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"""
19
# DO NOT change this to cStringIO - it results in control files
21
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
24
from StringIO import StringIO
29
from bzrlib import BZRDIR
30
from bzrlib.commands import Command, display_command
31
from bzrlib.branch import Branch
32
from bzrlib.revision import common_ancestor
33
import bzrlib.errors as errors
34
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch)
37
from bzrlib.option import Option
38
from bzrlib.revisionspec import RevisionSpec
40
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
41
from bzrlib.workingtree import WorkingTree
42
from bzrlib.log import show_one_log
45
def tree_files(file_list, default_branch=u'.'):
47
return internal_tree_files(file_list, default_branch)
48
except FileInWrongBranch, e:
49
raise BzrCommandError("%s is not in the same branch as %s" %
50
(e.path, file_list[0]))
52
def internal_tree_files(file_list, default_branch=u'.'):
54
Return a branch and list of branch-relative paths.
55
If supplied file_list is empty or None, the branch default will be used,
56
and returned file_list will match the original.
58
if file_list is None or len(file_list) == 0:
59
return WorkingTree.open_containing(default_branch)[0], file_list
60
tree = WorkingTree.open_containing(file_list[0])[0]
62
for filename in file_list:
64
new_list.append(tree.relpath(filename))
65
except errors.PathNotChild:
66
raise FileInWrongBranch(tree.branch, filename)
70
# TODO: Make sure no commands unconditionally use the working directory as a
71
# branch. If a filename argument is used, the first of them should be used to
72
# specify the branch. (Perhaps this can be factored out into some kind of
73
# Argument class, representing a file in a branch, where the first occurrence
76
class cmd_status(Command):
77
"""Display status summary.
79
This reports on versioned and unknown files, reporting them
80
grouped by state. Possible states are:
83
Versioned in the working copy but not in the previous revision.
86
Versioned in the previous revision but removed or deleted
90
Path of this file changed from the previous revision;
91
the text may also have changed. This includes files whose
92
parent directory was renamed.
95
Text has changed since the previous revision.
98
Nothing about this file has changed since the previous revision.
99
Only shown with --all.
102
Not versioned and not matching an ignore pattern.
104
To see ignored files use 'bzr ignored'. For details in the
105
changes to file texts, use 'bzr diff'.
107
If no arguments are specified, the status of the entire working
108
directory is shown. Otherwise, only the status of the specified
109
files or directories is reported. If a directory is given, status
110
is reported for everything inside that directory.
112
If a revision argument is given, the status is calculated against
113
that revision, or between two revisions if two are provided.
116
# TODO: --no-recurse, --recurse options
118
takes_args = ['file*']
119
takes_options = ['all', 'show-ids', 'revision']
120
aliases = ['st', 'stat']
123
def run(self, all=False, show_ids=False, file_list=None, revision=None):
124
tree, file_list = tree_files(file_list)
126
from bzrlib.status import show_status
127
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
128
specific_files=file_list, revision=revision)
131
class cmd_cat_revision(Command):
132
"""Write out metadata for a revision.
134
The revision to print can either be specified by a specific
135
revision identifier, or you can use --revision.
139
takes_args = ['revision_id?']
140
takes_options = ['revision']
143
def run(self, revision_id=None, revision=None):
145
if revision_id is not None and revision is not None:
146
raise BzrCommandError('You can only supply one of revision_id or --revision')
147
if revision_id is None and revision is None:
148
raise BzrCommandError('You must supply either --revision or a revision_id')
149
b = WorkingTree.open_containing(u'.')[0].branch
150
if revision_id is not None:
151
sys.stdout.write(b.get_revision_xml(revision_id))
152
elif revision is not None:
155
raise BzrCommandError('You cannot specify a NULL revision.')
156
revno, rev_id = rev.in_history(b)
157
sys.stdout.write(b.get_revision_xml(rev_id))
160
class cmd_revno(Command):
161
"""Show current revision number.
163
This is equal to the number of revisions on this branch."""
164
takes_args = ['location?']
166
def run(self, location=u'.'):
167
print Branch.open_containing(location)[0].revno()
170
class cmd_revision_info(Command):
171
"""Show revision number and revision id for a given revision identifier.
174
takes_args = ['revision_info*']
175
takes_options = ['revision']
177
def run(self, revision=None, revision_info_list=[]):
180
if revision is not None:
181
revs.extend(revision)
182
if revision_info_list is not None:
183
for rev in revision_info_list:
184
revs.append(RevisionSpec(rev))
186
raise BzrCommandError('You must supply a revision identifier')
188
b = WorkingTree.open_containing(u'.')[0].branch
191
revinfo = rev.in_history(b)
192
if revinfo.revno is None:
193
print ' %s' % revinfo.rev_id
195
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
198
class cmd_add(Command):
199
"""Add specified files or directories.
201
In non-recursive mode, all the named items are added, regardless
202
of whether they were previously ignored. A warning is given if
203
any of the named files are already versioned.
205
In recursive mode (the default), files are treated the same way
206
but the behaviour for directories is different. Directories that
207
are already versioned do not give a warning. All directories,
208
whether already versioned or not, are searched for files or
209
subdirectories that are neither versioned or ignored, and these
210
are added. This search proceeds recursively into versioned
211
directories. If no names are given '.' is assumed.
213
Therefore simply saying 'bzr add' will version all files that
214
are currently unknown.
216
Adding a file whose parent directory is not versioned will
217
implicitly add the parent, and so on up to the root. This means
218
you should never need to explictly add a directory, they'll just
219
get added when you add a file in the directory.
221
--dry-run will show which files would be added, but not actually
224
takes_args = ['file*']
225
takes_options = ['no-recurse', 'dry-run', 'verbose']
227
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
232
# This is pointless, but I'd rather not raise an error
233
action = bzrlib.add.add_action_null
235
action = bzrlib.add.add_action_print
237
action = bzrlib.add.add_action_add
239
action = bzrlib.add.add_action_add_and_print
241
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
244
for glob in sorted(ignored.keys()):
245
match_len = len(ignored[glob])
247
for path in ignored[glob]:
248
print "ignored %s matching \"%s\"" % (path, glob)
250
print "ignored %d file(s) matching \"%s\"" % (match_len,
252
print "If you wish to add some of these files, please add them"\
256
class cmd_mkdir(Command):
257
"""Create a new versioned directory.
259
This is equivalent to creating the directory and then adding it.
261
takes_args = ['dir+']
263
def run(self, dir_list):
266
wt, dd = WorkingTree.open_containing(d)
271
class cmd_relpath(Command):
272
"""Show path of a file relative to root"""
273
takes_args = ['filename']
277
def run(self, filename):
278
tree, relpath = WorkingTree.open_containing(filename)
282
class cmd_inventory(Command):
283
"""Show inventory of the current working copy or a revision.
285
It is possible to limit the output to a particular entry
286
type using the --kind option. For example; --kind file.
288
takes_options = ['revision', 'show-ids', 'kind']
291
def run(self, revision=None, show_ids=False, kind=None):
292
if kind and kind not in ['file', 'directory', 'symlink']:
293
raise BzrCommandError('invalid kind specified')
294
tree = WorkingTree.open_containing(u'.')[0]
296
inv = tree.read_working_inventory()
298
if len(revision) > 1:
299
raise BzrCommandError('bzr inventory --revision takes'
300
' exactly one revision identifier')
301
inv = tree.branch.get_revision_inventory(
302
revision[0].in_history(tree.branch).rev_id)
304
for path, entry in inv.entries():
305
if kind and kind != entry.kind:
308
print '%-50s %s' % (path, entry.file_id)
313
class cmd_move(Command):
314
"""Move files to a different directory.
319
The destination must be a versioned directory in the same branch.
321
takes_args = ['source$', 'dest']
322
def run(self, source_list, dest):
323
tree, source_list = tree_files(source_list)
324
# TODO: glob expansion on windows?
325
tree.move(source_list, tree.relpath(dest))
328
class cmd_rename(Command):
329
"""Change the name of an entry.
332
bzr rename frob.c frobber.c
333
bzr rename src/frob.c lib/frob.c
335
It is an error if the destination name exists.
337
See also the 'move' command, which moves files into a different
338
directory without changing their name.
340
# TODO: Some way to rename multiple files without invoking
341
# bzr for each one?"""
342
takes_args = ['from_name', 'to_name']
344
def run(self, from_name, to_name):
345
tree, (from_name, to_name) = tree_files((from_name, to_name))
346
tree.rename_one(from_name, to_name)
349
class cmd_mv(Command):
350
"""Move or rename a file.
353
bzr mv OLDNAME NEWNAME
354
bzr mv SOURCE... DESTINATION
356
If the last argument is a versioned directory, all the other names
357
are moved into it. Otherwise, there must be exactly two arguments
358
and the file is changed to a new name, which must not already exist.
360
Files cannot be moved between branches.
362
takes_args = ['names*']
363
def run(self, names_list):
364
if len(names_list) < 2:
365
raise BzrCommandError("missing file argument")
366
tree, rel_names = tree_files(names_list)
368
if os.path.isdir(names_list[-1]):
369
# move into existing directory
370
for pair in tree.move(rel_names[:-1], rel_names[-1]):
371
print "%s => %s" % pair
373
if len(names_list) != 2:
374
raise BzrCommandError('to mv multiple files the destination '
375
'must be a versioned directory')
376
tree.rename_one(rel_names[0], rel_names[1])
377
print "%s => %s" % (rel_names[0], rel_names[1])
380
class cmd_pull(Command):
381
"""Pull any changes from another branch into the current one.
383
If there is no default location set, the first pull will set it. After
384
that, you can omit the location to use the default. To change the
385
default, use --remember.
387
This command only works on branches that have not diverged. Branches are
388
considered diverged if both branches have had commits without first
389
pulling from the other.
391
If branches have diverged, you can use 'bzr merge' to pull the text changes
392
from one into the other. Once one branch has merged, the other should
393
be able to pull it again.
395
If you want to forget your local changes and just update your branch to
396
match the remote one, use --overwrite.
398
takes_options = ['remember', 'overwrite', 'verbose']
399
takes_args = ['location?']
401
def run(self, location=None, remember=False, overwrite=False, verbose=False):
402
from bzrlib.merge import merge
403
from shutil import rmtree
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
418
old_rh = br_to.revision_history()
419
count = tree_to.pull(br_from, overwrite)
421
if br_to.get_parent() is None or remember:
422
br_to.set_parent(location)
423
note('%d revision(s) pulled.' % (count,))
426
new_rh = tree_to.branch.revision_history()
429
from bzrlib.log import show_changed_revisions
430
show_changed_revisions(tree_to.branch, old_rh, new_rh)
433
class cmd_push(Command):
434
"""Push this branch into another branch.
436
The remote branch will not have its working tree populated because this
437
is both expensive, and may not be supported on the remote file system.
439
Some smart servers or protocols *may* put the working tree in place.
441
If there is no default push location set, the first push will set it.
442
After that, you can omit the location to use the default. To change the
443
default, use --remember.
445
This command only works on branches that have not diverged. Branches are
446
considered diverged if the branch being pushed to is not an older version
449
If branches have diverged, you can use 'bzr push --overwrite' to replace
450
the other branch completely.
452
If you want to ensure you have the different changes in the other branch,
453
do a merge (see bzr help merge) from the other branch, and commit that
454
before doing a 'push --overwrite'.
456
takes_options = ['remember', 'overwrite',
457
Option('create-prefix',
458
help='Create the path leading up to the branch '
459
'if it does not already exist')]
460
takes_args = ['location?']
462
def run(self, location=None, remember=False, overwrite=False,
463
create_prefix=False, verbose=False):
464
# FIXME: Way too big! Put this into a function called from the
467
from shutil import rmtree
468
from bzrlib.transport import get_transport
470
tree_from = WorkingTree.open_containing(u'.')[0]
471
br_from = tree_from.branch
472
stored_loc = tree_from.branch.get_push_location()
474
if stored_loc is None:
475
raise BzrCommandError("No push location known or specified.")
477
print "Using saved location: %s" % stored_loc
478
location = stored_loc
480
br_to = Branch.open(location)
481
except NotBranchError:
483
transport = get_transport(location).clone('..')
484
if not create_prefix:
486
transport.mkdir(transport.relpath(location))
488
raise BzrCommandError("Parent directory of %s "
489
"does not exist." % location)
491
current = transport.base
492
needed = [(transport, transport.relpath(location))]
495
transport, relpath = needed[-1]
496
transport.mkdir(relpath)
499
new_transport = transport.clone('..')
500
needed.append((new_transport,
501
new_transport.relpath(transport.base)))
502
if new_transport.base == transport.base:
503
raise BzrCommandError("Could not creeate "
505
br_to = Branch.initialize(location)
506
old_rh = br_to.revision_history()
509
tree_to = br_to.working_tree()
510
except NoWorkingTree:
511
# TODO: This should be updated for branches which don't have a
512
# working tree, as opposed to ones where we just couldn't
514
warning('Unable to update the working tree of: %s' % (br_to.base,))
515
count = br_to.pull(br_from, overwrite)
517
count = tree_to.pull(br_from, overwrite)
518
except DivergedBranches:
519
raise BzrCommandError("These branches have diverged."
520
" Try a merge then push with overwrite.")
521
if br_from.get_push_location() is None or remember:
522
br_from.set_push_location(location)
523
note('%d revision(s) pushed.' % (count,))
526
new_rh = br_to.revision_history()
529
from bzrlib.log import show_changed_revisions
530
show_changed_revisions(br_to, old_rh, new_rh)
533
class cmd_branch(Command):
534
"""Create a new copy of a branch.
536
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
537
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
539
To retrieve the branch as of a particular revision, supply the --revision
540
parameter, as in "branch foo/bar -r 5".
542
--basis is to speed up branching from remote branches. When specified, it
543
copies all the file-contents, inventory and revision data from the basis
544
branch before copying anything from the remote branch.
546
takes_args = ['from_location', 'to_location?']
547
takes_options = ['revision', 'basis']
548
aliases = ['get', 'clone']
550
def run(self, from_location, to_location=None, revision=None, basis=None):
551
from bzrlib.clone import copy_branch
553
from shutil import rmtree
556
elif len(revision) > 1:
557
raise BzrCommandError(
558
'bzr branch --revision takes exactly 1 revision value')
560
br_from = Branch.open(from_location)
562
if e.errno == errno.ENOENT:
563
raise BzrCommandError('Source location "%s" does not'
564
' exist.' % to_location)
569
if basis is not None:
570
basis_branch = WorkingTree.open_containing(basis)[0].branch
573
if len(revision) == 1 and revision[0] is not None:
574
revision_id = revision[0].in_history(br_from)[1]
577
if to_location is None:
578
to_location = os.path.basename(from_location.rstrip("/\\"))
581
name = os.path.basename(to_location) + '\n'
583
os.mkdir(to_location)
585
if e.errno == errno.EEXIST:
586
raise BzrCommandError('Target directory "%s" already'
587
' exists.' % to_location)
588
if e.errno == errno.ENOENT:
589
raise BzrCommandError('Parent of "%s" does not exist.' %
594
copy_branch(br_from, to_location, revision_id, basis_branch)
595
except bzrlib.errors.NoSuchRevision:
597
msg = "The branch %s has no revision %s." % (from_location, revision[0])
598
raise BzrCommandError(msg)
599
except bzrlib.errors.UnlistableBranch:
601
msg = "The branch %s cannot be used as a --basis"
602
raise BzrCommandError(msg)
603
branch = Branch.open(to_location)
605
name = StringIO(name)
606
branch.put_controlfile('branch-name', name)
607
note('Branched %d revision(s).' % branch.revno())
612
class cmd_renames(Command):
613
"""Show list of renamed files.
615
# TODO: Option to show renames between two historical versions.
617
# TODO: Only show renames under dir, rather than in the whole branch.
618
takes_args = ['dir?']
621
def run(self, dir=u'.'):
622
tree = WorkingTree.open_containing(dir)[0]
623
old_inv = tree.branch.basis_tree().inventory
624
new_inv = tree.read_working_inventory()
626
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
628
for old_name, new_name in renames:
629
print "%s => %s" % (old_name, new_name)
632
class cmd_info(Command):
633
"""Show statistical information about a branch."""
634
takes_args = ['branch?']
637
def run(self, branch=None):
639
b = WorkingTree.open_containing(branch)[0].branch
643
class cmd_remove(Command):
644
"""Make a file unversioned.
646
This makes bzr stop tracking changes to a versioned file. It does
647
not delete the working copy.
649
takes_args = ['file+']
650
takes_options = ['verbose']
653
def run(self, file_list, verbose=False):
654
tree, file_list = tree_files(file_list)
655
tree.remove(file_list, verbose=verbose)
658
class cmd_file_id(Command):
659
"""Print file_id of a particular file or directory.
661
The file_id is assigned when the file is first added and remains the
662
same through all revisions where the file exists, even when it is
666
takes_args = ['filename']
668
def run(self, filename):
669
tree, relpath = WorkingTree.open_containing(filename)
670
i = tree.inventory.path2id(relpath)
672
raise BzrError("%r is not a versioned file" % filename)
677
class cmd_file_path(Command):
678
"""Print path of file_ids to a file or directory.
680
This prints one line for each directory down to the target,
681
starting at the branch root."""
683
takes_args = ['filename']
685
def run(self, filename):
686
tree, relpath = WorkingTree.open_containing(filename)
688
fid = inv.path2id(relpath)
690
raise BzrError("%r is not a versioned file" % filename)
691
for fip in inv.get_idpath(fid):
695
class cmd_revision_history(Command):
696
"""Display list of revision ids on this branch."""
700
branch = WorkingTree.open_containing(u'.')[0].branch
701
for patchid in branch.revision_history():
705
class cmd_ancestry(Command):
706
"""List all revisions merged into this branch."""
710
tree = WorkingTree.open_containing(u'.')[0]
712
# FIXME. should be tree.last_revision
713
for revision_id in b.get_ancestry(b.last_revision()):
717
class cmd_init(Command):
718
"""Make a directory into a versioned branch.
720
Use this to create an empty branch, or before importing an
723
Recipe for importing a tree of files:
728
bzr commit -m 'imported project'
730
takes_args = ['location?']
731
def run(self, location=None):
732
from bzrlib.branch import Branch
736
# The path has to exist to initialize a
737
# branch inside of it.
738
# Just using os.mkdir, since I don't
739
# believe that we want to create a bunch of
740
# locations if the user supplies an extended path
741
if not os.path.exists(location):
743
Branch.initialize(location)
746
class cmd_diff(Command):
747
"""Show differences in working tree.
749
If files are listed, only the changes in those files are listed.
750
Otherwise, all changes for the tree are listed.
757
# TODO: Allow diff across branches.
758
# TODO: Option to use external diff command; could be GNU diff, wdiff,
759
# or a graphical diff.
761
# TODO: Python difflib is not exactly the same as unidiff; should
762
# either fix it up or prefer to use an external diff.
764
# TODO: If a directory is given, diff everything under that.
766
# TODO: Selected-file diff is inefficient and doesn't show you
769
# TODO: This probably handles non-Unix newlines poorly.
771
takes_args = ['file*']
772
takes_options = ['revision', 'diff-options']
773
aliases = ['di', 'dif']
776
def run(self, revision=None, file_list=None, diff_options=None):
777
from bzrlib.diff import show_diff
779
tree, file_list = internal_tree_files(file_list)
782
except FileInWrongBranch:
783
if len(file_list) != 2:
784
raise BzrCommandError("Files are in different branches")
786
b, file1 = Branch.open_containing(file_list[0])
787
b2, file2 = Branch.open_containing(file_list[1])
788
if file1 != "" or file2 != "":
789
# FIXME diff those two files. rbc 20051123
790
raise BzrCommandError("Files are in different branches")
792
if revision is not None:
794
raise BzrCommandError("Can't specify -r with two branches")
795
if len(revision) == 1:
796
return show_diff(tree.branch, revision[0], specific_files=file_list,
797
external_diff_options=diff_options)
798
elif len(revision) == 2:
799
return show_diff(tree.branch, revision[0], specific_files=file_list,
800
external_diff_options=diff_options,
801
revision2=revision[1])
803
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
806
return show_diff(b, None, specific_files=file_list,
807
external_diff_options=diff_options, b2=b2)
809
return show_diff(tree.branch, None, specific_files=file_list,
810
external_diff_options=diff_options)
813
class cmd_deleted(Command):
814
"""List files deleted in the working tree.
816
# TODO: Show files deleted since a previous revision, or
817
# between two revisions.
818
# TODO: Much more efficient way to do this: read in new
819
# directories with readdir, rather than stating each one. Same
820
# level of effort but possibly much less IO. (Or possibly not,
821
# if the directories are very large...)
823
def run(self, show_ids=False):
824
tree = WorkingTree.open_containing(u'.')[0]
825
old = tree.branch.basis_tree()
826
for path, ie in old.inventory.iter_entries():
827
if not tree.has_id(ie.file_id):
829
print '%-50s %s' % (path, ie.file_id)
834
class cmd_modified(Command):
835
"""List files modified in working tree."""
839
from bzrlib.delta import compare_trees
841
tree = WorkingTree.open_containing(u'.')[0]
842
td = compare_trees(tree.branch.basis_tree(), tree)
844
for path, id, kind, text_modified, meta_modified in td.modified:
849
class cmd_added(Command):
850
"""List files added in working tree."""
854
wt = WorkingTree.open_containing(u'.')[0]
855
basis_inv = wt.branch.basis_tree().inventory
858
if file_id in basis_inv:
860
path = inv.id2path(file_id)
861
if not os.access(b.abspath(path), os.F_OK):
867
class cmd_root(Command):
868
"""Show the tree root directory.
870
The root is the nearest enclosing directory with a .bzr control
872
takes_args = ['filename?']
874
def run(self, filename=None):
875
"""Print the branch root."""
876
tree = WorkingTree.open_containing(filename)[0]
880
class cmd_log(Command):
881
"""Show log of this branch.
883
To request a range of logs, you can use the command -r begin..end
884
-r revision requests a specific revision, -r ..end or -r begin.. are
888
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
890
takes_args = ['filename?']
891
takes_options = [Option('forward',
892
help='show from oldest to newest'),
893
'timezone', 'verbose',
894
'show-ids', 'revision',
897
help='show revisions whose message matches this regexp',
902
def run(self, filename=None, timezone='original',
911
from bzrlib.log import log_formatter, show_log
913
assert message is None or isinstance(message, basestring), \
914
"invalid message argument %r" % message
915
direction = (forward and 'forward') or 'reverse'
921
tree, fp = WorkingTree.open_containing(filename)
924
inv = tree.read_working_inventory()
925
except NotBranchError:
928
b, fp = Branch.open_containing(filename)
930
inv = b.get_inventory(b.last_revision())
932
file_id = inv.path2id(fp)
934
file_id = None # points to branch root
936
tree, relpath = WorkingTree.open_containing(u'.')
943
elif len(revision) == 1:
944
rev1 = rev2 = revision[0].in_history(b).revno
945
elif len(revision) == 2:
946
rev1 = revision[0].in_history(b).revno
947
rev2 = revision[1].in_history(b).revno
949
raise BzrCommandError('bzr log --revision takes one or two values.')
951
# By this point, the revision numbers are converted to the +ve
952
# form if they were supplied in the -ve form, so we can do
953
# this comparison in relative safety
955
(rev2, rev1) = (rev1, rev2)
957
mutter('encoding log as %r', bzrlib.user_encoding)
959
# use 'replace' so that we don't abort if trying to write out
960
# in e.g. the default C locale.
961
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
963
log_format = get_log_format(long=long, short=short, line=line)
964
lf = log_formatter(log_format,
967
show_timezone=timezone)
978
def get_log_format(long=False, short=False, line=False, default='long'):
989
class cmd_touching_revisions(Command):
990
"""Return revision-ids which affected a particular file.
992
A more user-friendly interface is "bzr log FILE"."""
994
takes_args = ["filename"]
996
def run(self, filename):
997
tree, relpath = WorkingTree.open_containing(filename)
999
inv = tree.read_working_inventory()
1000
file_id = inv.path2id(relpath)
1001
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1002
print "%6d %s" % (revno, what)
1005
class cmd_ls(Command):
1006
"""List files in a tree.
1008
# TODO: Take a revision or remote path and list that tree instead.
1010
takes_options = ['verbose', 'revision',
1011
Option('non-recursive',
1012
help='don\'t recurse into sub-directories'),
1014
help='Print all paths from the root of the branch.'),
1015
Option('unknown', help='Print unknown files'),
1016
Option('versioned', help='Print versioned files'),
1017
Option('ignored', help='Print ignored files'),
1019
Option('null', help='Null separate the files'),
1022
def run(self, revision=None, verbose=False,
1023
non_recursive=False, from_root=False,
1024
unknown=False, versioned=False, ignored=False,
1027
if verbose and null:
1028
raise BzrCommandError('Cannot set both --verbose and --null')
1029
all = not (unknown or versioned or ignored)
1031
selection = {'I':ignored, '?':unknown, 'V':versioned}
1033
tree, relpath = WorkingTree.open_containing(u'.')
1038
if revision is not None:
1039
tree = tree.branch.revision_tree(
1040
revision[0].in_history(tree.branch).rev_id)
1041
for fp, fc, kind, fid, entry in tree.list_files():
1042
if fp.startswith(relpath):
1043
fp = fp[len(relpath):]
1044
if non_recursive and '/' in fp:
1046
if not all and not selection[fc]:
1049
kindch = entry.kind_character()
1050
print '%-8s %s%s' % (fc, fp, kindch)
1052
sys.stdout.write(fp)
1053
sys.stdout.write('\0')
1059
class cmd_unknowns(Command):
1060
"""List unknown files."""
1063
from bzrlib.osutils import quotefn
1064
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1068
class cmd_ignore(Command):
1069
"""Ignore a command or pattern.
1071
To remove patterns from the ignore list, edit the .bzrignore file.
1073
If the pattern contains a slash, it is compared to the whole path
1074
from the branch root. Otherwise, it is compared to only the last
1075
component of the path. To match a file only in the root directory,
1078
Ignore patterns are case-insensitive on case-insensitive systems.
1080
Note: wildcards must be quoted from the shell on Unix.
1083
bzr ignore ./Makefile
1084
bzr ignore '*.class'
1086
# TODO: Complain if the filename is absolute
1087
takes_args = ['name_pattern']
1089
def run(self, name_pattern):
1090
from bzrlib.atomicfile import AtomicFile
1093
tree, relpath = WorkingTree.open_containing(u'.')
1094
ifn = tree.abspath('.bzrignore')
1096
if os.path.exists(ifn):
1099
igns = f.read().decode('utf-8')
1105
# TODO: If the file already uses crlf-style termination, maybe
1106
# we should use that for the newly added lines?
1108
if igns and igns[-1] != '\n':
1110
igns += name_pattern + '\n'
1113
f = AtomicFile(ifn, 'wt')
1114
f.write(igns.encode('utf-8'))
1119
inv = tree.inventory
1120
if inv.path2id('.bzrignore'):
1121
mutter('.bzrignore is already versioned')
1123
mutter('need to make new .bzrignore file versioned')
1124
tree.add(['.bzrignore'])
1127
class cmd_ignored(Command):
1128
"""List ignored files and the patterns that matched them.
1130
See also: bzr ignore"""
1133
tree = WorkingTree.open_containing(u'.')[0]
1134
for path, file_class, kind, file_id, entry in tree.list_files():
1135
if file_class != 'I':
1137
## XXX: Slightly inefficient since this was already calculated
1138
pat = tree.is_ignored(path)
1139
print '%-50s %s' % (path, pat)
1142
class cmd_lookup_revision(Command):
1143
"""Lookup the revision-id from a revision-number
1146
bzr lookup-revision 33
1149
takes_args = ['revno']
1152
def run(self, revno):
1156
raise BzrCommandError("not a valid revision-number: %r" % revno)
1158
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1161
class cmd_export(Command):
1162
"""Export past revision to destination directory.
1164
If no revision is specified this exports the last committed revision.
1166
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1167
given, try to find the format with the extension. If no extension
1168
is found exports to a directory (equivalent to --format=dir).
1170
Root may be the top directory for tar, tgz and tbz2 formats. If none
1171
is given, the top directory will be the root name of the file.
1173
Note: export of tree with non-ascii filenames to zip is not supported.
1175
Supported formats Autodetected by extension
1176
----------------- -------------------------
1179
tbz2 .tar.bz2, .tbz2
1183
takes_args = ['dest']
1184
takes_options = ['revision', 'format', 'root']
1185
def run(self, dest, revision=None, format=None, root=None):
1187
from bzrlib.export import export
1188
tree = WorkingTree.open_containing(u'.')[0]
1190
if revision is None:
1191
# should be tree.last_revision FIXME
1192
rev_id = b.last_revision()
1194
if len(revision) != 1:
1195
raise BzrError('bzr export --revision takes exactly 1 argument')
1196
rev_id = revision[0].in_history(b).rev_id
1197
t = b.revision_tree(rev_id)
1199
export(t, dest, format, root)
1200
except errors.NoSuchExportFormat, e:
1201
raise BzrCommandError('Unsupported export format: %s' % e.format)
1204
class cmd_cat(Command):
1205
"""Write a file's text from a previous revision."""
1207
takes_options = ['revision']
1208
takes_args = ['filename']
1211
def run(self, filename, revision=None):
1212
if revision is not None and len(revision) != 1:
1213
raise BzrCommandError("bzr cat --revision takes exactly one number")
1216
tree, relpath = WorkingTree.open_containing(filename)
1218
except NotBranchError:
1222
b, relpath = Branch.open_containing(filename)
1223
if revision is None:
1224
revision_id = b.last_revision()
1226
revision_id = revision[0].in_history(b).rev_id
1227
b.print_file(relpath, revision_id)
1230
class cmd_local_time_offset(Command):
1231
"""Show the offset in seconds from GMT to local time."""
1235
print bzrlib.osutils.local_time_offset()
1239
class cmd_commit(Command):
1240
"""Commit changes into a new revision.
1242
If no arguments are given, the entire tree is committed.
1244
If selected files are specified, only changes to those files are
1245
committed. If a directory is specified then the directory and everything
1246
within it is committed.
1248
A selected-file commit may fail in some cases where the committed
1249
tree would be invalid, such as trying to commit a file in a
1250
newly-added directory that is not itself committed.
1252
# TODO: Run hooks on tree to-be-committed, and after commit.
1254
# TODO: Strict commit that fails if there are deleted files.
1255
# (what does "deleted files" mean ??)
1257
# TODO: Give better message for -s, --summary, used by tla people
1259
# XXX: verbose currently does nothing
1261
takes_args = ['selected*']
1262
takes_options = ['message', 'verbose',
1264
help='commit even if nothing has changed'),
1265
Option('file', type=str,
1267
help='file containing commit message'),
1269
help="refuse to commit if there are unknown "
1270
"files in the working tree."),
1272
aliases = ['ci', 'checkin']
1274
def run(self, message=None, file=None, verbose=True, selected_list=None,
1275
unchanged=False, strict=False):
1276
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1278
from bzrlib.msgeditor import edit_commit_message, \
1279
make_commit_message_template
1280
from bzrlib.status import show_status
1281
from tempfile import TemporaryFile
1284
# TODO: Need a blackbox test for invoking the external editor; may be
1285
# slightly problematic to run this cross-platform.
1287
# TODO: do more checks that the commit will succeed before
1288
# spending the user's valuable time typing a commit message.
1290
# TODO: if the commit *does* happen to fail, then save the commit
1291
# message to a temporary file where it can be recovered
1292
tree, selected_list = tree_files(selected_list)
1293
if message is None and not file:
1294
template = make_commit_message_template(tree, selected_list)
1295
message = edit_commit_message(template)
1297
raise BzrCommandError("please specify a commit message"
1298
" with either --message or --file")
1299
elif message and file:
1300
raise BzrCommandError("please specify either --message or --file")
1304
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1307
raise BzrCommandError("empty commit message specified")
1310
tree.commit(message, specific_files=selected_list,
1311
allow_pointless=unchanged, strict=strict)
1312
except PointlessCommit:
1313
# FIXME: This should really happen before the file is read in;
1314
# perhaps prepare the commit; get the message; then actually commit
1315
raise BzrCommandError("no changes to commit",
1316
["use --unchanged to commit anyhow"])
1317
except ConflictsInTree:
1318
raise BzrCommandError("Conflicts detected in working tree. "
1319
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1320
except StrictCommitFailed:
1321
raise BzrCommandError("Commit refused because there are unknown "
1322
"files in the working tree.")
1323
note('Committed revision %d.' % (tree.branch.revno(),))
1326
class cmd_check(Command):
1327
"""Validate consistency of branch history.
1329
This command checks various invariants about the branch storage to
1330
detect data corruption or bzr bugs.
1332
takes_args = ['branch?']
1333
takes_options = ['verbose']
1335
def run(self, branch=None, verbose=False):
1336
from bzrlib.check import check
1338
tree = WorkingTree.open_containing()[0]
1339
branch = tree.branch
1341
branch = Branch.open(branch)
1342
check(branch, verbose)
1345
class cmd_scan_cache(Command):
1348
from bzrlib.hashcache import HashCache
1354
print '%6d stats' % c.stat_count
1355
print '%6d in hashcache' % len(c._cache)
1356
print '%6d files removed from cache' % c.removed_count
1357
print '%6d hashes updated' % c.update_count
1358
print '%6d files changed too recently to cache' % c.danger_count
1365
class cmd_upgrade(Command):
1366
"""Upgrade branch storage to current format.
1368
The check command or bzr developers may sometimes advise you to run
1369
this command. When the default format has changed you may also be warned
1370
during other operations to upgrade.
1372
takes_args = ['url?']
1374
def run(self, url='.'):
1375
from bzrlib.upgrade import upgrade
1379
class cmd_whoami(Command):
1380
"""Show bzr user id."""
1381
takes_options = ['email']
1384
def run(self, email=False):
1386
b = WorkingTree.open_containing(u'.')[0].branch
1387
config = bzrlib.config.BranchConfig(b)
1388
except NotBranchError:
1389
config = bzrlib.config.GlobalConfig()
1392
print config.user_email()
1394
print config.username()
1396
class cmd_nick(Command):
1398
Print or set the branch nickname.
1399
If unset, the tree root directory name is used as the nickname
1400
To print the current nickname, execute with no argument.
1402
takes_args = ['nickname?']
1403
def run(self, nickname=None):
1404
branch = Branch.open_containing(u'.')[0]
1405
if nickname is None:
1406
self.printme(branch)
1408
branch.nick = nickname
1411
def printme(self, branch):
1414
class cmd_selftest(Command):
1415
"""Run internal test suite.
1417
This creates temporary test directories in the working directory,
1418
but not existing data is affected. These directories are deleted
1419
if the tests pass, or left behind to help in debugging if they
1420
fail and --keep-output is specified.
1422
If arguments are given, they are regular expressions that say
1423
which tests should run.
1425
# TODO: --list should give a list of all available tests
1427
takes_args = ['testspecs*']
1428
takes_options = ['verbose',
1429
Option('one', help='stop when one test fails'),
1430
Option('keep-output',
1431
help='keep output directories when tests fail')
1434
def run(self, testspecs_list=None, verbose=False, one=False,
1437
from bzrlib.tests import selftest
1438
# we don't want progress meters from the tests to go to the
1439
# real output; and we don't want log messages cluttering up
1441
save_ui = bzrlib.ui.ui_factory
1442
bzrlib.trace.info('running tests...')
1444
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1445
if testspecs_list is not None:
1446
pattern = '|'.join(testspecs_list)
1449
result = selftest(verbose=verbose,
1451
stop_on_failure=one,
1452
keep_output=keep_output)
1454
bzrlib.trace.info('tests passed')
1456
bzrlib.trace.info('tests failed')
1457
return int(not result)
1459
bzrlib.ui.ui_factory = save_ui
1462
def _get_bzr_branch():
1463
"""If bzr is run from a branch, return Branch or None"""
1464
import bzrlib.errors
1465
from bzrlib.branch import Branch
1466
from bzrlib.osutils import abspath
1467
from os.path import dirname
1470
branch = Branch.open(dirname(abspath(dirname(__file__))))
1472
except bzrlib.errors.BzrError:
1477
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1478
# is bzrlib itself in a branch?
1479
branch = _get_bzr_branch()
1481
rh = branch.revision_history()
1483
print " bzr checkout, revision %d" % (revno,)
1484
print " nick: %s" % (branch.nick,)
1486
print " revid: %s" % (rh[-1],)
1487
print bzrlib.__copyright__
1488
print "http://bazaar-ng.org/"
1490
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1491
print "you may use, modify and redistribute it under the terms of the GNU"
1492
print "General Public License version 2 or later."
1495
class cmd_version(Command):
1496
"""Show version of bzr."""
1501
class cmd_rocks(Command):
1502
"""Statement of optimism."""
1506
print "it sure does!"
1509
class cmd_find_merge_base(Command):
1510
"""Find and print a base revision for merging two branches.
1512
# TODO: Options to specify revisions on either side, as if
1513
# merging only part of the history.
1514
takes_args = ['branch', 'other']
1518
def run(self, branch, other):
1519
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1521
branch1 = Branch.open_containing(branch)[0]
1522
branch2 = Branch.open_containing(other)[0]
1524
history_1 = branch1.revision_history()
1525
history_2 = branch2.revision_history()
1527
last1 = branch1.last_revision()
1528
last2 = branch2.last_revision()
1530
source = MultipleRevisionSources(branch1, branch2)
1532
base_rev_id = common_ancestor(last1, last2, source)
1534
print 'merge base is revision %s' % base_rev_id
1538
if base_revno is None:
1539
raise bzrlib.errors.UnrelatedBranches()
1541
print ' r%-6d in %s' % (base_revno, branch)
1543
other_revno = branch2.revision_id_to_revno(base_revid)
1545
print ' r%-6d in %s' % (other_revno, other)
1549
class cmd_merge(Command):
1550
"""Perform a three-way merge.
1552
The branch is the branch you will merge from. By default, it will
1553
merge the latest revision. If you specify a revision, that
1554
revision will be merged. If you specify two revisions, the first
1555
will be used as a BASE, and the second one as OTHER. Revision
1556
numbers are always relative to the specified branch.
1558
By default bzr will try to merge in all new work from the other
1559
branch, automatically determining an appropriate base. If this
1560
fails, you may need to give an explicit base.
1564
To merge the latest revision from bzr.dev
1565
bzr merge ../bzr.dev
1567
To merge changes up to and including revision 82 from bzr.dev
1568
bzr merge -r 82 ../bzr.dev
1570
To merge the changes introduced by 82, without previous changes:
1571
bzr merge -r 81..82 ../bzr.dev
1573
merge refuses to run if there are any uncommitted changes, unless
1576
takes_args = ['branch?']
1577
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1578
Option('show-base', help="Show base revision text in "
1581
def run(self, branch=None, revision=None, force=False, merge_type=None,
1582
show_base=False, reprocess=False):
1583
from bzrlib.merge import merge
1584
from bzrlib.merge_core import ApplyMerge3
1585
if merge_type is None:
1586
merge_type = ApplyMerge3
1588
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1590
raise BzrCommandError("No merge location known or specified.")
1592
print "Using saved location: %s" % branch
1593
if revision is None or len(revision) < 1:
1595
other = [branch, -1]
1597
if len(revision) == 1:
1599
other_branch = Branch.open_containing(branch)[0]
1600
revno = revision[0].in_history(other_branch).revno
1601
other = [branch, revno]
1603
assert len(revision) == 2
1604
if None in revision:
1605
raise BzrCommandError(
1606
"Merge doesn't permit that revision specifier.")
1607
b = Branch.open_containing(branch)[0]
1609
base = [branch, revision[0].in_history(b).revno]
1610
other = [branch, revision[1].in_history(b).revno]
1613
conflict_count = merge(other, base, check_clean=(not force),
1614
merge_type=merge_type, reprocess=reprocess,
1615
show_base=show_base)
1616
if conflict_count != 0:
1620
except bzrlib.errors.AmbiguousBase, e:
1621
m = ("sorry, bzr can't determine the right merge base yet\n"
1622
"candidates are:\n "
1623
+ "\n ".join(e.bases)
1625
"please specify an explicit base with -r,\n"
1626
"and (if you want) report this to the bzr developers\n")
1630
class cmd_remerge(Command):
1633
takes_args = ['file*']
1634
takes_options = ['merge-type', 'reprocess',
1635
Option('show-base', help="Show base revision text in "
1638
def run(self, file_list=None, merge_type=None, show_base=False,
1640
from bzrlib.merge import merge_inner, transform_tree
1641
from bzrlib.merge_core import ApplyMerge3
1642
if merge_type is None:
1643
merge_type = ApplyMerge3
1644
tree, file_list = tree_files(file_list)
1647
pending_merges = tree.pending_merges()
1648
if len(pending_merges) != 1:
1649
raise BzrCommandError("Sorry, remerge only works after normal"
1650
+ " merges. Not cherrypicking or"
1652
base_revision = common_ancestor(tree.branch.last_revision(),
1653
pending_merges[0], tree.branch)
1654
base_tree = tree.branch.revision_tree(base_revision)
1655
other_tree = tree.branch.revision_tree(pending_merges[0])
1656
interesting_ids = None
1657
if file_list is not None:
1658
interesting_ids = set()
1659
for filename in file_list:
1660
file_id = tree.path2id(filename)
1661
interesting_ids.add(file_id)
1662
if tree.kind(file_id) != "directory":
1665
for name, ie in tree.inventory.iter_entries(file_id):
1666
interesting_ids.add(ie.file_id)
1667
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1668
if file_list is None:
1669
restore_files = list(tree.iter_conflicts())
1671
restore_files = file_list
1672
for filename in restore_files:
1674
restore(tree.abspath(filename))
1675
except NotConflicted:
1677
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1678
interesting_ids = interesting_ids,
1679
other_rev_id=pending_merges[0],
1680
merge_type=merge_type,
1681
show_base=show_base,
1682
reprocess=reprocess)
1690
class cmd_revert(Command):
1691
"""Reverse all changes since the last commit.
1693
Only versioned files are affected. Specify filenames to revert only
1694
those files. By default, any files that are changed will be backed up
1695
first. Backup files have a '~' appended to their name.
1697
takes_options = ['revision', 'no-backup']
1698
takes_args = ['file*']
1699
aliases = ['merge-revert']
1701
def run(self, revision=None, no_backup=False, file_list=None):
1702
from bzrlib.merge import merge_inner
1703
from bzrlib.commands import parse_spec
1704
if file_list is not None:
1705
if len(file_list) == 0:
1706
raise BzrCommandError("No files specified")
1709
if revision is None:
1711
tree = WorkingTree.open_containing(u'.')[0]
1712
# FIXME should be tree.last_revision
1713
rev_id = tree.branch.last_revision()
1714
elif len(revision) != 1:
1715
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1717
tree, file_list = tree_files(file_list)
1718
rev_id = revision[0].in_history(tree.branch).rev_id
1719
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1723
class cmd_assert_fail(Command):
1724
"""Test reporting of assertion failures"""
1727
assert False, "always fails"
1730
class cmd_help(Command):
1731
"""Show help on a command or other topic.
1733
For a list of all available commands, say 'bzr help commands'."""
1734
takes_options = ['long']
1735
takes_args = ['topic?']
1739
def run(self, topic=None, long=False):
1741
if topic is None and long:
1746
class cmd_shell_complete(Command):
1747
"""Show appropriate completions for context.
1749
For a list of all available commands, say 'bzr shell-complete'."""
1750
takes_args = ['context?']
1755
def run(self, context=None):
1756
import shellcomplete
1757
shellcomplete.shellcomplete(context)
1760
class cmd_fetch(Command):
1761
"""Copy in history from another branch but don't merge it.
1763
This is an internal method used for pull and merge."""
1765
takes_args = ['from_branch', 'to_branch']
1766
def run(self, from_branch, to_branch):
1767
from bzrlib.fetch import Fetcher
1768
from bzrlib.branch import Branch
1769
from_b = Branch.open(from_branch)
1770
to_b = Branch.open(to_branch)
1775
Fetcher(to_b, from_b)
1782
class cmd_missing(Command):
1783
"""Show unmerged/unpulled revisions between two branches.
1785
OTHER_BRANCH may be local or remote."""
1786
takes_args = ['other_branch?']
1787
takes_options = [Option('reverse', 'Reverse the order of revisions'),
1789
'Display changes in the local branch only'),
1790
Option('theirs-only',
1791
'Display changes in the remote branch only'),
1799
def run(self, other_branch=None, reverse=False, mine_only=False,
1800
theirs_only=False, long=True, short=False, line=False,
1801
show_ids=False, verbose=False):
1802
from bzrlib.missing import find_unmerged, iter_log_data
1803
from bzrlib.log import log_formatter
1804
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
1805
parent = local_branch.get_parent()
1806
if other_branch is None:
1807
other_branch = parent
1808
if other_branch is None:
1809
raise BzrCommandError("No missing location known or specified.")
1810
print "Using last location: " + local_branch.get_parent()
1811
remote_branch = bzrlib.branch.Branch.open(other_branch)
1812
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1813
log_format = get_log_format(long=long, short=short, line=line)
1814
lf = log_formatter(log_format, sys.stdout,
1816
show_timezone='original')
1817
if reverse is False:
1818
local_extra.reverse()
1819
remote_extra.reverse()
1820
if local_extra and not theirs_only:
1821
print "You have %d extra revision(s):" % len(local_extra)
1822
for data in iter_log_data(local_extra, local_branch, verbose):
1824
printed_local = True
1826
printed_local = False
1827
if remote_extra and not mine_only:
1828
if printed_local is True:
1830
print "You are missing %d revision(s):" % len(remote_extra)
1831
for data in iter_log_data(remote_extra, remote_branch, verbose):
1833
if not remote_extra and not local_extra:
1835
print "Branches are up to date."
1838
if parent is None and other_branch is not None:
1839
local_branch.set_parent(other_branch)
1843
class cmd_plugins(Command):
1848
import bzrlib.plugin
1849
from inspect import getdoc
1850
for name, plugin in bzrlib.plugin.all_plugins().items():
1851
if hasattr(plugin, '__path__'):
1852
print plugin.__path__[0]
1853
elif hasattr(plugin, '__file__'):
1854
print plugin.__file__
1860
print '\t', d.split('\n')[0]
1863
class cmd_testament(Command):
1864
"""Show testament (signing-form) of a revision."""
1865
takes_options = ['revision', 'long']
1866
takes_args = ['branch?']
1868
def run(self, branch=u'.', revision=None, long=False):
1869
from bzrlib.testament import Testament
1870
b = WorkingTree.open_containing(branch)[0].branch
1873
if revision is None:
1874
rev_id = b.last_revision()
1876
rev_id = revision[0].in_history(b).rev_id
1877
t = Testament.from_revision(b, rev_id)
1879
sys.stdout.writelines(t.as_text_lines())
1881
sys.stdout.write(t.as_short_text())
1886
class cmd_annotate(Command):
1887
"""Show the origin of each line in a file.
1889
This prints out the given file with an annotation on the left side
1890
indicating which revision, author and date introduced the change.
1892
If the origin is the same for a run of consecutive lines, it is
1893
shown only at the top, unless the --all option is given.
1895
# TODO: annotate directories; showing when each file was last changed
1896
# TODO: annotate a previous version of a file
1897
# TODO: if the working copy is modified, show annotations on that
1898
# with new uncommitted lines marked
1899
aliases = ['blame', 'praise']
1900
takes_args = ['filename']
1901
takes_options = [Option('all', help='show annotations on all lines'),
1902
Option('long', help='show date in annotations'),
1906
def run(self, filename, all=False, long=False):
1907
from bzrlib.annotate import annotate_file
1908
tree, relpath = WorkingTree.open_containing(filename)
1909
branch = tree.branch
1912
file_id = tree.inventory.path2id(relpath)
1913
tree = branch.revision_tree(branch.last_revision())
1914
file_version = tree.inventory[file_id].revision
1915
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1920
class cmd_re_sign(Command):
1921
"""Create a digital signature for an existing revision."""
1922
# TODO be able to replace existing ones.
1924
hidden = True # is this right ?
1925
takes_args = ['revision_id?']
1926
takes_options = ['revision']
1928
def run(self, revision_id=None, revision=None):
1929
import bzrlib.config as config
1930
import bzrlib.gpg as gpg
1931
if revision_id is not None and revision is not None:
1932
raise BzrCommandError('You can only supply one of revision_id or --revision')
1933
if revision_id is None and revision is None:
1934
raise BzrCommandError('You must supply either --revision or a revision_id')
1935
b = WorkingTree.open_containing(u'.')[0].branch
1936
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1937
if revision_id is not None:
1938
b.sign_revision(revision_id, gpg_strategy)
1939
elif revision is not None:
1940
if len(revision) == 1:
1941
revno, rev_id = revision[0].in_history(b)
1942
b.sign_revision(rev_id, gpg_strategy)
1943
elif len(revision) == 2:
1944
# are they both on rh- if so we can walk between them
1945
# might be nice to have a range helper for arbitrary
1946
# revision paths. hmm.
1947
from_revno, from_revid = revision[0].in_history(b)
1948
to_revno, to_revid = revision[1].in_history(b)
1949
if to_revid is None:
1950
to_revno = b.revno()
1951
if from_revno is None or to_revno is None:
1952
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1953
for revno in range(from_revno, to_revno + 1):
1954
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1956
raise BzrCommandError('Please supply either one revision, or a range.')
1959
class cmd_uncommit(bzrlib.commands.Command):
1960
"""Remove the last committed revision.
1962
By supplying the --all flag, it will not only remove the entry
1963
from revision_history, but also remove all of the entries in the
1966
--verbose will print out what is being removed.
1967
--dry-run will go through all the motions, but not actually
1970
In the future, uncommit will create a changeset, which can then
1973
takes_options = ['all', 'verbose', 'revision',
1974
Option('dry-run', help='Don\'t actually make changes'),
1975
Option('force', help='Say yes to all questions.')]
1976
takes_args = ['location?']
1979
def run(self, location=None, all=False,
1980
dry_run=False, verbose=False,
1981
revision=None, force=False):
1982
from bzrlib.branch import Branch
1983
from bzrlib.log import log_formatter
1985
from bzrlib.uncommit import uncommit
1987
if location is None:
1989
b, relpath = Branch.open_containing(location)
1991
if revision is None:
1993
rev_id = b.last_revision()
1995
revno, rev_id = revision[0].in_history(b)
1997
print 'No revisions to uncommit.'
1999
for r in range(revno, b.revno()+1):
2000
rev_id = b.get_rev_id(r)
2001
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2002
lf.show(r, b.get_revision(rev_id), None)
2005
print 'Dry-run, pretending to remove the above revisions.'
2007
val = raw_input('Press <enter> to continue')
2009
print 'The above revision(s) will be removed.'
2011
val = raw_input('Are you sure [y/N]? ')
2012
if val.lower() not in ('y', 'yes'):
2016
uncommit(b, remove_files=all,
2017
dry_run=dry_run, verbose=verbose,
2021
# these get imported and then picked up by the scan for cmd_*
2022
# TODO: Some more consistent way to split command definitions across files;
2023
# we do need to load at least some information about them to know of
2025
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore