1
# Copyright (C) 2004, 2005 by Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""builtin bzr commands"""
22
from shutil import rmtree
27
from bzrlib.branch import Branch
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.commands import Command, display_command
30
from bzrlib.revision import common_ancestor
31
import bzrlib.errors as errors
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
NotBranchError, DivergedBranches, NotConflicted,
34
NoSuchFile, NoWorkingTree, FileInWrongBranch,
36
from bzrlib.log import show_one_log
37
from bzrlib.merge import Merge3Merger
38
from bzrlib.option import Option
39
from bzrlib.progress import DummyProgress
40
from bzrlib.revisionspec import RevisionSpec
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
43
from bzrlib.transport.local import LocalTransport
45
from bzrlib.workingtree import WorkingTree
48
def tree_files(file_list, default_branch=u'.'):
50
return internal_tree_files(file_list, default_branch)
51
except FileInWrongBranch, e:
52
raise BzrCommandError("%s is not in the same branch as %s" %
53
(e.path, file_list[0]))
55
def internal_tree_files(file_list, default_branch=u'.'):
57
Return a branch and list of branch-relative paths.
58
If supplied file_list is empty or None, the branch default will be used,
59
and returned file_list will match the original.
61
if file_list is None or len(file_list) == 0:
62
return WorkingTree.open_containing(default_branch)[0], file_list
63
tree = WorkingTree.open_containing(file_list[0])[0]
65
for filename in file_list:
67
new_list.append(tree.relpath(filename))
68
except errors.PathNotChild:
69
raise FileInWrongBranch(tree.branch, filename)
73
# TODO: Make sure no commands unconditionally use the working directory as a
74
# branch. If a filename argument is used, the first of them should be used to
75
# specify the branch. (Perhaps this can be factored out into some kind of
76
# Argument class, representing a file in a branch, where the first occurrence
79
class cmd_status(Command):
80
"""Display status summary.
82
This reports on versioned and unknown files, reporting them
83
grouped by state. Possible states are:
86
Versioned in the working copy but not in the previous revision.
89
Versioned in the previous revision but removed or deleted
93
Path of this file changed from the previous revision;
94
the text may also have changed. This includes files whose
95
parent directory was renamed.
98
Text has changed since the previous revision.
101
Nothing about this file has changed since the previous revision.
102
Only shown with --all.
105
Not versioned and not matching an ignore pattern.
107
To see ignored files use 'bzr ignored'. For details in the
108
changes to file texts, use 'bzr diff'.
110
If no arguments are specified, the status of the entire working
111
directory is shown. Otherwise, only the status of the specified
112
files or directories is reported. If a directory is given, status
113
is reported for everything inside that directory.
115
If a revision argument is given, the status is calculated against
116
that revision, or between two revisions if two are provided.
119
# TODO: --no-recurse, --recurse options
121
takes_args = ['file*']
122
takes_options = ['all', 'show-ids', 'revision']
123
aliases = ['st', 'stat']
126
def run(self, all=False, show_ids=False, file_list=None, revision=None):
127
tree, file_list = tree_files(file_list)
129
from bzrlib.status import show_tree_status
130
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
131
specific_files=file_list, revision=revision)
134
class cmd_cat_revision(Command):
135
"""Write out metadata for a revision.
137
The revision to print can either be specified by a specific
138
revision identifier, or you can use --revision.
142
takes_args = ['revision_id?']
143
takes_options = ['revision']
146
def run(self, revision_id=None, revision=None):
148
if revision_id is not None and revision is not None:
149
raise BzrCommandError('You can only supply one of revision_id or --revision')
150
if revision_id is None and revision is None:
151
raise BzrCommandError('You must supply either --revision or a revision_id')
152
b = WorkingTree.open_containing(u'.')[0].branch
153
if revision_id is not None:
154
sys.stdout.write(b.repository.get_revision_xml(revision_id))
155
elif revision is not None:
158
raise BzrCommandError('You cannot specify a NULL revision.')
159
revno, rev_id = rev.in_history(b)
160
sys.stdout.write(b.repository.get_revision_xml(rev_id))
163
class cmd_revno(Command):
164
"""Show current revision number.
166
This is equal to the number of revisions on this branch."""
167
takes_args = ['location?']
169
def run(self, location=u'.'):
170
print Branch.open_containing(location)[0].revno()
173
class cmd_revision_info(Command):
174
"""Show revision number and revision id for a given revision identifier.
177
takes_args = ['revision_info*']
178
takes_options = ['revision']
180
def run(self, revision=None, revision_info_list=[]):
183
if revision is not None:
184
revs.extend(revision)
185
if revision_info_list is not None:
186
for rev in revision_info_list:
187
revs.append(RevisionSpec(rev))
189
raise BzrCommandError('You must supply a revision identifier')
191
b = WorkingTree.open_containing(u'.')[0].branch
194
revinfo = rev.in_history(b)
195
if revinfo.revno is None:
196
print ' %s' % revinfo.rev_id
198
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
201
class cmd_add(Command):
202
"""Add specified files or directories.
204
In non-recursive mode, all the named items are added, regardless
205
of whether they were previously ignored. A warning is given if
206
any of the named files are already versioned.
208
In recursive mode (the default), files are treated the same way
209
but the behaviour for directories is different. Directories that
210
are already versioned do not give a warning. All directories,
211
whether already versioned or not, are searched for files or
212
subdirectories that are neither versioned or ignored, and these
213
are added. This search proceeds recursively into versioned
214
directories. If no names are given '.' is assumed.
216
Therefore simply saying 'bzr add' will version all files that
217
are currently unknown.
219
Adding a file whose parent directory is not versioned will
220
implicitly add the parent, and so on up to the root. This means
221
you should never need to explictly add a directory, they'll just
222
get added when you add a file in the directory.
224
--dry-run will show which files would be added, but not actually
227
takes_args = ['file*']
228
takes_options = ['no-recurse', 'dry-run', 'verbose']
230
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
235
# This is pointless, but I'd rather not raise an error
236
action = bzrlib.add.add_action_null
238
action = bzrlib.add.add_action_print
240
action = bzrlib.add.add_action_add
242
action = bzrlib.add.add_action_add_and_print
244
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
247
for glob in sorted(ignored.keys()):
248
match_len = len(ignored[glob])
250
for path in ignored[glob]:
251
print "ignored %s matching \"%s\"" % (path, glob)
253
print "ignored %d file(s) matching \"%s\"" % (match_len,
255
print "If you wish to add some of these files, please add them"\
259
class cmd_mkdir(Command):
260
"""Create a new versioned directory.
262
This is equivalent to creating the directory and then adding it.
264
takes_args = ['dir+']
266
def run(self, dir_list):
269
wt, dd = WorkingTree.open_containing(d)
274
class cmd_relpath(Command):
275
"""Show path of a file relative to root"""
276
takes_args = ['filename']
280
def run(self, filename):
281
tree, relpath = WorkingTree.open_containing(filename)
285
class cmd_inventory(Command):
286
"""Show inventory of the current working copy or a revision.
288
It is possible to limit the output to a particular entry
289
type using the --kind option. For example; --kind file.
291
takes_options = ['revision', 'show-ids', 'kind']
294
def run(self, revision=None, show_ids=False, kind=None):
295
if kind and kind not in ['file', 'directory', 'symlink']:
296
raise BzrCommandError('invalid kind specified')
297
tree = WorkingTree.open_containing(u'.')[0]
299
inv = tree.read_working_inventory()
301
if len(revision) > 1:
302
raise BzrCommandError('bzr inventory --revision takes'
303
' exactly one revision identifier')
304
inv = tree.branch.repository.get_revision_inventory(
305
revision[0].in_history(tree.branch).rev_id)
307
for path, entry in inv.entries():
308
if kind and kind != entry.kind:
311
print '%-50s %s' % (path, entry.file_id)
316
class cmd_move(Command):
317
"""Move files to a different directory.
322
The destination must be a versioned directory in the same branch.
324
takes_args = ['source$', 'dest']
325
def run(self, source_list, dest):
326
tree, source_list = tree_files(source_list)
327
# TODO: glob expansion on windows?
328
tree.move(source_list, tree.relpath(dest))
331
class cmd_rename(Command):
332
"""Change the name of an entry.
335
bzr rename frob.c frobber.c
336
bzr rename src/frob.c lib/frob.c
338
It is an error if the destination name exists.
340
See also the 'move' command, which moves files into a different
341
directory without changing their name.
343
# TODO: Some way to rename multiple files without invoking
344
# bzr for each one?"""
345
takes_args = ['from_name', 'to_name']
347
def run(self, from_name, to_name):
348
tree, (from_name, to_name) = tree_files((from_name, to_name))
349
tree.rename_one(from_name, to_name)
352
class cmd_mv(Command):
353
"""Move or rename a file.
356
bzr mv OLDNAME NEWNAME
357
bzr mv SOURCE... DESTINATION
359
If the last argument is a versioned directory, all the other names
360
are moved into it. Otherwise, there must be exactly two arguments
361
and the file is changed to a new name, which must not already exist.
363
Files cannot be moved between branches.
365
takes_args = ['names*']
366
def run(self, names_list):
367
if len(names_list) < 2:
368
raise BzrCommandError("missing file argument")
369
tree, rel_names = tree_files(names_list)
371
if os.path.isdir(names_list[-1]):
372
# move into existing directory
373
for pair in tree.move(rel_names[:-1], rel_names[-1]):
374
print "%s => %s" % pair
376
if len(names_list) != 2:
377
raise BzrCommandError('to mv multiple files the destination '
378
'must be a versioned directory')
379
tree.rename_one(rel_names[0], rel_names[1])
380
print "%s => %s" % (rel_names[0], rel_names[1])
383
class cmd_pull(Command):
384
"""Pull any changes from another branch into the current one.
386
If there is no default location set, the first pull will set it. After
387
that, you can omit the location to use the default. To change the
388
default, use --remember.
390
This command only works on branches that have not diverged. Branches are
391
considered diverged if both branches have had commits without first
392
pulling from the other.
394
If branches have diverged, you can use 'bzr merge' to pull the text changes
395
from one into the other. Once one branch has merged, the other should
396
be able to pull it again.
398
If you want to forget your local changes and just update your branch to
399
match the remote one, use --overwrite.
401
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
402
takes_args = ['location?']
404
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
405
# FIXME: too much stuff is in the command class
406
tree_to = WorkingTree.open_containing(u'.')[0]
407
stored_loc = tree_to.branch.get_parent()
409
if stored_loc is None:
410
raise BzrCommandError("No pull location known or specified.")
412
print "Using saved location: %s" % stored_loc
413
location = stored_loc
415
br_from = Branch.open(location)
416
br_to = tree_to.branch
420
elif len(revision) == 1:
421
rev_id = revision[0].in_history(br_from).rev_id
423
raise BzrCommandError('bzr pull --revision takes one value.')
425
old_rh = br_to.revision_history()
426
count = tree_to.pull(br_from, overwrite, rev_id)
428
if br_to.get_parent() is None or remember:
429
br_to.set_parent(location)
430
note('%d revision(s) pulled.' % (count,))
433
new_rh = tree_to.branch.revision_history()
436
from bzrlib.log import show_changed_revisions
437
show_changed_revisions(tree_to.branch, old_rh, new_rh)
440
class cmd_push(Command):
441
"""Push this branch into another branch.
443
The remote branch will not have its working tree populated because this
444
is both expensive, and may not be supported on the remote file system.
446
Some smart servers or protocols *may* put the working tree in place.
448
If there is no default push location set, the first push will set it.
449
After that, you can omit the location to use the default. To change the
450
default, use --remember.
452
This command only works on branches that have not diverged. Branches are
453
considered diverged if the branch being pushed to is not an older version
456
If branches have diverged, you can use 'bzr push --overwrite' to replace
457
the other branch completely.
459
If you want to ensure you have the different changes in the other branch,
460
do a merge (see bzr help merge) from the other branch, and commit that
461
before doing a 'push --overwrite'.
463
takes_options = ['remember', 'overwrite',
464
Option('create-prefix',
465
help='Create the path leading up to the branch '
466
'if it does not already exist')]
467
takes_args = ['location?']
469
def run(self, location=None, remember=False, overwrite=False,
470
create_prefix=False, verbose=False):
471
# FIXME: Way too big! Put this into a function called from the
473
from bzrlib.transport import get_transport
475
tree_from = WorkingTree.open_containing(u'.')[0]
476
br_from = tree_from.branch
477
stored_loc = tree_from.branch.get_push_location()
479
if stored_loc is None:
480
raise BzrCommandError("No push location known or specified.")
482
print "Using saved location: %s" % stored_loc
483
location = stored_loc
485
br_to = Branch.open(location)
486
except NotBranchError:
488
transport = get_transport(location).clone('..')
489
if not create_prefix:
491
transport.mkdir(transport.relpath(location))
493
raise BzrCommandError("Parent directory of %s "
494
"does not exist." % location)
496
current = transport.base
497
needed = [(transport, transport.relpath(location))]
500
transport, relpath = needed[-1]
501
transport.mkdir(relpath)
504
new_transport = transport.clone('..')
505
needed.append((new_transport,
506
new_transport.relpath(transport.base)))
507
if new_transport.base == transport.base:
508
raise BzrCommandError("Could not creeate "
510
br_to = bzrlib.bzrdir.BzrDir.create_branch_convenience(location)
511
old_rh = br_to.revision_history()
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
519
warning('Unable to update the working tree of: %s' % (br_to.base,))
520
count = br_to.pull(br_from, overwrite)
522
count = tree_to.pull(br_from, overwrite)
523
except DivergedBranches:
524
raise BzrCommandError("These branches have diverged."
525
" Try a merge then push with overwrite.")
526
if br_from.get_push_location() is None or remember:
527
br_from.set_push_location(location)
528
note('%d revision(s) pushed.' % (count,))
531
new_rh = br_to.revision_history()
534
from bzrlib.log import show_changed_revisions
535
show_changed_revisions(br_to, old_rh, new_rh)
538
class cmd_branch(Command):
539
"""Create a new copy of a branch.
541
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
542
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
544
To retrieve the branch as of a particular revision, supply the --revision
545
parameter, as in "branch foo/bar -r 5".
547
--basis is to speed up branching from remote branches. When specified, it
548
copies all the file-contents, inventory and revision data from the basis
549
branch before copying anything from the remote branch.
551
takes_args = ['from_location', 'to_location?']
552
takes_options = ['revision', 'basis', 'bound']
553
aliases = ['get', 'clone']
555
def run(self, from_location, to_location=None, revision=None, basis=None,
559
elif len(revision) > 1:
560
raise BzrCommandError(
561
'bzr branch --revision takes exactly 1 revision value')
563
br_from = Branch.open(from_location)
565
if e.errno == errno.ENOENT:
566
raise BzrCommandError('Source location "%s" does not'
567
' exist.' % to_location)
572
if basis is not None:
573
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
576
if len(revision) == 1 and revision[0] is not None:
577
revision_id = revision[0].in_history(br_from)[1]
579
# FIXME - wt.last_revision, fallback to branch, fall back to
580
# None or perhaps NULL_REVISION to mean copy nothing
582
revision_id = br_from.last_revision()
583
if to_location is None:
584
to_location = os.path.basename(from_location.rstrip("/\\"))
587
name = os.path.basename(to_location) + '\n'
589
os.mkdir(to_location)
591
if e.errno == errno.EEXIST:
592
raise BzrCommandError('Target directory "%s" already'
593
' exists.' % to_location)
594
if e.errno == errno.ENOENT:
595
raise BzrCommandError('Parent of "%s" does not exist.' %
600
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
601
branch = dir.open_branch()
602
except bzrlib.errors.NoSuchRevision:
604
msg = "The branch %s has no revision %s." % (from_location, revision[0])
605
raise BzrCommandError(msg)
606
except bzrlib.errors.UnlistableBranch:
608
msg = "The branch %s cannot be used as a --basis" % (basis,)
609
raise BzrCommandError(msg)
611
branch.control_files.put_utf8('branch-name', name)
613
note('Branched %d revision(s).' % branch.revno())
620
class cmd_checkout(Command):
621
"""Create a new checkout of an existing branch.
623
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
624
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
626
To retrieve the branch as of a particular revision, supply the --revision
627
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
628
out of date [so you cannot commit] but it may be useful (i.e. to examine old
631
--basis is to speed up checking out from remote branches. When specified, it
632
uses the inventory and file contents from the basis branch in preference to the
633
branch being checked out. [Not implemented yet.]
635
takes_args = ['branch_location', 'to_location?']
636
takes_options = ['revision'] # , 'basis']
638
def run(self, branch_location, to_location=None, revision=None, basis=None):
641
elif len(revision) > 1:
642
raise BzrCommandError(
643
'bzr checkout --revision takes exactly 1 revision value')
644
source = Branch.open(branch_location)
645
if len(revision) == 1 and revision[0] is not None:
646
revision_id = revision[0].in_history(source)[1]
649
if to_location is None:
650
to_location = os.path.basename(branch_location.rstrip("/\\"))
652
os.mkdir(to_location)
654
if e.errno == errno.EEXIST:
655
raise BzrCommandError('Target directory "%s" already'
656
' exists.' % to_location)
657
if e.errno == errno.ENOENT:
658
raise BzrCommandError('Parent of "%s" does not exist.' %
662
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
663
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
664
checkout.create_workingtree(revision_id)
667
class cmd_renames(Command):
668
"""Show list of renamed files.
670
# TODO: Option to show renames between two historical versions.
672
# TODO: Only show renames under dir, rather than in the whole branch.
673
takes_args = ['dir?']
676
def run(self, dir=u'.'):
677
tree = WorkingTree.open_containing(dir)[0]
678
old_inv = tree.basis_tree().inventory
679
new_inv = tree.read_working_inventory()
681
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
683
for old_name, new_name in renames:
684
print "%s => %s" % (old_name, new_name)
687
class cmd_update(Command):
688
"""Update a tree to have the latest code committed to its branch.
690
This will perform a merge into the working tree, and may generate
691
conflicts. If you have any uncommitted changes, you will still
692
need to commit them after the update.
694
takes_args = ['dir?']
696
def run(self, dir='.'):
697
tree = WorkingTree.open_containing(dir)[0]
700
if tree.last_revision() == tree.branch.last_revision():
701
note("Tree is up to date.")
703
conflicts = tree.update()
704
note('Updated to revision %d.' %
705
(tree.branch.revision_id_to_revno(tree.last_revision()),))
714
class cmd_info(Command):
715
"""Show statistical information about a branch."""
716
takes_args = ['branch?']
719
def run(self, branch=None):
721
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0])
724
class cmd_remove(Command):
725
"""Make a file unversioned.
727
This makes bzr stop tracking changes to a versioned file. It does
728
not delete the working copy.
730
takes_args = ['file+']
731
takes_options = ['verbose']
734
def run(self, file_list, verbose=False):
735
tree, file_list = tree_files(file_list)
736
tree.remove(file_list, verbose=verbose)
739
class cmd_file_id(Command):
740
"""Print file_id of a particular file or directory.
742
The file_id is assigned when the file is first added and remains the
743
same through all revisions where the file exists, even when it is
747
takes_args = ['filename']
749
def run(self, filename):
750
tree, relpath = WorkingTree.open_containing(filename)
751
i = tree.inventory.path2id(relpath)
753
raise BzrError("%r is not a versioned file" % filename)
758
class cmd_file_path(Command):
759
"""Print path of file_ids to a file or directory.
761
This prints one line for each directory down to the target,
762
starting at the branch root."""
764
takes_args = ['filename']
766
def run(self, filename):
767
tree, relpath = WorkingTree.open_containing(filename)
769
fid = inv.path2id(relpath)
771
raise BzrError("%r is not a versioned file" % filename)
772
for fip in inv.get_idpath(fid):
776
class cmd_reconcile(Command):
777
"""Reconcile bzr metadata in a branch.
779
This can correct data mismatches that may have been caused by
780
previous ghost operations or bzr upgrades. You should only
781
need to run this command if 'bzr check' or a bzr developer
782
advises you to run it.
784
If a second branch is provided, cross-branch reconciliation is
785
also attempted, which will check that data like the tree root
786
id which was not present in very early bzr versions is represented
787
correctly in both branches.
789
At the same time it is run it may recompress data resulting in
790
a potential saving in disk space or performance gain.
792
The branch *MUST* be on a listable system such as local disk or sftp.
794
takes_args = ['branch?']
796
def run(self, branch="."):
797
from bzrlib.reconcile import reconcile
798
dir = bzrlib.bzrdir.BzrDir.open(branch)
802
class cmd_revision_history(Command):
803
"""Display list of revision ids on this branch."""
807
branch = WorkingTree.open_containing(u'.')[0].branch
808
for patchid in branch.revision_history():
812
class cmd_ancestry(Command):
813
"""List all revisions merged into this branch."""
817
tree = WorkingTree.open_containing(u'.')[0]
819
# FIXME. should be tree.last_revision
820
for revision_id in b.repository.get_ancestry(b.last_revision()):
824
class cmd_init(Command):
825
"""Make a directory into a versioned branch.
827
Use this to create an empty branch, or before importing an
830
Recipe for importing a tree of files:
835
bzr commit -m 'imported project'
837
takes_args = ['location?']
838
def run(self, location=None):
839
from bzrlib.branch import Branch
843
# The path has to exist to initialize a
844
# branch inside of it.
845
# Just using os.mkdir, since I don't
846
# believe that we want to create a bunch of
847
# locations if the user supplies an extended path
848
if not os.path.exists(location):
850
bzrdir.BzrDir.create_standalone_workingtree(location)
853
class cmd_diff(Command):
854
"""Show differences in working tree.
856
If files are listed, only the changes in those files are listed.
857
Otherwise, all changes for the tree are listed.
864
# TODO: Allow diff across branches.
865
# TODO: Option to use external diff command; could be GNU diff, wdiff,
866
# or a graphical diff.
868
# TODO: Python difflib is not exactly the same as unidiff; should
869
# either fix it up or prefer to use an external diff.
871
# TODO: If a directory is given, diff everything under that.
873
# TODO: Selected-file diff is inefficient and doesn't show you
876
# TODO: This probably handles non-Unix newlines poorly.
878
takes_args = ['file*']
879
takes_options = ['revision', 'diff-options']
880
aliases = ['di', 'dif']
883
def run(self, revision=None, file_list=None, diff_options=None):
884
from bzrlib.diff import diff_cmd_helper, show_diff_trees
886
tree1, file_list = internal_tree_files(file_list)
890
except FileInWrongBranch:
891
if len(file_list) != 2:
892
raise BzrCommandError("Files are in different branches")
894
tree1, file1 = WorkingTree.open_containing(file_list[0])
895
tree2, file2 = WorkingTree.open_containing(file_list[1])
896
if file1 != "" or file2 != "":
897
# FIXME diff those two files. rbc 20051123
898
raise BzrCommandError("Files are in different branches")
900
if revision is not None:
901
if tree2 is not None:
902
raise BzrCommandError("Can't specify -r with two branches")
903
if (len(revision) == 1) or (revision[1].spec is None):
904
return diff_cmd_helper(tree1, file_list, diff_options,
906
elif len(revision) == 2:
907
return diff_cmd_helper(tree1, file_list, diff_options,
908
revision[0], revision[1])
910
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
912
if tree2 is not None:
913
return show_diff_trees(tree1, tree2, sys.stdout,
914
specific_files=file_list,
915
external_diff_options=diff_options)
917
return diff_cmd_helper(tree1, file_list, diff_options)
920
class cmd_deleted(Command):
921
"""List files deleted in the working tree.
923
# TODO: Show files deleted since a previous revision, or
924
# between two revisions.
925
# TODO: Much more efficient way to do this: read in new
926
# directories with readdir, rather than stating each one. Same
927
# level of effort but possibly much less IO. (Or possibly not,
928
# if the directories are very large...)
930
def run(self, show_ids=False):
931
tree = WorkingTree.open_containing(u'.')[0]
932
old = tree.basis_tree()
933
for path, ie in old.inventory.iter_entries():
934
if not tree.has_id(ie.file_id):
936
print '%-50s %s' % (path, ie.file_id)
941
class cmd_modified(Command):
942
"""List files modified in working tree."""
946
from bzrlib.delta import compare_trees
948
tree = WorkingTree.open_containing(u'.')[0]
949
td = compare_trees(tree.basis_tree(), tree)
951
for path, id, kind, text_modified, meta_modified in td.modified:
956
class cmd_added(Command):
957
"""List files added in working tree."""
961
wt = WorkingTree.open_containing(u'.')[0]
962
basis_inv = wt.basis_tree().inventory
965
if file_id in basis_inv:
967
path = inv.id2path(file_id)
968
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
974
class cmd_root(Command):
975
"""Show the tree root directory.
977
The root is the nearest enclosing directory with a .bzr control
979
takes_args = ['filename?']
981
def run(self, filename=None):
982
"""Print the branch root."""
983
tree = WorkingTree.open_containing(filename)[0]
987
class cmd_log(Command):
988
"""Show log of this branch.
990
To request a range of logs, you can use the command -r begin..end
991
-r revision requests a specific revision, -r ..end or -r begin.. are
995
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
997
takes_args = ['filename?']
998
takes_options = [Option('forward',
999
help='show from oldest to newest'),
1000
'timezone', 'verbose',
1001
'show-ids', 'revision',
1005
help='show revisions whose message matches this regexp',
1010
def run(self, filename=None, timezone='original',
1020
from bzrlib.log import log_formatter, show_log
1022
assert message is None or isinstance(message, basestring), \
1023
"invalid message argument %r" % message
1024
direction = (forward and 'forward') or 'reverse'
1029
# find the file id to log:
1031
dir, fp = bzrdir.BzrDir.open_containing(filename)
1032
b = dir.open_branch()
1036
inv = dir.open_workingtree().inventory
1037
except (errors.NotBranchError, errors.NotLocalUrl):
1038
# either no tree, or is remote.
1039
inv = b.basis_tree().inventory
1040
file_id = inv.path2id(fp)
1043
# FIXME ? log the current subdir only RBC 20060203
1044
dir, relpath = bzrdir.BzrDir.open_containing('.')
1045
b = dir.open_branch()
1047
if revision is None:
1050
elif len(revision) == 1:
1051
rev1 = rev2 = revision[0].in_history(b).revno
1052
elif len(revision) == 2:
1053
if revision[0].spec is None:
1054
# missing begin-range means first revision
1057
rev1 = revision[0].in_history(b).revno
1059
if revision[1].spec is None:
1060
# missing end-range means last known revision
1063
rev2 = revision[1].in_history(b).revno
1065
raise BzrCommandError('bzr log --revision takes one or two values.')
1067
# By this point, the revision numbers are converted to the +ve
1068
# form if they were supplied in the -ve form, so we can do
1069
# this comparison in relative safety
1071
(rev2, rev1) = (rev1, rev2)
1073
mutter('encoding log as %r', bzrlib.user_encoding)
1075
# use 'replace' so that we don't abort if trying to write out
1076
# in e.g. the default C locale.
1077
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1079
if (log_format == None):
1080
default = bzrlib.config.BranchConfig(b).log_format()
1081
log_format = get_log_format(long=long, short=short, line=line, default=default)
1083
lf = log_formatter(log_format,
1086
show_timezone=timezone)
1092
direction=direction,
1093
start_revision=rev1,
1098
def get_log_format(long=False, short=False, line=False, default='long'):
1099
log_format = default
1103
log_format = 'short'
1109
class cmd_touching_revisions(Command):
1110
"""Return revision-ids which affected a particular file.
1112
A more user-friendly interface is "bzr log FILE"."""
1114
takes_args = ["filename"]
1116
def run(self, filename):
1117
tree, relpath = WorkingTree.open_containing(filename)
1119
inv = tree.read_working_inventory()
1120
file_id = inv.path2id(relpath)
1121
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1122
print "%6d %s" % (revno, what)
1125
class cmd_ls(Command):
1126
"""List files in a tree.
1128
# TODO: Take a revision or remote path and list that tree instead.
1130
takes_options = ['verbose', 'revision',
1131
Option('non-recursive',
1132
help='don\'t recurse into sub-directories'),
1134
help='Print all paths from the root of the branch.'),
1135
Option('unknown', help='Print unknown files'),
1136
Option('versioned', help='Print versioned files'),
1137
Option('ignored', help='Print ignored files'),
1139
Option('null', help='Null separate the files'),
1142
def run(self, revision=None, verbose=False,
1143
non_recursive=False, from_root=False,
1144
unknown=False, versioned=False, ignored=False,
1147
if verbose and null:
1148
raise BzrCommandError('Cannot set both --verbose and --null')
1149
all = not (unknown or versioned or ignored)
1151
selection = {'I':ignored, '?':unknown, 'V':versioned}
1153
tree, relpath = WorkingTree.open_containing(u'.')
1158
if revision is not None:
1159
tree = tree.branch.repository.revision_tree(
1160
revision[0].in_history(tree.branch).rev_id)
1161
for fp, fc, kind, fid, entry in tree.list_files():
1162
if fp.startswith(relpath):
1163
fp = fp[len(relpath):]
1164
if non_recursive and '/' in fp:
1166
if not all and not selection[fc]:
1169
kindch = entry.kind_character()
1170
print '%-8s %s%s' % (fc, fp, kindch)
1172
sys.stdout.write(fp)
1173
sys.stdout.write('\0')
1179
class cmd_unknowns(Command):
1180
"""List unknown files."""
1183
from bzrlib.osutils import quotefn
1184
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1188
class cmd_ignore(Command):
1189
"""Ignore a command or pattern.
1191
To remove patterns from the ignore list, edit the .bzrignore file.
1193
If the pattern contains a slash, it is compared to the whole path
1194
from the branch root. Otherwise, it is compared to only the last
1195
component of the path. To match a file only in the root directory,
1198
Ignore patterns are case-insensitive on case-insensitive systems.
1200
Note: wildcards must be quoted from the shell on Unix.
1203
bzr ignore ./Makefile
1204
bzr ignore '*.class'
1206
# TODO: Complain if the filename is absolute
1207
takes_args = ['name_pattern']
1209
def run(self, name_pattern):
1210
from bzrlib.atomicfile import AtomicFile
1213
tree, relpath = WorkingTree.open_containing(u'.')
1214
ifn = tree.abspath('.bzrignore')
1216
if os.path.exists(ifn):
1219
igns = f.read().decode('utf-8')
1225
# TODO: If the file already uses crlf-style termination, maybe
1226
# we should use that for the newly added lines?
1228
if igns and igns[-1] != '\n':
1230
igns += name_pattern + '\n'
1233
f = AtomicFile(ifn, 'wt')
1234
f.write(igns.encode('utf-8'))
1239
inv = tree.inventory
1240
if inv.path2id('.bzrignore'):
1241
mutter('.bzrignore is already versioned')
1243
mutter('need to make new .bzrignore file versioned')
1244
tree.add(['.bzrignore'])
1247
class cmd_ignored(Command):
1248
"""List ignored files and the patterns that matched them.
1250
See also: bzr ignore"""
1253
tree = WorkingTree.open_containing(u'.')[0]
1254
for path, file_class, kind, file_id, entry in tree.list_files():
1255
if file_class != 'I':
1257
## XXX: Slightly inefficient since this was already calculated
1258
pat = tree.is_ignored(path)
1259
print '%-50s %s' % (path, pat)
1262
class cmd_lookup_revision(Command):
1263
"""Lookup the revision-id from a revision-number
1266
bzr lookup-revision 33
1269
takes_args = ['revno']
1272
def run(self, revno):
1276
raise BzrCommandError("not a valid revision-number: %r" % revno)
1278
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1281
class cmd_export(Command):
1282
"""Export past revision to destination directory.
1284
If no revision is specified this exports the last committed revision.
1286
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1287
given, try to find the format with the extension. If no extension
1288
is found exports to a directory (equivalent to --format=dir).
1290
Root may be the top directory for tar, tgz and tbz2 formats. If none
1291
is given, the top directory will be the root name of the file.
1293
Note: export of tree with non-ascii filenames to zip is not supported.
1295
Supported formats Autodetected by extension
1296
----------------- -------------------------
1299
tbz2 .tar.bz2, .tbz2
1303
takes_args = ['dest']
1304
takes_options = ['revision', 'format', 'root']
1305
def run(self, dest, revision=None, format=None, root=None):
1307
from bzrlib.export import export
1308
tree = WorkingTree.open_containing(u'.')[0]
1310
if revision is None:
1311
# should be tree.last_revision FIXME
1312
rev_id = b.last_revision()
1314
if len(revision) != 1:
1315
raise BzrError('bzr export --revision takes exactly 1 argument')
1316
rev_id = revision[0].in_history(b).rev_id
1317
t = b.repository.revision_tree(rev_id)
1319
export(t, dest, format, root)
1320
except errors.NoSuchExportFormat, e:
1321
raise BzrCommandError('Unsupported export format: %s' % e.format)
1324
class cmd_cat(Command):
1325
"""Write a file's text from a previous revision."""
1327
takes_options = ['revision']
1328
takes_args = ['filename']
1331
def run(self, filename, revision=None):
1332
if revision is not None and len(revision) != 1:
1333
raise BzrCommandError("bzr cat --revision takes exactly one number")
1336
tree, relpath = WorkingTree.open_containing(filename)
1338
except NotBranchError:
1342
b, relpath = Branch.open_containing(filename)
1343
if revision is None:
1344
revision_id = b.last_revision()
1346
revision_id = revision[0].in_history(b).rev_id
1347
b.print_file(relpath, revision_id)
1350
class cmd_local_time_offset(Command):
1351
"""Show the offset in seconds from GMT to local time."""
1355
print bzrlib.osutils.local_time_offset()
1359
class cmd_commit(Command):
1360
"""Commit changes into a new revision.
1362
If no arguments are given, the entire tree is committed.
1364
If selected files are specified, only changes to those files are
1365
committed. If a directory is specified then the directory and everything
1366
within it is committed.
1368
A selected-file commit may fail in some cases where the committed
1369
tree would be invalid, such as trying to commit a file in a
1370
newly-added directory that is not itself committed.
1372
# TODO: Run hooks on tree to-be-committed, and after commit.
1374
# TODO: Strict commit that fails if there are deleted files.
1375
# (what does "deleted files" mean ??)
1377
# TODO: Give better message for -s, --summary, used by tla people
1379
# XXX: verbose currently does nothing
1381
takes_args = ['selected*']
1382
takes_options = ['message', 'verbose',
1384
help='commit even if nothing has changed'),
1385
Option('file', type=str,
1387
help='file containing commit message'),
1389
help="refuse to commit if there are unknown "
1390
"files in the working tree."),
1392
help="perform a local only commit in a bound "
1393
"branch. Such commits are not pushed to "
1394
"the master branch until a normal commit "
1398
aliases = ['ci', 'checkin']
1400
def run(self, message=None, file=None, verbose=True, selected_list=None,
1401
unchanged=False, strict=False, local=False):
1402
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1404
from bzrlib.msgeditor import edit_commit_message, \
1405
make_commit_message_template
1406
from tempfile import TemporaryFile
1409
# TODO: Need a blackbox test for invoking the external editor; may be
1410
# slightly problematic to run this cross-platform.
1412
# TODO: do more checks that the commit will succeed before
1413
# spending the user's valuable time typing a commit message.
1415
# TODO: if the commit *does* happen to fail, then save the commit
1416
# message to a temporary file where it can be recovered
1417
tree, selected_list = tree_files(selected_list)
1418
if local and not tree.branch.get_bound_location():
1419
raise errors.LocalRequiresBoundBranch()
1420
if message is None and not file:
1421
template = make_commit_message_template(tree, selected_list)
1422
message = edit_commit_message(template)
1424
raise BzrCommandError("please specify a commit message"
1425
" with either --message or --file")
1426
elif message and file:
1427
raise BzrCommandError("please specify either --message or --file")
1431
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1434
raise BzrCommandError("empty commit message specified")
1437
tree.commit(message, specific_files=selected_list,
1438
allow_pointless=unchanged, strict=strict)
1439
except PointlessCommit:
1440
# FIXME: This should really happen before the file is read in;
1441
# perhaps prepare the commit; get the message; then actually commit
1442
raise BzrCommandError("no changes to commit",
1443
["use --unchanged to commit anyhow"])
1444
except ConflictsInTree:
1445
raise BzrCommandError("Conflicts detected in working tree. "
1446
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1447
except StrictCommitFailed:
1448
raise BzrCommandError("Commit refused because there are unknown "
1449
"files in the working tree.")
1450
except errors.BoundBranchOutOfDate, e:
1451
raise BzrCommandError(str(e)
1452
+ ' Either unbind or update.')
1454
note('Committed revision %d.' % (tree.branch.revno(),))
1457
class cmd_check(Command):
1458
"""Validate consistency of branch history.
1460
This command checks various invariants about the branch storage to
1461
detect data corruption or bzr bugs.
1463
takes_args = ['branch?']
1464
takes_options = ['verbose']
1466
def run(self, branch=None, verbose=False):
1467
from bzrlib.check import check
1469
tree = WorkingTree.open_containing()[0]
1470
branch = tree.branch
1472
branch = Branch.open(branch)
1473
check(branch, verbose)
1476
class cmd_scan_cache(Command):
1479
from bzrlib.hashcache import HashCache
1485
print '%6d stats' % c.stat_count
1486
print '%6d in hashcache' % len(c._cache)
1487
print '%6d files removed from cache' % c.removed_count
1488
print '%6d hashes updated' % c.update_count
1489
print '%6d files changed too recently to cache' % c.danger_count
1495
def get_format_type(typestring):
1496
"""Parse and return a format specifier."""
1497
if typestring == "metadir":
1498
return bzrdir.BzrDirMetaFormat1()
1499
if typestring == "knit":
1500
format = bzrdir.BzrDirMetaFormat1()
1501
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
1503
msg = "No known bzr-dir format %s. Supported types are: metadir\n" %\
1505
raise BzrCommandError(msg)
1508
class cmd_upgrade(Command):
1509
"""Upgrade branch storage to current format.
1511
The check command or bzr developers may sometimes advise you to run
1512
this command. When the default format has changed you may also be warned
1513
during other operations to upgrade.
1515
takes_args = ['url?']
1518
help='Upgrade to a specific format rather than the'
1519
' current default format. Currently this '
1520
' option only accepts =metadir',
1521
type=get_format_type),
1525
def run(self, url='.', format=None):
1526
from bzrlib.upgrade import upgrade
1527
upgrade(url, format)
1530
class cmd_whoami(Command):
1531
"""Show bzr user id."""
1532
takes_options = ['email']
1535
def run(self, email=False):
1537
b = WorkingTree.open_containing(u'.')[0].branch
1538
config = bzrlib.config.BranchConfig(b)
1539
except NotBranchError:
1540
config = bzrlib.config.GlobalConfig()
1543
print config.user_email()
1545
print config.username()
1548
class cmd_nick(Command):
1549
"""Print or set the branch nickname.
1551
If unset, the tree root directory name is used as the nickname
1552
To print the current nickname, execute with no argument.
1554
takes_args = ['nickname?']
1555
def run(self, nickname=None):
1556
branch = Branch.open_containing(u'.')[0]
1557
if nickname is None:
1558
self.printme(branch)
1560
branch.nick = nickname
1563
def printme(self, branch):
1567
class cmd_selftest(Command):
1568
"""Run internal test suite.
1570
This creates temporary test directories in the working directory,
1571
but not existing data is affected. These directories are deleted
1572
if the tests pass, or left behind to help in debugging if they
1573
fail and --keep-output is specified.
1575
If arguments are given, they are regular expressions that say
1576
which tests should run.
1578
If the global option '--no-plugins' is given, plugins are not loaded
1579
before running the selftests. This has two effects: features provided or
1580
modified by plugins will not be tested, and tests provided by plugins will
1585
bzr --no-plugins selftest -v
1587
# TODO: --list should give a list of all available tests
1589
# NB: this is used from the class without creating an instance, which is
1590
# why it does not have a self parameter.
1591
def get_transport_type(typestring):
1592
"""Parse and return a transport specifier."""
1593
if typestring == "sftp":
1594
from bzrlib.transport.sftp import SFTPAbsoluteServer
1595
return SFTPAbsoluteServer
1596
if typestring == "memory":
1597
from bzrlib.transport.memory import MemoryServer
1599
msg = "No known transport type %s. Supported types are: sftp\n" %\
1601
raise BzrCommandError(msg)
1604
takes_args = ['testspecs*']
1605
takes_options = ['verbose',
1606
Option('one', help='stop when one test fails'),
1607
Option('keep-output',
1608
help='keep output directories when tests fail'),
1610
help='Use a different transport by default '
1611
'throughout the test suite.',
1612
type=get_transport_type),
1615
def run(self, testspecs_list=None, verbose=False, one=False,
1616
keep_output=False, transport=None):
1618
from bzrlib.tests import selftest
1619
# we don't want progress meters from the tests to go to the
1620
# real output; and we don't want log messages cluttering up
1622
save_ui = bzrlib.ui.ui_factory
1623
bzrlib.trace.info('running tests...')
1625
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1626
if testspecs_list is not None:
1627
pattern = '|'.join(testspecs_list)
1630
result = selftest(verbose=verbose,
1632
stop_on_failure=one,
1633
keep_output=keep_output,
1634
transport=transport)
1636
bzrlib.trace.info('tests passed')
1638
bzrlib.trace.info('tests failed')
1639
return int(not result)
1641
bzrlib.ui.ui_factory = save_ui
1644
def _get_bzr_branch():
1645
"""If bzr is run from a branch, return Branch or None"""
1646
import bzrlib.errors
1647
from bzrlib.branch import Branch
1648
from bzrlib.osutils import abspath
1649
from os.path import dirname
1652
branch = Branch.open(dirname(abspath(dirname(__file__))))
1654
except bzrlib.errors.BzrError:
1659
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1660
# is bzrlib itself in a branch?
1661
branch = _get_bzr_branch()
1663
rh = branch.revision_history()
1665
print " bzr checkout, revision %d" % (revno,)
1666
print " nick: %s" % (branch.nick,)
1668
print " revid: %s" % (rh[-1],)
1669
print bzrlib.__copyright__
1670
print "http://bazaar-ng.org/"
1672
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1673
print "you may use, modify and redistribute it under the terms of the GNU"
1674
print "General Public License version 2 or later."
1677
class cmd_version(Command):
1678
"""Show version of bzr."""
1683
class cmd_rocks(Command):
1684
"""Statement of optimism."""
1688
print "it sure does!"
1691
class cmd_find_merge_base(Command):
1692
"""Find and print a base revision for merging two branches.
1694
# TODO: Options to specify revisions on either side, as if
1695
# merging only part of the history.
1696
takes_args = ['branch', 'other']
1700
def run(self, branch, other):
1701
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1703
branch1 = Branch.open_containing(branch)[0]
1704
branch2 = Branch.open_containing(other)[0]
1706
history_1 = branch1.revision_history()
1707
history_2 = branch2.revision_history()
1709
last1 = branch1.last_revision()
1710
last2 = branch2.last_revision()
1712
source = MultipleRevisionSources(branch1.repository,
1715
base_rev_id = common_ancestor(last1, last2, source)
1717
print 'merge base is revision %s' % base_rev_id
1721
if base_revno is None:
1722
raise bzrlib.errors.UnrelatedBranches()
1724
print ' r%-6d in %s' % (base_revno, branch)
1726
other_revno = branch2.revision_id_to_revno(base_revid)
1728
print ' r%-6d in %s' % (other_revno, other)
1732
class cmd_merge(Command):
1733
"""Perform a three-way merge.
1735
The branch is the branch you will merge from. By default, it will
1736
merge the latest revision. If you specify a revision, that
1737
revision will be merged. If you specify two revisions, the first
1738
will be used as a BASE, and the second one as OTHER. Revision
1739
numbers are always relative to the specified branch.
1741
By default bzr will try to merge in all new work from the other
1742
branch, automatically determining an appropriate base. If this
1743
fails, you may need to give an explicit base.
1747
To merge the latest revision from bzr.dev
1748
bzr merge ../bzr.dev
1750
To merge changes up to and including revision 82 from bzr.dev
1751
bzr merge -r 82 ../bzr.dev
1753
To merge the changes introduced by 82, without previous changes:
1754
bzr merge -r 81..82 ../bzr.dev
1756
merge refuses to run if there are any uncommitted changes, unless
1759
takes_args = ['branch?']
1760
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1761
Option('show-base', help="Show base revision text in "
1764
def run(self, branch=None, revision=None, force=False, merge_type=None,
1765
show_base=False, reprocess=False):
1766
if merge_type is None:
1767
merge_type = Merge3Merger
1769
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1771
raise BzrCommandError("No merge location known or specified.")
1773
print "Using saved location: %s" % branch
1774
if revision is None or len(revision) < 1:
1776
other = [branch, -1]
1778
if len(revision) == 1:
1780
other_branch = Branch.open_containing(branch)[0]
1781
revno = revision[0].in_history(other_branch).revno
1782
other = [branch, revno]
1784
assert len(revision) == 2
1785
if None in revision:
1786
raise BzrCommandError(
1787
"Merge doesn't permit that revision specifier.")
1788
b = Branch.open_containing(branch)[0]
1790
base = [branch, revision[0].in_history(b).revno]
1791
other = [branch, revision[1].in_history(b).revno]
1794
conflict_count = merge(other, base, check_clean=(not force),
1795
merge_type=merge_type, reprocess=reprocess,
1796
show_base=show_base,
1797
pb=bzrlib.ui.ui_factory.progress_bar())
1798
if conflict_count != 0:
1802
except bzrlib.errors.AmbiguousBase, e:
1803
m = ("sorry, bzr can't determine the right merge base yet\n"
1804
"candidates are:\n "
1805
+ "\n ".join(e.bases)
1807
"please specify an explicit base with -r,\n"
1808
"and (if you want) report this to the bzr developers\n")
1812
class cmd_remerge(Command):
1815
takes_args = ['file*']
1816
takes_options = ['merge-type', 'reprocess',
1817
Option('show-base', help="Show base revision text in "
1820
def run(self, file_list=None, merge_type=None, show_base=False,
1822
from bzrlib.merge import merge_inner, transform_tree
1823
if merge_type is None:
1824
merge_type = Merge3Merger
1825
tree, file_list = tree_files(file_list)
1828
pending_merges = tree.pending_merges()
1829
if len(pending_merges) != 1:
1830
raise BzrCommandError("Sorry, remerge only works after normal"
1831
+ " merges. Not cherrypicking or"
1833
repository = tree.branch.repository
1834
base_revision = common_ancestor(tree.branch.last_revision(),
1835
pending_merges[0], repository)
1836
base_tree = repository.revision_tree(base_revision)
1837
other_tree = repository.revision_tree(pending_merges[0])
1838
interesting_ids = None
1839
if file_list is not None:
1840
interesting_ids = set()
1841
for filename in file_list:
1842
file_id = tree.path2id(filename)
1844
raise NotVersionedError(filename)
1845
interesting_ids.add(file_id)
1846
if tree.kind(file_id) != "directory":
1849
for name, ie in tree.inventory.iter_entries(file_id):
1850
interesting_ids.add(ie.file_id)
1851
transform_tree(tree, tree.basis_tree(), interesting_ids)
1852
if file_list is None:
1853
restore_files = list(tree.iter_conflicts())
1855
restore_files = file_list
1856
for filename in restore_files:
1858
restore(tree.abspath(filename))
1859
except NotConflicted:
1861
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1862
interesting_ids = interesting_ids,
1863
other_rev_id=pending_merges[0],
1864
merge_type=merge_type,
1865
show_base=show_base,
1866
reprocess=reprocess)
1874
class cmd_revert(Command):
1875
"""Reverse all changes since the last commit.
1877
Only versioned files are affected. Specify filenames to revert only
1878
those files. By default, any files that are changed will be backed up
1879
first. Backup files have a '~' appended to their name.
1881
takes_options = ['revision', 'no-backup']
1882
takes_args = ['file*']
1883
aliases = ['merge-revert']
1885
def run(self, revision=None, no_backup=False, file_list=None):
1886
from bzrlib.commands import parse_spec
1887
if file_list is not None:
1888
if len(file_list) == 0:
1889
raise BzrCommandError("No files specified")
1893
tree, file_list = tree_files(file_list)
1894
if revision is None:
1895
# FIXME should be tree.last_revision
1896
rev_id = tree.branch.last_revision()
1897
elif len(revision) != 1:
1898
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1900
rev_id = revision[0].in_history(tree.branch).rev_id
1901
tree.revert(file_list, tree.branch.repository.revision_tree(rev_id),
1902
not no_backup, bzrlib.ui.ui_factory.progress_bar())
1905
class cmd_assert_fail(Command):
1906
"""Test reporting of assertion failures"""
1909
assert False, "always fails"
1912
class cmd_help(Command):
1913
"""Show help on a command or other topic.
1915
For a list of all available commands, say 'bzr help commands'."""
1916
takes_options = [Option('long', 'show help on all commands')]
1917
takes_args = ['topic?']
1921
def run(self, topic=None, long=False):
1923
if topic is None and long:
1928
class cmd_shell_complete(Command):
1929
"""Show appropriate completions for context.
1931
For a list of all available commands, say 'bzr shell-complete'."""
1932
takes_args = ['context?']
1937
def run(self, context=None):
1938
import shellcomplete
1939
shellcomplete.shellcomplete(context)
1942
class cmd_fetch(Command):
1943
"""Copy in history from another branch but don't merge it.
1945
This is an internal method used for pull and merge."""
1947
takes_args = ['from_branch', 'to_branch']
1948
def run(self, from_branch, to_branch):
1949
from bzrlib.fetch import Fetcher
1950
from bzrlib.branch import Branch
1951
from_b = Branch.open(from_branch)
1952
to_b = Branch.open(to_branch)
1953
Fetcher(to_b, from_b)
1956
class cmd_missing(Command):
1957
"""Show unmerged/unpulled revisions between two branches.
1959
OTHER_BRANCH may be local or remote."""
1960
takes_args = ['other_branch?']
1961
takes_options = [Option('reverse', 'Reverse the order of revisions'),
1963
'Display changes in the local branch only'),
1964
Option('theirs-only',
1965
'Display changes in the remote branch only'),
1974
def run(self, other_branch=None, reverse=False, mine_only=False,
1975
theirs_only=False, log_format=None, long=False, short=False, line=False,
1976
show_ids=False, verbose=False):
1977
from bzrlib.missing import find_unmerged, iter_log_data
1978
from bzrlib.log import log_formatter
1979
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
1980
parent = local_branch.get_parent()
1981
if other_branch is None:
1982
other_branch = parent
1983
if other_branch is None:
1984
raise BzrCommandError("No missing location known or specified.")
1985
print "Using last location: " + local_branch.get_parent()
1986
remote_branch = bzrlib.branch.Branch.open(other_branch)
1987
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1988
if (log_format == None):
1989
default = bzrlib.config.BranchConfig(local_branch).log_format()
1990
log_format = get_log_format(long=long, short=short, line=line, default=default)
1991
lf = log_formatter(log_format, sys.stdout,
1993
show_timezone='original')
1994
if reverse is False:
1995
local_extra.reverse()
1996
remote_extra.reverse()
1997
if local_extra and not theirs_only:
1998
print "You have %d extra revision(s):" % len(local_extra)
1999
for data in iter_log_data(local_extra, local_branch.repository,
2002
printed_local = True
2004
printed_local = False
2005
if remote_extra and not mine_only:
2006
if printed_local is True:
2008
print "You are missing %d revision(s):" % len(remote_extra)
2009
for data in iter_log_data(remote_extra, remote_branch.repository,
2012
if not remote_extra and not local_extra:
2014
print "Branches are up to date."
2017
if parent is None and other_branch is not None:
2018
local_branch.set_parent(other_branch)
2022
class cmd_plugins(Command):
2027
import bzrlib.plugin
2028
from inspect import getdoc
2029
for name, plugin in bzrlib.plugin.all_plugins().items():
2030
if hasattr(plugin, '__path__'):
2031
print plugin.__path__[0]
2032
elif hasattr(plugin, '__file__'):
2033
print plugin.__file__
2039
print '\t', d.split('\n')[0]
2042
class cmd_testament(Command):
2043
"""Show testament (signing-form) of a revision."""
2044
takes_options = ['revision', 'long']
2045
takes_args = ['branch?']
2047
def run(self, branch=u'.', revision=None, long=False):
2048
from bzrlib.testament import Testament
2049
b = WorkingTree.open_containing(branch)[0].branch
2052
if revision is None:
2053
rev_id = b.last_revision()
2055
rev_id = revision[0].in_history(b).rev_id
2056
t = Testament.from_revision(b.repository, rev_id)
2058
sys.stdout.writelines(t.as_text_lines())
2060
sys.stdout.write(t.as_short_text())
2065
class cmd_annotate(Command):
2066
"""Show the origin of each line in a file.
2068
This prints out the given file with an annotation on the left side
2069
indicating which revision, author and date introduced the change.
2071
If the origin is the same for a run of consecutive lines, it is
2072
shown only at the top, unless the --all option is given.
2074
# TODO: annotate directories; showing when each file was last changed
2075
# TODO: annotate a previous version of a file
2076
# TODO: if the working copy is modified, show annotations on that
2077
# with new uncommitted lines marked
2078
aliases = ['blame', 'praise']
2079
takes_args = ['filename']
2080
takes_options = [Option('all', help='show annotations on all lines'),
2081
Option('long', help='show date in annotations'),
2085
def run(self, filename, all=False, long=False):
2086
from bzrlib.annotate import annotate_file
2087
tree, relpath = WorkingTree.open_containing(filename)
2088
branch = tree.branch
2091
file_id = tree.inventory.path2id(relpath)
2092
tree = branch.repository.revision_tree(branch.last_revision())
2093
file_version = tree.inventory[file_id].revision
2094
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2099
class cmd_re_sign(Command):
2100
"""Create a digital signature for an existing revision."""
2101
# TODO be able to replace existing ones.
2103
hidden = True # is this right ?
2104
takes_args = ['revision_id*']
2105
takes_options = ['revision']
2107
def run(self, revision_id_list=None, revision=None):
2108
import bzrlib.config as config
2109
import bzrlib.gpg as gpg
2110
if revision_id_list is not None and revision is not None:
2111
raise BzrCommandError('You can only supply one of revision_id or --revision')
2112
if revision_id_list is None and revision is None:
2113
raise BzrCommandError('You must supply either --revision or a revision_id')
2114
b = WorkingTree.open_containing(u'.')[0].branch
2115
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2116
if revision_id_list is not None:
2117
for revision_id in revision_id_list:
2118
b.repository.sign_revision(revision_id, gpg_strategy)
2119
elif revision is not None:
2120
if len(revision) == 1:
2121
revno, rev_id = revision[0].in_history(b)
2122
b.repository.sign_revision(rev_id, gpg_strategy)
2123
elif len(revision) == 2:
2124
# are they both on rh- if so we can walk between them
2125
# might be nice to have a range helper for arbitrary
2126
# revision paths. hmm.
2127
from_revno, from_revid = revision[0].in_history(b)
2128
to_revno, to_revid = revision[1].in_history(b)
2129
if to_revid is None:
2130
to_revno = b.revno()
2131
if from_revno is None or to_revno is None:
2132
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2133
for revno in range(from_revno, to_revno + 1):
2134
b.repository.sign_revision(b.get_rev_id(revno),
2137
raise BzrCommandError('Please supply either one revision, or a range.')
2140
class cmd_bind(Command):
2141
"""Bind the current branch to its parent.
2143
After binding, commits must succeed on the parent branch
2144
before they can be done on the local one.
2147
takes_args = ['location?']
2150
def run(self, location=None):
2151
b, relpath = Branch.open_containing(u'.')
2152
if location is None:
2153
location = b.get_bound_location()
2154
if location is None:
2155
location = b.get_parent()
2156
if location is None:
2157
raise BzrCommandError('Branch has no parent,'
2158
' you must supply a bind location.')
2159
b_other = Branch.open(location)
2162
except DivergedBranches:
2163
raise BzrCommandError('These branches have diverged.'
2164
' Try merging, and then bind again.')
2167
class cmd_unbind(Command):
2168
"""Bind the current branch to its parent.
2170
After unbinding, the local branch is considered independent.
2177
b, relpath = Branch.open_containing(u'.')
2179
raise BzrCommandError('Local branch is not bound')
2182
class cmd_update(Command):
2183
"""Update the local tree for checkouts and bound branches.
2186
wt, relpath = WorkingTree.open_containing(u'.')
2187
# TODO: jam 20051127 Check here to see if this is a checkout
2188
bound_loc = wt.branch.get_bound_location()
2190
raise BzrCommandError('Working tree %s is not a checkout'
2191
' or a bound branch, you probably'
2192
' want pull' % wt.base)
2194
br_bound = Branch.open(bound_loc)
2196
wt.pull(br_bound, overwrite=False)
2197
except DivergedBranches:
2198
raise BzrCommandError("These branches have diverged."
2202
class cmd_uncommit(bzrlib.commands.Command):
2203
"""Remove the last committed revision.
2205
By supplying the --all flag, it will not only remove the entry
2206
from revision_history, but also remove all of the entries in the
2209
--verbose will print out what is being removed.
2210
--dry-run will go through all the motions, but not actually
2213
In the future, uncommit will create a changeset, which can then
2216
TODO: jam 20060108 Add an option to allow uncommit to remove unreferenced
2217
information in 'branch-as-repostory' branches.
2218
TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2219
information in shared branches as well.
2221
takes_options = ['verbose', 'revision',
2222
Option('dry-run', help='Don\'t actually make changes'),
2223
Option('force', help='Say yes to all questions.')]
2224
takes_args = ['location?']
2227
def run(self, location=None,
2228
dry_run=False, verbose=False,
2229
revision=None, force=False):
2230
from bzrlib.branch import Branch
2231
from bzrlib.log import log_formatter
2233
from bzrlib.uncommit import uncommit
2235
if location is None:
2237
control, relpath = bzrdir.BzrDir.open_containing(location)
2238
b = control.open_branch()
2240
tree = control.open_workingtree()
2241
except (errors.NoWorkingTree, errors.NotLocalUrl):
2244
if revision is None:
2246
rev_id = b.last_revision()
2248
revno, rev_id = revision[0].in_history(b)
2250
print 'No revisions to uncommit.'
2252
for r in range(revno, b.revno()+1):
2253
rev_id = b.get_rev_id(r)
2254
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2255
lf.show(r, b.repository.get_revision(rev_id), None)
2258
print 'Dry-run, pretending to remove the above revisions.'
2260
val = raw_input('Press <enter> to continue')
2262
print 'The above revision(s) will be removed.'
2264
val = raw_input('Are you sure [y/N]? ')
2265
if val.lower() not in ('y', 'yes'):
2269
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2273
def merge(other_revision, base_revision,
2274
check_clean=True, ignore_zero=False,
2275
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2276
file_list=None, show_base=False, reprocess=False,
2277
pb=DummyProgress()):
2278
"""Merge changes into a tree.
2281
list(path, revno) Base for three-way merge.
2282
If [None, None] then a base will be automatically determined.
2284
list(path, revno) Other revision for three-way merge.
2286
Directory to merge changes into; '.' by default.
2288
If true, this_dir must have no uncommitted changes before the
2290
ignore_zero - If true, suppress the "zero conflicts" message when
2291
there are no conflicts; should be set when doing something we expect
2292
to complete perfectly.
2293
file_list - If supplied, merge only changes to selected files.
2295
All available ancestors of other_revision and base_revision are
2296
automatically pulled into the branch.
2298
The revno may be -1 to indicate the last revision on the branch, which is
2301
This function is intended for use from the command line; programmatic
2302
clients might prefer to call merge.merge_inner(), which has less magic
2305
from bzrlib.merge import Merger
2306
if this_dir is None:
2308
this_tree = WorkingTree.open_containing(this_dir)[0]
2309
if show_base and not merge_type is Merge3Merger:
2310
raise BzrCommandError("Show-base is not supported for this merge"
2311
" type. %s" % merge_type)
2312
if reprocess and not merge_type is Merge3Merger:
2313
raise BzrCommandError("Reprocess is not supported for this merge"
2314
" type. %s" % merge_type)
2315
if reprocess and show_base:
2316
raise BzrCommandError("Cannot reprocess and show base.")
2317
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2318
merger.check_basis(check_clean)
2319
merger.set_other(other_revision)
2320
merger.set_base(base_revision)
2321
if merger.base_rev_id == merger.other_rev_id:
2322
note('Nothing to do.')
2324
merger.backup_files = backup_files
2325
merger.merge_type = merge_type
2326
merger.set_interesting_files(file_list)
2327
merger.show_base = show_base
2328
merger.reprocess = reprocess
2329
conflicts = merger.do_merge()
2330
merger.set_pending()
2334
# these get imported and then picked up by the scan for cmd_*
2335
# TODO: Some more consistent way to split command definitions across files;
2336
# we do need to load at least some information about them to know of
2338
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2339
from bzrlib.sign_my_commits import cmd_sign_my_commits
added
removed
bzrlib/builtins.py
