/brz/remove-bazaar : revision 7356.1.1

552

553

def run(self, revision=None, directory='.', force=False):

554

tree, _ = WorkingTree.open_containing(directory)

555

self.add_cleanup(tree.lock_tree_write().unlock)

555

self.enter_context(tree.lock_tree_write())

556

if not force:

557

try:

558

tree.check_state()

602

if tree:

603

try:

604

wt = WorkingTree.open_containing(location)[0]

605

self.add_cleanup(wt.lock_read().unlock)

605

self.enter_context(wt.lock_read())

606

except (errors.NoWorkingTree, errors.NotLocalUrl):

607

raise errors.NoWorkingTree(location)

608

b = wt.branch

609

revid = wt.last_revision()

610

else:

611

b = Branch.open_containing(location)[0]

612

self.add_cleanup(b.lock_read().unlock)

612

self.enter_context(b.lock_read())

613

if revision:

614

if len(revision) != 1:

615

raise errors.BzrCommandError(gettext(

646

try:

647

wt = WorkingTree.open_containing(directory)[0]

648

b = wt.branch

649

self.add_cleanup(wt.lock_read().unlock)

649

self.enter_context(wt.lock_read())

650

except (errors.NoWorkingTree, errors.NotLocalUrl):

651

wt = None

652

b = Branch.open_containing(directory)[0]

653

self.add_cleanup(b.lock_read().unlock)

653

self.enter_context(b.lock_read())

654

revision_ids = []

655

if revision is not None:

656

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

766

to_file=self.outf, should_print=(not is_quiet()))

767

768

if base_tree:

769

self.add_cleanup(base_tree.lock_read().unlock)

769

self.enter_context(base_tree.lock_read())

770

tree, file_list = tree_files_for_add(file_list)

771

added, ignored = tree.smart_add(

772

file_list, not no_recurse, action=action, save=not dry_run)

872

873

revision = _get_one_revision('inventory', revision)

874

work_tree, file_list = WorkingTree.open_containing_paths(file_list)

875

self.add_cleanup(work_tree.lock_read().unlock)

875

self.enter_context(work_tree.lock_read())

876

if revision is not None:

877

tree = revision.as_tree(work_tree.branch)

878

879

extra_trees = [work_tree]

880

self.add_cleanup(tree.lock_read().unlock)

880

self.enter_context(tree.lock_read())

881

else:

882

tree = work_tree

883

extra_trees = []

884

885

self.add_cleanup(tree.lock_read().unlock)

885

self.enter_context(tree.lock_read())

886

if file_list is not None:

887

paths = tree.find_related_paths_across_trees(

888

file_list, extra_trees, require_versioned=True)

937

if file_name == '':

938

raise errors.BzrCommandError(

939

gettext("can not copy root of branch"))

940

self.add_cleanup(tree.lock_tree_write().unlock)

940

self.enter_context(tree.lock_tree_write())

941

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

942

if not into_existing:

943

try:

1030

if file_name == '':

1031

raise errors.BzrCommandError(

1032

gettext("can not move root of branch"))

1033

self.add_cleanup(tree.lock_tree_write().unlock)

1033

self.enter_context(tree.lock_tree_write())

1034

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

1035

1036

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

1042

gettext('--after cannot be specified with --auto.'))

1043

work_tree, file_list = WorkingTree.open_containing_paths(

1044

names_list, default_directory='.')

1045

self.add_cleanup(work_tree.lock_tree_write().unlock)

1045

self.enter_context(work_tree.lock_tree_write())

1046

rename_map.RenameMap.guess_renames(

1047

work_tree.basis_tree(), work_tree, dry_run)

1048

1196

try:

1197

tree_to = WorkingTree.open_containing(directory)[0]

1198

branch_to = tree_to.branch

1199

self.add_cleanup(tree_to.lock_write().unlock)

1199

self.enter_context(tree_to.lock_write())

1200

except errors.NoWorkingTree:

1201

tree_to = None

1202

branch_to = Branch.open_containing(directory)[0]

1203

self.add_cleanup(branch_to.lock_write().unlock)

1203

self.enter_context(branch_to.lock_write())

1204

if show_base:

1205

warning(gettext("No working tree, ignoring --show-base"))

1206

1240

else:

1241

branch_from = Branch.open(location,

1242

possible_transports=possible_transports)

1243

self.add_cleanup(branch_from.lock_read().unlock)

1243

self.enter_context(branch_from.lock_read())

1244

# Remembers if asked explicitly or no previous location is set

1245

if (remember

1246

or (remember is None and branch_to.get_parent() is None)):

1472

if files_from is not None and files_from != from_location:

1473

accelerator_tree = WorkingTree.open(files_from)

