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