← 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: 2006-02-15 08:11:37 UTC
  • mto: (1534.1.24 integration)
  • mto: This revision was merged to the branch mainline in revision 1554.
  • Revision ID: robertc@robertcollins.net-20060215081137-4c27377517e96dd1
Make format 4/5/6 branches share a single LockableFiles instance across wt/branch/repository.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
# DO NOT change this to cStringIO - it results in control files 
18
 
# written as UCS4
19
 
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
20
 
# RBC 20051018
21
 
from StringIO import StringIO
 
17
"""builtin bzr commands"""
 
18
 
 
19
 
 
20
import errno
 
21
import os
 
22
from shutil import rmtree
22
23
import sys
23
 
import os
24
24
 
25
25
import bzrlib
26
 
from bzrlib import BZRDIR
 
26
import bzrlib.branch
 
27
from bzrlib.branch import Branch
 
28
import bzrlib.bzrdir as bzrdir
 
29
from bzrlib._merge_core import ApplyMerge3
27
30
from bzrlib.commands import Command, display_command
28
 
from bzrlib.branch import Branch
29
31
from bzrlib.revision import common_ancestor
 
32
import bzrlib.errors as errors
30
33
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 
31
34
                           NotBranchError, DivergedBranches, NotConflicted,
32
 
                           NoSuchFile, NoWorkingTree, FileInWrongBranch)
 
35
                           NoSuchFile, NoWorkingTree, FileInWrongBranch)
 
36
from bzrlib.log import show_one_log
33
37
from bzrlib.option import Option
34
38
from bzrlib.revisionspec import RevisionSpec
35
39
import bzrlib.trace
36
 
from bzrlib.trace import mutter, note, log_error, warning
 
40
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
 
41
from bzrlib.transport.local import LocalTransport
37
42
from bzrlib.workingtree import WorkingTree
38
43
 
39
44
 
40
 
def branch_files(file_list, default_branch='.'):
 
45
def tree_files(file_list, default_branch=u'.'):
41
46
    try:
42
 
        return inner_branch_files(file_list, default_branch)
 
47
        return internal_tree_files(file_list, default_branch)
43
48
    except FileInWrongBranch, e:
44
49
        raise BzrCommandError("%s is not in the same branch as %s" %
45
50
                             (e.path, file_list[0]))
46
51
 
47
 
def inner_branch_files(file_list, default_branch='.'):
 
52
def internal_tree_files(file_list, default_branch=u'.'):
48
53
    """\
49
54
    Return a branch and list of branch-relative paths.
50
55
    If supplied file_list is empty or None, the branch default will be used,
51
56
    and returned file_list will match the original.
52
57
    """
53
58
    if file_list is None or len(file_list) == 0:
54
 
        return Branch.open_containing(default_branch)[0], file_list
55
 
    b = Branch.open_containing(file_list[0])[0]
56
 
    
57
 
    # note that if this is a remote branch, we would want
58
 
    # relpath against the transport. RBC 20051018
59
 
    # Most branch ops can't meaningfully operate on files in remote branches;
60
 
    # the above comment was in cmd_status.  ADHB 20051026
61
 
    tree = WorkingTree(b.base, b)
 
59
        return WorkingTree.open_containing(default_branch)[0], file_list
 
60
    tree = WorkingTree.open_containing(file_list[0])[0]
62
61
    new_list = []
63
62
    for filename in file_list:
64
63
        try:
65
64
            new_list.append(tree.relpath(filename))
66
 
        except NotBranchError:
67
 
            raise FileInWrongBranch(b, filename)
68
 
    return b, new_list
 
65
        except errors.PathNotChild:
 
66
            raise FileInWrongBranch(tree.branch, filename)
 
67
    return tree, new_list
69
68
 
70
69
 
71
70
# TODO: Make sure no commands unconditionally use the working directory as a
122
121
    
123
122
    @display_command
124
123
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
125
 
        b, file_list = branch_files(file_list)
 
124
        tree, file_list = tree_files(file_list)
126
125
            
127
126
        from bzrlib.status import show_status
128
 
        show_status(b, show_unchanged=all, show_ids=show_ids,
 
127
        show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
129
128
                    specific_files=file_list, revision=revision)
130
129
 
131
130
 
147
146
            raise BzrCommandError('You can only supply one of revision_id or --revision')
148
147
        if revision_id is None and revision is None:
149
148
            raise BzrCommandError('You must supply either --revision or a revision_id')
150
 
        b = Branch.open_containing('.')[0]
 
149
        b = WorkingTree.open_containing(u'.')[0].branch
151
150
        if revision_id is not None:
152
 
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
 
151
            sys.stdout.write(b.repository.get_revision_xml(revision_id))
153
152
        elif revision is not None:
154
153
            for rev in revision:
155
154
                if rev is None:
156
155
                    raise BzrCommandError('You cannot specify a NULL revision.')
157
156
                revno, rev_id = rev.in_history(b)
158
 
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
 
157
                sys.stdout.write(b.repository.get_revision_xml(rev_id))
159
158
    
160
159
 
161
160
class cmd_revno(Command):
162
161
    """Show current revision number.
163
162
 
164
163
    This is equal to the number of revisions on this branch."""
 
164
    takes_args = ['location?']
165
165
    @display_command
166
 
    def run(self):
167
 
        print Branch.open_containing('.')[0].revno()
 
166
    def run(self, location=u'.'):
 
167
        print Branch.open_containing(location)[0].revno()
168
168
 
169
169
 
170
170
class cmd_revision_info(Command):
185
185
        if len(revs) == 0:
186
186
            raise BzrCommandError('You must supply a revision identifier')
187
187
 
188
 
        b = Branch.open_containing('.')[0]
 
188
        b = WorkingTree.open_containing(u'.')[0].branch
189
189
 
190
190
        for rev in revs:
191
191
            revinfo = rev.in_history(b)
217
217
    implicitly add the parent, and so on up to the root. This means
218
218
    you should never need to explictly add a directory, they'll just
219
219
    get added when you add a file in the directory.
 
220
 
 
221
    --dry-run will show which files would be added, but not actually 
 
222
    add them.
220
223
    """
221
224
    takes_args = ['file*']
222
 
    takes_options = ['no-recurse', 'quiet']
223
 
    
224
 
    def run(self, file_list, no_recurse=False, quiet=False):
225
 
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
226
 
        if quiet:
227
 
            reporter = add_reporter_null
 
225
    takes_options = ['no-recurse', 'dry-run', 'verbose']
 
226
 
 
227
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
 
228
        import bzrlib.add
 
229
 
 
230
        if dry_run:
 
231
            if is_quiet():
 
232
                # This is pointless, but I'd rather not raise an error
 
233
                action = bzrlib.add.add_action_null
 
234
            else:
 
235
                action = bzrlib.add.add_action_print
 
236
        elif is_quiet():
 
237
            action = bzrlib.add.add_action_add
228
238
        else:
229
 
            reporter = add_reporter_print
230
 
        smart_add(file_list, not no_recurse, reporter)
 
239
            action = bzrlib.add.add_action_add_and_print
 
240
 
 
241
        added, ignored = bzrlib.add.smart_add(file_list, not no_recurse, 
 
242
                                              action)
 
243
        if len(ignored) > 0:
 
244
            for glob in sorted(ignored.keys()):
 
245
                match_len = len(ignored[glob])
 
246
                if verbose:
 
247
                    for path in ignored[glob]:
 
248
                        print "ignored %s matching \"%s\"" % (path, glob)
 
249
                else:
 
250
                    print "ignored %d file(s) matching \"%s\"" % (match_len,
 
251
                                                              glob)
 
252
            print "If you wish to add some of these files, please add them"\
 
253
                " by name."
231
254
 
232
255
 
233
256
class cmd_mkdir(Command):
238
261
    takes_args = ['dir+']
239
262
 
240
263
    def run(self, dir_list):
241
 
        b = None
242
 
        
243
264
        for d in dir_list:
244
265
            os.mkdir(d)
245
 
            b, dd = Branch.open_containing(d)
246
 
            b.add([dd])
 
266
            wt, dd = WorkingTree.open_containing(d)
 
267
            wt.add([dd])
247
268
            print 'added', d
248
269
 
249
270
 
254
275
    
255
276
    @display_command
256
277
    def run(self, filename):
257
 
        branch, relpath = Branch.open_containing(filename)
 
278
        tree, relpath = WorkingTree.open_containing(filename)
258
279
        print relpath
259
280
 
260
281
 
270
291
    def run(self, revision=None, show_ids=False, kind=None):
271
292
        if kind and kind not in ['file', 'directory', 'symlink']:
272
293
            raise BzrCommandError('invalid kind specified')
273
 
        b = Branch.open_containing('.')[0]
 
294
        tree = WorkingTree.open_containing(u'.')[0]
274
295
        if revision is None:
275
 
            inv = b.working_tree().read_working_inventory()
 
296
            inv = tree.read_working_inventory()
276
297
        else:
277
298
            if len(revision) > 1:
278
299
                raise BzrCommandError('bzr inventory --revision takes'
279
300
                    ' exactly one revision identifier')
280
 
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
 
301
            inv = tree.branch.repository.get_revision_inventory(
 
302
                revision[0].in_history(tree.branch).rev_id)
281
303
 
282
304
        for path, entry in inv.entries():
283
305
            if kind and kind != entry.kind:
298
320
    """