1474

revision = _get_one_revision('branch', revision)

1475

self.add_cleanup(br_from.lock_read().unlock)

1475

self.enter_context(br_from.lock_read())

1476

if revision is not None:

1477

revision_id = revision.as_revision_id(br_from)

1478

else:

1696

@display_command

1697

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

1698

tree = WorkingTree.open_containing(dir)[0]

1699

self.add_cleanup(tree.lock_read().unlock)

1699

self.enter_context(tree.lock_read())

1700

old_tree = tree.basis_tree()

1701

self.add_cleanup(old_tree.lock_read().unlock)

1701

self.enter_context(old_tree.lock_read())

1702

renames = []

1703

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

1704

for change in iterator:

1769

possible_transports=possible_transports)

1770

if master is not None:

1771

branch_location = master.base

1772

tree.lock_write()

1772

self.enter_context(tree.lock_write())

1773

else:

1774

branch_location = tree.branch.base

1775

tree.lock_tree_write()

1776

self.add_cleanup(tree.unlock)

1775

self.enter_context(tree.lock_tree_write())

1777

1776

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

1778

1777

branch_location = urlutils.unescape_for_display(

1779

1778

branch_location.rstrip('/'),

1901

1900

if file_list is not None:

1902

1901

file_list = [f for f in file_list]

1903

1902

1904

self.add_cleanup(tree.lock_write().unlock)

1903

self.enter_context(tree.lock_write())

1905

1904

# Heuristics should probably all move into tree.remove_smart or

1906

1905

# some such?

1907

1906

if new:

1970

1969

@display_command

1971

1970

def run(self, location="."):

1972

1971

branch = Branch.open_containing(location)[0]

1973

self.add_cleanup(branch.lock_read().unlock)

1972

self.enter_context(branch.lock_read())

1974

1973

graph = branch.repository.get_graph()

1975

1974

history = list(graph.iter_lefthand_ancestry(branch.last_revision(),

1976

1975

[_mod_revision.NULL_REVISION]))

1998

1997

b = wt.branch

1999

1998

last_revision = wt.last_revision()

2000

1999

2001

self.add_cleanup(b.repository.lock_read().unlock)

2000

self.enter_context(b.repository.lock_read())

2002

2001

graph = b.repository.get_graph()

2003

2002

revisions = [revid for revid, parents in

2004

2003

graph.iter_ancestry([last_revision])]

2353

2352

(old_tree, new_tree,

2354

2353

old_branch, new_branch,

2355

2354

specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(

2356

file_list, revision, old, new, self.add_cleanup, apply_view=True)

2355

file_list, revision, old, new, self._exit_stack, apply_view=True)

2357

2356

# GNU diff on Windows uses ANSI encoding for filenames

2358

2357

path_encoding = osutils.get_diff_header_encoding()

2359

2358

return show_diff_trees(old_tree, new_tree, self.outf,

2381

2380

@display_command

2382

2381

def run(self, show_ids=False, directory=u'.'):

2383

2382

tree = WorkingTree.open_containing(directory)[0]

2384

self.add_cleanup(tree.lock_read().unlock)

2383

self.enter_context(tree.lock_read())

2385

2384

old = tree.basis_tree()

2386

self.add_cleanup(old.lock_read().unlock)

2385

self.enter_context(old.lock_read())

2387

2386

for path, ie in old.iter_entries_by_dir():

2388

2387

if not tree.has_id(ie.file_id):

2389

2388

self.outf.write(path)

2404

2403

@display_command

2405

2404

def run(self, null=False, directory=u'.'):

2406

2405

tree = WorkingTree.open_containing(directory)[0]

2407

self.add_cleanup(tree.lock_read().unlock)

2406

self.enter_context(tree.lock_read())

2408

2407

td = tree.changes_from(tree.basis_tree())

2409

2408

self.cleanup_now()

2410

2409

for path, id, kind, text_modified, meta_modified in td.modified:

2425

2424

@display_command

2426

2425

def run(self, null=False, directory=u'.'):

2427

2426

wt = WorkingTree.open_containing(directory)[0]

2428

self.add_cleanup(wt.lock_read().unlock)

2427

self.enter_context(wt.lock_read())

2429

2428

basis = wt.basis_tree()

2430

self.add_cleanup(basis.lock_read().unlock)

2429

self.enter_context(basis.lock_read())

2431

2430

for path in wt.all_versioned_paths():

2432

2431

if basis.has_filename(path):

2433

2432

continue

2761

2760

if file_list:

2762

2761

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

2763

2762

b, file_info_list, rev1, rev2 = _get_info_for_log_files(

2764

revision, file_list, self.add_cleanup)

2763

revision, file_list, self._exit_stack)

2765

2764

for relpath, file_id, kind in file_info_list:

2766

2765

if file_id is None:

2767

2766

raise errors.BzrCommandError(gettext(

2785

2784

location = '.'

2786

2785

dir, relpath = controldir.ControlDir.open_containing(location)

2787

2786

b = dir.open_branch()

2788

self.add_cleanup(b.lock_read().unlock)

2787

self.enter_context(b.lock_read())

2789

2788

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

2790

2789

2791

2790

if b.get_config_stack().get('validate_signatures_in_log'):

3016

3015

view_str = views.view_display_str(view_files)

3017

3016

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

3018

3017

3019

self.add_cleanup(tree.lock_read().unlock)

3018

self.enter_context(tree.lock_read())

3020

3019

for fp, fc, fkind, entry in tree.list_files(

3021

3020

include_root=False, from_dir=relpath, recursive=recursive):

3022

3021

# Apply additional masking

3193

3192

ignores.tree_ignores_add_patterns(tree, name_pattern_list)

3194

3193

ignored = globbing.Globster(name_pattern_list)

3195

3194

matches = []

3196

self.add_cleanup(tree.lock_read().unlock)

3195

self.enter_context(tree.lock_read())

3197

3196

for filename, fc, fkind, entry in tree.list_files():

3198

3197

id = getattr(entry, 'file_id', None)

3199

3198

if id is not None:

3224

3223

@display_command

3225

3224

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

3226

3225

tree = WorkingTree.open_containing(directory)[0]

3227

self.add_cleanup(tree.lock_read().unlock)

3226

self.enter_context(tree.lock_read())

3228

3227

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

3229

3228

if file_class != 'I':

3230

3229

continue

3315

3314

(tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(

3316

3315

branch_or_subdir)

3317

3316

if tree is not None:

3318

self.add_cleanup(tree.lock_read().unlock)

3317

self.enter_context(tree.lock_read())

3319

3318

3320

3319

if uncommitted:

3321

3320

if tree is None:

3379

3378

" one revision specifier"))

3380

3379

tree, branch, relpath = \

3381

3380

_open_directory_or_containing_tree_or_branch(filename, directory)

3382

self.add_cleanup(branch.lock_read().unlock)

3381

self.enter_context(branch.lock_read())

3383

3382

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

3384

3383

name_from_revision, filters)

3385

3384

3389

3388

if tree is None:

3390

3389

tree = b.basis_tree()

3391

3390

rev_tree = _get_one_revision_tree('cat', revision, branch=b)

3392

self.add_cleanup(rev_tree.lock_read().unlock)

3391

self.enter_context(rev_tree.lock_read())

3393

3392

3394

3393

if name_from_revision:

3395

3394

# Try in revision if requested

3903

3902

c = Branch.open_containing(u'.')[0].get_config_stack()

3904

3903

else:

3905

3904

b = Branch.open(directory)

3906

self.add_cleanup(b.lock_write().unlock)

3905

self.enter_context(b.lock_write())

3907

3906

c = b.get_config_stack()

3908

3907

else:

3909

3908

c = _mod_config.GlobalStack()

4281

4280

4282

4281

branch1 = Branch.open_containing(branch)[0]

4283

4282

branch2 = Branch.open_containing(other)[0]

4284

self.add_cleanup(branch1.lock_read().unlock)

4285

self.add_cleanup(branch2.lock_read().unlock)

4283

self.enter_context(branch1.lock_read())

4284

self.enter_context(branch2.lock_read())

4286

4285

last1 = ensure_null(branch1.last_revision())

4287

4286

last2 = ensure_null(branch2.last_revision())

4288

4287

4434

4433

change_reporter = delta._ChangeReporter(

4435

4434

unversioned_filter=tree.is_ignored, view_info=view_info)

4436

4435

pb = ui.ui_factory.nested_progress_bar()

4437

self.add_cleanup(pb.finished)

4438

self.add_cleanup(tree.lock_write().unlock)

4436

self.enter_context(pb)

4437

self.enter_context(tree.lock_write())

4439

4438

if location is not None:

4440

4439

try:

4441

4440

mergeable = _mod_mergeable.read_mergeable_from_url(

4503

4502

def _get_preview(self, merger):

4504

4503

tree_merger = merger.make_merger()

4505

4504

tt = tree_merger.make_preview_transform()

4506

self.add_cleanup(tt.finalize)

4505

self.enter_context(tt)

4507

4506

result_tree = tt.get_preview_tree()

4508

4507

return result_tree

4509

4508

4724

4723

if merge_type is None:

4725

4724

merge_type = _mod_merge.Merge3Merger

4726

4725

tree, file_list = WorkingTree.open_containing_paths(file_list)

4727

self.add_cleanup(tree.lock_write().unlock)

4726

self.enter_context(tree.lock_write())

4728

4727

parents = tree.get_parent_ids()

4729

4728

if len(parents) != 2:

4730

4729

raise errors.BzrCommandError(

4847

4846

def run(self, revision=None, no_backup=False, file_list=None,

4848

4847

forget_merges=None):

4849

4848

tree, file_list = WorkingTree.open_containing_paths(file_list)

4850

self.add_cleanup(tree.lock_tree_write().unlock)

4849

self.enter_context(tree.lock_tree_write())

4851

4850

if forget_merges:

4852

4851

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

4853

4852

else:

4996

4995

restrict = 'remote'

4997

4996

4998

4997

local_branch = Branch.open_containing(directory)[0]

4999

self.add_cleanup(local_branch.lock_read().unlock)

4998

self.enter_context(local_branch.lock_read())

5000

4999

5001

5000

parent = local_branch.get_parent()

5002

5001

if other_branch is None:

5013

5012

if remote_branch.base == local_branch.base:

5014

5013

remote_branch = local_branch

5015

5014

else:

5016

self.add_cleanup(remote_branch.lock_read().unlock)

5015

self.enter_context(remote_branch.lock_read())

5017

5016

5018

5017

local_revid_range = _revision_range_to_revid_range(

5019

5018

_get_revision_range(my_revision, local_branch,

5085

5084

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

5086

5085

self.cleanup_now()

5087

5086

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

5088

self.add_cleanup(local_branch.lock_write().unlock)

5087

self.enter_context(local_branch.lock_write())

5089

5088

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

5090

5089

if local_branch.get_parent() is None:

5091

5090

local_branch.set_parent(remote_branch.base)

5178

5177

b = Branch.open_containing(branch)[0]

5179

5178

else:

5180

5179

b = Branch.open(branch)

5181

self.add_cleanup(b.lock_read().unlock)

5180

self.enter_context(b.lock_read())

5182

5181

if revision is None:

5183

5182

rev_id = b.last_revision()

5184

5183

else:

5221

5220

wt, branch, relpath = \

5222

5221

_open_directory_or_containing_tree_or_branch(filename, directory)

5223

5222

if wt is not None:

5224

self.add_cleanup(wt.lock_read().unlock)

5223

self.enter_context(wt.lock_read())

5225

5224

else:

5226

self.add_cleanup(branch.lock_read().unlock)

5225

self.enter_context(branch.lock_read())

5227

5226

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

5228

self.add_cleanup(tree.lock_read().unlock)

5227

self.enter_context(tree.lock_read())

5229

5228

if wt is not None and revision is None:

5230

5229

if not wt.is_versioned(relpath):

5231

5230

raise errors.NotVersionedError(relpath)

5256

5255

raise errors.BzrCommandError(

5257

5256

gettext('You must supply either --revision or a revision_id'))

5258

5257

b = WorkingTree.open_containing(directory)[0].branch

5259

self.add_cleanup(b.lock_write().unlock)

5258

self.enter_context(b.lock_write())

5260

5259

return self._run(b, revision_id_list, revision)

5261

5260

5262

5261

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

5402

5401

b = control.open_branch()

5403

5402

5404

5403

if tree is not None:

5405

self.add_cleanup(tree.lock_write().unlock)

5404

self.enter_context(tree.lock_write())

5406

5405

else:

5407

self.add_cleanup(b.lock_write().unlock)

5406

self.enter_context(b.lock_write())

5408

5407

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

5409

5408

local, keep_tags, location)

5410

5409

5987

5986

revision=None,

5988

5987

):

5989

5988

branch, relpath = Branch.open_containing(directory)

5990

self.add_cleanup(branch.lock_write().unlock)

5989

self.enter_context(branch.lock_write())

5991

5990

if delete:

5992

5991

if tag_name is None:

5993

5992

raise errors.BzrCommandError(

6051

6050

if not tags:

6052

6051

return

6053

6052

6054

self.add_cleanup(branch.lock_read().unlock)

6053

self.enter_context(branch.lock_read())

6055

6054

if revision:

6056

6055

# Restrict to the specified range

6057

6056

tags = self._tags_for_range(branch, revision)

6615

6614

if directory is None:

6616

6615

directory = u'.'

6617

6616

tree = WorkingTree.open_containing(directory)[0]

6618

self.add_cleanup(tree.lock_read().unlock)

6617

self.enter_context(tree.lock_read())

6619

6618

manager = tree.get_shelf_manager()

6620

6619

shelves = manager.active_shelves()

6621

6620

if len(shelves) == 0: