14
19
# along with this program; if not, write to the Free Software
15
20
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
import sys, os, time, os.path
22
"""Bazaar-NG -- a free distributed version-control tool
24
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
26
Current limitation include:
28
* Metadata format is not stable yet -- you may need to
29
discard history in the future.
31
* No handling of subdirectories, symlinks or any non-text files.
33
* Insufficient error handling.
35
* Many commands unimplemented or partially implemented.
37
* Space-inefficient storage.
39
* No merge operators yet.
41
Interesting commands::
44
Show summary help screen
46
Show software version/licence/non-warranty.
48
Start versioning the current directory
52
Show revision history.
54
Show changes from last revision to working copy.
55
bzr commit -m 'MESSAGE'
56
Store current state as new revision.
57
bzr export REVNO DESTINATION
58
Export the branch state at a previous version.
60
Show summary of pending changes.
62
Make a file not versioned.
65
# not currently working:
67
# Run internal consistency checks.
69
# Show some information about this branch.
73
__copyright__ = "Copyright 2005 Canonical Development Ltd."
74
__author__ = "Martin Pool <mbp@canonical.com>"
75
__docformat__ = "restructuredtext en"
79
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
80
import traceback, socket, fnmatch, difflib
83
from pprint import pprint
88
from bzrlib.store import ImmutableStore
22
89
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
90
from bzrlib.errors import bailout, BzrError
24
91
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
25
from bzrlib.tree import RevisionTree, EmptyTree, Tree
92
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
26
93
from bzrlib.revision import Revision
27
94
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
29
from bzrlib import merge
32
def _squish_command_name(cmd):
33
return 'cmd_' + cmd.replace('-', '_')
36
def _unsquish_command_name(cmd):
37
assert cmd.startswith("cmd_")
38
return cmd[4:].replace('_','-')
41
"""Return canonical name and class for all registered commands."""
42
for k, v in globals().iteritems():
43
if k.startswith("cmd_"):
44
yield _unsquish_command_name(k), v
46
def get_cmd_class(cmd):
47
"""Return the canonical name and command class for a command.
49
cmd = str(cmd) # not unicode
51
# first look up this command under the specified name
53
return cmd, globals()[_squish_command_name(cmd)]
57
# look for any command which claims this as an alias
58
for cmdname, cmdclass in get_all_cmds():
59
if cmd in cmdclass.aliases:
60
return cmdname, cmdclass
62
cmdclass = ExternalCommand.find_command(cmd)
66
raise BzrCommandError("unknown command %r" % cmd)
69
class Command(object):
70
"""Base class for commands.
72
The docstring for an actual command should give a single-line
73
summary, then a complete description of the command. A grammar
74
description will be inserted.
77
List of argument forms, marked with whether they are optional,
81
List of options that may be given for this command.
84
If true, this command isn't advertised.
93
def __init__(self, options, arguments):
94
"""Construct and run the command.
96
Sets self.status to the return value of run()."""
97
assert isinstance(options, dict)
98
assert isinstance(arguments, dict)
99
cmdargs = options.copy()
100
cmdargs.update(arguments)
101
assert self.__doc__ != Command.__doc__, \
102
("No help message set for %r" % self)
103
self.status = self.run(**cmdargs)
107
"""Override this in sub-classes.
109
This is invoked with the options and arguments bound to
112
Return 0 or None if the command was successful, or a shell
118
class ExternalCommand(Command):
119
"""Class to wrap external commands.
121
We cheat a little here, when get_cmd_class() calls us we actually give it back
122
an object we construct that has the appropriate path, help, options etc for the
125
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
126
method, which we override to call the Command.__init__ method. That then calls
127
our run method which is pretty straight forward.
129
The only wrinkle is that we have to map bzr's dictionary of options and arguments
130
back into command line options and arguments for the script.
133
def find_command(cls, cmd):
134
bzrpath = os.environ.get('BZRPATH', '')
136
for dir in bzrpath.split(':'):
137
path = os.path.join(dir, cmd)
138
if os.path.isfile(path):
139
return ExternalCommand(path)
143
find_command = classmethod(find_command)
145
def __init__(self, path):
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
151
pipe = os.popen('%s --bzr-usage' % path, 'r')
152
self.takes_options = pipe.readline().split()
153
self.takes_args = pipe.readline().split()
156
pipe = os.popen('%s --bzr-help' % path, 'r')
157
self.__doc__ = pipe.read()
160
def __call__(self, options, arguments):
161
Command.__init__(self, options, arguments)
164
def run(self, **kargs):
172
if OPTIONS.has_key(name):
174
opts.append('--%s' % name)
175
if value is not None and value is not True:
176
opts.append(str(value))
178
# it's an arg, or arg list
179
if type(value) is not list:
185
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
189
class cmd_status(Command):
97
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
98
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
100
## standard representation
101
NONE_STRING = '(none)'
105
## TODO: Perhaps a different version of inventory commands that
106
## returns iterators...
108
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
110
## TODO: Some kind of locking on branches. Perhaps there should be a
111
## parameter to the branch object saying whether we want a read or
112
## write lock; release it from destructor. Perhaps don't even need a
113
## read lock to look at immutable objects?
115
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
116
## to compare output?
121
######################################################################
125
def cmd_status(all=False):
190
126
"""Display status summary.
192
This reports on versioned and unknown files, reporting them
193
grouped by state. Possible states are:
196
Versioned in the working copy but not in the previous revision.
199
Versioned in the previous revision but removed or deleted
203
Path of this file changed from the previous revision;
204
the text may also have changed. This includes files whose
205
parent directory was renamed.
208
Text has changed since the previous revision.
211
Nothing about this file has changed since the previous revision.
212
Only shown with --all.
215
Not versioned and not matching an ignore pattern.
217
To see ignored files use 'bzr ignored'. For details in the
218
changes to file texts, use 'bzr diff'.
220
If no arguments are specified, the status of the entire working
221
directory is shown. Otherwise, only the status of the specified
222
files or directories is reported. If a directory is given, status
223
is reported for everything inside that directory.
225
takes_args = ['file*']
226
takes_options = ['all', 'show-ids']
227
aliases = ['st', 'stat']
229
def run(self, all=False, show_ids=False, file_list=None):
231
b = Branch(file_list[0], lock_mode='r')
232
file_list = [b.relpath(x) for x in file_list]
233
# special case: only one path was given and it's the root
235
if file_list == ['']:
238
b = Branch('.', lock_mode='r')
240
status.show_status(b, show_unchanged=all, show_ids=show_ids,
241
specific_files=file_list)
244
class cmd_cat_revision(Command):
245
"""Write out metadata for a revision."""
248
takes_args = ['revision_id']
250
def run(self, revision_id):
251
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
254
class cmd_revno(Command):
255
"""Show current revision number.
257
This is equal to the number of revisions on this branch."""
259
print Branch('.').revno()
262
class cmd_add(Command):
263
"""Add specified files or directories.
265
In non-recursive mode, all the named items are added, regardless
266
of whether they were previously ignored. A warning is given if
267
any of the named files are already versioned.
269
In recursive mode (the default), files are treated the same way
270
but the behaviour for directories is different. Directories that
271
are already versioned do not give a warning. All directories,
272
whether already versioned or not, are searched for files or
273
subdirectories that are neither versioned or ignored, and these
274
are added. This search proceeds recursively into versioned
277
Therefore simply saying 'bzr add .' will version all files that
278
are currently unknown.
280
TODO: Perhaps adding a file whose directly is not versioned should
281
recursively add that parent, rather than giving an error?
283
takes_args = ['file+']
284
takes_options = ['verbose']
286
def run(self, file_list, verbose=False):
287
bzrlib.add.smart_add(file_list, verbose)
290
class cmd_relpath(Command):
291
"""Show path of a file relative to root"""
292
takes_args = ['filename']
294
def run(self, filename):
295
print Branch(filename).relpath(filename)
299
class cmd_inventory(Command):
300
"""Show inventory of the current working copy or a revision."""
301
takes_options = ['revision']
303
def run(self, revision=None):
306
inv = b.read_working_inventory()
308
inv = b.get_revision_inventory(b.lookup_revision(revision))
310
for path, entry in inv.entries():
311
print '%-50s %s' % (entry.file_id, path)
314
class cmd_move(Command):
315
"""Move files to a different directory.
320
The destination must be a versioned directory in the same branch.
322
takes_args = ['source$', 'dest']
323
def run(self, source_list, dest):
326
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
329
class cmd_rename(Command):
330
"""Change the name of an entry.
333
bzr rename frob.c frobber.c
334
bzr rename src/frob.c lib/frob.c
336
It is an error if the destination name exists.
338
See also the 'move' command, which moves files into a different
339
directory without changing their name.
341
TODO: Some way to rename multiple files without invoking bzr for each
343
takes_args = ['from_name', 'to_name']
345
def run(self, from_name, to_name):
347
b.rename_one(b.relpath(from_name), b.relpath(to_name))
351
class cmd_renames(Command):
352
"""Show list of renamed files.
354
TODO: Option to show renames between two historical versions.
356
TODO: Only show renames under dir, rather than in the whole branch.
358
takes_args = ['dir?']
360
def run(self, dir='.'):
362
old_inv = b.basis_tree().inventory
363
new_inv = b.read_working_inventory()
365
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
367
for old_name, new_name in renames:
368
print "%s => %s" % (old_name, new_name)
371
class cmd_info(Command):
372
"""Show statistical information about a branch."""
373
takes_args = ['branch?']
375
def run(self, branch=None):
378
from branch import find_branch
379
b = find_branch(branch)
383
class cmd_remove(Command):
384
"""Make a file unversioned.
386
This makes bzr stop tracking changes to a versioned file. It does
387
not delete the working copy.
389
takes_args = ['file+']
390
takes_options = ['verbose']
392
def run(self, file_list, verbose=False):
393
b = Branch(file_list[0])
394
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
397
class cmd_file_id(Command):
398
"""Print file_id of a particular file or directory.
400
The file_id is assigned when the file is first added and remains the
401
same through all revisions where the file exists, even when it is
405
takes_args = ['filename']
406
def run(self, filename):
408
i = b.inventory.path2id(b.relpath(filename))
410
bailout("%r is not a versioned file" % filename)
415
class cmd_file_path(Command):
416
"""Print path of file_ids to a file or directory.
418
This prints one line for each directory down to the target,
419
starting at the branch root."""
421
takes_args = ['filename']
422
def run(self, filename):
425
fid = inv.path2id(b.relpath(filename))
427
bailout("%r is not a versioned file" % filename)
428
for fip in inv.get_idpath(fid):
432
class cmd_revision_history(Command):
433
"""Display list of revision ids on this branch."""
435
for patchid in Branch('.').revision_history():
439
class cmd_directories(Command):
440
"""Display list of versioned directories in this branch."""
442
for name, ie in Branch('.').read_working_inventory().directories():
449
class cmd_init(Command):
450
"""Make a directory into a versioned branch.
452
Use this to create an empty branch, or before importing an
455
Recipe for importing a tree of files:
460
bzr commit -m 'imported project'
463
Branch('.', init=True)
466
class cmd_diff(Command):
467
"""Show differences in working tree.
469
If files are listed, only the changes in those files are listed.
470
Otherwise, all changes for the tree are listed.
472
TODO: Given two revision arguments, show the difference between them.
474
TODO: Allow diff across branches.
476
TODO: Option to use external diff command; could be GNU diff, wdiff,
479
TODO: Python difflib is not exactly the same as unidiff; should
480
either fix it up or prefer to use an external diff.
482
TODO: If a directory is given, diff everything under that.
484
TODO: Selected-file diff is inefficient and doesn't show you
487
TODO: This probably handles non-Unix newlines poorly.
490
takes_args = ['file*']
491
takes_options = ['revision']
494
def run(self, revision=None, file_list=None):
495
from bzrlib.diff import show_diff
496
from bzrlib import find_branch
499
b = find_branch(file_list[0], lock_mode='r')
500
file_list = [b.relpath(f) for f in file_list]
501
if file_list == ['']:
502
# just pointing to top-of-tree
505
b = Branch('.', lock_mode='r')
507
show_diff(b, revision, specific_files=file_list)
513
class cmd_deleted(Command):
514
"""List files deleted in the working tree.
516
TODO: Show files deleted since a previous revision, or between two revisions.
518
def run(self, show_ids=False):
521
new = b.working_tree()
523
## TODO: Much more efficient way to do this: read in new
524
## directories with readdir, rather than stating each one. Same
525
## level of effort but possibly much less IO. (Or possibly not,
526
## if the directories are very large...)
528
for path, ie in old.inventory.iter_entries():
529
if not new.has_id(ie.file_id):
531
print '%-50s %s' % (path, ie.file_id)
536
class cmd_modified(Command):
537
"""List files modified in working tree."""
128
For each file there is a single line giving its file state and name.
129
The name is that in the current revision unless it is deleted or
130
missing, in which case the old name is shown.
132
:todo: Don't show unchanged files unless ``--all`` is given?
134
Branch('.').show_status(show_all=all)
138
######################################################################
140
def cmd_get_revision(revision_id):
141
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
144
def cmd_get_inventory(inventory_id):
145
"""Return inventory in XML by hash"""
146
Branch('.').get_inventory(inventory_hash).write_xml(sys.stdout)
149
def cmd_get_revision_inventory(revision_id):
150
"""Output inventory for a revision."""
152
b.get_revision_inventory(revision_id).write_xml(sys.stdout)
155
def cmd_get_file_text(text_id):
156
"""Get contents of a file by hash."""
157
sf = Branch('.').text_store[text_id]
158
pumpfile(sf, sys.stdout)
162
######################################################################
167
"""Show number of revisions on this branch"""
168
print Branch('.').revno()
171
def cmd_add(file_list, verbose=False):
172
"""Add specified files.
174
Fails if the files are already added.
176
Branch('.').add(file_list, verbose=verbose)
179
def cmd_inventory(revision=None):
180
"""Show inventory of the current working copy."""
181
## TODO: Also optionally show a previous inventory
182
## TODO: Format options
542
185
inv = b.read_working_inventory()
543
sc = statcache.update_cache(b, inv)
544
basis = b.basis_tree()
545
basis_inv = basis.inventory
547
# We used to do this through iter_entries(), but that's slow
548
# when most of the files are unmodified, as is usually the
549
# case. So instead we iterate by inventory entry, and only
550
# calculate paths as necessary.
552
for file_id in basis_inv:
553
cacheentry = sc.get(file_id)
554
if not cacheentry: # deleted
556
ie = basis_inv[file_id]
557
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
558
path = inv.id2path(file_id)
563
class cmd_added(Command):
564
"""List files added in working tree."""
568
wt = b.working_tree()
569
basis_inv = b.basis_tree().inventory
572
if file_id in basis_inv:
574
path = inv.id2path(file_id)
575
if not os.access(b.abspath(path), os.F_OK):
581
class cmd_root(Command):
582
"""Show the tree root directory.
584
The root is the nearest enclosing directory with a .bzr control
586
takes_args = ['filename?']
587
def run(self, filename=None):
588
"""Print the branch root."""
589
from branch import find_branch
590
b = find_branch(filename)
591
print getattr(b, 'base', None) or getattr(b, 'baseurl')
594
class cmd_log(Command):
187
inv = b.get_revision_inventory(b.lookup_revision(revision))
189
for path, entry in inv.iter_entries():
190
print '%-50s %s' % (entry.file_id, path)
196
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
197
print 'revision number:', b.revno()
198
print 'number of versioned files:', len(b.read_working_inventory())
201
def cmd_remove(file_list, verbose=False):
202
Branch('.').remove(file_list, verbose=verbose)
206
def cmd_file_id(filename):
207
i = Branch('.').read_working_inventory().path2id(filename)
209
bailout("%s is not a versioned file" % filename)
214
def cmd_find_filename(fileid):
215
n = find_filename(fileid)
217
bailout("%s is not a live file id" % fileid)
222
def cmd_revision_history():
223
for patchid in Branch('.').revision_history():
229
# TODO: Check we're not already in a working directory? At the
230
# moment you'll get an ugly error.
232
# TODO: What if we're in a subdirectory of a branch? Would like
233
# to allow that, but then the parent may need to understand that
234
# the children have disappeared, or should they be versioned in
237
# TODO: Take an argument/option for branch name.
238
Branch('.', init=True)
241
def cmd_diff(revision=None):
242
"""Show diff from basis to working copy.
244
:todo: Take one or two revision arguments, look up those trees,
247
:todo: Allow diff across branches.
249
:todo: Mangle filenames in diff to be more relevant.
251
:todo: Shouldn't be in the cmd function.
257
old_tree = b.basis_tree()
259
old_tree = b.revision_tree(b.lookup_revision(revision))
261
new_tree = b.working_tree()
262
old_inv = old_tree.inventory
263
new_inv = new_tree.inventory
265
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
269
DEVNULL = '/dev/null'
270
# Windows users, don't panic about this filename -- it is a
271
# special signal to GNU patch that the file should be created or
272
# deleted respectively.
274
# TODO: Generation of pseudo-diffs for added/deleted files could
275
# be usefully made into a much faster special case.
277
# TODO: Better to return them in sorted order I think.
279
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
282
# Don't show this by default; maybe do it if an option is passed
283
# idlabel = ' {%s}' % fid
286
# FIXME: Something about the diff format makes patch unhappy
287
# with newly-added files.
289
def diffit(*a, **kw):
290
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
293
if file_state in ['.', '?', 'I']:
295
elif file_state == 'A':
296
print '*** added %s %r' % (kind, new_name)
299
new_tree.get_file(fid).readlines(),
301
tofile=new_label + new_name + idlabel)
302
elif file_state == 'D':
303
assert isinstance(old_name, types.StringTypes)
304
print '*** deleted %s %r' % (kind, old_name)
306
diffit(old_tree.get_file(fid).readlines(), [],
307
fromfile=old_label + old_name + idlabel,
309
elif file_state in ['M', 'R']:
310
if file_state == 'M':
311
assert kind == 'file'
312
assert old_name == new_name
313
print '*** modified %s %r' % (kind, new_name)
314
elif file_state == 'R':
315
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
318
diffit(old_tree.get_file(fid).readlines(),
319
new_tree.get_file(fid).readlines(),
320
fromfile=old_label + old_name + idlabel,
321
tofile=new_label + new_name)
323
bailout("can't represent state %s {%s}" % (file_state, fid))
327
def cmd_log(timezone='original'):
595
328
"""Show log of this branch.
597
TODO: Option to limit range.
330
:todo: Options for utc; to show ids; to limit range; etc.
600
takes_args = ['filename?']
601
takes_options = ['forward', 'timezone', 'verbose', 'show-ids']
603
def run(self, filename=None, timezone='original',
607
from bzrlib import show_log, find_branch
609
direction = (forward and 'forward') or 'reverse'
612
b = find_branch(filename, lock_mode='r')
613
fp = b.relpath(filename)
615
file_id = b.read_working_inventory().path2id(fp)
617
file_id = None # points to branch root
619
b = find_branch('.', lock_mode='r')
623
show_timezone=timezone,
631
class cmd_touching_revisions(Command):
632
"""Return revision-ids which affected a particular file.
634
A more user-friendly interface is "bzr log FILE"."""
636
takes_args = ["filename"]
637
def run(self, filename):
638
b = Branch(filename, lock_mode='r')
639
inv = b.read_working_inventory()
640
file_id = inv.path2id(b.relpath(filename))
641
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
642
print "%6d %s" % (revno, what)
645
class cmd_ls(Command):
332
Branch('.').write_log(show_timezone=timezone)
335
def cmd_ls(revision=None, verbose=False):
646
336
"""List files in a tree.
648
TODO: Take a revision or remote path and list that tree instead.
338
:todo: Take a revision or remote path and list that tree instead.
651
def run(self, revision=None, verbose=False):
654
tree = b.working_tree()
342
tree = b.working_tree()
344
tree = b.revision_tree(b.lookup_revision(revision))
346
for fp, fc, kind, fid in tree.list_files():
348
if kind == 'directory':
355
print '%-8s %s%s' % (fc, fp, kindch)
656
tree = b.revision_tree(b.lookup_revision(revision))
658
for fp, fc, kind, fid in tree.list_files():
660
if kind == 'directory':
667
print '%-8s %s%s' % (fc, fp, kindch)
673
class cmd_unknowns(Command):
674
362
"""List unknown files"""
676
for f in Branch('.').unknowns():
681
class cmd_ignore(Command):
682
"""Ignore a command or pattern
684
To remove patterns from the ignore list, edit the .bzrignore file.
686
If the pattern contains a slash, it is compared to the whole path
687
from the branch root. Otherwise, it is comapred to only the last
688
component of the path.
690
Ignore patterns are case-insensitive on case-insensitive systems.
692
Note: wildcards must be quoted from the shell on Unix.
695
bzr ignore ./Makefile
698
takes_args = ['name_pattern']
700
def run(self, name_pattern):
701
from bzrlib.atomicfile import AtomicFile
705
ifn = b.abspath('.bzrignore')
707
if os.path.exists(ifn):
710
igns = f.read().decode('utf-8')
716
if igns and igns[-1] != '\n':
718
igns += name_pattern + '\n'
721
f = AtomicFile(ifn, 'wt')
722
f.write(igns.encode('utf-8'))
727
inv = b.working_tree().inventory
728
if inv.path2id('.bzrignore'):
729
mutter('.bzrignore is already versioned')
731
mutter('need to make new .bzrignore file versioned')
732
b.add(['.bzrignore'])
736
class cmd_ignored(Command):
737
"""List ignored files and the patterns that matched them.
739
See also: bzr ignore"""
741
tree = Branch('.').working_tree()
742
for path, file_class, kind, file_id in tree.list_files():
743
if file_class != 'I':
745
## XXX: Slightly inefficient since this was already calculated
746
pat = tree.is_ignored(path)
747
print '%-50s %s' % (path, pat)
750
class cmd_lookup_revision(Command):
751
"""Lookup the revision-id from a revision-number
754
bzr lookup-revision 33
757
takes_args = ['revno']
759
def run(self, revno):
763
raise BzrCommandError("not a valid revision-number: %r" % revno)
765
print Branch('.').lookup_revision(revno)
768
class cmd_export(Command):
769
"""Export past revision to destination directory.
771
If no revision is specified this exports the last committed revision."""
772
takes_args = ['dest']
773
takes_options = ['revision']
774
def run(self, dest, revision=None):
777
rh = b.revision_history()[-1]
779
rh = b.lookup_revision(int(revision))
780
t = b.revision_tree(rh)
784
class cmd_cat(Command):
785
"""Write a file's text from a previous revision."""
787
takes_options = ['revision']
788
takes_args = ['filename']
790
def run(self, filename, revision=None):
792
raise BzrCommandError("bzr cat requires a revision number")
794
b.print_file(b.relpath(filename), int(revision))
797
class cmd_local_time_offset(Command):
798
"""Show the offset in seconds from GMT to local time."""
801
print bzrlib.osutils.local_time_offset()
805
class cmd_commit(Command):
806
"""Commit changes into a new revision.
808
If selected files are specified, only changes to those files are
809
committed. If a directory is specified then its contents are also
812
A selected-file commit may fail in some cases where the committed
813
tree would be invalid, such as trying to commit a file in a
814
newly-added directory that is not itself committed.
816
TODO: Run hooks on tree to-be-committed, and after commit.
818
TODO: Strict commit that fails if there are unknown or deleted files.
820
takes_args = ['selected*']
821
takes_options = ['message', 'file', 'verbose']
822
aliases = ['ci', 'checkin']
824
def run(self, message=None, file=None, verbose=True, selected_list=None):
825
from bzrlib.commit import commit
827
## Warning: shadows builtin file()
828
if not message and not file:
829
raise BzrCommandError("please specify a commit message",
830
["use either --message or --file"])
831
elif message and file:
832
raise BzrCommandError("please specify either --message or --file")
363
for f in Branch('.').unknowns():
367
def cmd_lookup_revision(revno):
371
bailout("usage: lookup-revision REVNO",
372
["REVNO is a non-negative revision number for this branch"])
374
print Branch('.').lookup_revision(revno) or NONE_STRING
378
def cmd_export(revno, dest):
379
"""Export past revision to destination directory."""
381
rh = b.lookup_revision(int(revno))
382
t = b.revision_tree(rh)
387
######################################################################
388
# internal/test commands
392
"""Print a newly-generated UUID."""
397
def cmd_local_time_offset():
398
print bzrlib.osutils.local_time_offset()
402
def cmd_commit(message, verbose=False):
403
Branch('.').commit(message, verbose=verbose)
407
"""Check consistency of the branch."""
411
def cmd_is(pred, *rest):
412
"""Test whether PREDICATE is true."""
414
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
416
bailout("unknown predicate: %s" % quotefn(pred))
836
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
839
commit(b, message, verbose=verbose, specific_files=selected_list)
842
class cmd_check(Command):
843
"""Validate consistency of branch history.
845
This command checks various invariants about the branch storage to
846
detect data corruption or bzr bugs.
848
takes_args = ['dir?']
849
def run(self, dir='.'):
851
bzrlib.check.check(Branch(dir))
855
class cmd_whoami(Command):
856
"""Show bzr user id."""
857
takes_options = ['email']
420
except BzrCheckError:
421
# by default we don't print the message so that this can
422
# be used from shell scripts without producing noise
427
print bzrlib.osutils.username()
430
def cmd_user_email():
431
print bzrlib.osutils.user_email()
434
def cmd_gen_revision_id():
436
print bzrlib.branch._gen_revision_id(time.time())
440
"""Run internal doctest suite"""
441
## -v, if present, is seen by doctest; the argument is just here
442
## so our parser doesn't complain
444
## TODO: --verbose option
859
def run(self, email=False):
861
print bzrlib.osutils.user_email()
863
print bzrlib.osutils.username()
866
class cmd_selftest(Command):
867
"""Run internal test suite"""
870
failures, tests = 0, 0
872
import doctest, bzrlib.store
873
bzrlib.trace.verbose = False
875
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
876
bzrlib.tree, bzrlib.commands, bzrlib.add:
877
mf, mt = doctest.testmod(m)
880
print '%-40s %3d tests' % (m.__name__, mt),
882
print '%3d FAILED!' % mf
886
print '%-40s %3d tests' % ('total', tests),
888
print '%3d FAILED!' % failures
896
class cmd_version(Command):
897
"""Show version of bzr"""
902
print "bzr (bazaar-ng) %s" % bzrlib.__version__
903
print bzrlib.__copyright__
446
import bzr, doctest, bzrlib.store
447
bzrlib.trace.verbose = False
449
doctest.testmod(bzrlib.store)
450
doctest.testmod(bzrlib.inventory)
451
doctest.testmod(bzrlib.branch)
452
doctest.testmod(bzrlib.osutils)
453
doctest.testmod(bzrlib.tree)
455
# more strenuous tests;
457
doctest.testmod(bzrlib.tests)
460
######################################################################
465
# TODO: Specific help for particular commands
470
print "bzr (bazaar-ng) %s" % __version__
904
472
print "http://bazaar-ng.org/"
906
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
907
print "you may use, modify and redistribute it under the terms of the GNU"
908
print "General Public License version 2 or later."
911
class cmd_rocks(Command):
475
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
476
you may use, modify and redistribute it under the terms of the GNU
477
General Public License version 2 or later."""
912
481
"""Statement of optimism."""
915
print "it sure does!"
917
def parse_spec(spec):
919
parsed = spec.split('/@')
920
assert len(parsed) == 2
924
parsed[1] = int(parsed[1])
927
parsed = [spec, None]
930
class cmd_merge(Command):
931
"""Perform a three-way merge of trees."""
932
takes_args = ['other_spec', 'base_spec']
934
def run(self, other_spec, base_spec):
935
merge.merge(parse_spec(other_spec), parse_spec(base_spec))
937
class cmd_assert_fail(Command):
938
"""Test reporting of assertion failures"""
941
assert False, "always fails"
944
class cmd_help(Command):
945
"""Show help on a command or other topic.
947
For a list of all available commands, say 'bzr help commands'."""
948
takes_args = ['topic?']
951
def run(self, topic=None):
956
class cmd_update_stat_cache(Command):
957
"""Update stat-cache mapping inodes to SHA-1 hashes.
964
statcache.update_cache(b.base, b.read_working_inventory())
482
print "it sure does!"
967
486
######################################################################