~bzr-pqm/bzr/bzr.dev : revision 4734.4.11

502

wt.lock_read()

503

except (errors.NoWorkingTree, errors.NotLocalUrl):

504

raise errors.NoWorkingTree(location)

505

self.add_cleanup(wt.unlock)

506

revid = wt.last_revision()

505

507

try:

506

revid = wt.last_revision()

507

try:

508

revno_t = wt.branch.revision_id_to_dotted_revno(revid)

509

except errors.NoSuchRevision:

510

revno_t = ('???',)

511

revno = ".".join(str(n) for n in revno_t)

512

finally:

513

wt.unlock()

508

revno_t = wt.branch.revision_id_to_dotted_revno(revid)

509

except errors.NoSuchRevision:

510

revno_t = ('???',)

511

revno = ".".join(str(n) for n in revno_t)

514

512

else:

515

513

b = Branch.open_containing(location)[0]

516

514

b.lock_read()

517

try:

518

revno = b.revno()

519

finally:

520

b.unlock()

521

515

self.add_cleanup(b.unlock)

516

revno = b.revno()

517

self.cleanup_now()

522

518

self.outf.write(str(revno) + '\n')

523

519

524

520

546

542

wt = WorkingTree.open_containing(directory)[0]

547

543

b = wt.branch

548

544

wt.lock_read()

545

self.add_cleanup(wt.unlock)

549

546

except (errors.NoWorkingTree, errors.NotLocalUrl):

550

547

wt = None

551

548

b = Branch.open_containing(directory)[0]

552

549

b.lock_read()

553

try:

554

revision_ids = []

555

if revision is not None:

556

revision_ids.extend(rev.as_revision_id(b) for rev in revision)

557

if revision_info_list is not None:

558

for rev_str in revision_info_list:

559

rev_spec = RevisionSpec.from_string(rev_str)

560

revision_ids.append(rev_spec.as_revision_id(b))

561

# No arguments supplied, default to the last revision

562

if len(revision_ids) == 0:

563

if tree:

564

if wt is None:

565

raise errors.NoWorkingTree(directory)

566

revision_ids.append(wt.last_revision())

567

else:

568

revision_ids.append(b.last_revision())

569

570

revinfos = []

571

maxlen = 0

572

for revision_id in revision_ids:

573

try:

574

dotted_revno = b.revision_id_to_dotted_revno(revision_id)

575

revno = '.'.join(str(i) for i in dotted_revno)

576

except errors.NoSuchRevision:

577

revno = '???'

578

maxlen = max(maxlen, len(revno))

579

revinfos.append([revno, revision_id])

580

finally:

581

if wt is None:

582

b.unlock()

550

self.add_cleanup(b.unlock)

551

revision_ids = []

552

if revision is not None:

553

revision_ids.extend(rev.as_revision_id(b) for rev in revision)

554

if revision_info_list is not None:

555

for rev_str in revision_info_list:

556

rev_spec = RevisionSpec.from_string(rev_str)

557

revision_ids.append(rev_spec.as_revision_id(b))

558

# No arguments supplied, default to the last revision

559

if len(revision_ids) == 0:

560

if tree:

561

if wt is None:

562

raise errors.NoWorkingTree(directory)

563

revision_ids.append(wt.last_revision())

583

564

else:

584

wt.unlock()

585

565

revision_ids.append(b.last_revision())

566

567

revinfos = []

568

maxlen = 0

569

for revision_id in revision_ids:

570

try:

571

dotted_revno = b.revision_id_to_dotted_revno(revision_id)

572

revno = '.'.join(str(i) for i in dotted_revno)

573

except errors.NoSuchRevision:

574

revno = '???'

575

maxlen = max(maxlen, len(revno))

576

revinfos.append([revno, revision_id])

577

578

self.cleanup_now()

586

579

for ri in revinfos:

587

580

self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))

588

581

660

653

661

654

if base_tree:

662

655

base_tree.lock_read()

663

try:

664

tree, file_list = tree_files_for_add(file_list)

665

added, ignored = tree.smart_add(file_list, not

666

no_recurse, action=action, save=not dry_run)

667

finally:

668

if base_tree is not None:

669

base_tree.unlock()

656

self.add_cleanup(base_tree.unlock)

657

tree, file_list = tree_files_for_add(file_list)

658

added, ignored = tree.smart_add(file_list, not

659

no_recurse, action=action, save=not dry_run)

660

self.cleanup_now()

670

661

if len(ignored) > 0:

671

662

if verbose:

672

663

for glob in sorted(ignored.keys()):

736

727

revision = _get_one_revision('inventory', revision)

737

728

work_tree, file_list = tree_files(file_list)

738

729

work_tree.lock_read()

739

try:

740

if revision is not None:

741

tree = revision.as_tree(work_tree.branch)

742

743

extra_trees = [work_tree]

744

tree.lock_read()

745

else:

746

tree = work_tree

747

extra_trees = []

748

749

if file_list is not None:

750

file_ids = tree.paths2ids(file_list, trees=extra_trees,

751

require_versioned=True)

752

# find_ids_across_trees may include some paths that don't

753

# exist in 'tree'.

754

entries = sorted((tree.id2path(file_id), tree.inventory[file_id])

755

for file_id in file_ids if file_id in tree)

756

else:

757

entries = tree.inventory.entries()

758

finally:

759

tree.unlock()

760

if tree is not work_tree:

761

work_tree.unlock()

762

730

self.add_cleanup(work_tree.unlock)

731

if revision is not None:

732

tree = revision.as_tree(work_tree.branch)

733

734

extra_trees = [work_tree]

735

tree.lock_read()

736

self.add_cleanup(tree.unlock)

737

else:

738

tree = work_tree

739

extra_trees = []

740

741

if file_list is not None:

742

file_ids = tree.paths2ids(file_list, trees=extra_trees,

743

require_versioned=True)

744

# find_ids_across_trees may include some paths that don't

745

# exist in 'tree'.

746

entries = sorted((tree.id2path(file_id), tree.inventory[file_id])

747

for file_id in file_ids if file_id in tree)

748

else:

749

entries = tree.inventory.entries()

750

751

self.cleanup_now()

763

752

for path, entry in entries:

764

753

if kind and kind != entry.kind:

765

754

continue

811

800

raise errors.BzrCommandError("missing file argument")

812

801

tree, rel_names = tree_files(names_list, canonicalize=False)

813

802

tree.lock_tree_write()

814

try:

815

self._run(tree, names_list, rel_names, after)

816

finally:

817

tree.unlock()

803

self.add_cleanup(tree.unlock)

804

self._run(tree, names_list, rel_names, after)

818

805

819

806

def run_auto(self, names_list, after, dry_run):

820

807

if names_list is not None and len(names_list) > 1:

825

812

' --auto.')

826

813

work_tree, file_list = tree_files(names_list, default_branch='.')

827

814

work_tree.lock_tree_write()

828

try:

829

rename_map.RenameMap.guess_renames(work_tree, dry_run)

830

finally:

831

work_tree.unlock()

815

self.add_cleanup(work_tree.unlock)

816

rename_map.RenameMap.guess_renames(work_tree, dry_run)

832

817

833

818

def _run(self, tree, names_list, rel_names, after):

834

819

into_existing = osutils.isdir(names_list[-1])

1012

997

1013

998

if branch_from is not branch_to:

1014

999

branch_from.lock_read()

1015

try:

1016

if revision is not None:

1017

revision_id = revision.as_revision_id(branch_from)

1018

1019

branch_to.lock_write()

1020

try:

1021

if tree_to is not None:

1022

view_info = _get_view_info_for_change_reporter(tree_to)

1023

change_reporter = delta._ChangeReporter(

1024

unversioned_filter=tree_to.is_ignored,

1025

view_info=view_info)

1026

result = tree_to.pull(

1027

branch_from, overwrite, revision_id, change_reporter,

1028

possible_transports=possible_transports, local=local)

1029

else:

1030

result = branch_to.pull(

1031

branch_from, overwrite, revision_id, local=local)

1032

1033

result.report(self.outf)

1034

if verbose and result.old_revid != result.new_revid:

1035

log.show_branch_change(

1036

branch_to, self.outf, result.old_revno,

1037

result.old_revid)

1038

finally:

1039

branch_to.unlock()

1040

finally:

1041

if branch_from is not branch_to:

1042

branch_from.unlock()

1000

self.add_cleanup(branch_from.unlock)

1001

if revision is not None:

1002

revision_id = revision.as_revision_id(branch_from)

1003

1004

branch_to.lock_write()

1005

self.add_cleanup(branch_to.unlock)

