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
22
from bzrlib import BZRDIR
23
from bzrlib.commands import Command
24
from bzrlib.branch import Branch
25
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
26
from bzrlib.errors import DivergedBranches
27
from bzrlib.option import Option
28
from bzrlib.revisionspec import RevisionSpec
30
from bzrlib.trace import mutter, note, log_error, warning
31
from bzrlib.workingtree import WorkingTree
34
class cmd_status(Command):
35
"""Display status summary.
37
This reports on versioned and unknown files, reporting them
38
grouped by state. Possible states are:
41
Versioned in the working copy but not in the previous revision.
44
Versioned in the previous revision but removed or deleted
48
Path of this file changed from the previous revision;
49
the text may also have changed. This includes files whose
50
parent directory was renamed.
53
Text has changed since the previous revision.
56
Nothing about this file has changed since the previous revision.
57
Only shown with --all.
60
Not versioned and not matching an ignore pattern.
62
To see ignored files use 'bzr ignored'. For details in the
63
changes to file texts, use 'bzr diff'.
65
If no arguments are specified, the status of the entire working
66
directory is shown. Otherwise, only the status of the specified
67
files or directories is reported. If a directory is given, status
68
is reported for everything inside that directory.
70
If a revision argument is given, the status is calculated against
71
that revision, or between two revisions if two are provided.
73
# XXX: FIXME: bzr status should accept a -r option to show changes
74
# relative to a revision, or between revisions
76
takes_args = ['file*']
77
takes_options = ['all', 'show-ids']
78
aliases = ['st', 'stat']
80
def run(self, all=False, show_ids=False, file_list=None, revision=None):
82
b, relpath = Branch.open_containing(file_list[0])
83
if relpath == '' and len(file_list) == 1:
86
# generate relative paths.
87
# note that if this is a remote branch, we would want
88
# relpath against the transport. RBC 20051018
89
tree = WorkingTree(b.base, b)
90
file_list = [tree.relpath(x) for x in file_list]
92
b = Branch.open_containing('.')[0]
94
from bzrlib.status import show_status
95
show_status(b, show_unchanged=all, show_ids=show_ids,
96
specific_files=file_list, revision=revision)
99
class cmd_cat_revision(Command):
100
"""Write out metadata for a revision.
102
The revision to print can either be specified by a specific
103
revision identifier, or you can use --revision.
107
takes_args = ['revision_id?']
108
takes_options = ['revision']
110
def run(self, revision_id=None, revision=None):
112
if revision_id is not None and revision is not None:
113
raise BzrCommandError('You can only supply one of revision_id or --revision')
114
if revision_id is None and revision is None:
115
raise BzrCommandError('You must supply either --revision or a revision_id')
116
b = Branch.open_containing('.')[0]
117
if revision_id is not None:
118
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
119
elif revision is not None:
122
raise BzrCommandError('You cannot specify a NULL revision.')
123
revno, rev_id = rev.in_history(b)
124
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
127
class cmd_revno(Command):
128
"""Show current revision number.
130
This is equal to the number of revisions on this branch."""
132
print Branch.open_containing('.')[0].revno()
135
class cmd_revision_info(Command):
136
"""Show revision number and revision id for a given revision identifier.
139
takes_args = ['revision_info*']
140
takes_options = ['revision']
141
def run(self, revision=None, revision_info_list=[]):
144
if revision is not None:
145
revs.extend(revision)
146
if revision_info_list is not None:
147
for rev in revision_info_list:
148
revs.append(RevisionSpec(rev))
150
raise BzrCommandError('You must supply a revision identifier')
152
b = Branch.open_containing('.')[0]
155
revinfo = rev.in_history(b)
156
if revinfo.revno is None:
157
print ' %s' % revinfo.rev_id
159
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
162
class cmd_add(Command):
163
"""Add specified files or directories.
165
In non-recursive mode, all the named items are added, regardless
166
of whether they were previously ignored. A warning is given if
167
any of the named files are already versioned.
169
In recursive mode (the default), files are treated the same way
170
but the behaviour for directories is different. Directories that
171
are already versioned do not give a warning. All directories,
172
whether already versioned or not, are searched for files or
173
subdirectories that are neither versioned or ignored, and these
174
are added. This search proceeds recursively into versioned
175
directories. If no names are given '.' is assumed.
177
Therefore simply saying 'bzr add' will version all files that
178
are currently unknown.
180
Adding a file whose parent directory is not versioned will
181
implicitly add the parent, and so on up to the root. This means
182
you should never need to explictly add a directory, they'll just
183
get added when you add a file in the directory.
185
takes_args = ['file*']
186
takes_options = ['no-recurse', 'quiet']
188
def run(self, file_list, no_recurse=False, quiet=False):
189
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
191
reporter = add_reporter_null
193
reporter = add_reporter_print
194
smart_add(file_list, not no_recurse, reporter)
197
class cmd_mkdir(Command):
198
"""Create a new versioned directory.
200
This is equivalent to creating the directory and then adding it.
202
takes_args = ['dir+']
204
def run(self, dir_list):
210
b = Branch.open_containing(d)[0]
215
class cmd_relpath(Command):
216
"""Show path of a file relative to root"""
217
takes_args = ['filename']
220
def run(self, filename):
221
branch, relpath = Branch.open_containing(filename)
225
class cmd_inventory(Command):
226
"""Show inventory of the current working copy or a revision."""
227
takes_options = ['revision', 'show-ids']
229
def run(self, revision=None, show_ids=False):
230
b = Branch.open_containing('.')[0]
232
inv = b.read_working_inventory()
234
if len(revision) > 1:
235
raise BzrCommandError('bzr inventory --revision takes'
236
' exactly one revision identifier')
237
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
239
for path, entry in inv.entries():
241
print '%-50s %s' % (path, entry.file_id)
246
class cmd_move(Command):
247
"""Move files to a different directory.
252
The destination must be a versioned directory in the same branch.
254
takes_args = ['source$', 'dest']
255
def run(self, source_list, dest):
256
b = Branch.open_containing('.')[0]
258
# TODO: glob expansion on windows?
259
tree = WorkingTree(b.base, b)
260
b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
263
class cmd_rename(Command):
264
"""Change the name of an entry.
267
bzr rename frob.c frobber.c
268
bzr rename src/frob.c lib/frob.c
270
It is an error if the destination name exists.
272
See also the 'move' command, which moves files into a different
273
directory without changing their name.
275
# TODO: Some way to rename multiple files without invoking
276
# bzr for each one?"""
277
takes_args = ['from_name', 'to_name']
279
def run(self, from_name, to_name):
280
b = Branch.open_containing('.')[0]
281
tree = WorkingTree(b.base, b)
282
b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
285
class cmd_mv(Command):
286
"""Move or rename a file.
289
bzr mv OLDNAME NEWNAME
290
bzr mv SOURCE... DESTINATION
292
If the last argument is a versioned directory, all the other names
293
are moved into it. Otherwise, there must be exactly two arguments
294
and the file is changed to a new name, which must not already exist.
296
Files cannot be moved between branches.
298
takes_args = ['names*']
299
def run(self, names_list):
300
if len(names_list) < 2:
301
raise BzrCommandError("missing file argument")
302
b = Branch.open_containing(names_list[0])[0]
303
tree = WorkingTree(b.base, b)
304
rel_names = [tree.relpath(x) for x in names_list]
306
if os.path.isdir(names_list[-1]):
307
# move into existing directory
308
for pair in b.move(rel_names[:-1], rel_names[-1]):
309
print "%s => %s" % pair
311
if len(names_list) != 2:
312
raise BzrCommandError('to mv multiple files the destination '
313
'must be a versioned directory')
314
b.rename_one(rel_names[0], rel_names[1])
315
print "%s => %s" % (rel_names[0], rel_names[1])
320
class cmd_pull(Command):
321
"""Pull any changes from another branch into the current one.
323
If the location is omitted, the last-used location will be used.
324
Both the revision history and the working directory will be
327
This command only works on branches that have not diverged. Branches are
328
considered diverged if both branches have had commits without first
329
pulling from the other.
331
If branches have diverged, you can use 'bzr merge' to pull the text changes
332
from one into the other.
334
takes_options = ['remember', 'clobber']
335
takes_args = ['location?']
337
def run(self, location=None, remember=False, clobber=False):
338
from bzrlib.merge import merge
340
from shutil import rmtree
343
br_to = Branch.open_containing('.')[0]
344
stored_loc = br_to.get_parent()
346
if stored_loc is None:
347
raise BzrCommandError("No pull location known or specified.")
349
print "Using saved location: %s" % stored_loc
350
location = stored_loc
351
br_from = Branch.open(location)
353
br_to.working_tree().pull(br_from, remember, clobber)
354
except DivergedBranches:
355
raise BzrCommandError("These branches have diverged."
359
class cmd_branch(Command):
360
"""Create a new copy of a branch.
362
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
363
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
365
To retrieve the branch as of a particular revision, supply the --revision
366
parameter, as in "branch foo/bar -r 5".
368
--basis is to speed up branching from remote branches. When specified, it
369
copies all the file-contents, inventory and revision data from the basis
370
branch before copying anything from the remote branch.
372
takes_args = ['from_location', 'to_location?']
373
takes_options = ['revision', 'basis']
374
aliases = ['get', 'clone']
376
def run(self, from_location, to_location=None, revision=None, basis=None):
377
from bzrlib.clone import copy_branch
380
from shutil import rmtree
381
cache_root = tempfile.mkdtemp()
384
elif len(revision) > 1:
385
raise BzrCommandError(
386
'bzr branch --revision takes exactly 1 revision value')
388
br_from = Branch.open(from_location)
390
if e.errno == errno.ENOENT:
391
raise BzrCommandError('Source location "%s" does not'
392
' exist.' % to_location)
397
br_from.setup_caching(cache_root)
398
if basis is not None:
399
basis_branch = Branch.open_containing(basis)[0]
402
if len(revision) == 1 and revision[0] is not None:
403
revision_id = revision[0].in_history(br_from)[1]
406
if to_location is None:
407
to_location = os.path.basename(from_location.rstrip("/\\"))
409
os.mkdir(to_location)
411
if e.errno == errno.EEXIST:
412
raise BzrCommandError('Target directory "%s" already'
413
' exists.' % to_location)
414
if e.errno == errno.ENOENT:
415
raise BzrCommandError('Parent of "%s" does not exist.' %
420
copy_branch(br_from, to_location, revision_id, basis_branch)
421
except bzrlib.errors.NoSuchRevision:
423
msg = "The branch %s has no revision %d." % (from_location, revision[0])
424
raise BzrCommandError(msg)
425
except bzrlib.errors.UnlistableBranch:
426
msg = "The branch %s cannot be used as a --basis"
432
class cmd_renames(Command):
433
"""Show list of renamed files.
435
# TODO: Option to show renames between two historical versions.
437
# TODO: Only show renames under dir, rather than in the whole branch.
438
takes_args = ['dir?']
440
def run(self, dir='.'):
441
b = Branch.open_containing(dir)[0]
442
old_inv = b.basis_tree().inventory
443
new_inv = b.read_working_inventory()
445
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
447
for old_name, new_name in renames:
448
print "%s => %s" % (old_name, new_name)
451
class cmd_info(Command):
452
"""Show statistical information about a branch."""
453
takes_args = ['branch?']
455
def run(self, branch=None):
457
b = Branch.open_containing(branch)[0]
461
class cmd_remove(Command):
462
"""Make a file unversioned.
464
This makes bzr stop tracking changes to a versioned file. It does
465
not delete the working copy.
467
takes_args = ['file+']
468
takes_options = ['verbose']
471
def run(self, file_list, verbose=False):
472
b = Branch.open_containing(file_list[0])[0]
473
tree = WorkingTree(b.base, b)
474
tree.remove([tree.relpath(f) for f in file_list], verbose=verbose)
477
class cmd_file_id(Command):
478
"""Print file_id of a particular file or directory.
480
The file_id is assigned when the file is first added and remains the
481
same through all revisions where the file exists, even when it is
485
takes_args = ['filename']
486
def run(self, filename):
487
b, relpath = Branch.open_containing(filename)
488
i = b.inventory.path2id(relpath)
490
raise BzrError("%r is not a versioned file" % filename)
495
class cmd_file_path(Command):
496
"""Print path of file_ids to a file or directory.
498
This prints one line for each directory down to the target,
499
starting at the branch root."""
501
takes_args = ['filename']
502
def run(self, filename):
503
b, relpath = Branch.open_containing(filename)
505
fid = inv.path2id(relpath)
507
raise BzrError("%r is not a versioned file" % filename)
508
for fip in inv.get_idpath(fid):
512
class cmd_revision_history(Command):
513
"""Display list of revision ids on this branch."""
516
for patchid in Branch.open_containing('.')[0].revision_history():
520
class cmd_ancestry(Command):
521
"""List all revisions merged into this branch."""
525
for revision_id in b.get_ancestry(b.last_revision()):
529
class cmd_directories(Command):
530
"""Display list of versioned directories in this branch."""
532
for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
539
class cmd_init(Command):
540
"""Make a directory into a versioned branch.
542
Use this to create an empty branch, or before importing an
545
Recipe for importing a tree of files:
550
bzr commit -m 'imported project'
553
Branch.initialize('.')
556
class cmd_diff(Command):
557
"""Show differences in working tree.
559
If files are listed, only the changes in those files are listed.
560
Otherwise, all changes for the tree are listed.
567
# TODO: Allow diff across branches.
568
# TODO: Option to use external diff command; could be GNU diff, wdiff,
569
# or a graphical diff.
571
# TODO: Python difflib is not exactly the same as unidiff; should
572
# either fix it up or prefer to use an external diff.
574
# TODO: If a directory is given, diff everything under that.
576
# TODO: Selected-file diff is inefficient and doesn't show you
579
# TODO: This probably handles non-Unix newlines poorly.
581
takes_args = ['file*']
582
takes_options = ['revision', 'diff-options']
583
aliases = ['di', 'dif']
585
def run(self, revision=None, file_list=None, diff_options=None):
586
from bzrlib.diff import show_diff
589
b = Branch.open_containing(file_list[0])[0]
590
tree = WorkingTree(b.base, b)
591
file_list = [tree.relpath(f) for f in file_list]
592
if file_list == ['']:
593
# just pointing to top-of-tree
596
b = Branch.open_containing('.')[0]
598
if revision is not None:
599
if len(revision) == 1:
600
show_diff(b, revision[0], specific_files=file_list,
601
external_diff_options=diff_options)
602
elif len(revision) == 2:
603
show_diff(b, revision[0], specific_files=file_list,
604
external_diff_options=diff_options,
605
revision2=revision[1])
607
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
609
show_diff(b, None, specific_files=file_list,
610
external_diff_options=diff_options)
615
class cmd_deleted(Command):
616
"""List files deleted in the working tree.
618
# TODO: Show files deleted since a previous revision, or
619
# between two revisions.
620
# TODO: Much more efficient way to do this: read in new
621
# directories with readdir, rather than stating each one. Same
622
# level of effort but possibly much less IO. (Or possibly not,
623
# if the directories are very large...)
624
def run(self, show_ids=False):
625
b = Branch.open_containing('.')[0]
627
new = b.working_tree()
628
for path, ie in old.inventory.iter_entries():
629
if not new.has_id(ie.file_id):
631
print '%-50s %s' % (path, ie.file_id)
636
class cmd_modified(Command):
637
"""List files modified in working tree."""
640
from bzrlib.delta import compare_trees
642
b = Branch.open_containing('.')[0]
643
td = compare_trees(b.basis_tree(), b.working_tree())
645
for path, id, kind, text_modified, meta_modified in td.modified:
650
class cmd_added(Command):
651
"""List files added in working tree."""
654
b = Branch.open_containing('.')[0]
655
wt = b.working_tree()
656
basis_inv = b.basis_tree().inventory
659
if file_id in basis_inv:
661
path = inv.id2path(file_id)
662
if not os.access(b.abspath(path), os.F_OK):
668
class cmd_root(Command):
669
"""Show the tree root directory.
671
The root is the nearest enclosing directory with a .bzr control
673
takes_args = ['filename?']
674
def run(self, filename=None):
675
"""Print the branch root."""
676
b = Branch.open_containing(filename)[0]
680
class cmd_log(Command):
681
"""Show log of this branch.
683
To request a range of logs, you can use the command -r begin:end
684
-r revision requests a specific revision, -r :end or -r begin: are
688
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
690
takes_args = ['filename?']
691
takes_options = [Option('forward',
692
help='show from oldest to newest'),
693
'timezone', 'verbose',
694
'show-ids', 'revision',
695
Option('line', help='format with one line per revision'),
698
help='show revisions whose message matches this regexp',
700
Option('short', help='use moderately short format'),
703
def run(self, filename=None, timezone='original',
712
from bzrlib.log import log_formatter, show_log
714
assert message is None or isinstance(message, basestring), \
715
"invalid message argument %r" % message
716
direction = (forward and 'forward') or 'reverse'
719
b, fp = Branch.open_containing(filename)
721
file_id = b.read_working_inventory().path2id(fp)
723
file_id = None # points to branch root
725
b, relpath = Branch.open_containing('.')
731
elif len(revision) == 1:
732
rev1 = rev2 = revision[0].in_history(b).revno
733
elif len(revision) == 2:
734
rev1 = revision[0].in_history(b).revno
735
rev2 = revision[1].in_history(b).revno
737
raise BzrCommandError('bzr log --revision takes one or two values.')
744
mutter('encoding log as %r' % bzrlib.user_encoding)
746
# use 'replace' so that we don't abort if trying to write out
747
# in e.g. the default C locale.
748
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
755
lf = log_formatter(log_format,
758
show_timezone=timezone)
771
class cmd_touching_revisions(Command):
772
"""Return revision-ids which affected a particular file.
774
A more user-friendly interface is "bzr log FILE"."""
776
takes_args = ["filename"]
777
def run(self, filename):
778
b, relpath = Branch.open_containing(filename)[0]
779
inv = b.read_working_inventory()
780
file_id = inv.path2id(relpath)
781
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
782
print "%6d %s" % (revno, what)
785
class cmd_ls(Command):
786
"""List files in a tree.
788
# TODO: Take a revision or remote path and list that tree instead.
790
def run(self, revision=None, verbose=False):
791
b, relpath = Branch.open_containing('.')[0]
793
tree = b.working_tree()
795
tree = b.revision_tree(revision.in_history(b).rev_id)
796
for fp, fc, kind, fid, entry in tree.list_files():
798
kindch = entry.kind_character()
799
print '%-8s %s%s' % (fc, fp, kindch)
805
class cmd_unknowns(Command):
806
"""List unknown files."""
808
from bzrlib.osutils import quotefn
809
for f in Branch.open_containing('.')[0].unknowns():
814
class cmd_ignore(Command):
815
"""Ignore a command or pattern.
817
To remove patterns from the ignore list, edit the .bzrignore file.
819
If the pattern contains a slash, it is compared to the whole path
820
from the branch root. Otherwise, it is compared to only the last
821
component of the path. To match a file only in the root directory,
824
Ignore patterns are case-insensitive on case-insensitive systems.
826
Note: wildcards must be quoted from the shell on Unix.
829
bzr ignore ./Makefile
832
# TODO: Complain if the filename is absolute
833
takes_args = ['name_pattern']
835
def run(self, name_pattern):
836
from bzrlib.atomicfile import AtomicFile
839
b, relpath = Branch.open_containing('.')
840
ifn = b.abspath('.bzrignore')
842
if os.path.exists(ifn):
845
igns = f.read().decode('utf-8')
851
# TODO: If the file already uses crlf-style termination, maybe
852
# we should use that for the newly added lines?
854
if igns and igns[-1] != '\n':
856
igns += name_pattern + '\n'
859
f = AtomicFile(ifn, 'wt')
860
f.write(igns.encode('utf-8'))
865
inv = b.working_tree().inventory
866
if inv.path2id('.bzrignore'):
867
mutter('.bzrignore is already versioned')
869
mutter('need to make new .bzrignore file versioned')
870
b.add(['.bzrignore'])
874
class cmd_ignored(Command):
875
"""List ignored files and the patterns that matched them.
877
See also: bzr ignore"""
879
tree = Branch.open_containing('.')[0].working_tree()
880
for path, file_class, kind, file_id, entry in tree.list_files():
881
if file_class != 'I':
883
## XXX: Slightly inefficient since this was already calculated
884
pat = tree.is_ignored(path)
885
print '%-50s %s' % (path, pat)
888
class cmd_lookup_revision(Command):
889
"""Lookup the revision-id from a revision-number
892
bzr lookup-revision 33
895
takes_args = ['revno']
897
def run(self, revno):
901
raise BzrCommandError("not a valid revision-number: %r" % revno)
903
print Branch.open_containing('.')[0].get_rev_id(revno)
906
class cmd_export(Command):
907
"""Export past revision to destination directory.
909
If no revision is specified this exports the last committed revision.
911
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
912
given, try to find the format with the extension. If no extension
913
is found exports to a directory (equivalent to --format=dir).
915
Root may be the top directory for tar, tgz and tbz2 formats. If none
916
is given, the top directory will be the root name of the file."""
917
# TODO: list known exporters
918
takes_args = ['dest']
919
takes_options = ['revision', 'format', 'root']
920
def run(self, dest, revision=None, format=None, root=None):
922
b = Branch.open_containing('.')[0]
924
rev_id = b.last_revision()
926
if len(revision) != 1:
927
raise BzrError('bzr export --revision takes exactly 1 argument')
928
rev_id = revision[0].in_history(b).rev_id
929
t = b.revision_tree(rev_id)
930
arg_root, ext = os.path.splitext(os.path.basename(dest))
931
if ext in ('.gz', '.bz2'):
932
new_root, new_ext = os.path.splitext(arg_root)
933
if new_ext == '.tar':
941
elif ext in (".tar.gz", ".tgz"):
943
elif ext in (".tar.bz2", ".tbz2"):
947
t.export(dest, format, root)
950
class cmd_cat(Command):
951
"""Write a file's text from a previous revision."""
953
takes_options = ['revision']
954
takes_args = ['filename']
956
def run(self, filename, revision=None):
958
raise BzrCommandError("bzr cat requires a revision number")
959
elif len(revision) != 1:
960
raise BzrCommandError("bzr cat --revision takes exactly one number")
961
b, relpath = Branch.open_containing(filename)
962
b.print_file(relpath, revision[0].in_history(b).revno)
965
class cmd_local_time_offset(Command):
966
"""Show the offset in seconds from GMT to local time."""
969
print bzrlib.osutils.local_time_offset()
973
class cmd_commit(Command):
974
"""Commit changes into a new revision.
976
If no arguments are given, the entire tree is committed.
978
If selected files are specified, only changes to those files are
979
committed. If a directory is specified then the directory and everything
980
within it is committed.
982
A selected-file commit may fail in some cases where the committed
983
tree would be invalid, such as trying to commit a file in a
984
newly-added directory that is not itself committed.
986
# TODO: Run hooks on tree to-be-committed, and after commit.
988
# TODO: Strict commit that fails if there are deleted files.
989
# (what does "deleted files" mean ??)
991
# TODO: Give better message for -s, --summary, used by tla people
993
# XXX: verbose currently does nothing
995
takes_args = ['selected*']
996
takes_options = ['message', 'verbose',
998
help='commit even if nothing has changed'),
999
Option('file', type=str,
1001
help='file containing commit message'),
1003
help="refuse to commit if there are unknown "
1004
"files in the working tree."),
1006
aliases = ['ci', 'checkin']
1008
def run(self, message=None, file=None, verbose=True, selected_list=None,
1009
unchanged=False, strict=False):
1010
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1012
from bzrlib.msgeditor import edit_commit_message
1013
from bzrlib.status import show_status
1014
from cStringIO import StringIO
1016
b = Branch.open_containing('.')[0]
1017
tree = WorkingTree(b.base, b)
1019
selected_list = [tree.relpath(s) for s in selected_list]
1020
if message is None and not file:
1021
catcher = StringIO()
1022
show_status(b, specific_files=selected_list,
1024
message = edit_commit_message(catcher.getvalue())
1027
raise BzrCommandError("please specify a commit message"
1028
" with either --message or --file")
1029
elif message and file:
1030
raise BzrCommandError("please specify either --message or --file")
1034
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1037
raise BzrCommandError("empty commit message specified")
1040
b.commit(message, specific_files=selected_list,
1041
allow_pointless=unchanged, strict=strict)
1042
except PointlessCommit:
1043
# FIXME: This should really happen before the file is read in;
1044
# perhaps prepare the commit; get the message; then actually commit
1045
raise BzrCommandError("no changes to commit",
1046
["use --unchanged to commit anyhow"])
1047
except ConflictsInTree:
1048
raise BzrCommandError("Conflicts detected in working tree. "
1049
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1050
except StrictCommitFailed:
1051
raise BzrCommandError("Commit refused because there are unknown "
1052
"files in the working tree.")
1055
class cmd_check(Command):
1056
"""Validate consistency of branch history.
1058
This command checks various invariants about the branch storage to
1059
detect data corruption or bzr bugs.
1061
takes_args = ['dir?']
1062
takes_options = ['verbose']
1064
def run(self, dir='.', verbose=False):
1065
from bzrlib.check import check
1066
check(Branch.open_containing(dir)[0], verbose)
1069
class cmd_scan_cache(Command):
1072
from bzrlib.hashcache import HashCache
1078
print '%6d stats' % c.stat_count
1079
print '%6d in hashcache' % len(c._cache)
1080
print '%6d files removed from cache' % c.removed_count
1081
print '%6d hashes updated' % c.update_count
1082
print '%6d files changed too recently to cache' % c.danger_count
1089
class cmd_upgrade(Command):
1090
"""Upgrade branch storage to current format.
1092
The check command or bzr developers may sometimes advise you to run
1095
This version of this command upgrades from the full-text storage
1096
used by bzr 0.0.8 and earlier to the weave format (v5).
1098
takes_args = ['dir?']
1100
def run(self, dir='.'):
1101
from bzrlib.upgrade import upgrade
1105
class cmd_whoami(Command):
1106
"""Show bzr user id."""
1107
takes_options = ['email']
1109
def run(self, email=False):
1111
b = bzrlib.branch.Branch.open_containing('.')[0]
1112
config = bzrlib.config.BranchConfig(b)
1113
except NotBranchError:
1114
config = bzrlib.config.GlobalConfig()
1117
print config.user_email()
1119
print config.username()
1122
class cmd_selftest(Command):
1123
"""Run internal test suite.
1125
This creates temporary test directories in the working directory,
1126
but not existing data is affected. These directories are deleted
1127
if the tests pass, or left behind to help in debugging if they
1130
If arguments are given, they are regular expressions that say
1131
which tests should run.
1133
# TODO: --list should give a list of all available tests
1135
takes_args = ['testspecs*']
1136
takes_options = ['verbose',
1137
Option('one', help='stop when one test fails'),
1140
def run(self, testspecs_list=None, verbose=False, one=False):
1142
from bzrlib.selftest import selftest
1143
# we don't want progress meters from the tests to go to the
1144
# real output; and we don't want log messages cluttering up
1146
save_ui = bzrlib.ui.ui_factory
1147
bzrlib.trace.info('running tests...')
1149
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1150
if testspecs_list is not None:
1151
pattern = '|'.join(testspecs_list)
1154
result = selftest(verbose=verbose,
1156
stop_on_failure=one)
1158
bzrlib.trace.info('tests passed')
1160
bzrlib.trace.info('tests failed')
1161
return int(not result)
1163
bzrlib.ui.ui_factory = save_ui
1167
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1168
# is bzrlib itself in a branch?
1169
bzrrev = bzrlib.get_bzr_revision()
1171
print " (bzr checkout, revision %d {%s})" % bzrrev
1172
print bzrlib.__copyright__
1173
print "http://bazaar-ng.org/"
1175
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1176
print "you may use, modify and redistribute it under the terms of the GNU"
1177
print "General Public License version 2 or later."
1180
class cmd_version(Command):
1181
"""Show version of bzr."""
1185
class cmd_rocks(Command):
1186
"""Statement of optimism."""
1189
print "it sure does!"
1192
class cmd_find_merge_base(Command):
1193
"""Find and print a base revision for merging two branches.
1195
# TODO: Options to specify revisions on either side, as if
1196
# merging only part of the history.
1197
takes_args = ['branch', 'other']
1200
def run(self, branch, other):
1201
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1203
branch1 = Branch.open_containing(branch)[0]
1204
branch2 = Branch.open_containing(other)[0]
1206
history_1 = branch1.revision_history()
1207
history_2 = branch2.revision_history()
1209
last1 = branch1.last_revision()
1210
last2 = branch2.last_revision()
1212
source = MultipleRevisionSources(branch1, branch2)
1214
base_rev_id = common_ancestor(last1, last2, source)
1216
print 'merge base is revision %s' % base_rev_id
1220
if base_revno is None:
1221
raise bzrlib.errors.UnrelatedBranches()
1223
print ' r%-6d in %s' % (base_revno, branch)
1225
other_revno = branch2.revision_id_to_revno(base_revid)
1227
print ' r%-6d in %s' % (other_revno, other)
1231
class cmd_merge(Command):
1232
"""Perform a three-way merge.
1234
The branch is the branch you will merge from. By default, it will
1235
merge the latest revision. If you specify a revision, that
1236
revision will be merged. If you specify two revisions, the first
1237
will be used as a BASE, and the second one as OTHER. Revision
1238
numbers are always relative to the specified branch.
1240
By default bzr will try to merge in all new work from the other
1241
branch, automatically determining an appropriate base. If this
1242
fails, you may need to give an explicit base.
1246
To merge the latest revision from bzr.dev
1247
bzr merge ../bzr.dev
1249
To merge changes up to and including revision 82 from bzr.dev
1250
bzr merge -r 82 ../bzr.dev
1252
To merge the changes introduced by 82, without previous changes:
1253
bzr merge -r 81..82 ../bzr.dev
1255
merge refuses to run if there are any uncommitted changes, unless
1258
takes_args = ['branch?']
1259
takes_options = ['revision', 'force', 'merge-type']
1261
def run(self, branch=None, revision=None, force=False,
1263
from bzrlib.merge import merge
1264
from bzrlib.merge_core import ApplyMerge3
1265
if merge_type is None:
1266
merge_type = ApplyMerge3
1268
branch = Branch.open_containing('.')[0].get_parent()
1270
raise BzrCommandError("No merge location known or specified.")
1272
print "Using saved location: %s" % branch
1273
if revision is None or len(revision) < 1:
1275
other = [branch, -1]
1277
if len(revision) == 1:
1279
other = [branch, revision[0].in_history(branch).revno]
1281
assert len(revision) == 2
1282
if None in revision:
1283
raise BzrCommandError(
1284
"Merge doesn't permit that revision specifier.")
1285
b = Branch.open(branch)
1287
base = [branch, revision[0].in_history(b).revno]
1288
other = [branch, revision[1].in_history(b).revno]
1291
merge(other, base, check_clean=(not force), merge_type=merge_type)
1292
except bzrlib.errors.AmbiguousBase, e:
1293
m = ("sorry, bzr can't determine the right merge base yet\n"
1294
"candidates are:\n "
1295
+ "\n ".join(e.bases)
1297
"please specify an explicit base with -r,\n"
1298
"and (if you want) report this to the bzr developers\n")
1302
class cmd_revert(Command):
1303
"""Reverse all changes since the last commit.
1305
Only versioned files are affected. Specify filenames to revert only
1306
those files. By default, any files that are changed will be backed up
1307
first. Backup files have a '~' appended to their name.
1309
takes_options = ['revision', 'no-backup']
1310
takes_args = ['file*']
1311
aliases = ['merge-revert']
1313
def run(self, revision=None, no_backup=False, file_list=None):
1314
from bzrlib.merge import merge
1315
from bzrlib.commands import parse_spec
1317
if file_list is not None:
1318
if len(file_list) == 0:
1319
raise BzrCommandError("No files specified")
1320
if revision is None:
1322
elif len(revision) != 1:
1323
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1325
b = Branch.open_containing('.')[0]
1326
revno = revision[0].in_history(b).revno
1327
merge(('.', revno), parse_spec('.'),
1330
backup_files=not no_backup,
1331
file_list=file_list)
1333
Branch.open_containing('.')[0].set_pending_merges([])
1336
class cmd_assert_fail(Command):
1337
"""Test reporting of assertion failures"""
1340
assert False, "always fails"
1343
class cmd_help(Command):
1344
"""Show help on a command or other topic.
1346
For a list of all available commands, say 'bzr help commands'."""
1347
takes_options = ['long']
1348
takes_args = ['topic?']
1351
def run(self, topic=None, long=False):
1353
if topic is None and long:
1358
class cmd_shell_complete(Command):
1359
"""Show appropriate completions for context.
1361
For a list of all available commands, say 'bzr shell-complete'."""
1362
takes_args = ['context?']
1366
def run(self, context=None):
1367
import shellcomplete
1368
shellcomplete.shellcomplete(context)
1371
class cmd_fetch(Command):
1372
"""Copy in history from another branch but don't merge it.
1374
This is an internal method used for pull and merge."""
1376
takes_args = ['from_branch', 'to_branch']
1377
def run(self, from_branch, to_branch):
1378
from bzrlib.fetch import Fetcher
1379
from bzrlib.branch import Branch
1380
from_b = Branch(from_branch)
1381
to_b = Branch(to_branch)
1382
Fetcher(to_b, from_b)
1386
class cmd_missing(Command):
1387
"""What is missing in this branch relative to other branch.
1389
# TODO: rewrite this in terms of ancestry so that it shows only
1392
takes_args = ['remote?']
1393
aliases = ['mis', 'miss']
1394
# We don't have to add quiet to the list, because
1395
# unknown options are parsed as booleans
1396
takes_options = ['verbose', 'quiet']
1398
def run(self, remote=None, verbose=False, quiet=False):
1399
from bzrlib.errors import BzrCommandError
1400
from bzrlib.missing import show_missing
1402
if verbose and quiet:
1403
raise BzrCommandError('Cannot pass both quiet and verbose')
1405
b = Branch.open_containing('.')[0]
1406
parent = b.get_parent()
1409
raise BzrCommandError("No missing location known or specified.")
1412
print "Using last location: %s" % parent
1414
elif parent is None:
1415
# We only update parent if it did not exist, missing
1416
# should not change the parent
1417
b.set_parent(remote)
1418
br_remote = Branch.open_containing(remote)[0]
1419
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1422
class cmd_plugins(Command):
1426
import bzrlib.plugin
1427
from inspect import getdoc
1428
for plugin in bzrlib.plugin.all_plugins:
1429
if hasattr(plugin, '__path__'):
1430
print plugin.__path__[0]
1431
elif hasattr(plugin, '__file__'):
1432
print plugin.__file__
1438
print '\t', d.split('\n')[0]
1441
class cmd_testament(Command):
1442
"""Show testament (signing-form) of a revision."""
1443
takes_options = ['revision', 'long']
1444
takes_args = ['branch?']
1445
def run(self, branch='.', revision=None, long=False):
1446
from bzrlib.testament import Testament
1447
b = Branch.open_containing(branch)[0]
1450
if revision is None:
1451
rev_id = b.last_revision()
1453
rev_id = revision[0].in_history(b).rev_id
1454
t = Testament.from_revision(b, rev_id)
1456
sys.stdout.writelines(t.as_text_lines())
1458
sys.stdout.write(t.as_short_text())
1463
class cmd_annotate(Command):
1464
"""Show the origin of each line in a file.
1466
This prints out the given file with an annotation on the left side
1467
indicating which revision, author and date introduced the change.
1469
If the origin is the same for a run of consecutive lines, it is
1470
shown only at the top, unless the --all option is given.
1472
# TODO: annotate directories; showing when each file was last changed
1473
# TODO: annotate a previous version of a file
1474
# TODO: if the working copy is modified, show annotations on that
1475
# with new uncommitted lines marked
1476
aliases = ['blame', 'praise']
1477
takes_args = ['filename']
1478
takes_options = [Option('all', help='show annotations on all lines'),
1479
Option('long', help='show date in annotations'),
1482
def run(self, filename, all=False, long=False):
1483
from bzrlib.annotate import annotate_file
1484
b, relpath = Branch.open_containing(filename)
1487
tree = WorkingTree(b.base, b)
1488
tree = b.revision_tree(b.last_revision())
1489
file_id = tree.inventory.path2id(relpath)
1490
file_version = tree.inventory[file_id].revision
1491
annotate_file(b, file_version, file_id, long, all, sys.stdout)
1496
class cmd_re_sign(Command):
1497
"""Create a digital signature for an existing revision."""
1498
# TODO be able to replace existing ones.
1500
hidden = True # is this right ?
1501
takes_args = ['revision_id?']
1502
takes_options = ['revision']
1504
def run(self, revision_id=None, revision=None):
1505
import bzrlib.config as config
1506
import bzrlib.gpg as gpg
1507
if revision_id is not None and revision is not None:
1508
raise BzrCommandError('You can only supply one of revision_id or --revision')
1509
if revision_id is None and revision is None:
1510
raise BzrCommandError('You must supply either --revision or a revision_id')
1511
b = Branch.open_containing('.')[0]
1512
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1513
if revision_id is not None:
1514
b.sign_revision(revision_id, gpg_strategy)
1515
elif revision is not None:
1516
for rev in revision:
1518
raise BzrCommandError('You cannot specify a NULL revision.')
1519
revno, rev_id = rev.in_history(b)
1520
b.sign_revision(rev_id, gpg_strategy)
1523
# these get imported and then picked up by the scan for cmd_*
1524
# TODO: Some more consistent way to split command definitions across files;
1525
# we do need to load at least some information about them to know of
1527
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
added
removed
bzrlib/builtins.py
