« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 45
- compare with another revision
- download diff
- download tarball
- view history from revision 45
- Committer: Martin Pool
- Date: 2005-03-14 07:07:24 UTC
- Revision ID: mbp@sourcefrog.net-20050314070724-ba6c85db7d96c508
- add setup.py and install instructions
- rename main script to just bzr
- rename main script to just bzr
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files renamed:
- bzrlib/store/__init__.py => bzrlib/store.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/commands.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
#! /usr/bin/python
2
3
4
# Copyright (C) 2004, 2005 by Martin Pool
5
# Copyright (C) 2005 by Canonical Ltd
6
2
7
3
8
# This program is free software; you can redistribute it and/or modify
4
9
# it under the terms of the GNU General Public License as published by
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
16
21
17
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
20
21
# TODO: Help messages for options.
22
23
# TODO: Define arguments by objects, rather than just using names.
24
# Those objects can specify the expected type of the argument, which
25
# would help with validation and shell completion.
26
27
# TODO: "--profile=cum", to change sort order. Is there any value in leaving
28
# the profile output behind so it can be interactively examined?
29
30
import sys
31
import os
32
from warnings import warn
33
from inspect import getdoc
34
import errno
22
"""Bazaar-NG -- a free distributed version-control tool
23
24
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
25
26
Current limitation include:
27
28
* Metadata format is not stable yet -- you may need to
29
discard history in the future.
30
31
* No handling of subdirectories, symlinks or any non-text files.
32
33
* Insufficient error handling.
34
35
* Many commands unimplemented or partially implemented.
36
37
* Space-inefficient storage.
38
39
* No merge operators yet.
40
41
Interesting commands::
42
43
bzr help
44
Show summary help screen
45
bzr version
46
Show software version/licence/non-warranty.
47
bzr init
48
Start versioning the current directory
49
bzr add FILE...
50
Make files versioned.
51
bzr log
52
Show revision history.
53
bzr diff
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.
59
bzr status
60
Show summary of pending changes.
61
bzr remove FILE...
62
Make a file not versioned.
63
"""
64
65
# not currently working:
66
# bzr info
67
# Show some information about this branch.
68
69
70
71
__copyright__ = "Copyright 2005 Canonical Development Ltd."
72
__author__ = "Martin Pool <mbp@canonical.com>"
73
__docformat__ = "restructuredtext en"
74
__version__ = '0.0.0'
75
76
77
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
78
import traceback, socket, fnmatch, difflib
79
from os import path
80
from sets import Set
81
from pprint import pprint
82
from stat import *
83
from glob import glob
35
84
36
85
import bzrlib
37
import bzrlib.trace
38
from bzrlib.trace import mutter, note, log_error, warning
39
from bzrlib.errors import (BzrError,
40
BzrCheckError,
41
BzrCommandError,
42
BzrOptionError,
43
NotBranchError)
44
from bzrlib.revisionspec import RevisionSpec
45
from bzrlib import BZRDIR
46
from bzrlib.option import Option
47
48
plugin_cmds = {}
49
50
51
def register_command(cmd, decorate=False):
52
"Utility function to help register a command"
53
global plugin_cmds
54
k = cmd.__name__
55
if k.startswith("cmd_"):
56
k_unsquished = _unsquish_command_name(k)
57
else:
58
k_unsquished = k
59
if not plugin_cmds.has_key(k_unsquished):
60
plugin_cmds[k_unsquished] = cmd
61
mutter('registered plugin command %s', k_unsquished)
62
if decorate and k_unsquished in builtin_command_names():
63
return _builtin_commands()[k_unsquished]
64
elif decorate:
65
result = plugin_cmds[k_unsquished]
66
plugin_cmds[k_unsquished] = cmd
67
return result
68
else:
69
log_error('Two plugins defined the same command: %r' % k)
70
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
71
72
73
def _squish_command_name(cmd):
74
return 'cmd_' + cmd.replace('-', '_')
75
76
77
def _unsquish_command_name(cmd):
78
assert cmd.startswith("cmd_")
79
return cmd[4:].replace('_','-')
80
81
82
def _builtin_commands():
83
import bzrlib.builtins
84
r = {}
85
builtins = bzrlib.builtins.__dict__
86
for name in builtins:
87
if name.startswith("cmd_"):
88
real_name = _unsquish_command_name(name)
89
r[real_name] = builtins[name]
90
return r
91
92
93
94
def builtin_command_names():
95
"""Return list of builtin command names."""
96
return _builtin_commands().keys()
97
98
99
def plugin_command_names():
100
return plugin_cmds.keys()
101
102
103
def _get_cmd_dict(plugins_override=True):
104
"""Return name->class mapping for all commands."""
105
d = _builtin_commands()
106
if plugins_override:
107
d.update(plugin_cmds)
108
return d
109
110
111
def get_all_cmds(plugins_override=True):
112
"""Return canonical name and class for all registered commands."""
113
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
114
yield k,v
115
116
117
def get_cmd_object(cmd_name, plugins_override=True):
118
"""Return the canonical name and command class for a command.
119
120
plugins_override
121
If true, plugin commands can override builtins.
122
"""
123
from bzrlib.externalcommand import ExternalCommand
124
125
cmd_name = str(cmd_name) # not unicode
126
127
# first look up this command under the specified name
128
cmds = _get_cmd_dict(plugins_override=plugins_override)
129
try:
130
return cmds[cmd_name]()
86
from bzrlib.store import ImmutableStore
87
from bzrlib.trace import mutter, note, log_error
88
from bzrlib.errors import bailout, BzrError
89
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
90
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
91
from bzrlib.revision import Revision
92
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
93
format_date
94
95
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
96
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
97
98
## standard representation
99
NONE_STRING = '(none)'
100
EMPTY = 'empty'
101
102
103
## TODO: Perhaps a different version of inventory commands that
104
## returns iterators...
105
106
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
107
108
## TODO: Some kind of locking on branches. Perhaps there should be a
109
## parameter to the branch object saying whether we want a read or
110
## write lock; release it from destructor. Perhaps don't even need a
111
## read lock to look at immutable objects?
112
113
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
114
## to compare output?
115
116
## TODO: Some kind of global code to generate the right Branch object
117
## to work on. Almost, but not quite all, commands need one, and it
118
## can be taken either from their parameters or their working
119
## directory.
120
121
122
123
def cmd_status(all=False):
124
"""Display status summary.
125
126
For each file there is a single line giving its file state and name.
127
The name is that in the current revision unless it is deleted or
128
missing, in which case the old name is shown.
129
130
:todo: Don't show unchanged files unless ``--all`` is given?
131
"""
132
Branch('.').show_status(show_all=all)
133
134
135
136
######################################################################
137
# examining history
138
def cmd_get_revision(revision_id):
139
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
140
141
142
def cmd_get_file_text(text_id):
143
"""Get contents of a file by hash."""
144
sf = Branch('.').text_store[text_id]
145
pumpfile(sf, sys.stdout)
146
147
148
149
######################################################################
150
# commands
151
152
153
def cmd_revno():
154
"""Show number of revisions on this branch"""
155
print Branch('.').revno()
156
157
158
def cmd_add(file_list, verbose=False):
159
"""Add specified files.
160
161
Fails if the files are already added.
162
"""
163
Branch('.').add(file_list, verbose=verbose)
164
165
166
def cmd_inventory(revision=None):
167
"""Show inventory of the current working copy."""
168
## TODO: Also optionally show a previous inventory
169
## TODO: Format options
170
b = Branch('.')
171
if revision == None:
172
inv = b.read_working_inventory()
173
else:
174
inv = b.get_revision_inventory(b.lookup_revision(revision))
175
176
for path, entry in inv.iter_entries():
177
print '%-50s %s' % (entry.file_id, path)
178
179
180
181
def cmd_info():
182
b = Branch('.')
183
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
184
185
def plural(n, base='', pl=None):
186
if n == 1:
187
return base
188
elif pl is not None:
189
return pl
190
else:
191
return 's'
192
193
count_version_dirs = 0
194
195
count_status = {'A': 0, 'D': 0, 'M': 0, 'R': 0, '?': 0, 'I': 0, '.': 0}
196
for st_tup in bzrlib.diff_trees(b.basis_tree(), b.working_tree()):
197
fs = st_tup[0]
198
count_status[fs] += 1
199
if fs not in ['I', '?'] and st_tup[4] == 'directory':
200
count_version_dirs += 1
201
202
print
203
print 'in the working tree:'
204
for name, fs in (('unchanged', '.'),
205
('modified', 'M'), ('added', 'A'), ('removed', 'D'),
206
('renamed', 'R'), ('unknown', '?'), ('ignored', 'I'),
207
):
208
print ' %5d %s' % (count_status[fs], name)
209
print ' %5d versioned subdirector%s' % (count_version_dirs,
210
plural(count_version_dirs, 'y', 'ies'))
211
212
print
213
print 'branch history:'
214
history = b.revision_history()
215
revno = len(history)
216
print ' %5d revision%s' % (revno, plural(revno))
217
committers = Set()
218
for rev in history:
219
committers.add(b.get_revision(rev).committer)
220
print ' %5d committer%s' % (len(committers), plural(len(committers)))
221
if revno > 0:
222
firstrev = b.get_revision(history[0])
223
age = int((time.time() - firstrev.timestamp) / 3600 / 24)
224
print ' %5d day%s old' % (age, plural(age))
225
print ' first revision: %s' % format_date(firstrev.timestamp,
226
firstrev.timezone)
227
228
lastrev = b.get_revision(history[-1])
229
print ' latest revision: %s' % format_date(lastrev.timestamp,
230
lastrev.timezone)
231
232
233
234
235
def cmd_remove(file_list, verbose=False):
236
Branch('.').remove(file_list, verbose=verbose)
237
238
239
240
def cmd_file_id(filename):
241
i = Branch('.').read_working_inventory().path2id(filename)
242
if i is None:
243
bailout("%s is not a versioned file" % filename)
244
else:
245
print i
246
247
248
def cmd_find_filename(fileid):
249
n = find_filename(fileid)
250
if n is None:
251
bailout("%s is not a live file id" % fileid)
252
else:
253
print n
254
255
256
def cmd_revision_history():
257
for patchid in Branch('.').revision_history():
258
print patchid
259
260
261
262
def cmd_init():
263
# TODO: Check we're not already in a working directory? At the
264
# moment you'll get an ugly error.
265
266
# TODO: What if we're in a subdirectory of a branch? Would like
267
# to allow that, but then the parent may need to understand that
268
# the children have disappeared, or should they be versioned in
269
# both?
270
271
# TODO: Take an argument/option for branch name.
272
Branch('.', init=True)
273
274
275
def cmd_diff(revision=None):
276
"""Show diff from basis to working copy.
277
278
:todo: Take one or two revision arguments, look up those trees,
279
and diff them.
280
281
:todo: Allow diff across branches.
282
283
:todo: Mangle filenames in diff to be more relevant.
284
285
:todo: Shouldn't be in the cmd function.
286
"""
287
288
b = Branch('.')
289
290
if revision == None:
291
old_tree = b.basis_tree()
292
else:
293
old_tree = b.revision_tree(b.lookup_revision(revision))
294
295
new_tree = b.working_tree()
296
old_inv = old_tree.inventory
297
new_inv = new_tree.inventory
298
299
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
300
old_label = ''
301
new_label = ''
302
303
DEVNULL = '/dev/null'
304
# Windows users, don't panic about this filename -- it is a
305
# special signal to GNU patch that the file should be created or
306
# deleted respectively.
307
308
# TODO: Generation of pseudo-diffs for added/deleted files could
309
# be usefully made into a much faster special case.
310
311
# TODO: Better to return them in sorted order I think.
312
313
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
314
d = None
315
316
# Don't show this by default; maybe do it if an option is passed
317
# idlabel = ' {%s}' % fid
318
idlabel = ''
319
320
# FIXME: Something about the diff format makes patch unhappy
321
# with newly-added files.
322
323
def diffit(*a, **kw):
324
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
325
print
326
327
if file_state in ['.', '?', 'I']:
328
continue
329
elif file_state == 'A':
330
print '*** added %s %r' % (kind, new_name)
331
if kind == 'file':
332
diffit([],
333
new_tree.get_file(fid).readlines(),
334
fromfile=DEVNULL,
335
tofile=new_label + new_name + idlabel)
336
elif file_state == 'D':
337
assert isinstance(old_name, types.StringTypes)
338
print '*** deleted %s %r' % (kind, old_name)
339
if kind == 'file':
340
diffit(old_tree.get_file(fid).readlines(), [],
341
fromfile=old_label + old_name + idlabel,
342
tofile=DEVNULL)
343
elif file_state in ['M', 'R']:
344
if file_state == 'M':
345
assert kind == 'file'
346
assert old_name == new_name
347
print '*** modified %s %r' % (kind, new_name)
348
elif file_state == 'R':
349
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
350
351
if kind == 'file':
352
diffit(old_tree.get_file(fid).readlines(),
353
new_tree.get_file(fid).readlines(),
354
fromfile=old_label + old_name + idlabel,
355
tofile=new_label + new_name)
356
else:
357
bailout("can't represent state %s {%s}" % (file_state, fid))
358
359
360
361
def cmd_log(timezone='original'):
362
"""Show log of this branch.
363
364
:todo: Options for utc; to show ids; to limit range; etc.
365
"""
366
Branch('.').write_log(show_timezone=timezone)
367
368
369
def cmd_ls(revision=None, verbose=False):
370
"""List files in a tree.
371
372
:todo: Take a revision or remote path and list that tree instead.
373
"""
374
b = Branch('.')
375
if revision == None:
376
tree = b.working_tree()
377
else:
378
tree = b.revision_tree(b.lookup_revision(revision))
379
380
for fp, fc, kind, fid in tree.list_files():
381
if verbose:
382
if kind == 'directory':
383
kindch = '/'
384
elif kind == 'file':
385
kindch = ''
386
else:
387
kindch = '???'
388
389
print '%-8s %s%s' % (fc, fp, kindch)
390
else:
391
print fp
392
393
394
395
def cmd_unknowns():
396
"""List unknown files"""
397
for f in Branch('.').unknowns():
398
print quotefn(f)
399
400
401
def cmd_lookup_revision(revno):
402
try:
403
revno = int(revno)
404
except ValueError:
405
bailout("usage: lookup-revision REVNO",
406
["REVNO is a non-negative revision number for this branch"])
407
408
print Branch('.').lookup_revision(revno) or NONE_STRING
409
410
411
412
def cmd_export(revno, dest):
413
"""Export past revision to destination directory."""
414
b = Branch('.')
415
rh = b.lookup_revision(int(revno))
416
t = b.revision_tree(rh)
417
t.export(dest)
418
419
420
421
######################################################################
422
# internal/test commands
423
424
425
def cmd_uuid():
426
"""Print a newly-generated UUID."""
427
print uuid()
428
429
430
431
def cmd_local_time_offset():
432
print bzrlib.osutils.local_time_offset()
433
434
435
436
def cmd_commit(message, verbose=False):
437
Branch('.').commit(message, verbose=verbose)
438
439
440
def cmd_check():
441
"""Check consistency of the branch."""
442
check()
443
444
445
def cmd_is(pred, *rest):
446
"""Test whether PREDICATE is true."""
447
try:
448
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
131
449
except KeyError:
132
pass
133
134
# look for any command which claims this as an alias
135
for real_cmd_name, cmd_class in cmds.iteritems():
136
if cmd_name in cmd_class.aliases:
137
return cmd_class()
138
139
cmd_obj = ExternalCommand.find_command(cmd_name)
140
if cmd_obj:
141
return cmd_obj
142
143
raise BzrCommandError("unknown command %r" % cmd_name)
144
145
146
class Command(object):
147
"""Base class for commands.
148
149
Commands are the heart of the command-line bzr interface.
150
151
The command object mostly handles the mapping of command-line
152
parameters into one or more bzrlib operations, and of the results
153
into textual output.
154
155
Commands normally don't have any state. All their arguments are
156
passed in to the run method. (Subclasses may take a different
157
policy if the behaviour of the instance needs to depend on e.g. a
158
shell plugin and not just its Python class.)
159
160
The docstring for an actual command should give a single-line
161
summary, then a complete description of the command. A grammar
162
description will be inserted.
163
164
aliases
165
Other accepted names for this command.
166
167
takes_args
168
List of argument forms, marked with whether they are optional,
169
repeated, etc.
170
171
takes_options
172
List of options that may be given for this command. These can
173
be either strings, referring to globally-defined options,
174
or option objects. Retrieve through options().
175
176
hidden
177
If true, this command isn't advertised. This is typically
178
for commands intended for expert users.
179
"""
180
aliases = []
181
takes_args = []
182
takes_options = []
183
184
hidden = False
185
186
def __init__(self):
187
"""Construct an instance of this command."""
188
if self.__doc__ == Command.__doc__:
189
warn("No help message set for %r" % self)
190
191
def options(self):
192
"""Return dict of valid options for this command.
193
194
Maps from long option name to option object."""
195
r = dict()
196
r['help'] = Option.OPTIONS['help']
197
for o in self.takes_options:
198
if not isinstance(o, Option):
199
o = Option.OPTIONS[o]
200
r[o.name] = o
201
return r
202
203
def run_argv(self, argv):
204
"""Parse command line and run."""
205
args, opts = parse_args(self, argv)
206
if 'help' in opts: # e.g. bzr add --help
207
from bzrlib.help import help_on_command
208
help_on_command(self.name())
209
return 0
210
# XXX: This should be handled by the parser
211
allowed_names = self.options().keys()
212
for oname in opts:
213
if oname not in allowed_names:
214
raise BzrCommandError("option '--%s' is not allowed for command %r"
215
% (oname, self.name()))
216
# mix arguments and options into one dictionary
217
cmdargs = _match_argform(self.name(), self.takes_args, args)
218
cmdopts = {}
219
for k, v in opts.items():
220
cmdopts[k.replace('-', '_')] = v
221
222
all_cmd_args = cmdargs.copy()
223
all_cmd_args.update(cmdopts)
224
225
return self.run(**all_cmd_args)
226
227
def run(self):
228
"""Actually run the command.
229
230
This is invoked with the options and arguments bound to
231
keyword parameters.
232
233
Return 0 or None if the command was successful, or a non-zero
234
shell error code if not. It's OK for this method to allow
235
an exception to raise up.
236
"""
237
raise NotImplementedError()
238
239
240
def help(self):
241
"""Return help message for this class."""
242
if self.__doc__ is Command.__doc__:
243
return None
244
return getdoc(self)
245
246
def name(self):
247
return _unsquish_command_name(self.__class__.__name__)
248
249
250
def parse_spec(spec):
251
"""
252
>>> parse_spec(None)
253
[None, None]
254
>>> parse_spec("./")
255
['./', None]
256
>>> parse_spec("../@")
257
['..', -1]
258
>>> parse_spec("../f/@35")
259
['../f', 35]
260
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
261
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
262
"""
263
if spec is None:
264
return [None, None]
265
if '/@' in spec:
266
parsed = spec.split('/@')
267
assert len(parsed) == 2
268
if parsed[1] == "":
269
parsed[1] = -1
270
else:
271
try:
272
parsed[1] = int(parsed[1])
273
except ValueError:
274
pass # We can allow stuff like ./@revid:blahblahblah
275
else:
276
assert parsed[1] >=0
277
else:
278
parsed = [spec, None]
279
return parsed
280
281
def parse_args(command, argv):
450
bailout("unknown predicate: %s" % quotefn(pred))
451
452
try:
453
cmd_handler(*rest)
454
except BzrCheckError:
455
# by default we don't print the message so that this can
456
# be used from shell scripts without producing noise
457
sys.exit(1)
458
459
460
def cmd_username():
461
print bzrlib.osutils.username()
462
463
464
def cmd_user_email():
465
print bzrlib.osutils.user_email()
466
467
468
def cmd_gen_revision_id():
469
import time
470
print bzrlib.branch._gen_revision_id(time.time())
471
472
473
def cmd_doctest():
474
"""Run internal doctest suite"""
475
## -v, if present, is seen by doctest; the argument is just here
476
## so our parser doesn't complain
477
478
## TODO: --verbose option
479
480
import bzr, doctest, bzrlib.store
481
bzrlib.trace.verbose = False
482
doctest.testmod(bzr)
483
doctest.testmod(bzrlib.store)
484
doctest.testmod(bzrlib.inventory)
485
doctest.testmod(bzrlib.branch)
486
doctest.testmod(bzrlib.osutils)
487
doctest.testmod(bzrlib.tree)
488
489
# more strenuous tests;
490
import bzrlib.tests
491
doctest.testmod(bzrlib.tests)
492
493
494
######################################################################
495
# help
496
497
498
def cmd_help():
499
# TODO: Specific help for particular commands
500
print __doc__
501
502
503
def cmd_version():
504
print "bzr (bazaar-ng) %s" % __version__
505
print __copyright__
506
print "http://bazaar-ng.org/"
507
print
508
print \
509
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
510
you may use, modify and redistribute it under the terms of the GNU
511
General Public License version 2 or later."""
512
513
514
def cmd_rocks():
515
"""Statement of optimism."""
516
print "it sure does!"
517
518
519
520
######################################################################
521
# main routine
522
523
524
# list of all available options; the rhs can be either None for an
525
# option that takes no argument, or a constructor function that checks
526
# the type.
527
OPTIONS = {
528
'all': None,
529
'help': None,
530
'message': unicode,
531
'revision': int,
532
'show-ids': None,
533
'timezone': str,
534
'verbose': None,
535
'version': None,
536
}
537
538
SHORT_OPTIONS = {
539
'm': 'message',
540
'r': 'revision',
541
'v': 'verbose',
542
}
543
544
# List of options that apply to particular commands; commands not
545
# listed take none.
546
cmd_options = {
547
'add': ['verbose'],
548
'commit': ['message', 'verbose'],
549
'diff': ['revision'],
550
'inventory': ['revision'],
551
'log': ['show-ids', 'timezone'],
552
'ls': ['revision', 'verbose'],
553
'remove': ['verbose'],
554
'status': ['all'],
555
}
556
557
558
cmd_args = {
559
'init': [],
560
'add': ['file+'],
561
'commit': [],
562
'diff': [],
563
'file-id': ['filename'],
564
'get-file-text': ['text_id'],
565
'get-inventory': ['inventory_id'],
566
'get-revision': ['revision_id'],
567
'get-revision-inventory': ['revision_id'],
568
'log': [],
569
'lookup-revision': ['revno'],
570
'export': ['revno', 'dest'],
571
'remove': ['file+'],
572
'status': [],
573
}
574
575
576
def parse_args(argv):
282
577
"""Parse command line.
283
578
284
579
Arguments and options are parsed at this level before being passed
285
580
down to specific command handlers. This routine knows, from a
286
581
lookup table, something about the available options, what optargs
287
582
they take, and which commands will accept them.
583
584
>>> parse_args('--help'.split())
585
([], {'help': True})
586
>>> parse_args('--version'.split())
587
([], {'version': True})
588
>>> parse_args('status --all'.split())
589
(['status'], {'all': True})
590
>>> parse_args('commit --message=biter'.split())
591
(['commit'], {'message': u'biter'})
288
592
"""
289
# TODO: chop up this beast; make it a method of the Command
290
593
args = []
291
594
opts = {}
292
595
293
cmd_options = command.options()
294
argsover = False
596
# TODO: Maybe handle '--' to end options?
597
295
598
while argv:
296
599
a = argv.pop(0)
297
if argsover:
298
args.append(a)
299
continue
300
elif a == '--':
301
# We've received a standalone -- No more flags
302
argsover = True
303
continue
304
600
if a[0] == '-':
305
# option names must not be unicode
306
a = str(a)
307
601
optarg = None
308
602
if a[1] == '-':
309
603
mutter(" got option %r" % a)
311
605
optname, optarg = a[2:].split('=', 1)
312
606
else:
313
607
optname = a[2:]
314
if optname not in cmd_options:
315
raise BzrOptionError('unknown long option %r for command %s'
316
% (a, command.name()))
608
if optname not in OPTIONS:
609
bailout('unknown long option %r' % a)
317
610
else:
318
611
shortopt = a[1:]
319
if shortopt in Option.SHORT_OPTIONS:
320
# Multi-character options must have a space to delimit
321
# their value
322
# ^^^ what does this mean? mbp 20051014
323
optname = Option.SHORT_OPTIONS[shortopt].name
324
else:
325
# Single character short options, can be chained,
326
# and have their value appended to their name
327
shortopt = a[1:2]
328
if shortopt not in Option.SHORT_OPTIONS:
329
# We didn't find the multi-character name, and we
330
# didn't find the single char name
331
raise BzrError('unknown short option %r' % a)
332
optname = Option.SHORT_OPTIONS[shortopt].name
333
334
if a[2:]:
335
# There are extra things on this option
336
# see if it is the value, or if it is another
337
# short option
338
optargfn = Option.OPTIONS[optname].type
339
if optargfn is None:
340
# This option does not take an argument, so the
341
# next entry is another short option, pack it back
342
# into the list
343
argv.insert(0, '-' + a[2:])
344
else:
345
# This option takes an argument, so pack it
346
# into the array
347
optarg = a[2:]
612
if shortopt not in SHORT_OPTIONS:
613
bailout('unknown short option %r' % a)
614
optname = SHORT_OPTIONS[shortopt]
348
615
349
616
if optname in opts:
350
617
# XXX: Do we ever want to support this, e.g. for -r?
351
raise BzrError('repeated option %r' % a)
618
bailout('repeated option %r' % a)
352
619
353
option_obj = cmd_options[optname]
354
optargfn = option_obj.type
620
optargfn = OPTIONS[optname]
355
621
if optargfn:
356
622
if optarg == None:
357
623
if not argv:
358
raise BzrError('option %r needs an argument' % a)
624
bailout('option %r needs an argument' % a)
359
625
else:
360
626
optarg = argv.pop(0)
361
627
opts[optname] = optargfn(optarg)
628
mutter(" option argument %r" % opts[optname])
362
629
else:
363
630
if optarg != None:
364
raise BzrError('option %r takes no argument' % optname)
631
bailout('option %r takes no argument' % optname)
365
632
opts[optname] = True
366
633
else:
367
634
args.append(a)
635
368
636
return args, opts
369
637
370
638
371
def _match_argform(cmd, takes_args, args):
639
640
def _match_args(cmd, args):
641
"""Check non-option arguments match required pattern.
642
643
>>> _match_args('status', ['asdasdsadasd'])
644
Traceback (most recent call last):
645
...
646
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
647
>>> _match_args('add', ['asdasdsadasd'])
648
{'file_list': ['asdasdsadasd']}
649
>>> _match_args('add', 'abc def gj'.split())
650
{'file_list': ['abc', 'def', 'gj']}
651
"""
652
# match argument pattern
653
argform = cmd_args.get(cmd, [])
372
654
argdict = {}
655
# TODO: Need a way to express 'cp SRC... DEST', where it matches
656
# all but one.
373
657
374
# step through args and takes_args, allowing appropriate 0-many matches
375
for ap in takes_args:
658
for ap in argform:
376
659
argname = ap[:-1]
377
660
if ap[-1] == '?':
378
if args:
379
argdict[argname] = args.pop(0)
380
elif ap[-1] == '*': # all remaining arguments
381
if args:
382
argdict[argname + '_list'] = args[:]
383
args = []
384
else:
385
argdict[argname + '_list'] = None
661
assert 0
662
elif ap[-1] == '*':
663
assert 0
386
664
elif ap[-1] == '+':
387
665
if not args:
388
raise BzrCommandError("command %r needs one or more %s"
666
bailout("command %r needs one or more %s"
389
667
% (cmd, argname.upper()))
390
668
else:
391
669
argdict[argname + '_list'] = args[:]
392
670
args = []
393
elif ap[-1] == '$': # all but one
394
if len(args) < 2:
395
raise BzrCommandError("command %r needs one or more %s"
396
% (cmd, argname.upper()))
397
argdict[argname + '_list'] = args[:-1]
398
args[:-1] = []
399
671
else:
400
672
# just a plain arg
401
673
argname = ap
402
674
if not args:
403
raise BzrCommandError("command %r requires argument %s"
675
bailout("command %r requires argument %s"
404
676
% (cmd, argname.upper()))
405
677
else:
406
678
argdict[argname] = args.pop(0)
407
679
408
680
if args:
409
raise BzrCommandError("extra argument to command %s: %s"
410
% (cmd, args[0]))
681
bailout("extra arguments to command %s: %r"
682
% (cmd, args))
411
683
412
684
return argdict
413
685
414
686
415
687
416
def apply_profiled(the_callable, *args, **kwargs):
417
import hotshot
418
import tempfile
419
import hotshot.stats
420
pffileno, pfname = tempfile.mkstemp()
421
try:
422
prof = hotshot.Profile(pfname)
423
try:
424
ret = prof.runcall(the_callable, *args, **kwargs) or 0
425
finally:
426
prof.close()
427
stats = hotshot.stats.load(pfname)
428
stats.strip_dirs()
429
stats.sort_stats('cum') # 'time'
430
## XXX: Might like to write to stderr or the trace file instead but
431
## print_stats seems hardcoded to stdout
432
stats.print_stats(20)
433
return ret
434
finally:
435
os.close(pffileno)
436
os.remove(pfname)
437
438
439
688
def run_bzr(argv):
440
689
"""Execute a command.
441
690
442
691
This is similar to main(), but without all the trappings for
443
logging and error handling.
444
445
argv
446
The command-line arguments, without the program name from argv[0]
447
448
Returns a command status or raises an exception.
449
450
Special master options: these must come before the command because
451
they control how the command is interpreted.
452
453
--no-plugins
454
Do not load plugin modules at all
455
456
--builtin
457
Only use builtin commands. (Plugins are still allowed to change
458
other behaviour.)
459
460
--profile
461
Run under the Python profiler.
692
logging and error handling.
462
693
"""
463
argv = [a.decode(bzrlib.user_encoding) for a in argv]
464
465
opt_profile = opt_no_plugins = opt_builtin = False
466
467
# --no-plugins is handled specially at a very early stage. We need
468
# to load plugins before doing other command parsing so that they
469
# can override commands, but this needs to happen first.
470
471
for a in argv:
472
if a == '--profile':
473
opt_profile = True
474
elif a == '--no-plugins':
475
opt_no_plugins = True
476
elif a == '--builtin':
477
opt_builtin = True
478
else:
479
break
480
argv.remove(a)
481
482
if (not argv) or (argv[0] == '--help'):
483
from bzrlib.help import help
484
if len(argv) > 1:
485
help(argv[1])
486
else:
487
help()
488
return 0
489
490
if argv[0] == '--version':
491
from bzrlib.builtins import show_version
492
show_version()
493
return 0
494
495
if not opt_no_plugins:
496
from bzrlib.plugin import load_plugins
497
load_plugins()
498
499
cmd = str(argv.pop(0))
500
501
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
502
503
if opt_profile:
504
ret = apply_profiled(cmd_obj.run_argv, argv)
505
else:
506
ret = cmd_obj.run_argv(argv)
507
return ret or 0
508
509
def display_command(func):
510
def ignore_pipe(*args, **kwargs):
511
try:
512
return func(*args, **kwargs)
513
except IOError, e:
514
if e.errno != errno.EPIPE:
515
raise
516
except KeyboardInterrupt:
517
pass
518
return ignore_pipe
694
try:
695
args, opts = parse_args(argv[1:])
696
if 'help' in opts:
697
# TODO: pass down other arguments in case they asked for
698
# help on a command name?
699
cmd_help()
700
return 0
701
elif 'version' in opts:
702
cmd_version()
703
return 0
704
cmd = args.pop(0)
705
except IndexError:
706
log_error('usage: bzr COMMAND\n')
707
log_error(' try "bzr help"\n')
708
return 1
709
710
try:
711
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
712
except KeyError:
713
bailout("unknown command " + `cmd`)
714
715
# TODO: special --profile option to turn on the Python profiler
716
717
# check options are reasonable
718
allowed = cmd_options.get(cmd, [])
719
for oname in opts:
720
if oname not in allowed:
721
bailout("option %r is not allowed for command %r"
722
% (oname, cmd))
723
724
cmdargs = _match_args(cmd, args)
725
cmdargs.update(opts)
726
727
ret = cmd_handler(**cmdargs) or 0
728
729
519
730
520
731
def main(argv):
521
import bzrlib.ui
522
bzrlib.trace.log_startup(argv)
523
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
524
525
return run_bzr_catch_errors(argv[1:])
526
527
528
def run_bzr_catch_errors(argv):
732
## TODO: Handle command-line options; probably know what options are valid for
733
## each command
734
735
## TODO: If the arguments are wrong, give a usage message rather
736
## than just a backtrace.
737
529
738
try:
530
try:
531
return run_bzr(argv)
532
finally:
533
# do this here inside the exception wrappers to catch EPIPE
534
sys.stdout.flush()
535
except BzrCommandError, e:
536
# command line syntax error, etc
537
log_error(str(e))
538
return 1
739
# TODO: Lift into separate function in trace.py
740
# TODO: Also show contents of /etc/lsb-release, if it can be parsed.
741
# Perhaps that should eventually go into the platform library?
742
# TODO: If the file doesn't exist, add a note describing it.
743
t = bzrlib.trace._tracefile
744
t.write('-' * 60 + '\n')
745
t.write('bzr invoked at %s\n' % format_date(time.time()))
746
t.write(' by %s on %s\n' % (bzrlib.osutils.username(), socket.getfqdn()))
747
t.write(' arguments: %r\n' % argv)
748
749
starttime = os.times()[4]
750
751
import platform
752
t.write(' platform: %s\n' % platform.platform())
753
t.write(' python: %s\n' % platform.python_version())
754
755
ret = run_bzr(argv)
756
757
times = os.times()
758
mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum"
759
% times[:4])
760
mutter(" %.3f elapsed" % (times[4] - starttime))
761
762
return ret
539
763
except BzrError, e:
540
bzrlib.trace.log_exception()
764
log_error('bzr: error: ' + e.args[0] + '\n')
765
if len(e.args) > 1:
766
for h in e.args[1]:
767
log_error(' ' + h + '\n')
541
768
return 1
542
except AssertionError, e:
543
bzrlib.trace.log_exception('assertion failed: ' + str(e))
544
return 3
545
except KeyboardInterrupt, e:
546
bzrlib.trace.log_exception('interrupted')
547
return 2
548
769
except Exception, e:
549
import errno
550
if (isinstance(e, IOError)
551
and hasattr(e, 'errno')
552
and e.errno == errno.EPIPE):
553
bzrlib.trace.note('broken pipe')
554
return 2
555
else:
556
## import pdb
557
## pdb.pm()
558
bzrlib.trace.log_exception()
559
return 2
770
log_error('bzr: exception: %s\n' % e)
771
log_error(' see .bzr.log for details\n')
772
traceback.print_exc(None, bzrlib.trace._tracefile)
773
traceback.print_exc(None, sys.stderr)
774
return 1
775
776
# TODO: Maybe nicer handling of IOError?
777
778
560
779
561
780
if __name__ == '__main__':
562
781
sys.exit(main(sys.argv))
782
##import profile
783
##profile.run('main(sys.argv)')
784
Loggerhead is a web-based interface for Breezy
Version: 2.0.1