/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/builtins.py

  • Committer: Jelmer Vernooij
  • Date: 2019-08-11 13:21:03 UTC
  • mfrom: (7379 work)
  • mto: This revision was merged to the branch mainline in revision 7388.
  • Revision ID: jelmer@jelmer.uk-20190811132103-u3ne03yf37c1h57n
merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/builtins.py
552
552
 
553
553
    def run(self, revision=None, directory='.', force=False):
554
554
        tree, _ = WorkingTree.open_containing(directory)
555
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
555
        self.enter_context(tree.lock_tree_write())
556
556
        if not force:
557
557
            try:
558
558
                tree.check_state()
602
602
        if tree:
603
603
            try:
604
604
                wt = WorkingTree.open_containing(location)[0]
605
 
                self.add_cleanup(wt.lock_read().unlock)
 
605
                self.enter_context(wt.lock_read())
606
606
            except (errors.NoWorkingTree, errors.NotLocalUrl):
607
607
                raise errors.NoWorkingTree(location)
608
608
            b = wt.branch
609
609
            revid = wt.last_revision()
610
610
        else:
611
611
            b = Branch.open_containing(location)[0]
612
 
            self.add_cleanup(b.lock_read().unlock)
 
612
            self.enter_context(b.lock_read())
613
613
            if revision:
614
614
                if len(revision) != 1:
615
615
                    raise errors.BzrCommandError(gettext(
646
646
        try:
647
647
            wt = WorkingTree.open_containing(directory)[0]
648
648
            b = wt.branch
649
 
            self.add_cleanup(wt.lock_read().unlock)
 
649
            self.enter_context(wt.lock_read())
650
650
        except (errors.NoWorkingTree, errors.NotLocalUrl):
651
651
            wt = None
652
652
            b = Branch.open_containing(directory)[0]
653
 
            self.add_cleanup(b.lock_read().unlock)
 
653
            self.enter_context(b.lock_read())
654
654
        revision_ids = []
655
655
        if revision is not None:
656
656
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
766
766
                to_file=self.outf, should_print=(not is_quiet()))
767
767
 
768
768
        if base_tree:
769
 
            self.add_cleanup(base_tree.lock_read().unlock)
 
769
            self.enter_context(base_tree.lock_read())
770
770
        tree, file_list = tree_files_for_add(file_list)
771
771
        added, ignored = tree.smart_add(
772
772
            file_list, not no_recurse, action=action, save=not dry_run)
857
857
    takes_options = [
858
858
        'revision',
859
859
        'show-ids',
 
860
        Option('include-root',
 
861
               help='Include the entry for the root of the tree, if any.'),
860
862
        Option('kind',
861
863
               help='List entries of a particular kind: file, directory, '
862
864
                    'symlink.',
865
867
    takes_args = ['file*']
866
868
 
867
869
    @display_command
868
 
    def run(self, revision=None, show_ids=False, kind=None, file_list=None):
 
870
    def run(self, revision=None, show_ids=False, kind=None, include_root=False,
 
871
            file_list=None):
869
872
        if kind and kind not in ['file', 'directory', 'symlink']:
870
873
            raise errors.BzrCommandError(
871
874
                gettext('invalid kind %r specified') % (kind,))
872
875
 
873
876
        revision = _get_one_revision('inventory', revision)
874
877
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
875
 
        self.add_cleanup(work_tree.lock_read().unlock)
 
878
        self.enter_context(work_tree.lock_read())
876
879
        if revision is not None:
877
880
            tree = revision.as_tree(work_tree.branch)
878
881
 
879
882
            extra_trees = [work_tree]
880
 
            self.add_cleanup(tree.lock_read().unlock)
 
883
            self.enter_context(tree.lock_read())
881
884
        else:
882
885
            tree = work_tree
883
886
            extra_trees = []
884
887
 
885
 
        self.add_cleanup(tree.lock_read().unlock)
 
888
        self.enter_context(tree.lock_read())
886
889
        if file_list is not None:
887
890
            paths = tree.find_related_paths_across_trees(
888
891
                file_list, extra_trees, require_versioned=True)
895
898
        for path, entry in sorted(entries):
896
899
            if kind and kind != entry.kind:
897
900
                continue
898
 
            if path == "":
 
901
            if path == "" and not include_root:
899
902
                continue
900
903
            if show_ids:
901
904
                self.outf.write('%-50s %s\n' % (
937
940
            if file_name == '':
938
941
                raise errors.BzrCommandError(
939
942
                    gettext("can not copy root of branch"))
940
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
943
        self.enter_context(tree.lock_tree_write())
941
944
        into_existing = osutils.isdir(names_list[-1])
942
945
        if not into_existing:
943
946
            try:
1030
1033
            if file_name == '':
1031
1034
                raise errors.BzrCommandError(
1032
1035
                    gettext("can not move root of branch"))
1033
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
1036
        self.enter_context(tree.lock_tree_write())
1034
1037
        self._run(tree, names_list, rel_names, after)
1035
1038
 
1036
1039
    def run_auto(self, names_list, after, dry_run):
1042
1045
                gettext('--after cannot be specified with --auto.'))
1043
1046
        work_tree, file_list = WorkingTree.open_containing_paths(
1044
1047
            names_list, default_directory='.')
1045
 
        self.add_cleanup(work_tree.lock_tree_write().unlock)
 
1048
        self.enter_context(work_tree.lock_tree_write())
1046
1049
        rename_map.RenameMap.guess_renames(
1047
1050
            work_tree.basis_tree(), work_tree, dry_run)
1048
1051
 
1196
1199
        try:
1197
1200
            tree_to = WorkingTree.open_containing(directory)[0]
1198
1201
            branch_to = tree_to.branch
1199
 
            self.add_cleanup(tree_to.lock_write().unlock)
 
1202
            self.enter_context(tree_to.lock_write())
1200
1203
        except errors.NoWorkingTree:
1201
1204
            tree_to = None
1202
1205
            branch_to = Branch.open_containing(directory)[0]
1203
 
            self.add_cleanup(branch_to.lock_write().unlock)
 
1206
            self.enter_context(branch_to.lock_write())
1204
1207
            if show_base:
1205
1208
                warning(gettext("No working tree, ignoring --show-base"))
1206
1209
 
1240
1243
        else:
1241
1244
            branch_from = Branch.open(location,
1242
1245
                                      possible_transports=possible_transports)
1243
 
            self.add_cleanup(branch_from.lock_read().unlock)
 
1246
            self.enter_context(branch_from.lock_read())
1244
1247
            # Remembers if asked explicitly or no previous location is set
1245
1248
            if (remember
1246
1249
                    or (remember is None and branch_to.get_parent() is None)):
1472
1475
        if files_from is not None and files_from != from_location:
1473
1476
            accelerator_tree = WorkingTree.open(files_from)
1474
1477
        revision = _get_one_revision('branch', revision)
1475
 
        self.add_cleanup(br_from.lock_read().unlock)
 
1478
        self.enter_context(br_from.lock_read())
1476
1479
        if revision is not None:
1477
1480
            revision_id = revision.as_revision_id(br_from)
1478
1481
        else:
1696
1699
    @display_command
1697
1700
    def run(self, dir=u'.'):
1698
1701
        tree = WorkingTree.open_containing(dir)[0]
1699
 
        self.add_cleanup(tree.lock_read().unlock)
 
1702
        self.enter_context(tree.lock_read())
1700
1703
        old_tree = tree.basis_tree()
1701
 
        self.add_cleanup(old_tree.lock_read().unlock)
 
1704
        self.enter_context(old_tree.lock_read())
1702
1705
        renames = []
1703
1706
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1704
1707
        for change in iterator:
1769
1772
            possible_transports=possible_transports)
1770
1773
        if master is not None:
1771
1774
            branch_location = master.base
1772
 
            tree.lock_write()
 
1775
            self.enter_context(tree.lock_write())
1773
1776
        else:
1774
1777
            branch_location = tree.branch.base
1775
 
            tree.lock_tree_write()
1776
 
        self.add_cleanup(tree.unlock)
 
1778
            self.enter_context(tree.lock_tree_write())
1777
1779
        # get rid of the final '/' and be ready for display
1778
1780
        branch_location = urlutils.unescape_for_display(
1779
1781
            branch_location.rstrip('/'),
1901
1903
        if file_list is not None:
1902
1904
            file_list = [f for f in file_list]
1903
1905
 
1904
 
        self.add_cleanup(tree.lock_write().unlock)
 
1906
        self.enter_context(tree.lock_write())
1905
1907
        # Heuristics should probably all move into tree.remove_smart or
1906
1908
        # some such?
1907
1909
        if new:
1970
1972
    @display_command
1971
1973
    def run(self, location="."):
1972
1974
        branch = Branch.open_containing(location)[0]
1973
 
        self.add_cleanup(branch.lock_read().unlock)
 
1975
        self.enter_context(branch.lock_read())
1974
1976
        graph = branch.repository.get_graph()
1975
1977
        history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
1976
1978
                                                    [_mod_revision.NULL_REVISION]))
1998
2000
            b = wt.branch
1999
2001
            last_revision = wt.last_revision()
2000
2002
 
2001
 
        self.add_cleanup(b.repository.lock_read().unlock)
 
2003
        self.enter_context(b.repository.lock_read())
2002
2004
        graph = b.repository.get_graph()
2003
2005
        revisions = [revid for revid, parents in
2004
2006
                     graph.iter_ancestry([last_revision])]
2353
2355
        (old_tree, new_tree,
2354
2356
         old_branch, new_branch,
2355
2357
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
2356
 
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2358
            file_list, revision, old, new, self._exit_stack, apply_view=True)
2357
2359
        # GNU diff on Windows uses ANSI encoding for filenames
2358
2360
        path_encoding = osutils.get_diff_header_encoding()
2359
2361
        return show_diff_trees(old_tree, new_tree, self.outf,
2381
2383
    @display_command
2382
2384
    def run(self, show_ids=False, directory=u'.'):
2383
2385
        tree = WorkingTree.open_containing(directory)[0]
2384
 
        self.add_cleanup(tree.lock_read().unlock)
 
2386
        self.enter_context(tree.lock_read())
2385
2387
        old = tree.basis_tree()
2386
 
        self.add_cleanup(old.lock_read().unlock)
 
2388
        self.enter_context(old.lock_read())
2387
2389
        for path, ie in old.iter_entries_by_dir():
2388
2390
            if not tree.has_id(ie.file_id):
2389
2391
                self.outf.write(path)
2404
2406
    @display_command
2405
2407
    def run(self, null=False, directory=u'.'):
2406
2408
        tree = WorkingTree.open_containing(directory)[0]
2407
 
        self.add_cleanup(tree.lock_read().unlock)
 
2409
        self.enter_context(tree.lock_read())
2408
2410
        td = tree.changes_from(tree.basis_tree())
2409
2411
        self.cleanup_now()
2410
2412
        for path, id, kind, text_modified, meta_modified in td.modified:
2425
2427
    @display_command
2426
2428
    def run(self, null=False, directory=u'.'):
2427
2429
        wt = WorkingTree.open_containing(directory)[0]
2428
 
        self.add_cleanup(wt.lock_read().unlock)
 
2430
        self.enter_context(wt.lock_read())
2429
2431
        basis = wt.basis_tree()
2430
 
        self.add_cleanup(basis.lock_read().unlock)
 
2432
        self.enter_context(basis.lock_read())
2431
2433
        for path in wt.all_versioned_paths():
2432
2434
            if basis.has_filename(path):
2433
2435
                continue
2761
2763
        if file_list:
2762
2764
            # find the file ids to log and check for directory filtering
2763
2765
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2764
 
                revision, file_list, self.add_cleanup)
 
2766
                revision, file_list, self._exit_stack)
2765
2767
            for relpath, file_id, kind in file_info_list:
2766
2768
                if file_id is None:
2767
2769
                    raise errors.BzrCommandError(gettext(
2785
2787
                location = '.'
2786
2788
            dir, relpath = controldir.ControlDir.open_containing(location)
2787
2789
            b = dir.open_branch()
2788
 
            self.add_cleanup(b.lock_read().unlock)
 
2790
            self.enter_context(b.lock_read())
2789
2791
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2790
2792
 
2791
2793
        if b.get_config_stack().get('validate_signatures_in_log'):
3016
3018
                view_str = views.view_display_str(view_files)
3017
3019
                note(gettext("Ignoring files outside view. View is %s") % view_str)
3018
3020
 
3019
 
        self.add_cleanup(tree.lock_read().unlock)
 
3021
        self.enter_context(tree.lock_read())
3020
3022
        for fp, fc, fkind, entry in tree.list_files(
3021
3023
                include_root=False, from_dir=relpath, recursive=recursive):
3022
3024
            # Apply additional masking
3193
3195
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
3194
3196
        ignored = globbing.Globster(name_pattern_list)
3195
3197
        matches = []
3196
 
        self.add_cleanup(tree.lock_read().unlock)
 
3198
        self.enter_context(tree.lock_read())
3197
3199
        for filename, fc, fkind, entry in tree.list_files():
3198
3200
            id = getattr(entry, 'file_id', None)
3199
3201
            if id is not None:
3224
3226
    @display_command
3225
3227
    def run(self, directory=u'.'):
3226
3228
        tree = WorkingTree.open_containing(directory)[0]
3227
 
        self.add_cleanup(tree.lock_read().unlock)
 
3229
        self.enter_context(tree.lock_read())
3228
3230
        for path, file_class, kind, entry in tree.list_files():
3229
3231
            if file_class != 'I':
3230
3232
                continue
3315
3317
        (tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
3316
3318
            branch_or_subdir)
3317
3319
        if tree is not None:
3318
 
            self.add_cleanup(tree.lock_read().unlock)
 
3320
            self.enter_context(tree.lock_read())
3319
3321
 
3320
3322
        if uncommitted:
3321
3323
            if tree is None:
3379
3381
                                                 " one revision specifier"))
3380
3382
        tree, branch, relpath = \
3381
3383
            _open_directory_or_containing_tree_or_branch(filename, directory)
3382
 
        self.add_cleanup(branch.lock_read().unlock)
 
3384
        self.enter_context(branch.lock_read())
3383
3385
        return self._run(tree, branch, relpath, filename, revision,
3384
3386
                         name_from_revision, filters)
3385
3387
 
3389
3391
        if tree is None:
3390
3392
            tree = b.basis_tree()
3391
3393
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
3392
 
        self.add_cleanup(rev_tree.lock_read().unlock)
 
3394
        self.enter_context(rev_tree.lock_read())
3393
3395
 
3394
3396
        if name_from_revision:
3395
3397
            # Try in revision if requested
3903
3905
                c = Branch.open_containing(u'.')[0].get_config_stack()
3904
3906
            else:
3905
3907
                b = Branch.open(directory)
3906
 
                self.add_cleanup(b.lock_write().unlock)
 
3908
                self.enter_context(b.lock_write())
3907
3909
                c = b.get_config_stack()
3908
3910
        else:
3909
3911
            c = _mod_config.GlobalStack()
4281
4283
 
4282
4284
        branch1 = Branch.open_containing(branch)[0]
4283
4285
        branch2 = Branch.open_containing(other)[0]
4284
 
        self.add_cleanup(branch1.lock_read().unlock)
4285
 
        self.add_cleanup(branch2.lock_read().unlock)
 
4286
        self.enter_context(branch1.lock_read())
 
4287
        self.enter_context(branch2.lock_read())
4286
4288
        last1 = ensure_null(branch1.last_revision())
4287
4289
        last2 = ensure_null(branch2.last_revision())
4288
4290
 
4434
4436
        change_reporter = delta._ChangeReporter(
4435
4437
            unversioned_filter=tree.is_ignored, view_info=view_info)
4436
4438
        pb = ui.ui_factory.nested_progress_bar()
4437
 
        self.add_cleanup(pb.finished)
4438
 
        self.add_cleanup(tree.lock_write().unlock)
 
4439
        self.enter_context(pb)
 
4440
        self.enter_context(tree.lock_write())
4439
4441
        if location is not None:
4440
4442
            try:
4441
4443
                mergeable = _mod_mergeable.read_mergeable_from_url(
4503
4505
    def _get_preview(self, merger):
4504
4506
        tree_merger = merger.make_merger()
4505
4507
        tt = tree_merger.make_preview_transform()
4506
 
        self.add_cleanup(tt.finalize)
 
4508
        self.enter_context(tt)
4507
4509
        result_tree = tt.get_preview_tree()
4508
4510
        return result_tree
4509
4511
 
4724
4726
        if merge_type is None:
4725
4727
            merge_type = _mod_merge.Merge3Merger
4726
4728
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4727
 
        self.add_cleanup(tree.lock_write().unlock)
 
4729
        self.enter_context(tree.lock_write())
4728
4730
        parents = tree.get_parent_ids()
4729
4731
        if len(parents) != 2:
4730
4732
            raise errors.BzrCommandError(
4847
4849
    def run(self, revision=None, no_backup=False, file_list=None,
4848
4850
            forget_merges=None):
4849
4851
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4850
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
4852
        self.enter_context(tree.lock_tree_write())
4851
4853
        if forget_merges:
4852
4854
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4853
4855
        else:
4996
4998
            restrict = 'remote'
4997
4999
 
4998
5000
        local_branch = Branch.open_containing(directory)[0]
4999
 
        self.add_cleanup(local_branch.lock_read().unlock)
 
5001
        self.enter_context(local_branch.lock_read())
5000
5002
 
5001
5003
        parent = local_branch.get_parent()
5002
5004
        if other_branch is None:
5013
5015
        if remote_branch.base == local_branch.base:
5014
5016
            remote_branch = local_branch
5015
5017
        else:
5016
 
            self.add_cleanup(remote_branch.lock_read().unlock)
 
5018
            self.enter_context(remote_branch.lock_read())
5017
5019
 
5018
5020
        local_revid_range = _revision_range_to_revid_range(
5019
5021
            _get_revision_range(my_revision, local_branch,
5085
5087
            message(gettext("Branches are up to date.\n"))
5086
5088
        self.cleanup_now()
5087
5089
        if not status_code and parent is None and other_branch is not None:
5088
 
            self.add_cleanup(local_branch.lock_write().unlock)
 
5090
            self.enter_context(local_branch.lock_write())
5089
5091
            # handle race conditions - a parent might be set while we run.
5090
5092
            if local_branch.get_parent() is None:
5091
5093
                local_branch.set_parent(remote_branch.base)
5178
5180
            b = Branch.open_containing(branch)[0]
5179
5181
        else:
5180
5182
            b = Branch.open(branch)
5181
 
        self.add_cleanup(b.lock_read().unlock)
 
5183
        self.enter_context(b.lock_read())
5182
5184
        if revision is None:
5183
5185
            rev_id = b.last_revision()
5184
5186
        else:
5221
5223
        wt, branch, relpath = \
5222
5224
            _open_directory_or_containing_tree_or_branch(filename, directory)
5223
5225
        if wt is not None:
5224
 
            self.add_cleanup(wt.lock_read().unlock)
 
5226
            self.enter_context(wt.lock_read())
5225
5227
        else:
5226
 
            self.add_cleanup(branch.lock_read().unlock)
 
5228
            self.enter_context(branch.lock_read())
5227
5229
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
5228
 
        self.add_cleanup(tree.lock_read().unlock)
 
5230
        self.enter_context(tree.lock_read())
5229
5231
        if wt is not None and revision is None:
5230
5232
            if not wt.is_versioned(relpath):
5231
5233
                raise errors.NotVersionedError(relpath)
5256
5258
            raise errors.BzrCommandError(
5257
5259
                gettext('You must supply either --revision or a revision_id'))
5258
5260
        b = WorkingTree.open_containing(directory)[0].branch
5259
 
        self.add_cleanup(b.lock_write().unlock)
 
5261
        self.enter_context(b.lock_write())
5260
5262
        return self._run(b, revision_id_list, revision)
5261
5263
 
5262
5264
    def _run(self, b, revision_id_list, revision):
5402
5404
            b = control.open_branch()
5403
5405
 
5404
5406
        if tree is not None:
5405
 
            self.add_cleanup(tree.lock_write().unlock)
 
5407
            self.enter_context(tree.lock_write())
5406
5408
        else:
5407
 
            self.add_cleanup(b.lock_write().unlock)
 
5409
            self.enter_context(b.lock_write())
5408
5410
        return self._run(b, tree, dry_run, verbose, revision, force,
5409
5411
                         local, keep_tags, location)
5410
5412
 
5987
5989
            revision=None,
5988
5990
            ):
5989
5991
        branch, relpath = Branch.open_containing(directory)
5990
 
        self.add_cleanup(branch.lock_write().unlock)
 
5992
        self.enter_context(branch.lock_write())
5991
5993
        if delete:
5992
5994
            if tag_name is None:
5993
5995
                raise errors.BzrCommandError(
6051
6053
        if not tags:
6052
6054
            return
6053
6055
 
6054
 
        self.add_cleanup(branch.lock_read().unlock)
 
6056
        self.enter_context(branch.lock_read())
6055
6057
        if revision:
6056
6058
            # Restrict to the specified range
6057
6059
            tags = self._tags_for_range(branch, revision)
6568
6570
    editor program to decide what the file remaining in the working copy
6569
6571
    should look like.  To do this, add the configuration option
6570
6572
 
6571
 
        change_editor = PROGRAM @new_path @old_path
 
6573
        change_editor = PROGRAM {new_path} {old_path}
6572
6574
 
6573
 
    where @new_path is replaced with the path of the new version of the
6574
 
    file and @old_path is replaced with the path of the old version of
 
6575
    where {new_path} is replaced with the path of the new version of the
 
6576
    file and {old_path} is replaced with the path of the old version of
6575
6577
    the file.  The PROGRAM should save the new file with the desired
6576
6578
    contents of the file in the working tree.
6577
6579
 
6615
6617
        if directory is None:
6616
6618
            directory = u'.'
6617
6619
        tree = WorkingTree.open_containing(directory)[0]
6618
 
        self.add_cleanup(tree.lock_read().unlock)
 
6620
        self.enter_context(tree.lock_read())
6619
6621
        manager = tree.get_shelf_manager()
6620
6622
        shelves = manager.active_shelves()
6621
6623
        if len(shelves) == 0:
7052
7054
    # be only called once.
7053
7055
    for (name, aliases, module_name) in [
7054
7056
            ('cmd_bisect', [], 'breezy.bisect'),
7055
 
            ('cmd_bundle_info', [], 'breezy.bundle.commands'),
 
7057
            ('cmd_bundle_info', [], 'breezy.bzr.bundle.commands'),
7056
7058
            ('cmd_config', [], 'breezy.config'),
7057
7059
            ('cmd_dump_btree', [], 'breezy.bzr.debug_commands'),
7058
7060
            ('cmd_file_id', [], 'breezy.bzr.debug_commands'),