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