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.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
30
from bzrlib.errors import DivergedBranches
31
from bzrlib.option import Option
32
from bzrlib.revisionspec import RevisionSpec
34
from bzrlib.trace import mutter, note, log_error, warning
35
from bzrlib.workingtree import WorkingTree
38
# TODO: Make sure no commands unconditionally use the working directory as a
39
# branch. If a filename argument is used, the first of them should be used to
40
# specify the branch. (Perhaps this can be factored out into some kind of
41
# Argument class, representing a file in a branch, where the first occurrence
44
class cmd_status(Command):
45
"""Display status summary.
47
This reports on versioned and unknown files, reporting them
48
grouped by state. Possible states are:
51
Versioned in the working copy but not in the previous revision.
54
Versioned in the previous revision but removed or deleted
58
Path of this file changed from the previous revision;
59
the text may also have changed. This includes files whose
60
parent directory was renamed.
63
Text has changed since the previous revision.
66
Nothing about this file has changed since the previous revision.
67
Only shown with --all.
70
Not versioned and not matching an ignore pattern.
72
To see ignored files use 'bzr ignored'. For details in the
73
changes to file texts, use 'bzr diff'.
75
If no arguments are specified, the status of the entire working
76
directory is shown. Otherwise, only the status of the specified
77
files or directories is reported. If a directory is given, status
78
is reported for everything inside that directory.
80
If a revision argument is given, the status is calculated against
81
that revision, or between two revisions if two are provided.
84
# XXX: FIXME: bzr status should accept a -r option to show changes
85
# relative to a revision, or between revisions
87
# TODO: --no-recurse, --recurse options
89
takes_args = ['file*']
90
takes_options = ['all', 'show-ids']
91
aliases = ['st', 'stat']
94
def run(self, all=False, show_ids=False, file_list=None, revision=None):
96
b, relpath = Branch.open_containing(file_list[0])
97
if relpath == '' and len(file_list) == 1:
100
# generate relative paths.
101
# note that if this is a remote branch, we would want
102
# relpath against the transport. RBC 20051018
103
tree = WorkingTree(b.base, b)
104
file_list = [tree.relpath(x) for x in file_list]
106
b = Branch.open_containing('.')[0]
108
from bzrlib.status import show_status
109
show_status(b, show_unchanged=all, show_ids=show_ids,
110
specific_files=file_list, revision=revision)
113
class cmd_cat_revision(Command):
114
"""Write out metadata for a revision.
116
The revision to print can either be specified by a specific
117
revision identifier, or you can use --revision.
121
takes_args = ['revision_id?']
122
takes_options = ['revision']
125
def run(self, revision_id=None, revision=None):
127
if revision_id is not None and revision is not None:
128
raise BzrCommandError('You can only supply one of revision_id or --revision')
129
if revision_id is None and revision is None:
130
raise BzrCommandError('You must supply either --revision or a revision_id')
131
b = Branch.open_containing('.')[0]
132
if revision_id is not None:
133
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
134
elif revision is not None:
137
raise BzrCommandError('You cannot specify a NULL revision.')
138
revno, rev_id = rev.in_history(b)
139
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
142
class cmd_revno(Command):
143
"""Show current revision number.
145
This is equal to the number of revisions on this branch."""
148
print Branch.open_containing('.')[0].revno()
151
class cmd_revision_info(Command):
152
"""Show revision number and revision id for a given revision identifier.
155
takes_args = ['revision_info*']
156
takes_options = ['revision']
158
def run(self, revision=None, revision_info_list=[]):
161
if revision is not None:
162
revs.extend(revision)
163
if revision_info_list is not None:
164
for rev in revision_info_list:
165
revs.append(RevisionSpec(rev))
167
raise BzrCommandError('You must supply a revision identifier')
169
b = Branch.open_containing('.')[0]
172
revinfo = rev.in_history(b)
173
if revinfo.revno is None:
174
print ' %s' % revinfo.rev_id
176
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
179
class cmd_add(Command):
180
"""Add specified files or directories.
182
In non-recursive mode, all the named items are added, regardless
183
of whether they were previously ignored. A warning is given if
184
any of the named files are already versioned.
186
In recursive mode (the default), files are treated the same way
187
but the behaviour for directories is different. Directories that
188
are already versioned do not give a warning. All directories,
189
whether already versioned or not, are searched for files or
190
subdirectories that are neither versioned or ignored, and these
191
are added. This search proceeds recursively into versioned
192
directories. If no names are given '.' is assumed.
194
Therefore simply saying 'bzr add' will version all files that
195
are currently unknown.
197
Adding a file whose parent directory is not versioned will
198
implicitly add the parent, and so on up to the root. This means
199
you should never need to explictly add a directory, they'll just
200
get added when you add a file in the directory.
202
takes_args = ['file*']
203
takes_options = ['no-recurse', 'quiet']
205
def run(self, file_list, no_recurse=False, quiet=False):
206
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
208
reporter = add_reporter_null
210
reporter = add_reporter_print
211
smart_add(file_list, not no_recurse, reporter)
214
class cmd_mkdir(Command):
215
"""Create a new versioned directory.
217
This is equivalent to creating the directory and then adding it.
219
takes_args = ['dir+']
221
def run(self, dir_list):
227
b = Branch.open_containing(d)[0]
232
class cmd_relpath(Command):
233
"""Show path of a file relative to root"""
234
takes_args = ['filename']
238
def run(self, filename):
239
branch, relpath = Branch.open_containing(filename)
243
class cmd_inventory(Command):
244
"""Show inventory of the current working copy or a revision."""
245
takes_options = ['revision', 'show-ids']
248
def run(self, revision=None, show_ids=False):
249
b = Branch.open_containing('.')[0]
251
inv = b.read_working_inventory()
253
if len(revision) > 1:
254
raise BzrCommandError('bzr inventory --revision takes'
255
' exactly one revision identifier')
256
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
258
for path, entry in inv.entries():
260
print '%-50s %s' % (path, entry.file_id)
265
class cmd_move(Command):
266
"""Move files to a different directory.
271
The destination must be a versioned directory in the same branch.
273
takes_args = ['source$', 'dest']
274
def run(self, source_list, dest):
275
b = Branch.open_containing('.')[0]
277
# TODO: glob expansion on windows?
278
tree = WorkingTree(b.base, b)
279
b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
282
class cmd_rename(Command):
283
"""Change the name of an entry.
286
bzr rename frob.c frobber.c
287
bzr rename src/frob.c lib/frob.c
289
It is an error if the destination name exists.
291
See also the 'move' command, which moves files into a different
292
directory without changing their name.
294
# TODO: Some way to rename multiple files without invoking
295
# bzr for each one?"""
296
takes_args = ['from_name', 'to_name']
298
def run(self, from_name, to_name):
299
b = Branch.open_containing('.')[0]
300
tree = WorkingTree(b.base, b)
301
b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
304
class cmd_mv(Command):
305
"""Move or rename a file.
308
bzr mv OLDNAME NEWNAME
309
bzr mv SOURCE... DESTINATION
311
If the last argument is a versioned directory, all the other names
312
are moved into it. Otherwise, there must be exactly two arguments
313
and the file is changed to a new name, which must not already exist.
315
Files cannot be moved between branches.
317
takes_args = ['names*']
318
def run(self, names_list):
319
if len(names_list) < 2:
320
raise BzrCommandError("missing file argument")
321
b = Branch.open_containing(names_list[0])[0]
322
tree = WorkingTree(b.base, b)
323
rel_names = [tree.relpath(x) for x in names_list]
325
if os.path.isdir(names_list[-1]):
326
# move into existing directory
327
for pair in b.move(rel_names[:-1], rel_names[-1]):
328
print "%s => %s" % pair
330
if len(names_list) != 2:
331
raise BzrCommandError('to mv multiple files the destination '
332
'must be a versioned directory')
333
b.rename_one(rel_names[0], rel_names[1])
334
print "%s => %s" % (rel_names[0], rel_names[1])
339
class cmd_pull(Command):
340
"""Pull any changes from another branch into the current one.
342
If the location is omitted, the last-used location will be used.
343
Both the revision history and the working directory will be
346
This command only works on branches that have not diverged. Branches are
347
considered diverged if both branches have had commits without first
348
pulling from the other.
350
If branches have diverged, you can use 'bzr merge' to pull the text changes
351
from one into the other.
353
takes_options = ['remember', 'clobber']
354
takes_args = ['location?']
356
def run(self, location=None, remember=False, clobber=False):
357
from bzrlib.merge import merge
358
from shutil import rmtree
361
br_to = Branch.open_containing('.')[0]
362
stored_loc = br_to.get_parent()
364
if stored_loc is None:
365
raise BzrCommandError("No pull location known or specified.")
367
print "Using saved location: %s" % stored_loc
368
location = stored_loc
369
br_from = Branch.open(location)
371
br_to.working_tree().pull(br_from, remember, clobber)
372
except DivergedBranches:
373
raise BzrCommandError("These branches have diverged."
377
class cmd_branch(Command):
378
"""Create a new copy of a branch.
380
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
381
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
383
To retrieve the branch as of a particular revision, supply the --revision
384
parameter, as in "branch foo/bar -r 5".
386
--basis is to speed up branching from remote branches. When specified, it
387
copies all the file-contents, inventory and revision data from the basis
388
branch before copying anything from the remote branch.
390
takes_args = ['from_location', 'to_location?']
391
takes_options = ['revision', 'basis']
392
aliases = ['get', 'clone']
394
def run(self, from_location, to_location=None, revision=None, basis=None):
395
from bzrlib.clone import copy_branch
397
from shutil import rmtree
400
elif len(revision) > 1:
401
raise BzrCommandError(
402
'bzr branch --revision takes exactly 1 revision value')
404
br_from = Branch.open(from_location)
406
if e.errno == errno.ENOENT:
407
raise BzrCommandError('Source location "%s" does not'
408
' exist.' % to_location)
413
if basis is not None:
414
basis_branch = Branch.open_containing(basis)[0]
417
if len(revision) == 1 and revision[0] is not None:
418
revision_id = revision[0].in_history(br_from)[1]
421
if to_location is None:
422
to_location = os.path.basename(from_location.rstrip("/\\"))
425
name = os.path.basename(to_location) + '\n'
427
os.mkdir(to_location)
429
if e.errno == errno.EEXIST:
430
raise BzrCommandError('Target directory "%s" already'
431
' exists.' % to_location)
432
if e.errno == errno.ENOENT:
433
raise BzrCommandError('Parent of "%s" does not exist.' %
438
copy_branch(br_from, to_location, revision_id, basis_branch)
439
except bzrlib.errors.NoSuchRevision:
441
msg = "The branch %s has no revision %s." % (from_location, revision[0])
442
raise BzrCommandError(msg)
443
except bzrlib.errors.UnlistableBranch:
445
msg = "The branch %s cannot be used as a --basis"
446
raise BzrCommandError(msg)
448
branch = Branch.open(to_location)
449
name = StringIO(name)
450
branch.put_controlfile('branch-name', name)
455
class cmd_renames(Command):
456
"""Show list of renamed files.
458
# TODO: Option to show renames between two historical versions.
460
# TODO: Only show renames under dir, rather than in the whole branch.
461
takes_args = ['dir?']
464
def run(self, dir='.'):
465
b = Branch.open_containing(dir)[0]
466
old_inv = b.basis_tree().inventory
467
new_inv = b.read_working_inventory()
469
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
471
for old_name, new_name in renames:
472
print "%s => %s" % (old_name, new_name)
475
class cmd_info(Command):
476
"""Show statistical information about a branch."""
477
takes_args = ['branch?']
480
def run(self, branch=None):
482
b = Branch.open_containing(branch)[0]
486
class cmd_remove(Command):
487
"""Make a file unversioned.
489
This makes bzr stop tracking changes to a versioned file. It does
490
not delete the working copy.
492
takes_args = ['file+']
493
takes_options = ['verbose']
496
def run(self, file_list, verbose=False):
497
b = Branch.open_containing(file_list[0])[0]
498
tree = WorkingTree(b.base, b)
499
tree.remove([tree.relpath(f) for f in file_list], verbose=verbose)
502
class cmd_file_id(Command):
503
"""Print file_id of a particular file or directory.
505
The file_id is assigned when the file is first added and remains the
506
same through all revisions where the file exists, even when it is
510
takes_args = ['filename']
512
def run(self, filename):
513
b, relpath = Branch.open_containing(filename)
514
i = b.inventory.path2id(relpath)
516
raise BzrError("%r is not a versioned file" % filename)
521
class cmd_file_path(Command):
522
"""Print path of file_ids to a file or directory.
524
This prints one line for each directory down to the target,
525
starting at the branch root."""
527
takes_args = ['filename']
529
def run(self, filename):
530
b, relpath = Branch.open_containing(filename)
532
fid = inv.path2id(relpath)
534
raise BzrError("%r is not a versioned file" % filename)
535
for fip in inv.get_idpath(fid):
539
class cmd_revision_history(Command):
540
"""Display list of revision ids on this branch."""
544
for patchid in Branch.open_containing('.')[0].revision_history():
548
class cmd_ancestry(Command):
549
"""List all revisions merged into this branch."""
553
b = Branch.open_containing('.')[0]
554
for revision_id in b.get_ancestry(b.last_revision()):
558
class cmd_directories(Command):
559
"""Display list of versioned directories in this branch."""
562
for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
569
class cmd_init(Command):
570
"""Make a directory into a versioned branch.
572
Use this to create an empty branch, or before importing an
575
Recipe for importing a tree of files:
580
bzr commit -m 'imported project'
583
Branch.initialize('.')
586
class cmd_diff(Command):
587
"""Show differences in working tree.
589
If files are listed, only the changes in those files are listed.
590
Otherwise, all changes for the tree are listed.
597
# TODO: Allow diff across branches.
598
# TODO: Option to use external diff command; could be GNU diff, wdiff,
599
# or a graphical diff.
601
# TODO: Python difflib is not exactly the same as unidiff; should
602
# either fix it up or prefer to use an external diff.
604
# TODO: If a directory is given, diff everything under that.
606
# TODO: Selected-file diff is inefficient and doesn't show you
609
# TODO: This probably handles non-Unix newlines poorly.
611
takes_args = ['file*']
612
takes_options = ['revision', 'diff-options']
613
aliases = ['di', 'dif']
616
def run(self, revision=None, file_list=None, diff_options=None):
617
from bzrlib.diff import show_diff
620
b = Branch.open_containing(file_list[0])[0]
621
tree = WorkingTree(b.base, b)
622
file_list = [tree.relpath(f) for f in file_list]
623
if file_list == ['']:
624
# just pointing to top-of-tree
627
b = Branch.open_containing('.')[0]
629
if revision is not None:
630
if len(revision) == 1:
631
show_diff(b, revision[0], specific_files=file_list,
632
external_diff_options=diff_options)
633
elif len(revision) == 2:
634
show_diff(b, revision[0], specific_files=file_list,
635
external_diff_options=diff_options,
636
revision2=revision[1])
638
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
640
show_diff(b, None, specific_files=file_list,
641
external_diff_options=diff_options)
646
class cmd_deleted(Command):
647
"""List files deleted in the working tree.
649
# TODO: Show files deleted since a previous revision, or
650
# between two revisions.
651
# TODO: Much more efficient way to do this: read in new
652
# directories with readdir, rather than stating each one. Same
653
# level of effort but possibly much less IO. (Or possibly not,
654
# if the directories are very large...)
656
def run(self, show_ids=False):
657
b = Branch.open_containing('.')[0]
659
new = b.working_tree()
660
for path, ie in old.inventory.iter_entries():
661
if not new.has_id(ie.file_id):
663
print '%-50s %s' % (path, ie.file_id)
668
class cmd_modified(Command):
669
"""List files modified in working tree."""
673
from bzrlib.delta import compare_trees
675
b = Branch.open_containing('.')[0]
676
td = compare_trees(b.basis_tree(), b.working_tree())
678
for path, id, kind, text_modified, meta_modified in td.modified:
683
class cmd_added(Command):
684
"""List files added in working tree."""
688
b = Branch.open_containing('.')[0]
689
wt = b.working_tree()
690
basis_inv = b.basis_tree().inventory
693
if file_id in basis_inv:
695
path = inv.id2path(file_id)
696
if not os.access(b.abspath(path), os.F_OK):
702
class cmd_root(Command):
703
"""Show the tree root directory.
705
The root is the nearest enclosing directory with a .bzr control
707
takes_args = ['filename?']
709
def run(self, filename=None):
710
"""Print the branch root."""
711
b = Branch.open_containing(filename)[0]
715
class cmd_log(Command):
716
"""Show log of this branch.
718
To request a range of logs, you can use the command -r begin:end
719
-r revision requests a specific revision, -r :end or -r begin: are
723
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
725
takes_args = ['filename?']
726
takes_options = [Option('forward',
727
help='show from oldest to newest'),
728
'timezone', 'verbose',
729
'show-ids', 'revision',
730
Option('line', help='format with one line per revision'),
733
help='show revisions whose message matches this regexp',
735
Option('short', help='use moderately short format'),
738
def run(self, filename=None, timezone='original',
747
from bzrlib.log import log_formatter, show_log
749
assert message is None or isinstance(message, basestring), \
750
"invalid message argument %r" % message
751
direction = (forward and 'forward') or 'reverse'
754
b, fp = Branch.open_containing(filename)
756
file_id = b.read_working_inventory().path2id(fp)
758
file_id = None # points to branch root
760
b, relpath = Branch.open_containing('.')
766
elif len(revision) == 1:
767
rev1 = rev2 = revision[0].in_history(b).revno
768
elif len(revision) == 2:
769
rev1 = revision[0].in_history(b).revno
770
rev2 = revision[1].in_history(b).revno
772
raise BzrCommandError('bzr log --revision takes one or two values.')
779
mutter('encoding log as %r' % bzrlib.user_encoding)
781
# use 'replace' so that we don't abort if trying to write out
782
# in e.g. the default C locale.
783
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
790
lf = log_formatter(log_format,
793
show_timezone=timezone)
806
class cmd_touching_revisions(Command):
807
"""Return revision-ids which affected a particular file.
809
A more user-friendly interface is "bzr log FILE"."""
811
takes_args = ["filename"]
813
def run(self, filename):
814
b, relpath = Branch.open_containing(filename)[0]
815
inv = b.read_working_inventory()
816
file_id = inv.path2id(relpath)
817
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
818
print "%6d %s" % (revno, what)
821
class cmd_ls(Command):
822
"""List files in a tree.
824
# TODO: Take a revision or remote path and list that tree instead.
827
def run(self, revision=None, verbose=False):
828
b, relpath = Branch.open_containing('.')[0]
830
tree = b.working_tree()
832
tree = b.revision_tree(revision.in_history(b).rev_id)
833
for fp, fc, kind, fid, entry in tree.list_files():
835
kindch = entry.kind_character()
836
print '%-8s %s%s' % (fc, fp, kindch)
842
class cmd_unknowns(Command):
843
"""List unknown files."""
846
from bzrlib.osutils import quotefn
847
for f in Branch.open_containing('.')[0].unknowns():
852
class cmd_ignore(Command):
853
"""Ignore a command or pattern.
855
To remove patterns from the ignore list, edit the .bzrignore file.
857
If the pattern contains a slash, it is compared to the whole path
858
from the branch root. Otherwise, it is compared to only the last
859
component of the path. To match a file only in the root directory,
862
Ignore patterns are case-insensitive on case-insensitive systems.
864
Note: wildcards must be quoted from the shell on Unix.
867
bzr ignore ./Makefile
870
# TODO: Complain if the filename is absolute
871
takes_args = ['name_pattern']
873
def run(self, name_pattern):
874
from bzrlib.atomicfile import AtomicFile
877
b, relpath = Branch.open_containing('.')
878
ifn = b.abspath('.bzrignore')
880
if os.path.exists(ifn):
883
igns = f.read().decode('utf-8')
889
# TODO: If the file already uses crlf-style termination, maybe
890
# we should use that for the newly added lines?
892
if igns and igns[-1] != '\n':
894
igns += name_pattern + '\n'
897
f = AtomicFile(ifn, 'wt')
898
f.write(igns.encode('utf-8'))
903
inv = b.working_tree().inventory
904
if inv.path2id('.bzrignore'):
905
mutter('.bzrignore is already versioned')
907
mutter('need to make new .bzrignore file versioned')
908
b.add(['.bzrignore'])
912
class cmd_ignored(Command):
913
"""List ignored files and the patterns that matched them.
915
See also: bzr ignore"""
918
tree = Branch.open_containing('.')[0].working_tree()
919
for path, file_class, kind, file_id, entry in tree.list_files():
920
if file_class != 'I':
922
## XXX: Slightly inefficient since this was already calculated
923
pat = tree.is_ignored(path)
924
print '%-50s %s' % (path, pat)
927
class cmd_lookup_revision(Command):
928
"""Lookup the revision-id from a revision-number
931
bzr lookup-revision 33
934
takes_args = ['revno']
937
def run(self, revno):
941
raise BzrCommandError("not a valid revision-number: %r" % revno)
943
print Branch.open_containing('.')[0].get_rev_id(revno)
946
class cmd_export(Command):
947
"""Export past revision to destination directory.
949
If no revision is specified this exports the last committed revision.
951
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
952
given, try to find the format with the extension. If no extension
953
is found exports to a directory (equivalent to --format=dir).
955
Root may be the top directory for tar, tgz and tbz2 formats. If none
956
is given, the top directory will be the root name of the file."""
957
# TODO: list known exporters
958
takes_args = ['dest']
959
takes_options = ['revision', 'format', 'root']
960
def run(self, dest, revision=None, format=None, root=None):
962
b = Branch.open_containing('.')[0]
964
rev_id = b.last_revision()
966
if len(revision) != 1:
967
raise BzrError('bzr export --revision takes exactly 1 argument')
968
rev_id = revision[0].in_history(b).rev_id
969
t = b.revision_tree(rev_id)
970
arg_root, ext = os.path.splitext(os.path.basename(dest))
971
if ext in ('.gz', '.bz2'):
972
new_root, new_ext = os.path.splitext(arg_root)
973
if new_ext == '.tar':
981
elif ext in (".tar.gz", ".tgz"):
983
elif ext in (".tar.bz2", ".tbz2"):
987
t.export(dest, format, root)
990
class cmd_cat(Command):
991
"""Write a file's text from a previous revision."""
993
takes_options = ['revision']
994
takes_args = ['filename']
997
def run(self, filename, revision=None):
999
raise BzrCommandError("bzr cat requires a revision number")
1000
elif len(revision) != 1:
1001
raise BzrCommandError("bzr cat --revision takes exactly one number")
1002
b, relpath = Branch.open_containing(filename)
1003
b.print_file(relpath, revision[0].in_history(b).revno)
1006
class cmd_local_time_offset(Command):
1007
"""Show the offset in seconds from GMT to local time."""
1011
print bzrlib.osutils.local_time_offset()
1015
class cmd_commit(Command):
1016
"""Commit changes into a new revision.
1018
If no arguments are given, the entire tree is committed.
1020
If selected files are specified, only changes to those files are
1021
committed. If a directory is specified then the directory and everything
1022
within it is committed.
1024
A selected-file commit may fail in some cases where the committed
1025
tree would be invalid, such as trying to commit a file in a
1026
newly-added directory that is not itself committed.
1028
# TODO: Run hooks on tree to-be-committed, and after commit.
1030
# TODO: Strict commit that fails if there are deleted files.
1031
# (what does "deleted files" mean ??)
1033
# TODO: Give better message for -s, --summary, used by tla people
1035
# XXX: verbose currently does nothing
1037
takes_args = ['selected*']
1038
takes_options = ['message', 'verbose',
1040
help='commit even if nothing has changed'),
1041
Option('file', type=str,
1043
help='file containing commit message'),
1045
help="refuse to commit if there are unknown "
1046
"files in the working tree."),
1048
aliases = ['ci', 'checkin']
1050
def run(self, message=None, file=None, verbose=True, selected_list=None,
1051
unchanged=False, strict=False):
1052
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1054
from bzrlib.msgeditor import edit_commit_message
1055
from bzrlib.status import show_status
1056
from cStringIO import StringIO
1058
b = Branch.open_containing('.')[0]
1059
tree = WorkingTree(b.base, b)
1061
selected_list = [tree.relpath(s) for s in selected_list]
1062
if message is None and not file:
1063
catcher = StringIO()
1064
show_status(b, specific_files=selected_list,
1066
message = edit_commit_message(catcher.getvalue())
1069
raise BzrCommandError("please specify a commit message"
1070
" with either --message or --file")
1071
elif message and file:
1072
raise BzrCommandError("please specify either --message or --file")
1076
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1079
raise BzrCommandError("empty commit message specified")
1082
b.commit(message, specific_files=selected_list,
1083
allow_pointless=unchanged, strict=strict)
1084
except PointlessCommit:
1085
# FIXME: This should really happen before the file is read in;
1086
# perhaps prepare the commit; get the message; then actually commit
1087
raise BzrCommandError("no changes to commit",
1088
["use --unchanged to commit anyhow"])
1089
except ConflictsInTree:
1090
raise BzrCommandError("Conflicts detected in working tree. "
1091
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1092
except StrictCommitFailed:
1093
raise BzrCommandError("Commit refused because there are unknown "
1094
"files in the working tree.")
1097
class cmd_check(Command):
1098
"""Validate consistency of branch history.
1100
This command checks various invariants about the branch storage to
1101
detect data corruption or bzr bugs.
1103
takes_args = ['dir?']
1104
takes_options = ['verbose']
1106
def run(self, dir='.', verbose=False):
1107
from bzrlib.check import check
1108
check(Branch.open_containing(dir)[0], verbose)
1111
class cmd_scan_cache(Command):
1114
from bzrlib.hashcache import HashCache
1120
print '%6d stats' % c.stat_count
1121
print '%6d in hashcache' % len(c._cache)
1122
print '%6d files removed from cache' % c.removed_count
1123
print '%6d hashes updated' % c.update_count
1124
print '%6d files changed too recently to cache' % c.danger_count
1131
class cmd_upgrade(Command):
1132
"""Upgrade branch storage to current format.
1134
The check command or bzr developers may sometimes advise you to run
1137
This version of this command upgrades from the full-text storage
1138
used by bzr 0.0.8 and earlier to the weave format (v5).
1140
takes_args = ['dir?']
1142
def run(self, dir='.'):
1143
from bzrlib.upgrade import upgrade
1147
class cmd_whoami(Command):
1148
"""Show bzr user id."""
1149
takes_options = ['email']
1152
def run(self, email=False):
1154
b = bzrlib.branch.Branch.open_containing('.')[0]
1155
config = bzrlib.config.BranchConfig(b)
1156
except NotBranchError:
1157
config = bzrlib.config.GlobalConfig()
1160
print config.user_email()
1162
print config.username()
1165
class cmd_selftest(Command):
1166
"""Run internal test suite.
1168
This creates temporary test directories in the working directory,
1169
but not existing data is affected. These directories are deleted
1170
if the tests pass, or left behind to help in debugging if they
1173
If arguments are given, they are regular expressions that say
1174
which tests should run.
1176
# TODO: --list should give a list of all available tests
1178
takes_args = ['testspecs*']
1179
takes_options = ['verbose',
1180
Option('one', help='stop when one test fails'),
1183
def run(self, testspecs_list=None, verbose=False, one=False):
1185
from bzrlib.selftest import selftest
1186
# we don't want progress meters from the tests to go to the
1187
# real output; and we don't want log messages cluttering up
1189
save_ui = bzrlib.ui.ui_factory
1190
bzrlib.trace.info('running tests...')
1192
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1193
if testspecs_list is not None:
1194
pattern = '|'.join(testspecs_list)
1197
result = selftest(verbose=verbose,
1199
stop_on_failure=one)
1201
bzrlib.trace.info('tests passed')
1203
bzrlib.trace.info('tests failed')
1204
return int(not result)
1206
bzrlib.ui.ui_factory = save_ui
1210
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1211
# is bzrlib itself in a branch?
1212
bzrrev = bzrlib.get_bzr_revision()
1214
print " (bzr checkout, revision %d {%s})" % bzrrev
1215
print bzrlib.__copyright__
1216
print "http://bazaar-ng.org/"
1218
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1219
print "you may use, modify and redistribute it under the terms of the GNU"
1220
print "General Public License version 2 or later."
1223
class cmd_version(Command):
1224
"""Show version of bzr."""
1229
class cmd_rocks(Command):
1230
"""Statement of optimism."""
1234
print "it sure does!"
1237
class cmd_find_merge_base(Command):
1238
"""Find and print a base revision for merging two branches.
1240
# TODO: Options to specify revisions on either side, as if
1241
# merging only part of the history.
1242
takes_args = ['branch', 'other']
1246
def run(self, branch, other):
1247
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1249
branch1 = Branch.open_containing(branch)[0]
1250
branch2 = Branch.open_containing(other)[0]
1252
history_1 = branch1.revision_history()
1253
history_2 = branch2.revision_history()
1255
last1 = branch1.last_revision()
1256
last2 = branch2.last_revision()
1258
source = MultipleRevisionSources(branch1, branch2)
1260
base_rev_id = common_ancestor(last1, last2, source)
1262
print 'merge base is revision %s' % base_rev_id
1266
if base_revno is None:
1267
raise bzrlib.errors.UnrelatedBranches()
1269
print ' r%-6d in %s' % (base_revno, branch)
1271
other_revno = branch2.revision_id_to_revno(base_revid)
1273
print ' r%-6d in %s' % (other_revno, other)
1277
class cmd_merge(Command):
1278
"""Perform a three-way merge.
1280
The branch is the branch you will merge from. By default, it will
1281
merge the latest revision. If you specify a revision, that
1282
revision will be merged. If you specify two revisions, the first
1283
will be used as a BASE, and the second one as OTHER. Revision
1284
numbers are always relative to the specified branch.
1286
By default bzr will try to merge in all new work from the other
1287
branch, automatically determining an appropriate base. If this
1288
fails, you may need to give an explicit base.
1292
To merge the latest revision from bzr.dev
1293
bzr merge ../bzr.dev
1295
To merge changes up to and including revision 82 from bzr.dev
1296
bzr merge -r 82 ../bzr.dev
1298
To merge the changes introduced by 82, without previous changes:
1299
bzr merge -r 81..82 ../bzr.dev
1301
merge refuses to run if there are any uncommitted changes, unless
1304
takes_args = ['branch?']
1305
takes_options = ['revision', 'force', 'merge-type',
1306
Option('show-base', help="Show base revision text in "
1309
def run(self, branch=None, revision=None, force=False, merge_type=None,
1311
from bzrlib.merge import merge
1312
from bzrlib.merge_core import ApplyMerge3
1313
if merge_type is None:
1314
merge_type = ApplyMerge3
1316
branch = Branch.open_containing('.')[0].get_parent()
1318
raise BzrCommandError("No merge location known or specified.")
1320
print "Using saved location: %s" % branch
1321
if revision is None or len(revision) < 1:
1323
other = [branch, -1]
1325
if len(revision) == 1:
1327
other_branch = Branch.open_containing(branch)[0]
1328
revno = revision[0].in_history(other_branch).revno
1329
other = [branch, revno]
1331
assert len(revision) == 2
1332
if None in revision:
1333
raise BzrCommandError(
1334
"Merge doesn't permit that revision specifier.")
1335
b = Branch.open_containing(branch)[0]
1337
base = [branch, revision[0].in_history(b).revno]
1338
other = [branch, revision[1].in_history(b).revno]
1341
conflict_count = merge(other, base, check_clean=(not force),
1342
merge_type=merge_type,
1343
show_base=show_base)
1344
if conflict_count != 0:
1348
except bzrlib.errors.AmbiguousBase, e:
1349
m = ("sorry, bzr can't determine the right merge base yet\n"
1350
"candidates are:\n "
1351
+ "\n ".join(e.bases)
1353
"please specify an explicit base with -r,\n"
1354
"and (if you want) report this to the bzr developers\n")
1358
class cmd_revert(Command):
1359
"""Reverse all changes since the last commit.
1361
Only versioned files are affected. Specify filenames to revert only
1362
those files. By default, any files that are changed will be backed up
1363
first. Backup files have a '~' appended to their name.
1365
takes_options = ['revision', 'no-backup']
1366
takes_args = ['file*']
1367
aliases = ['merge-revert']
1369
def run(self, revision=None, no_backup=False, file_list=None):
1370
from bzrlib.merge import merge
1371
from bzrlib.commands import parse_spec
1373
if file_list is not None:
1374
if len(file_list) == 0:
1375
raise BzrCommandError("No files specified")
1376
if revision is None:
1378
elif len(revision) != 1:
1379
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1381
b = Branch.open_containing('.')[0]
1382
revno = revision[0].in_history(b).revno
1383
merge(('.', revno), parse_spec('.'),
1386
backup_files=not no_backup,
1387
file_list=file_list)
1389
Branch.open_containing('.')[0].set_pending_merges([])
1392
class cmd_assert_fail(Command):
1393
"""Test reporting of assertion failures"""
1396
assert False, "always fails"
1399
class cmd_help(Command):
1400
"""Show help on a command or other topic.
1402
For a list of all available commands, say 'bzr help commands'."""
1403
takes_options = ['long']
1404
takes_args = ['topic?']
1408
def run(self, topic=None, long=False):
1410
if topic is None and long:
1415
class cmd_shell_complete(Command):
1416
"""Show appropriate completions for context.
1418
For a list of all available commands, say 'bzr shell-complete'."""
1419
takes_args = ['context?']
1424
def run(self, context=None):
1425
import shellcomplete
1426
shellcomplete.shellcomplete(context)
1429
class cmd_fetch(Command):
1430
"""Copy in history from another branch but don't merge it.
1432
This is an internal method used for pull and merge."""
1434
takes_args = ['from_branch', 'to_branch']
1435
def run(self, from_branch, to_branch):
1436
from bzrlib.fetch import Fetcher
1437
from bzrlib.branch import Branch
1438
from_b = Branch.open(from_branch)
1439
to_b = Branch.open(to_branch)
1444
Fetcher(to_b, from_b)
1451
class cmd_missing(Command):
1452
"""What is missing in this branch relative to other branch.
1454
# TODO: rewrite this in terms of ancestry so that it shows only
1457
takes_args = ['remote?']
1458
aliases = ['mis', 'miss']
1459
# We don't have to add quiet to the list, because
1460
# unknown options are parsed as booleans
1461
takes_options = ['verbose', 'quiet']
1464
def run(self, remote=None, verbose=False, quiet=False):
1465
from bzrlib.errors import BzrCommandError
1466
from bzrlib.missing import show_missing
1468
if verbose and quiet:
1469
raise BzrCommandError('Cannot pass both quiet and verbose')
1471
b = Branch.open_containing('.')[0]
1472
parent = b.get_parent()
1475
raise BzrCommandError("No missing location known or specified.")
1478
print "Using last location: %s" % parent
1480
elif parent is None:
1481
# We only update parent if it did not exist, missing
1482
# should not change the parent
1483
b.set_parent(remote)
1484
br_remote = Branch.open_containing(remote)[0]
1485
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1488
class cmd_plugins(Command):
1493
import bzrlib.plugin
1494
from inspect import getdoc
1495
for plugin in bzrlib.plugin.all_plugins:
1496
if hasattr(plugin, '__path__'):
1497
print plugin.__path__[0]
1498
elif hasattr(plugin, '__file__'):
1499
print plugin.__file__
1505
print '\t', d.split('\n')[0]
1508
class cmd_testament(Command):
1509
"""Show testament (signing-form) of a revision."""
1510
takes_options = ['revision', 'long']
1511
takes_args = ['branch?']
1513
def run(self, branch='.', revision=None, long=False):
1514
from bzrlib.testament import Testament
1515
b = Branch.open_containing(branch)[0]
1518
if revision is None:
1519
rev_id = b.last_revision()
1521
rev_id = revision[0].in_history(b).rev_id
1522
t = Testament.from_revision(b, rev_id)
1524
sys.stdout.writelines(t.as_text_lines())
1526
sys.stdout.write(t.as_short_text())
1531
class cmd_annotate(Command):
1532
"""Show the origin of each line in a file.
1534
This prints out the given file with an annotation on the left side
1535
indicating which revision, author and date introduced the change.
1537
If the origin is the same for a run of consecutive lines, it is
1538
shown only at the top, unless the --all option is given.
1540
# TODO: annotate directories; showing when each file was last changed
1541
# TODO: annotate a previous version of a file
1542
# TODO: if the working copy is modified, show annotations on that
1543
# with new uncommitted lines marked
1544
aliases = ['blame', 'praise']
1545
takes_args = ['filename']
1546
takes_options = [Option('all', help='show annotations on all lines'),
1547
Option('long', help='show date in annotations'),
1551
def run(self, filename, all=False, long=False):
1552
from bzrlib.annotate import annotate_file
1553
b, relpath = Branch.open_containing(filename)
1556
tree = WorkingTree(b.base, b)
1557
tree = b.revision_tree(b.last_revision())
1558
file_id = tree.inventory.path2id(relpath)
1559
file_version = tree.inventory[file_id].revision
1560
annotate_file(b, file_version, file_id, long, all, sys.stdout)
1565
class cmd_re_sign(Command):
1566
"""Create a digital signature for an existing revision."""
1567
# TODO be able to replace existing ones.
1569
hidden = True # is this right ?
1570
takes_args = ['revision_id?']
1571
takes_options = ['revision']
1573
def run(self, revision_id=None, revision=None):
1574
import bzrlib.config as config
1575
import bzrlib.gpg as gpg
1576
if revision_id is not None and revision is not None:
1577
raise BzrCommandError('You can only supply one of revision_id or --revision')
1578
if revision_id is None and revision is None:
1579
raise BzrCommandError('You must supply either --revision or a revision_id')
1580
b = Branch.open_containing('.')[0]
1581
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1582
if revision_id is not None:
1583
b.sign_revision(revision_id, gpg_strategy)
1584
elif revision is not None:
1585
if len(revision) == 1:
1586
revno, rev_id = revision[0].in_history(b)
1587
b.sign_revision(rev_id, gpg_strategy)
1588
elif len(revision) == 2:
1589
# are they both on rh- if so we can walk between them
1590
# might be nice to have a range helper for arbitrary
1591
# revision paths. hmm.
1592
from_revno, from_revid = revision[0].in_history(b)
1593
to_revno, to_revid = revision[1].in_history(b)
1594
if to_revid is None:
1595
to_revno = b.revno()
1596
if from_revno is None or to_revno is None:
1597
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1598
for revno in range(from_revno, to_revno + 1):
1599
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1601
raise BzrCommandError('Please supply either one revision, or a range.')
1604
# these get imported and then picked up by the scan for cmd_*
1605
# TODO: Some more consistent way to split command definitions across files;
1606
# we do need to load at least some information about them to know of
1608
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
added
removed
bzrlib/builtins.py
