/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 bzrlib/builtins.py

Only chown() the .bzr.log when creating it, fixing NEWS entry to put it under 2.2b3

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
504
504
                if (working.has_changes()):
505
505
                    raise errors.UncommittedChanges(working)
506
506
 
507
 
            if working.user_url != working.branch.user_url:
 
507
            working_path = working.bzrdir.root_transport.base
 
508
            branch_path = working.branch.bzrdir.root_transport.base
 
509
            if working_path != branch_path:
508
510
                raise errors.BzrCommandError("You cannot remove the working tree"
509
511
                                             " from a lightweight checkout")
510
512
 
528
530
        if tree:
529
531
            try:
530
532
                wt = WorkingTree.open_containing(location)[0]
531
 
                self.add_cleanup(wt.lock_read().unlock)
 
533
                wt.lock_read()
532
534
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
535
                raise errors.NoWorkingTree(location)
 
536
            self.add_cleanup(wt.unlock)
534
537
            revid = wt.last_revision()
535
538
            try:
536
539
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
539
542
            revno = ".".join(str(n) for n in revno_t)
540
543
        else:
541
544
            b = Branch.open_containing(location)[0]
542
 
            self.add_cleanup(b.lock_read().unlock)
 
545
            b.lock_read()
 
546
            self.add_cleanup(b.unlock)
543
547
            revno = b.revno()
544
548
        self.cleanup_now()
545
549
        self.outf.write(str(revno) + '\n')
568
572
        try:
569
573
            wt = WorkingTree.open_containing(directory)[0]
570
574
            b = wt.branch
571
 
            self.add_cleanup(wt.lock_read().unlock)
 
575
            wt.lock_read()
 
576
            self.add_cleanup(wt.unlock)
572
577
        except (errors.NoWorkingTree, errors.NotLocalUrl):
573
578
            wt = None
574
579
            b = Branch.open_containing(directory)[0]
575
 
            self.add_cleanup(b.lock_read().unlock)
 
580
            b.lock_read()
 
581
            self.add_cleanup(b.unlock)
576
582
        revision_ids = []
577
583
        if revision is not None:
578
584
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
677
683
                should_print=(not is_quiet()))
678
684
 
679
685
        if base_tree:
680
 
            self.add_cleanup(base_tree.lock_read().unlock)
 
686
            base_tree.lock_read()
 
687
            self.add_cleanup(base_tree.unlock)
681
688
        tree, file_list = tree_files_for_add(file_list)
682
689
        added, ignored = tree.smart_add(file_list, not
683
690
            no_recurse, action=action, save=not dry_run)
755
762
 
756
763
        revision = _get_one_revision('inventory', revision)
757
764
        work_tree, file_list = tree_files(file_list)
758
 
        self.add_cleanup(work_tree.lock_read().unlock)
 
765
        work_tree.lock_read()
 
766
        self.add_cleanup(work_tree.unlock)
759
767
        if revision is not None:
760
768
            tree = revision.as_tree(work_tree.branch)
761
769
 
762
770
            extra_trees = [work_tree]
763
 
            self.add_cleanup(tree.lock_read().unlock)
 
771
            tree.lock_read()
 
772
            self.add_cleanup(tree.unlock)
764
773
        else:
765
774
            tree = work_tree
766
775
            extra_trees = []
826
835
        if len(names_list) < 2:
827
836
            raise errors.BzrCommandError("missing file argument")
828
837
        tree, rel_names = tree_files(names_list, canonicalize=False)
829
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
838
        tree.lock_tree_write()
 
839
        self.add_cleanup(tree.unlock)
830
840
        self._run(tree, names_list, rel_names, after)
831
841
 
832
842
    def run_auto(self, names_list, after, dry_run):
837
847
            raise errors.BzrCommandError('--after cannot be specified with'
838
848
                                         ' --auto.')
839
849
        work_tree, file_list = tree_files(names_list, default_branch='.')
840
 
        self.add_cleanup(work_tree.lock_tree_write().unlock)
 
850
        work_tree.lock_tree_write()
 
851
        self.add_cleanup(work_tree.unlock)
841
852
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
842
853
 
843
854
    def _run(self, tree, names_list, rel_names, after):
977
988
        try:
978
989
            tree_to = WorkingTree.open_containing(directory)[0]
979
990
            branch_to = tree_to.branch
980
 
            self.add_cleanup(tree_to.lock_write().unlock)
 
991
            tree_to.lock_write()
 
992
            self.add_cleanup(tree_to.unlock)
981
993
        except errors.NoWorkingTree:
982
994
            tree_to = None
983
995
            branch_to = Branch.open_containing(directory)[0]
984
 
            self.add_cleanup(branch_to.lock_write().unlock)
 
996
            branch_to.lock_write()
 
997
            self.add_cleanup(branch_to.unlock)
985
998
 
986
999
        if local and not branch_to.get_bound_location():
987
1000
            raise errors.LocalRequiresBoundBranch()
1018
1031
        else:
1019
1032
            branch_from = Branch.open(location,
1020
1033
                possible_transports=possible_transports)
1021
 
            self.add_cleanup(branch_from.lock_read().unlock)
 
1034
            branch_from.lock_read()
 
1035
            self.add_cleanup(branch_from.unlock)
1022
1036
 
1023
1037
            if branch_to.get_parent() is None or remember:
1024
1038
                branch_to.set_parent(branch_from.base)
1120
1134
        else:
1121
1135
            revision_id = None
1122
1136
        if tree is not None and revision_id is None:
1123
 
            tree.check_changed_or_out_of_date(
1124
 
                strict, 'push_strict',
1125
 
                more_error='Use --no-strict to force the push.',
1126
 
                more_warning='Uncommitted changes will not be pushed.')
 
1137
            tree.warn_if_changed_or_out_of_date(
 
1138
                strict, 'push_strict', 'Use --no-strict to force the push.')
1127
1139
        # Get the stacked_on branch, if any
1128
1140
        if stacked_on is not None:
1129
1141
            stacked_on = urlutils.normalize_url(stacked_on)
1207
1219
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
1220
            from_location)
1209
1221
        revision = _get_one_revision('branch', revision)
1210
 
        self.add_cleanup(br_from.lock_read().unlock)
 
1222
        br_from.lock_read()
 
1223
        self.add_cleanup(br_from.unlock)
1211
1224
        if revision is not None:
1212
1225
            revision_id = revision.as_revision_id(br_from)
1213
1226
        else:
1353
1366
    @display_command
1354
1367
    def run(self, dir=u'.'):
1355
1368
        tree = WorkingTree.open_containing(dir)[0]
1356
 
        self.add_cleanup(tree.lock_read().unlock)
 
1369
        tree.lock_read()
 
1370
        self.add_cleanup(tree.unlock)
1357
1371
        new_inv = tree.inventory
1358
1372
        old_tree = tree.basis_tree()
1359
 
        self.add_cleanup(old_tree.lock_read().unlock)
 
1373
        old_tree.lock_read()
 
1374
        self.add_cleanup(old_tree.unlock)
1360
1375
        old_inv = old_tree.inventory
1361
1376
        renames = []
1362
1377
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1400
1415
        master = branch.get_master_branch(
1401
1416
            possible_transports=possible_transports)
1402
1417
        if master is not None:
 
1418
            tree.lock_write()
1403
1419
            branch_location = master.base
1404
 
            tree.lock_write()
1405
1420
        else:
 
1421
            tree.lock_tree_write()
1406
1422
            branch_location = tree.branch.base
1407
 
            tree.lock_tree_write()
1408
1423
        self.add_cleanup(tree.unlock)
1409
1424
        # get rid of the final '/' and be ready for display
1410
1425
        branch_location = urlutils.unescape_for_display(
1530
1545
        if file_list is not None:
1531
1546
            file_list = [f for f in file_list]
1532
1547
 
1533
 
        self.add_cleanup(tree.lock_write().unlock)
 
1548
        tree.lock_write()
 
1549
        self.add_cleanup(tree.unlock)
1534
1550
        # Heuristics should probably all move into tree.remove_smart or
1535
1551
        # some such?
1536
1552
        if new:
1992
2008
    @display_command
1993
2009
    def run(self, show_ids=False):
1994
2010
        tree = WorkingTree.open_containing(u'.')[0]
1995
 
        self.add_cleanup(tree.lock_read().unlock)
 
2011
        tree.lock_read()
 
2012
        self.add_cleanup(tree.unlock)
1996
2013
        old = tree.basis_tree()
1997
 
        self.add_cleanup(old.lock_read().unlock)
 
2014
        old.lock_read()
 
2015
        self.add_cleanup(old.unlock)
1998
2016
        for path, ie in old.inventory.iter_entries():
1999
2017
            if not tree.has_id(ie.file_id):
2000
2018
                self.outf.write(path)
2042
2060
    @display_command
2043
2061
    def run(self, null=False):
2044
2062
        wt = WorkingTree.open_containing(u'.')[0]
2045
 
        self.add_cleanup(wt.lock_read().unlock)
 
2063
        wt.lock_read()
 
2064
        self.add_cleanup(wt.unlock)
2046
2065
        basis = wt.basis_tree()
2047
 
        self.add_cleanup(basis.lock_read().unlock)
 
2066
        basis.lock_read()
 
2067
        self.add_cleanup(basis.unlock)
2048
2068
        basis_inv = basis.inventory
2049
2069
        inv = wt.inventory
2050
2070
        for file_id in inv:
2279
2299
                   help='Show changes made in each revision as a patch.'),
