← 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-09-28 05:25:54 UTC
  • mfrom: (1185.1.42)
  • mto: (1092.2.18)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20050928052554-beb985505f77ea6a
update symlink branch to integration

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
22
22
import bzrlib.trace
23
23
from bzrlib.trace import mutter, note, log_error, warning
24
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
25
 
from bzrlib.branch import find_branch
 
25
from bzrlib.branch import Branch
26
26
from bzrlib import BZRDIR
27
27
from bzrlib.commands import Command
28
28
 
62
62
    directory is shown.  Otherwise, only the status of the specified
63
63
    files or directories is reported.  If a directory is given, status
64
64
    is reported for everything inside that directory.
 
65
 
 
66
    If a revision argument is given, the status is calculated against
 
67
    that revision, or between two revisions if two are provided.
65
68
    """
 
69
    # XXX: FIXME: bzr status should accept a -r option to show changes
 
70
    # relative to a revision, or between revisions
66
71
 
67
72
    takes_args = ['file*']
68
73
    takes_options = ['all', 'show-ids']
69
74
    aliases = ['st', 'stat']
70
75
    
71
 
    def run(self, all=False, show_ids=False, file_list=None):
 
76
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
72
77
        if file_list:
73
 
            b = find_branch(file_list[0])
 
78
            b = Branch.open_containing(file_list[0])
74
79
            file_list = [b.relpath(x) for x in file_list]
75
80
            # special case: only one path was given and it's the root
76
81
            # of the branch
77
82
            if file_list == ['']:
78
83
                file_list = None
79
84
        else:
80
 
            b = find_branch('.')
 
85
            b = Branch.open_containing('.')
81
86
            
82
87
        from bzrlib.status import show_status
83
88
        show_status(b, show_unchanged=all, show_ids=show_ids,
84
 
                    specific_files=file_list)
 
89
                    specific_files=file_list, revision=revision)
85
90
 
86
91
 
87
92
class cmd_cat_revision(Command):
88
 
    """Write out metadata for a revision."""
 
93
    """Write out metadata for a revision.
 
94
    
 
95
    The revision to print can either be specified by a specific
 
96
    revision identifier, or you can use --revision.
 
97
    """
89
98
 
90
99
    hidden = True
91
 
    takes_args = ['revision_id']
 
100
    takes_args = ['revision_id?']
 
101
    takes_options = ['revision']
92
102
    
93
 
    def run(self, revision_id):
94
 
        b = find_branch('.')
95
 
        sys.stdout.write(b.get_revision_xml_file(revision_id).read())
 
103
    def run(self, revision_id=None, revision=None):
 
104
        from bzrlib.revisionspec import RevisionSpec
96
105
 
 
106
        if revision_id is not None and revision is not None:
 
107
            raise BzrCommandError('You can only supply one of revision_id or --revision')
 
108
        if revision_id is None and revision is None:
 
109
            raise BzrCommandError('You must supply either --revision or a revision_id')
 
110
        b = Branch.open_containing('.')
 
111
        if revision_id is not None:
 
112
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
 
113
        elif revision is not None:
 
114
            for rev in revision:
 
115
                if rev is None:
 
116
                    raise BzrCommandError('You cannot specify a NULL revision.')
 
117
                revno, rev_id = rev.in_history(b)
 
118
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
 
119
    
97
120
 
98
121
class cmd_revno(Command):
99
122
    """Show current revision number.
100
123
 
101
124
    This is equal to the number of revisions on this branch."""
102
125
    def run(self):
103
 
        print find_branch('.').revno()
 
126
        print Branch.open_containing('.').revno()
104
127
 
105
128
 
106
129
class cmd_revision_info(Command):
109
132
    hidden = True
110
133
    takes_args = ['revision_info*']
111
134
    takes_options = ['revision']
112
 
    def run(self, revision=None, revision_info_list=None):
113
 
        from bzrlib.branch import find_branch
 
135
    def run(self, revision=None, revision_info_list=[]):
 
136
        from bzrlib.revisionspec import RevisionSpec
114
137
 
115
138
        revs = []
116
139
        if revision is not None:
117
140
            revs.extend(revision)
118
141
        if revision_info_list is not None:
119
 
            revs.extend(revision_info_list)
 
142
            for rev in revision_info_list:
 
143
                revs.append(RevisionSpec(rev))
120
144
        if len(revs) == 0:
121
145
            raise BzrCommandError('You must supply a revision identifier')
122
146
 
123
 
        b = find_branch('.')
 
147
        b = Branch.open_containing('.')
124
148
 
125
149
        for rev in revs:
126
 
            print '%4d %s' % b.get_revision_info(rev)
 
150
            revinfo = rev.in_history(b)
 
151
            if revinfo.revno is None:
 
152
                print '     %s' % revinfo.rev_id
 
153
            else:
 
154
                print '%4d %s' % (revinfo.revno, revinfo.rev_id)
127
155
 
128
156
    
129
157
class cmd_add(Command):
172
200
        for d in dir_list:
173
201
            os.mkdir(d)
174
202
            if not b:
175
 
                b = find_branch(d)
 
203
                b = Branch.open_containing(d)
176
204
            b.add([d])
177
205
            print 'added', d
178
206
 
183
211
    hidden = True
184
212
    
185
213
    def run(self, filename):
186
 
        print find_branch(filename).relpath(filename)
 
214
        print Branch.open_containing(filename).relpath(filename)
187
215
 
188
216
 
189
217
 
192
220
    takes_options = ['revision', 'show-ids']
193
221
    
194
222
    def run(self, revision=None, show_ids=False):
195
 
        b = find_branch('.')
196
 
        if revision == None:
 
223
        b = Branch.open_containing('.')
 
224
        if revision is None:
197
225
            inv = b.read_working_inventory()
198
226
        else:
199
227
            if len(revision) > 1:
200
228
                raise BzrCommandError('bzr inventory --revision takes'
201
229
                    ' exactly one revision identifier')
202
 
            inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
 
230
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
203
231
 
204
232
        for path, entry in inv.entries():
205
233
            if show_ids:
218
246
    """
219
247
    takes_args = ['source$', 'dest']
220
248
    def run(self, source_list, dest):
221
 
        b = find_branch('.')
 
249
        b = Branch.open_containing('.')
222
250
 
223
251
        # TODO: glob expansion on windows?
224
252
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
241
269
    takes_args = ['from_name', 'to_name']
242
270
    
243
271
    def run(self, from_name, to_name):
244
 
        b = find_branch('.')
 
272
        b = Branch.open_containing('.')
245
273
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
246
274
 
247
275
 
263
291
    def run(self, names_list):
264
292
        if len(names_list) < 2:
265
293
            raise BzrCommandError("missing file argument")
266
 
        b = find_branch(names_list[0])
 
294
        b = Branch.open_containing(names_list[0])
267
295
 
268
296
        rel_names = [b.relpath(x) for x in names_list]
269
297
        
275
303
            if len(names_list) != 2:
276
304
                raise BzrCommandError('to mv multiple files the destination '
277
305
                                      'must be a versioned directory')
278
 
            for pair in b.move(rel_names[0], rel_names[1]):
279
 
                print "%s => %s" % pair
 
306
            b.rename_one(rel_names[0], rel_names[1])
 
307
            print "%s => %s" % (rel_names[0], rel_names[1])
280
308
            
281
309
    
282
310
 
302
330
        import tempfile
303
331
        from shutil import rmtree
304
332
        import errno
305
 
        from bzrlib.branch import pull_loc
306
333
        
307
 
        br_to = find_branch('.')
308
 
        stored_loc = None
309
 
        try:
310
 
            stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
311
 
        except IOError, e:
312
 
            if e.errno != errno.ENOENT:
313
 
                raise
 
334
        br_to = Branch.open_containing('.')
 
335
        stored_loc = br_to.get_parent()
314
336
        if location is None:
315
337
            if stored_loc is None:
316
338
                raise BzrCommandError("No pull location known or specified.")
318
340
                print "Using last location: %s" % stored_loc
319
341
                location = stored_loc
320
342
        cache_root = tempfile.mkdtemp()
321
 
        from bzrlib.branch import DivergedBranches
322
 
        br_from = find_branch(location)
323
 
        location = pull_loc(br_from)
 