1006

if tree_to is not None:

1007

view_info = _get_view_info_for_change_reporter(tree_to)

1008

change_reporter = delta._ChangeReporter(

1009

unversioned_filter=tree_to.is_ignored,

1010

view_info=view_info)

1011

result = tree_to.pull(

1012

branch_from, overwrite, revision_id, change_reporter,

1013

possible_transports=possible_transports, local=local)

1014

else:

1015

result = branch_to.pull(

1016

branch_from, overwrite, revision_id, local=local)

1017

1018

result.report(self.outf)

1019

if verbose and result.old_revid != result.new_revid:

1020

log.show_branch_change(

1021

branch_to, self.outf, result.old_revno,

1022

result.old_revid)

1043

1023

1044

1024

1045

1025

class cmd_push(Command):

1212

1192

from_location)

1213

1193

revision = _get_one_revision('branch', revision)

1214

1194

br_from.lock_read()

1195

self.add_cleanup(br_from.unlock)

1196

if revision is not None:

1197

revision_id = revision.as_revision_id(br_from)

1198

else:

1199

# FIXME - wt.last_revision, fallback to branch, fall back to

1200

# None or perhaps NULL_REVISION to mean copy nothing

1201

# RBC 20060209

1202

revision_id = br_from.last_revision()

1203

if to_location is None:

1204

to_location = urlutils.derive_to_location(from_location)

1205

to_transport = transport.get_transport(to_location)

1215

1206

try:

1216

if revision is not None:

1217

revision_id = revision.as_revision_id(br_from)

1207

to_transport.mkdir('.')

1208

except errors.FileExists:

1209

if not use_existing_dir:

1210

raise errors.BzrCommandError('Target directory "%s" '

1211

'already exists.' % to_location)

1218

1212

else:

1219

# FIXME - wt.last_revision, fallback to branch, fall back to

1220

# None or perhaps NULL_REVISION to mean copy nothing

1221

# RBC 20060209

1222

revision_id = br_from.last_revision()

1223

if to_location is None:

1224

to_location = urlutils.derive_to_location(from_location)

1225

to_transport = transport.get_transport(to_location)

1226

try:

1227

to_transport.mkdir('.')

1228

except errors.FileExists:

1229

if not use_existing_dir:

1230

raise errors.BzrCommandError('Target directory "%s" '

1231

'already exists.' % to_location)

1213

try:

1214

bzrdir.BzrDir.open_from_transport(to_transport)

1215

except errors.NotBranchError:

1216

pass

1232

1217

else:

1233

try:

1234

bzrdir.BzrDir.open_from_transport(to_transport)

1235

except errors.NotBranchError:

1236

pass

1237

else:

1238

raise errors.AlreadyBranchError(to_location)

1239

except errors.NoSuchFile:

1240

raise errors.BzrCommandError('Parent of "%s" does not exist.'

1241

% to_location)

1242

try:

1243

# preserve whatever source format we have.

1244

dir = br_from.bzrdir.sprout(to_transport.base, revision_id,

1245

possible_transports=[to_transport],

1246

accelerator_tree=accelerator_tree,

1247

hardlink=hardlink, stacked=stacked,

1248

force_new_repo=standalone,

1249

create_tree_if_local=not no_tree,

1250

source_branch=br_from)

1251

branch = dir.open_branch()

1252

except errors.NoSuchRevision:

1253

to_transport.delete_tree('.')

1254

msg = "The branch %s has no revision %s." % (from_location,

1255

revision)

1256

raise errors.BzrCommandError(msg)

1257

_merge_tags_if_possible(br_from, branch)

1258

# If the source branch is stacked, the new branch may

1259

# be stacked whether we asked for that explicitly or not.

1260

# We therefore need a try/except here and not just 'if stacked:'

1261

try:

1262

note('Created new stacked branch referring to %s.' %

1263

branch.get_stacked_on_url())

1264

except (errors.NotStacked, errors.UnstackableBranchFormat,

1265

errors.UnstackableRepositoryFormat), e:

1266

note('Branched %d revision(s).' % branch.revno())

1267

if switch:

1268

# Switch to the new branch

1269

wt, _ = WorkingTree.open_containing('.')

1270

_mod_switch.switch(wt.bzrdir, branch)

1271

note('Switched to branch: %s',

1272

urlutils.unescape_for_display(branch.base, 'utf-8'))

1273

finally:

1274

br_from.unlock()

1218

raise errors.AlreadyBranchError(to_location)

1219

except errors.NoSuchFile:

1220

raise errors.BzrCommandError('Parent of "%s" does not exist.'

1221

% to_location)

1222

try:

1223

# preserve whatever source format we have.

1224

dir = br_from.bzrdir.sprout(to_transport.base, revision_id,

1225

possible_transports=[to_transport],

1226

accelerator_tree=accelerator_tree,

1227

hardlink=hardlink, stacked=stacked,

1228

force_new_repo=standalone,

1229

create_tree_if_local=not no_tree,

1230

source_branch=br_from)

1231

branch = dir.open_branch()

1232

except errors.NoSuchRevision:

1233

to_transport.delete_tree('.')

1234

msg = "The branch %s has no revision %s." % (from_location,

1235

revision)

1236

raise errors.BzrCommandError(msg)

1237

_merge_tags_if_possible(br_from, branch)

1238

# If the source branch is stacked, the new branch may

1239

# be stacked whether we asked for that explicitly or not.

1240

# We therefore need a try/except here and not just 'if stacked:'

1241

try:

1242

note('Created new stacked branch referring to %s.' %

1243

branch.get_stacked_on_url())

1244

except (errors.NotStacked, errors.UnstackableBranchFormat,

1245

errors.UnstackableRepositoryFormat), e:

1246

note('Branched %d revision(s).' % branch.revno())

1247

if switch:

1248

# Switch to the new branch

1249

wt, _ = WorkingTree.open_containing('.')

1250

_mod_switch.switch(wt.bzrdir, branch)

1251

note('Switched to branch: %s',

1252

urlutils.unescape_for_display(branch.base, 'utf-8'))

1275

1253

1276

1254

1277

1255

class cmd_checkout(Command):

1356

1334

def run(self, dir=u'.'):

1357

1335

tree = WorkingTree.open_containing(dir)[0]

1358

1336

tree.lock_read()

1359

try:

1360

new_inv = tree.inventory

1361

old_tree = tree.basis_tree()

1362

old_tree.lock_read()

1363

try:

1364

old_inv = old_tree.inventory

1365

renames = []

1366

iterator = tree.iter_changes(old_tree, include_unchanged=True)

1367

for f, paths, c, v, p, n, k, e in iterator:

1368

if paths[0] == paths[1]:

1369

continue

1370

if None in (paths):

1371

continue

1372

renames.append(paths)

1373

renames.sort()

1374

for old_name, new_name in renames:

1375

self.outf.write("%s => %s\n" % (old_name, new_name))

1376

finally:

1377

old_tree.unlock()

1378

finally:

1379

tree.unlock()

1337

self.add_cleanup(tree.unlock)

1338

new_inv = tree.inventory

1339

old_tree = tree.basis_tree()

1340

old_tree.lock_read()

1341

self.add_cleanup(old_tree.unlock)

1342

old_inv = old_tree.inventory

1343

renames = []

1344

iterator = tree.iter_changes(old_tree, include_unchanged=True)

1345

for f, paths, c, v, p, n, k, e in iterator:

1346

if paths[0] == paths[1]:

1347

continue

1348

if None in (paths):

1349

continue

1350

renames.append(paths)

1351

renames.sort()

1352

for old_name, new_name in renames:

1353

self.outf.write("%s => %s\n" % (old_name, new_name))

1380

1354

1381

1355

1382

1356

class cmd_update(Command):

1413

1387

else:

1414

1388

tree.lock_tree_write()

1415

1389

branch_location = tree.branch.base

1390

self.add_cleanup(tree.unlock)

1416

1391

# get rid of the final '/' and be ready for display

1417

1392

branch_location = urlutils.unescape_for_display(branch_location[:-1],

1418

1393

self.outf.encoding)

1394

existing_pending_merges = tree.get_parent_ids()[1:]

1395

if master is None:

1396

old_tip = None

1397

else:

1398

# may need to fetch data into a heavyweight checkout

1399

# XXX: this may take some time, maybe we should display a

1400

# message

1401

old_tip = branch.update(possible_transports)

1402

if revision is not None:

1403

revision_id = revision[0].as_revision_id(branch)

1404

else:

1405

revision_id = branch.last_revision()

1406

if revision_id == _mod_revision.ensure_null(tree.last_revision()):

1407

revno = branch.revision_id_to_revno(revision_id)

1408

note("Tree is up to date at revision %d of branch %s" %

1409

(revno, branch_location))

1410

return 0

1411

view_info = _get_view_info_for_change_reporter(tree)

1412

change_reporter = delta._ChangeReporter(

1413

unversioned_filter=tree.is_ignored,

1414

view_info=view_info)

1419

1415

try:

1420

existing_pending_merges = tree.get_parent_ids()[1:]

1421

if master is None:

1422

old_tip = None

1423

else:

1424

# may need to fetch data into a heavyweight checkout

1425

# XXX: this may take some time, maybe we should display a

1426

# message

1427

old_tip = branch.update(possible_transports)

1428

if revision is not None:

1429

revision_id = revision[0].as_revision_id(branch)

1430

else:

1431

revision_id = branch.last_revision()

1432

if revision_id == _mod_revision.ensure_null(tree.last_revision()):

1433

revno = branch.revision_id_to_revno(revision_id)

1434

note("Tree is up to date at revision %d of branch %s" %

1435

(revno, branch_location))

1436

return 0

1437

view_info = _get_view_info_for_change_reporter(tree)

1438

change_reporter = delta._ChangeReporter(

1439

unversioned_filter=tree.is_ignored,

1440

view_info=view_info)

1441

try:

1442

conflicts = tree.update(

1443

change_reporter,

1444

possible_transports=possible_transports,

1445

revision=revision_id,

1446

old_tip=old_tip)

1447

except errors.NoSuchRevision, e:

1448

raise errors.BzrCommandError(

1449

"branch has no revision %s\n"

1450

"bzr update --revision only works"

1451

" for a revision in the branch history"

1452

% (e.revision))

1453

revno = tree.branch.revision_id_to_revno(

1454

_mod_revision.ensure_null(tree.last_revision()))

1455

note('Updated to revision %d of branch %s' %

1456

(revno, branch_location))

1457

if tree.get_parent_ids()[1:] != existing_pending_merges:

1458

note('Your local commits will now show as pending merges with '

1459

"'bzr status', and can be committed with 'bzr commit'.")

1460

if conflicts != 0:

1461

return 1

1462

else:

1463

return 0

1464

finally:

1465

tree.unlock()

1416

conflicts = tree.update(

1417

change_reporter,

1418

possible_transports=possible_transports,

1419

revision=revision_id,

1420

old_tip=old_tip)

1421

except errors.NoSuchRevision, e:

1422

raise errors.BzrCommandError(

1423

"branch has no revision %s\n"

1424

"bzr update --revision only works"

1425

" for a revision in the branch history"

1426

% (e.revision))

1427

revno = tree.branch.revision_id_to_revno(

1428

_mod_revision.ensure_null(tree.last_revision()))

1429

note('Updated to revision %d of branch %s' %

1430

(revno, branch_location))

1431

if tree.get_parent_ids()[1:] != existing_pending_merges:

1432

note('Your local commits will now show as pending merges with '

1433

"'bzr status', and can be committed with 'bzr commit'.")

1434

if conflicts != 0:

1435

return 1

1436

else:

1437

return 0

1466

1438

1467

1439

1468

1440

class cmd_info(Command):

1539

1511

file_list = [f for f in file_list]

1540

1512

1541

1513

tree.lock_write()

1542

try:

1543

# Heuristics should probably all move into tree.remove_smart or

1544

# some such?

1545

if new:

1546

added = tree.changes_from(tree.basis_tree(),

1547

specific_files=file_list).added

1548

file_list = sorted([f[0] for f in added], reverse=True)

1549

if len(file_list) == 0:

1550

raise errors.BzrCommandError('No matching files.')

1551

elif file_list is None:

1552

# missing files show up in iter_changes(basis) as

1553

# versioned-with-no-kind.

1554

missing = []

1555

for change in tree.iter_changes(tree.basis_tree()):

1556

# Find paths in the working tree that have no kind:

1557

if change[1][1] is not None and change[6][1] is None:

1558

missing.append(change[1][1])

1559

file_list = sorted(missing, reverse=True)

1560

file_deletion_strategy = 'keep'

1561

tree.remove(file_list, verbose=verbose, to_file=self.outf,

1562

keep_files=file_deletion_strategy=='keep',

1563

force=file_deletion_strategy=='force')

1564

finally:

1565

tree.unlock()

1514

self.add_cleanup(tree.unlock)

1515

# Heuristics should probably all move into tree.remove_smart or

1516

# some such?

1517

if new:

1518

added = tree.changes_from(tree.basis_tree(),

1519

specific_files=file_list).added

1520

file_list = sorted([f[0] for f in added], reverse=True)

1521

if len(file_list) == 0:

1522

raise errors.BzrCommandError('No matching files.')

1523

elif file_list is None:

1524

# missing files show up in iter_changes(basis) as

1525

# versioned-with-no-kind.

1526

missing = []

1527

for change in tree.iter_changes(tree.basis_tree()):

1528

# Find paths in the working tree that have no kind:

1529

if change[1][1] is not None and change[6][1] is None:

1530

missing.append(change[1][1])

1531

file_list = sorted(missing, reverse=True)

1532

file_deletion_strategy = 'keep'

1533

tree.remove(file_list, verbose=verbose, to_file=self.outf,

1534

keep_files=file_deletion_strategy=='keep',

1535

force=file_deletion_strategy=='force')

1566

1536

1567

1537

1568

1538

class cmd_file_id(Command):

1994

1964

def run(self, show_ids=False):

1995

1965

tree = WorkingTree.open_containing(u'.')[0]

1996

1966

tree.lock_read()

1997

try:

1998

old = tree.basis_tree()

1999

old.lock_read()

2000

try:

2001

for path, ie in old.inventory.iter_entries():

2002

if not tree.has_id(ie.file_id):

2003

self.outf.write(path)

2004

if show_ids:

2005

self.outf.write(' ')

2006

self.outf.write(ie.file_id)

2007

self.outf.write('\n')

2008

finally:

2009

old.unlock()

2010

finally:

2011

tree.unlock()

1967

self.add_cleanup(tree.unlock)

1968

old = tree.basis_tree()

1969

old.lock_read()

1970

self.add_cleanup(old.unlock)

1971

for path, ie in old.inventory.iter_entries():

1972

if not tree.has_id(ie.file_id):

1973

self.outf.write(path)

1974

if show_ids:

1975

self.outf.write(' ')

1976

self.outf.write(ie.file_id)

1977

self.outf.write('\n')

2012

1978

2013

1979

2014

1980

class cmd_modified(Command):

2050

2016

def run(self, null=False):

2051

2017

wt = WorkingTree.open_containing(u'.')[0]

2052

2018

wt.lock_read()

2053

try:

2054

basis = wt.basis_tree()

2055

basis.lock_read()

2056

try:

2057

basis_inv = basis.inventory

2058

inv = wt.inventory

2059

for file_id in inv:

2060

if file_id in basis_inv:

2061

continue

2062

if inv.is_root(file_id) and len(basis_inv) == 0:

2063

continue

2064

path = inv.id2path(file_id)

2065

if not os.access(osutils.abspath(path), os.F_OK):

2066

continue

2067

if null:

2068

self.outf.write(path + '\0')

2069

else:

2070

self.outf.write(osutils.quotefn(path) + '\n')

2071

finally:

2072

basis.unlock()

2073

finally:

2074

wt.unlock()

2019

self.add_cleanup(wt.unlock)

2020

basis = wt.basis_tree()

2021

basis.lock_read()

2022

self.add_cleanup(basis.unlock)

2023

basis_inv = basis.inventory

2024

inv = wt.inventory

2025

for file_id in inv:

2026

if file_id in basis_inv:

2027

continue

2028

if inv.is_root(file_id) and len(basis_inv) == 0:

2029

continue

2030

path = inv.id2path(file_id)

2031

if not os.access(osutils.abspath(path), os.F_OK):

2032

continue

2033

if null:

2034

self.outf.write(path + '\0')

2035

else:

2036

self.outf.write(osutils.quotefn(path) + '\n')

2075

2037

2076

2038

2077

2039

class cmd_root(Command):

2335

2297

2336

2298

file_ids = []

2337

2299

filter_by_dir = False

2338

b = None

2339

try:

2340

if file_list:

2341

# find the file ids to log and check for directory filtering

2342

b, file_info_list, rev1, rev2 = _get_info_for_log_files(

2343

revision, file_list)

2344

for relpath, file_id, kind in file_info_list:

2345

if file_id is None:

2346

raise errors.BzrCommandError(

2347

"Path unknown at end or start of revision range: %s" %

2348

relpath)

2349

# If the relpath is the top of the tree, we log everything

2350

if relpath == '':

2351

file_ids = []

2352

break

2353

else:

2354

file_ids.append(file_id)

2355

filter_by_dir = filter_by_dir or (

2356

kind in ['directory', 'tree-reference'])

2357

else:

2358

# log everything

2359

# FIXME ? log the current subdir only RBC 20060203

2360

if revision is not None \

2361

and len(revision) > 0 and revision[0].get_branch():

2362

location = revision[0].get_branch()

2300

if file_list:

2301

# find the file ids to log and check for directory filtering

2302

b, file_info_list, rev1, rev2 = _get_info_for_log_files(

2303

revision, file_list)

2304

self.add_cleanup(b.unlock)

2305

for relpath, file_id, kind in file_info_list:

2306

if file_id is None:

2307

raise errors.BzrCommandError(

2308

"Path unknown at end or start of revision range: %s" %

2309

relpath)

2310

# If the relpath is the top of the tree, we log everything

2311

if relpath == '':

2312

file_ids = []

2313

break

2363

2314

else:

2364

location = '.'

2365

dir, relpath = bzrdir.BzrDir.open_containing(location)

2366

b = dir.open_branch()

2367

b.lock_read()

2368

rev1, rev2 = _get_revision_range(revision, b, self.name())

2369

2370

# Decide on the type of delta & diff filtering to use

2371

# TODO: add an --all-files option to make this configurable & consistent

2372

if not verbose:

2373

delta_type = None

2374

else:

2375

delta_type = 'full'

2376

if not show_diff:

2377

diff_type = None

2378

elif file_ids:

2379

diff_type = 'partial'

2380

else:

2381

diff_type = 'full'

2382

2383

# Build the log formatter

2384

if log_format is None:

2385

log_format = log.log_formatter_registry.get_default(b)

2386

# Make a non-encoding output to include the diffs - bug 328007

2387

unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')

2388

lf = log_format(show_ids=show_ids, to_file=self.outf,

2389

to_exact_file=unencoded_output,

2390

show_timezone=timezone,

2391

delta_format=get_verbosity_level(),

2392

levels=levels,

2393

show_advice=levels is None)

2394

2395

# Choose the algorithm for doing the logging. It's annoying

2396

# having multiple code paths like this but necessary until

2397

# the underlying repository format is faster at generating

2398

# deltas or can provide everything we need from the indices.

2399

# The default algorithm - match-using-deltas - works for

2400

# multiple files and directories and is faster for small

2401

# amounts of history (200 revisions say). However, it's too

2402

# slow for logging a single file in a repository with deep

2403

# history, i.e. > 10K revisions. In the spirit of "do no

2404

# evil when adding features", we continue to use the

2405

# original algorithm - per-file-graph - for the "single

2406

# file that isn't a directory without showing a delta" case.

2407

partial_history = revision and b.repository._format.supports_chks

2408

match_using_deltas = (len(file_ids) != 1 or filter_by_dir

2409

or delta_type or partial_history)

2410

2411

# Build the LogRequest and execute it

2412

if len(file_ids) == 0:

2413

file_ids = None

2414

rqst = make_log_request_dict(

2415

direction=direction, specific_fileids=file_ids,

2416

start_revision=rev1, end_revision=rev2, limit=limit,

2417

message_search=message, delta_type=delta_type,

2418

diff_type=diff_type, _match_using_deltas=match_using_deltas)

2419

Logger(b, rqst).show(lf)

2420

finally:

2421

if b is not None:

2422

b.unlock()

2315

file_ids.append(file_id)

2316

filter_by_dir = filter_by_dir or (

2317

kind in ['directory', 'tree-reference'])

2318

else:

2319

# log everything

2320

# FIXME ? log the current subdir only RBC 20060203

2321

if revision is not None \

2322

and len(revision) > 0 and revision[0].get_branch():

2323

location = revision[0].get_branch()

2324

else:

2325

location = '.'

2326

dir, relpath = bzrdir.BzrDir.open_containing(location)

2327

b = dir.open_branch()

2328

b.lock_read()

2329

self.add_cleanup(b.unlock)

2330

rev1, rev2 = _get_revision_range(revision, b, self.name())

2331

2332

# Decide on the type of delta & diff filtering to use

2333

# TODO: add an --all-files option to make this configurable & consistent

2334

if not verbose:

2335

delta_type = None

2336

else:

2337

delta_type = 'full'

2338

if not show_diff:

2339

diff_type = None

2340

elif file_ids:

2341

diff_type = 'partial'

2342

else:

2343

diff_type = 'full'

2344

2345

# Build the log formatter

2346

if log_format is None:

2347

log_format = log.log_formatter_registry.get_default(b)

2348

# Make a non-encoding output to include the diffs - bug 328007

2349

unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')

2350

lf = log_format(show_ids=show_ids, to_file=self.outf,

2351

to_exact_file=unencoded_output,

2352

show_timezone=timezone,

2353

delta_format=get_verbosity_level(),

2354

levels=levels,

2355

show_advice=levels is None)

2356

2357

# Choose the algorithm for doing the logging. It's annoying

2358

# having multiple code paths like this but necessary until

2359

# the underlying repository format is faster at generating

2360

# deltas or can provide everything we need from the indices.

2361

# The default algorithm - match-using-deltas - works for

2362

# multiple files and directories and is faster for small

2363

# amounts of history (200 revisions say). However, it's too

2364

# slow for logging a single file in a repository with deep

2365

# history, i.e. > 10K revisions. In the spirit of "do no

2366

# evil when adding features", we continue to use the

2367

# original algorithm - per-file-graph - for the "single

2368

# file that isn't a directory without showing a delta" case.

2369

partial_history = revision and b.repository._format.supports_chks

2370

match_using_deltas = (len(file_ids) != 1 or filter_by_dir

2371

or delta_type or partial_history)

2372

2373

# Build the LogRequest and execute it

2374

if len(file_ids) == 0:

2375

file_ids = None

2376

rqst = make_log_request_dict(

2377

direction=direction, specific_fileids=file_ids,

2378

start_revision=rev1, end_revision=rev2, limit=limit,

2379

message_search=message, delta_type=delta_type,

2380

diff_type=diff_type, _match_using_deltas=match_using_deltas)

2381

Logger(b, rqst).show(lf)

2423

2382

2424

2383

2425

2384

def _get_revision_range(revisionspec_list, branch, command_name):

2492

2451

file_id = tree.path2id(relpath)

2493

2452

b = tree.branch

2494

2453

b.lock_read()

2495

try:

2496

touching_revs = log.find_touching_revisions(b, file_id)

2497

for revno, revision_id, what in touching_revs:

2498

self.outf.write("%6d %s\n" % (revno, what))

2499

finally:

2500

b.unlock()

2454

self.add_cleanup(b.unlock)

2455

touching_revs = log.find_touching_revisions(b, file_id)

2456

for revno, revision_id, what in touching_revs:

2457

self.outf.write("%6d %s\n" % (revno, what))

2501

2458

2502

2459

2503

2460

class cmd_ls(Command):

2570

2527

note("Ignoring files outside view. View is %s" % view_str)

2571

2528

2572

2529

tree.lock_read()

2573

try:

2574

for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,

2575

from_dir=relpath, recursive=recursive):

2576

# Apply additional masking

2577

if not all and not selection[fc]:

2578

continue

2579

if kind is not None and fkind != kind:

2580

continue

2581

if apply_view:

2582

try:

2583

if relpath:

2584

fullpath = osutils.pathjoin(relpath, fp)

2585

else:

2586

fullpath = fp

2587

views.check_path_in_view(tree, fullpath)

2588

except errors.FileOutsideView:

2589

continue

2530

self.add_cleanup(tree.unlock)

2531

for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,

2532

from_dir=relpath, recursive=recursive):

2533

# Apply additional masking

2534

if not all and not selection[fc]:

2535

continue

2536

if kind is not None and fkind != kind:

2537

continue

2538

if apply_view:

2539

try:

2540

if relpath:

2541

fullpath = osutils.pathjoin(relpath, fp)

2542

else:

2543

fullpath = fp

2544

views.check_path_in_view(tree, fullpath)

2545

except errors.FileOutsideView:

2546

continue

2590

2547

2591

# Output the entry

2592

if prefix:

2593

fp = osutils.pathjoin(prefix, fp)

2594

kindch = entry.kind_character()

2595

outstring = fp + kindch

2596

