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