299
321
    takes_args = ['source$', 'dest']
300
322
    def run(self, source_list, dest):
301
 
        b, source_list = branch_files(source_list)
302
 
 
 
323
        tree, source_list = tree_files(source_list)
303
324
        # TODO: glob expansion on windows?
304
 
        tree = WorkingTree(b.base, b)
305
 
        b.move(source_list, tree.relpath(dest))
 
325
        tree.move(source_list, tree.relpath(dest))
306
326
 
307
327
 
308
328
class cmd_rename(Command):
322
342
    takes_args = ['from_name', 'to_name']
323
343
    
324
344
    def run(self, from_name, to_name):
325
 
        b, (from_name, to_name) = branch_files((from_name, to_name))
326
 
        b.rename_one(from_name, to_name)
 
345
        tree, (from_name, to_name) = tree_files((from_name, to_name))
 
346
        tree.rename_one(from_name, to_name)
327
347
 
328
348
 
329
349
class cmd_mv(Command):
343
363
    def run(self, names_list):
344
364
        if len(names_list) < 2:
345
365
            raise BzrCommandError("missing file argument")
346
 
        b, rel_names = branch_files(names_list)
 
366
        tree, rel_names = tree_files(names_list)
347
367
        
348
368
        if os.path.isdir(names_list[-1]):
349
369
            # move into existing directory
350
 
            for pair in b.move(rel_names[:-1], rel_names[-1]):
 
370
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
351
371
                print "%s => %s" % pair
352
372
        else:
353
373
            if len(names_list) != 2:
354
374
                raise BzrCommandError('to mv multiple files the destination '
355
375
                                      'must be a versioned directory')
356
 
            b.rename_one(rel_names[0], rel_names[1])
 
376
            tree.rename_one(rel_names[0], rel_names[1])
357
377
            print "%s => %s" % (rel_names[0], rel_names[1])
358
378
            
359
379
    
375
395
    If you want to forget your local changes and just update your branch to
376
396
    match the remote one, use --overwrite.
377
397
    """
378
 
    takes_options = ['remember', 'overwrite', 'verbose']
 
398
    takes_options = ['remember', 'overwrite', 'revision', 'verbose']
379
399
    takes_args = ['location?']
380
400
 
381
 
    def run(self, location=None, remember=False, overwrite=False, verbose=False):
382
 
        from bzrlib.merge import merge
383
 
        from shutil import rmtree
384
 
        import errno
385
 
        
386
 
        br_to = Branch.open_containing('.')[0]
387
 
        stored_loc = br_to.get_parent()
 
401
    def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
 
402
        # FIXME: too much stuff is in the command class        
 
403
        tree_to = WorkingTree.open_containing(u'.')[0]
 
404
        stored_loc = tree_to.branch.get_parent()
388
405
        if location is None:
389
406
            if stored_loc is None:
390
407
                raise BzrCommandError("No pull location known or specified.")
391
408
            else:
392
409
                print "Using saved location: %s" % stored_loc
393
410
                location = stored_loc
 
411
 
394
412
        br_from = Branch.open(location)
395
 
        try:
396
 
            old_rh = br_to.revision_history()
397
 
            br_to.working_tree().pull(br_from, overwrite)
398
 
        except DivergedBranches:
399
 
            raise BzrCommandError("These branches have diverged."
400
 
                                  "  Try merge.")
 
413
        br_to = tree_to.branch
 
414
 
 
415
        if revision is None:
 
416
            rev_id = None
 
417
        elif len(revision) == 1:
 
418
            rev_id = revision[0].in_history(br_from).rev_id
 
419
        else:
 
420
            raise BzrCommandError('bzr pull --revision takes one value.')
 
421
 
 
422
        old_rh = br_to.revision_history()
 
423
        count = tree_to.pull(br_from, overwrite, rev_id)
 
424
 
401
425
        if br_to.get_parent() is None or remember:
402
426
            br_to.set_parent(location)
 
427
        note('%d revision(s) pulled.' % (count,))
403
428
 
404
429
        if verbose:
405
 
            new_rh = br_to.revision_history()
 
430
            new_rh = tree_to.branch.revision_history()
406
431
            if old_rh != new_rh:
407
432
                # Something changed
408
433
                from bzrlib.log import show_changed_revisions
409
 
                show_changed_revisions(br_to, old_rh, new_rh)
 
434
                show_changed_revisions(tree_to.branch, old_rh, new_rh)
410
435
 
411
436
 
412
437
class cmd_push(Command):
440
465
 
441
466
    def run(self, location=None, remember=False, overwrite=False,
442
467
            create_prefix=False, verbose=False):
443
 
        import errno
444
 
        from shutil import rmtree
 
468
        # FIXME: Way too big!  Put this into a function called from the
 
469
        # command.
445
470
        from bzrlib.transport import get_transport
446
471
        
447
 
        br_from = Branch.open_containing('.')[0]
448
 
        stored_loc = br_from.get_push_location()
 
472
        tree_from = WorkingTree.open_containing(u'.')[0]
 
473
        br_from = tree_from.branch
 
474
        stored_loc = tree_from.branch.get_push_location()
449
475
        if location is None:
450
476
            if stored_loc is None:
451
477
                raise BzrCommandError("No push location known or specified.")
478
504
                        if new_transport.base == transport.base:
479
505
                            raise BzrCommandError("Could not creeate "
480
506
                                                  "path prefix.")
481
 
                        
482
 
            NoSuchFile
483
 
            br_to = Branch.initialize(location)
 
507
            if isinstance(transport, LocalTransport):
 
508
                br_to = WorkingTree.create_standalone(location).branch
 
509
            else:
 
510
                br_to = Branch.create(location)
 
511
        old_rh = br_to.revision_history()
484
512
        try:
485
 
            old_rh = br_to.revision_history()
486
 
            br_to.pull(br_from, overwrite)
 
513
            try:
 
514
                tree_to = br_to.working_tree()
 
515
            except NoWorkingTree:
 
516
                # TODO: This should be updated for branches which don't have a
 
517
                # working tree, as opposed to ones where we just couldn't 
 
518
                # update the tree.
 
519
                warning('Unable to update the working tree of: %s' % (br_to.base,))
 
520
                count = br_to.pull(br_from, overwrite)
 
521
            else:
 
522
                count = tree_to.pull(br_from, overwrite)
487
523
        except DivergedBranches:
488
524
            raise BzrCommandError("These branches have diverged."
489
525
                                  "  Try a merge then push with overwrite.")
490
526
        if br_from.get_push_location() is None or remember:
491
527
            br_from.set_push_location(location)
 
528
        note('%d revision(s) pushed.' % (count,))
492
529
 
493
530
        if verbose:
494
531
            new_rh = br_to.revision_history()
497
534
                from bzrlib.log import show_changed_revisions
498
535
                show_changed_revisions(br_to, old_rh, new_rh)
499
536
 
 
537
 
500
538
class cmd_branch(Command):
501
539
    """Create a new copy of a branch.
502
540
 
515
553
    aliases = ['get', 'clone']
516
554
 
517
555
    def run(self, from_location, to_location=None, revision=None, basis=None):
518
 
        from bzrlib.clone import copy_branch
519
 
        import errno
520
 
        from shutil import rmtree
521
556
        if revision is None:
522
557
            revision = [None]
523
558
        elif len(revision) > 1:
534
569
        br_from.lock_read()
535
570
        try:
536
571
            if basis is not None:
537
 
                basis_branch = Branch.open_containing(basis)[0]
 
572
                basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
538
573
            else:
539
 
                basis_branch = None
 
574
                basis_dir = None
540
575
            if len(revision) == 1 and revision[0] is not None:
541
576
                revision_id = revision[0].in_history(br_from)[1]
542
577
            else:
543
 
                revision_id = None
 
578
                # FIXME - wt.last_revision, fallback to branch, fall back to
 
579
                # None or perhaps NULL_REVISION to mean copy nothing
 
580
                # RBC 20060209
 
581
                revision_id = br_from.last_revision()
544
582
            if to_location is None:
545
583
                to_location = os.path.basename(from_location.rstrip("/\\"))
546
584
                name = None
558
596
                else:
559
597
                    raise
560
598
            try:
561
 
                copy_branch(br_from, to_location, revision_id, basis_branch)
 
599
                dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
 
600
                branch = dir.open_branch()
562
601
            except bzrlib.errors.NoSuchRevision:
563
602
                rmtree(to_location)
564
603
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
568
607
                msg = "The branch %s cannot be used as a --basis"