2280
2300
            Option('include-merges',
2281
2301
                   help='Show merged revisions like --levels 0 does.'),
2282
 
            Option('exclude-common-ancestry',
2283
 
                   help='Display only the revisions that are not part'
2284
 
                   ' of both ancestries (require -rX..Y)'
2285
 
                   )
2286
2302
            ]
2287
2303
    encoding_type = 'replace'
2288
2304
 
2298
2314
            message=None,
2299
2315
            limit=None,
2300
2316
            show_diff=False,
2301
 
            include_merges=False,
2302
 
            exclude_common_ancestry=False,
2303
 
            ):
 
2317
            include_merges=False):
2304
2318
        from bzrlib.log import (
2305
2319
            Logger,
2306
2320
            make_log_request_dict,
2307
2321
            _get_info_for_log_files,
2308
2322
            )
2309
2323
        direction = (forward and 'forward') or 'reverse'
2310
 
        if (exclude_common_ancestry
2311
 
            and (revision is None or len(revision) != 2)):
2312
 
            raise errors.BzrCommandError(
2313
 
                '--exclude-common-ancestry requires -r with two revisions')
2314
2324
        if include_merges:
2315
2325
            if levels is None:
2316
2326
                levels = 0
2332
2342
        if file_list:
2333
2343
            # find the file ids to log and check for directory filtering
2334
2344
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
 
                revision, file_list, self.add_cleanup)
 
2345
                revision, file_list)
 
2346
            self.add_cleanup(b.unlock)
2336
2347
            for relpath, file_id, kind in file_info_list:
2337
2348
                if file_id is None:
2338
2349
                    raise errors.BzrCommandError(
2356
2367
                location = '.'
2357
2368
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2358
2369
            b = dir.open_branch()
2359
 
            self.add_cleanup(b.lock_read().unlock)
 
2370
            b.lock_read()
 
2371
            self.add_cleanup(b.unlock)
2360
2372
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2373
 
2362
2374
        # Decide on the type of delta & diff filtering to use
2407
2419
            direction=direction, specific_fileids=file_ids,
2408
2420
            start_revision=rev1, end_revision=rev2, limit=limit,
2409
2421
            message_search=message, delta_type=delta_type,
2410
 
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2411
 
            exclude_common_ancestry=exclude_common_ancestry,
2412
 
            )
 
2422
            diff_type=diff_type, _match_using_deltas=match_using_deltas)
2413
2423
        Logger(b, rqst).show(lf)
2414
2424
 
2415
2425
 
2486
2496
        tree, relpath = WorkingTree.open_containing(filename)
2487
2497
        file_id = tree.path2id(relpath)
2488
2498
        b = tree.branch
2489
 
        self.add_cleanup(b.lock_read().unlock)
 
2499
        b.lock_read()
 
2500
        self.add_cleanup(b.unlock)
2490
2501
        touching_revs = log.find_touching_revisions(b, file_id)
2491
2502
        for revno, revision_id, what in touching_revs:
2492
2503
            self.outf.write("%6d %s\n" % (revno, what))
2561
2572
                view_str = views.view_display_str(view_files)
2562
2573
                note("Ignoring files outside view. View is %s" % view_str)
2563
2574
 
2564
 
        self.add_cleanup(tree.lock_read().unlock)
 
2575
        tree.lock_read()
 
2576
        self.add_cleanup(tree.unlock)
2565
2577
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
2578
            from_dir=relpath, recursive=recursive):