343
        from bzrlib.errors import DivergedBranches
 
344
        br_from = Branch.open_containing(location)
 
345
        location = br_from.base
324
346
        old_revno = br_to.revno()
325
347
        try:
326
 
            from branch import find_cached_branch, DivergedBranches
327
 
            br_from = find_cached_branch(location, cache_root)
328
 
            location = pull_loc(br_from)
 
348
            from bzrlib.errors import DivergedBranches
 
349
            br_from = Branch.open(location)
 
350
            br_from.setup_caching(cache_root)
 
351
            location = br_from.base
329
352
            old_revno = br_to.revno()
330
353
            try:
331
354
                br_to.update_revisions(br_from)
335
358
                
336
359
            merge(('.', -1), ('.', old_revno), check_clean=False)
337
360
            if location != stored_loc:
338
 
                br_to.controlfile("x-pull", "wb").write(location + "\n")
 
361
                br_to.set_parent(location)
339
362
        finally:
340
363
            rmtree(cache_root)
341
364
 
355
378
    aliases = ['get', 'clone']
356
379
 
357
380
    def run(self, from_location, to_location=None, revision=None):
358
 
        from bzrlib.branch import copy_branch, find_cached_branch
 
381
        from bzrlib.branch import copy_branch
359
382
        import tempfile
360
383
        import errno
361
384
        from shutil import rmtree
367
390
                raise BzrCommandError(
368
391
                    'bzr branch --revision takes exactly 1 revision value')
369
392
            try:
370
 
                br_from = find_cached_branch(from_location, cache_root)
 
393
                br_from = Branch.open(from_location)
371
394
            except OSError, e:
372
395
                if e.errno == errno.ENOENT:
373
396
                    raise BzrCommandError('Source location "%s" does not'
374
397
                                          ' exist.' % to_location)
375
398
                else:
376
399
                    raise
 
400
            br_from.setup_caching(cache_root)
 
401
            if len(revision) == 1 and revision[0] is not None:
 
402
                revno = revision[0].in_history(br_from)[0]
 
403
            else:
 
404
                revno = None
377
405
            if to_location is None:
378
406
                to_location = os.path.basename(from_location.rstrip("/\\"))
379
407
            try:
388
416
                else:
389
417
                    raise
390
418
            try:
391
 
                copy_branch(br_from, to_location, revision[0])
 
419
                copy_branch(br_from, to_location, revno)
392
420
            except bzrlib.errors.NoSuchRevision:
393
421
                rmtree(to_location)
394
422
                msg = "The branch %s has no revision %d." % (from_location, revision[0])
407
435
    takes_args = ['dir?']
408
436
 
409
437
    def run(self, dir='.'):
410
 
        b = find_branch(dir)
 
438
        b = Branch.open_containing(dir)
411
439
        old_inv = b.basis_tree().inventory
412
440
        new_inv = b.read_working_inventory()
413
441
 
424
452
    def run(self, branch=None):
425
453
        import info
426
454
 
427
 
        b = find_branch(branch)
 
455
        b = Branch.open_containing(branch)
428
456
        info.show_info(b)
429
457
 
430
458
 
438
466
    takes_options = ['verbose']
439
467
    
440
468
    def run(self, file_list, verbose=False):
441
 
        b = find_branch(file_list[0])
 
469
        b = Branch.open_containing(file_list[0])
442
470
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
443
471
 
444
472
 
452
480
    hidden = True
453
481
    takes_args = ['filename']
454
482
    def run(self, filename):
455
 
        b = find_branch(filename)
 
483
        b = Branch.open_containing(filename)
456
484
        i = b.inventory.path2id(b.relpath(filename))
457
485
        if i == None:
458
486
            raise BzrError("%r is not a versioned file" % filename)
468
496
    hidden = True
469
497
    takes_args = ['filename']
470
498
    def run(self, filename):
471
 
        b = find_branch(filename)
 
499
        b = Branch.open_containing(filename)
472
500
        inv = b.inventory
473
501
        fid = inv.path2id(b.relpath(filename))
474
502
        if fid == None:
481
509
    """Display list of revision ids on this branch."""
482
510
    hidden = True
483
511
    def run(self):
484
 
        for patchid in find_branch('.').revision_history():
 
512
        for patchid in Branch.open_containing('.').revision_history():
485
513
            print patchid
486
514
 
487
515
 
488
516
class cmd_directories(Command):
489
517
    """Display list of versioned directories in this branch."""
490
518
    def run(self):
491
 
        for name, ie in find_branch('.').read_working_inventory().directories():
 
519
        for name, ie in Branch.open_containing('.').read_working_inventory().directories():
492
520
            if name == '':
493
521
                print '.'
494
522
            else:
509
537
        bzr commit -m 'imported project'
510
538
    """
511
539
    def run(self):
512
 
        from bzrlib.branch import Branch
513
 
        Branch('.', init=True)
 
540
        Branch.initialize('.')
514
541
 
515
542
 
516
543
class cmd_diff(Command):
548
575
        from bzrlib.diff import show_diff
549
576
 
550
577
        if file_list:
551
 
            b = find_branch(file_list[0])
 
578
            b = Branch.open_containing(file_list[0])
552
579
            file_list = [b.relpath(f) for f in file_list]
553
580
            if file_list == ['']:
554
581
                # just pointing to top-of-tree
555
582
                file_list = None
556
583
        else:
557
 
            b = find_branch('.')
 
584
            b = Branch.open_containing('.')
558
585
 
559
586
        if revision is not None:
560
587
            if len(revision) == 1:
579
606
    TODO: Show files deleted since a previous revision, or between two revisions.
580
607
    """
581
608
    def run(self, show_ids=False):
582
 
        b = find_branch('.')
 
609
        b = Branch.open_containing('.')
583
610
        old = b.basis_tree()
584
611
        new = b.working_tree()
585
612
 
602
629
    def run(self):
603
630
        from bzrlib.delta import compare_trees
604
631
 
605
 
        b = find_branch('.')
 
632
        b = Branch.open_containing('.')
606
633
        td = compare_trees(b.basis_tree(), b.working_tree())
607
634
 
608
635
        for path, id, kind in td.modified:
614
641
    """List files added in working tree."""
615
642
    hidden = True
616
643
    def run(self):
617
 
        b = find_branch('.')
 
644
        b = Branch.open_containing('.')
618
645
        wt = b.working_tree()
619
646
        basis_inv = b.basis_tree().inventory
620
647
        inv = wt.inventory
636
663
    takes_args = ['filename?']
637
664
    def run(self, filename=None):
638
665
        """Print the branch root."""
639
 
        b = find_branch(filename)
640
 
        print getattr(b, 'base', None) or getattr(b, 'baseurl')
 
666
        b = Branch.open_containing(filename)
 
667
        print b.base
641
668
 
642
669
 
643
670
class cmd_log(Command):
672
699
        direction = (forward and 'forward') or 'reverse'
673
700
        
674
701
        if filename:
675
 
            b = find_branch(filename)
 
702
            b = Branch.open_containing(filename)
676
703
            fp = b.relpath(filename)
677
704
            if fp:
678
705
                file_id = b.read_working_inventory().path2id(fp)
679
706
            else:
680
707
                file_id = None  # points to branch root
681
708
        else:
682
 
            b = find_branch('.')
 
709
            b = Branch.open_containing('.')
683
710
            file_id = None
684
711
 
685
712
        if revision is None:
686
713
            rev1 = None
687
714
            rev2 = None
688
715
        elif len(revision) == 1:
689
 
            rev1 = rev2 = b.get_revision_info(revision[0])[0]
 
716
            rev1 = rev2 = revision[0].in_history(b).revno
690
717
        elif len(revision) == 2:
691
 
            rev1 = b.get_revision_info(revision[0])[0]
692
 
            rev2 = b.get_revision_info(revision[1])[0]
 
718
            rev1 = revision[0].in_history(b).revno
 
719
            rev2 = revision[1].in_history(b).revno
693
720
        else:
694
721
            raise BzrCommandError('bzr log --revision takes one or two values.')
695
722
 
731
758
    hidden = True
732
759
    takes_args = ["filename"]
733
760
    def run(self, filename):
734
 
        b = find_branch(filename)
 
761
        b = Branch.open_containing(filename)