ui.ui_factory.clear_term()

2597

if verbose:

2598

outstring = '%-8s %s' % (fc, outstring)

2599

if show_ids and fid is not None:

2600

outstring = "%-50s %s" % (outstring, fid)

2548

# Output the entry

2549

if prefix:

2550

fp = osutils.pathjoin(prefix, fp)

2551

kindch = entry.kind_character()

2552

outstring = fp + kindch

2553

ui.ui_factory.clear_term()

2554

if verbose:

2555

outstring = '%-8s %s' % (fc, outstring)

2556

if show_ids and fid is not None:

2557

outstring = "%-50s %s" % (outstring, fid)

2558

self.outf.write(outstring + '\n')

2559

elif null:

2560

self.outf.write(fp + '\0')

2561

if show_ids:

2562

if fid is not None:

2563

self.outf.write(fid)

2564

self.outf.write('\0')

2565

self.outf.flush()

2566

else:

2567

if show_ids:

2568

if fid is not None:

2569

my_id = fid

2570

else:

2571

my_id = ''

2572

self.outf.write('%-50s %s\n' % (outstring, my_id))

2573

else:

2601

2574

self.outf.write(outstring + '\n')

2602

elif null:

2603

self.outf.write(fp + '\0')

2604

if show_ids:

2605

if fid is not None:

2606

self.outf.write(fid)

2607

self.outf.write('\0')

2608

self.outf.flush()

2609

else:

2610

if show_ids:

2611

if fid is not None:

2612

my_id = fid

2613

else:

2614

my_id = ''

2615

self.outf.write('%-50s %s\n' % (outstring, my_id))

2616

else:

2617

self.outf.write(outstring + '\n')

2618

finally:

2619

tree.unlock()

2620

2575

2621

2576

2622

2577

class cmd_unknowns(Command):

2734

2689

def run(self):

2735

2690

tree = WorkingTree.open_containing(u'.')[0]

2736

2691

tree.lock_read()

2737

try:

2738

for path, file_class, kind, file_id, entry in tree.list_files():

2739

if file_class != 'I':

2740

continue

2741

## XXX: Slightly inefficient since this was already calculated

2742

pat = tree.is_ignored(path)

2743

self.outf.write('%-50s %s\n' % (path, pat))

2744

finally:

2745

tree.unlock()

2692

self.add_cleanup(tree.unlock)

2693

for path, file_class, kind, file_id, entry in tree.list_files():

2694

if file_class != 'I':

2695

continue

2696

## XXX: Slightly inefficient since this was already calculated

2697

pat = tree.is_ignored(path)

2698

self.outf.write('%-50s %s\n' % (path, pat))

2746

2699

2747

2700

2748

2701

class cmd_lookup_revision(Command):

2851

2804

tree, branch, relpath = \

2852

2805

bzrdir.BzrDir.open_containing_tree_or_branch(filename)

2853

2806

branch.lock_read()

2854

try:

2855

return self._run(tree, branch, relpath, filename, revision,

2856

name_from_revision, filters)

2857

finally:

2858

branch.unlock()

2807

self.add_cleanup(branch.unlock)

2808

return self._run(tree, branch, relpath, filename, revision,

2809

name_from_revision, filters)

2859

2810

2860

2811

def _run(self, tree, b, relpath, filename, revision, name_from_revision,

2861

2812

filtered):

3570

3521

verbose = not is_quiet()

3571

3522

# TODO: should possibly lock the history file...

3572

3523

benchfile = open(".perf_history", "at", buffering=1)

3524

self.add_cleanup(benchfile.close)

3573

3525

else:

3574

3526

test_suite_factory = None

3575

3527

benchfile = None

3576

try:

3577

selftest_kwargs = {"verbose": verbose,

3578

"pattern": pattern,

3579

"stop_on_failure": one,

3580

"transport": transport,

3581

"test_suite_factory": test_suite_factory,

3582

"lsprof_timed": lsprof_timed,

3583

"lsprof_tests": lsprof_tests,

3584

"bench_history": benchfile,

3585

"matching_tests_first": first,

3586

"list_only": list_only,

3587

"random_seed": randomize,

3588

"exclude_pattern": exclude,

3589

"strict": strict,

3590

"load_list": load_list,

3591

"debug_flags": debugflag,

3592

"starting_with": starting_with

3593

}

3594

selftest_kwargs.update(self.additional_selftest_args)

3595

result = selftest(**selftest_kwargs)

3596

finally:

3597

if benchfile is not None:

3598

benchfile.close()

3528

selftest_kwargs = {"verbose": verbose,

3529

"pattern": pattern,

3530

"stop_on_failure": one,

3531

"transport": transport,

3532

"test_suite_factory": test_suite_factory,

3533

"lsprof_timed": lsprof_timed,

3534

"lsprof_tests": lsprof_tests,

3535

"bench_history": benchfile,

3536

"matching_tests_first": first,

3537

"list_only": list_only,

3538

"random_seed": randomize,

3539

"exclude_pattern": exclude,

3540

"strict": strict,

3541

"load_list": load_list,

3542

"debug_flags": debugflag,

3543

"starting_with": starting_with

3544

}

3545

selftest_kwargs.update(self.additional_selftest_args)

3546

result = selftest(**selftest_kwargs)

3599

3547

return int(not result)

3600

3548

3601

3549

3640

3588

branch1 = Branch.open_containing(branch)[0]

3641

3589

branch2 = Branch.open_containing(other)[0]

3642

3590

branch1.lock_read()

3643

try:

3644

branch2.lock_read()

3645

try:

3646

last1 = ensure_null(branch1.last_revision())

3647

last2 = ensure_null(branch2.last_revision())

3648

3649

graph = branch1.repository.get_graph(branch2.repository)

3650

base_rev_id = graph.find_unique_lca(last1, last2)

3651

3652

print 'merge base is revision %s' % base_rev_id

3653

finally:

3654

branch2.unlock()

3655

finally:

3656

branch1.unlock()

3591

self.add_cleanup(branch1.unlock)

3592

branch2.lock_read()

3593

self.add_cleanup(branch2.unlock)

3594

last1 = ensure_null(branch1.last_revision())

3595

last2 = ensure_null(branch2.last_revision())

3596

3597

graph = branch1.repository.get_graph(branch2.repository)

3598

base_rev_id = graph.find_unique_lca(last1, last2)

3599

3600

print 'merge base is revision %s' % base_rev_id

3657

3601

3658

3602

3659

3603

class cmd_merge(Command):

3776

3720

view_info = _get_view_info_for_change_reporter(tree)

3777

3721

change_reporter = delta._ChangeReporter(

3778

3722

unversioned_filter=tree.is_ignored, view_info=view_info)

3779

cleanups = []

3780

try:

3781

pb = ui.ui_factory.nested_progress_bar()

3782

cleanups.append(pb.finished)

3783

tree.lock_write()

3784

cleanups.append(tree.unlock)

3785

if location is not None:

3786

try:

3787

mergeable = bundle.read_mergeable_from_url(location,

3788

possible_transports=possible_transports)

3789

except errors.NotABundle:

3790

mergeable = None

3791

else:

3792

if uncommitted:

3793

raise errors.BzrCommandError('Cannot use --uncommitted'

3794

' with bundles or merge directives.')

3795

3796

if revision is not None:

3797

raise errors.BzrCommandError(

3798

'Cannot use -r with merge directives or bundles')

3799

merger, verified = _mod_merge.Merger.from_mergeable(tree,

3800

mergeable, pb)

3801

3802

if merger is None and uncommitted:

3803

if revision is not None and len(revision) > 0:

3804

raise errors.BzrCommandError('Cannot use --uncommitted and'

3805

' --revision at the same time.')

3806

merger = self.get_merger_from_uncommitted(tree, location, pb,

3807

cleanups)

3808

allow_pending = False

3809

3810

if merger is None:

3811

merger, allow_pending = self._get_merger_from_branch(tree,

3812

location, revision, remember, possible_transports, pb)

3813

3814

merger.merge_type = merge_type

3815

merger.reprocess = reprocess

3816

merger.show_base = show_base

3817

self.sanity_check_merger(merger)

3818

if (merger.base_rev_id == merger.other_rev_id and

3819

merger.other_rev_id is not None):

3820

note('Nothing to do.')

3723

pb = ui.ui_factory.nested_progress_bar()

3724

self.add_cleanup(pb.finished)

3725

tree.lock_write()

3726

self.add_cleanup(tree.unlock)

3727

if location is not None:

3728

try:

3729

mergeable = bundle.read_mergeable_from_url(location,

3730

possible_transports=possible_transports)

