19
import sys, os, time, os.path
23
22
from bzrlib.trace import mutter, note, log_error
24
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
26
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
27
from bzrlib.revision import Revision
28
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.branch import find_branch
25
from bzrlib import BZRDIR
31
def register_command(cmd):
32
"Utility function to help register a command"
35
if k.startswith("cmd_"):
36
k_unsquished = _unsquish_command_name(k)
39
if not plugin_cmds.has_key(k_unsquished):
40
plugin_cmds[k_unsquished] = cmd
42
log_error('Two plugins defined the same command: %r' % k)
43
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
32
46
def _squish_command_name(cmd):
37
51
assert cmd.startswith("cmd_")
38
52
return cmd[4:].replace('_','-')
41
"""Return canonical name and class for all registered commands."""
54
def _parse_revision_str(revstr):
55
"""This handles a revision string -> revno.
57
There are several possibilities:
60
'234:345' -> [234, 345]
64
In the future we will also support:
65
'uuid:blah-blah-blah' -> ?
66
'hash:blahblahblah' -> ?
70
if revstr.find(':') != -1:
71
revs = revstr.split(':')
73
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
78
revs[0] = int(revs[0])
83
revs[1] = int(revs[1])
90
def _get_cmd_dict(plugins_override=True):
42
92
for k, v in globals().iteritems():
43
93
if k.startswith("cmd_"):
44
yield _unsquish_command_name(k), v
46
def get_cmd_class(cmd):
94
d[_unsquish_command_name(k)] = v
95
# If we didn't load plugins, the plugin_cmds dict will be empty
99
d2 = plugin_cmds.copy()
105
def get_all_cmds(plugins_override=True):
106
"""Return canonical name and class for all registered commands."""
107
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
111
def get_cmd_class(cmd, plugins_override=True):
47
112
"""Return the canonical name and command class for a command.
49
114
cmd = str(cmd) # not unicode
51
116
# first look up this command under the specified name
117
cmds = _get_cmd_dict(plugins_override=plugins_override)
53
return cmd, globals()[_squish_command_name(cmd)]
119
return cmd, cmds[cmd]
57
123
# look for any command which claims this as an alias
58
for cmdname, cmdclass in get_all_cmds():
124
for cmdname, cmdclass in cmds.iteritems():
59
125
if cmd in cmdclass.aliases:
60
126
return cmdname, cmdclass
62
raise BzrCommandError("unknown command %r" % cmd)
128
cmdclass = ExternalCommand.find_command(cmd)
132
raise BzrCommandError("unknown command %r" % cmd)
135
class Command(object):
66
136
"""Base class for commands.
68
138
The docstring for an actual command should give a single-line
184
class ExternalCommand(Command):
185
"""Class to wrap external commands.
187
We cheat a little here, when get_cmd_class() calls us we actually give it back
188
an object we construct that has the appropriate path, help, options etc for the
191
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
192
method, which we override to call the Command.__init__ method. That then calls
193
our run method which is pretty straight forward.
195
The only wrinkle is that we have to map bzr's dictionary of options and arguments
196
back into command line options and arguments for the script.
199
def find_command(cls, cmd):
201
bzrpath = os.environ.get('BZRPATH', '')
203
for dir in bzrpath.split(os.pathsep):
204
path = os.path.join(dir, cmd)
205
if os.path.isfile(path):
206
return ExternalCommand(path)
210
find_command = classmethod(find_command)
212
def __init__(self, path):
215
pipe = os.popen('%s --bzr-usage' % path, 'r')
216
self.takes_options = pipe.readline().split()
218
for opt in self.takes_options:
219
if not opt in OPTIONS:
220
raise BzrError("Unknown option '%s' returned by external command %s"
223
# TODO: Is there any way to check takes_args is valid here?
224
self.takes_args = pipe.readline().split()
226
if pipe.close() is not None:
227
raise BzrError("Failed funning '%s --bzr-usage'" % path)
229
pipe = os.popen('%s --bzr-help' % path, 'r')
230
self.__doc__ = pipe.read()
231
if pipe.close() is not None:
232
raise BzrError("Failed funning '%s --bzr-help'" % path)
234
def __call__(self, options, arguments):
235
Command.__init__(self, options, arguments)
238
def run(self, **kargs):
245
optname = name.replace('_','-')
247
if OPTIONS.has_key(optname):
249
opts.append('--%s' % optname)
250
if value is not None and value is not True:
251
opts.append(str(value))
253
# it's an arg, or arg list
254
if type(value) is not list:
260
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
115
264
class cmd_status(Command):
116
265
"""Display status summary.
118
For each file there is a single line giving its file state and name.
119
The name is that in the current revision unless it is deleted or
120
missing, in which case the old name is shown.
267
This reports on versioned and unknown files, reporting them
268
grouped by state. Possible states are:
271
Versioned in the working copy but not in the previous revision.
274
Versioned in the previous revision but removed or deleted
278
Path of this file changed from the previous revision;
279
the text may also have changed. This includes files whose
280
parent directory was renamed.
283
Text has changed since the previous revision.
286
Nothing about this file has changed since the previous revision.
287
Only shown with --all.
290
Not versioned and not matching an ignore pattern.
292
To see ignored files use 'bzr ignored'. For details in the
293
changes to file texts, use 'bzr diff'.
295
If no arguments are specified, the status of the entire working
296
directory is shown. Otherwise, only the status of the specified
297
files or directories is reported. If a directory is given, status
298
is reported for everything inside that directory.
122
takes_options = ['all']
300
takes_args = ['file*']
301
takes_options = ['all', 'show-ids']
123
302
aliases = ['st', 'stat']
125
def run(self, all=False):
126
#import bzrlib.status
127
#bzrlib.status.tree_status(Branch('.'))
128
Branch('.').show_status(show_all=all)
304
def run(self, all=False, show_ids=False, file_list=None):
306
b = find_branch(file_list[0])
307
file_list = [b.relpath(x) for x in file_list]
308
# special case: only one path was given and it's the root
310
if file_list == ['']:
315
status.show_status(b, show_unchanged=all, show_ids=show_ids,
316
specific_files=file_list)
131
319
class cmd_cat_revision(Command):
168
357
recursively add that parent, rather than giving an error?
170
359
takes_args = ['file+']
171
takes_options = ['verbose']
360
takes_options = ['verbose', 'no-recurse']
173
def run(self, file_list, verbose=False):
174
bzrlib.add.smart_add(file_list, verbose)
177
def Relpath(Command):
362
def run(self, file_list, verbose=False, no_recurse=False):
363
from bzrlib.add import smart_add
364
smart_add(file_list, verbose, not no_recurse)
368
class cmd_mkdir(Command):
369
"""Create a new versioned directory.
371
This is equivalent to creating the directory and then adding it.
373
takes_args = ['dir+']
375
def run(self, dir_list):
382
b.add([d], verbose=True)
385
class cmd_relpath(Command):
178
386
"""Show path of a file relative to root"""
179
takes_args = ('filename')
387
takes_args = ['filename']
182
print Branch(self.args['filename']).relpath(filename)
390
def run(self, filename):
391
print find_branch(filename).relpath(filename)
186
395
class cmd_inventory(Command):
187
396
"""Show inventory of the current working copy or a revision."""
188
takes_options = ['revision']
397
takes_options = ['revision', 'show-ids']
190
def run(self, revision=None):
399
def run(self, revision=None, show_ids=False):
192
401
if revision == None:
193
402
inv = b.read_working_inventory()
195
404
inv = b.get_revision_inventory(b.lookup_revision(revision))
197
for path, entry in inv.iter_entries():
198
print '%-50s %s' % (entry.file_id, path)
406
for path, entry in inv.entries():
408
print '%-50s %s' % (path, entry.file_id)
201
413
class cmd_move(Command):
230
442
takes_args = ['from_name', 'to_name']
232
444
def run(self, from_name, to_name):
234
446
b.rename_one(b.relpath(from_name), b.relpath(to_name))
452
class cmd_pull(Command):
453
"""Pull any changes from another branch into the current one.
455
If the location is omitted, the last-used location will be used.
456
Both the revision history and the working directory will be
459
This command only works on branches that have not diverged. Branches are
460
considered diverged if both branches have had commits without first
461
pulling from the other.
463
If branches have diverged, you can use 'bzr merge' to pull the text changes
464
from one into the other.
466
takes_args = ['location?']
468
def run(self, location=None):
469
from bzrlib.merge import merge
471
from shutil import rmtree
474
br_to = find_branch('.')
477
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
479
if e.errno != errno.ENOENT:
482
if stored_loc is None:
483
raise BzrCommandError("No pull location known or specified.")
485
print "Using last location: %s" % stored_loc
486
location = stored_loc
487
cache_root = tempfile.mkdtemp()
488
from bzrlib.branch import DivergedBranches
489
br_from = find_branch(location)
490
location = pull_loc(br_from)
491
old_revno = br_to.revno()
493
from branch import find_cached_branch, DivergedBranches
494
br_from = find_cached_branch(location, cache_root)
495
location = pull_loc(br_from)
496
old_revno = br_to.revno()
498
br_to.update_revisions(br_from)
499
except DivergedBranches:
500
raise BzrCommandError("These branches have diverged."
503
merge(('.', -1), ('.', old_revno), check_clean=False)
504
if location != stored_loc:
505
br_to.controlfile("x-pull", "wb").write(location + "\n")
511
class cmd_branch(Command):
512
"""Create a new copy of a branch.
514
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
515
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
517
To retrieve the branch as of a particular revision, supply the --revision
518
parameter, as in "branch foo/bar -r 5".
520
takes_args = ['from_location', 'to_location?']
521
takes_options = ['revision']
523
def run(self, from_location, to_location=None, revision=None):
525
from bzrlib.merge import merge
526
from bzrlib.branch import DivergedBranches, NoSuchRevision, \
527
find_cached_branch, Branch
528
from shutil import rmtree
529
from meta_store import CachedStore
531
cache_root = tempfile.mkdtemp()
534
br_from = find_cached_branch(from_location, cache_root)
536
if e.errno == errno.ENOENT:
537
raise BzrCommandError('Source location "%s" does not'
538
' exist.' % to_location)
542
if to_location is None:
543
to_location = os.path.basename(from_location.rstrip("/\\"))
546
os.mkdir(to_location)
548
if e.errno == errno.EEXIST:
549
raise BzrCommandError('Target directory "%s" already'
550
' exists.' % to_location)
551
if e.errno == errno.ENOENT:
552
raise BzrCommandError('Parent of "%s" does not exist.' %
556
br_to = Branch(to_location, init=True)
559
br_to.update_revisions(br_from, stop_revision=revision)
560
except NoSuchRevision:
562
msg = "The branch %s has no revision %d." % (from_location,
564
raise BzrCommandError(msg)
565
merge((to_location, -1), (to_location, 0), this_dir=to_location,
566
check_clean=False, ignore_zero=True)
567
from_location = pull_loc(br_from)
568
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
573
def pull_loc(branch):
574
# TODO: Should perhaps just make attribute be 'base' in
575
# RemoteBranch and Branch?
576
if hasattr(branch, "baseurl"):
577
return branch.baseurl
238
583
class cmd_renames(Command):
239
584
"""Show list of renamed files.
303
652
takes_args = ['filename']
304
653
def run(self, filename):
654
b = find_branch(filename)
306
655
inv = b.inventory
307
656
fid = inv.path2id(b.relpath(filename))
309
bailout("%r is not a versioned file" % filename)
658
raise BzrError("%r is not a versioned file" % filename)
310
659
for fip in inv.get_idpath(fid):
314
663
class cmd_revision_history(Command):
315
664
"""Display list of revision ids on this branch."""
317
for patchid in Branch('.').revision_history():
667
for patchid in find_branch('.').revision_history():
321
671
class cmd_directories(Command):
322
672
"""Display list of versioned directories in this branch."""
324
for name, ie in Branch('.').read_working_inventory().directories():
674
for name, ie in find_branch('.').read_working_inventory().directories():
372
723
takes_args = ['file*']
373
takes_options = ['revision']
724
takes_options = ['revision', 'diff-options']
725
aliases = ['di', 'dif']
376
def run(self, revision=None, file_list=None):
727
def run(self, revision=None, file_list=None, diff_options=None):
377
728
from bzrlib.diff import show_diff
731
b = find_branch(file_list[0])
732
file_list = [b.relpath(f) for f in file_list]
733
if file_list == ['']:
734
# just pointing to top-of-tree
379
show_diff(Branch('.'), revision, file_list)
739
show_diff(b, revision, specific_files=file_list,
740
external_diff_options=diff_options)
382
746
class cmd_deleted(Command):
769
class cmd_modified(Command):
770
"""List files modified in working tree."""
775
inv = b.read_working_inventory()
776
sc = statcache.update_cache(b, inv)
777
basis = b.basis_tree()
778
basis_inv = basis.inventory
780
# We used to do this through iter_entries(), but that's slow
781
# when most of the files are unmodified, as is usually the
782
# case. So instead we iterate by inventory entry, and only
783
# calculate paths as necessary.
785
for file_id in basis_inv:
786
cacheentry = sc.get(file_id)
787
if not cacheentry: # deleted
789
ie = basis_inv[file_id]
790
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
791
path = inv.id2path(file_id)
796
class cmd_added(Command):
797
"""List files added in working tree."""
801
wt = b.working_tree()
802
basis_inv = b.basis_tree().inventory
805
if file_id in basis_inv:
807
path = inv.id2path(file_id)
808
if not os.access(b.abspath(path), os.F_OK):
404
814
class cmd_root(Command):
405
815
"""Show the tree root directory.
409
819
takes_args = ['filename?']
410
820
def run(self, filename=None):
411
821
"""Print the branch root."""
412
print bzrlib.branch.find_branch_root(filename)
822
b = find_branch(filename)
823
print getattr(b, 'base', None) or getattr(b, 'baseurl')
416
826
class cmd_log(Command):
417
827
"""Show log of this branch.
419
TODO: Options to show ids; to limit range; etc.
829
To request a range of logs, you can use the command -r begin:end
830
-r revision requests a specific revision, -r :end or -r begin: are
833
TODO: Make --revision support uuid: and hash: [future tag:] notation.
421
takes_options = ['timezone', 'verbose']
422
def run(self, timezone='original', verbose=False):
423
Branch('.', lock_mode='r').write_log(show_timezone=timezone, verbose=verbose)
837
takes_args = ['filename?']
838
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
840
def run(self, filename=None, timezone='original',
845
from bzrlib.branch import find_branch
846
from bzrlib.log import log_formatter, show_log
849
direction = (forward and 'forward') or 'reverse'
852
b = find_branch(filename)
853
fp = b.relpath(filename)
855
file_id = b.read_working_inventory().path2id(fp)
857
file_id = None # points to branch root
863
revision = [None, None]
864
elif isinstance(revision, int):
865
revision = [revision, revision]
870
assert len(revision) == 2
872
mutter('encoding log as %r' % bzrlib.user_encoding)
874
# use 'replace' so that we don't abort if trying to write out
875
# in e.g. the default C locale.
876
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
878
lf = log_formatter('short',
881
show_timezone=timezone)
888
start_revision=revision[0],
889
end_revision=revision[1])
893
class cmd_touching_revisions(Command):
894
"""Return revision-ids which affected a particular file.
896
A more user-friendly interface is "bzr log FILE"."""
898
takes_args = ["filename"]
899
def run(self, filename):
900
b = find_branch(filename)
901
inv = b.read_working_inventory()
902
file_id = inv.path2id(b.relpath(filename))
903
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
904
print "%6d %s" % (revno, what)
426
907
class cmd_ls(Command):
454
935
class cmd_unknowns(Command):
455
"""List unknown files"""
936
"""List unknown files."""
457
for f in Branch('.').unknowns():
938
from bzrlib.osutils import quotefn
939
for f in find_branch('.').unknowns():
462
944
class cmd_ignore(Command):
463
"""Ignore a command or pattern"""
945
"""Ignore a command or pattern.
947
To remove patterns from the ignore list, edit the .bzrignore file.
949
If the pattern contains a slash, it is compared to the whole path
950
from the branch root. Otherwise, it is comapred to only the last
951
component of the path.
953
Ignore patterns are case-insensitive on case-insensitive systems.
955
Note: wildcards must be quoted from the shell on Unix.
958
bzr ignore ./Makefile
464
961
takes_args = ['name_pattern']
466
963
def run(self, name_pattern):
469
# XXX: This will fail if it's a hardlink; should use an AtomicFile class.
470
f = open(b.abspath('.bzrignore'), 'at')
471
f.write(name_pattern + '\n')
964
from bzrlib.atomicfile import AtomicFile
968
ifn = b.abspath('.bzrignore')
970
if os.path.exists(ifn):
973
igns = f.read().decode('utf-8')
979
# TODO: If the file already uses crlf-style termination, maybe
980
# we should use that for the newly added lines?
982
if igns and igns[-1] != '\n':
984
igns += name_pattern + '\n'
987
f = AtomicFile(ifn, 'wt')
988
f.write(igns.encode('utf-8'))
474
993
inv = b.working_tree().inventory
475
994
if inv.path2id('.bzrignore'):
507
1028
except ValueError:
508
1029
raise BzrCommandError("not a valid revision-number: %r" % revno)
510
print Branch('.').lookup_revision(revno)
1031
print find_branch('.').lookup_revision(revno)
513
1034
class cmd_export(Command):
514
1035
"""Export past revision to destination directory.
516
If no revision is specified this exports the last committed revision."""
1037
If no revision is specified this exports the last committed revision.
1039
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1040
given, exports to a directory (equivalent to --format=dir)."""
1041
# TODO: list known exporters
517
1042
takes_args = ['dest']
518
takes_options = ['revision']
519
def run(self, dest, revno=None):
522
rh = b.revision_history[-1]
1043
takes_options = ['revision', 'format']
1044
def run(self, dest, revision=None, format='dir'):
1045
b = find_branch('.')
1046
if revision == None:
1047
rh = b.revision_history()[-1]
524
rh = b.lookup_revision(int(revno))
1049
rh = b.lookup_revision(int(revision))
525
1050
t = b.revision_tree(rh)
1051
t.export(dest, format)
529
1054
class cmd_cat(Command):
550
1075
class cmd_commit(Command):
551
1076
"""Commit changes into a new revision.
553
TODO: Commit only selected files.
1078
If selected files are specified, only changes to those files are
1079
committed. If a directory is specified then its contents are also
1082
A selected-file commit may fail in some cases where the committed
1083
tree would be invalid, such as trying to commit a file in a
1084
newly-added directory that is not itself committed.
555
1086
TODO: Run hooks on tree to-be-committed, and after commit.
557
1088
TODO: Strict commit that fails if there are unknown or deleted files.
559
takes_options = ['message', 'verbose']
1090
takes_args = ['selected*']
1091
takes_options = ['message', 'file', 'verbose']
560
1092
aliases = ['ci', 'checkin']
562
def run(self, message=None, verbose=False):
564
raise BzrCommandError("please specify a commit message")
565
Branch('.').commit(message, verbose=verbose)
1094
def run(self, message=None, file=None, verbose=True, selected_list=None):
1095
from bzrlib.commit import commit
1096
from bzrlib.osutils import get_text_message
1098
## Warning: shadows builtin file()
1099
if not message and not file:
1102
catcher = cStringIO.StringIO()
1103
sys.stdout = catcher
1104
cmd_status({"file_list":selected_list}, {})
1105
info = catcher.getvalue()
1107
message = get_text_message(info)
1110
raise BzrCommandError("please specify a commit message",
1111
["use either --message or --file"])
1112
elif message and file:
1113
raise BzrCommandError("please specify either --message or --file")
1117
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1119
b = find_branch('.')
1120
commit(b, message, verbose=verbose, specific_files=selected_list)
568
1123
class cmd_check(Command):
593
1166
"""Run internal test suite"""
596
failures, tests = 0, 0
598
import doctest, bzrlib.store, bzrlib.tests
599
bzrlib.trace.verbose = False
601
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
602
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
603
mf, mt = doctest.testmod(m)
606
print '%-40s %3d tests' % (m.__name__, mt),
608
print '%3d FAILED!' % mf
612
print '%-40s %3d tests' % ('total', tests),
614
print '%3d FAILED!' % failures
1169
from bzrlib.selftest import selftest
1170
return int(not selftest())
620
1173
class cmd_version(Command):
621
"""Show version of bzr"""
1174
"""Show version of bzr."""
625
1178
def show_version():
626
1179
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1180
# is bzrlib itself in a branch?
1181
bzrrev = bzrlib.get_bzr_revision()
1183
print " (bzr checkout, revision %d {%s})" % bzrrev
627
1184
print bzrlib.__copyright__
628
1185
print "http://bazaar-ng.org/"
639
1196
print "it sure does!"
1198
def parse_spec(spec):
1200
>>> parse_spec(None)
1202
>>> parse_spec("./")
1204
>>> parse_spec("../@")
1206
>>> parse_spec("../f/@35")
1212
parsed = spec.split('/@')
1213
assert len(parsed) == 2
1217
parsed[1] = int(parsed[1])
1218
assert parsed[1] >=0
1220
parsed = [spec, None]
1225
class cmd_merge(Command):
1226
"""Perform a three-way merge of trees.
1228
The SPEC parameters are working tree or revision specifiers. Working trees
1229
are specified using standard paths or urls. No component of a directory
1230
path may begin with '@'.
1232
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1234
Revisions are specified using a dirname/@revno pair, where dirname is the
1235
branch directory and revno is the revision within that branch. If no revno
1236
is specified, the latest revision is used.
1238
Revision examples: './@127', 'foo/@', '../@1'
1240
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1241
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1244
merge refuses to run if there are any uncommitted changes, unless
1247
takes_args = ['other_spec', 'base_spec?']
1248
takes_options = ['force']
1250
def run(self, other_spec, base_spec=None, force=False):
1251
from bzrlib.merge import merge
1252
merge(parse_spec(other_spec), parse_spec(base_spec),
1253
check_clean=(not force))
1257
class cmd_revert(Command):
1258
"""Restore selected files from a previous revision.
1260
takes_args = ['file+']
1261
def run(self, file_list):
1262
from bzrlib.branch import find_branch
1267
b = find_branch(file_list[0])
1269
b.revert([b.relpath(f) for f in file_list])
1272
class cmd_merge_revert(Command):
1273
"""Reverse all changes since the last commit.
1275
Only versioned files are affected.
1277
TODO: Store backups of any files that will be reverted, so
1278
that the revert can be undone.
1280
takes_options = ['revision']
1282
def run(self, revision=-1):
1283
from bzrlib.merge import merge
1284
merge(('.', revision), parse_spec('.'),
642
1289
class cmd_assert_fail(Command):
643
1290
"""Test reporting of assertion failures"""
701
1375
(['status'], {'all': True})
702
1376
>>> parse_args('commit --message=biter'.split())
703
1377
(['commit'], {'message': u'biter'})
1378
>>> parse_args('log -r 500'.split())
1379
(['log'], {'revision': 500})
1380
>>> parse_args('log -r500:600'.split())
1381
(['log'], {'revision': [500, 600]})
1382
>>> parse_args('log -vr500:600'.split())
1383
(['log'], {'verbose': True, 'revision': [500, 600]})
1384
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1385
Traceback (most recent call last):
1387
ValueError: invalid literal for int(): v500
722
1406
if optname not in OPTIONS:
723
bailout('unknown long option %r' % a)
1407
raise BzrError('unknown long option %r' % a)
725
1409
shortopt = a[1:]
726
if shortopt not in SHORT_OPTIONS:
727
bailout('unknown short option %r' % a)
728
optname = SHORT_OPTIONS[shortopt]
1410
if shortopt in SHORT_OPTIONS:
1411
# Multi-character options must have a space to delimit
1413
optname = SHORT_OPTIONS[shortopt]
1415
# Single character short options, can be chained,
1416
# and have their value appended to their name
1418
if shortopt not in SHORT_OPTIONS:
1419
# We didn't find the multi-character name, and we
1420
# didn't find the single char name
1421
raise BzrError('unknown short option %r' % a)
1422
optname = SHORT_OPTIONS[shortopt]
1425
# There are extra things on this option
1426
# see if it is the value, or if it is another
1428
optargfn = OPTIONS[optname]
1429
if optargfn is None:
1430
# This option does not take an argument, so the
1431
# next entry is another short option, pack it back
1433
argv.insert(0, '-' + a[2:])
1435
# This option takes an argument, so pack it
730
1439
if optname in opts:
731
1440
# XXX: Do we ever want to support this, e.g. for -r?
732
bailout('repeated option %r' % a)
1441
raise BzrError('repeated option %r' % a)
734
1443
optargfn = OPTIONS[optname]
736
1445
if optarg == None:
738
bailout('option %r needs an argument' % a)
1447
raise BzrError('option %r needs an argument' % a)
740
1449
optarg = argv.pop(0)
741
1450
opts[optname] = optargfn(optarg)
743
1452
if optarg != None:
744
bailout('option %r takes no argument' % optname)
1453
raise BzrError('option %r takes no argument' % optname)
745
1454
opts[optname] = True
1507
def _parse_master_args(argv):
1508
"""Parse the arguments that always go with the original command.
1509
These are things like bzr --no-plugins, etc.
1511
There are now 2 types of option flags. Ones that come *before* the command,
1512
and ones that come *after* the command.
1513
Ones coming *before* the command are applied against all possible commands.
1514
And are generally applied before plugins are loaded.
1516
The current list are:
1517
--builtin Allow plugins to load, but don't let them override builtin commands,
1518
they will still be allowed if they do not override a builtin.
1519
--no-plugins Don't load any plugins. This lets you get back to official source
1521
--profile Enable the hotspot profile before running the command.
1522
For backwards compatibility, this is also a non-master option.
1523
--version Spit out the version of bzr that is running and exit.
1524
This is also a non-master option.
1525
--help Run help and exit, also a non-master option (I think that should stay, though)
1527
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1528
Traceback (most recent call last):
1530
BzrCommandError: Invalid master option: 'test'
1531
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1534
>>> print opts['version']
1536
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1538
['command', '--more-options']
1539
>>> print opts['profile']
1541
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1544
>>> print opts['no-plugins']
1546
>>> print opts['profile']
1548
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1550
['command', '--profile']
1551
>>> print opts['profile']
1554
master_opts = {'builtin':False,
1561
# This is the point where we could hook into argv[0] to determine
1562
# what front-end is supposed to be run
1563
# For now, we are just ignoring it.
1564
cmd_name = argv.pop(0)
1566
if arg[:2] != '--': # at the first non-option, we return the rest
1568
arg = arg[2:] # Remove '--'
1569
if arg not in master_opts:
1570
# We could say that this is not an error, that we should
1571
# just let it be handled by the main section instead
1572
raise BzrCommandError('Invalid master option: %r' % arg)
1573
argv.pop(0) # We are consuming this entry
1574
master_opts[arg] = True
1575
return argv, master_opts
799
1579
def run_bzr(argv):
800
1580
"""Execute a command.
805
1585
argv = [a.decode(bzrlib.user_encoding) for a in argv]
808
args, opts = parse_args(argv[1:])
1588
# some options like --builtin and --no-plugins have special effects
1589
argv, master_opts = _parse_master_args(argv)
1590
if not master_opts['no-plugins']:
1591
from bzrlib.plugin import load_plugins
1594
args, opts = parse_args(argv)
1596
if master_opts['help']:
1597
from bzrlib.help import help
809
1604
if 'help' in opts:
1605
from bzrlib.help import help
816
1611
elif 'version' in opts:
1614
elif args and args[0] == 'builtin':
1615
include_plugins=False
819
1617
cmd = str(args.pop(0))
820
1618
except IndexError:
821
log_error('usage: bzr COMMAND')
822
log_error(' try "bzr help"')
825
canonical_cmd, cmd_class = get_cmd_class(cmd)
1624
plugins_override = not (master_opts['builtin'])
1625
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1627
profile = master_opts['profile']
1628
# For backwards compatibility, I would rather stick with --profile being a
1629
# master/global option
828
1630
if 'profile' in opts:
830
1632
del opts['profile']
834
1634
# check options are reasonable
835
1635
allowed = cmd_class.takes_options
836
1636
for oname in opts:
837
1637
if oname not in allowed:
838
raise BzrCommandError("option %r is not allowed for command %r"
1638
raise BzrCommandError("option '--%s' is not allowed for command %r"
841
1641
# mix arguments and options into one dictionary