« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1185.1.21
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.1.21
- Committer: Robert Collins
- Date: 2005-09-15 13:34:01 UTC
- mto: (1393.2.1) (1185.41.1 bzr.sftp) (1092.3.4) (1417.1.4) (1464.1.1) (1534.1.1 integration) (1495.1.4) (1505.1.16 bzr-bound-branch) (1508.1.15) (1526.1.3 run_tests_twice_for_i18n) (1540.1.3 bzr.dev (Main development branch)) (1685.1.1 bzr-encoding) (1553.5.1 bzr.dev (Main development branch)) (1608.2.1 bzr.mbp.escape-stores)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: robertc@robertcollins.net-20050915133401-179830dbe1ad6ad7
add a clean target
- 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
# TODO: Help messages for options.
29
30
# TODO: Define arguments by objects, rather than just using names.
31
# Those objects can specify the expected type of the argument, which
32
# would help with validation and shell completion.
33
34
35
36
import sys
37
import os
38
from warnings import warn
39
from inspect import getdoc
84
40
85
41
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
42
import bzrlib.trace
43
from bzrlib.trace import mutter, note, log_error, warning
44
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
45
from bzrlib.branch import find_branch
46
from bzrlib import BZRDIR
47
48
plugin_cmds = {}
49
50
51
def register_command(cmd):
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
else:
63
log_error('Two plugins defined the same command: %r' % k)
64
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
65
66
67
def _squish_command_name(cmd):
68
return 'cmd_' + cmd.replace('-', '_')
69
70
71
def _unsquish_command_name(cmd):
72
assert cmd.startswith("cmd_")
73
return cmd[4:].replace('_','-')
74
75
76
def _parse_revision_str(revstr):
77
"""This handles a revision string -> revno.
78
79
This always returns a list. The list will have one element for
80
81
It supports integers directly, but everything else it
82
defers for passing to Branch.get_revision_info()
83
84
>>> _parse_revision_str('234')
85
[234]
86
>>> _parse_revision_str('234..567')
87
[234, 567]
88
>>> _parse_revision_str('..')
89
[None, None]
90
>>> _parse_revision_str('..234')
91
[None, 234]
92
>>> _parse_revision_str('234..')
93
[234, None]
94
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
95
[234, 456, 789]
96
>>> _parse_revision_str('234....789') # Error?
97
[234, None, 789]
98
>>> _parse_revision_str('revid:test@other.com-234234')
99
['revid:test@other.com-234234']
100
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
101
['revid:test@other.com-234234', 'revid:test@other.com-234235']
102
>>> _parse_revision_str('revid:test@other.com-234234..23')
103
['revid:test@other.com-234234', 23]
104
>>> _parse_revision_str('date:2005-04-12')
105
['date:2005-04-12']
106
>>> _parse_revision_str('date:2005-04-12 12:24:33')
107
['date:2005-04-12 12:24:33']
108
>>> _parse_revision_str('date:2005-04-12T12:24:33')
109
['date:2005-04-12T12:24:33']
110
>>> _parse_revision_str('date:2005-04-12,12:24:33')
111
['date:2005-04-12,12:24:33']
112
>>> _parse_revision_str('-5..23')
113
[-5, 23]
114
>>> _parse_revision_str('-5')
115
[-5]
116
>>> _parse_revision_str('123a')
117
['123a']
118
>>> _parse_revision_str('abc')
119
['abc']
120
"""
121
import re
122
old_format_re = re.compile('\d*:\d*')
123
m = old_format_re.match(revstr)
124
if m:
125
warning('Colon separator for revision numbers is deprecated.'
126
' Use .. instead')
127
revs = []
128
for rev in revstr.split(':'):
129
if rev:
130
revs.append(int(rev))
131
else:
132
revs.append(None)
133
return revs
134
revs = []
135
for x in revstr.split('..'):
136
if not x:
137
revs.append(None)
138
else:
139
try:
140
revs.append(int(x))
141
except ValueError:
142
revs.append(x)
143
return revs
144
145
146
def get_merge_type(typestring):
147
"""Attempt to find the merge class/factory associated with a string."""
148
from merge import merge_types
149
try:
150
return merge_types[typestring][0]
151
except KeyError:
152
templ = '%s%%7s: %%s' % (' '*12)
153
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
154
type_list = '\n'.join(lines)
155
msg = "No known merge type %s. Supported types are:\n%s" %\
156
(typestring, type_list)
157
raise BzrCommandError(msg)
158
159
160
def _builtin_commands():
161
import bzrlib.builtins
162
r = {}
163
builtins = bzrlib.builtins.__dict__
164
for name in builtins:
165
if name.startswith("cmd_"):
166
real_name = _unsquish_command_name(name)
167
r[real_name] = builtins[name]
168
return r
169
170
171
172
def builtin_command_names():
173
"""Return list of builtin command names."""
174
return _builtin_commands().keys()
175
176
177
def plugin_command_names():
178
return plugin_cmds.keys()
179
180
181
def _get_cmd_dict(plugins_override=True):
182
"""Return name->class mapping for all commands."""
183
d = _builtin_commands()
184
if plugins_override:
185
d.update(plugin_cmds)
186
return d
187
188
189
def get_all_cmds(plugins_override=True):
190
"""Return canonical name and class for all registered commands."""
191
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
192
yield k,v
193
194
195
def get_cmd_object(cmd_name, plugins_override=True):
196
"""Return the canonical name and command class for a command.
197
198
plugins_override
199
If true, plugin commands can override builtins.
200
"""
201
from bzrlib.externalcommand import ExternalCommand
202
203
cmd_name = str(cmd_name) # not unicode
204
205
# first look up this command under the specified name
206
cmds = _get_cmd_dict(plugins_override=plugins_override)
207
try:
208
return cmds[cmd_name]()
209
except KeyError:
210
pass
211
212
# look for any command which claims this as an alias
213
for real_cmd_name, cmd_class in cmds.iteritems():
214
if cmd_name in cmd_class.aliases:
215
return cmd_class()
216
217
cmd_obj = ExternalCommand.find_command(cmd_name)
218
if cmd_obj:
219
return cmd_obj
220
221
raise BzrCommandError("unknown command %r" % cmd_name)
222
223
224
class Command(object):
225
"""Base class for commands.
226
227
Commands are the heart of the command-line bzr interface.
228
229
The command object mostly handles the mapping of command-line
230
parameters into one or more bzrlib operations, and of the results
231
into textual output.
232
233
Commands normally don't have any state. All their arguments are
234
passed in to the run method. (Subclasses may take a different
235
policy if the behaviour of the instance needs to depend on e.g. a
236
shell plugin and not just its Python class.)
237
238
The docstring for an actual command should give a single-line
239
summary, then a complete description of the command. A grammar
240
description will be inserted.
241
242
aliases
243
Other accepted names for this command.
244
245
takes_args
246
List of argument forms, marked with whether they are optional,
247
repeated, etc.
248
249
takes_options
250
List of options that may be given for this command.
251
252
hidden
253
If true, this command isn't advertised. This is typically
254
for commands intended for expert users.
255
"""
256
aliases = []
257
258
takes_args = []
259
takes_options = []
260
261
hidden = False
262
263
def __init__(self):
264
"""Construct an instance of this command."""
265
if self.__doc__ == Command.__doc__:
266
warn("No help message set for %r" % self)
267
268
269
def run_argv(self, argv):
270
"""Parse command line and run."""
271
args, opts = parse_args(argv)
272
273
if 'help' in opts: # e.g. bzr add --help
274
from bzrlib.help import help_on_command
275
help_on_command(self.name())
276
return 0
277
278
# check options are reasonable
279
allowed = self.takes_options
280
for oname in opts:
281
if oname not in allowed:
282
raise BzrCommandError("option '--%s' is not allowed for command %r"
283
% (oname, self.name()))
284
285
# mix arguments and options into one dictionary
286
cmdargs = _match_argform(self.name(), self.takes_args, args)
287
cmdopts = {}
288
for k, v in opts.items():
289
cmdopts[k.replace('-', '_')] = v
290
291
all_cmd_args = cmdargs.copy()
292
all_cmd_args.update(cmdopts)
293
294
return self.run(**all_cmd_args)
295
296
297
def run(self):
298
"""Actually run the command.
299
300
This is invoked with the options and arguments bound to
301
keyword parameters.
302
303
Return 0 or None if the command was successful, or a non-zero
304
shell error code if not. It's OK for this method to allow
305
an exception to raise up.
306
"""
307
raise NotImplementedError()
308
309
310
def help(self):
311
"""Return help message for this class."""
312
if self.__doc__ is Command.__doc__:
313
return None
314
return getdoc(self)
315
316
def name(self):
317
return _unsquish_command_name(self.__class__.__name__)
318
319
320
def parse_spec(spec):
321
"""
322
>>> parse_spec(None)
323
[None, None]
324
>>> parse_spec("./")
325
['./', None]
326
>>> parse_spec("../@")
327
['..', -1]
328
>>> parse_spec("../f/@35")
329
['../f', 35]
330
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
331
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
332
"""
333
if spec is None:
334
return [None, None]
335
if '/@' in spec:
336
parsed = spec.split('/@')
337
assert len(parsed) == 2
338
if parsed[1] == "":
339
parsed[1] = -1
340
else:
341
try:
342
parsed[1] = int(parsed[1])
343
except ValueError:
344
pass # We can allow stuff like ./@revid:blahblahblah
345
else:
346
assert parsed[1] >=0
347
else:
348
parsed = [spec, None]
349
return parsed
580
350
581
351
582
352
# list of all available options; the rhs can be either None for an
584
354
# the type.
585
355
OPTIONS = {
586
356
'all': None,
357
'diff-options': str,
587
358
'help': None,
359
'file': unicode,
360
'force': None,
361
'format': unicode,
362
'forward': None,
588
363
'message': unicode,
589
'revision': int,
364
'no-recurse': None,
365
'profile': None,
366
'revision': _parse_revision_str,
367
'short': None,
590
368
'show-ids': None,
591
369
'timezone': str,
592
370
'verbose': None,
593
371
'version': None,
372
'email': None,
373
'unchanged': None,
374
'update': None,
375
'long': None,
376
'root': str,
377
'no-backup': None,
378
'merge-type': get_merge_type,
379
'pattern': str,
594
380
}
595
381
596
382
SHORT_OPTIONS = {
383
'F': 'file',
384
'h': 'help',
597
385
'm': 'message',
598
386
'r': 'revision',
599
387
'v': 'verbose',
388
'l': 'long',
600
389
}
601
390
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
391
636
392
def parse_args(argv):
637
393
"""Parse command line.
643
399
644
400
>>> parse_args('--help'.split())
645
401
([], {'help': True})
402
>>> parse_args('help -- --invalidcmd'.split())
403
(['help', '--invalidcmd'], {})
646
404
>>> parse_args('--version'.split())
647
405
([], {'version': True})
648
406
>>> parse_args('status --all'.split())
649
407
(['status'], {'all': True})
650
408
>>> parse_args('commit --message=biter'.split())
651
409
(['commit'], {'message': u'biter'})
410
>>> parse_args('log -r 500'.split())
411
(['log'], {'revision': [500]})
412
>>> parse_args('log -r500..600'.split())
413
(['log'], {'revision': [500, 600]})
414
>>> parse_args('log -vr500..600'.split())
415
(['log'], {'verbose': True, 'revision': [500, 600]})
416
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
417
(['log'], {'revision': ['v500', 600]})
652
418
"""
653
419
args = []
654
420
opts = {}
655
421
656
# TODO: Maybe handle '--' to end options?
657
422
argsover = False
658
423
while argv:
659
424
a = argv.pop(0)
660
if a[0] == '-':
425
if not argsover and a[0] == '-':
426
# option names must not be unicode
427
a = str(a)
661
428
optarg = None
662
429
if a[1] == '-':
430
if a == '--':
431
# We've received a standalone -- No more flags
432
argsover = True
433
continue
663
434
mutter(" got option %r" % a)
664
435
if '=' in a:
665
436
optname, optarg = a[2:].split('=', 1)
666
437
else:
667
438
optname = a[2:]
668
439
if optname not in OPTIONS:
669
bailout('unknown long option %r' % a)
440
raise BzrError('unknown long option %r' % a)
670
441
else:
671
442
shortopt = a[1:]
672
if shortopt not in SHORT_OPTIONS:
673
bailout('unknown short option %r' % a)
674
optname = SHORT_OPTIONS[shortopt]
443
if shortopt in SHORT_OPTIONS:
444
# Multi-character options must have a space to delimit
445
# their value
446
optname = SHORT_OPTIONS[shortopt]
447
else:
448
# Single character short options, can be chained,
449
# and have their value appended to their name
450
shortopt = a[1:2]
451
if shortopt not in SHORT_OPTIONS:
452
# We didn't find the multi-character name, and we
453
# didn't find the single char name
454
raise BzrError('unknown short option %r' % a)
455
optname = SHORT_OPTIONS[shortopt]
456
457
if a[2:]:
458
# There are extra things on this option
459
# see if it is the value, or if it is another
460
# short option
461
optargfn = OPTIONS[optname]
462
if optargfn is None:
463
# This option does not take an argument, so the
464
# next entry is another short option, pack it back
465
# into the list
466
argv.insert(0, '-' + a[2:])
467
else:
468
# This option takes an argument, so pack it
469
# into the array
470
optarg = a[2:]
675
471
676
472
if optname in opts:
677
473
# XXX: Do we ever want to support this, e.g. for -r?
678
bailout('repeated option %r' % a)
474
raise BzrError('repeated option %r' % a)
679
475
680
476
optargfn = OPTIONS[optname]
681
477
if optargfn:
682
478
if optarg == None:
683
479
if not argv:
684
bailout('option %r needs an argument' % a)
480
raise BzrError('option %r needs an argument' % a)
685
481
else:
686
482
optarg = argv.pop(0)
687
483
opts[optname] = optargfn(optarg)
688
mutter(" option argument %r" % opts[optname])
689
484
else:
690
485
if optarg != None:
691
bailout('option %r takes no argument' % optname)
486
raise BzrError('option %r takes no argument' % optname)
692
487
opts[optname] = True
693
488
else:
694
489
args.append(a)
697
492
698
493
699
494
700
def _match_args(cmd, args):
701
"""Check non-option arguments match required pattern.
702
495
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, [])
496
def _match_argform(cmd, takes_args, args):
714
497
argdict = {}
715
# TODO: Need a way to express 'cp SRC... DEST', where it matches
716
# all but one.
717
498
718
# step through args and argform, allowing appropriate 0-many matches
719
for ap in argform:
499
# step through args and takes_args, allowing appropriate 0-many matches
500
for ap in takes_args:
720
501
argname = ap[:-1]
721
502
if ap[-1] == '?':
722
503
if args:
723
504
argdict[argname] = args.pop(0)
724
elif ap[-1] == '*':
725
assert 0
505
elif ap[-1] == '*': # all remaining arguments
506
if args:
507
argdict[argname + '_list'] = args[:]
508
args = []
509
else:
510
argdict[argname + '_list'] = None
726
511
elif ap[-1] == '+':
727
512
if not args:
728
bailout("command %r needs one or more %s"
513
raise BzrCommandError("command %r needs one or more %s"
729
514
% (cmd, argname.upper()))
730
515
else:
731
516
argdict[argname + '_list'] = args[:]
732
517
args = []
518
elif ap[-1] == '$': # all but one
519
if len(args) < 2:
520
raise BzrCommandError("command %r needs one or more %s"
521
% (cmd, argname.upper()))
522
argdict[argname + '_list'] = args[:-1]
523
args[:-1] = []
733
524
else:
734
525
# just a plain arg
735
526
argname = ap
736
527
if not args:
737
bailout("command %r requires argument %s"
528
raise BzrCommandError("command %r requires argument %s"
738
529
% (cmd, argname.upper()))
739
530
else:
740
531
argdict[argname] = args.pop(0)
741
532
742
533
if args:
743
bailout("extra arguments to command %s: %r"
744
% (cmd, args))
534
raise BzrCommandError("extra argument to command %s: %s"
535
% (cmd, args[0]))
745
536
746
537
return argdict
747
538
748
539
749
540
541
def apply_profiled(the_callable, *args, **kwargs):
542
import hotshot
543
import tempfile
544
pffileno, pfname = tempfile.mkstemp()
545
try:
546
prof = hotshot.Profile(pfname)
547
try:
548
ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
finally:
550
prof.close()
551
552
import hotshot.stats
553
stats = hotshot.stats.load(pfname)
554
#stats.strip_dirs()
555
stats.sort_stats('time')
556
## XXX: Might like to write to stderr or the trace file instead but
557
## print_stats seems hardcoded to stdout
558
stats.print_stats(20)
559
560
return ret
561
finally:
562
os.close(pffileno)
563
os.remove(pfname)
564
565
750
566
def run_bzr(argv):
751
567
"""Execute a command.
752
568
753
569
This is similar to main(), but without all the trappings for
754
logging and error handling.
570
logging and error handling.
571
572
argv
573
The command-line arguments, without the program name from argv[0]
574
575
Returns a command status or raises an exception.
576
577
Special master options: these must come before the command because
578
they control how the command is interpreted.
579
580
--no-plugins
581
Do not load plugin modules at all
582
583
--builtin
584
Only use builtin commands. (Plugins are still allowed to change
585
other behaviour.)
586
587
--profile
588
Run under the Python profiler.
755
589
"""
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
590
591
argv = [a.decode(bzrlib.user_encoding) for a in argv]
592
593
opt_profile = opt_no_plugins = opt_builtin = False
594
595
# --no-plugins is handled specially at a very early stage. We need
596
# to load plugins before doing other command parsing so that they
597
# can override commands, but this needs to happen first.
598
599
for a in argv:
600
if a == '--profile':
601
opt_profile = True
602
elif a == '--no-plugins':
603
opt_no_plugins = True
604
elif a == '--builtin':
605
opt_builtin = True
606
else:
607
break
608
argv.remove(a)
609
610
if (not argv) or (argv[0] == '--help'):
611
from bzrlib.help import help
612
if len(argv) > 1:
613
help(argv[1])
614
else:
615
help()
616
return 0
617
618
if argv[0] == '--version':
619
from bzrlib.builtins import show_version
620
show_version()
621
return 0
622
623
if not opt_no_plugins:
624
from bzrlib.plugin import load_plugins
625
load_plugins()
626
627
cmd = str(argv.pop(0))
628
629
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
630
631
if opt_profile:
632
ret = apply_profiled(cmd_obj.run_argv, argv)
633
else:
634
ret = cmd_obj.run_argv(argv)
635
return ret or 0
791
636
792
637
793
638
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
639
import bzrlib.ui
640
bzrlib.trace.log_startup(argv)
641
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
642
802
643
try:
803
ret = run_bzr(argv)
804
return ret
644
try:
645
try:
646
return run_bzr(argv[1:])
647
finally:
648
# do this here inside the exception wrappers to catch EPIPE
649
sys.stdout.flush()
650
#wrap common errors as CommandErrors.
651
except (NotBranchError,), e:
652
raise BzrCommandError(str(e))
653
except BzrCommandError, e:
654
# command line syntax error, etc
655
log_error(str(e))
656
return 1
805
657
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')
658
bzrlib.trace.log_exception()
810
659
return 1
660
except AssertionError, e:
661
bzrlib.trace.log_exception('assertion failed: ' + str(e))
662
return 3
663
except KeyboardInterrupt, e:
664
bzrlib.trace.note('interrupted')
665
return 2
811
666
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
667
import errno
668
if (isinstance(e, IOError)
669
and hasattr(e, 'errno')
670
and e.errno == errno.EPIPE):
671
bzrlib.trace.note('broken pipe')
672
return 2
673
else:
674
bzrlib.trace.log_exception()
675
return 2
820
676
821
677
822
678
if __name__ == '__main__':
823
679
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