735
762
        inv = b.read_working_inventory()
736
763
        file_id = inv.path2id(b.relpath(filename))
737
764
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
745
772
    """
746
773
    hidden = True
747
774
    def run(self, revision=None, verbose=False):
748
 
        b = find_branch('.')
 
775
        b = Branch.open_containing('.')
749
776
        if revision == None:
750
777
            tree = b.working_tree()
751
778
        else:
752
 
            tree = b.revision_tree(b.lookup_revision(revision))
 
779
            tree = b.revision_tree(revision.in_history(b).rev_id)
753
780
 
754
781
        for fp, fc, kind, fid in tree.list_files():
755
782
            if verbose:
770
797
    """List unknown files."""
771
798
    def run(self):
772
799
        from bzrlib.osutils import quotefn
773
 
        for f in find_branch('.').unknowns():
 
800
        for f in Branch.open_containing('.').unknowns():
774
801
            print quotefn(f)
775
802
 
776
803
 
798
825
        from bzrlib.atomicfile import AtomicFile
799
826
        import os.path
800
827
 
801
 
        b = find_branch('.')
 
828
        b = Branch.open_containing('.')
802
829
        ifn = b.abspath('.bzrignore')
803
830
 
804
831
        if os.path.exists(ifn):
838
865
 
839
866
    See also: bzr ignore"""
840
867
    def run(self):
841
 
        tree = find_branch('.').working_tree()
 
868
        tree = Branch.open_containing('.').working_tree()
842
869
        for path, file_class, kind, file_id in tree.list_files():
843
870
            if file_class != 'I':
844
871
                continue
862
889
        except ValueError:
863
890
            raise BzrCommandError("not a valid revision-number: %r" % revno)
864
891
 
865
 
        print find_branch('.').lookup_revision(revno)
 
892
        print Branch.open_containing('.').get_rev_id(revno)
866
893
 
867
894
 
868
895
class cmd_export(Command):
881
908
    takes_options = ['revision', 'format', 'root']
882
909
    def run(self, dest, revision=None, format=None, root=None):
883
910
        import os.path
884
 
        b = find_branch('.')
 
911
        b = Branch.open_containing('.')
885
912
        if revision is None:
886
913
            rev_id = b.last_patch()
887
914
        else:
888
915
            if len(revision) != 1:
889
916
                raise BzrError('bzr export --revision takes exactly 1 argument')
890
 
            revno, rev_id = b.get_revision_info(revision[0])
 
917
            rev_id = revision[0].in_history(b).rev_id
891
918
        t = b.revision_tree(rev_id)
892
919
        root, ext = os.path.splitext(dest)
893
920
        if not format:
909
936
    takes_args = ['filename']
910
937
 
911
938
    def run(self, filename, revision=None):
912
 
        if revision == None:
 
939
        if revision is None:
913
940
            raise BzrCommandError("bzr cat requires a revision number")
914
941
        elif len(revision) != 1:
915
942
            raise BzrCommandError("bzr cat --revision takes exactly one number")
916
 
        b = find_branch('.')
917
 
        b.print_file(b.relpath(filename), revision[0])
 
943
        b = Branch.open_containing('.')
 
944
        b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
918
945
 
919
946
 
920
947
class cmd_local_time_offset(Command):
955
982
        from bzrlib.status import show_status
956
983
        from cStringIO import StringIO
957
984
 
958
 
        b = find_branch('.')
 
985
        b = Branch.open_containing('.')
959
986
        if selected_list:
960
987
            selected_list = [b.relpath(s) for s in selected_list]
961
988
            
991
1018
 
992
1019
    This command checks various invariants about the branch storage to
993
1020
    detect data corruption or bzr bugs.
994
 
 
995
 
    If given the --update flag, it will update some optional fields
996
 
    to help ensure data consistency.
997
1021
    """
998
1022
    takes_args = ['dir?']
999
1023
 
1000
1024
    def run(self, dir='.'):
1001
1025
        from bzrlib.check import check
1002
1026
 
1003
 
        check(find_branch(dir))
 
1027
        check(Branch.open_containing(dir))
1004
1028
 
1005
1029
 
1006
1030
class cmd_scan_cache(Command):
1033
1057
 
1034
1058
    def run(self, dir='.'):
1035
1059
        from bzrlib.upgrade import upgrade
1036
 
        upgrade(find_branch(dir))
 
1060
        upgrade(Branch.open_containing(dir))
1037
1061
 
1038
1062
 
1039
1063
 
1043
1067
    
1044
1068
    def run(self, email=False):
1045
1069
        try:
1046
 
            b = bzrlib.branch.find_branch('.')
 
1070
            b = bzrlib.branch.Branch.open_containing('.')
1047
1071
        except:
1048
1072
            b = None
1049
1073
        
1115
1139
    def run(self, branch, other):
1116
1140
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
1117
1141
        
1118
 
        branch1 = find_branch(branch)
1119
 
        branch2 = find_branch(other)
 
1142
        branch1 = Branch.open_containing(branch)
 
1143
        branch2 = Branch.open_containing(other)
1120
1144
 
1121
1145
        history_1 = branch1.revision_history()
1122
1146
        history_2 = branch2.revision_history()
1185
1209
            other = [branch, -1]
1186
1210
        else:
1187
1211
            if len(revision) == 1:
1188
 
                other = [branch, revision[0]]
1189
1212
                base = [None, None]
 
1213
                other = [branch, revision[0].in_history(branch).revno]
1190
1214
            else:
1191
1215
                assert len(revision) == 2
1192
1216
                if None in revision:
1193
1217
                    raise BzrCommandError(
1194
1218
                        "Merge doesn't permit that revision specifier.")
1195
 
                base = [branch, revision[0]]
1196
 
                other = [branch, revision[1]]
 
1219
                b = Branch.open(branch)
 
1220
 
 
1221
                base = [branch, revision[0].in_history(b).revno]
 
1222
                other = [branch, revision[1].in_history(b).revno]
1197
1223
 
1198
1224
        try:
1199
1225
            merge(other, base, check_clean=(not force), merge_type=merge_type)
1220
1246
 
1221
1247
    def run(self, revision=None, no_backup=False, file_list=None):
1222
1248
        from bzrlib.merge import merge
1223
 
        from bzrlib.branch import Branch
1224
1249
        from bzrlib.commands import parse_spec
1225
1250
 
1226
1251
        if file_list is not None:
1227
1252
            if len(file_list) == 0:
1228
1253
                raise BzrCommandError("No files specified")
1229
1254
        if revision is None:
1230
 
            revision = [-1]
 
1255
            revno = -1
1231
1256
        elif len(revision) != 1:
1232
1257
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1233
 
        merge(('.', revision[0]), parse_spec('.'),
 
1258
        else:
 
1259
            b = Branch.open_containing('.')
 
1260
            revno = revision[0].in_history(b).revno
 
1261
        merge(('.', revno), parse_spec('.'),
1234
1262
              check_clean=False,
1235
1263
              ignore_zero=True,
1236
1264
              backup_files=not no_backup,
1237
1265
              file_list=file_list)
1238
1266
        if not file_list:
1239
 
            Branch('.').set_pending_merges([])
 
1267
            Branch.open_containing('.').set_pending_merges([])
1240
1268
 
1241
1269
 
1242
1270
class cmd_assert_fail(Command):
1290
1318
        if verbose and quiet:
1291
1319
            raise BzrCommandError('Cannot pass both quiet and verbose')
1292
1320
 
1293
 
        b = find_branch('.')
 
1321
        b = Branch.open_containing('.')
1294
1322
        parent = b.get_parent()
1295
1323
        if remote is None:
1296
1324
            if parent is None:
1300
1328
                    print "Using last location: %s" % parent
1301
1329
                remote = parent
1302
1330
        elif parent is None:
1303
 
            # We only update x-pull if it did not exist, missing should not change the parent
1304
 
            b.controlfile('x-pull', 'wb').write(remote + '\n')
1305
 
        br_remote = find_branch(remote)
 
1331
            # We only update parent if it did not exist, missing
 
1332
            # should not change the parent
 
1333
            b.set_parent(remote)
 
1334
        br_remote = Branch.open_containing(remote)
1306
1335
 
1307
1336
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1308
1337