← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Robert Collins
  • Date: 2005-10-17 23:13:00 UTC
  • mto: This revision was merged to the branch mainline in revision 1462.
  • Revision ID: robertc@robertcollins.net-20051017231300-e1c9e931bcfacd6a
Branch.open_containing now returns a tuple (Branch, relative-path).

This allows direct access to the common case of 'get me this file
from its branch'. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
79
79
    
80
80
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
81
81
        if file_list:
82
 
            b = Branch.open_containing(file_list[0])
83
 
            tree = WorkingTree(b.base, b)
84
 
            file_list = [tree.relpath(x) for x in file_list]
85
 
            # special case: only one path was given and it's the root
86
 
            # of the branch
87
 
            if file_list == ['']:
 
82
            b, relpath = Branch.open_containing(file_list[0])
 
83
            if relpath == '' and len(file_list) == 1:
88
84
                file_list = None
 
85
            else:
 
86
                # generate relative paths.
 
87
                # note that if this is a remote branch, we would want
 
88
                # relpath against the transport. RBC 20051018
 
89
                tree = WorkingTree(b.base, b)
 
90
                file_list = [tree.relpath(x) for x in file_list]
89
91
        else:
90
 
            b = Branch.open_containing('.')
 
92
            b = Branch.open_containing('.')[0]
91
93
            
92
94
        from bzrlib.status import show_status
93
95
        show_status(b, show_unchanged=all, show_ids=show_ids,
111
113
            raise BzrCommandError('You can only supply one of revision_id or --revision')
112
114
        if revision_id is None and revision is None:
113
115
            raise BzrCommandError('You must supply either --revision or a revision_id')
114
 
        b = Branch.open_containing('.')
 
116
        b = Branch.open_containing('.')[0]
115
117
        if revision_id is not None:
116
118
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
117
119
        elif revision is not None:
127
129
 
128
130
    This is equal to the number of revisions on this branch."""
129
131
    def run(self):
130
 
        print Branch.open_containing('.').revno()
 
132
        print Branch.open_containing('.')[0].revno()
131
133
 
132
134
 
133
135
class cmd_revision_info(Command):
147
149
        if len(revs) == 0:
148
150
            raise BzrCommandError('You must supply a revision identifier')
149
151
 
150
 
        b = Branch.open_containing('.')
 
152
        b = Branch.open_containing('.')[0]
151
153
 
152
154
        for rev in revs:
153
155
            revinfo = rev.in_history(b)
205
207
        for d in dir_list:
206
208
            os.mkdir(d)
207
209
            if not b:
208
 
                b = Branch.open_containing(d)
 
210
                b = Branch.open_containing(d)[0]
209
211
            b.add([d])
210
212
            print 'added', d
211
213
 
216
218
    hidden = True
217
219
    
218
220
    def run(self, filename):
219
 
        branch = Branch.open_containing(filename)
220
 
        print WorkingTree(branch.base, branch).relpath(filename)
 
221
        branch, relpath = Branch.open_containing(filename)
 
222
        print relpath
221
223
 
222
224
 
223
225
class cmd_inventory(Command):
225
227
    takes_options = ['revision', 'show-ids']
226
228
    
227
229
    def run(self, revision=None, show_ids=False):
228
 
        b = Branch.open_containing('.')
 
230
        b = Branch.open_containing('.')[0]
229
231
        if revision is None:
230
232
            inv = b.read_working_inventory()
231
233
        else:
251
253
    """
252
254
    takes_args = ['source$', 'dest']
253
255
    def run(self, source_list, dest):
254
 
        b = Branch.open_containing('.')
 
256
        b = Branch.open_containing('.')[0]
255
257
 
256
258
        # TODO: glob expansion on windows?
257
259
        tree = WorkingTree(b.base, b)
275
277
    takes_args = ['from_name', 'to_name']
276
278
    
277
279
    def run(self, from_name, to_name):
278
 
        b = Branch.open_containing('.')
 
280
        b = Branch.open_containing('.')[0]
279
281
        tree = WorkingTree(b.base, b)
280
282
        b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
281
283
 
297
299
    def run(self, names_list):
298
300
        if len(names_list) < 2:
299
301
            raise BzrCommandError("missing file argument")
300
 
        b = Branch.open_containing(names_list[0])
 
302
        b = Branch.open_containing(names_list[0])[0]
301
303
        tree = WorkingTree(b.base, b)
302
304
        rel_names = [tree.relpath(x) for x in names_list]
303
305
        
338
340
        from shutil import rmtree
339
341
        import errno
340
342
        
341
 
        br_to = Branch.open_containing('.')
 
343
        br_to = Branch.open_containing('.')[0]
342
344
        stored_loc = br_to.get_parent()
343
345
        if location is None:
344
346
            if stored_loc is None:
410
412
        try:
411
413
            br_from.setup_caching(cache_root)
412
414
            if basis is not None:
413
 
                basis_branch = Branch.open_containing(basis)
 
415
                basis_branch = Branch.open_containing(basis)[0]
414
416
            else:
415
417
                basis_branch = None
416
418
            if len(revision) == 1 and revision[0] is not None:
452
454
    takes_args = ['dir?']
453
455
 
454
456
    def run(self, dir='.'):
455
 
        b = Branch.open_containing(dir)
 
457
        b = Branch.open_containing(dir)[0]
456
458
        old_inv = b.basis_tree().inventory
457
459
        new_inv = b.read_working_inventory()
458
460
 
468
470
    
469
471
    def run(self, branch=None):
470
472
        import info
471
 
        b = Branch.open_containing(branch)
 
473
        b = Branch.open_containing(branch)[0]
472
474
        info.show_info(b)
473
475
 
474
476
 
483
485
    aliases = ['rm']
484
486
    
485
487
    def run(self, file_list, verbose=False):
486
 
        b = Branch.open_containing(file_list[0])
 
488
        b = Branch.open_containing(file_list[0])[0]
487
489
        tree = WorkingTree(b.base, b)
488
490
        b.remove([tree.relpath(f) for f in file_list], verbose=verbose)
489
491
 
498
500
    hidden = True
499
501
    takes_args = ['filename']
500
502
    def run(self, filename):
501
 
        b = Branch.open_containing(filename)
502
 
        tree = WorkingTree(b.base, b)
503
 
        i = b.inventory.path2id(tree.relpath(filename))
 
503
        b, relpath = Branch.open_containing(filename)
 
504
        i = b.inventory.path2id(relpath)
504
505
        if i == None:
505
506
            raise BzrError("%r is not a versioned file" % filename)
506
507
        else:
515
516
    hidden = True
516
517
    takes_args = ['filename']
517
518
    def run(self, filename):
518
 
        b = Branch.open_containing(filename)
 
519
        b, relpath = Branch.open_containing(filename)
519
520
        inv = b.inventory
520
 
        tree = WorkingTree(b.base, b)
521
 
        fid = inv.path2id(tree.relpath(filename))
 
521
        fid = inv.path2id(relpath)
522
522
        if fid == None:
523
523
            raise BzrError("%r is not a versioned file" % filename)
524
524
        for fip in inv.get_idpath(fid):
529
529
    """Display list of revision ids on this branch."""
530
530
    hidden = True
531
531
    def run(self):
532
 
        for patchid in Branch.open_containing('.').revision_history():
 
532
        for patchid in Branch.open_containing('.')[0].revision_history():
533
533
            print patchid
534
534
 
535
535
 
545
545
class cmd_directories(Command):
546
546
    """Display list of versioned directories in this branch."""
547
547
    def run(self):
548
 
        for name, ie in Branch.open_containing('.').read_working_inventory().directories():
 
548
        for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
549
549
            if name == '':
550
550
                print '.'
551
551
            else:
602
602
        from bzrlib.diff import show_diff
603
603
 
604
604
        if file_list:
605
 
            b = Branch.open_containing(file_list[0])
 
605
            b = Branch.open_containing(file_list[0])[0]
606
606
            tree = WorkingTree(b.base, b)
607
607
            file_list = [tree.relpath(f) for f in file_list]
608
608
            if file_list == ['']:
609
609
                # just pointing to top-of-tree
610
610
                file_list = None
611
611
        else:
612
 
            b = Branch.open_containing('.')
 
612
            b = Branch.open_containing('.')[0]
613
613
 
614
614
        if revision is not None:
615
615
            if len(revision) == 1:
638
638
    # level of effort but possibly much less IO.  (Or possibly not,
639
639
    # if the directories are very large...)
640
640
    def run(self, show_ids=False):
641
 
        b = Branch.open_containing('.')
 
641
        b = Branch.open_containing('.')[0]
642
642
        old = b.basis_tree()
643
643
        new = b.working_tree()
644
644
        for path, ie in old.inventory.iter_entries():
655
655
    def run(self):
656
656
        from bzrlib.delta import compare_trees
657
657
 
658
 
        b = Branch.open_containing('.')
 
658
        b = Branch.open_containing('.')[0]
659
659
        td = compare_trees(b.basis_tree(), b.working_tree())
660
660
 
661
661
        for path, id, kind, text_modified, meta_modified in td.modified:
667
667
    """List files added in working tree."""
668
668
    hidden = True
669
669
    def run(self):
670
 
        b = Branch.open_containing('.')
 
670
        b = Branch.open_containing('.')[0]
671
671
        wt = b.working_tree()
672
672
        basis_inv = b.basis_tree().inventory
673
673
        inv = wt.inventory
689
689
    takes_args = ['filename?']
690
690
    def run(self, filename=None):
691
691
        """Print the branch root."""
692
 
        b = Branch.open_containing(filename)
 
692
        b = Branch.open_containing(filename)[0]
693
693
        print b.base
694
694
 
695
695
 
732
732
        direction = (forward and 'forward') or 'reverse'
733
733
        
734
734
        if filename:
735
 
            b = Branch.open_containing(filename)
736
 
            tree = WorkingTree(b.base, b)
737
 
            fp = tree.relpath(filename)
738
 
            if fp:
 
735
            b, fp = Branch.open_containing(filename)
 
736
            if fp != '':
739
737
                file_id = b.read_working_inventory().path2id(fp)
740
738
            else:
741
739
                file_id = None  # points to branch root
742
740
        else:
743
 
            b = Branch.open_containing('.')
 
741
            b, relpath = Branch.open_containing('.')
744
742
            file_id = None
745
743
 
746
744
        if revision is None:
793
791
    hidden = True
794
792
    takes_args = ["filename"]
795
793
    def run(self, filename):
796
 
        b = Branch.open_containing(filename)
 
794
        b, relpath = Branch.open_containing(filename)[0]
797
795
        inv = b.read_working_inventory()
798
 
        tree = WorkingTree(b.base, b)
799
 
        file_id = inv.path2id(tree.relpath(filename))
 
796
        file_id = inv.path2id(relpath)
800
797
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
801
798
            print "%6d %s" % (revno, what)
802
799
 
807
804
    # TODO: Take a revision or remote path and list that tree instead.
808
805
    hidden = True
809
806
    def run(self, revision=None, verbose=False):
810
 
        b = Branch.open_containing('.')
 
807
        b, relpath = Branch.open_containing('.')[0]
811
808
        if revision == None:
812
809
            tree = b.working_tree()
813
810
        else:
825
822
    """List unknown files."""
826
823
    def run(self):
827
824
        from bzrlib.osutils import quotefn
828
 
        for f in Branch.open_containing('.').unknowns():
 
825
        for f in Branch.open_containing('.')[0].unknowns():
829
826
            print quotefn(f)
830
827
 
831
828
 
855
852
        from bzrlib.atomicfile import AtomicFile
856
853
        import os.path
857
854
 
858
 
        b = Branch.open_containing('.')
 
855
        b, relpath = Branch.open_containing('.')
859
856
        ifn = b.abspath('.bzrignore')
860
857
 
861
858
        if os.path.exists(ifn):
895
892
 
896
893
    See also: bzr ignore"""
897
894
    def run(self):
898
 
        tree = Branch.open_containing('.').working_tree()
 
895
        tree = Branch.open_containing('.')[0].working_tree()
899
896
        for path, file_class, kind, file_id, entry in tree.list_files():
900
897
            if file_class != 'I':
901
898
                continue
919
916
        except ValueError:
920
917
            raise BzrCommandError("not a valid revision-number: %r" % revno)
921
918
 
922
 
        print Branch.open_containing('.').get_rev_id(revno)
 
919
        print Branch.open_containing('.')[0].get_rev_id(revno)
923
920
 
924
921
 
925
922
class cmd_export(Command):
938
935
    takes_options = ['revision', 'format', 'root']
939
936
    def run(self, dest, revision=None, format=None, root=None):
940
937
        import os.path
941
 
        b = Branch.open_containing('.')
 
938
        b = Branch.open_containing('.')[0]
942
939
        if revision is None:
943
940
            rev_id = b.last_revision()
944
941
        else:
977
974
            raise BzrCommandError("bzr cat requires a revision number")
978
975
        elif len(revision) != 1:
979
976
            raise BzrCommandError("bzr cat --revision takes exactly one number")
980
 
        b = Branch.open_containing('.')
981
 
        tree = WorkingTree(b.base, b)
982
 
        b.print_file(tree.relpath(filename), revision[0].in_history(b).revno)
 
977
        b, relpath = Branch.open_containing(filename)
 
978
        b.print_file(relpath, revision[0].in_history(b).revno)
983
979
 
984
980
 
985
981
class cmd_local_time_offset(Command):
1027
1023
        from bzrlib.status import show_status
1028
1024
        from cStringIO import StringIO
1029
1025
 
1030
 
        b = Branch.open_containing('.')
 
1026
        b = Branch.open_containing('.')[0]
1031
1027
        tree = WorkingTree(b.base, b)
1032
1028
        if selected_list:
1033
1029
            selected_list = [tree.relpath(s) for s in selected_list]
1075
1071
 
1076
1072
    def run(self, dir='.', verbose=False):
1077
1073
        from bzrlib.check import check
1078
 
        check(Branch.open_containing(dir), verbose)
 
1074
        check(Branch.open_containing(dir)[0], verbose)
1079
1075
 
1080
1076
 
1081
1077
class cmd_scan_cache(Command):
1120
1116
    
1121
1117
    def run(self, email=False):
1122
1118
        try:
1123
 
            b = bzrlib.branch.Branch.open_containing('.')
 
1119
            b = bzrlib.branch.Branch.open_containing('.')[0]
1124
1120
            config = bzrlib.config.BranchConfig(b)
1125
1121
        except NotBranchError:
1126
1122
            config = bzrlib.config.GlobalConfig()
1212
1208
    def run(self, branch, other):
1213
1209
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
1214
1210
        
1215
 
        branch1 = Branch.open_containing(branch)
1216
 
        branch2 = Branch.open_containing(other)
 
1211
        branch1 = Branch.open_containing(branch)[0]
 
1212
        branch2 = Branch.open_containing(other)[0]
1217
1213
 
1218
1214
        history_1 = branch1.revision_history()
1219
1215
        history_2 = branch2.revision_history()
1277
1273
        if merge_type is None:
1278
1274
            merge_type = ApplyMerge3
1279
1275
        if branch is None:
1280
 
            branch = Branch.open_containing('.').get_parent()
 
1276
            branch = Branch.open_containing('.')[0].get_parent()
1281
1277
            if branch is None:
1282
1278
                raise BzrCommandError("No merge location known or specified.")
1283
1279
            else:
1334
1330
        elif len(revision) != 1:
1335
1331
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1336
1332
        else:
1337
 
            b = Branch.open_containing('.')
 
1333
            b = Branch.open_containing('.')[0]
1338
1334
            revno = revision[0].in_history(b).revno
1339
1335
        merge(('.', revno), parse_spec('.'),
1340
1336
              check_clean=False,
1342
1338
              backup_files=not no_backup,
1343
1339
              file_list=file_list)
1344
1340
        if not file_list:
1345
 
            Branch.open_containing('.').set_pending_merges([])
 
1341
            Branch.open_containing('.')[0].set_pending_merges([])
1346
1342
 
1347
1343
 
1348
1344
class cmd_assert_fail(Command):
1414
1410
        if verbose and quiet:
1415
1411
            raise BzrCommandError('Cannot pass both quiet and verbose')
1416
1412
 
1417
 
        b = Branch.open_containing('.')
 
1413
        b = Branch.open_containing('.')[0]
1418
1414
        parent = b.get_parent()
1419
1415
        if remote is None:
1420
1416
            if parent is None:
1427
1423
            # We only update parent if it did not exist, missing
1428
1424
            # should not change the parent
1429
1425
            b.set_parent(remote)
1430
 
        br_remote = Branch.open_containing(remote)
 
1426
        br_remote = Branch.open_containing(remote)[0]
1431
1427
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1432
1428
 
1433
1429
 
1456
1452
    takes_args = ['branch?']
1457
1453
    def run(self, branch='.', revision=None, long=False):
1458
1454
        from bzrlib.testament import Testament
1459
 
        b = Branch.open_containing(branch)
 
1455
        b = Branch.open_containing(branch)[0]
1460
1456
        b.lock_read()
1461
1457
        try:
1462
1458
            if revision is None:
1493
1489
 
1494
1490
    def run(self, filename, all=False, long=False):
1495
1491
        from bzrlib.annotate import annotate_file
1496
 
        b = Branch.open_containing(filename)
 
1492
        b, relpath = Branch.open_containing(filename)
1497
1493
        b.lock_read()
1498
1494
        try:
1499
1495
            tree = WorkingTree(b.base, b)
1500
 
            rp = tree.relpath(filename)
1501
1496
            tree = b.revision_tree(b.last_revision())
1502
 
            file_id = tree.inventory.path2id(rp)
 
1497
            file_id = tree.inventory.path2id(relpath)
1503
1498
            file_version = tree.inventory[file_id].revision
1504
1499
            annotate_file(b, file_version, file_id, long, all, sys.stdout)
1505
1500
        finally:
1521
1516
            raise BzrCommandError('You can only supply one of revision_id or --revision')
1522
1517
        if revision_id is None and revision is None:
1523
1518
            raise BzrCommandError('You must supply either --revision or a revision_id')
1524
 
        b = Branch.open_containing('.')
 
1519
        b = Branch.open_containing('.')[0]
1525
1520
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1526
1521
        if revision_id is not None:
1527
1522
            b.sign_revision(revision_id, gpg_strategy)