569
608
                raise BzrCommandError(msg)
570
609
            if name:
571
 
                branch = Branch.open(to_location)
572
 
                name = StringIO(name)
573
 
                branch.put_controlfile('branch-name', name)
 
610
                branch.control_files.put_utf8('branch-name', name)
 
611
 
 
612
            note('Branched %d revision(s).' % branch.revno())
574
613
        finally:
575
614
            br_from.unlock()
576
615
 
577
616
 
 
617
class cmd_checkout(Command):
 
618
    """Create a new checkout of an existing branch.
 
619
 
 
620
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
 
621
    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
 
622
 
 
623
    To retrieve the branch as of a particular revision, supply the --revision
 
624
    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
 
625
    out of date [so you cannot commit] but it may be useful (i.e. to examine old
 
626
    code.)
 
627
 
 
628
    --basis is to speed up checking out from remote branches.  When specified, it
 
629
    uses the inventory and file contents from the basis branch in preference to the
 
630
    branch being checked out. [Not implemented yet.]
 
631
    """
 
632
    takes_args = ['branch_location', 'to_location?']
 
633
    takes_options = ['revision'] # , 'basis']
 
634
 
 
635
    def run(self, branch_location, to_location=None, revision=None, basis=None):
 
636
        if revision is None:
 
637
            revision = [None]
 
638
        elif len(revision) > 1:
 
639
            raise BzrCommandError(
 
640
                'bzr checkout --revision takes exactly 1 revision value')
 
641
        source = Branch.open(branch_location)
 
642
        if len(revision) == 1 and revision[0] is not None:
 
643
            revision_id = revision[0].in_history(source)[1]
 
644
        else:
 
645
            revision_id = None
 
646
        if to_location is None:
 
647
            to_location = os.path.basename(branch_location.rstrip("/\\"))
 
648
        try:
 
649
            os.mkdir(to_location)
 
650
        except OSError, e:
 
651
            if e.errno == errno.EEXIST:
 
652
                raise BzrCommandError('Target directory "%s" already'
 
653
                                      ' exists.' % to_location)
 
654
            if e.errno == errno.ENOENT:
 
655
                raise BzrCommandError('Parent of "%s" does not exist.' %
 
656
                                      to_location)
 
657
            else:
 
658
                raise
 
659
        checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
 
660
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
661
        checkout.create_workingtree(revision_id)
 
662
 
 
663
 
578
664
class cmd_renames(Command):
579
665
    """Show list of renamed files.
580
666
    """
584
670
    takes_args = ['dir?']
585
671
 
586
672
    @display_command
587
 
    def run(self, dir='.'):
588
 
        b = Branch.open_containing(dir)[0]
589
 
        old_inv = b.basis_tree().inventory
590
 
        new_inv = b.working_tree().read_working_inventory()
 
673
    def run(self, dir=u'.'):
 
674
        tree = WorkingTree.open_containing(dir)[0]
 
675
        old_inv = tree.basis_tree().inventory
 
676
        new_inv = tree.read_working_inventory()
591
677
 
592
678
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
593
679
        renames.sort()
595
681
            print "%s => %s" % (old_name, new_name)        
596
682
 
597
683
 
 
684
class cmd_update(Command):
 
685
    """Update a tree to have the latest code committed to its branch.
 
686
    
 
687
    This will perform a merge into the working tree, and may generate
 
688
    conflicts. If you have any uncommitted changes, you will still 
 
689
    need to commit them after the update.
 
690
    """
 
691
    takes_args = ['dir?']
 
692
 
 
693
    def run(self, dir='.'):
 
694
        tree = WorkingTree.open_containing(dir)[0]
 
695
        tree.lock_write()
 
696
        try:
 
697
            if tree.last_revision() == tree.branch.last_revision():
 
698
                note("Tree is up to date.")
 
699
                return
 
700
            conflicts = tree.update()
 
701
            note('Updated to revision %d.' %
 
702
                 (tree.branch.revision_id_to_revno(tree.last_revision()),))
 
703
            if conflicts != 0:
 
704
                return 1
 
705
            else:
 
706
                return 0
 
707
        finally:
 
708
            tree.unlock()
 
709
 
 
710
 
598
711
class cmd_info(Command):
599
712
    """Show statistical information about a branch."""
600
713
    takes_args = ['branch?']
602
715
    @display_command
603
716
    def run(self, branch=None):
604
717
        import info
605
 
        b = Branch.open_containing(branch)[0]
606
 
        info.show_info(b)
 
718
        info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0])
607
719
 
608
720
 
609
721
class cmd_remove(Command):
617
729
    aliases = ['rm']
618
730
    
619
731
    def run(self, file_list, verbose=False):
620
 
        b, file_list = branch_files(file_list)
621
 
        tree = b.working_tree()
 
732
        tree, file_list = tree_files(file_list)
622
733
        tree.remove(file_list, verbose=verbose)
623
734
 
624
735
 
633
744
    takes_args = ['filename']
634
745
    @display_command
635
746
    def run(self, filename):
636
 
        b, relpath = Branch.open_containing(filename)
637
 
        i = b.working_tree().inventory.path2id(relpath)
 
747
        tree, relpath = WorkingTree.open_containing(filename)
 
748
        i = tree.inventory.path2id(relpath)
638
749
        if i == None:
639
750
            raise BzrError("%r is not a versioned file" % filename)
640
751
        else:
650
761
    takes_args = ['filename']
651
762
    @display_command
652
763
    def run(self, filename):
653
 
        b, relpath = Branch.open_containing(filename)
654
 
        inv = b.inventory
 
764
        tree, relpath = WorkingTree.open_containing(filename)
 
765
        inv = tree.inventory
655
766
        fid = inv.path2id(relpath)
656
767
        if fid == None:
657
768
            raise BzrError("%r is not a versioned file" % filename)
664
775
    hidden = True
665
776
    @display_command
666
777
    def run(self):
667
 
        for patchid in Branch.open_containing('.')[0].revision_history():
 
778
        branch = WorkingTree.open_containing(u'.')[0].branch
 
779
        for patchid in branch.revision_history():
668
780
            print patchid
669
781
 
670
782
 
673
785
    hidden = True
674
786
    @display_command
675
787
    def run(self):
676
 
        b = Branch.open_containing('.')[0]
677
 
        for revision_id in b.get_ancestry(b.last_revision()):
 
788
        tree = WorkingTree.open_containing(u'.')[0]
 
789
        b = tree.branch
 
790
        # FIXME. should be tree.last_revision
 
791
        for revision_id in b.repository.get_ancestry(b.last_revision()):
678
792
            print revision_id
679
793
 
680
794
 
695
809
    def run(self, location=None):
696
810
        from bzrlib.branch import Branch
697
811
        if location is None:
698
 
            location = '.'
 
812
            location = u'.'
699
813
        else:
700
814
            # The path has to exist to initialize a
701
815
            # branch inside of it.
704
818
            # locations if the user supplies an extended path
705
819
            if not os.path.exists(location):
706
820
                os.mkdir(location)
707
 
        Branch.initialize(location)
 
821
        bzrdir.BzrDir.create_standalone_workingtree(location)
708
822
 
709
823
 
710
824
class cmd_diff(Command):
740
854
    def run(self, revision=None, file_list=None, diff_options=None):
741
855
        from bzrlib.diff import show_diff
742
856
        try:
743
 
            b, file_list = inner_branch_files(file_list)
 
857
            tree, file_list = internal_tree_files(file_list)
 
858
            b = None
744
859
            b2 = None
745
860
        except FileInWrongBranch:
746
861
            if len(file_list) != 2:
749
864
            b, file1 = Branch.open_containing(file_list[0])
750
865
            b2, file2 = Branch.open_containing(file_list[1])
751
866
            if file1 != "" or file2 != "":
 
867
                # FIXME diff those two files. rbc 20051123
752
868
                raise BzrCommandError("Files are in different branches")
753
869
            file_list = None
754
870
        if revision is not None:
755
871
            if b2 is not None:
756
872
                raise BzrCommandError("Can't specify -r with two branches")
757
 
            if len(revision) == 1:
758
 
                return show_diff(b, revision[0], specific_files=file_list,
 
873
            if (len(revision) == 1) or (revision[1].spec is None):
 
874
                return show_diff(tree.branch, revision[0], specific_files=file_list,
759
875
                                 external_diff_options=diff_options)
760
876
            elif len(revision) == 2:
761
 
                return show_diff(b, revision[0], specific_files=file_list,
 
877
                return show_diff(tree.branch, revision[0], specific_files=file_list,
762
878
                                 external_diff_options=diff_options,
763
879
                                 revision2=revision[1])
764
880
            else:
765
881
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
766
882
        else:
767
 
            return show_diff(b, None, specific_files=file_list,
768
 
                             external_diff_options=diff_options, b2=b2)
 
883
            if b is not None:
 
884
                return show_diff(b, None, specific_files=file_list,
 
885
                                 external_diff_options=diff_options, b2=b2)
 
886
            else:
 
887
                return show_diff(tree.branch, None, specific_files=file_list,
 
888
                                 external_diff_options=diff_options)
769
889
 
770
890
 
771
891
class cmd_deleted(Command):
779
899
    # if the directories are very large...)
780
900
    @display_command
781
901
    def run(self, show_ids=False):
782
 
        b = Branch.open_containing('.')[0]
783
 
        old = b.basis_tree()
784
 
        new = b.working_tree()
 
902
        tree = WorkingTree.open_containing(u'.')[0]
 
903
        old = tree.basis_tree()
785
904
        for path, ie in old.inventory.iter_entries():
786
 
            if not new.has_id(ie.file_id):
 
905
            if not tree.has_id(ie.file_id):
787
906
                if show_ids:
788
907
                    print '%-50s %s' % (path, ie.file_id)
789
908
                else:
797
916
    def run(self):
798
917
        from bzrlib.delta import compare_trees
799
918
 
800
 
        b = Branch.open_containing('.')[0]
801
 
        td = compare_trees(b.basis_tree(), b.working_tree())
 
919
        tree = WorkingTree.open_containing(u'.')[0]
 
920
        td = compare_trees(tree.basis_tree(), tree)
802
921
 
803
922
        for path, id, kind, text_modified, meta_modified in td.modified:
804
923
            print path
810
929
    hidden = True
811
930
    @display_command
812
931
    def run(self):
813
 
        b = Branch.open_containing('.')[0]
814
 
        wt = b.working_tree()
815
 
        basis_inv = b.basis_tree().inventory
 
932
        wt = WorkingTree.open_containing(u'.')[0]
 
933
        basis_inv = wt.basis_tree().inventory
816
934
        inv = wt.inventory
817
935
        for file_id in inv:
818
936
            if file_id in basis_inv:
819
937
                continue
820
938
            path = inv.id2path(file_id)
821
 
            if not os.access(b.abspath(path), os.F_OK):
 
939
            if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
822
940
                continue
823
941
            print path
824
942
                
833
951
    @display_command
834
952
    def run(self, filename=None):
835
953
        """Print the branch root."""
836
 
        b = Branch.open_containing(filename)[0]
837
 
        print b.base
 
954
        tree = WorkingTree.open_containing(filename)[0]
 
955
        print tree.basedir
838
956
 
839
957
 
840
958
class cmd_log(Command):
852
970
                            help='show from oldest to newest'),
853
971
                     'timezone', 'verbose', 
854
972
                     'show-ids', 'revision',
855
 
                     Option('line', help='format with one line per revision'),
856
 
                     'long', 
 
973
                     'line', 'long', 
857
974
                     Option('message',
858
975
                            help='show revisions whose message matches this regexp',
859
976
                            type=str),
860
 
                     Option('short', help='use moderately short format'),
 
977
                     'short',
861
978
                     ]
862
979
    @display_command
863
980
    def run(self, filename=None, timezone='original',
875
992
            "invalid message argument %r" % message
876
993
        direction = (forward and 'forward') or 'reverse'
877
994
        
 
995
        # log everything
 
996
        file_id = None
878
997
        if filename:
879
 
            b, fp = Branch.open_containing(filename)
 
998
            # find the file id to log:
 
999
 
 
1000
            dir, fp = bzrdir.BzrDir.open_containing(filename)
 
1001
            b = dir.open_branch()
880
1002
            if fp != '':
881
1003
                try:
882
 
                    inv = b.working_tree().read_working_inventory()
883
 
                except NoWorkingTree:
884
 
                    inv = b.get_inventory(b.last_revision())
 
1004
                    # might be a tree:
 
1005
                    inv = dir.open_workingtree().inventory
 
1006
                except (errors.NotBranchError, errors.NotLocalUrl):
 
1007
                    # either no tree, or is remote.
 
1008
                    inv = b.basis_tree().inventory
885
1009
                file_id = inv.path2id(fp)
886
 
            else:
887
 
                file_id = None  # points to branch root
888
1010
        else:
889
 
            b, relpath = Branch.open_containing('.')
890
 
            file_id = None
 
1011
            # local dir only
 
1012
            # FIXME ? log the current subdir only RBC 20060203 
 
1013
            dir, relpath = bzrdir.BzrDir.open_containing('.')
 
1014
            b = dir.open_branch()
891
1015
 
892
1016
        if revision is None:
893
1017
            rev1 = None
896
1020
            rev1 = rev2 = revision[0].in_history(b).revno
897
1021
        elif len(revision) == 2:
898
1022
            rev1 = revision[0].in_history(b).revno
899
 
            rev2 = revision[1].in_history(b).revno
 
1023
            if revision[1].spec is None:
 
1024
                # missing end-range means last known revision
 
1025
                rev2 = b.revno()
 
1026
            else:
 
1027
                rev2 = revision[1].in_history(b).revno
900
1028
        else:
901
1029
            raise BzrCommandError('bzr log --revision takes one or two values.')
902
1030
 
912
1040
        # in e.g. the default C locale.
913
1041
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
914
1042
 
915
 
        log_format = 'long'
916
 
        if short:
917
 
            log_format = 'short'
918
 
        if line:
919
 
            log_format = 'line'
 
1043
        log_format = get_log_format(long=long, short=short, line=line)
920
1044
        lf = log_formatter(log_format,
921
1045
                           show_ids=show_ids,
922
1046
                           to_file=outf,
932
1056
                 search=message)
933
1057
 
934
1058
 
 
1059
def get_log_format(long=False, short=False, line=False, default='long'):
 
1060
    log_format = default
 
1061
    if long:
 
1062
        log_format = 'long'
 
1063
    if short:
 
1064
        log_format = 'short'
 
1065
    if line:
 
1066
        log_format = 'line'
 
1067
    return log_format
 
1068
 
935
1069
 
936
1070
class cmd_touching_revisions(Command):
937
1071
    """Return revision-ids which affected a particular file.
941
1075
    takes_args = ["filename"]
942
1076
    @display_command
943
1077
    def run(self, filename):
944
 
        b, relpath = Branch.open_containing(filename)[0]
945
 
        inv = b.working_tree().read_working_inventory()
 
1078
        tree, relpath = WorkingTree.open_containing(filename)
 
1079
        b = tree.branch
 
1080
        inv = tree.read_working_inventory()
946
1081
        file_id = inv.path2id(relpath)
947
1082
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
948
1083
            print "%6d %s" % (revno, what)
976
1111
 
977
1112
        selection = {'I':ignored, '?':unknown, 'V':versioned}
978
1113
 
979
 
        b, relpath = Branch.open_containing('.')
 
1114
        tree, relpath = WorkingTree.open_containing(u'.')
980
1115
        if from_root:
981
 
            relpath = ''
 
1116
            relpath = u''
982
1117
        elif relpath:
983
1118
            relpath += '/'
984
 
        if revision == None:
985
 
            tree = b.working_tree()
986
 
        else:
987
 
            tree = b.revision_tree(revision[0].in_history(b).rev_id)
 
1119
        if revision is not None:
 
1120
            tree = tree.branch.repository.revision_tree(
 
1121
                revision[0].in_history(tree.branch).rev_id)
988
1122
        for fp, fc, kind, fid, entry in tree.list_files():
989
1123
            if fp.startswith(relpath):
990
1124
                fp = fp[len(relpath):]
1003
1137
                    print fp
1004
1138
 
1005
1139
 
1006
 
 
1007
1140
class cmd_unknowns(Command):
1008
1141
    """List unknown files."""
1009
1142
    @display_command
1010
1143
    def run(self):
1011
1144
        from bzrlib.osutils import quotefn
1012
 
        for f in Branch.open_containing('.')[0].unknowns():
 
1145
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
1013
1146
            print quotefn(f)
1014
1147
 
1015
1148
 
1016
 
 
1017
1149
class cmd_ignore(Command):
1018
1150
    """Ignore a command or pattern.
1019
1151
 
1039
1171
        from bzrlib.atomicfile import AtomicFile
1040
1172
        import os.path
1041
1173
 
1042
 
        b, relpath = Branch.open_containing('.')
1043
 
        ifn = b.abspath('.bzrignore')
 
1174
        tree, relpath = WorkingTree.open_containing(u'.')
 
1175
        ifn = tree.abspath('.bzrignore')
1044
1176
 
1045
1177
        if os.path.exists(ifn):
1046
1178
            f = open(ifn, 'rt')
1065
1197
        finally:
1066
1198
            f.close()
1067
1199
 
1068
 
        inv = b.working_tree().inventory
 
1200
        inv = tree.inventory
1069
1201
        if inv.path2id('.bzrignore'):
1070
1202
            mutter('.bzrignore is already versioned')
1071
1203
        else:
1072
1204
            mutter('need to make new .bzrignore file versioned')
1073
 
            b.add(['.bzrignore'])
1074
 
 
 
1205
            tree.add(['.bzrignore'])
1075
1206
 
1076
1207
 
1077
1208
class cmd_ignored(Command):
1080
1211
    See also: bzr ignore"""
1081
1212
    @display_command
1082
1213
    def run(self):
1083
 
        tree = Branch.open_containing('.')[0].working_tree()
 
1214
        tree = WorkingTree.open_containing(u'.')[0]
1084
1215
        for path, file_class, kind, file_id, entry in tree.list_files():
1085
1216
            if file_class != 'I':
1086
1217
                continue
1105
1236
        except ValueError:
1106
1237
            raise BzrCommandError("not a valid revision-number: %r" % revno)
1107
1238
 
1108
 
        print Branch.open_containing('.')[0].get_rev_id(revno)
 
1239
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1109
1240
 
1110
1241
 
1111
1242
class cmd_export(Command):
1118
1249
    is found exports to a directory (equivalent to --format=dir).
1119
1250
 
1120
1251
    Root may be the top directory for tar, tgz and tbz2 formats. If none
1121
 
    is given, the top directory will be the root name of the file."""
1122
 
    # TODO: list known exporters
 
1252
    is given, the top directory will be the root name of the file.
 
1253
 
 
1254
    Note: export of tree with non-ascii filenames to zip is not supported.
 
1255
 
 
1256
     Supported formats       Autodetected by extension
 
1257
     -----------------       -------------------------
 
1258
         dir                            -
 
1259
         tar                          .tar
 
1260
         tbz2                    .tar.bz2, .tbz2
 
1261
         tgz                      .tar.gz, .tgz
 
1262
         zip                          .zip
 
1263
    """
1123
1264
    takes_args = ['dest']
1124
1265
    takes_options = ['revision', 'format', 'root']
1125
1266
    def run(self, dest, revision=None, format=None, root=None):
1126
1267
        import os.path
1127
 
        b = Branch.open_containing('.')[0]
 
1268
        from bzrlib.export import export
 
1269
        tree = WorkingTree.open_containing(u'.')[0]
 
1270
        b = tree.branch
1128
1271
        if revision is None:
 
1272
            # should be tree.last_revision  FIXME
1129
1273
            rev_id = b.last_revision()
1130
1274
        else:
1131
1275
            if len(revision) != 1:
1132
1276
                raise BzrError('bzr export --revision takes exactly 1 argument')
1133
1277
            rev_id = revision[0].in_history(b).rev_id
1134
 
        t = b.revision_tree(rev_id)
1135
 
        arg_root, ext = os.path.splitext(os.path.basename(dest))
1136
 
        if ext in ('.gz', '.bz2'):
1137
 
            new_root, new_ext = os.path.splitext(arg_root)
1138
 
            if new_ext == '.tar':
1139
 
                arg_root = new_root
1140
 
                ext = new_ext + ext
1141
 
        if root is None:
1142
 
            root = arg_root
1143
 
        if not format:
1144
 
            if ext in (".tar",):
1145
 
                format = "tar"
1146
 
            elif ext in (".tar.gz", ".tgz"):
1147
 
                format = "tgz"
1148
 
            elif ext in (".tar.bz2", ".tbz2"):
1149
 
                format = "tbz2"
1150
 
            else:
1151
 
                format = "dir"
1152
 
        t.export(dest, format, root)
 
1278
        t = b.repository.revision_tree(rev_id)
 
1279
        try:
 
1280
            export(t, dest, format, root)
 
1281
        except errors.NoSuchExportFormat, e:
 
1282
            raise BzrCommandError('Unsupported export format: %s' % e.format)
1153
1283
 
1154
1284
 
1155
1285
class cmd_cat(Command):
1160
1290
 
1161
1291
    @display_command
1162
1292
    def run(self, filename, revision=None):
1163
 
        if revision is None:
1164
 
            raise BzrCommandError("bzr cat requires a revision number")
1165
 
        elif len(revision) != 1:
 
1293
        if revision is not None and len(revision) != 1:
1166
1294
            raise BzrCommandError("bzr cat --revision takes exactly one number")
1167
 
        b, relpath = Branch.open_containing(filename)
1168
 
        b.print_file(relpath, revision[0].in_history(b).revno)
 
1295
        tree = None
 
1296
        try:
 
1297
            tree, relpath = WorkingTree.open_containing(filename)
 
1298
            b = tree.branch
 
1299
        except NotBranchError:
 
1300
            pass
 
1301
 
 
1302
        if tree is None:
 
1303
            b, relpath = Branch.open_containing(filename)
 
1304
        if revision is None:
 
1305
            revision_id = b.last_revision()
 
1306
        else:
 
1307
            revision_id = revision[0].in_history(b).rev_id
 
1308
        b.print_file(relpath, revision_id)
1169
1309
 
1170
1310
 
1171
1311
class cmd_local_time_offset(Command):
1216
1356
            unchanged=False, strict=False):
1217
1357
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1218
1358
                StrictCommitFailed)
1219
 
        from bzrlib.msgeditor import edit_commit_message
 
1359
        from bzrlib.msgeditor import edit_commit_message, \
 
1360
                make_commit_message_template
1220
1361
        from bzrlib.status import show_status
1221
 
        from cStringIO import StringIO
1222
 
 
1223
 
        b, selected_list = branch_files(selected_list)
 
1362
        from tempfile import TemporaryFile
 
1363
        import codecs
 
1364
 
 
1365
        # TODO: Need a blackbox test for invoking the external editor; may be
 
1366
        # slightly problematic to run this cross-platform.
 
1367
 
 
1368
        # TODO: do more checks that the commit will succeed before 
 
1369
        # spending the user's valuable time typing a commit message.
 
1370
        #
 
1371
        # TODO: if the commit *does* happen to fail, then save the commit 
 
1372
        # message to a temporary file where it can be recovered
 
1373
        tree, selected_list = tree_files(selected_list)
1224
1374
        if message is None and not file:
1225
 
            catcher = StringIO()
1226
 
            show_status(b, specific_files=selected_list,
1227
 
                        to_file=catcher)
1228
 
            message = edit_commit_message(catcher.getvalue())
1229
 
 
 
1375
            template = make_commit_message_template(tree, selected_list)
 
1376
            message = edit_commit_message(template)
1230
1377
            if message is None:
1231
1378
                raise BzrCommandError("please specify a commit message"
1232
1379
                                      " with either --message or --file")
1241
1388
                raise BzrCommandError("empty commit message specified")
1242
1389
            
1243
1390
        try:
1244
 
            b.working_tree().commit(message, specific_files=selected_list,
1245
 
                     allow_pointless=unchanged, strict=strict)
 
1391
            tree.commit(message, specific_files=selected_list,
 
1392
                        allow_pointless=unchanged, strict=strict)
1246
1393
        except PointlessCommit:
1247
1394
            # FIXME: This should really happen before the file is read in;
1248
1395
            # perhaps prepare the commit; get the message; then actually commit
1254
1401
        except StrictCommitFailed:
1255
1402
            raise BzrCommandError("Commit refused because there are unknown "
1256
1403
                                  "files in the working tree.")
 
1404
        note('Committed revision %d.' % (tree.branch.revno(),))
1257
1405
 
1258
1406
 
1259
1407
class cmd_check(Command):
1262
1410
    This command checks various invariants about the branch storage to
1263
1411
    detect data corruption or bzr bugs.
1264
1412
    """
1265
 
    takes_args = ['dir?']
 
1413
    takes_args = ['branch?']
1266
1414
    takes_options = ['verbose']
1267
1415
 
1268
 
    def run(self, dir='.', verbose=False):
 
1416
    def run(self, branch=None, verbose=False):
1269
1417
        from bzrlib.check import check
1270
 
        check(Branch.open_containing(dir)[0], verbose)
 
1418
        if branch is None:
 
1419
            tree = WorkingTree.open_containing()[0]
 
1420
            branch = tree.branch
 
1421
        else:
 
1422
            branch = Branch.open(branch)
 
1423
        check(branch, verbose)
1271
1424
 
1272
1425
 
1273
1426
class cmd_scan_cache(Command):
1275
1428
    def run(self):
1276
1429
        from bzrlib.hashcache import HashCache
1277
1430
 
1278
 
        c = HashCache('.')
 
1431
        c = HashCache(u'.')
1279
1432
        c.read()
1280
1433
        c.scan()
1281
1434
            
1294
1447
    """Upgrade branch storage to current format.
1295
1448
 
1296
1449
    The check command or bzr developers may sometimes advise you to run
1297
 
    this command.
1298
 
 
1299
 
    This version of this command upgrades from the full-text storage
1300
 
    used by bzr 0.0.8 and earlier to the weave format (v5).
 
1450
    this command. When the default format has changed you may also be warned
 
1451
    during other operations to upgrade.
1301
1452
    """
1302
 
    takes_args = ['dir?']
 
1453
    takes_args = ['url?']
1303
1454
 
1304
 
    def run(self, dir='.'):
 
1455
    def run(self, url='.'):
1305
1456
        from bzrlib.upgrade import upgrade
1306
 
        upgrade(dir)
 
1457
        upgrade(url)
1307
1458
 
1308
1459
 
1309
1460
class cmd_whoami(Command):
1313
1464
    @display_command
1314
1465
    def run(self, email=False):
1315
1466
        try:
1316
 
            b = bzrlib.branch.Branch.open_containing('.')[0]
 
1467
            b = WorkingTree.open_containing(u'.')[0].branch
1317
1468
            config = bzrlib.config.BranchConfig(b)
1318
1469
        except NotBranchError:
1319
1470
            config = bzrlib.config.GlobalConfig()
1323
1474
        else:
1324
1475
            print config.username()
1325
1476
 
 
1477
 
1326
1478
class cmd_nick(Command):
1327
 
    """\
1328
 
    Print or set the branch nickname.  
 
1479
    """Print or set the branch nickname.  
 
1480
 
1329
1481
    If unset, the tree root directory name is used as the nickname
1330
1482
    To print the current nickname, execute with no argument.  
1331
1483
    """
1332
1484
    takes_args = ['nickname?']
1333
1485
    def run(self, nickname=None):
1334
 
        branch = Branch.open_containing('.')[0]
 
1486
        branch = Branch.open_containing(u'.')[0]
1335
1487
        if nickname is None:
1336
1488
            self.printme(branch)
1337
1489
        else:
1341
1493
    def printme(self, branch):
1342
1494
        print branch.nick 
1343
1495
 
 
1496
 
1344
1497
class cmd_selftest(Command):
1345
1498
    """Run internal test suite.
1346
1499
    
1351
1504
    
1352
1505
    If arguments are given, they are regular expressions that say
1353
1506
    which tests should run.
 
1507
 
 
1508
    If the global option '--no-plugins' is given, plugins are not loaded
 
1509
    before running the selftests.  This has two effects: features provided or
 
1510
    modified by plugins will not be tested, and tests provided by plugins will
 
1511
    not be run.
 
1512
 
 
1513
    examples:
 
1514
        bzr selftest ignore
 
1515
        bzr --no-plugins selftest -v
1354
1516
    """
1355
1517
    # TODO: --list should give a list of all available tests
 
1518
 
 
1519
    # NB: this is used from the class without creating an instance, which is
 
1520
    # why it does not have a self parameter.
 
1521
    def get_transport_type(typestring):
 
1522
        """Parse and return a transport specifier."""
 
1523
        if typestring == "sftp":
 
1524
            from bzrlib.transport.sftp import SFTPAbsoluteServer
 
1525
            return SFTPAbsoluteServer
 
1526
        if typestring == "memory":
 
1527
            from bzrlib.transport.memory import MemoryServer
 
1528
            return MemoryServer
 
1529
        msg = "No known transport type %s. Supported types are: sftp\n" %\
 
1530
            (typestring)
 
1531
        raise BzrCommandError(msg)
 
1532
 
1356
1533
    hidden = True
1357
1534
    takes_args = ['testspecs*']
1358
 
    takes_options = ['verbose', 
 
1535
    takes_options = ['verbose',
1359
1536
                     Option('one', help='stop when one test fails'),
1360
1537
                     Option('keep-output', 
1361
 
                            help='keep output directories when tests fail')
 
1538
                            help='keep output directories when tests fail'),
 
1539
                     Option('transport', 
 
1540
                            help='Use a different transport by default '
 
1541
                                 'throughout the test suite.',
 
1542
                            type=get_transport_type),
1362
1543
                    ]
1363
1544
 
1364
1545
    def run(self, testspecs_list=None, verbose=False, one=False,
1365
 
            keep_output=False):
 
1546
            keep_output=False, transport=None):
1366
1547
        import bzrlib.ui
1367
 
        from bzrlib.selftest import selftest
 
1548
        from bzrlib.tests import selftest
1368
1549
        # we don't want progress meters from the tests to go to the
1369
1550
        # real output; and we don't want log messages cluttering up
1370
1551
        # the real logs.
1379
1560
            result = selftest(verbose=verbose, 
1380
1561
                              pattern=pattern,
1381
1562
                              stop_on_failure=one, 
1382
 
                              keep_output=keep_output)
 
1563
                              keep_output=keep_output,
 
1564
                              transport=transport)
1383
1565
            if result:
1384
1566
                bzrlib.trace.info('tests passed')
1385
1567
            else:
1389
1571
            bzrlib.ui.ui_factory = save_ui
1390
1572
 
1391
1573
 
 
1574
def _get_bzr_branch():
 
1575
    """If bzr is run from a branch, return Branch or None"""
 
1576
    import bzrlib.errors
 
1577
    from bzrlib.branch import Branch
 
1578
    from bzrlib.osutils import abspath
 
1579
    from os.path import dirname
 
1580
    
 
1581
    try:
 
1582
        branch = Branch.open(dirname(abspath(dirname(__file__))))
 
1583
        return branch
 
1584
    except bzrlib.errors.BzrError:
 
1585
        return None
 
1586
    
 
1587
 
1392
1588
def show_version():
1393
1589
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
1394
1590
    # is bzrlib itself in a branch?
1395
 
    bzrrev = bzrlib.get_bzr_revision()
1396
 
    if bzrrev:
1397
 
        print "  (bzr checkout, revision %d {%s})" % bzrrev
 
1591
    branch = _get_bzr_branch()
 
1592
    if branch:
 
1593
        rh = branch.revision_history()
 
1594
        revno = len(rh)
 
1595
        print "  bzr checkout, revision %d" % (revno,)
 
1596
        print "  nick: %s" % (branch.nick,)
 
1597
        if rh:
 
1598
            print "  revid: %s" % (rh[-1],)
1398
1599
    print bzrlib.__copyright__
1399
1600
    print "http://bazaar-ng.org/"
1400
1601
    print
1438
1639
        last1 = branch1.last_revision()
1439
1640
        last2 = branch2.last_revision()
1440
1641
 
1441
 
        source = MultipleRevisionSources(branch1, branch2)
 
1642
        source = MultipleRevisionSources(branch1.repository, 
 
1643
                                         branch2.repository)
1442
1644
        
1443
1645
        base_rev_id = common_ancestor(last1, last2, source)
1444
1646
 
1491
1693
 
1492
1694
    def run(self, branch=None, revision=None, force=False, merge_type=None,
1493
1695
            show_base=False, reprocess=False):
1494
 
        from bzrlib.merge import merge
1495
 
        from bzrlib.merge_core import ApplyMerge3
 
1696
        from bzrlib._merge_core import ApplyMerge3
1496
1697
        if merge_type is None:
1497
1698
            merge_type = ApplyMerge3
1498
1699
        if branch is None:
1499
 
            branch = Branch.open_containing('.')[0].get_parent()
 
1700
            branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1500
1701
            if branch is None:
1501
1702
                raise BzrCommandError("No merge location known or specified.")
1502
1703
            else:
1549
1750
    def run(self, file_list=None, merge_type=None, show_base=False,
1550
1751
            reprocess=False):
1551
1752
        from bzrlib.merge import merge_inner, transform_tree
1552
 
        from bzrlib.merge_core import ApplyMerge3
 
1753
        from bzrlib._merge_core import ApplyMerge3
1553
1754
        if merge_type is None:
1554
1755
            merge_type = ApplyMerge3
1555
 
        b, file_list = branch_files(file_list)
1556
 
        b.lock_write()
 
1756
        tree, file_list = tree_files(file_list)
 
1757
        tree.lock_write()
1557
1758
        try:
1558
 
            pending_merges = b.working_tree().pending_merges() 
 
1759
            pending_merges = tree.pending_merges() 
1559
1760
            if len(pending_merges) != 1:
1560
1761
                raise BzrCommandError("Sorry, remerge only works after normal"
1561
1762
                                      + " merges.  Not cherrypicking or"
1562
1763
                                      + "multi-merges.")
1563
 
            this_tree = b.working_tree()
1564
 
            base_revision = common_ancestor(b.last_revision(), 
1565
 
                                            pending_merges[0], b)
1566
 
            base_tree = b.revision_tree(base_revision)
1567
 
            other_tree = b.revision_tree(pending_merges[0])
 
1764
            repository = tree.branch.repository
 
1765
            base_revision = common_ancestor(tree.branch.last_revision(), 
 
1766
                                            pending_merges[0], repository)
 
1767
            base_tree = repository.revision_tree(base_revision)
 
1768
            other_tree = repository.revision_tree(pending_merges[0])
1568
1769
            interesting_ids = None
1569
1770
            if file_list is not None:
1570
1771
                interesting_ids = set()
1571
1772
                for filename in file_list:
1572
 
                    file_id = this_tree.path2id(filename)
 
1773
                    file_id = tree.path2id(filename)
1573
1774
                    interesting_ids.add(file_id)
1574
 
                    if this_tree.kind(file_id) != "directory":
 
1775
                    if tree.kind(file_id) != "directory":
1575
1776
                        continue
1576
1777
                    
1577
 
                    for name, ie in this_tree.inventory.iter_entries(file_id):
 
1778
                    for name, ie in tree.inventory.iter_entries(file_id):
1578
1779
                        interesting_ids.add(ie.file_id)
1579
 
            transform_tree(this_tree, b.basis_tree(), interesting_ids)
 
1780
            transform_tree(tree, tree.basis_tree(), interesting_ids)
1580
1781
            if file_list is None:
1581
 
                restore_files = list(this_tree.iter_conflicts())
 
1782
                restore_files = list(tree.iter_conflicts())
1582
1783
            else:
1583
1784
                restore_files = file_list
1584
1785
            for filename in restore_files:
1585
1786
                try:
1586
 
                    restore(this_tree.abspath(filename))
 
1787
                    restore(tree.abspath(filename))
1587
1788
                except NotConflicted:
1588
1789
                    pass
1589
 
            conflicts =  merge_inner(b, other_tree, base_tree, 
 
1790
            conflicts =  merge_inner(tree.branch, other_tree, base_tree, 
1590
1791
                                     interesting_ids = interesting_ids, 
1591
1792
                                     other_rev_id=pending_merges[0], 
1592
1793
                                     merge_type=merge_type, 
1593
1794
                                     show_base=show_base,
1594
1795
                                     reprocess=reprocess)
1595
1796
        finally:
1596
 
            b.unlock()
 
1797
            tree.unlock()
1597
1798
        if conflicts > 0:
1598
1799
            return 1
1599
1800
        else:
1611
1812
    aliases = ['merge-revert']
1612
1813
 
1613
1814
    def run(self, revision=None, no_backup=False, file_list=None):
1614
 
        from bzrlib.merge import merge_inner
1615
1815
        from bzrlib.commands import parse_spec
1616
1816
        if file_list is not None:
1617
1817
            if len(file_list) == 0:
1618
1818
                raise BzrCommandError("No files specified")
1619
1819
        else:
1620
1820
            file_list = []
 
1821
        
 
1822
        tree, file_list = tree_files(file_list)
1621
1823
        if revision is None:
1622
 
            revno = -1
1623
 
            b = Branch.open_containing('.')[0]
1624
 
            rev_id = b.last_revision()
 
1824
            # FIXME should be tree.last_revision
 
1825
            rev_id = tree.branch.last_revision()
1625
1826
        elif len(revision) != 1:
1626
1827
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1627
1828
        else:
1628
 
            b, file_list = branch_files(file_list)
1629
 
            rev_id = revision[0].in_history(b).rev_id
1630
 
        b.working_tree().revert(file_list, b.revision_tree(rev_id),
1631
 
                                not no_backup)
 
1829
            rev_id = revision[0].in_history(tree.branch).rev_id
 
1830
        tree.revert(file_list, tree.branch.repository.revision_tree(rev_id),
 
1831
                    not no_backup)
1632
1832
 
1633
1833
 
1634
1834
class cmd_assert_fail(Command):
1679
1879
        from bzrlib.branch import Branch
1680
1880
        from_b = Branch.open(from_branch)
1681
1881
        to_b = Branch.open(to_branch)
1682
 
        from_b.lock_read()
1683
 
        try:
1684
 
            to_b.lock_write()
1685
 
            try:
1686
 
                Fetcher(to_b, from_b)
1687
 
            finally:
1688
 
                to_b.unlock()
1689
 
        finally:
1690
 
            from_b.unlock()
 
1882
        Fetcher(to_b, from_b)
1691
1883
 
1692
1884
 
1693
1885
class cmd_missing(Command):
1694
 
    """What is missing in this branch relative to other branch.
1695
 
    """
1696
 
    # TODO: rewrite this in terms of ancestry so that it shows only
1697
 
    # unmerged things
1698
 
    
1699
 
    takes_args = ['remote?']
1700
 
    aliases = ['mis', 'miss']
1701
 
    # We don't have to add quiet to the list, because 
1702
 
    # unknown options are parsed as booleans
1703
 
    takes_options = ['verbose', 'quiet']
1704
 
 
1705
 
    @display_command
1706
 
    def run(self, remote=None, verbose=False, quiet=False):
1707
 
        from bzrlib.errors import BzrCommandError
1708
 
        from bzrlib.missing import show_missing
1709
 
 
1710
 
        if verbose and quiet:
1711
 
            raise BzrCommandError('Cannot pass both quiet and verbose')
1712
 
 
1713
 
        b = Branch.open_containing('.')[0]
1714
 
        parent = b.get_parent()
1715
 
        if remote is None:
1716
 
            if parent is None:
 
1886
    """Show unmerged/unpulled revisions between two branches.
 
1887
 
 
1888
    OTHER_BRANCH may be local or remote."""
 
1889
    takes_args = ['other_branch?']
 
1890
    takes_options = [Option('reverse', 'Reverse the order of revisions'),
 
1891
                     Option('mine-only', 
 
1892
                            'Display changes in the local branch only'),
 
1893
                     Option('theirs-only', 
 
1894
                            'Display changes in the remote branch only'), 
 
1895
                     'line',
 
1896
                     'long', 
 
1897
                     'short',
 
1898
                     'show-ids',
 
1899
                     'verbose'
 
1900
                     ]
 
1901
 
 
1902
    def run(self, other_branch=None, reverse=False, mine_only=False,
 
1903
            theirs_only=False, long=True, short=False, line=False, 
 
1904
            show_ids=False, verbose=False):
 
1905
        from bzrlib.missing import find_unmerged, iter_log_data
 
1906
        from bzrlib.log import log_formatter
 
1907
        local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
 
1908
        parent = local_branch.get_parent()
 
1909
        if other_branch is None:
 
1910
            other_branch = parent
 
1911
            if other_branch is None:
1717
1912
                raise BzrCommandError("No missing location known or specified.")
1718
 
            else:
1719
 
                if not quiet:
1720
 
                    print "Using last location: %s" % parent
1721
 
                remote = parent
1722
 
        elif parent is None:
1723
 
            # We only update parent if it did not exist, missing
1724
 
            # should not change the parent
1725
 
            b.set_parent(remote)
1726
 
        br_remote = Branch.open_containing(remote)[0]
1727
 
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
 
1913
            print "Using last location: " + local_branch.get_parent()
 
1914
        remote_branch = bzrlib.branch.Branch.open(other_branch)
 
1915
        local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
 
1916
        log_format = get_log_format(long=long, short=short, line=line)
 
1917
        lf = log_formatter(log_format, sys.stdout,
 
1918
                           show_ids=show_ids,
 
1919
                           show_timezone='original')
 
1920
        if reverse is False:
 
1921
            local_extra.reverse()
 
1922
            remote_extra.reverse()
 
1923
        if local_extra and not theirs_only:
 
1924
            print "You have %d extra revision(s):" % len(local_extra)
 
1925
            for data in iter_log_data(local_extra, local_branch.repository,
 
1926
                                      verbose):
 
1927
                lf.show(*data)
 
1928
            printed_local = True
 
1929
        else:
 
1930
            printed_local = False
 
1931
        if remote_extra and not mine_only:
 
1932
            if printed_local is True:
 
1933
                print "\n\n"
 
1934
            print "You are missing %d revision(s):" % len(remote_extra)
 
1935
            for data in iter_log_data(remote_extra, remote_branch.repository, 
 
1936
                                      verbose):
 
1937
                lf.show(*data)
 
1938
        if not remote_extra and not local_extra:
 
1939
            status_code = 0
 
1940
            print "Branches are up to date."
 
1941
        else:
 
1942
            status_code = 1
 
1943
        if parent is None and other_branch is not None:
 
1944
            local_branch.set_parent(other_branch)
 
1945
        return status_code
1728
1946
 
1729
1947
 
1730
1948
class cmd_plugins(Command):
1734
1952
    def run(self):
1735
1953
        import bzrlib.plugin
1736
1954
        from inspect import getdoc
1737
 
        for plugin in bzrlib.plugin.all_plugins:
 
1955
        for name, plugin in bzrlib.plugin.all_plugins().items():
1738
1956
            if hasattr(plugin, '__path__'):
1739
1957
                print plugin.__path__[0]
1740
1958
            elif hasattr(plugin, '__file__'):
1752
1970
    takes_options = ['revision', 'long']
1753
1971
    takes_args = ['branch?']
1754
1972
    @display_command
1755
 
    def run(self, branch='.', revision=None, long=False):
 
1973
    def run(self, branch=u'.', revision=None, long=False):
1756
1974
        from bzrlib.testament import Testament
1757
 
        b = Branch.open_containing(branch)[0]
 
1975
        b = WorkingTree.open_containing(branch)[0].branch
1758
1976
        b.lock_read()
1759
1977
        try:
1760
1978
            if revision is None:
1761
1979
                rev_id = b.last_revision()
1762
1980
            else:
1763
1981
                rev_id = revision[0].in_history(b).rev_id
1764
 
            t = Testament.from_revision(b, rev_id)
 
1982
            t = Testament.from_revision(b.repository, rev_id)
1765
1983
            if long:
1766
1984
                sys.stdout.writelines(t.as_text_lines())
1767
1985
            else:
1792
2010
    @display_command
1793
2011
    def run(self, filename, all=False, long=False):
1794
2012
        from bzrlib.annotate import annotate_file
1795
 
        b, relpath = Branch.open_containing(filename)
1796
 
        b.lock_read()
 
2013
        tree, relpath = WorkingTree.open_containing(filename)
 
2014
        branch = tree.branch
 
2015
        branch.lock_read()
1797
2016
        try:
1798
 
            tree = WorkingTree(b.base, b)
1799
 
            tree = b.revision_tree(b.last_revision())
1800
2017
            file_id = tree.inventory.path2id(relpath)
 
2018
            tree = branch.repository.revision_tree(branch.last_revision())
1801
2019
            file_version = tree.inventory[file_id].revision
1802
 
            annotate_file(b, file_version, file_id, long, all, sys.stdout)
 
2020
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1803
2021
        finally:
1804
 
            b.unlock()
 
2022
            branch.unlock()
1805
2023
 
1806
2024
 
1807
2025
class cmd_re_sign(Command):
1819
2037
            raise BzrCommandError('You can only supply one of revision_id or --revision')
1820
2038
        if revision_id is None and revision is None:
1821
2039
            raise BzrCommandError('You must supply either --revision or a revision_id')
1822
 
        b = Branch.open_containing('.')[0]
 
2040
        b = WorkingTree.open_containing(u'.')[0].branch
1823
2041
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1824
2042
        if revision_id is not None:
1825
 
            b.sign_revision(revision_id, gpg_strategy)
 
2043
            b.repository.sign_revision(revision_id, gpg_strategy)
1826
2044
        elif revision is not None:
1827
2045
            if len(revision) == 1:
1828
2046
                revno, rev_id = revision[0].in_history(b)
1829
 
                b.sign_revision(rev_id, gpg_strategy)
 
2047
                b.repository.sign_revision(rev_id, gpg_strategy)
1830
2048
            elif len(revision) == 2:
1831
2049
                # are they both on rh- if so we can walk between them
1832
2050
                # might be nice to have a range helper for arbitrary
1838
2056
                if from_revno is None or to_revno is None:
1839
2057
                    raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1840
2058
                for revno in range(from_revno, to_revno + 1):
1841
 
                    b.sign_revision(b.get_rev_id(revno), gpg_strategy)
 
2059
                    b.repository.sign_revision(b.get_rev_id(revno), 
 
2060
                                               gpg_strategy)
1842
2061
            else:
1843
2062
                raise BzrCommandError('Please supply either one revision, or a range.')
1844
2063
 
1845
2064
 
 
2065
class cmd_uncommit(bzrlib.commands.Command):
 
2066
    """Remove the last committed revision.
 
2067
 
 
2068
    By supplying the --all flag, it will not only remove the entry 
 
2069
    from revision_history, but also remove all of the entries in the
 
2070
    stores.
 
2071
 
 
2072
    --verbose will print out what is being removed.
 
2073
    --dry-run will go through all the motions, but not actually
 
2074
    remove anything.
 
2075
    
 
2076
    In the future, uncommit will create a changeset, which can then
 
2077
    be re-applied.
 
2078
 
 
2079
    TODO: jam 20060108 Add an option to allow uncommit to remove unreferenced
 
2080
              information in 'branch-as-repostory' branches.
 
2081
    TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
 
2082
              information in shared branches as well.
 
2083
    """
 
2084
    takes_options = ['verbose', 'revision',
 
2085
                    Option('dry-run', help='Don\'t actually make changes'),
 
2086
                    Option('force', help='Say yes to all questions.')]
 
2087
    takes_args = ['location?']
 
2088
    aliases = []
 
2089
 
 
2090
    def run(self, location=None, 
 
2091
            dry_run=False, verbose=False,
 
2092
            revision=None, force=False):
 
2093
        from bzrlib.branch import Branch
 
2094
        from bzrlib.log import log_formatter
 
2095
        import sys
 
2096
        from bzrlib.uncommit import uncommit
 
2097
 
 
2098
        if location is None:
 
2099
            location = u'.'
 
2100
        b, relpath = Branch.open_containing(location)
 
2101
 
 
2102
        if revision is None:
 
2103
            revno = b.revno()
 
2104
            rev_id = b.last_revision()
 
2105
        else:
 
2106
            revno, rev_id = revision[0].in_history(b)
 
2107
        if rev_id is None:
 
2108
            print 'No revisions to uncommit.'
 
2109
 
 
2110
        for r in range(revno, b.revno()+1):
 
2111
            rev_id = b.get_rev_id(r)
 
2112
            lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
 
2113
            lf.show(r, b.repository.get_revision(rev_id), None)
 
2114
 
 
2115
        if dry_run:
 
2116
            print 'Dry-run, pretending to remove the above revisions.'
 
2117
            if not force:
 
2118
                val = raw_input('Press <enter> to continue')
 
2119
        else:
 
2120
            print 'The above revision(s) will be removed.'
 
2121
            if not force:
 
2122
                val = raw_input('Are you sure [y/N]? ')
 
2123
                if val.lower() not in ('y', 'yes'):
 
2124
                    print 'Canceled'
 
2125
                    return 0
 
2126
 
 
2127
        uncommit(b, dry_run=dry_run, verbose=verbose,
 
2128
                revno=revno)
 
2129
 
 
2130
 
 
2131
def merge(other_revision, base_revision,
 
2132
          check_clean=True, ignore_zero=False,
 
2133
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
 
2134
          file_list=None, show_base=False, reprocess=False):
 
2135
    """Merge changes into a tree.
 
2136
 
 
2137
    base_revision
 
2138
        list(path, revno) Base for three-way merge.  
 
2139
        If [None, None] then a base will be automatically determined.
 
2140
    other_revision
 
2141
        list(path, revno) Other revision for three-way merge.
 
2142
    this_dir
 
2143
        Directory to merge changes into; '.' by default.
 
2144
    check_clean
 
2145
        If true, this_dir must have no uncommitted changes before the
 
2146
        merge begins.
 
2147
    ignore_zero - If true, suppress the "zero conflicts" message when 
 
2148
        there are no conflicts; should be set when doing something we expect
 
2149
        to complete perfectly.
 
2150
    file_list - If supplied, merge only changes to selected files.
 
2151
 
 
2152
    All available ancestors of other_revision and base_revision are
 
2153
    automatically pulled into the branch.
 
2154
 
 
2155
    The revno may be -1 to indicate the last revision on the branch, which is
 
2156
    the typical case.
 
2157
 
 
2158
    This function is intended for use from the command line; programmatic
 
2159
    clients might prefer to call merge.merge_inner(), which has less magic 
 
2160
    behavior.
 
2161
    """
 
2162
    from bzrlib.merge import Merger, _MergeConflictHandler
 
2163
    if this_dir is None:
 
2164
        this_dir = u'.'
 
2165
    this_tree = WorkingTree.open_containing(this_dir)[0]
 
2166
    if show_base and not merge_type is ApplyMerge3:
 
2167
        raise BzrCommandError("Show-base is not supported for this merge"
 
2168
                              " type. %s" % merge_type)
 
2169
    if reprocess and not merge_type is ApplyMerge3:
 
2170
        raise BzrCommandError("Reprocess is not supported for this merge"
 
2171
                              " type. %s" % merge_type)
 
2172
    if reprocess and show_base:
 
2173
        raise BzrCommandError("Cannot reprocess and show base.")
 
2174
    merger = Merger(this_tree.branch, this_tree=this_tree)
 
2175
    merger.check_basis(check_clean)
 
2176
    merger.set_other(other_revision)
 
2177
    merger.set_base(base_revision)
 
2178
    if merger.base_rev_id == merger.other_rev_id:
 
2179
        note('Nothing to do.')
 
2180
        return 0
 
2181
    merger.backup_files = backup_files
 
2182
    merger.merge_type = merge_type 
 
2183
    merger.set_interesting_files(file_list)
 
2184
    merger.show_base = show_base 
 
2185
    merger.reprocess = reprocess
 
2186
    merger.conflict_handler = _MergeConflictHandler(merger.this_tree, 
 
2187
                                                    merger.base_tree, 
 
2188
                                                    merger.other_tree,
 
2189
                                                    ignore_zero=ignore_zero)
 
2190
    conflicts = merger.do_merge()
 
2191
    merger.set_pending()
 
2192
    return conflicts
 
2193
 
 
2194
 
1846
2195
# these get imported and then picked up by the scan for cmd_*
1847
2196
# TODO: Some more consistent way to split command definitions across files;
1848
2197
# we do need to load at least some information about them to know of