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
# DO NOT change this to cStringIO - it results in control files
19
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
21
from StringIO import StringIO
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command, display_command
28
from bzrlib.branch import Branch
29
from bzrlib.revision import common_ancestor
30
import bzrlib.errors as errors
31
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
32
NotBranchError, DivergedBranches, NotConflicted,
33
NoSuchFile, NoWorkingTree, FileInWrongBranch)
34
from bzrlib.option import Option
35
from bzrlib.revisionspec import RevisionSpec
37
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
38
from bzrlib.workingtree import WorkingTree
41
def tree_files(file_list, default_branch='.'):
43
return internal_tree_files(file_list, default_branch)
44
except FileInWrongBranch, e:
45
raise BzrCommandError("%s is not in the same branch as %s" %
46
(e.path, file_list[0]))
48
def internal_tree_files(file_list, default_branch='.'):
50
Return a branch and list of branch-relative paths.
51
If supplied file_list is empty or None, the branch default will be used,
52
and returned file_list will match the original.
54
if file_list is None or len(file_list) == 0:
55
return WorkingTree.open_containing(default_branch)[0], file_list
56
tree = WorkingTree.open_containing(file_list[0])[0]
58
for filename in file_list:
60
new_list.append(tree.relpath(filename))
61
except NotBranchError:
62
raise FileInWrongBranch(tree.branch, filename)
66
# TODO: Make sure no commands unconditionally use the working directory as a
67
# branch. If a filename argument is used, the first of them should be used to
68
# specify the branch. (Perhaps this can be factored out into some kind of
69
# Argument class, representing a file in a branch, where the first occurrence
72
class cmd_status(Command):
73
"""Display status summary.
75
This reports on versioned and unknown files, reporting them
76
grouped by state. Possible states are:
79
Versioned in the working copy but not in the previous revision.
82
Versioned in the previous revision but removed or deleted
86
Path of this file changed from the previous revision;
87
the text may also have changed. This includes files whose
88
parent directory was renamed.
91
Text has changed since the previous revision.
94
Nothing about this file has changed since the previous revision.
95
Only shown with --all.
98
Not versioned and not matching an ignore pattern.
100
To see ignored files use 'bzr ignored'. For details in the
101
changes to file texts, use 'bzr diff'.
103
If no arguments are specified, the status of the entire working
104
directory is shown. Otherwise, only the status of the specified
105
files or directories is reported. If a directory is given, status
106
is reported for everything inside that directory.
108
If a revision argument is given, the status is calculated against
109
that revision, or between two revisions if two are provided.
112
# TODO: --no-recurse, --recurse options
114
takes_args = ['file*']
115
takes_options = ['all', 'show-ids', 'revision']
116
aliases = ['st', 'stat']
119
def run(self, all=False, show_ids=False, file_list=None, revision=None):
120
tree, file_list = tree_files(file_list)
122
from bzrlib.status import show_status
123
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
124
specific_files=file_list, revision=revision)
127
class cmd_cat_revision(Command):
128
"""Write out metadata for a revision.
130
The revision to print can either be specified by a specific
131
revision identifier, or you can use --revision.
135
takes_args = ['revision_id?']
136
takes_options = ['revision']
139
def run(self, revision_id=None, revision=None):
141
if revision_id is not None and revision is not None:
142
raise BzrCommandError('You can only supply one of revision_id or --revision')
143
if revision_id is None and revision is None:
144
raise BzrCommandError('You must supply either --revision or a revision_id')
145
b = WorkingTree.open_containing('.')[0].branch
146
if revision_id is not None:
147
sys.stdout.write(b.get_revision_xml(revision_id))
148
elif revision is not None:
151
raise BzrCommandError('You cannot specify a NULL revision.')
152
revno, rev_id = rev.in_history(b)
153
sys.stdout.write(b.get_revision_xml(rev_id))
156
class cmd_revno(Command):
157
"""Show current revision number.
159
This is equal to the number of revisions on this branch."""
162
print Branch.open_containing('.')[0].revno()
165
class cmd_revision_info(Command):
166
"""Show revision number and revision id for a given revision identifier.
169
takes_args = ['revision_info*']
170
takes_options = ['revision']
172
def run(self, revision=None, revision_info_list=[]):
175
if revision is not None:
176
revs.extend(revision)
177
if revision_info_list is not None:
178
for rev in revision_info_list:
179
revs.append(RevisionSpec(rev))
181
raise BzrCommandError('You must supply a revision identifier')
183
b = WorkingTree.open_containing('.')[0].branch
186
revinfo = rev.in_history(b)
187
if revinfo.revno is None:
188
print ' %s' % revinfo.rev_id
190
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
193
class cmd_add(Command):
194
"""Add specified files or directories.
196
In non-recursive mode, all the named items are added, regardless
197
of whether they were previously ignored. A warning is given if
198
any of the named files are already versioned.
200
In recursive mode (the default), files are treated the same way
201
but the behaviour for directories is different. Directories that
202
are already versioned do not give a warning. All directories,
203
whether already versioned or not, are searched for files or
204
subdirectories that are neither versioned or ignored, and these
205
are added. This search proceeds recursively into versioned
206
directories. If no names are given '.' is assumed.
208
Therefore simply saying 'bzr add' will version all files that
209
are currently unknown.
211
Adding a file whose parent directory is not versioned will
212
implicitly add the parent, and so on up to the root. This means
213
you should never need to explictly add a directory, they'll just
214
get added when you add a file in the directory.
216
takes_args = ['file*']
217
takes_options = ['no-recurse']
219
def run(self, file_list, no_recurse=False):
220
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
222
reporter = add_reporter_null
224
reporter = add_reporter_print
225
smart_add(file_list, not no_recurse, reporter)
228
class cmd_mkdir(Command):
229
"""Create a new versioned directory.
231
This is equivalent to creating the directory and then adding it.
233
takes_args = ['dir+']
235
def run(self, dir_list):
238
wt, dd = WorkingTree.open_containing(d)
243
class cmd_relpath(Command):
244
"""Show path of a file relative to root"""
245
takes_args = ['filename']
249
def run(self, filename):
250
tree, relpath = WorkingTree.open_containing(filename)
254
class cmd_inventory(Command):
255
"""Show inventory of the current working copy or a revision.
257
It is possible to limit the output to a particular entry
258
type using the --kind option. For example; --kind file.
260
takes_options = ['revision', 'show-ids', 'kind']
263
def run(self, revision=None, show_ids=False, kind=None):
264
if kind and kind not in ['file', 'directory', 'symlink']:
265
raise BzrCommandError('invalid kind specified')
266
tree = WorkingTree.open_containing('.')[0]
268
inv = tree.read_working_inventory()
270
if len(revision) > 1:
271
raise BzrCommandError('bzr inventory --revision takes'
272
' exactly one revision identifier')
273
inv = tree.branch.get_revision_inventory(
274
revision[0].in_history(tree.branch).rev_id)
276
for path, entry in inv.entries():
277
if kind and kind != entry.kind:
280
print '%-50s %s' % (path, entry.file_id)
285
class cmd_move(Command):
286
"""Move files to a different directory.
291
The destination must be a versioned directory in the same branch.
293
takes_args = ['source$', 'dest']
294
def run(self, source_list, dest):
295
tree, source_list = tree_files(source_list)
296
# TODO: glob expansion on windows?
297
tree.move(source_list, tree.relpath(dest))
300
class cmd_rename(Command):
301
"""Change the name of an entry.
304
bzr rename frob.c frobber.c
305
bzr rename src/frob.c lib/frob.c
307
It is an error if the destination name exists.
309
See also the 'move' command, which moves files into a different
310
directory without changing their name.
312
# TODO: Some way to rename multiple files without invoking
313
# bzr for each one?"""
314
takes_args = ['from_name', 'to_name']
316
def run(self, from_name, to_name):
317
tree, (from_name, to_name) = tree_files((from_name, to_name))
318
tree.rename_one(from_name, to_name)
321
class cmd_mv(Command):
322
"""Move or rename a file.
325
bzr mv OLDNAME NEWNAME
326
bzr mv SOURCE... DESTINATION
328
If the last argument is a versioned directory, all the other names
329
are moved into it. Otherwise, there must be exactly two arguments
330
and the file is changed to a new name, which must not already exist.
332
Files cannot be moved between branches.
334
takes_args = ['names*']
335
def run(self, names_list):
336
if len(names_list) < 2:
337
raise BzrCommandError("missing file argument")
338
tree, rel_names = tree_files(names_list)
340
if os.path.isdir(names_list[-1]):
341
# move into existing directory
342
for pair in tree.move(rel_names[:-1], rel_names[-1]):
343
print "%s => %s" % pair
345
if len(names_list) != 2:
346
raise BzrCommandError('to mv multiple files the destination '
347
'must be a versioned directory')
348
tree.rename_one(rel_names[0], rel_names[1])
349
print "%s => %s" % (rel_names[0], rel_names[1])
352
class cmd_pull(Command):
353
"""Pull any changes from another branch into the current one.
355
If there is no default location set, the first pull will set it. After
356
that, you can omit the location to use the default. To change the
357
default, use --remember.
359
This command only works on branches that have not diverged. Branches are
360
considered diverged if both branches have had commits without first
361
pulling from the other.
363
If branches have diverged, you can use 'bzr merge' to pull the text changes
364
from one into the other. Once one branch has merged, the other should
365
be able to pull it again.
367
If you want to forget your local changes and just update your branch to
368
match the remote one, use --overwrite.
370
takes_options = ['remember', 'overwrite', 'verbose']
371
takes_args = ['location?']
373
def run(self, location=None, remember=False, overwrite=False, verbose=False):
374
from bzrlib.merge import merge
375
from shutil import rmtree
377
# FIXME: too much stuff is in the command class
378
tree_to = WorkingTree.open_containing('.')[0]
379
stored_loc = tree_to.branch.get_parent()
381
if stored_loc is None:
382
raise BzrCommandError("No pull location known or specified.")
384
print "Using saved location: %s" % stored_loc
385
location = stored_loc
386
br_from = Branch.open(location)
387
br_to = tree_to.branch
389
old_rh = br_to.revision_history()
390
count = tree_to.pull(br_from, overwrite)
391
except DivergedBranches:
392
# FIXME: Just make DivergedBranches display the right message
394
raise BzrCommandError("These branches have diverged."
396
if br_to.get_parent() is None or remember:
397
br_to.set_parent(location)
398
note('%d revision(s) pulled.', count)
400
new_rh = tree_to.branch.revision_history()
403
from bzrlib.log import show_changed_revisions
404
show_changed_revisions(tree_to.branch, old_rh, new_rh)
407
class cmd_push(Command):
408
"""Push this branch into another branch.
410
The remote branch will not have its working tree populated because this
411
is both expensive, and may not be supported on the remote file system.
413
Some smart servers or protocols *may* put the working tree in place.
415
If there is no default push location set, the first push will set it.
416
After that, you can omit the location to use the default. To change the
417
default, use --remember.
419
This command only works on branches that have not diverged. Branches are
420
considered diverged if the branch being pushed to is not an older version
423
If branches have diverged, you can use 'bzr push --overwrite' to replace
424
the other branch completely.
426
If you want to ensure you have the different changes in the other branch,
427
do a merge (see bzr help merge) from the other branch, and commit that
428
before doing a 'push --overwrite'.
430
takes_options = ['remember', 'overwrite',
431
Option('create-prefix',
432
help='Create the path leading up to the branch '
433
'if it does not already exist')]
434
takes_args = ['location?']
436
def run(self, location=None, remember=False, overwrite=False,
437
create_prefix=False, verbose=False):
438
# FIXME: Way too big! Put this into a function called from the
441
from shutil import rmtree
442
from bzrlib.transport import get_transport
444
tree_from = WorkingTree.open_containing('.')[0]
445
br_from = tree_from.branch
446
stored_loc = tree_from.branch.get_push_location()
448
if stored_loc is None:
449
raise BzrCommandError("No push location known or specified.")
451
print "Using saved location: %s" % stored_loc
452
location = stored_loc
454
br_to = Branch.open(location)
455
except NotBranchError:
457
transport = get_transport(location).clone('..')
458
if not create_prefix:
460
transport.mkdir(transport.relpath(location))
462
raise BzrCommandError("Parent directory of %s "
463
"does not exist." % location)
465
current = transport.base
466
needed = [(transport, transport.relpath(location))]
469
transport, relpath = needed[-1]
470
transport.mkdir(relpath)
473
new_transport = transport.clone('..')
474
needed.append((new_transport,
475
new_transport.relpath(transport.base)))
476
if new_transport.base == transport.base:
477
raise BzrCommandError("Could not creeate "
479
br_to = Branch.initialize(location)
481
old_rh = br_to.revision_history()
482
count = br_to.pull(br_from, overwrite)
483
except DivergedBranches:
484
raise BzrCommandError("These branches have diverged."
485
" Try a merge then push with overwrite.")
486
if br_from.get_push_location() is None or remember:
487
br_from.set_push_location(location)
488
note('%d revision(s) pushed.' % (count,))
490
new_rh = br_to.revision_history()
493
from bzrlib.log import show_changed_revisions
494
show_changed_revisions(br_to, old_rh, new_rh)
497
class cmd_branch(Command):
498
"""Create a new copy of a branch.
500
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
501
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
503
To retrieve the branch as of a particular revision, supply the --revision
504
parameter, as in "branch foo/bar -r 5".
506
--basis is to speed up branching from remote branches. When specified, it
507
copies all the file-contents, inventory and revision data from the basis
508
branch before copying anything from the remote branch.
510
takes_args = ['from_location', 'to_location?']
511
takes_options = ['revision', 'basis']
512
aliases = ['get', 'clone']
514
def run(self, from_location, to_location=None, revision=None, basis=None):
515
from bzrlib.clone import copy_branch
517
from shutil import rmtree
520
elif len(revision) > 1:
521
raise BzrCommandError(
522
'bzr branch --revision takes exactly 1 revision value')
524
br_from = Branch.open(from_location)
526
if e.errno == errno.ENOENT:
527
raise BzrCommandError('Source location "%s" does not'
528
' exist.' % to_location)
533
if basis is not None:
534
basis_branch = WorkingTree.open_containing(basis)[0].branch
537
if len(revision) == 1 and revision[0] is not None:
538
revision_id = revision[0].in_history(br_from)[1]
541
if to_location is None:
542
to_location = os.path.basename(from_location.rstrip("/\\"))
545
name = os.path.basename(to_location) + '\n'
547
os.mkdir(to_location)
549
if e.errno == errno.EEXIST:
550
raise BzrCommandError('Target directory "%s" already'
551
' exists.' % to_location)
552
if e.errno == errno.ENOENT:
553
raise BzrCommandError('Parent of "%s" does not exist.' %
558
copy_branch(br_from, to_location, revision_id, basis_branch)
559
except bzrlib.errors.NoSuchRevision:
561
msg = "The branch %s has no revision %s." % (from_location, revision[0])
562
raise BzrCommandError(msg)
563
except bzrlib.errors.UnlistableBranch:
565
msg = "The branch %s cannot be used as a --basis"
566
raise BzrCommandError(msg)
567
branch = Branch.open(to_location)
569
name = StringIO(name)
570
branch.put_controlfile('branch-name', name)
571
note('Branched %d revision(s).' % branch.revno())
576
class cmd_renames(Command):
577
"""Show list of renamed files.
579
# TODO: Option to show renames between two historical versions.
581
# TODO: Only show renames under dir, rather than in the whole branch.
582
takes_args = ['dir?']
585
def run(self, dir='.'):
586
tree = WorkingTree.open_containing(dir)[0]
587
old_inv = tree.branch.basis_tree().inventory
588
new_inv = tree.read_working_inventory()
590
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
592
for old_name, new_name in renames:
593
print "%s => %s" % (old_name, new_name)
596
class cmd_info(Command):
597
"""Show statistical information about a branch."""
598
takes_args = ['branch?']
601
def run(self, branch=None):
603
b = WorkingTree.open_containing(branch)[0].branch
607
class cmd_remove(Command):
608
"""Make a file unversioned.
610
This makes bzr stop tracking changes to a versioned file. It does
611
not delete the working copy.
613
takes_args = ['file+']
614
takes_options = ['verbose']
617
def run(self, file_list, verbose=False):
618
tree, file_list = tree_files(file_list)
619
tree.remove(file_list, verbose=verbose)
622
class cmd_file_id(Command):
623
"""Print file_id of a particular file or directory.
625
The file_id is assigned when the file is first added and remains the
626
same through all revisions where the file exists, even when it is
630
takes_args = ['filename']
632
def run(self, filename):
633
tree, relpath = WorkingTree.open_containing(filename)
634
i = tree.inventory.path2id(relpath)
636
raise BzrError("%r is not a versioned file" % filename)
641
class cmd_file_path(Command):
642
"""Print path of file_ids to a file or directory.
644
This prints one line for each directory down to the target,
645
starting at the branch root."""
647
takes_args = ['filename']
649
def run(self, filename):
650
tree, relpath = WorkingTree.open_containing(filename)
652
fid = inv.path2id(relpath)
654
raise BzrError("%r is not a versioned file" % filename)
655
for fip in inv.get_idpath(fid):
659
class cmd_revision_history(Command):
660
"""Display list of revision ids on this branch."""
664
branch = WorkingTree.open_containing('.')[0].branch
665
for patchid in branch.revision_history():
669
class cmd_ancestry(Command):
670
"""List all revisions merged into this branch."""
674
tree = WorkingTree.open_containing('.')[0]
676
# FIXME. should be tree.last_revision
677
for revision_id in b.get_ancestry(b.last_revision()):
681
class cmd_init(Command):
682
"""Make a directory into a versioned branch.
684
Use this to create an empty branch, or before importing an
687
Recipe for importing a tree of files:
692
bzr commit -m 'imported project'
694
takes_args = ['location?']
695
def run(self, location=None):
696
from bzrlib.branch import Branch
700
# The path has to exist to initialize a
701
# branch inside of it.
702
# Just using os.mkdir, since I don't
703
# believe that we want to create a bunch of
704
# locations if the user supplies an extended path
705
if not os.path.exists(location):
707
Branch.initialize(location)
710
class cmd_diff(Command):
711
"""Show differences in working tree.
713
If files are listed, only the changes in those files are listed.
714
Otherwise, all changes for the tree are listed.
721
# TODO: Allow diff across branches.
722
# TODO: Option to use external diff command; could be GNU diff, wdiff,
723
# or a graphical diff.
725
# TODO: Python difflib is not exactly the same as unidiff; should
726
# either fix it up or prefer to use an external diff.
728
# TODO: If a directory is given, diff everything under that.
730
# TODO: Selected-file diff is inefficient and doesn't show you
733
# TODO: This probably handles non-Unix newlines poorly.
735
takes_args = ['file*']
736
takes_options = ['revision', 'diff-options']
737
aliases = ['di', 'dif']
740
def run(self, revision=None, file_list=None, diff_options=None):
741
from bzrlib.diff import show_diff
743
tree, file_list = internal_tree_files(file_list)
746
except FileInWrongBranch:
747
if len(file_list) != 2:
748
raise BzrCommandError("Files are in different branches")
750
b, file1 = Branch.open_containing(file_list[0])
751
b2, file2 = Branch.open_containing(file_list[1])
752
if file1 != "" or file2 != "":
753
# FIXME diff those two files. rbc 20051123
754
raise BzrCommandError("Files are in different branches")
756
if revision is not None:
758
raise BzrCommandError("Can't specify -r with two branches")
759
if len(revision) == 1:
760
return show_diff(tree.branch, revision[0], specific_files=file_list,
761
external_diff_options=diff_options)
762
elif len(revision) == 2:
763
return show_diff(tree.branch, revision[0], specific_files=file_list,
764
external_diff_options=diff_options,
765
revision2=revision[1])
767
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
770
return show_diff(b, None, specific_files=file_list,
771
external_diff_options=diff_options, b2=b2)
773
return show_diff(tree.branch, None, specific_files=file_list,
774
external_diff_options=diff_options)
777
class cmd_deleted(Command):
778
"""List files deleted in the working tree.
780
# TODO: Show files deleted since a previous revision, or
781
# between two revisions.
782
# TODO: Much more efficient way to do this: read in new
783
# directories with readdir, rather than stating each one. Same
784
# level of effort but possibly much less IO. (Or possibly not,
785
# if the directories are very large...)
787
def run(self, show_ids=False):
788
tree = WorkingTree.open_containing('.')[0]
789
old = tree.branch.basis_tree()
790
for path, ie in old.inventory.iter_entries():
791
if not tree.has_id(ie.file_id):
793
print '%-50s %s' % (path, ie.file_id)
798
class cmd_modified(Command):
799
"""List files modified in working tree."""
803
from bzrlib.delta import compare_trees
805
tree = WorkingTree.open_containing('.')[0]
806
td = compare_trees(tree.branch.basis_tree(), tree)
808
for path, id, kind, text_modified, meta_modified in td.modified:
813
class cmd_added(Command):
814
"""List files added in working tree."""
818
wt = WorkingTree.open_containing('.')[0]
819
basis_inv = wt.branch.basis_tree().inventory
822
if file_id in basis_inv:
824
path = inv.id2path(file_id)
825
if not os.access(b.abspath(path), os.F_OK):
831
class cmd_root(Command):
832
"""Show the tree root directory.
834
The root is the nearest enclosing directory with a .bzr control
836
takes_args = ['filename?']
838
def run(self, filename=None):
839
"""Print the branch root."""
840
tree = WorkingTree.open_containing(filename)[0]
844
class cmd_log(Command):
845
"""Show log of this branch.
847
To request a range of logs, you can use the command -r begin..end
848
-r revision requests a specific revision, -r ..end or -r begin.. are
852
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
854
takes_args = ['filename?']
855
takes_options = [Option('forward',
856
help='show from oldest to newest'),
857
'timezone', 'verbose',
858
'show-ids', 'revision',
859
Option('line', help='format with one line per revision'),
862
help='show revisions whose message matches this regexp',
864
Option('short', help='use moderately short format'),
867
def run(self, filename=None, timezone='original',
876
from bzrlib.log import log_formatter, show_log
878
assert message is None or isinstance(message, basestring), \
879
"invalid message argument %r" % message
880
direction = (forward and 'forward') or 'reverse'
886
tree, fp = WorkingTree.open_containing(filename)
889
inv = tree.read_working_inventory()
890
except NotBranchError:
893
b, fp = Branch.open_containing(filename)
895
inv = b.get_inventory(b.last_revision())
897
file_id = inv.path2id(fp)
899
file_id = None # points to branch root
901
tree, relpath = WorkingTree.open_containing('.')
908
elif len(revision) == 1:
909
rev1 = rev2 = revision[0].in_history(b).revno
910
elif len(revision) == 2:
911
rev1 = revision[0].in_history(b).revno
912
rev2 = revision[1].in_history(b).revno
914
raise BzrCommandError('bzr log --revision takes one or two values.')
916
# By this point, the revision numbers are converted to the +ve
917
# form if they were supplied in the -ve form, so we can do
918
# this comparison in relative safety
920
(rev2, rev1) = (rev1, rev2)
922
mutter('encoding log as %r', bzrlib.user_encoding)
924
# use 'replace' so that we don't abort if trying to write out
925
# in e.g. the default C locale.
926
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
933
lf = log_formatter(log_format,
936
show_timezone=timezone)
949
class cmd_touching_revisions(Command):
950
"""Return revision-ids which affected a particular file.
952
A more user-friendly interface is "bzr log FILE"."""
954
takes_args = ["filename"]
956
def run(self, filename):
957
tree, relpath = WorkingTree.open_containing(filename)
959
inv = tree.read_working_inventory()
960
file_id = inv.path2id(relpath)
961
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
962
print "%6d %s" % (revno, what)
965
class cmd_ls(Command):
966
"""List files in a tree.
968
# TODO: Take a revision or remote path and list that tree instead.
970
takes_options = ['verbose', 'revision',
971
Option('non-recursive',
972
help='don\'t recurse into sub-directories'),
974
help='Print all paths from the root of the branch.'),
975
Option('unknown', help='Print unknown files'),
976
Option('versioned', help='Print versioned files'),
977
Option('ignored', help='Print ignored files'),
979
Option('null', help='Null separate the files'),
982
def run(self, revision=None, verbose=False,
983
non_recursive=False, from_root=False,
984
unknown=False, versioned=False, ignored=False,
988
raise BzrCommandError('Cannot set both --verbose and --null')
989
all = not (unknown or versioned or ignored)
991
selection = {'I':ignored, '?':unknown, 'V':versioned}
993
tree, relpath = WorkingTree.open_containing('.')
998
if revision is not None:
999
tree = tree.branch.revision_tree(
1000
revision[0].in_history(tree.branch).rev_id)
1001
for fp, fc, kind, fid, entry in tree.list_files():
1002
if fp.startswith(relpath):
1003
fp = fp[len(relpath):]
1004
if non_recursive and '/' in fp:
1006
if not all and not selection[fc]:
1009
kindch = entry.kind_character()
1010
print '%-8s %s%s' % (fc, fp, kindch)
1012
sys.stdout.write(fp)
1013
sys.stdout.write('\0')
1019
class cmd_unknowns(Command):
1020
"""List unknown files."""
1023
from bzrlib.osutils import quotefn
1024
for f in WorkingTree.open_containing('.')[0].unknowns():
1028
class cmd_ignore(Command):
1029
"""Ignore a command or pattern.
1031
To remove patterns from the ignore list, edit the .bzrignore file.
1033
If the pattern contains a slash, it is compared to the whole path
1034
from the branch root. Otherwise, it is compared to only the last
1035
component of the path. To match a file only in the root directory,
1038
Ignore patterns are case-insensitive on case-insensitive systems.
1040
Note: wildcards must be quoted from the shell on Unix.
1043
bzr ignore ./Makefile
1044
bzr ignore '*.class'
1046
# TODO: Complain if the filename is absolute
1047
takes_args = ['name_pattern']
1049
def run(self, name_pattern):
1050
from bzrlib.atomicfile import AtomicFile
1053
tree, relpath = WorkingTree.open_containing('.')
1054
ifn = tree.abspath('.bzrignore')
1056
if os.path.exists(ifn):
1059
igns = f.read().decode('utf-8')
1065
# TODO: If the file already uses crlf-style termination, maybe
1066
# we should use that for the newly added lines?
1068
if igns and igns[-1] != '\n':
1070
igns += name_pattern + '\n'
1073
f = AtomicFile(ifn, 'wt')
1074
f.write(igns.encode('utf-8'))
1079
inv = tree.inventory
1080
if inv.path2id('.bzrignore'):
1081
mutter('.bzrignore is already versioned')
1083
mutter('need to make new .bzrignore file versioned')
1084
tree.add(['.bzrignore'])
1087
class cmd_ignored(Command):
1088
"""List ignored files and the patterns that matched them.
1090
See also: bzr ignore"""
1093
tree = WorkingTree.open_containing('.')[0]
1094
for path, file_class, kind, file_id, entry in tree.list_files():
1095
if file_class != 'I':
1097
## XXX: Slightly inefficient since this was already calculated
1098
pat = tree.is_ignored(path)
1099
print '%-50s %s' % (path, pat)
1102
class cmd_lookup_revision(Command):
1103
"""Lookup the revision-id from a revision-number
1106
bzr lookup-revision 33
1109
takes_args = ['revno']
1112
def run(self, revno):
1116
raise BzrCommandError("not a valid revision-number: %r" % revno)
1118
print WorkingTree.open_containing('.')[0].branch.get_rev_id(revno)
1121
class cmd_export(Command):
1122
"""Export past revision to destination directory.
1124
If no revision is specified this exports the last committed revision.
1126
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1127
given, try to find the format with the extension. If no extension
1128
is found exports to a directory (equivalent to --format=dir).
1130
Root may be the top directory for tar, tgz and tbz2 formats. If none
1131
is given, the top directory will be the root name of the file.
1133
Note: export of tree with non-ascii filenames to zip is not supported.
1135
Supported formats Autodetected by extension
1136
----------------- -------------------------
1139
tbz2 .tar.bz2, .tbz2
1143
takes_args = ['dest']
1144
takes_options = ['revision', 'format', 'root']
1145
def run(self, dest, revision=None, format=None, root=None):
1147
from bzrlib.export import export
1148
tree = WorkingTree.open_containing('.')[0]
1150
if revision is None:
1151
# should be tree.last_revision FIXME
1152
rev_id = b.last_revision()
1154
if len(revision) != 1:
1155
raise BzrError('bzr export --revision takes exactly 1 argument')
1156
rev_id = revision[0].in_history(b).rev_id
1157
t = b.revision_tree(rev_id)
1159
export(t, dest, format, root)
1160
except errors.NoSuchExportFormat, e:
1161
raise BzrCommandError('Unsupported export format: %s' % e.format)
1164
class cmd_cat(Command):
1165
"""Write a file's text from a previous revision."""
1167
takes_options = ['revision']
1168
takes_args = ['filename']
1171
def run(self, filename, revision=None):
1172
if revision is None:
1173
raise BzrCommandError("bzr cat requires a revision number")
1174
elif len(revision) != 1:
1175
raise BzrCommandError("bzr cat --revision takes exactly one number")
1178
tree, relpath = WorkingTree.open_containing(filename)
1180
except NotBranchError:
1183
b, relpath = Branch.open_containing(filename)
1184
b.print_file(relpath, revision[0].in_history(b).revno)
1187
class cmd_local_time_offset(Command):
1188
"""Show the offset in seconds from GMT to local time."""
1192
print bzrlib.osutils.local_time_offset()
1196
class cmd_commit(Command):
1197
"""Commit changes into a new revision.
1199
If no arguments are given, the entire tree is committed.
1201
If selected files are specified, only changes to those files are
1202
committed. If a directory is specified then the directory and everything
1203
within it is committed.
1205
A selected-file commit may fail in some cases where the committed
1206
tree would be invalid, such as trying to commit a file in a
1207
newly-added directory that is not itself committed.
1209
# TODO: Run hooks on tree to-be-committed, and after commit.
1211
# TODO: Strict commit that fails if there are deleted files.
1212
# (what does "deleted files" mean ??)
1214
# TODO: Give better message for -s, --summary, used by tla people
1216
# XXX: verbose currently does nothing
1218
takes_args = ['selected*']
1219
takes_options = ['message', 'verbose',
1221
help='commit even if nothing has changed'),
1222
Option('file', type=str,
1224
help='file containing commit message'),
1226
help="refuse to commit if there are unknown "
1227
"files in the working tree."),
1229
aliases = ['ci', 'checkin']
1231
def run(self, message=None, file=None, verbose=True, selected_list=None,
1232
unchanged=False, strict=False):
1233
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1235
from bzrlib.msgeditor import edit_commit_message
1236
from bzrlib.status import show_status
1237
from cStringIO import StringIO
1239
tree, selected_list = tree_files(selected_list)
1240
if message is None and not file:
1241
catcher = StringIO()
1242
show_status(tree.branch, specific_files=selected_list,
1244
message = edit_commit_message(catcher.getvalue())
1247
raise BzrCommandError("please specify a commit message"
1248
" with either --message or --file")
1249
elif message and file:
1250
raise BzrCommandError("please specify either --message or --file")
1254
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1257
raise BzrCommandError("empty commit message specified")
1260
tree.commit(message, specific_files=selected_list,
1261
allow_pointless=unchanged, strict=strict)
1262
except PointlessCommit:
1263
# FIXME: This should really happen before the file is read in;
1264
# perhaps prepare the commit; get the message; then actually commit
1265
raise BzrCommandError("no changes to commit",
1266
["use --unchanged to commit anyhow"])
1267
except ConflictsInTree:
1268
raise BzrCommandError("Conflicts detected in working tree. "
1269
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1270
except StrictCommitFailed:
1271
raise BzrCommandError("Commit refused because there are unknown "
1272
"files in the working tree.")
1273
note('Committed revision %d.' % (tree.branch.revno(),))
1276
class cmd_check(Command):
1277
"""Validate consistency of branch history.
1279
This command checks various invariants about the branch storage to
1280
detect data corruption or bzr bugs.
1282
takes_args = ['branch?']
1283
takes_options = ['verbose']
1285
def run(self, branch=None, verbose=False):
1286
from bzrlib.check import check
1288
tree = WorkingTree.open_containing()[0]
1289
branch = tree.branch
1291
branch = Branch.open(branch)
1292
check(branch, verbose)
1295
class cmd_scan_cache(Command):
1298
from bzrlib.hashcache import HashCache
1304
print '%6d stats' % c.stat_count
1305
print '%6d in hashcache' % len(c._cache)
1306
print '%6d files removed from cache' % c.removed_count
1307
print '%6d hashes updated' % c.update_count
1308
print '%6d files changed too recently to cache' % c.danger_count
1315
class cmd_upgrade(Command):
1316
"""Upgrade branch storage to current format.
1318
The check command or bzr developers may sometimes advise you to run
1321
This version of this command upgrades from the full-text storage
1322
used by bzr 0.0.8 and earlier to the weave format (v5).
1324
takes_args = ['dir?']
1326
def run(self, dir='.'):
1327
from bzrlib.upgrade import upgrade
1331
class cmd_whoami(Command):
1332
"""Show bzr user id."""
1333
takes_options = ['email']
1336
def run(self, email=False):
1338
b = WorkingTree.open_containing('.')[0].branch
1339
config = bzrlib.config.BranchConfig(b)
1340
except NotBranchError:
1341
config = bzrlib.config.GlobalConfig()
1344
print config.user_email()
1346
print config.username()
1348
class cmd_nick(Command):
1350
Print or set the branch nickname.
1351
If unset, the tree root directory name is used as the nickname
1352
To print the current nickname, execute with no argument.
1354
takes_args = ['nickname?']
1355
def run(self, nickname=None):
1356
branch = Branch.open_containing('.')[0]
1357
if nickname is None:
1358
self.printme(branch)
1360
branch.nick = nickname
1363
def printme(self, branch):
1366
class cmd_selftest(Command):
1367
"""Run internal test suite.
1369
This creates temporary test directories in the working directory,
1370
but not existing data is affected. These directories are deleted
1371
if the tests pass, or left behind to help in debugging if they
1372
fail and --keep-output is specified.
1374
If arguments are given, they are regular expressions that say
1375
which tests should run.
1377
# TODO: --list should give a list of all available tests
1379
takes_args = ['testspecs*']
1380
takes_options = ['verbose',
1381
Option('one', help='stop when one test fails'),
1382
Option('keep-output',
1383
help='keep output directories when tests fail')
1386
def run(self, testspecs_list=None, verbose=False, one=False,
1389
from bzrlib.tests import selftest
1390
# we don't want progress meters from the tests to go to the
1391
# real output; and we don't want log messages cluttering up
1393
save_ui = bzrlib.ui.ui_factory
1394
bzrlib.trace.info('running tests...')
1396
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1397
if testspecs_list is not None:
1398
pattern = '|'.join(testspecs_list)
1401
result = selftest(verbose=verbose,
1403
stop_on_failure=one,
1404
keep_output=keep_output)
1406
bzrlib.trace.info('tests passed')
1408
bzrlib.trace.info('tests failed')
1409
return int(not result)
1411
bzrlib.ui.ui_factory = save_ui
1415
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1416
# is bzrlib itself in a branch?
1417
bzrrev = bzrlib.get_bzr_revision()
1419
print " (bzr checkout, revision %d {%s})" % bzrrev
1420
print bzrlib.__copyright__
1421
print "http://bazaar-ng.org/"
1423
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1424
print "you may use, modify and redistribute it under the terms of the GNU"
1425
print "General Public License version 2 or later."
1428
class cmd_version(Command):
1429
"""Show version of bzr."""
1434
class cmd_rocks(Command):
1435
"""Statement of optimism."""
1439
print "it sure does!"
1442
class cmd_find_merge_base(Command):
1443
"""Find and print a base revision for merging two branches.
1445
# TODO: Options to specify revisions on either side, as if
1446
# merging only part of the history.
1447
takes_args = ['branch', 'other']
1451
def run(self, branch, other):
1452
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1454
branch1 = Branch.open_containing(branch)[0]
1455
branch2 = Branch.open_containing(other)[0]
1457
history_1 = branch1.revision_history()
1458
history_2 = branch2.revision_history()
1460
last1 = branch1.last_revision()
1461
last2 = branch2.last_revision()
1463
source = MultipleRevisionSources(branch1, branch2)
1465
base_rev_id = common_ancestor(last1, last2, source)
1467
print 'merge base is revision %s' % base_rev_id
1471
if base_revno is None:
1472
raise bzrlib.errors.UnrelatedBranches()
1474
print ' r%-6d in %s' % (base_revno, branch)
1476
other_revno = branch2.revision_id_to_revno(base_revid)
1478
print ' r%-6d in %s' % (other_revno, other)
1482
class cmd_merge(Command):
1483
"""Perform a three-way merge.
1485
The branch is the branch you will merge from. By default, it will
1486
merge the latest revision. If you specify a revision, that
1487
revision will be merged. If you specify two revisions, the first
1488
will be used as a BASE, and the second one as OTHER. Revision
1489
numbers are always relative to the specified branch.
1491
By default bzr will try to merge in all new work from the other
1492
branch, automatically determining an appropriate base. If this
1493
fails, you may need to give an explicit base.
1497
To merge the latest revision from bzr.dev
1498
bzr merge ../bzr.dev
1500
To merge changes up to and including revision 82 from bzr.dev
1501
bzr merge -r 82 ../bzr.dev
1503
To merge the changes introduced by 82, without previous changes:
1504
bzr merge -r 81..82 ../bzr.dev
1506
merge refuses to run if there are any uncommitted changes, unless
1509
takes_args = ['branch?']
1510
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1511
Option('show-base', help="Show base revision text in "
1514
def run(self, branch=None, revision=None, force=False, merge_type=None,
1515
show_base=False, reprocess=False):
1516
from bzrlib.merge import merge
1517
from bzrlib.merge_core import ApplyMerge3
1518
if merge_type is None:
1519
merge_type = ApplyMerge3
1521
branch = WorkingTree.open_containing('.')[0].branch.get_parent()
1523
raise BzrCommandError("No merge location known or specified.")
1525
print "Using saved location: %s" % branch
1526
if revision is None or len(revision) < 1:
1528
other = [branch, -1]
1530
if len(revision) == 1:
1532
other_branch = Branch.open_containing(branch)[0]
1533
revno = revision[0].in_history(other_branch).revno
1534
other = [branch, revno]
1536
assert len(revision) == 2
1537
if None in revision:
1538
raise BzrCommandError(
1539
"Merge doesn't permit that revision specifier.")
1540
b = Branch.open_containing(branch)[0]
1542
base = [branch, revision[0].in_history(b).revno]
1543
other = [branch, revision[1].in_history(b).revno]
1546
conflict_count = merge(other, base, check_clean=(not force),
1547
merge_type=merge_type, reprocess=reprocess,
1548
show_base=show_base)
1549
if conflict_count != 0:
1553
except bzrlib.errors.AmbiguousBase, e:
1554
m = ("sorry, bzr can't determine the right merge base yet\n"
1555
"candidates are:\n "
1556
+ "\n ".join(e.bases)
1558
"please specify an explicit base with -r,\n"
1559
"and (if you want) report this to the bzr developers\n")
1563
class cmd_remerge(Command):
1566
takes_args = ['file*']
1567
takes_options = ['merge-type', 'reprocess',
1568
Option('show-base', help="Show base revision text in "
1571
def run(self, file_list=None, merge_type=None, show_base=False,
1573
from bzrlib.merge import merge_inner, transform_tree
1574
from bzrlib.merge_core import ApplyMerge3
1575
if merge_type is None:
1576
merge_type = ApplyMerge3
1577
tree, file_list = tree_files(file_list)
1580
pending_merges = tree.pending_merges()
1581
if len(pending_merges) != 1:
1582
raise BzrCommandError("Sorry, remerge only works after normal"
1583
+ " merges. Not cherrypicking or"
1585
base_revision = common_ancestor(tree.branch.last_revision(),
1586
pending_merges[0], tree.branch)
1587
base_tree = tree.branch.revision_tree(base_revision)
1588
other_tree = tree.branch.revision_tree(pending_merges[0])
1589
interesting_ids = None
1590
if file_list is not None:
1591
interesting_ids = set()
1592
for filename in file_list:
1593
file_id = tree.path2id(filename)
1594
interesting_ids.add(file_id)
1595
if tree.kind(file_id) != "directory":
1598
for name, ie in tree.inventory.iter_entries(file_id):
1599
interesting_ids.add(ie.file_id)
1600
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1601
if file_list is None:
1602
restore_files = list(tree.iter_conflicts())
1604
restore_files = file_list
1605
for filename in restore_files:
1607
restore(tree.abspath(filename))
1608
except NotConflicted:
1610
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1611
interesting_ids = interesting_ids,
1612
other_rev_id=pending_merges[0],
1613
merge_type=merge_type,
1614
show_base=show_base,
1615
reprocess=reprocess)
1623
class cmd_revert(Command):
1624
"""Reverse all changes since the last commit.
1626
Only versioned files are affected. Specify filenames to revert only
1627
those files. By default, any files that are changed will be backed up
1628
first. Backup files have a '~' appended to their name.
1630
takes_options = ['revision', 'no-backup']
1631
takes_args = ['file*']
1632
aliases = ['merge-revert']
1634
def run(self, revision=None, no_backup=False, file_list=None):
1635
from bzrlib.merge import merge_inner
1636
from bzrlib.commands import parse_spec
1637
if file_list is not None:
1638
if len(file_list) == 0:
1639
raise BzrCommandError("No files specified")
1642
if revision is None:
1644
tree = WorkingTree.open_containing('.')[0]
1645
# FIXME should be tree.last_revision
1646
rev_id = tree.branch.last_revision()
1647
elif len(revision) != 1:
1648
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1650
tree, file_list = tree_files(file_list)
1651
rev_id = revision[0].in_history(tree.branch).rev_id
1652
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1656
class cmd_assert_fail(Command):
1657
"""Test reporting of assertion failures"""
1660
assert False, "always fails"
1663
class cmd_help(Command):
1664
"""Show help on a command or other topic.
1666
For a list of all available commands, say 'bzr help commands'."""
1667
takes_options = ['long']
1668
takes_args = ['topic?']
1672
def run(self, topic=None, long=False):
1674
if topic is None and long:
1679
class cmd_shell_complete(Command):
1680
"""Show appropriate completions for context.
1682
For a list of all available commands, say 'bzr shell-complete'."""
1683
takes_args = ['context?']
1688
def run(self, context=None):
1689
import shellcomplete
1690
shellcomplete.shellcomplete(context)
1693
class cmd_fetch(Command):
1694
"""Copy in history from another branch but don't merge it.
1696
This is an internal method used for pull and merge."""
1698
takes_args = ['from_branch', 'to_branch']
1699
def run(self, from_branch, to_branch):
1700
from bzrlib.fetch import Fetcher
1701
from bzrlib.branch import Branch
1702
from_b = Branch.open(from_branch)
1703
to_b = Branch.open(to_branch)
1708
Fetcher(to_b, from_b)
1715
class cmd_missing(Command):
1716
"""What is missing in this branch relative to other branch.
1718
# TODO: rewrite this in terms of ancestry so that it shows only
1721
takes_args = ['remote?']
1722
aliases = ['mis', 'miss']
1723
takes_options = ['verbose']
1726
def run(self, remote=None, verbose=False):
1727
from bzrlib.errors import BzrCommandError
1728
from bzrlib.missing import show_missing
1730
if verbose and is_quiet():
1731
raise BzrCommandError('Cannot pass both quiet and verbose')
1733
tree = WorkingTree.open_containing('.')[0]
1734
parent = tree.branch.get_parent()
1737
raise BzrCommandError("No missing location known or specified.")
1740
print "Using last location: %s" % parent
1742
elif parent is None:
1743
# We only update parent if it did not exist, missing
1744
# should not change the parent
1745
tree.branch.set_parent(remote)
1746
br_remote = Branch.open_containing(remote)[0]
1747
return show_missing(tree.branch, br_remote, verbose=verbose,
1751
class cmd_plugins(Command):
1756
import bzrlib.plugin
1757
from inspect import getdoc
1758
for name, plugin in bzrlib.plugin.all_plugins().items():
1759
if hasattr(plugin, '__path__'):
1760
print plugin.__path__[0]
1761
elif hasattr(plugin, '__file__'):
1762
print plugin.__file__
1768
print '\t', d.split('\n')[0]
1771
class cmd_testament(Command):
1772
"""Show testament (signing-form) of a revision."""
1773
takes_options = ['revision', 'long']
1774
takes_args = ['branch?']
1776
def run(self, branch='.', revision=None, long=False):
1777
from bzrlib.testament import Testament
1778
b = WorkingTree.open_containing(branch)[0].branch
1781
if revision is None:
1782
rev_id = b.last_revision()
1784
rev_id = revision[0].in_history(b).rev_id
1785
t = Testament.from_revision(b, rev_id)
1787
sys.stdout.writelines(t.as_text_lines())
1789
sys.stdout.write(t.as_short_text())
1794
class cmd_annotate(Command):
1795
"""Show the origin of each line in a file.
1797
This prints out the given file with an annotation on the left side
1798
indicating which revision, author and date introduced the change.
1800
If the origin is the same for a run of consecutive lines, it is
1801
shown only at the top, unless the --all option is given.
1803
# TODO: annotate directories; showing when each file was last changed
1804
# TODO: annotate a previous version of a file
1805
# TODO: if the working copy is modified, show annotations on that
1806
# with new uncommitted lines marked
1807
aliases = ['blame', 'praise']
1808
takes_args = ['filename']
1809
takes_options = [Option('all', help='show annotations on all lines'),
1810
Option('long', help='show date in annotations'),
1814
def run(self, filename, all=False, long=False):
1815
from bzrlib.annotate import annotate_file
1816
tree, relpath = WorkingTree.open_containing(filename)
1817
branch = tree.branch
1820
file_id = tree.inventory.path2id(relpath)
1821
tree = branch.revision_tree(branch.last_revision())
1822
file_version = tree.inventory[file_id].revision
1823
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1828
class cmd_re_sign(Command):
1829
"""Create a digital signature for an existing revision."""
1830
# TODO be able to replace existing ones.
1832
hidden = True # is this right ?
1833
takes_args = ['revision_id?']
1834
takes_options = ['revision']
1836
def run(self, revision_id=None, revision=None):
1837
import bzrlib.config as config
1838
import bzrlib.gpg as gpg
1839
if revision_id is not None and revision is not None:
1840
raise BzrCommandError('You can only supply one of revision_id or --revision')
1841
if revision_id is None and revision is None:
1842
raise BzrCommandError('You must supply either --revision or a revision_id')
1843
b = WorkingTree.open_containing('.')[0].branch
1844
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1845
if revision_id is not None:
1846
b.sign_revision(revision_id, gpg_strategy)
1847
elif revision is not None:
1848
if len(revision) == 1:
1849
revno, rev_id = revision[0].in_history(b)
1850
b.sign_revision(rev_id, gpg_strategy)
1851
elif len(revision) == 2:
1852
# are they both on rh- if so we can walk between them
1853
# might be nice to have a range helper for arbitrary
1854
# revision paths. hmm.
1855
from_revno, from_revid = revision[0].in_history(b)
1856
to_revno, to_revid = revision[1].in_history(b)
1857
if to_revid is None:
1858
to_revno = b.revno()
1859
if from_revno is None or to_revno is None:
1860
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1861
for revno in range(from_revno, to_revno + 1):
1862
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1864
raise BzrCommandError('Please supply either one revision, or a range.')
1867
class cmd_uncommit(bzrlib.commands.Command):
1868
"""Remove the last committed revision.
1870
By supplying the --all flag, it will not only remove the entry
1871
from revision_history, but also remove all of the entries in the
1874
--verbose will print out what is being removed.
1875
--dry-run will go through all the motions, but not actually
1878
In the future, uncommit will create a changeset, which can then
1881
takes_options = ['all', 'verbose', 'revision',
1882
Option('dry-run', help='Don\'t actually make changes'),
1883
Option('force', help='Say yes to all questions.')]
1884
takes_args = ['location?']
1887
def run(self, location=None, all=False,
1888
dry_run=False, verbose=False,
1889
revision=None, force=False):
1890
from bzrlib.branch import Branch
1891
from bzrlib.log import log_formatter
1893
from bzrlib.uncommit import uncommit
1895
if location is None:
1897
b, relpath = Branch.open_containing(location)
1899
if revision is None:
1901
rev_id = b.last_revision()
1903
revno, rev_id = revision[0].in_history(b)
1905
print 'No revisions to uncommit.'
1907
for r in range(revno, b.revno()+1):
1908
rev_id = b.get_rev_id(r)
1909
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1910
lf.show(r, b.get_revision(rev_id), None)
1913
print 'Dry-run, pretending to remove the above revisions.'
1915
val = raw_input('Press <enter> to continue')
1917
print 'The above revision(s) will be removed.'
1919
val = raw_input('Are you sure [y/N]? ')
1920
if val.lower() not in ('y', 'yes'):
1924
uncommit(b, remove_files=all,
1925
dry_run=dry_run, verbose=verbose,
1929
# these get imported and then picked up by the scan for cmd_*
1930
# TODO: Some more consistent way to split command definitions across files;
1931
# we do need to load at least some information about them to know of
1933
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
added
removed
bzrlib/builtins.py