3731

except errors.NotABundle:

3732

mergeable = None

3733

else:

3734

if uncommitted:

3735

raise errors.BzrCommandError('Cannot use --uncommitted'

3736

' with bundles or merge directives.')

3737

3738

if revision is not None:

3739

raise errors.BzrCommandError(

3740

'Cannot use -r with merge directives or bundles')

3741

merger, verified = _mod_merge.Merger.from_mergeable(tree,

3742

mergeable, pb)

3743

3744

if merger is None and uncommitted:

3745

if revision is not None and len(revision) > 0:

3746

raise errors.BzrCommandError('Cannot use --uncommitted and'

3747

' --revision at the same time.')

3748

merger = self.get_merger_from_uncommitted(tree, location, pb)

3749

allow_pending = False

3750

3751

if merger is None:

3752

merger, allow_pending = self._get_merger_from_branch(tree,

3753

location, revision, remember, possible_transports, pb)

3754

3755

merger.merge_type = merge_type

3756

merger.reprocess = reprocess

3757

merger.show_base = show_base

3758

self.sanity_check_merger(merger)

3759

if (merger.base_rev_id == merger.other_rev_id and

3760

merger.other_rev_id is not None):

3761

note('Nothing to do.')

3762

return 0

3763

if pull:

3764

if merger.interesting_files is not None:

3765

raise errors.BzrCommandError('Cannot pull individual files')

3766

if (merger.base_rev_id == tree.last_revision()):

3767

result = tree.pull(merger.other_branch, False,

3768

merger.other_rev_id)

3769

result.report(self.outf)

3821

3770

return 0

3822

if pull:

3823

if merger.interesting_files is not None:

3824

raise errors.BzrCommandError('Cannot pull individual files')

3825

if (merger.base_rev_id == tree.last_revision()):

3826

result = tree.pull(merger.other_branch, False,

3827

merger.other_rev_id)

3828

result.report(self.outf)

3829

return 0

3830

if merger.this_basis is None:

3831

raise errors.BzrCommandError(

3832

"This branch has no commits."

3833

" (perhaps you would prefer 'bzr pull')")

3834

if preview:

3835

return self._do_preview(merger, cleanups)

3836

elif interactive:

3837

return self._do_interactive(merger, cleanups)

3838

else:

3839

return self._do_merge(merger, change_reporter, allow_pending,

3840

verified)

3841

finally:

3842

for cleanup in reversed(cleanups):

3843

cleanup()

3771

if merger.this_basis is None:

3772

raise errors.BzrCommandError(

3773

"This branch has no commits."

3774

" (perhaps you would prefer 'bzr pull')")

3775

if preview:

3776

return self._do_preview(merger)

3777

elif interactive:

3778

return self._do_interactive(merger)

3779

else:

3780

return self._do_merge(merger, change_reporter, allow_pending,

3781

verified)

3844

3782

3845

def _get_preview(self, merger, cleanups):

3783

def _get_preview(self, merger):

3846

3784

tree_merger = merger.make_merger()

3847

3785

tt = tree_merger.make_preview_transform()

3848

cleanups.append(tt.finalize)

3786

self.add_cleanup(tt.finalize)

3849

3787

result_tree = tt.get_preview_tree()

3850

3788

return result_tree

3851

3789

3852

def _do_preview(self, merger, cleanups):

3790

def _do_preview(self, merger):

3853

3791

from bzrlib.diff import show_diff_trees

3854

result_tree = self._get_preview(merger, cleanups)

3792

result_tree = self._get_preview(merger)

3855

3793

show_diff_trees(merger.this_tree, result_tree, self.outf,

3856

3794

old_label='', new_label='')

3857

3795

3867

3805

else:

3868

3806

return 0

3869

3807

3870

def _do_interactive(self, merger, cleanups):

3808

def _do_interactive(self, merger):

3871

3809

"""Perform an interactive merge.

3872

3810

3873

3811

This works by generating a preview tree of the merge, then using

3875

3813

and the preview tree.

3876

3814

"""

3877

3815

from bzrlib import shelf_ui

3878

result_tree = self._get_preview(merger, cleanups)

3816

result_tree = self._get_preview(merger)

3879

3817

writer = bzrlib.option.diff_writer_registry.get()

3880

3818

shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,

3881

3819

reporter=shelf_ui.ApplyReporter(),

3949

3887

allow_pending = True

3950

3888

return merger, allow_pending

3951

3889

3952

def get_merger_from_uncommitted(self, tree, location, pb, cleanups):

3890

def get_merger_from_uncommitted(self, tree, location, pb):

3953

3891

"""Get a merger for uncommitted changes.

3954

3892

3955

3893

:param tree: The tree the merger should apply to.

3956

3894

:param location: The location containing uncommitted changes.

3957

3895

:param pb: The progress bar to use for showing progress.

3958

:param cleanups: A list of operations to perform to clean up the

3959

temporary directories, unfinalized objects, etc.

3960

3896

"""

3961

3897

location = self._select_branch_location(tree, location)[0]

3962

3898

other_tree, other_path = WorkingTree.open_containing(location)

4049

3985

merge_type = _mod_merge.Merge3Merger

4050

3986

tree, file_list = tree_files(file_list)

4051

3987

tree.lock_write()

4052

try:

4053

parents = tree.get_parent_ids()

4054

if len(parents) != 2:

4055

raise errors.BzrCommandError("Sorry, remerge only works after normal"

4056

" merges. Not cherrypicking or"

4057

" multi-merges.")

4058

repository = tree.branch.repository

4059

interesting_ids = None

4060

new_conflicts = []

4061

conflicts = tree.conflicts()

4062

if file_list is not None:

4063

interesting_ids = set()

4064

for filename in file_list:

4065

file_id = tree.path2id(filename)

4066

if file_id is None:

4067

raise errors.NotVersionedError(filename)

4068

interesting_ids.add(file_id)

4069

if tree.kind(file_id) != "directory":

4070

continue

3988

self.add_cleanup(tree.unlock)

3989

parents = tree.get_parent_ids()

3990

if len(parents) != 2:

3991

raise errors.BzrCommandError("Sorry, remerge only works after normal"

3992

" merges. Not cherrypicking or"

3993

" multi-merges.")

3994

repository = tree.branch.repository

3995

interesting_ids = None

3996

new_conflicts = []

3997

conflicts = tree.conflicts()

3998

if file_list is not None:

3999

interesting_ids = set()

4000

for filename in file_list:

4001

file_id = tree.path2id(filename)

4002

if file_id is None:

4003

raise errors.NotVersionedError(filename)

4004

interesting_ids.add(file_id)

4005

if tree.kind(file_id) != "directory":

4006

continue

4071

4007

4072

for name, ie in tree.inventory.iter_entries(file_id):

4073

interesting_ids.add(ie.file_id)

4074

new_conflicts = conflicts.select_conflicts(tree, file_list)[0]

4075

else:

4076

# Remerge only supports resolving contents conflicts

4077

allowed_conflicts = ('text conflict', 'contents conflict')

4078

restore_files = [c.path for c in conflicts

4079

if c.typestring in allowed_conflicts]

4080

_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)

4081

tree.set_conflicts(ConflictList(new_conflicts))

4082

if file_list is not None:

4083

restore_files = file_list

4084

for filename in restore_files:

4085

try:

4086

restore(tree.abspath(filename))

4087

except errors.NotConflicted:

4088

pass

4089

# Disable pending merges, because the file texts we are remerging

4090

# have not had those merges performed. If we use the wrong parents

4091

# list, we imply that the working tree text has seen and rejected

4092

# all the changes from the other tree, when in fact those changes

4093

# have not yet been seen.

4094

pb = ui.ui_factory.nested_progress_bar()

4095

tree.set_parent_ids(parents[:1])

4008

for name, ie in tree.inventory.iter_entries(file_id):

4009

interesting_ids.add(ie.file_id)

4010

new_conflicts = conflicts.select_conflicts(tree, file_list)[0]

4011

else:

4012

# Remerge only supports resolving contents conflicts

4013

allowed_conflicts = ('text conflict', 'contents conflict')

4014

restore_files = [c.path for c in conflicts

4015

if c.typestring in allowed_conflicts]

4016

_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)

4017

tree.set_conflicts(ConflictList(new_conflicts))

4018

if file_list is not None:

4019

restore_files = file_list

4020

for filename in restore_files:

4096

4021

try:

4097

merger = _mod_merge.Merger.from_revision_ids(pb,

4098

tree, parents[1])

4099

merger.interesting_ids = interesting_ids

4100

merger.merge_type = merge_type

4101

merger.show_base = show_base

4102

merger.reprocess = reprocess

4103

conflicts = merger.do_merge()

4104

finally:

4105

tree.set_parent_ids(parents)

4106

pb.finished()

4022

restore(tree.abspath(filename))

4023

except errors.NotConflicted:

4024

pass

4025

# Disable pending merges, because the file texts we are remerging

4026

# have not had those merges performed. If we use the wrong parents

4027

# list, we imply that the working tree text has seen and rejected

4028

# all the changes from the other tree, when in fact those changes

4029

# have not yet been seen.

4030

pb = ui.ui_factory.nested_progress_bar()

4031

tree.set_parent_ids(parents[:1])

4032

try:

4033

merger = _mod_merge.Merger.from_revision_ids(pb,

4034

tree, parents[1])

4035

merger.interesting_ids = interesting_ids

4036

merger.merge_type = merge_type

4037

merger.show_base = show_base

4038

merger.reprocess = reprocess

4039

conflicts = merger.do_merge()

4107

4040

finally:

4108

tree.unlock()

4041

tree.set_parent_ids(parents)

4042

pb.finished()

4109

4043

if conflicts > 0:

4110

4044

return 1

4111

4045

else:

4170

4104

forget_merges=None):

4171

4105

tree, file_list = tree_files(file_list)

4172

4106

tree.lock_write()

4173

try:

4174

if forget_merges:

4175

tree.set_parent_ids(tree.get_parent_ids()[:1])

4176

else:

4177

self._revert_tree_to_revision(tree, revision, file_list, no_backup)

4178

finally:

4179

tree.unlock()

4107

self.add_cleanup(tree.unlock)

4108

if forget_merges:

4109

tree.set_parent_ids(tree.get_parent_ids()[:1])

4110

else:

4111

self._revert_tree_to_revision(tree, revision, file_list, no_backup)

4180

4112

4181

4113

@staticmethod

4182

4114

def _revert_tree_to_revision(tree, revision, file_list, no_backup):

4333

4265

if remote_branch.base == local_branch.base:

4334

4266

remote_branch = local_branch

4335

4267

4268

local_branch.lock_read()

4269

self.add_cleanup(local_branch.unlock)

4336

4270

local_revid_range = _revision_range_to_revid_range(

4337

4271

_get_revision_range(my_revision, local_branch,

4338

4272

self.name()))

4339

4273

4274

remote_branch.lock_read()

4275

self.add_cleanup(remote_branch.unlock)

4340

4276

remote_revid_range = _revision_range_to_revid_range(

4341

4277

_get_revision_range(revision,

4342

4278

remote_branch, self.name()))

4343

4279

4344

local_branch.lock_read()

4345

try:

4346

remote_branch.lock_read()

4347

try:

4348

local_extra, remote_extra = find_unmerged(

4349

local_branch, remote_branch, restrict,

4350

backward=not reverse,

4351

include_merges=include_merges,

4352

local_revid_range=local_revid_range,

4353

remote_revid_range=remote_revid_range)

4354

4355

if log_format is None:

4356

registry = log.log_formatter_registry

4357

log_format = registry.get_default(local_branch)

4358

lf = log_format(to_file=self.outf,

4359

show_ids=show_ids,

4360

show_timezone='original')

4361

4362

status_code = 0

4363

if local_extra and not theirs_only:

4364

message("You have %d extra revision(s):\n" %

4365

len(local_extra))

4366

for revision in iter_log_revisions(local_extra,

4367

local_branch.repository,

4368

verbose):

4369

lf.log_revision(revision)

4370

printed_local = True

4371

status_code = 1

4372

else:

4373

printed_local = False

4374

4375

if remote_extra and not mine_only:

4376

if printed_local is True:

4377

message("\n\n\n")

4378

message("You are missing %d revision(s):\n" %

4379

len(remote_extra))

4380

for revision in iter_log_revisions(remote_extra,

4381

remote_branch.repository,

4382

verbose):

4383

lf.log_revision(revision)

4384

status_code = 1

4385

4386

if mine_only and not local_extra:

4387

# We checked local, and found nothing extra

4388

message('This branch is up to date.\n')

4389

elif theirs_only and not remote_extra:

4390

# We checked remote, and found nothing extra

4391

message('Other branch is up to date.\n')

4392

elif not (mine_only or theirs_only or local_extra or

4393

remote_extra):

4394

# We checked both branches, and neither one had extra

4395

# revisions

4396

message("Branches are up to date.\n")

4397

finally:

4398

remote_branch.unlock()

4399

finally:

4400

local_branch.unlock()

4280

local_extra, remote_extra = find_unmerged(

4281

local_branch, remote_branch, restrict,

4282

backward=not reverse,

4283

include_merges=include_merges,

4284

local_revid_range=local_revid_range,

4285

remote_revid_range=remote_revid_range)

4286

4287

if log_format is None:

4288

registry = log.log_formatter_registry

4289

log_format = registry.get_default(local_branch)

4290

lf = log_format(to_file=self.outf,

4291

show_ids=show_ids,

4292

show_timezone='original')

4293

4294

status_code = 0

4295

if local_extra and not theirs_only:

4296

message("You have %d extra revision(s):\n" %

4297

len(local_extra))

4298

for revision in iter_log_revisions(local_extra,

4299

local_branch.repository,

4300

verbose):

4301

lf.log_revision(revision)

4302

printed_local = True

4303

status_code = 1

4304

else:

4305

printed_local = False

4306

4307

if remote_extra and not mine_only:

4308

if printed_local is True:

4309

message("\n\n\n")

4310

message("You are missing %d revision(s):\n" %

4311

len(remote_extra))

4312

for revision in iter_log_revisions(remote_extra,

4313

remote_branch.repository,

4314

verbose):

4315

lf.log_revision(revision)

4316

status_code = 1

4317

4318

if mine_only and not local_extra:

4319

# We checked local, and found nothing extra

4320

message('This branch is up to date.\n')

4321

elif theirs_only and not remote_extra:

4322

# We checked remote, and found nothing extra

4323

message('Other branch is up to date.\n')

4324

elif not (mine_only or theirs_only or local_extra or

4325

remote_extra):

4326

# We checked both branches, and neither one had extra

4327

# revisions

4328

message("Branches are up to date.\n")

4329

self.cleanup_now()

4401

4330

if not status_code and parent is None and other_branch is not None:

4402

4331

local_branch.lock_write()

4403

try:

4404

# handle race conditions - a parent might be set while we run.

4405

if local_branch.get_parent() is None:

4406

local_branch.set_parent(remote_branch.base)

4407

finally:

4408

local_branch.unlock()

4332

self.add_cleanup(local_branch.unlock)

4333

# handle race conditions - a parent might be set while we run.

4334

if local_branch.get_parent() is None:

4335

local_branch.set_parent(remote_branch.base)

4409

4336

return status_code

4410

4337

4411

4338

4490

4417

else:

4491

4418

b = Branch.open(branch)

4492

4419

b.lock_read()

4493

try:

4494

if revision is None:

4495

rev_id = b.last_revision()

4496

else:

4497

rev_id = revision[0].as_revision_id(b)

4498

t = testament_class.from_revision(b.repository, rev_id)

4499

if long:

4500

sys.stdout.writelines(t.as_text_lines())

4501

else:

4502

sys.stdout.write(t.as_short_text())

4503

finally:

4504

b.unlock()

4420

self.add_cleanup(b.unlock)

4421

if revision is None:

4422

rev_id = b.last_revision()

4423

else:

4424

rev_id = revision[0].as_revision_id(b)

4425

t = testament_class.from_revision(b.repository, rev_id)

4426

if long:

4427

sys.stdout.writelines(t.as_text_lines())

4428

else:

4429

sys.stdout.write(t.as_short_text())

4505

4430

4506

4431

4507

4432

class cmd_annotate(Command):

4533

4458

bzrdir.BzrDir.open_containing_tree_or_branch(filename)

4534

4459

if wt is not None:

4535

4460

wt.lock_read()

4461

self.add_cleanup(wt.unlock)

4536

4462

else:

4537

4463

branch.lock_read()

4538

try:

4539

tree = _get_one_revision_tree('annotate', revision, branch=branch)

4540

if wt is not None:

4541

file_id = wt.path2id(relpath)

4542

else:

4543

file_id = tree.path2id(relpath)

4544

if file_id is None:

4545

raise errors.NotVersionedError(filename)

4546

file_version = tree.inventory[file_id].revision

4547

if wt is not None and revision is None:

4548

# If there is a tree and we're not annotating historical

4549

# versions, annotate the working tree's content.

4550

annotate_file_tree(wt, file_id, self.outf, long, all,

4551

show_ids=show_ids)

4552

else:

4553

annotate_file(branch, file_version, file_id, long, all, self.outf,

4554

show_ids=show_ids)

4555

finally:

4556

if wt is not None:

4557

wt.unlock()

4558

else:

4559

branch.unlock()

4464

self.add_cleanup(branch.unlock)

4465

tree = _get_one_revision_tree('annotate', revision, branch=branch)

4466

tree.lock_read()

4467

self.add_cleanup(tree.unlock)

4468

if wt is not None:

4469

file_id = wt.path2id(relpath)

4470

else:

4471

file_id = tree.path2id(relpath)

4472

if file_id is None:

4473

raise errors.NotVersionedError(filename)

4474

file_version = tree.inventory[file_id].revision

4475

if wt is not None and revision is None:

4476

# If there is a tree and we're not annotating historical

4477

# versions, annotate the working tree's content.

4478

annotate_file_tree(wt, file_id, self.outf, long, all,

4479

show_ids=show_ids)

4480

else:

4481

annotate_file(branch, file_version, file_id, long, all, self.outf,

4482

show_ids=show_ids)

4560

4483

4561

4484

4562

4485

class cmd_re_sign(Command):

4574

4497

raise errors.BzrCommandError('You must supply either --revision or a revision_id')

4575

4498

b = WorkingTree.open_containing(u'.')[0].branch

4576

4499

b.lock_write()

4577

try:

4578

return self._run(b, revision_id_list, revision)

4579

finally:

4580

b.unlock()

4500

self.add_cleanup(b.unlock)

4501

return self._run(b, revision_id_list, revision)

4581

4502

4582

4503

def _run(self, b, revision_id_list, revision):

4583

4504

import bzrlib.gpg as gpg

4729

4650

4730

4651

if tree is not None:

4731

4652

tree.lock_write()

4653

self.add_cleanup(tree.unlock)

4732

4654

else:

4733

4655

b.lock_write()

4734

try:

4735

return self._run(b, tree, dry_run, verbose, revision, force,

4736

local=local)

4737

finally:

4738

if tree is not None:

4739

tree.unlock()

4740

else:

4741

b.unlock()

4656

self.add_cleanup(b.unlock)

4657

return self._run(b, tree, dry_run, verbose, revision, force, local=local)

4742

4658

4743

4659

def _run(self, b, tree, dry_run, verbose, revision, force, local=False):

4744

4660

from bzrlib.log import log_formatter, show_log

5283

5199

):

5284

5200

branch, relpath = Branch.open_containing(directory)

5285

5201

branch.lock_write()

5286

try:

5287

if delete:

5288

branch.tags.delete_tag(tag_name)

5289

self.outf.write('Deleted tag %s.\n' % tag_name)

5202

self.add_cleanup(branch.unlock)

5203

if delete:

5204

branch.tags.delete_tag(tag_name)

5205

self.outf.write('Deleted tag %s.\n' % tag_name)

5206

else:

5207

if revision:

5208

if len(revision) != 1:

5209

raise errors.BzrCommandError(

5210

"Tags can only be placed on a single revision, "

5211

"not on a range")

5212

revision_id = revision[0].as_revision_id(branch)

5290

5213

else:

5291

if revision:

5292

if len(revision) != 1:

5293

raise errors.BzrCommandError(

5294

"Tags can only be placed on a single revision, "

5295

"not on a range")

5296

revision_id = revision[0].as_revision_id(branch)

5297

else:

5298

revision_id = branch.last_revision()

5299

if (not force) and branch.tags.has_tag(tag_name):

5300

raise errors.TagAlreadyExists(tag_name)

5301

branch.tags.set_tag(tag_name, revision_id)

5302

self.outf.write('Created tag %s.\n' % tag_name)

5303

finally:

5304

branch.unlock()

5214

revision_id = branch.last_revision()

5215

if (not force) and branch.tags.has_tag(tag_name):

5216

raise errors.TagAlreadyExists(tag_name)

5217

branch.tags.set_tag(tag_name, revision_id)

5218

self.outf.write('Created tag %s.\n' % tag_name)

5305

5219

5306

5220

5307

5221

class cmd_tags(Command):

5340

5254

return

5341

5255

5342

5256

branch.lock_read()

5343

try:

5344

if revision:

5345

graph = branch.repository.get_graph()

5346

rev1, rev2 = _get_revision_range(revision, branch, self.name())

5347

revid1, revid2 = rev1.rev_id, rev2.rev_id

5348

# only show revisions between revid1 and revid2 (inclusive)

5349

tags = [(tag, revid) for tag, revid in tags if

5350

graph.is_between(revid, revid1, revid2)]

5351

if sort == 'alpha':

5352

tags.sort()

5353

elif sort == 'time':

5354

timestamps = {}

5355

for tag, revid in tags:

5356

try:

5357

revobj = branch.repository.get_revision(revid)

5358

except errors.NoSuchRevision:

5359

timestamp = sys.maxint # place them at the end

5360

else:

5361

timestamp = revobj.timestamp

5362

timestamps[revid] = timestamp

5363

tags.sort(key=lambda x: timestamps[x[1]])

5364

if not show_ids:

5365

# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]

5366

for index, (tag, revid) in enumerate(tags):

5367

try:

5368

revno = branch.revision_id_to_dotted_revno(revid)

5369

if isinstance(revno, tuple):

5370

revno = '.'.join(map(str, revno))

5371

except errors.NoSuchRevision:

5372

# Bad tag data/merges can lead to tagged revisions

5373

# which are not in this branch. Fail gracefully ...

5374

revno = '?'

5375

tags[index] = (tag, revno)

5376

finally:

5377

branch.unlock()

5257

self.add_cleanup(branch.unlock)

5258

if revision:

5259

graph = branch.repository.get_graph()

5260

rev1, rev2 = _get_revision_range(revision, branch, self.name())

5261

revid1, revid2 = rev1.rev_id, rev2.rev_id

5262

# only show revisions between revid1 and revid2 (inclusive)

5263

tags = [(tag, revid) for tag, revid in tags if

5264

graph.is_between(revid, revid1, revid2)]

5265

if sort == 'alpha':

5266

tags.sort()

5267

elif sort == 'time':

5268

timestamps = {}

5269

for tag, revid in tags:

5270

try:

5271

revobj = branch.repository.get_revision(revid)

5272

except errors.NoSuchRevision:

5273

timestamp = sys.maxint # place them at the end

5274

else:

5275

timestamp = revobj.timestamp

5276

timestamps[revid] = timestamp

5277

tags.sort(key=lambda x: timestamps[x[1]])

5278

if not show_ids:

5279

# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]

5280

for index, (tag, revid) in enumerate(tags):

5281

try:

5282

revno = branch.revision_id_to_dotted_revno(revid)

5283

if isinstance(revno, tuple):

5284

revno = '.'.join(map(str, revno))

5285

except errors.NoSuchRevision:

5286

# Bad tag data/merges can lead to tagged revisions

5287

# which are not in this branch. Fail gracefully ...

5288

revno = '?'

5289

tags[index] = (tag, revno)

5290

self.cleanup_now()

5378

5291

for tag, revspec in tags:

5379

5292

self.outf.write('%-20s %s\n' % (tag, revspec))

5380

5293

5798

5711

def run_for_list(self):

5799

5712

tree = WorkingTree.open_containing('.')[0]

5800

5713

tree.lock_read()

5801

try:

5802

manager = tree.get_shelf_manager()

5803

shelves = manager.active_shelves()

5804

if len(shelves) == 0:

5805

note('No shelved changes.')

5806

return 0

5807

for shelf_id in reversed(shelves):

5808

message = manager.get_metadata(shelf_id).get('message')

5809

if message is None:

5810

message = '<no message>'

5811

self.outf.write('%3d: %s\n' % (shelf_id, message))

5812

return 1

5813

finally:

5814

tree.unlock()

5714

self.add_cleanup(tree.unlock)

5715

manager = tree.get_shelf_manager()

5716

shelves = manager.active_shelves()

5717

if len(shelves) == 0:

5718

note('No shelved changes.')

5719

return 0

5720

for shelf_id in reversed(shelves):

5721

message = manager.get_metadata(shelf_id).get('message')

5722

if message is None:

5723

message = '<no message>'

5724

self.outf.write('%3d: %s\n' % (shelf_id, message))

5725

return 1

5815

5726

5816

5727

5817

5728

class cmd_unshelve(Command):