« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 195
- compare with another revision
- download diff
- download tarball
- view history from revision 195
- Committer: mbp at sourcefrog
- Date: 2005-04-08 05:39:46 UTC
- Revision ID: mbp@sourcefrog.net-20050408053946-1cb3415e1f8f58493034a5cf
- import lovely urlgrabber library
- files added:
- bzrlib/tests.py
- files removed:
- TODO
- contrib
- contrib/bash
- contrib/zsh
- patches
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
# Copyright (C) 2004, 2005 by Martin Pool
2
# Copyright (C) 2005 by Canonical Ltd
3
2
4
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
14
16
# along with this program; if not, write to the Free Software
15
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
18
17
18
19
import sys, os
19
"""Bazaar-NG -- a free distributed version-control tool
20
21
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
22
23
Current limitation include:
24
25
* Metadata format is not stable yet -- you may need to
26
discard history in the future.
27
28
* Insufficient error handling.
29
30
* Many commands unimplemented or partially implemented.
31
32
* Space-inefficient storage.
33
34
* No merge operators yet.
35
36
Interesting commands::
37
38
bzr help [COMMAND]
39
Show help screen
40
bzr version
41
Show software version/licence/non-warranty.
42
bzr init
43
Start versioning the current directory
44
bzr add FILE...
45
Make files versioned.
46
bzr log
47
Show revision history.
48
bzr diff
49
Show changes from last revision to working copy.
50
bzr commit -m 'MESSAGE'
51
Store current state as new revision.
52
bzr export REVNO DESTINATION
53
Export the branch state at a previous version.
54
bzr status
55
Show summary of pending changes.
56
bzr remove FILE...
57
Make a file not versioned.
58
bzr info
59
Show statistics about this branch.
60
"""
61
62
63
64
65
import sys, os, time, types, shutil, tempfile, traceback, fnmatch, difflib, os.path
66
from sets import Set
67
from pprint import pprint
68
from stat import *
69
from glob import glob
20
70
21
71
import bzrlib
72
from bzrlib.store import ImmutableStore
22
73
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
74
from bzrlib.errors import bailout, BzrError, BzrCheckError
75
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
76
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
77
from bzrlib.revision import Revision
78
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
26
79
format_date
27
80
28
29
def _squish_command_name(cmd):
30
return 'cmd_' + cmd.replace('-', '_')
31
32
33
def _unsquish_command_name(cmd):
34
assert cmd.startswith("cmd_")
35
return cmd[4:].replace('_','-')
36
37
def _parse_revision_str(revstr):
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
52
"""
53
if revstr.find(':') != -1:
54
revs = revstr.split(':')
55
if len(revs) > 2:
56
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
57
58
if not revs[0]:
59
revs[0] = None
60
else:
61
revs[0] = int(revs[0])
62
63
if not revs[1]:
64
revs[1] = None
65
else:
66
revs[1] = int(revs[1])
67
else:
68
revs = int(revstr)
69
return revs
70
71
def get_all_cmds():
72
"""Return canonical name and class for all registered commands."""
73
for k, v in globals().iteritems():
74
if k.startswith("cmd_"):
75
yield _unsquish_command_name(k), v
76
77
def get_cmd_class(cmd):
78
"""Return the canonical name and command class for a command.
79
"""
80
cmd = str(cmd) # not unicode
81
82
# first look up this command under the specified name
83
try:
84
return cmd, globals()[_squish_command_name(cmd)]
85
except KeyError:
86
pass
87
88
# look for any command which claims this as an alias
89
for cmdname, cmdclass in get_all_cmds():
90
if cmd in cmdclass.aliases:
91
return cmdname, cmdclass
92
93
cmdclass = ExternalCommand.find_command(cmd)
94
if cmdclass:
95
return cmd, cmdclass
96
97
raise BzrCommandError("unknown command %r" % cmd)
98
99
100
class Command(object):
101
"""Base class for commands.
102
103
The docstring for an actual command should give a single-line
104
summary, then a complete description of the command. A grammar
105
description will be inserted.
106
107
takes_args
108
List of argument forms, marked with whether they are optional,
109
repeated, etc.
110
111
takes_options
112
List of options that may be given for this command.
113
114
hidden
115
If true, this command isn't advertised.
116
"""
117
aliases = []
118
119
takes_args = []
120
takes_options = []
121
122
hidden = False
123
124
def __init__(self, options, arguments):
125
"""Construct and run the command.
126
127
Sets self.status to the return value of run()."""
128
assert isinstance(options, dict)
129
assert isinstance(arguments, dict)
130
cmdargs = options.copy()
131
cmdargs.update(arguments)
132
assert self.__doc__ != Command.__doc__, \
133
("No help message set for %r" % self)
134
self.status = self.run(**cmdargs)
135
136
137
def run(self):
138
"""Override this in sub-classes.
139
140
This is invoked with the options and arguments bound to
141
keyword parameters.
142
143
Return 0 or None if the command was successful, or a shell
144
error code if not.
145
"""
146
return 0
147
148
149
class ExternalCommand(Command):
150
"""Class to wrap external commands.
151
152
We cheat a little here, when get_cmd_class() calls us we actually give it back
153
an object we construct that has the appropriate path, help, options etc for the
154
specified command.
155
156
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
157
method, which we override to call the Command.__init__ method. That then calls
158
our run method which is pretty straight forward.
159
160
The only wrinkle is that we have to map bzr's dictionary of options and arguments
161
back into command line options and arguments for the script.
162
"""
163
164
def find_command(cls, cmd):
165
import os.path
166
bzrpath = os.environ.get('BZRPATH', '')
167
168
for dir in bzrpath.split(':'):
169
path = os.path.join(dir, cmd)
170
if os.path.isfile(path):
171
return ExternalCommand(path)
172
173
return None
174
175
find_command = classmethod(find_command)
176
177
def __init__(self, path):
178
self.path = path
179
180
# TODO: If either of these fail, we should detect that and
181
# assume that path is not really a bzr plugin after all.
182
183
pipe = os.popen('%s --bzr-usage' % path, 'r')
184
self.takes_options = pipe.readline().split()
185
self.takes_args = pipe.readline().split()
186
pipe.close()
187
188
pipe = os.popen('%s --bzr-help' % path, 'r')
189
self.__doc__ = pipe.read()
190
pipe.close()
191
192
def __call__(self, options, arguments):
193
Command.__init__(self, options, arguments)
194
return self
195
196
def run(self, **kargs):
197
opts = []
198
args = []
199
200
keys = kargs.keys()
201
keys.sort()
202
for name in keys:
203
value = kargs[name]
204
if OPTIONS.has_key(name):
205
# it's an option
206
opts.append('--%s' % name)
207
if value is not None and value is not True:
208
opts.append(str(value))
209
else:
210
# it's an arg, or arg list
211
if type(value) is not list:
212
value = [value]
213
for v in value:
214
if v is not None:
215
args.append(str(v))
216
217
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
218
return self.status
219
220
221
class cmd_status(Command):
81
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
82
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
83
84
## standard representation
85
NONE_STRING = '(none)'
86
EMPTY = 'empty'
87
88
89
## TODO: Perhaps a different version of inventory commands that
90
## returns iterators...
91
92
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
93
94
## TODO: Some kind of locking on branches. Perhaps there should be a
95
## parameter to the branch object saying whether we want a read or
96
## write lock; release it from destructor. Perhaps don't even need a
97
## read lock to look at immutable objects?
98
99
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
100
## to compare output?
101
102
## TODO: Some kind of global code to generate the right Branch object
103
## to work on. Almost, but not quite all, commands need one, and it
104
## can be taken either from their parameters or their working
105
## directory.
106
107
## TODO: rename command, needed soon: check destination doesn't exist
108
## either in working copy or tree; move working copy; update
109
## inventory; write out
110
111
## TODO: move command; check destination is a directory and will not
112
## clash; move it.
113
114
## TODO: command to show renames, one per line, as to->from
115
116
117
118
119
def cmd_status(all=False):
222
120
"""Display status summary.
223
121
224
This reports on versioned and unknown files, reporting them
225
grouped by state. Possible states are:
226
227
added
228
Versioned in the working copy but not in the previous revision.
229
230
removed
231
Versioned in the previous revision but removed or deleted
232
in the working copy.
233
234
renamed
235
Path of this file changed from the previous revision;
236
the text may also have changed. This includes files whose
237
parent directory was renamed.
238
239
modified
240
Text has changed since the previous revision.
241
242
unchanged
243
Nothing about this file has changed since the previous revision.
244
Only shown with --all.
245
246
unknown
247
Not versioned and not matching an ignore pattern.
248
249
To see ignored files use 'bzr ignored'. For details in the
250
changes to file texts, use 'bzr diff'.
251
252
If no arguments are specified, the status of the entire working
253
directory is shown. Otherwise, only the status of the specified
254
files or directories is reported. If a directory is given, status
255
is reported for everything inside that directory.
122
For each file there is a single line giving its file state and name.
123
The name is that in the current revision unless it is deleted or
124
missing, in which case the old name is shown.
125
126
:todo: Don't show unchanged files unless ``--all`` is given?
256
127
"""
257
takes_args = ['file*']
258
takes_options = ['all', 'show-ids']
259
aliases = ['st', 'stat']
260
261
def run(self, all=False, show_ids=False, file_list=None):
262
if file_list:
263
b = Branch(file_list[0])
264
file_list = [b.relpath(x) for x in file_list]
265
# special case: only one path was given and it's the root
266
# of the branch
267
if file_list == ['']:
268
file_list = None
269
else:
270
b = Branch('.')
271
import status
272
status.show_status(b, show_unchanged=all, show_ids=show_ids,
273
specific_files=file_list)
274
275
276
class cmd_cat_revision(Command):
277
"""Write out metadata for a revision."""
278
279
hidden = True
280
takes_args = ['revision_id']
281
282
def run(self, revision_id):
283
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
284
285
286
class cmd_revno(Command):
287
"""Show current revision number.
288
289
This is equal to the number of revisions on this branch."""
290
def run(self):
291
print Branch('.').revno()
292
293
294
class cmd_add(Command):
128
Branch('.').show_status(show_all=all)
129
130
131
132
######################################################################
133
# examining history
134
def cmd_get_revision(revision_id):
135
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
136
137
138
def cmd_get_file_text(text_id):
139
"""Get contents of a file by hash."""
140
sf = Branch('.').text_store[text_id]
141
pumpfile(sf, sys.stdout)
142
143
144
145
######################################################################
146
# commands
147
148
149
def cmd_revno():
150
"""Show number of revisions on this branch"""
151
print Branch('.').revno()
152
153
154
155
def cmd_add(file_list, verbose=False):
295
156
"""Add specified files or directories.
296
157
297
158
In non-recursive mode, all the named items are added, regardless
308
169
309
170
Therefore simply saying 'bzr add .' will version all files that
310
171
are currently unknown.
311
312
TODO: Perhaps adding a file whose directly is not versioned should
313
recursively add that parent, rather than giving an error?
314
"""
315
takes_args = ['file+']
316
takes_options = ['verbose', 'no-recurse']
317
318
def run(self, file_list, verbose=False, no_recurse=False):
319
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
320
321
322
class cmd_relpath(Command):
323
"""Show path of a file relative to root"""
324
takes_args = ['filename']
325
hidden = True
326
327
def run(self, filename):
328
print Branch(filename).relpath(filename)
329
330
331
332
class cmd_inventory(Command):
333
"""Show inventory of the current working copy or a revision."""
334
takes_options = ['revision', 'show-ids']
335
336
def run(self, revision=None, show_ids=False):
337
b = Branch('.')
338
if revision == None:
339
inv = b.read_working_inventory()
340
else:
341
inv = b.get_revision_inventory(b.lookup_revision(revision))
342
343
for path, entry in inv.entries():
344
if show_ids:
345
print '%-50s %s' % (path, entry.file_id)
346
else:
347
print path
348
349
350
class cmd_move(Command):
351
"""Move files to a different directory.
352
353
examples:
354
bzr move *.txt doc
355
356
The destination must be a versioned directory in the same branch.
357
"""
358
takes_args = ['source$', 'dest']
359
def run(self, source_list, dest):
360
b = Branch('.')
361
362
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
363
364
365
class cmd_rename(Command):
172
"""
173
bzrlib.add.smart_add(file_list, verbose)
174
175
176
def cmd_relpath(filename):
177
"""Show path of file relative to root"""
178
print Branch(filename).relpath(filename)
179
180
181
182
def cmd_inventory(revision=None):
183
"""Show inventory of the current working copy."""
184
## TODO: Also optionally show a previous inventory
185
## TODO: Format options
186
b = Branch('.')
187
if revision == None:
188
inv = b.read_working_inventory()
189
else:
190
inv = b.get_revision_inventory(b.lookup_revision(revision))
191
192
for path, entry in inv.iter_entries():
193
print '%-50s %s' % (entry.file_id, path)
194
195
196
197
# TODO: Maybe a 'mv' command that has the combined move/rename
198
# special behaviour of Unix?
199
200
def cmd_move(source_list, dest):
201
b = Branch('.')
202
203
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
204
205
206
207
def cmd_rename(from_name, to_name):
366
208
"""Change the name of an entry.
367
209
368
examples:
369
bzr rename frob.c frobber.c
370
bzr rename src/frob.c lib/frob.c
371
372
It is an error if the destination name exists.
373
374
See also the 'move' command, which moves files into a different
375
directory without changing their name.
376
377
TODO: Some way to rename multiple files without invoking bzr for each
378
one?"""
379
takes_args = ['from_name', 'to_name']
210
usage: bzr rename FROM_NAME TO_NAME
211
212
examples:
213
bzr rename frob.c frobber.c
214
bzr rename src/frob.c lib/frob.c
215
216
It is an error if the destination name exists.
217
218
See also the 'move' command, which moves files into a different
219
directory without changing their name.
220
221
TODO: Some way to rename multiple files without invoking bzr for each
222
one?"""
223
b = Branch('.')
224
b.rename_one(b.relpath(from_name), b.relpath(to_name))
380
225
381
def run(self, from_name, to_name):
382
b = Branch('.')
383
b.rename_one(b.relpath(from_name), b.relpath(to_name))
384
385
386
387
class cmd_renames(Command):
226
227
228
229
def cmd_renames(dir='.'):
388
230
"""Show list of renamed files.
389
231
390
TODO: Option to show renames between two historical versions.
391
392
TODO: Only show renames under dir, rather than in the whole branch.
393
"""
394
takes_args = ['dir?']
395
396
def run(self, dir='.'):
397
b = Branch(dir)
398
old_inv = b.basis_tree().inventory
399
new_inv = b.read_working_inventory()
400
401
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
402
renames.sort()
403
for old_name, new_name in renames:
404
print "%s => %s" % (old_name, new_name)
405
406
407
class cmd_info(Command):
408
"""Show statistical information about a branch."""
409
takes_args = ['branch?']
410
411
def run(self, branch=None):
412
import info
413
414
from branch import find_branch
415
b = find_branch(branch)
416
info.show_info(b)
417
418
419
class cmd_remove(Command):
420
"""Make a file unversioned.
421
422
This makes bzr stop tracking changes to a versioned file. It does
423
not delete the working copy.
424
"""
425
takes_args = ['file+']
426
takes_options = ['verbose']
427
428
def run(self, file_list, verbose=False):
429
b = Branch(file_list[0])
430
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
431
432
433
class cmd_file_id(Command):
232
usage: bzr renames [BRANCH]
233
234
TODO: Option to show renames between two historical versions.
235
236
TODO: Only show renames under dir, rather than in the whole branch.
237
"""
238
b = Branch(dir)
239
old_inv = b.basis_tree().inventory
240
new_inv = b.read_working_inventory()
241
242
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
243
renames.sort()
244
for old_name, new_name in renames:
245
print "%s => %s" % (old_name, new_name)
246
247
248
249
def cmd_info():
250
"""info: Show statistical information for this branch
251
252
usage: bzr info"""
253
import info
254
info.show_info(Branch('.'))
255
256
257
258
def cmd_remove(file_list, verbose=False):
259
b = Branch(file_list[0])
260
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
261
262
263
264
def cmd_file_id(filename):
434
265
"""Print file_id of a particular file or directory.
435
266
436
The file_id is assigned when the file is first added and remains the
437
same through all revisions where the file exists, even when it is
438
moved or renamed.
439
"""
440
hidden = True
441
takes_args = ['filename']
442
def run(self, filename):
443
b = Branch(filename)
444
i = b.inventory.path2id(b.relpath(filename))
445
if i == None:
446
bailout("%r is not a versioned file" % filename)
447
else:
448
print i
449
450
451
class cmd_file_path(Command):
267
usage: bzr file-id FILE
268
269
The file_id is assigned when the file is first added and remains the
270
same through all revisions where the file exists, even when it is
271
moved or renamed.
272
"""
273
b = Branch(filename)
274
i = b.inventory.path2id(b.relpath(filename))
275
if i == None:
276
bailout("%r is not a versioned file" % filename)
277
else:
278
print i
279
280
281
def cmd_file_id_path(filename):
452
282
"""Print path of file_ids to a file or directory.
453
283
454
This prints one line for each directory down to the target,
455
starting at the branch root."""
456
hidden = True
457
takes_args = ['filename']
458
def run(self, filename):
459
b = Branch(filename)
460
inv = b.inventory
461
fid = inv.path2id(b.relpath(filename))
462
if fid == None:
463
bailout("%r is not a versioned file" % filename)
464
for fip in inv.get_idpath(fid):
465
print fip
466
467
468
class cmd_revision_history(Command):
469
"""Display list of revision ids on this branch."""
470
hidden = True
471
def run(self):
472
for patchid in Branch('.').revision_history():
473
print patchid
474
475
476
class cmd_directories(Command):
477
"""Display list of versioned directories in this branch."""
478
def run(self):
479
for name, ie in Branch('.').read_working_inventory().directories():
480
if name == '':
481
print '.'
482
else:
483
print name
484
485
486
class cmd_init(Command):
487
"""Make a directory into a versioned branch.
488
489
Use this to create an empty branch, or before importing an
490
existing project.
491
492
Recipe for importing a tree of files:
493
cd ~/project
494
bzr init
495
bzr add -v .
496
bzr status
497
bzr commit -m 'imported project'
498
"""
499
def run(self):
500
Branch('.', init=True)
501
502
503
class cmd_diff(Command):
504
"""Show differences in working tree.
505
506
If files are listed, only the changes in those files are listed.
507
Otherwise, all changes for the tree are listed.
508
509
TODO: Given two revision arguments, show the difference between them.
510
511
TODO: Allow diff across branches.
512
513
TODO: Option to use external diff command; could be GNU diff, wdiff,
514
or a graphical diff.
515
516
TODO: Python difflib is not exactly the same as unidiff; should
517
either fix it up or prefer to use an external diff.
518
519
TODO: If a directory is given, diff everything under that.
520
521
TODO: Selected-file diff is inefficient and doesn't show you
522
deleted files.
523
524
TODO: This probably handles non-Unix newlines poorly.
525
"""
526
527
takes_args = ['file*']
528
takes_options = ['revision', 'diff-options']
529
aliases = ['di']
530
531
def run(self, revision=None, file_list=None, diff_options=None):
532
from bzrlib.diff import show_diff
533
from bzrlib import find_branch
534
535
if file_list:
536
b = find_branch(file_list[0])
537
file_list = [b.relpath(f) for f in file_list]
538
if file_list == ['']:
539
# just pointing to top-of-tree
540
file_list = None
541
else:
542
b = Branch('.')
543
544
show_diff(b, revision, specific_files=file_list,
545
external_diff_options=diff_options)
546
547
548
549
550
551
class cmd_deleted(Command):
284
usage: bzr file-id-path FILE
285
286
This prints one line for each directory down to the target,
287
starting at the branch root."""
288
b = Branch(filename)
289
inv = b.inventory
290
fid = inv.path2id(b.relpath(filename))
291
if fid == None:
292
bailout("%r is not a versioned file" % filename)
293
for fip in inv.get_idpath(fid):
294
print fip
295
296
297
def cmd_revision_history():
298
for patchid in Branch('.').revision_history():
299
print patchid
300
301
302
def cmd_directories():
303
for name, ie in Branch('.').read_working_inventory().directories():
304
if name == '':
305
print '.'
306
else:
307
print name
308
309
310
def cmd_missing():
311
for name, ie in Branch('.').working_tree().missing():
312
print name
313
314
315
def cmd_init():
316
# TODO: Check we're not already in a working directory? At the
317
# moment you'll get an ugly error.
318
319
# TODO: What if we're in a subdirectory of a branch? Would like
320
# to allow that, but then the parent may need to understand that
321
# the children have disappeared, or should they be versioned in
322
# both?
323
324
# TODO: Take an argument/option for branch name.
325
Branch('.', init=True)
326
327
328
def cmd_diff(revision=None):
329
"""bzr diff: Show differences in working tree.
330
331
usage: bzr diff [-r REV]
332
333
--revision REV
334
Show changes since REV, rather than predecessor.
335
336
TODO: Given two revision arguments, show the difference between them.
337
338
TODO: Allow diff across branches.
339
340
TODO: Option to use external diff command; could be GNU diff, wdiff,
341
or a graphical diff.
342
343
TODO: Diff selected files.
344
"""
345
346
## TODO: Shouldn't be in the cmd function.
347
348
b = Branch('.')
349
350
if revision == None:
351
old_tree = b.basis_tree()
352
else:
353
old_tree = b.revision_tree(b.lookup_revision(revision))
354
355
new_tree = b.working_tree()
356
357
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
358
old_label = ''
359
new_label = ''
360
361
DEVNULL = '/dev/null'
362
# Windows users, don't panic about this filename -- it is a
363
# special signal to GNU patch that the file should be created or
364
# deleted respectively.
365
366
# TODO: Generation of pseudo-diffs for added/deleted files could
367
# be usefully made into a much faster special case.
368
369
# TODO: Better to return them in sorted order I think.
370
371
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
372
# Don't show this by default; maybe do it if an option is passed
373
# idlabel = ' {%s}' % fid
374
idlabel = ''
375
376
# FIXME: Something about the diff format makes patch unhappy
377
# with newly-added files.
378
379
def diffit(oldlines, newlines, **kw):
380
# FIXME: difflib is wrong if there is no trailing newline.
381
382
# Special workaround for Python2.3, where difflib fails if
383
# both sequences are empty.
384
if oldlines or newlines:
385
sys.stdout.writelines(difflib.unified_diff(oldlines, newlines, **kw))
386
print
387
388
if file_state in ['.', '?', 'I']:
389
continue
390
elif file_state == 'A':
391
print '*** added %s %r' % (kind, new_name)
392
if kind == 'file':
393
diffit([],
394
new_tree.get_file(fid).readlines(),
395
fromfile=DEVNULL,
396
tofile=new_label + new_name + idlabel)
397
elif file_state == 'D':
398
assert isinstance(old_name, types.StringTypes)
399
print '*** deleted %s %r' % (kind, old_name)
400
if kind == 'file':
401
diffit(old_tree.get_file(fid).readlines(), [],
402
fromfile=old_label + old_name + idlabel,
403
tofile=DEVNULL)
404
elif file_state in ['M', 'R']:
405
if file_state == 'M':
406
assert kind == 'file'
407
assert old_name == new_name
408
print '*** modified %s %r' % (kind, new_name)
409
elif file_state == 'R':
410
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
411
412
if kind == 'file':
413
diffit(old_tree.get_file(fid).readlines(),
414
new_tree.get_file(fid).readlines(),
415
fromfile=old_label + old_name + idlabel,
416
tofile=new_label + new_name)
417
else:
418
bailout("can't represent state %s {%s}" % (file_state, fid))
419
420
421
422
def cmd_deleted(show_ids=False):
552
423
"""List files deleted in the working tree.
553
424
554
TODO: Show files deleted since a previous revision, or between two revisions.
425
TODO: Show files deleted since a previous revision, or between two revisions.
555
426
"""
556
def run(self, show_ids=False):
557
b = Branch('.')
558
old = b.basis_tree()
559
new = b.working_tree()
560
561
## TODO: Much more efficient way to do this: read in new
562
## directories with readdir, rather than stating each one. Same
563
## level of effort but possibly much less IO. (Or possibly not,
564
## if the directories are very large...)
565
566
for path, ie in old.inventory.iter_entries():
567
if not new.has_id(ie.file_id):
568
if show_ids:
569
print '%-50s %s' % (path, ie.file_id)
570
else:
571
print path
572
573
574
class cmd_modified(Command):
575
"""List files modified in working tree."""
576
hidden = True
577
def run(self):
578
import statcache
579
b = Branch('.')
580
inv = b.read_working_inventory()
581
sc = statcache.update_cache(b, inv)
582
basis = b.basis_tree()
583
basis_inv = basis.inventory
584
585
# We used to do this through iter_entries(), but that's slow
586
# when most of the files are unmodified, as is usually the
587
# case. So instead we iterate by inventory entry, and only
588
# calculate paths as necessary.
589
590
for file_id in basis_inv:
591
cacheentry = sc.get(file_id)
592
if not cacheentry: # deleted
593
continue
594
ie = basis_inv[file_id]
595
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
596
path = inv.id2path(file_id)
427
b = Branch('.')
428
old = b.basis_tree()
429
new = b.working_tree()
430
431
## TODO: Much more efficient way to do this: read in new
432
## directories with readdir, rather than stating each one. Same
433
## level of effort but possibly much less IO. (Or possibly not,
434
## if the directories are very large...)
435
436
for path, ie in old.inventory.iter_entries():
437
if not new.has_id(ie.file_id):
438
if show_ids:
439
print '%-50s %s' % (path, ie.file_id)
440
else:
597
441
print path
598
442
599
443
600
444
601
class cmd_added(Command):
602
"""List files added in working tree."""
603
hidden = True
604
def run(self):
605
b = Branch('.')
606
wt = b.working_tree()
607
basis_inv = b.basis_tree().inventory
608
inv = wt.inventory
609
for file_id in inv:
610
if file_id in basis_inv:
611
continue
612
path = inv.id2path(file_id)
613
if not os.access(b.abspath(path), os.F_OK):
614
continue
615
print path
616
617
618
619
class cmd_root(Command):
620
"""Show the tree root directory.
621
622
The root is the nearest enclosing directory with a .bzr control
623
directory."""
624
takes_args = ['filename?']
625
def run(self, filename=None):
626
"""Print the branch root."""
627
from branch import find_branch
628
b = find_branch(filename)
629
print getattr(b, 'base', None) or getattr(b, 'baseurl')
630
631
632
class cmd_log(Command):
445
def cmd_parse_inventory():
446
import cElementTree
447
448
cElementTree.ElementTree().parse(file('.bzr/inventory'))
449
450
451
452
def cmd_load_inventory():
453
"""Load inventory for timing purposes"""
454
Branch('.').basis_tree().inventory
455
456
457
def cmd_dump_inventory():
458
Branch('.').read_working_inventory().write_xml(sys.stdout)
459
460
461
def cmd_dump_new_inventory():
462
import bzrlib.newinventory
463
inv = Branch('.').basis_tree().inventory
464
bzrlib.newinventory.write_inventory(inv, sys.stdout)
465
466
467
def cmd_load_new_inventory():
468
import bzrlib.newinventory
469
bzrlib.newinventory.read_new_inventory(sys.stdin)
470
471
472
def cmd_dump_slacker_inventory():
473
import bzrlib.newinventory
474
inv = Branch('.').basis_tree().inventory
475
bzrlib.newinventory.write_slacker_inventory(inv, sys.stdout)
476
477
478
479
def cmd_root(filename=None):
480
"""Print the branch root."""
481
print bzrlib.branch.find_branch_root(filename)
482
483
484
def cmd_log(timezone='original'):
633
485
"""Show log of this branch.
634
486
635
To request a range of logs, you can use the command -r begin:end
636
-r revision requests a specific revision, -r :end or -r begin: are
637
also valid.
638
639
TODO: Make --revision support uuid: and hash: [future tag:] notation.
640
487
:todo: Options for utc; to show ids; to limit range; etc.
641
488
"""
642
643
takes_args = ['filename?']
644
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
645
646
def run(self, filename=None, timezone='original',
647
verbose=False,
648
show_ids=False,
649
forward=False,
650
revision=None):
651
from bzrlib import show_log, find_branch
652
import codecs
653
654
direction = (forward and 'forward') or 'reverse'
655
656
if filename:
657
b = find_branch(filename)
658
fp = b.relpath(filename)
659
if fp:
660
file_id = b.read_working_inventory().path2id(fp)
661
else:
662
file_id = None # points to branch root
663
else:
664
b = find_branch('.')
665
file_id = None
666
667
if revision == None:
668
revision = [None, None]
669
elif isinstance(revision, int):
670
revision = [revision, revision]
671
else:
672
# pair of revisions?
673
pass
674
675
assert len(revision) == 2
676
677
mutter('encoding log as %r' % bzrlib.user_encoding)
678
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout)
679
680
show_log(b, file_id,
681
show_timezone=timezone,
682
verbose=verbose,
683
show_ids=show_ids,
684
to_file=outf,
685
direction=direction,
686
start_revision=revision[0],
687
end_revision=revision[1])
688
689
690
691
class cmd_touching_revisions(Command):
692
"""Return revision-ids which affected a particular file.
693
694
A more user-friendly interface is "bzr log FILE"."""
695
hidden = True
696
takes_args = ["filename"]
697
def run(self, filename):
698
b = Branch(filename)
699
inv = b.read_working_inventory()
700
file_id = inv.path2id(b.relpath(filename))
701
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
702
print "%6d %s" % (revno, what)
703
704
705
class cmd_ls(Command):
489
Branch('.').write_log(show_timezone=timezone)
490
491
492
def cmd_ls(revision=None, verbose=False):
706
493
"""List files in a tree.
707
494
708
TODO: Take a revision or remote path and list that tree instead.
495
:todo: Take a revision or remote path and list that tree instead.
709
496
"""
710
hidden = True
711
def run(self, revision=None, verbose=False):
712
b = Branch('.')
713
if revision == None:
714
tree = b.working_tree()
497
b = Branch('.')
498
if revision == None:
499
tree = b.working_tree()
500
else:
501
tree = b.revision_tree(b.lookup_revision(revision))
502
503
for fp, fc, kind, fid in tree.list_files():
504
if verbose:
505
if kind == 'directory':
506
kindch = '/'
507
elif kind == 'file':
508
kindch = ''
509
else:
510
kindch = '???'
511
512
print '%-8s %s%s' % (fc, fp, kindch)
715
513
else:
716
tree = b.revision_tree(b.lookup_revision(revision))
717
718
for fp, fc, kind, fid in tree.list_files():
719
if verbose:
720
if kind == 'directory':
721
kindch = '/'
722
elif kind == 'file':
723
kindch = ''
724
else:
725
kindch = '???'
726
727
print '%-8s %s%s' % (fc, fp, kindch)
728
else:
729
print fp
730
731
732
733
class cmd_unknowns(Command):
514
print fp
515
516
517
518
def cmd_unknowns():
734
519
"""List unknown files"""
735
def run(self):
736
for f in Branch('.').unknowns():
737
print quotefn(f)
738
739
740
741
class cmd_ignore(Command):
742
"""Ignore a command or pattern
743
744
To remove patterns from the ignore list, edit the .bzrignore file.
745
746
If the pattern contains a slash, it is compared to the whole path
747
from the branch root. Otherwise, it is comapred to only the last
748
component of the path.
749
750
Ignore patterns are case-insensitive on case-insensitive systems.
751
752
Note: wildcards must be quoted from the shell on Unix.
753
754
examples:
755
bzr ignore ./Makefile
756
bzr ignore '*.class'
757
"""
758
takes_args = ['name_pattern']
759
760
def run(self, name_pattern):
761
from bzrlib.atomicfile import AtomicFile
762
import os.path
763
764
b = Branch('.')
765
ifn = b.abspath('.bzrignore')
766
767
if os.path.exists(ifn):
768
f = open(ifn, 'rt')
769
try:
770
igns = f.read().decode('utf-8')
771
finally:
772
f.close()
773
else:
774
igns = ''
775
776
# TODO: If the file already uses crlf-style termination, maybe
777
# we should use that for the newly added lines?
778
779
if igns and igns[-1] != '\n':
780
igns += '\n'
781
igns += name_pattern + '\n'
782
783
try:
784
f = AtomicFile(ifn, 'wt')
785
f.write(igns.encode('utf-8'))
786
f.commit()
787
finally:
788
f.close()
789
790
inv = b.working_tree().inventory
791
if inv.path2id('.bzrignore'):
792
mutter('.bzrignore is already versioned')
793
else:
794
mutter('need to make new .bzrignore file versioned')
795
b.add(['.bzrignore'])
796
797
798
799
class cmd_ignored(Command):
520
for f in Branch('.').unknowns():
521
print quotefn(f)
522
523
524
525
def cmd_ignored():
800
526
"""List ignored files and the patterns that matched them.
801
802
See also: bzr ignore"""
803
def run(self):
804
tree = Branch('.').working_tree()
805
for path, file_class, kind, file_id in tree.list_files():
806
if file_class != 'I':
807
continue
808
## XXX: Slightly inefficient since this was already calculated
809
pat = tree.is_ignored(path)
810
print '%-50s %s' % (path, pat)
811
812
813
class cmd_lookup_revision(Command):
814
"""Lookup the revision-id from a revision-number
815
816
example:
817
bzr lookup-revision 33
818
"""
819
hidden = True
820
takes_args = ['revno']
821
822
def run(self, revno):
823
try:
824
revno = int(revno)
825
except ValueError:
826
raise BzrCommandError("not a valid revision-number: %r" % revno)
827
828
print Branch('.').lookup_revision(revno)
829
830
831
class cmd_export(Command):
832
"""Export past revision to destination directory.
833
834
If no revision is specified this exports the last committed revision."""
835
takes_args = ['dest']
836
takes_options = ['revision']
837
def run(self, dest, revision=None):
838
b = Branch('.')
839
if revision == None:
840
rh = b.revision_history()[-1]
841
else:
842
rh = b.lookup_revision(int(revision))
843
t = b.revision_tree(rh)
844
t.export(dest)
845
846
847
class cmd_cat(Command):
848
"""Write a file's text from a previous revision."""
849
850
takes_options = ['revision']
851
takes_args = ['filename']
852
853
def run(self, filename, revision=None):
854
if revision == None:
855
raise BzrCommandError("bzr cat requires a revision number")
856
b = Branch('.')
857
b.print_file(b.relpath(filename), int(revision))
858
859
860
class cmd_local_time_offset(Command):
861
"""Show the offset in seconds from GMT to local time."""
862
hidden = True
863
def run(self):
864
print bzrlib.osutils.local_time_offset()
865
866
867
868
class cmd_commit(Command):
869
"""Commit changes into a new revision.
870
871
If selected files are specified, only changes to those files are
872
committed. If a directory is specified then its contents are also
873
committed.
874
875
A selected-file commit may fail in some cases where the committed
876
tree would be invalid, such as trying to commit a file in a
877
newly-added directory that is not itself committed.
878
879
TODO: Run hooks on tree to-be-committed, and after commit.
880
881
TODO: Strict commit that fails if there are unknown or deleted files.
882
"""
883
takes_args = ['selected*']
884
takes_options = ['message', 'file', 'verbose']
885
aliases = ['ci', 'checkin']
886
887
def run(self, message=None, file=None, verbose=True, selected_list=None):
888
from bzrlib.commit import commit
889
890
## Warning: shadows builtin file()
891
if not message and not file:
892
raise BzrCommandError("please specify a commit message",
893
["use either --message or --file"])
894
elif message and file:
895
raise BzrCommandError("please specify either --message or --file")
527
"""
528
tree = Branch('.').working_tree()
529
for path, file_class, kind, file_id in tree.list_files():
530
if file_class != 'I':
531
continue
532
## XXX: Slightly inefficient since this was already calculated
533
pat = tree.is_ignored(path)
534
print '%-50s %s' % (path, pat)
535
536
537
def cmd_lookup_revision(revno):
538
try:
539
revno = int(revno)
540
except ValueError:
541
bailout("usage: lookup-revision REVNO",
542
["REVNO is a non-negative revision number for this branch"])
543
544
print Branch('.').lookup_revision(revno) or NONE_STRING
545
546
547
548
def cmd_export(revno, dest):
549
"""Export past revision to destination directory."""
550
b = Branch('.')
551
rh = b.lookup_revision(int(revno))
552
t = b.revision_tree(rh)
553
t.export(dest)
554
555
def cmd_cat(revision, filename):
556
"""Print file to stdout."""
557
b = Branch('.')
558
b.print_file(b.relpath(filename), int(revision))
559
560
561
######################################################################
562
# internal/test commands
563
564
565
def cmd_uuid():
566
"""Print a newly-generated UUID."""
567
print bzrlib.osutils.uuid()
568
569
570
571
def cmd_local_time_offset():
572
print bzrlib.osutils.local_time_offset()
573
574
575
576
def cmd_commit(message=None, verbose=False):
577
"""Commit changes to a new revision.
578
579
--message MESSAGE
580
Description of changes in this revision; free form text.
581
It is recommended that the first line be a single-sentence
582
summary.
583
--verbose
584
Show status of changed files,
585
586
TODO: Commit only selected files.
587
588
TODO: Run hooks on tree to-be-committed, and after commit.
589
590
TODO: Strict commit that fails if there are unknown or deleted files.
591
"""
592
593
if not message:
594
bailout("please specify a commit message")
595
Branch('.').commit(message, verbose=verbose)
596
597
598
def cmd_check(dir='.'):
599
"""check: Consistency check of branch history.
600
601
usage: bzr check [-v] [BRANCH]
602
603
options:
604
--verbose, -v Show progress of checking.
605
606
This command checks various invariants about the branch storage to
607
detect data corruption or bzr bugs.
608
"""
609
import bzrlib.check
610
bzrlib.check.check(Branch(dir, find_root=False))
611
612
613
def cmd_is(pred, *rest):
614
"""Test whether PREDICATE is true."""
615
try:
616
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
617
except KeyError:
618
bailout("unknown predicate: %s" % quotefn(pred))
896
619
897
if file:
898
import codecs
899
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
900
901
b = Branch('.')
902
commit(b, message, verbose=verbose, specific_files=selected_list)
903
904
905
class cmd_check(Command):
906
"""Validate consistency of branch history.
907
908
This command checks various invariants about the branch storage to
909
detect data corruption or bzr bugs.
910
"""
911
takes_args = ['dir?']
912
def run(self, dir='.'):
913
import bzrlib.check
914
bzrlib.check.check(Branch(dir))
915
916
917
918
class cmd_whoami(Command):
919
"""Show bzr user id."""
920
takes_options = ['email']
921
922
def run(self, email=False):
923
if email:
924
print bzrlib.osutils.user_email()
925
else:
926
print bzrlib.osutils.username()
927
928
929
class cmd_selftest(Command):
620
try:
621
cmd_handler(*rest)
622
except BzrCheckError:
623
# by default we don't print the message so that this can
624
# be used from shell scripts without producing noise
625
sys.exit(1)
626
627
628
def cmd_username():
629
print bzrlib.osutils.username()
630
631
632
def cmd_user_email():
633
print bzrlib.osutils.user_email()
634
635
636
def cmd_gen_revision_id():
637
print bzrlib.branch._gen_revision_id(time.time())
638
639
640
def cmd_selftest():
930
641
"""Run internal test suite"""
931
hidden = True
932
def run(self):
933
failures, tests = 0, 0
934
935
import doctest, bzrlib.store
936
bzrlib.trace.verbose = False
937
938
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
939
bzrlib.tree, bzrlib.commands, bzrlib.add:
940
mf, mt = doctest.testmod(m)
941
failures += mf
942
tests += mt
943
print '%-40s %3d tests' % (m.__name__, mt),
944
if mf:
945
print '%3d FAILED!' % mf
946
else:
947
print
948
949
print '%-40s %3d tests' % ('total', tests),
950
if failures:
951
print '%3d FAILED!' % failures
952
return 1
642
## -v, if present, is seen by doctest; the argument is just here
643
## so our parser doesn't complain
644
645
## TODO: --verbose option
646
647
failures, tests = 0, 0
648
649
import doctest, bzrlib.store, bzrlib.tests
650
bzrlib.trace.verbose = False
651
652
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
653
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
654
mf, mt = doctest.testmod(m)
655
failures += mf
656
tests += mt
657
print '%-40s %3d tests' % (m.__name__, mt),
658
if mf:
659
print '%3d FAILED!' % mf
953
660
else:
954
661
print
955
return 0
956
957
958
959
class cmd_version(Command):
960
"""Show version of bzr"""
961
def run(self):
962
show_version()
963
964
def show_version():
662
663
print '%-40s %3d tests' % ('total', tests),
664
if failures:
665
print '%3d FAILED!' % failures
666
else:
667
print
668
669
670
671
# deprecated
672
cmd_doctest = cmd_selftest
673
674
675
######################################################################
676
# help
677
678
679
def cmd_help(topic=None):
680
if topic == None:
681
print __doc__
682
return
683
684
# otherwise, maybe the name of a command?
685
try:
686
cmdfn = globals()['cmd_' + topic.replace('-', '_')]
687
except KeyError:
688
bailout("no help for %r" % topic)
689
690
doc = cmdfn.__doc__
691
if doc == None:
692
bailout("sorry, no detailed help yet for %r" % topic)
693
694
print doc
695
696
697
698
699
def cmd_version():
965
700
print "bzr (bazaar-ng) %s" % bzrlib.__version__
966
701
print bzrlib.__copyright__
967
702
print "http://bazaar-ng.org/"
968
703
print
969
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
970
print "you may use, modify and redistribute it under the terms of the GNU"
971
print "General Public License version 2 or later."
972
973
974
class cmd_rocks(Command):
704
print \
705
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
706
you may use, modify and redistribute it under the terms of the GNU
707
General Public License version 2 or later."""
708
709
710
def cmd_rocks():
975
711
"""Statement of optimism."""
976
hidden = True
977
def run(self):
978
print "it sure does!"
979
980
def parse_spec(spec):
981
if '/@' in spec:
982
parsed = spec.split('/@')
983
assert len(parsed) == 2
984
if parsed[1] == "":
985
parsed[1] = -1
986
else:
987
parsed[1] = int(parsed[1])
988
assert parsed[1] >=0
989
else:
990
parsed = [spec, None]
991
return parsed
992
993
class cmd_merge(Command):
994
"""Perform a three-way merge of trees."""
995
takes_args = ['other_spec', 'base_spec']
996
997
def run(self, other_spec, base_spec):
998
from bzrlib.merge import merge
999
merge(parse_spec(other_spec), parse_spec(base_spec))
1000
1001
class cmd_assert_fail(Command):
1002
"""Test reporting of assertion failures"""
1003
hidden = True
1004
def run(self):
1005
assert False, "always fails"
1006
1007
1008
class cmd_help(Command):
1009
"""Show help on a command or other topic.
1010
1011
For a list of all available commands, say 'bzr help commands'."""
1012
takes_args = ['topic?']
1013
aliases = ['?']
1014
1015
def run(self, topic=None):
1016
import help
1017
help.help(topic)
1018
1019
1020
class cmd_update_stat_cache(Command):
1021
"""Update stat-cache mapping inodes to SHA-1 hashes.
1022
1023
For testing only."""
1024
hidden = True
1025
def run(self):
1026
import statcache
1027
b = Branch('.')
1028
statcache.update_cache(b.base, b.read_working_inventory())
1029
712
print "it sure does!"
713
714
715
716
######################################################################
717
# main routine
1030
718
1031
719
1032
720
# list of all available options; the rhs can be either None for an
1034
722
# the type.
1035
723
OPTIONS = {
1036
724
'all': None,
1037
'diff-options': str,
1038
725
'help': None,
1039
'file': unicode,
1040
'forward': None,
1041
726
'message': unicode,
1042
'no-recurse': None,
1043
727
'profile': None,
1044
'revision': _parse_revision_str,
728
'revision': int,
1045
729
'show-ids': None,
1046
730
'timezone': str,
1047
731
'verbose': None,
1048
732
'version': None,
1049
'email': None,
1050
733
}
1051
734
1052
735
SHORT_OPTIONS = {
1053
'F': 'file',
1054
'h': 'help',
1055
736
'm': 'message',
1056
737
'r': 'revision',
1057
738
'v': 'verbose',
1058
739
}
1059
740
741
# List of options that apply to particular commands; commands not
742
# listed take none.
743
cmd_options = {
744
'add': ['verbose'],
745
'cat': ['revision'],
746
'commit': ['message', 'verbose'],
747
'deleted': ['show-ids'],
748
'diff': ['revision'],
749
'inventory': ['revision'],
750
'log': ['timezone'],
751
'ls': ['revision', 'verbose'],
752
'remove': ['verbose'],
753
'status': ['all'],
754
}
755
756
757
cmd_args = {
758
'add': ['file+'],
759
'cat': ['filename'],
760
'commit': [],
761
'diff': [],
762
'export': ['revno', 'dest'],
763
'file-id': ['filename'],
764
'file-id-path': ['filename'],
765
'get-file-text': ['text_id'],
766
'get-inventory': ['inventory_id'],
767
'get-revision': ['revision_id'],
768
'get-revision-inventory': ['revision_id'],
769
'help': ['topic?'],
770
'init': [],
771
'log': [],
772
'lookup-revision': ['revno'],
773
'move': ['source$', 'dest'],
774
'relpath': ['filename'],
775
'remove': ['file+'],
776
'rename': ['from_name', 'to_name'],
777
'renames': ['dir?'],
778
'root': ['filename?'],
779
'status': [],
780
}
781
1060
782
1061
783
def parse_args(argv):
1062
784
"""Parse command line.
1083
805
while argv:
1084
806
a = argv.pop(0)
1085
807
if a[0] == '-':
1086
# option names must not be unicode
1087
a = str(a)
1088
808
optarg = None
1089
809
if a[1] == '-':
1090
810
mutter(" got option %r" % a)
1123
843
1124
844
1125
845
846
def _match_args(cmd, args):
847
"""Check non-option arguments match required pattern.
1126
848
1127
def _match_argform(cmd, takes_args, args):
849
>>> _match_args('status', ['asdasdsadasd'])
850
Traceback (most recent call last):
851
...
852
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
853
>>> _match_args('add', ['asdasdsadasd'])
854
{'file_list': ['asdasdsadasd']}
855
>>> _match_args('add', 'abc def gj'.split())
856
{'file_list': ['abc', 'def', 'gj']}
857
"""
858
# match argument pattern
859
argform = cmd_args.get(cmd, [])
1128
860
argdict = {}
861
# TODO: Need a way to express 'cp SRC... DEST', where it matches
862
# all but one.
1129
863
1130
# step through args and takes_args, allowing appropriate 0-many matches
1131
for ap in takes_args:
864
# step through args and argform, allowing appropriate 0-many matches
865
for ap in argform:
1132
866
argname = ap[:-1]
1133
867
if ap[-1] == '?':
1134
868
if args:
1135
869
argdict[argname] = args.pop(0)
1136
elif ap[-1] == '*': # all remaining arguments
1137
if args:
1138
argdict[argname + '_list'] = args[:]
1139
args = []
1140
else:
1141
argdict[argname + '_list'] = None
870
elif ap[-1] == '*':
871
raise BzrError("arg form %r not implemented yet" % ap)
1142
872
elif ap[-1] == '+':
1143
873
if not args:
1144
raise BzrCommandError("command %r needs one or more %s"
874
bailout("command %r needs one or more %s"
1145
875
% (cmd, argname.upper()))
1146
876
else:
1147
877
argdict[argname + '_list'] = args[:]
1148
878
args = []
1149
879
elif ap[-1] == '$': # all but one
1150
880
if len(args) < 2:
1151
raise BzrCommandError("command %r needs one or more %s"
881
bailout("command %r needs one or more %s"
1152
882
% (cmd, argname.upper()))
1153
883
argdict[argname + '_list'] = args[:-1]
1154
884
args[:-1] = []
1156
886
# just a plain arg
1157
887
argname = ap
1158
888
if not args:
1159
raise BzrCommandError("command %r requires argument %s"
889
bailout("command %r requires argument %s"
1160
890
% (cmd, argname.upper()))
1161
891
else:
1162
892
argdict[argname] = args.pop(0)
1163
893
1164
894
if args:
1165
raise BzrCommandError("extra argument to command %s: %s"
1166
% (cmd, args[0]))
895
bailout("extra arguments to command %s: %r"
896
% (cmd, args))
1167
897
1168
898
return argdict
1169
899
1173
903
"""Execute a command.
1174
904
1175
905
This is similar to main(), but without all the trappings for
1176
logging and error handling.
906
logging and error handling.
1177
907
"""
1178
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1179
1180
908
try:
1181
909
args, opts = parse_args(argv[1:])
1182
910
if 'help' in opts:
1183
import help
911
# TODO: pass down other arguments in case they asked for
912
# help on a command name?
1184
913
if args:
1185
help.help(args[0])
914
cmd_help(args[0])
1186
915
else:
1187
help.help()
916
cmd_help()
1188
917
return 0
1189
918
elif 'version' in opts:
1190
show_version()
919
cmd_version()
1191
920
return 0
1192
cmd = str(args.pop(0))
921
cmd = args.pop(0)
1193
922
except IndexError:
1194
import help
1195
help.help()
923
log_error('usage: bzr COMMAND\n')
924
log_error(' try "bzr help"\n')
1196
925
return 1
1197
1198
926
1199
canonical_cmd, cmd_class = get_cmd_class(cmd)
927
try:
928
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
929
except KeyError:
930
bailout("unknown command " + `cmd`)
1200
931
1201
932
# global option
1202
933
if 'profile' in opts:
1206
937
profile = False
1207
938
1208
939
# check options are reasonable
1209
allowed = cmd_class.takes_options
940
allowed = cmd_options.get(cmd, [])
1210
941
for oname in opts:
1211
942
if oname not in allowed:
1212
raise BzrCommandError("option '--%s' is not allowed for command %r"
1213
% (oname, cmd))
943
bailout("option %r is not allowed for command %r"
944
% (oname, cmd))
945
946
# TODO: give an error if there are any mandatory options which are
947
# not specified? Or maybe there shouldn't be any "mandatory
948
# options" (it is an oxymoron)
1214
949
1215
950
# mix arguments and options into one dictionary
1216
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1217
cmdopts = {}
951
cmdargs = _match_args(cmd, args)
1218
952
for k, v in opts.items():
1219
cmdopts[k.replace('-', '_')] = v
953
cmdargs[k.replace('-', '_')] = v
1220
954
1221
955
if profile:
1222
import hotshot, tempfile
1223
pffileno, pfname = tempfile.mkstemp()
1224
try:
1225
prof = hotshot.Profile(pfname)
1226
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1227
prof.close()
1228
1229
import hotshot.stats
1230
stats = hotshot.stats.load(pfname)
1231
#stats.strip_dirs()
1232
stats.sort_stats('time')
1233
## XXX: Might like to write to stderr or the trace file instead but
1234
## print_stats seems hardcoded to stdout
1235
stats.print_stats(20)
1236
1237
return ret.status
1238
1239
finally:
1240
os.close(pffileno)
1241
os.remove(pfname)
956
import hotshot
957
prof = hotshot.Profile('.bzr.profile')
958
ret = prof.runcall(cmd_handler, **cmdargs) or 0
959
prof.close()
960
961
import hotshot.stats
962
stats = hotshot.stats.load('.bzr.profile')
963
#stats.strip_dirs()
964
stats.sort_stats('time')
965
stats.print_stats(20)
966
967
return ret
1242
968
else:
1243
return cmd_class(cmdopts, cmdargs).status
1244
1245
1246
def _report_exception(summary, quiet=False):
1247
import traceback
1248
log_error('bzr: ' + summary)
1249
bzrlib.trace.log_exception()
1250
1251
if not quiet:
1252
tb = sys.exc_info()[2]
1253
exinfo = traceback.extract_tb(tb)
1254
if exinfo:
1255
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1256
sys.stderr.write(' see ~/.bzr.log for debug information\n')
969
return cmd_handler(**cmdargs) or 0
1257
970
1258
971
1259
972
1260
973
def main(argv):
1261
import errno
974
## TODO: Handle command-line options; probably know what options are valid for
975
## each command
976
977
## TODO: If the arguments are wrong, give a usage message rather
978
## than just a backtrace.
979
980
bzrlib.trace.create_tracefile(argv)
1262
981
1263
bzrlib.open_tracefile(argv)
1264
1265
982
try:
1266
try:
1267
try:
1268
return run_bzr(argv)
1269
finally:
1270
# do this here inside the exception wrappers to catch EPIPE
1271
sys.stdout.flush()
1272
except BzrError, e:
1273
quiet = isinstance(e, (BzrCommandError))
1274
_report_exception('error: ' + e.args[0], quiet=quiet)
1275
if len(e.args) > 1:
1276
for h in e.args[1]:
1277
# some explanation or hints
1278
log_error(' ' + h)
1279
return 1
1280
except AssertionError, e:
1281
msg = 'assertion failed'
1282
if str(e):
1283
msg += ': ' + str(e)
1284
_report_exception(msg)
1285
return 2
1286
except KeyboardInterrupt, e:
1287
_report_exception('interrupted', quiet=True)
1288
return 2
1289
except Exception, e:
1290
quiet = False
1291
if (isinstance(e, IOError)
1292
and hasattr(e, 'errno')
1293
and e.errno == errno.EPIPE):
1294
quiet = True
1295
msg = 'broken pipe'
1296
else:
1297
msg = str(e).rstrip('\n')
1298
_report_exception(msg, quiet)
1299
return 2
1300
finally:
1301
bzrlib.trace.close_trace()
983
ret = run_bzr(argv)
984
return ret
985
except BzrError, e:
986
log_error('bzr: error: ' + e.args[0] + '\n')
987
if len(e.args) > 1:
988
for h in e.args[1]:
989
log_error(' ' + h + '\n')
990
traceback.print_exc(None, bzrlib.trace._tracefile)
991
log_error('(see $HOME/.bzr.log for debug information)\n')
992
return 1
993
except Exception, e:
994
log_error('bzr: exception: %s\n' % e)
995
log_error('(see $HOME/.bzr.log for debug information)\n')
996
traceback.print_exc(None, bzrlib.trace._tracefile)
997
## traceback.print_exc(None, sys.stderr)
998
return 1
999
1000
# TODO: Maybe nicer handling of IOError?
1001
1302
1002
1303
1003
1304
1004
if __name__ == '__main__':
1305
1005
sys.exit(main(sys.argv))
1006
##import profile
1007
##profile.run('main(sys.argv)')
1008
Loggerhead is a web-based interface for Breezy
Version: 2.0.1