2567
2579
            # Apply additional masking
2746
2758
    @display_command
2747
2759
    def run(self):
2748
2760
        tree = WorkingTree.open_containing(u'.')[0]
2749
 
        self.add_cleanup(tree.lock_read().unlock)
 
2761
        tree.lock_read()
 
2762
        self.add_cleanup(tree.unlock)
2750
2763
        for path, file_class, kind, file_id, entry in tree.list_files():
2751
2764
            if file_class != 'I':
2752
2765
                continue
2865
2878
                                         " one revision specifier")
2866
2879
        tree, branch, relpath = \
2867
2880
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
 
        self.add_cleanup(branch.lock_read().unlock)
 
2881
        branch.lock_read()
 
2882
        self.add_cleanup(branch.unlock)
2869
2883
        return self._run(tree, branch, relpath, filename, revision,
2870
2884
                         name_from_revision, filters)
2871
2885
 
2874
2888
        if tree is None:
2875
2889
            tree = b.basis_tree()
2876
2890
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
 
        self.add_cleanup(rev_tree.lock_read().unlock)
 
2891
        rev_tree.lock_read()
 
2892
        self.add_cleanup(rev_tree.unlock)
2878
2893
 
2879
2894
        old_file_id = rev_tree.path2id(relpath)
2880
2895
 
3046
3061
                         "the master branch until a normal commit "
3047
3062
                         "is performed."
3048
3063
                    ),
3049
 
             Option('show-diff', short_name='p',
 
3064
             Option('show-diff',
3050
3065
                    help='When no message is supplied, show the diff along'
3051
3066
                    ' with the status summary in the message editor.'),
3052
3067
             ]
3663
3678
 
3664
3679
        branch1 = Branch.open_containing(branch)[0]
3665
3680
        branch2 = Branch.open_containing(other)[0]
3666
 
        self.add_cleanup(branch1.lock_read().unlock)
3667
 
        self.add_cleanup(branch2.lock_read().unlock)
 
3681
        branch1.lock_read()
 
3682
        self.add_cleanup(branch1.unlock)
 
3683
        branch2.lock_read()
 
3684
        self.add_cleanup(branch2.unlock)
3668
3685
        last1 = ensure_null(branch1.last_revision())
3669
3686
        last2 = ensure_null(branch2.last_revision())
3670
3687
 
3808
3825
            unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3826
        pb = ui.ui_factory.nested_progress_bar()
3810
3827
        self.add_cleanup(pb.finished)
3811
 
        self.add_cleanup(tree.lock_write().unlock)
 
3828
        tree.lock_write()
 
3829
        self.add_cleanup(tree.unlock)
3812
3830
        if location is not None:
3813
3831
            try:
