« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1455
- compare with another revision
- download diff
- download tarball
- view history from revision 1455
- Committer: Robert Collins
- Date: 2005-10-15 11:38:29 UTC
- mfrom: (1185.16.40)
- Revision ID: robertc@lifelesslap.robertcollins.net-20051015113829-40226233fb246920
merge from martin
- 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:
- bzr.py => bzrlib/commands.py
- bzrlib/store.py => bzrlib/store/__init__.py
- 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 check
67
# Run internal consistency checks.
68
# bzr info
69
# Show some information about this branch.
70
71
72
73
__copyright__ = "Copyright 2005 Canonical Development Ltd."
74
__author__ = "Martin Pool <mbp@canonical.com>"
75
__docformat__ = "restructuredtext en"
76
__version__ = '0.0.0'
77
78
79
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
80
import traceback, socket, fnmatch, difflib
81
from os import path
82
from sets import Set
83
from pprint import pprint
84
from stat import *
85
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
86
34
87
35
import bzrlib
88
from bzrlib.store import ImmutableStore
89
from bzrlib.trace import mutter, note, log_error
90
from bzrlib.errors import bailout, BzrError
91
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
92
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
93
from bzrlib.revision import Revision
94
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
95
format_date
96
97
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
98
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
99
100
## standard representation
101
NONE_STRING = '(none)'
102
EMPTY = 'empty'
103
104
105
## TODO: Perhaps a different version of inventory commands that
106
## returns iterators...
107
108
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
109
110
## TODO: Some kind of locking on branches. Perhaps there should be a
111
## parameter to the branch object saying whether we want a read or
112
## write lock; release it from destructor. Perhaps don't even need a
113
## read lock to look at immutable objects?
114
115
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
116
## to compare output?
117
118
119
120
121
######################################################################
122
# check status
123
124
125
def cmd_status(all=False):
126
"""Display status summary.
127
128
For each file there is a single line giving its file state and name.
129
The name is that in the current revision unless it is deleted or
130
missing, in which case the old name is shown.
131
132
:todo: Don't show unchanged files unless ``--all`` is given?
133
"""
134
Branch('.').show_status(show_all=all)
135
136
137
138
######################################################################
139
# examining history
140
def cmd_get_revision(revision_id):
141
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
142
143
144
def cmd_get_inventory(inventory_id):
145
"""Return inventory in XML by hash"""
146
Branch('.').get_inventory(inventory_hash).write_xml(sys.stdout)
147
148
149
def cmd_get_revision_inventory(revision_id):
150
"""Output inventory for a revision."""
151
b = Branch('.')
152
b.get_revision_inventory(revision_id).write_xml(sys.stdout)
153
154
155
def cmd_get_file_text(text_id):
156
"""Get contents of a file by hash."""
157
sf = Branch('.').text_store[text_id]
158
pumpfile(sf, sys.stdout)
159
160
161
162
######################################################################
163
# commands
164
165
166
def cmd_revno():
167
"""Show number of revisions on this branch"""
168
print Branch('.').revno()
169
170
171
def cmd_add(file_list, verbose=False):
172
"""Add specified files.
173
174
Fails if the files are already added.
175
"""
176
Branch('.').add(file_list, verbose=verbose)
177
178
179
def cmd_inventory(revision=None):
180
"""Show inventory of the current working copy."""
181
## TODO: Also optionally show a previous inventory
182
## TODO: Format options
183
b = Branch('.')
184
if revision == None:
185
inv = b.read_working_inventory()
186
else:
187
inv = b.get_revision_inventory(b.lookup_revision(revision))
188
189
for path, entry in inv.iter_entries():
190
print '%-50s %s' % (entry.file_id, path)
191
192
193
194
def cmd_info():
195
b = Branch('.')
196
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
197
198
def plural(n, base='', pl=None):
199
if n == 1:
200
return base
201
elif pl is not None:
202
return pl
203
else:
204
return 's'
205
206
count_version_dirs = 0
207
208
count_status = {'A': 0, 'D': 0, 'M': 0, 'R': 0, '?': 0, 'I': 0, '.': 0}
209
for st_tup in bzrlib.diff_trees(b.basis_tree(), b.working_tree()):
210
fs = st_tup[0]
211
count_status[fs] += 1
212
if fs not in ['I', '?'] and st_tup[4] == 'directory':
213
count_version_dirs += 1
214
215
print
216
print 'in the working tree:'
217
for name, fs in (('unchanged', '.'),
218
('modified', 'M'), ('added', 'A'), ('removed', 'D'),
219
('renamed', 'R'), ('unknown', '?'), ('ignored', 'I'),
220
):
221
print ' %5d %s' % (count_status[fs], name)
222
print ' %5d versioned subdirector%s' % (count_version_dirs,
223
plural(count_version_dirs, 'y', 'ies'))
224
225
print
226
print 'branch history:'
227
history = b.revision_history()
228
revno = len(history)
229
print ' %5d revision%s' % (revno, plural(revno))
230
committers = Set()
231
for rev in history:
232
committers.add(b.get_revision(rev).committer)
233
print ' %5d committer%s' % (len(committers), plural(len(committers)))
234
if revno > 0:
235
firstrev = b.get_revision(history[0])
236
age = int((time.time() - firstrev.timestamp) / 3600 / 24)
237
print ' %5d day%s old' % (age, plural(age))
238
print ' first revision: %s' % format_date(firstrev.timestamp,
239
firstrev.timezone)
240
241
lastrev = b.get_revision(history[-1])
242
print ' latest revision: %s' % format_date(lastrev.timestamp,
243
lastrev.timezone)
244
245
246
247
248
def cmd_remove(file_list, verbose=False):
249
Branch('.').remove(file_list, verbose=verbose)
250
251
252
253
def cmd_file_id(filename):
254
i = Branch('.').read_working_inventory().path2id(filename)
255
if i is None:
256
bailout("%s is not a versioned file" % filename)
257
else:
258
print i
259
260
261
def cmd_find_filename(fileid):
262
n = find_filename(fileid)
263
if n is None:
264
bailout("%s is not a live file id" % fileid)
265
else:
266
print n
267
268
269
def cmd_revision_history():
270
for patchid in Branch('.').revision_history():
271
print patchid
272
273
274
275
def cmd_init():
276
# TODO: Check we're not already in a working directory? At the
277
# moment you'll get an ugly error.
278
279
# TODO: What if we're in a subdirectory of a branch? Would like
280
# to allow that, but then the parent may need to understand that
281
# the children have disappeared, or should they be versioned in
282
# both?
283
284
# TODO: Take an argument/option for branch name.
285
Branch('.', init=True)
286
287
288
def cmd_diff(revision=None):
289
"""Show diff from basis to working copy.
290
291
:todo: Take one or two revision arguments, look up those trees,
292
and diff them.
293
294
:todo: Allow diff across branches.
295
296
:todo: Mangle filenames in diff to be more relevant.
297
298
:todo: Shouldn't be in the cmd function.
299
"""
300
301
b = Branch('.')
302
303
if revision == None:
304
old_tree = b.basis_tree()
305
else:
306
old_tree = b.revision_tree(b.lookup_revision(revision))
307
308
new_tree = b.working_tree()
309
old_inv = old_tree.inventory
310
new_inv = new_tree.inventory
311
312
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
313
old_label = ''
314
new_label = ''
315
316
DEVNULL = '/dev/null'
317
# Windows users, don't panic about this filename -- it is a
318
# special signal to GNU patch that the file should be created or
319
# deleted respectively.
320
321
# TODO: Generation of pseudo-diffs for added/deleted files could
322
# be usefully made into a much faster special case.
323
324
# TODO: Better to return them in sorted order I think.
325
326
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
327
d = None
328
329
# Don't show this by default; maybe do it if an option is passed
330
# idlabel = ' {%s}' % fid
331
idlabel = ''
332
333
# FIXME: Something about the diff format makes patch unhappy
334
# with newly-added files.
335
336
def diffit(*a, **kw):
337
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
338
print
339
340
if file_state in ['.', '?', 'I']:
341
continue
342
elif file_state == 'A':
343
print '*** added %s %r' % (kind, new_name)
344
if kind == 'file':
345
diffit([],
346
new_tree.get_file(fid).readlines(),
347
fromfile=DEVNULL,
348
tofile=new_label + new_name + idlabel)
349
elif file_state == 'D':
350
assert isinstance(old_name, types.StringTypes)
351
print '*** deleted %s %r' % (kind, old_name)
352
if kind == 'file':
353
diffit(old_tree.get_file(fid).readlines(), [],
354
fromfile=old_label + old_name + idlabel,
355
tofile=DEVNULL)
356
elif file_state in ['M', 'R']:
357
if file_state == 'M':
358
assert kind == 'file'
359
assert old_name == new_name
360
print '*** modified %s %r' % (kind, new_name)
361
elif file_state == 'R':
362
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
363
364
if kind == 'file':
365
diffit(old_tree.get_file(fid).readlines(),
366
new_tree.get_file(fid).readlines(),
367
fromfile=old_label + old_name + idlabel,
368
tofile=new_label + new_name)
369
else:
370
bailout("can't represent state %s {%s}" % (file_state, fid))
371
372
373
374
def cmd_log(timezone='original'):
375
"""Show log of this branch.
376
377
:todo: Options for utc; to show ids; to limit range; etc.
378
"""
379
Branch('.').write_log(show_timezone=timezone)
380
381
382
def cmd_ls(revision=None, verbose=False):
383
"""List files in a tree.
384
385
:todo: Take a revision or remote path and list that tree instead.
386
"""
387
b = Branch('.')
388
if revision == None:
389
tree = b.working_tree()
390
else:
391
tree = b.revision_tree(b.lookup_revision(revision))
392
393
for fp, fc, kind, fid in tree.list_files():
394
if verbose:
395
if kind == 'directory':
396
kindch = '/'
397
elif kind == 'file':
398
kindch = ''
399
else:
400
kindch = '???'
401
402
print '%-8s %s%s' % (fc, fp, kindch)
403
else:
404
print fp
405
406
407
408
def cmd_unknowns():
409
"""List unknown files"""
410
for f in Branch('.').unknowns():
411
print quotefn(f)
412
413
414
def cmd_lookup_revision(revno):
415
try:
416
revno = int(revno)
417
except ValueError:
418
bailout("usage: lookup-revision REVNO",
419
["REVNO is a non-negative revision number for this branch"])
420
421
print Branch('.').lookup_revision(revno) or NONE_STRING
422
423
424
425
def cmd_export(revno, dest):
426
"""Export past revision to destination directory."""
427
b = Branch('.')
428
rh = b.lookup_revision(int(revno))
429
t = b.revision_tree(rh)
430
t.export(dest)
431
432
433
434
######################################################################
435
# internal/test commands
436
437
438
def cmd_uuid():
439
"""Print a newly-generated UUID."""
440
print uuid()
441
442
443
444
def cmd_local_time_offset():
445
print bzrlib.osutils.local_time_offset()
446
447
448
449
def cmd_commit(message, verbose=False):
450
Branch('.').commit(message, verbose=verbose)
451
452
453
def cmd_check():
454
"""Check consistency of the branch."""
455
check()
456
457
458
def cmd_is(pred, *rest):
459
"""Test whether PREDICATE is true."""
460
try:
461
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]()
462
198
except KeyError:
463
bailout("unknown predicate: %s" % quotefn(pred))
464
465
try:
466
cmd_handler(*rest)
467
except BzrCheckError:
468
# by default we don't print the message so that this can
469
# be used from shell scripts without producing noise
470
sys.exit(1)
471
472
473
def cmd_username():
474
print bzrlib.osutils.username()
475
476
477
def cmd_user_email():
478
print bzrlib.osutils.user_email()
479
480
481
def cmd_gen_revision_id():
482
import time
483
print bzrlib.branch._gen_revision_id(time.time())
484
485
486
def cmd_doctest():
487
"""Run internal doctest suite"""
488
## -v, if present, is seen by doctest; the argument is just here
489
## so our parser doesn't complain
490
491
## TODO: --verbose option
492
493
import bzr, doctest, bzrlib.store
494
bzrlib.trace.verbose = False
495
doctest.testmod(bzr)
496
doctest.testmod(bzrlib.store)
497
doctest.testmod(bzrlib.inventory)
498
doctest.testmod(bzrlib.branch)
499
doctest.testmod(bzrlib.osutils)
500
doctest.testmod(bzrlib.tree)
501
502
# more strenuous tests;
503
import bzrlib.tests
504
doctest.testmod(bzrlib.tests)
505
506
507
######################################################################
508
# help
509
510
511
def cmd_help():
512
# TODO: Specific help for particular commands
513
print __doc__
514
515
516
def cmd_version():
517
print "bzr (bazaar-ng) %s" % __version__
518
print __copyright__
519
print "http://bazaar-ng.org/"
520
print
521
print \
522
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
523
you may use, modify and redistribute it under the terms of the GNU
524
General Public License version 2 or later."""
525
526
527
def cmd_rocks():
528
"""Statement of optimism."""
529
print "it sure does!"
530
531
532
533
######################################################################
534
# 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
535
339
536
340
537
341
# list of all available options; the rhs can be either None for an
539
343
# the type.
540
344
OPTIONS = {
541
345
'all': None,
346
'basis': str,
347
'diff-options': str,
542
348
'help': None,
349
'file': unicode,
350
'force': None,
351
'format': unicode,
352
'forward': None,
353
'quiet': None,
543
354
'message': unicode,
544
'revision': int,
355
'no-recurse': None,
356
'profile': None,
357
'revision': _parse_revision_str,
358
'short': None,
545
359
'show-ids': None,
546
360
'timezone': str,
547
361
'verbose': None,
548
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,
549
371
}
550
372
551
373
SHORT_OPTIONS = {
374
'F': 'file',
375
'h': 'help',
552
376
'm': 'message',
553
377
'r': 'revision',
554
378
'v': 'verbose',
379
'l': 'long',
380
'q': 'quiet',
555
381
}
556
382
557
# List of options that apply to particular commands; commands not
558
# listed take none.
559
cmd_options = {
560
'add': ['verbose'],
561
'commit': ['message', 'verbose'],
562
'diff': ['revision'],
563
'inventory': ['revision'],
564
'log': ['show-ids', 'timezone'],
565
'ls': ['revision', 'verbose'],
566
'remove': ['verbose'],
567
'status': ['all'],
568
}
569
570
571
cmd_args = {
572
'init': [],
573
'add': ['file+'],
574
'commit': [],
575
'diff': [],
576
'file-id': ['filename'],
577
'get-file-text': ['text_id'],
578
'get-inventory': ['inventory_id'],
579
'get-revision': ['revision_id'],
580
'get-revision-inventory': ['revision_id'],
581
'log': [],
582
'lookup-revision': ['revno'],
583
'export': ['revno', 'dest'],
584
'remove': ['file+'],
585
'status': [],
586
}
587
588
383
589
384
def parse_args(argv):
590
385
"""Parse command line.
594
389
lookup table, something about the available options, what optargs
595
390
they take, and which commands will accept them.
596
391
597
>>> parse_args('bzr --help'.split())
392
>>> parse_args('--help'.split())
598
393
([], {'help': True})
599
>>> parse_args('bzr --version'.split())
394
>>> parse_args('help -- --invalidcmd'.split())
395
(['help', '--invalidcmd'], {})
396
>>> parse_args('--version'.split())
600
397
([], {'version': True})
601
>>> parse_args('bzr status --all'.split())
398
>>> parse_args('status --all'.split())
602
399
(['status'], {'all': True})
603
>>> parse_args('bzr commit --message=biter'.split())
400
>>> parse_args('commit --message=biter'.split())
604
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>]})
605
410
"""
606
411
args = []
607
412
opts = {}
608
413
609
# TODO: Maybe handle '--' to end options?
610
414
argsover = False
611
415
while argv:
612
416
a = argv.pop(0)
613
if a[0] == '-':
417
if not argsover and a[0] == '-':
418
# option names must not be unicode
419
a = str(a)
614
420
optarg = None
615
421
if a[1] == '-':
422
if a == '--':
423
# We've received a standalone -- No more flags
424
argsover = True
425
continue
616
426
mutter(" got option %r" % a)
617
427
if '=' in a:
618
428
optname, optarg = a[2:].split('=', 1)
619
429
else:
620
430
optname = a[2:]
621
431
if optname not in OPTIONS:
622
bailout('unknown long option %r' % a)
432
raise BzrError('unknown long option %r' % a)
623
433
else:
624
434
shortopt = a[1:]
625
if shortopt not in SHORT_OPTIONS:
626
bailout('unknown short option %r' % a)
627
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:]
628
463
629
464
if optname in opts:
630
465
# XXX: Do we ever want to support this, e.g. for -r?
631
bailout('repeated option %r' % a)
466
raise BzrError('repeated option %r' % a)
632
467
633
468
optargfn = OPTIONS[optname]
634
469
if optargfn:
635
470
if optarg == None:
636
471
if not argv:
637
bailout('option %r needs an argument' % a)
472
raise BzrError('option %r needs an argument' % a)
638
473
else:
639
474
optarg = argv.pop(0)
640
475
opts[optname] = optargfn(optarg)
641
mutter(" option argument %r" % opts[optname])
642
476
else:
643
477
if optarg != None:
644
bailout('option %r takes no argument' % optname)
478
raise BzrError('option %r takes no argument' % optname)
645
479
opts[optname] = True
646
480
else:
647
481
args.append(a)
650
484
651
485
652
486
653
def _match_args(cmd, args):
654
"""Check non-option arguments match required pattern.
655
487
656
>>> _match_args('status', ['asdasdsadasd'])
657
Traceback (most recent call last):
658
...
659
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
660
>>> _match_args('add', ['asdasdsadasd'])
661
{'file_list': ['asdasdsadasd']}
662
>>> _match_args('add', 'abc def gj'.split())
663
{'file_list': ['abc', 'def', 'gj']}
664
"""
665
# match argument pattern
666
argform = cmd_args.get(cmd, [])
488
def _match_argform(cmd, takes_args, args):
667
489
argdict = {}
668
# TODO: Need a way to express 'cp SRC... DEST', where it matches
669
# all but one.
670
490
671
for ap in argform:
491
# step through args and takes_args, allowing appropriate 0-many matches
492
for ap in takes_args:
672
493
argname = ap[:-1]
673
494
if ap[-1] == '?':
674
assert 0
675
elif ap[-1] == '*':
676
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
677
503
elif ap[-1] == '+':
678
504
if not args:
679
bailout("command %r needs one or more %s"
505
raise BzrCommandError("command %r needs one or more %s"
680
506
% (cmd, argname.upper()))
681
507
else:
682
508
argdict[argname + '_list'] = args[:]
683
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] = []
684
516
else:
685
517
# just a plain arg
686
518
argname = ap
687
519
if not args:
688
bailout("command %r requires argument %s"
520
raise BzrCommandError("command %r requires argument %s"
689
521
% (cmd, argname.upper()))
690
522
else:
691
523
argdict[argname] = args.pop(0)
692
524
693
525
if args:
694
bailout("extra arguments to command %s: %r"
695
% (cmd, args))
526
raise BzrCommandError("extra argument to command %s: %s"
527
% (cmd, args[0]))
696
528
697
529
return argdict
698
530
699
531
700
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
701
556
def run_bzr(argv):
702
557
"""Execute a command.
703
558
704
559
This is similar to main(), but without all the trappings for
705
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.
706
579
"""
707
try:
708
args, opts = parse_args(argv[1:])
709
if 'help' in opts:
710
# TODO: pass down other arguments in case they asked for
711
# help on a command name?
712
cmd_help()
713
return 0
714
elif 'version' in opts:
715
cmd_version()
716
return 0
717
cmd = args.pop(0)
718
except IndexError:
719
log_error('usage: bzr COMMAND\n')
720
log_error(' try "bzr help"\n')
721
return 1
722
723
try:
724
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
725
except KeyError:
726
bailout("unknown command " + `cmd`)
727
728
# TODO: special --profile option to turn on the Python profiler
729
730
# check options are reasonable
731
allowed = cmd_options.get(cmd, [])
732
for oname in opts:
733
if oname not in allowed:
734
bailout("option %r is not allowed for command %r"
735
% (oname, cmd))
736
737
cmdargs = _match_args(cmd, args)
738
cmdargs.update(opts)
739
740
ret = cmd_handler(**cmdargs) or 0
741
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
742
628
743
629
744
630
def main(argv):
745
## TODO: Handle command-line options; probably know what options are valid for
746
## each command
747
748
## TODO: If the arguments are wrong, give a usage message rather
749
## than just a backtrace.
750
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):
751
639
try:
752
t = bzrlib.trace._tracefile
753
t.write('-' * 60 + '\n')
754
t.write('bzr invoked at %s\n' % format_date(time.time()))
755
t.write(' by %s on %s\n' % (bzrlib.osutils.username(), socket.gethostname()))
756
t.write(' arguments: %r\n' % argv)
757
758
starttime = os.times()[4]
759
760
import platform
761
t.write(' platform: %s\n' % platform.platform())
762
t.write(' python: %s\n' % platform.python_version())
763
764
ret = run_bzr(argv)
765
766
times = os.times()
767
mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum"
768
% times[:4])
769
mutter(" %.3f elapsed" % (times[4] - starttime))
770
771
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
772
649
except BzrError, e:
773
log_error('bzr: error: ' + e.args[0] + '\n')
774
if len(e.args) > 1:
775
for h in e.args[1]:
776
log_error(' ' + h + '\n')
650
bzrlib.trace.log_exception()
777
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
778
658
except Exception, e:
779
log_error('bzr: exception: %s\n' % e)
780
log_error(' see .bzr.log for details\n')
781
traceback.print_exc(None, bzrlib.trace._tracefile)
782
traceback.print_exc(None, sys.stderr)
783
return 1
784
785
# TODO: Maybe nicer handling of IOError?
786
787
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
788
670
789
671
if __name__ == '__main__':
790
672
sys.exit(main(sys.argv))
791
##import profile
792
##profile.run('main(sys.argv)')
793
Loggerhead is a web-based interface for Breezy
Version: 2.0.1