3814
3832
                mergeable = bundle.read_mergeable_from_url(location,
4070
4088
        if merge_type is None:
4071
4089
            merge_type = _mod_merge.Merge3Merger
4072
4090
        tree, file_list = tree_files(file_list)
4073
 
        self.add_cleanup(tree.lock_write().unlock)
 
4091
        tree.lock_write()
 
4092
        self.add_cleanup(tree.unlock)
4074
4093
        parents = tree.get_parent_ids()
4075
4094
        if len(parents) != 2:
4076
4095
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4186
4205
    def run(self, revision=None, no_backup=False, file_list=None,
4187
4206
            forget_merges=None):
4188
4207
        tree, file_list = tree_files(file_list)
4189
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
4208
        tree.lock_tree_write()
 
4209
        self.add_cleanup(tree.unlock)
4190
4210
        if forget_merges:
4191
4211
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4212
        else:
4328
4348
            restrict = 'remote'
4329
4349
 
4330
4350
        local_branch = Branch.open_containing(u".")[0]
4331
 
        self.add_cleanup(local_branch.lock_read().unlock)
 
4351
        local_branch.lock_read()
 
4352
        self.add_cleanup(local_branch.unlock)
4332
4353
 
4333
4354
        parent = local_branch.get_parent()
4334
4355
        if other_branch is None:
4345
4366
        if remote_branch.base == local_branch.base:
4346
4367
            remote_branch = local_branch
4347
4368
        else:
4348
 
            self.add_cleanup(remote_branch.lock_read().unlock)
 
4369
            remote_branch.lock_read()
 
4370
            self.add_cleanup(remote_branch.unlock)
4349
4371
 
4350
4372
        local_revid_range = _revision_range_to_revid_range(
4351
4373
            _get_revision_range(my_revision, local_branch,
4406
4428
            message("Branches are up to date.\n")
4407
4429
        self.cleanup_now()
4408
4430
        if not status_code and parent is None and other_branch is not None:
4409
 
            self.add_cleanup(local_branch.lock_write().unlock)
 
4431
            local_branch.lock_write()
 
4432
            self.add_cleanup(local_branch.unlock)
4410
4433
            # handle race conditions - a parent might be set while we run.
4411
4434
            if local_branch.get_parent() is None:
4412
4435
                local_branch.set_parent(remote_branch.base)
4512
4535
            b = Branch.open_containing(branch)[0]
4513
4536
        else:
4514
4537
            b = Branch.open(branch)
4515
 
        self.add_cleanup(b.lock_read().unlock)
 
4538
        b.lock_read()
 
4539
        self.add_cleanup(b.unlock)
4516
4540
        if revision is None:
4517
4541
            rev_id = b.last_revision()
4518
4542
        else:
4552
4576
        wt, branch, relpath = \
4553
4577
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4578
        if wt is not None:
4555
 
            self.add_cleanup(wt.lock_read().unlock)
 
4579
            wt.lock_read()
 
4580
            self.add_cleanup(wt.unlock)
4556
4581
        else:
4557
 
            self.add_cleanup(branch.lock_read().unlock)
 
4582
            branch.lock_read()
 
4583
            self.add_cleanup(branch.unlock)
4558
4584
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
 
        self.add_cleanup(tree.lock_read().unlock)
 
4585
        tree.lock_read()
 
4586
        self.add_cleanup(tree.unlock)
4560
4587
        if wt is not None:
4561
4588
            file_id = wt.path2id(relpath)
4562
4589
        else:
4588
4615
        if revision_id_list is None and revision is None:
4589
4616
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4617
        b = WorkingTree.open_containing(u'.')[0].branch
4591
 
        self.add_cleanup(b.lock_write().unlock)
 
4618
        b.lock_write()
 
4619
        self.add_cleanup(b.unlock)
4592
4620
        return self._run(b, revision_id_list, revision)
4593
4621
 
4594
4622
    def _run(self, b, revision_id_list, revision):
4641
4669
 
4642
4670
class cmd_bind(Command):
4643
4671
    __doc__ = """Convert the current branch into a checkout of the supplied branch.
4644
 
    If no branch is supplied, rebind to the last bound location.
4645
4672
 
4646
4673
    Once converted into a checkout, commits must succeed on the master branch
4647
4674
    before they will be applied to the local branch.
4744
4771
            b = control.open_branch()
4745
4772
 
4746
4773
        if tree is not None:
4747
 
            self.add_cleanup(tree.lock_write().unlock)
 
4774
            tree.lock_write()
 
4775
            self.add_cleanup(tree.unlock)
4748
4776
        else:
4749
 
            self.add_cleanup(b.lock_write().unlock)
 
4777
            b.lock_write()
 
4778
            self.add_cleanup(b.unlock)
4750
4779
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4780
 
4752
4781
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
5315
5344
            revision=None,
5316
5345
            ):
5317
5346
        branch, relpath = Branch.open_containing(directory)
5318
 
        self.add_cleanup(branch.lock_write().unlock)
 
5347
        branch.lock_write()
 
5348
        self.add_cleanup(branch.unlock)
5319
5349
        if delete:
5320
5350
            if tag_name is None:
5321
5351
                raise errors.BzrCommandError("No tag specified to delete.")
5376
5406
        if not tags:
5377
5407
            return
5378
5408
 
5379
 
        self.add_cleanup(branch.lock_read().unlock)
 
5409
        branch.lock_read()
 
5410
        self.add_cleanup(branch.unlock)
5380
5411
        if revision:
5381
5412
            graph = branch.repository.get_graph()
5382
5413
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5860
5891
 
5861
5892
    def run_for_list(self):
5862
5893
        tree = WorkingTree.open_containing('.')[0]
5863
 
        self.add_cleanup(tree.lock_read().unlock)
 
5894
        tree.lock_read()
 
5895
        self.add_cleanup(tree.unlock)
5864
5896
        manager = tree.get_shelf_manager()
5865
5897
        shelves = manager.active_shelves()
5866
5898
        if len(shelves) == 0: