« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 974.1.17
- compare with another revision
- download diff
- download tarball
- view history from revision 974.1.17
- Committer: Aaron Bentley
- Date: 2005-08-10 15:05:26 UTC
- mto: (1092.1.41) (1185.3.4) (974.1.47)
- mto: This revision was merged to the branch mainline in revision 1110.
- Revision ID: abentley@panoramicfeedback.com-20050810150526-468a7e2e3dc299e4
Switched to using a set of interesting file_ids instead of SourceFile attribute
- files added:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- contrib/bash/bzr => contrib/bash/bzr.simple
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
"""Bazaar-NG -- a free distributed version-control tool
18
http://bazaar-ng.org/
19
20
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
21
22
* Metadata format is not stable yet -- you may need to
23
discard history in the future.
24
25
* Many commands unimplemented or partially implemented.
26
27
* Space-inefficient storage.
28
29
* No merge operators yet.
30
31
Interesting commands:
32
33
bzr help [COMMAND]
34
Show help screen
35
bzr version
36
Show software version/licence/non-warranty.
37
bzr init
38
Start versioning the current directory
39
bzr add FILE...
40
Make files versioned.
41
bzr log
42
Show revision history.
43
bzr rename FROM TO
44
Rename one file.
45
bzr move FROM... DESTDIR
46
Move one or more files to a different directory.
47
bzr diff [FILE...]
48
Show changes from last revision to working copy.
49
bzr commit -m 'MESSAGE'
50
Store current state as new revision.
51
bzr export [-r REVNO] DESTINATION
52
Export the branch state at a previous version.
53
bzr status
54
Show summary of pending changes.
55
bzr remove FILE...
56
Make a file not versioned.
57
bzr info
58
Show statistics about this branch.
59
bzr check
60
Verify history is stored safely.
61
(for more type 'bzr help commands')
62
"""
63
64
65
66
67
import sys, os, time, types, shutil, tempfile, fnmatch, difflib, os.path
68
from sets import Set
69
from pprint import pprint
70
from stat import *
71
from glob import glob
17
18
19
import sys, os
72
20
73
21
import bzrlib
74
from bzrlib.store import ImmutableStore
75
from bzrlib.trace import mutter, note, log_error
76
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
77
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
78
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
79
from bzrlib.revision import Revision
80
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
81
format_date
82
83
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
84
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
85
86
## standard representation
87
NONE_STRING = '(none)'
88
EMPTY = 'empty'
89
90
91
CMD_ALIASES = {
92
'?': 'help',
93
'ci': 'commit',
94
'checkin': 'commit',
95
'di': 'diff',
96
'st': 'status',
97
'stat': 'status',
98
}
99
100
101
def get_cmd_class(cmd):
102
cmd = str(cmd)
103
104
cmd = CMD_ALIASES.get(cmd, cmd)
105
106
try:
107
cmd_class = globals()['cmd_' + cmd.replace('-', '_')]
108
except KeyError:
109
raise BzrError("unknown command %r" % cmd)
110
111
return cmd, cmd_class
112
113
114
115
class Command:
22
from bzrlib.trace import mutter, note, log_error, warning
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.branch import find_branch
25
from bzrlib import BZRDIR
26
27
28
plugin_cmds = {}
29
30
31
def register_command(cmd):
32
"Utility function to help register a command"
33
global plugin_cmds
34
k = cmd.__name__
35
if k.startswith("cmd_"):
36
k_unsquished = _unsquish_command_name(k)
37
else:
38
k_unsquished = k
39
if not plugin_cmds.has_key(k_unsquished):
40
plugin_cmds[k_unsquished] = cmd
41
else:
42
log_error('Two plugins defined the same command: %r' % k)
43
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
44
45
46
def _squish_command_name(cmd):
47
return 'cmd_' + cmd.replace('-', '_')
48
49
50
def _unsquish_command_name(cmd):
51
assert cmd.startswith("cmd_")
52
return cmd[4:].replace('_','-')
53
54
55
def _parse_revision_str(revstr):
56
"""This handles a revision string -> revno.
57
58
This always returns a list. The list will have one element for
59
60
It supports integers directly, but everything else it
61
defers for passing to Branch.get_revision_info()
62
63
>>> _parse_revision_str('234')
64
[234]
65
>>> _parse_revision_str('234..567')
66
[234, 567]
67
>>> _parse_revision_str('..')
68
[None, None]
69
>>> _parse_revision_str('..234')
70
[None, 234]
71
>>> _parse_revision_str('234..')
72
[234, None]
73
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
74
[234, 456, 789]
75
>>> _parse_revision_str('234....789') # Error?
76
[234, None, 789]
77
>>> _parse_revision_str('revid:test@other.com-234234')
78
['revid:test@other.com-234234']
79
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
80
['revid:test@other.com-234234', 'revid:test@other.com-234235']
81
>>> _parse_revision_str('revid:test@other.com-234234..23')
82
['revid:test@other.com-234234', 23]
83
>>> _parse_revision_str('date:2005-04-12')
84
['date:2005-04-12']
85
>>> _parse_revision_str('date:2005-04-12 12:24:33')
86
['date:2005-04-12 12:24:33']
87
>>> _parse_revision_str('date:2005-04-12T12:24:33')
88
['date:2005-04-12T12:24:33']
89
>>> _parse_revision_str('date:2005-04-12,12:24:33')
90
['date:2005-04-12,12:24:33']
91
>>> _parse_revision_str('-5..23')
92
[-5, 23]
93
>>> _parse_revision_str('-5')
94
[-5]
95
>>> _parse_revision_str('123a')
96
['123a']
97
>>> _parse_revision_str('abc')
98
['abc']
99
"""
100
import re
101
old_format_re = re.compile('\d*:\d*')
102
m = old_format_re.match(revstr)
103
if m:
104
warning('Colon separator for revision numbers is deprecated.'
105
' Use .. instead')
106
revs = []
107
for rev in revstr.split(':'):
108
if rev:
109
revs.append(int(rev))
110
else:
111
revs.append(None)
112
return revs
113
revs = []
114
for x in revstr.split('..'):
115
if not x:
116
revs.append(None)
117
else:
118
try:
119
revs.append(int(x))
120
except ValueError:
121
revs.append(x)
122
return revs
123
124
125
def get_merge_type(typestring):
126
"""Attempt to find the merge class/factory associated with a string."""
127
from merge import merge_types
128
try:
129
return merge_types[typestring][0]
130
except KeyError:
131
templ = '%s%%7s: %%s' % (' '*12)
132
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
133
type_list = '\n'.join(lines)
134
msg = "No known merge type %s. Supported types are:\n%s" %\
135
(typestring, type_list)
136
raise BzrCommandError(msg)
137
138
139
140
def _get_cmd_dict(plugins_override=True):
141
d = {}
142
for k, v in globals().iteritems():
143
if k.startswith("cmd_"):
144
d[_unsquish_command_name(k)] = v
145
# If we didn't load plugins, the plugin_cmds dict will be empty
146
if plugins_override:
147
d.update(plugin_cmds)
148
else:
149
d2 = plugin_cmds.copy()
150
d2.update(d)
151
d = d2
152
return d
153
154
155
def get_all_cmds(plugins_override=True):
156
"""Return canonical name and class for all registered commands."""
157
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
158
yield k,v
159
160
161
def get_cmd_class(cmd, plugins_override=True):
162
"""Return the canonical name and command class for a command.
163
"""
164
cmd = str(cmd) # not unicode
165
166
# first look up this command under the specified name
167
cmds = _get_cmd_dict(plugins_override=plugins_override)
168
try:
169
return cmd, cmds[cmd]
170
except KeyError:
171
pass
172
173
# look for any command which claims this as an alias
174
for cmdname, cmdclass in cmds.iteritems():
175
if cmd in cmdclass.aliases:
176
return cmdname, cmdclass
177
178
cmdclass = ExternalCommand.find_command(cmd)
179
if cmdclass:
180
return cmd, cmdclass
181
182
raise BzrCommandError("unknown command %r" % cmd)
183
184
185
class Command(object):
116
186
"""Base class for commands.
117
187
118
188
The docstring for an actual command should give a single-line
144
214
assert isinstance(arguments, dict)
145
215
cmdargs = options.copy()
146
216
cmdargs.update(arguments)
147
assert self.__doc__ != Command.__doc__, \
148
("No help message set for %r" % self)
217
if self.__doc__ == Command.__doc__:
218
from warnings import warn
219
warn("No help message set for %r" % self)
149
220
self.status = self.run(**cmdargs)
221
if self.status is None:
222
self.status = 0
150
223
151
224
152
225
def run(self):
155
228
This is invoked with the options and arguments bound to
156
229
keyword parameters.
157
230
158
Return True if the command was successful, False if not.
231
Return 0 or None if the command was successful, or a shell
232
error code if not.
159
233
"""
160
return True
161
234
return 0
235
236
237
class ExternalCommand(Command):
238
"""Class to wrap external commands.
239
240
We cheat a little here, when get_cmd_class() calls us we actually give it back
241
an object we construct that has the appropriate path, help, options etc for the
242
specified command.
243
244
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
245
method, which we override to call the Command.__init__ method. That then calls
246
our run method which is pretty straight forward.
247
248
The only wrinkle is that we have to map bzr's dictionary of options and arguments
249
back into command line options and arguments for the script.
250
"""
251
252
def find_command(cls, cmd):
253
import os.path
254
bzrpath = os.environ.get('BZRPATH', '')
255
256
for dir in bzrpath.split(os.pathsep):
257
path = os.path.join(dir, cmd)
258
if os.path.isfile(path):
259
return ExternalCommand(path)
260
261
return None
262
263
find_command = classmethod(find_command)
264
265
def __init__(self, path):
266
self.path = path
267
268
pipe = os.popen('%s --bzr-usage' % path, 'r')
269
self.takes_options = pipe.readline().split()
270
271
for opt in self.takes_options:
272
if not opt in OPTIONS:
273
raise BzrError("Unknown option '%s' returned by external command %s"
274
% (opt, path))
275
276
# TODO: Is there any way to check takes_args is valid here?
277
self.takes_args = pipe.readline().split()
278
279
if pipe.close() is not None:
280
raise BzrError("Failed funning '%s --bzr-usage'" % path)
281
282
pipe = os.popen('%s --bzr-help' % path, 'r')
283
self.__doc__ = pipe.read()
284
if pipe.close() is not None:
285
raise BzrError("Failed funning '%s --bzr-help'" % path)
286
287
def __call__(self, options, arguments):
288
Command.__init__(self, options, arguments)
289
return self
290
291
def run(self, **kargs):
292
opts = []
293
args = []
294
295
keys = kargs.keys()
296
keys.sort()
297
for name in keys:
298
optname = name.replace('_','-')
299
value = kargs[name]
300
if OPTIONS.has_key(optname):
301
# it's an option
302
opts.append('--%s' % optname)
303
if value is not None and value is not True:
304
opts.append(str(value))
305
else:
306
# it's an arg, or arg list
307
if type(value) is not list:
308
value = [value]
309
for v in value:
310
if v is not None:
311
args.append(str(v))
312
313
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
314
return self.status
162
315
163
316
164
317
class cmd_status(Command):
165
318
"""Display status summary.
166
319
167
For each file there is a single line giving its file state and name.
168
The name is that in the current revision unless it is deleted or
169
missing, in which case the old name is shown.
320
This reports on versioned and unknown files, reporting them
321
grouped by state. Possible states are:
322
323
added
324
Versioned in the working copy but not in the previous revision.
325
326
removed
327
Versioned in the previous revision but removed or deleted
328
in the working copy.
329
330
renamed
331
Path of this file changed from the previous revision;
332
the text may also have changed. This includes files whose
333
parent directory was renamed.
334
335
modified
336
Text has changed since the previous revision.
337
338
unchanged
339
Nothing about this file has changed since the previous revision.
340
Only shown with --all.
341
342
unknown
343
Not versioned and not matching an ignore pattern.
344
345
To see ignored files use 'bzr ignored'. For details in the
346
changes to file texts, use 'bzr diff'.
347
348
If no arguments are specified, the status of the entire working
349
directory is shown. Otherwise, only the status of the specified
350
files or directories is reported. If a directory is given, status
351
is reported for everything inside that directory.
352
353
If a revision is specified, the changes since that revision are shown.
170
354
"""
171
takes_options = ['all']
355
takes_args = ['file*']
356
takes_options = ['all', 'show-ids', 'revision']
357
aliases = ['st', 'stat']
172
358
173
def run(self, all=False):
174
#import bzrlib.status
175
#bzrlib.status.tree_status(Branch('.'))
176
Branch('.').show_status(show_all=all)
359
def run(self, all=False, show_ids=False, file_list=None):
360
if file_list:
361
b = find_branch(file_list[0])
362
file_list = [b.relpath(x) for x in file_list]
363
# special case: only one path was given and it's the root
364
# of the branch
365
if file_list == ['']:
366
file_list = None
367
else:
368
b = find_branch('.')
369
370
from bzrlib.status import show_status
371
show_status(b, show_unchanged=all, show_ids=show_ids,
372
specific_files=file_list)
177
373
178
374
179
375
class cmd_cat_revision(Command):
183
379
takes_args = ['revision_id']
184
380
185
381
def run(self, revision_id):
186
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
382
from bzrlib.xml import pack_xml
383
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
187
384
188
385
189
386
class cmd_revno(Command):
191
388
192
389
This is equal to the number of revisions on this branch."""
193
390
def run(self):
194
print Branch('.').revno()
391
print find_branch('.').revno()
392
393
class cmd_revision_info(Command):
394
"""Show revision number and revision id for a given revision identifier.
395
"""
396
hidden = True
397
takes_args = ['revision_info*']
398
takes_options = ['revision']
399
def run(self, revision=None, revision_info_list=None):
400
from bzrlib.branch import find_branch
401
402
revs = []
403
if revision is not None:
404
revs.extend(revision)
405
if revision_info_list is not None:
406
revs.extend(revision_info_list)
407
if len(revs) == 0:
408
raise BzrCommandError('You must supply a revision identifier')
409
410
b = find_branch('.')
411
412
for rev in revs:
413
print '%4d %s' % b.get_revision_info(rev)
195
414
196
415
197
416
class cmd_add(Command):
207
426
whether already versioned or not, are searched for files or
208
427
subdirectories that are neither versioned or ignored, and these
209
428
are added. This search proceeds recursively into versioned
210
directories.
429
directories. If no names are given '.' is assumed.
211
430
212
Therefore simply saying 'bzr add .' will version all files that
431
Therefore simply saying 'bzr add' will version all files that
213
432
are currently unknown.
214
433
215
434
TODO: Perhaps adding a file whose directly is not versioned should
216
435
recursively add that parent, rather than giving an error?
217
436
"""
218
takes_args = ['file+']
219
takes_options = ['verbose']
437
takes_args = ['file*']
438
takes_options = ['verbose', 'no-recurse']
220
439
221
def run(self, file_list, verbose=False):
222
bzrlib.add.smart_add(file_list, verbose)
223
224
225
def Relpath(Command):
440
def run(self, file_list, verbose=False, no_recurse=False):
441
from bzrlib.add import smart_add
442
smart_add(file_list, verbose, not no_recurse)
443
444
445
446
class cmd_mkdir(Command):
447
"""Create a new versioned directory.
448
449
This is equivalent to creating the directory and then adding it.
450
"""
451
takes_args = ['dir+']
452
453
def run(self, dir_list):
454
b = None
455
456
for d in dir_list:
457
os.mkdir(d)
458
if not b:
459
b = find_branch(d)
460
b.add([d], verbose=True)
461
462
463
class cmd_relpath(Command):
226
464
"""Show path of a file relative to root"""
227
takes_args = ('filename')
465
takes_args = ['filename']
466
hidden = True
228
467
229
def run(self):
230
print Branch(self.args['filename']).relpath(filename)
468
def run(self, filename):
469
print find_branch(filename).relpath(filename)
231
470
232
471
233
472
234
473
class cmd_inventory(Command):
235
474
"""Show inventory of the current working copy or a revision."""
236
takes_options = ['revision']
475
takes_options = ['revision', 'show-ids']
237
476
238
def run(self, revision=None):
239
b = Branch('.')
477
def run(self, revision=None, show_ids=False):
478
b = find_branch('.')
240
479
if revision == None:
241
480
inv = b.read_working_inventory()
242
481
else:
243
inv = b.get_revision_inventory(b.lookup_revision(revision))
482
if len(revision) > 1:
483
raise BzrCommandError('bzr inventory --revision takes'
484
' exactly one revision identifier')
485
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
244
486
245
for path, entry in inv.iter_entries():
246
print '%-50s %s' % (entry.file_id, path)
487
for path, entry in inv.entries():
488
if show_ids:
489
print '%-50s %s' % (path, entry.file_id)
490
else:
491
print path
247
492
248
493
249
494
class cmd_move(Command):
256
501
"""
257
502
takes_args = ['source$', 'dest']
258
503
def run(self, source_list, dest):
259
b = Branch('.')
504
b = find_branch('.')
260
505
261
506
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
262
507
278
523
takes_args = ['from_name', 'to_name']
279
524
280
525
def run(self, from_name, to_name):
281
b = Branch('.')
526
b = find_branch('.')
282
527
b.rename_one(b.relpath(from_name), b.relpath(to_name))
283
528
284
529
285
530
531
532
533
class cmd_pull(Command):
534
"""Pull any changes from another branch into the current one.
535
536
If the location is omitted, the last-used location will be used.
537
Both the revision history and the working directory will be
538
updated.
539
540
This command only works on branches that have not diverged. Branches are
541
considered diverged if both branches have had commits without first
542
pulling from the other.
543
544
If branches have diverged, you can use 'bzr merge' to pull the text changes
545
from one into the other.
546
"""
547
takes_args = ['location?']
548
549
def run(self, location=None):
550
from bzrlib.merge import merge
551
import tempfile
552
from shutil import rmtree
553
import errno
554
555
br_to = find_branch('.')
556
stored_loc = None
557
try:
558
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
559
except IOError, e:
560
if e.errno != errno.ENOENT:
561
raise
562
if location is None:
563
if stored_loc is None:
564
raise BzrCommandError("No pull location known or specified.")
565
else:
566
print "Using last location: %s" % stored_loc
567
location = stored_loc
568
cache_root = tempfile.mkdtemp()
569
from bzrlib.branch import DivergedBranches
570
br_from = find_branch(location)
571
location = pull_loc(br_from)
572
old_revno = br_to.revno()
573
try:
574
from branch import find_cached_branch, DivergedBranches
575
br_from = find_cached_branch(location, cache_root)
576
location = pull_loc(br_from)
577
old_revno = br_to.revno()
578
try:
579
br_to.update_revisions(br_from)
580
except DivergedBranches:
581
raise BzrCommandError("These branches have diverged."
582
" Try merge.")
583
584
merge(('.', -1), ('.', old_revno), check_clean=False)
585
if location != stored_loc:
586
br_to.controlfile("x-pull", "wb").write(location + "\n")
587
finally:
588
rmtree(cache_root)
589
590
591
592
class cmd_branch(Command):
593
"""Create a new copy of a branch.
594
595
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
596
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
597
598
To retrieve the branch as of a particular revision, supply the --revision
599
parameter, as in "branch foo/bar -r 5".
600
"""
601
takes_args = ['from_location', 'to_location?']
602
takes_options = ['revision']
603
604
def run(self, from_location, to_location=None, revision=None):
605
import errno
606
from bzrlib.merge import merge
607
from bzrlib.branch import DivergedBranches, NoSuchRevision, \
608
find_cached_branch, Branch
609
from shutil import rmtree
610
from meta_store import CachedStore
611
import tempfile
612
cache_root = tempfile.mkdtemp()
613
614
if revision is None:
615
revision = [None]
616
elif len(revision) > 1:
617
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
618
619
try:
620
try:
621
br_from = find_cached_branch(from_location, cache_root)
622
except OSError, e:
623
if e.errno == errno.ENOENT:
624
raise BzrCommandError('Source location "%s" does not'
625
' exist.' % to_location)
626
else:
627
raise
628
629
if to_location is None:
630
to_location = os.path.basename(from_location.rstrip("/\\"))
631
632
try:
633
os.mkdir(to_location)
634
except OSError, e:
635
if e.errno == errno.EEXIST:
636
raise BzrCommandError('Target directory "%s" already'
637
' exists.' % to_location)
638
if e.errno == errno.ENOENT:
639
raise BzrCommandError('Parent of "%s" does not exist.' %
640
to_location)
641
else:
642
raise
643
br_to = Branch(to_location, init=True)
644
645
br_to.set_root_id(br_from.get_root_id())
646
647
if revision:
648
if revision[0] is None:
649
revno = br_from.revno()
650
else:
651
revno, rev_id = br_from.get_revision_info(revision[0])
652
try:
653
br_to.update_revisions(br_from, stop_revision=revno)
654
except NoSuchRevision:
655
rmtree(to_location)
656
msg = "The branch %s has no revision %d." % (from_location,
657
revno)
658
raise BzrCommandError(msg)
659
660
merge((to_location, -1), (to_location, 0), this_dir=to_location,
661
check_clean=False, ignore_zero=True)
662
from_location = pull_loc(br_from)
663
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
664
finally:
665
rmtree(cache_root)
666
667
668
def pull_loc(branch):
669
# TODO: Should perhaps just make attribute be 'base' in
670
# RemoteBranch and Branch?
671
if hasattr(branch, "baseurl"):
672
return branch.baseurl
673
else:
674
return branch.base
675
676
677
286
678
class cmd_renames(Command):
287
679
"""Show list of renamed files.
288
680
293
685
takes_args = ['dir?']
294
686
295
687
def run(self, dir='.'):
296
b = Branch(dir)
688
b = find_branch(dir)
297
689
old_inv = b.basis_tree().inventory
298
690
new_inv = b.read_working_inventory()
299
691
304
696
305
697
306
698
class cmd_info(Command):
307
"""Show statistical information for this branch"""
308
def run(self):
699
"""Show statistical information about a branch."""
700
takes_args = ['branch?']
701
702
def run(self, branch=None):
309
703
import info
310
info.show_info(Branch('.'))
704
705
b = find_branch(branch)
706
info.show_info(b)
311
707
312
708
313
709
class cmd_remove(Command):
320
716
takes_options = ['verbose']
321
717
322
718
def run(self, file_list, verbose=False):
323
b = Branch(file_list[0])
719
b = find_branch(file_list[0])
324
720
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
325
721
326
722
334
730
hidden = True
335
731
takes_args = ['filename']
336
732
def run(self, filename):
337
b = Branch(filename)
733
b = find_branch(filename)
338
734
i = b.inventory.path2id(b.relpath(filename))
339
735
if i == None:
340
bailout("%r is not a versioned file" % filename)
736
raise BzrError("%r is not a versioned file" % filename)
341
737
else:
342
738
print i
343
739
350
746
hidden = True
351
747
takes_args = ['filename']
352
748
def run(self, filename):
353
b = Branch(filename)
749
b = find_branch(filename)
354
750
inv = b.inventory
355
751
fid = inv.path2id(b.relpath(filename))
356
752
if fid == None:
357
bailout("%r is not a versioned file" % filename)
753
raise BzrError("%r is not a versioned file" % filename)
358
754
for fip in inv.get_idpath(fid):
359
755
print fip
360
756
361
757
362
758
class cmd_revision_history(Command):
363
759
"""Display list of revision ids on this branch."""
760
hidden = True
364
761
def run(self):
365
for patchid in Branch('.').revision_history():
762
for patchid in find_branch('.').revision_history():
366
763
print patchid
367
764
368
765
369
766
class cmd_directories(Command):
370
767
"""Display list of versioned directories in this branch."""
371
768
def run(self):
372
for name, ie in Branch('.').read_working_inventory().directories():
769
for name, ie in find_branch('.').read_working_inventory().directories():
373
770
if name == '':
374
771
print '.'
375
772
else:
390
787
bzr commit -m 'imported project'
391
788
"""
392
789
def run(self):
790
from bzrlib.branch import Branch
393
791
Branch('.', init=True)
394
792
395
793
418
816
"""
419
817
420
818
takes_args = ['file*']
421
takes_options = ['revision']
819
takes_options = ['revision', 'diff-options']
820
aliases = ['di', 'dif']
422
821
423
def run(self, revision=None, file_list=None):
822
def run(self, revision=None, file_list=None, diff_options=None):
424
823
from bzrlib.diff import show_diff
824
825
if file_list:
826
b = find_branch(file_list[0])
827
file_list = [b.relpath(f) for f in file_list]
828
if file_list == ['']:
829
# just pointing to top-of-tree
830
file_list = None
831
else:
832
b = find_branch('.')
833
834
# TODO: Make show_diff support taking 2 arguments
835
base_rev = None
836
if revision is not None:
837
if len(revision) != 1:
838
raise BzrCommandError('bzr diff --revision takes exactly one revision identifier')
839
base_rev = revision[0]
425
840
426
show_diff(Branch('.'), revision, file_list)
841
show_diff(b, base_rev, specific_files=file_list,
842
external_diff_options=diff_options)
843
844
845
427
846
428
847
429
848
class cmd_deleted(Command):
432
851
TODO: Show files deleted since a previous revision, or between two revisions.
433
852
"""
434
853
def run(self, show_ids=False):
435
b = Branch('.')
854
b = find_branch('.')
436
855
old = b.basis_tree()
437
856
new = b.working_tree()
438
857
448
867
else:
449
868
print path
450
869
870
871
class cmd_modified(Command):
872
"""List files modified in working tree."""
873
hidden = True
874
def run(self):
875
from bzrlib.diff import compare_trees
876
877
b = find_branch('.')
878
td = compare_trees(b.basis_tree(), b.working_tree())
879
880
for path, id, kind in td.modified:
881
print path
882
883
884
885
class cmd_added(Command):
886
"""List files added in working tree."""
887
hidden = True
888
def run(self):
889
b = find_branch('.')
890
wt = b.working_tree()
891
basis_inv = b.basis_tree().inventory
892
inv = wt.inventory
893
for file_id in inv:
894
if file_id in basis_inv:
895
continue
896
path = inv.id2path(file_id)
897
if not os.access(b.abspath(path), os.F_OK):
898
continue
899
print path
900
901
902
451
903
class cmd_root(Command):
452
904
"""Show the tree root directory.
453
905
456
908
takes_args = ['filename?']
457
909
def run(self, filename=None):
458
910
"""Print the branch root."""
459
print bzrlib.branch.find_branch_root(filename)
460
911
b = find_branch(filename)
912
print getattr(b, 'base', None) or getattr(b, 'baseurl')
461
913
462
914
463
915
class cmd_log(Command):
464
916
"""Show log of this branch.
465
917
466
TODO: Options to show ids; to limit range; etc.
918
To request a range of logs, you can use the command -r begin:end
919
-r revision requests a specific revision, -r :end or -r begin: are
920
also valid.
921
922
--message allows you to give a regular expression, which will be evaluated
923
so that only matching entries will be displayed.
924
925
TODO: Make --revision support uuid: and hash: [future tag:] notation.
926
467
927
"""
468
takes_options = ['timezone', 'verbose']
469
def run(self, timezone='original', verbose=False):
470
Branch('.').write_log(show_timezone=timezone, verbose=verbose)
928
929
takes_args = ['filename?']
930
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long', 'message']
931
932
def run(self, filename=None, timezone='original',
933
verbose=False,
934
show_ids=False,
935
forward=False,
936
revision=None,
937
message=None,
938
long=False):
939
from bzrlib.branch import find_branch
940
from bzrlib.log import log_formatter, show_log
941
import codecs
942
943
direction = (forward and 'forward') or 'reverse'
944
945
if filename:
946
b = find_branch(filename)
947
fp = b.relpath(filename)
948
if fp:
949
file_id = b.read_working_inventory().path2id(fp)
950
else:
951
file_id = None # points to branch root
952
else:
953
b = find_branch('.')
954
file_id = None
955
956
if revision is None:
957
rev1 = None
958
rev2 = None
959
elif len(revision) == 1:
960
rev1 = rev2 = b.get_revision_info(revision[0])[0]
961
elif len(revision) == 2:
962
rev1 = b.get_revision_info(revision[0])[0]
963
rev2 = b.get_revision_info(revision[1])[0]
964
else:
965
raise BzrCommandError('bzr log --revision takes one or two values.')
966
967
if rev1 == 0:
968
rev1 = None
969
if rev2 == 0:
970
rev2 = None
971
972
mutter('encoding log as %r' % bzrlib.user_encoding)
973
974
# use 'replace' so that we don't abort if trying to write out
975
# in e.g. the default C locale.
976
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
977
978
if long:
979
log_format = 'long'
980
else:
981
log_format = 'short'
982
lf = log_formatter(log_format,
983
show_ids=show_ids,
984
to_file=outf,
985
show_timezone=timezone)
986
987
show_log(b,
988
lf,
989
file_id,
990
verbose=verbose,
991
direction=direction,
992
start_revision=rev1,
993
end_revision=rev2,
994
search=message)
995
996
997
998
class cmd_touching_revisions(Command):
999
"""Return revision-ids which affected a particular file.
1000
1001
A more user-friendly interface is "bzr log FILE"."""
1002
hidden = True
1003
takes_args = ["filename"]
1004
def run(self, filename):
1005
b = find_branch(filename)
1006
inv = b.read_working_inventory()
1007
file_id = inv.path2id(b.relpath(filename))
1008
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1009
print "%6d %s" % (revno, what)
471
1010
472
1011
473
1012
class cmd_ls(Command):
477
1016
"""
478
1017
hidden = True
479
1018
def run(self, revision=None, verbose=False):
480
b = Branch('.')
1019
b = find_branch('.')
481
1020
if revision == None:
482
1021
tree = b.working_tree()
483
1022
else:
499
1038
500
1039
501
1040
class cmd_unknowns(Command):
502
"""List unknown files"""
1041
"""List unknown files."""
503
1042
def run(self):
504
for f in Branch('.').unknowns():
1043
from bzrlib.osutils import quotefn
1044
for f in find_branch('.').unknowns():
505
1045
print quotefn(f)
506
1046
507
1047
508
1048
509
1049
class cmd_ignore(Command):
510
"""Ignore a command or pattern"""
1050
"""Ignore a command or pattern.
1051
1052
To remove patterns from the ignore list, edit the .bzrignore file.
1053
1054
If the pattern contains a slash, it is compared to the whole path
1055
from the branch root. Otherwise, it is comapred to only the last
1056
component of the path.
1057
1058
Ignore patterns are case-insensitive on case-insensitive systems.
1059
1060
Note: wildcards must be quoted from the shell on Unix.
1061
1062
examples:
1063
bzr ignore ./Makefile
1064
bzr ignore '*.class'
1065
"""
511
1066
takes_args = ['name_pattern']
512
1067
513
1068
def run(self, name_pattern):
514
b = Branch('.')
515
516
# XXX: This will fail if it's a hardlink; should use an AtomicFile class.
517
f = open(b.abspath('.bzrignore'), 'at')
518
f.write(name_pattern + '\n')
519
f.close()
1069
from bzrlib.atomicfile import AtomicFile
1070
import os.path
1071
1072
b = find_branch('.')
1073
ifn = b.abspath('.bzrignore')
1074
1075
if os.path.exists(ifn):
1076
f = open(ifn, 'rt')
1077
try:
1078
igns = f.read().decode('utf-8')
1079
finally:
1080
f.close()
1081
else:
1082
igns = ''
1083
1084
# TODO: If the file already uses crlf-style termination, maybe
1085
# we should use that for the newly added lines?
1086
1087
if igns and igns[-1] != '\n':
1088
igns += '\n'
1089
igns += name_pattern + '\n'
1090
1091
try:
1092
f = AtomicFile(ifn, 'wt')
1093
f.write(igns.encode('utf-8'))
1094
f.commit()
1095
finally:
1096
f.close()
520
1097
521
1098
inv = b.working_tree().inventory
522
1099
if inv.path2id('.bzrignore'):
528
1105
529
1106
530
1107
class cmd_ignored(Command):
531
"""List ignored files and the patterns that matched them."""
1108
"""List ignored files and the patterns that matched them.
1109
1110
See also: bzr ignore"""
532
1111
def run(self):
533
tree = Branch('.').working_tree()
1112
tree = find_branch('.').working_tree()
534
1113
for path, file_class, kind, file_id in tree.list_files():
535
1114
if file_class != 'I':
536
1115
continue
544
1123
545
1124
example:
546
1125
bzr lookup-revision 33
547
"""
1126
"""
548
1127
hidden = True
1128
takes_args = ['revno']
1129
549
1130
def run(self, revno):
550
1131
try:
551
1132
revno = int(revno)
552
1133
except ValueError:
553
raise BzrError("not a valid revision-number: %r" % revno)
554
555
print Branch('.').lookup_revision(revno) or NONE_STRING
556
1134
raise BzrCommandError("not a valid revision-number: %r" % revno)
1135
1136
print find_branch('.').lookup_revision(revno)
557
1137
558
1138
559
1139
class cmd_export(Command):
560
1140
"""Export past revision to destination directory.
561
1141
562
If no revision is specified this exports the last committed revision."""
1142
If no revision is specified this exports the last committed revision.
1143
1144
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1145
given, try to find the format with the extension. If no extension
1146
is found exports to a directory (equivalent to --format=dir).
1147
1148
Root may be the top directory for tar, tgz and tbz2 formats. If none
1149
is given, the top directory will be the root name of the file."""
1150
# TODO: list known exporters
563
1151
takes_args = ['dest']
564
takes_options = ['revision']
565
def run(self, dest, revno=None):
566
b = Branch('.')
567
if revno == None:
568
rh = b.revision_history[-1]
1152
takes_options = ['revision', 'format', 'root']
1153
def run(self, dest, revision=None, format=None, root=None):
1154
import os.path
1155
b = find_branch('.')
1156
if revision is None:
1157
rev_id = b.last_patch()
569
1158
else:
570
rh = b.lookup_revision(int(revno))
571
t = b.revision_tree(rh)
572
t.export(dest)
1159
if len(revision) != 1:
1160
raise BzrError('bzr export --revision takes exactly 1 argument')
1161
revno, rev_id = b.get_revision_info(revision[0])
1162
t = b.revision_tree(rev_id)
1163
root, ext = os.path.splitext(dest)
1164
if not format:
1165
if ext in (".tar",):
1166
format = "tar"
1167
elif ext in (".gz", ".tgz"):
1168
format = "tgz"
1169
elif ext in (".bz2", ".tbz2"):
1170
format = "tbz2"
1171
else:
1172
format = "dir"
1173
t.export(dest, format, root)
573
1174
574
1175
575
1176
class cmd_cat(Command):
581
1182
def run(self, filename, revision=None):
582
1183
if revision == None:
583
1184
raise BzrCommandError("bzr cat requires a revision number")
584
b = Branch('.')
585
b.print_file(b.relpath(filename), int(revision))
1185
elif len(revision) != 1:
1186
raise BzrCommandError("bzr cat --revision takes exactly one number")
1187
b = find_branch('.')
1188
b.print_file(b.relpath(filename), revision[0])
586
1189
587
1190
588
1191
class cmd_local_time_offset(Command):
596
1199
class cmd_commit(Command):
597
1200
"""Commit changes into a new revision.
598
1201
599
TODO: Commit only selected files.
1202
If selected files are specified, only changes to those files are
1203
committed. If a directory is specified then its contents are also
1204
committed.
1205
1206
A selected-file commit may fail in some cases where the committed
1207
tree would be invalid, such as trying to commit a file in a
1208
newly-added directory that is not itself committed.
600
1209
601
1210
TODO: Run hooks on tree to-be-committed, and after commit.
602
1211
603
1212
TODO: Strict commit that fails if there are unknown or deleted files.
604
1213
"""
605
takes_options = ['message', 'verbose']
606
607
def run(self, message=None, verbose=False):
608
if not message:
609
raise BzrCommandError("please specify a commit message")
610
Branch('.').commit(message, verbose=verbose)
1214
takes_args = ['selected*']
1215
takes_options = ['message', 'file', 'verbose', 'unchanged']
1216
aliases = ['ci', 'checkin']
1217
1218
def run(self, message=None, file=None, verbose=True, selected_list=None,
1219
unchanged=False):
1220
from bzrlib.errors import PointlessCommit
1221
from bzrlib.osutils import get_text_message
1222
1223
## Warning: shadows builtin file()
1224
if not message and not file:
1225
import cStringIO
1226
stdout = sys.stdout
1227
catcher = cStringIO.StringIO()
1228
sys.stdout = catcher
1229
cmd_status({"file_list":selected_list}, {})
1230
info = catcher.getvalue()
1231
sys.stdout = stdout
1232
message = get_text_message(info)
1233
1234
if message is None:
1235
raise BzrCommandError("please specify a commit message",
1236
["use either --message or --file"])
1237
elif message and file:
1238
raise BzrCommandError("please specify either --message or --file")
1239
1240
if file:
1241
import codecs
1242
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1243
1244
b = find_branch('.')
1245
1246
try:
1247
b.commit(message, verbose=verbose,
1248
specific_files=selected_list,
1249
allow_pointless=unchanged)
1250
except PointlessCommit:
1251
# FIXME: This should really happen before the file is read in;
1252
# perhaps prepare the commit; get the message; then actually commit
1253
raise BzrCommandError("no changes to commit",
1254
["use --unchanged to commit anyhow"])
611
1255
612
1256
613
1257
class cmd_check(Command):
615
1259
616
1260
This command checks various invariants about the branch storage to
617
1261
detect data corruption or bzr bugs.
618
"""
619
takes_args = ['dir?']
620
def run(self, dir='.'):
621
import bzrlib.check
622
bzrlib.check.check(Branch(dir, find_root=False))
1262
1263
If given the --update flag, it will update some optional fields
1264
to help ensure data consistency.
1265
"""
1266
takes_args = ['dir?']
1267
1268
def run(self, dir='.'):
1269
from bzrlib.check import check
1270
check(find_branch(dir))
1271
1272
1273
1274
class cmd_scan_cache(Command):
1275
hidden = True
1276
def run(self):
1277
from bzrlib.hashcache import HashCache
1278
import os
1279
1280
c = HashCache('.')
1281
c.read()
1282
c.scan()
1283
1284
print '%6d stats' % c.stat_count
1285
print '%6d in hashcache' % len(c._cache)
1286
print '%6d files removed from cache' % c.removed_count
1287
print '%6d hashes updated' % c.update_count
1288
print '%6d files changed too recently to cache' % c.danger_count
1289
1290
if c.needs_write:
1291
c.write()
1292
1293
1294
1295
class cmd_upgrade(Command):
1296
"""Upgrade branch storage to current format.
1297
1298
This should normally be used only after the check command tells
1299
you to run it.
1300
"""
1301
takes_args = ['dir?']
1302
1303
def run(self, dir='.'):
1304
from bzrlib.upgrade import upgrade
1305
upgrade(find_branch(dir))
623
1306
624
1307
625
1308
637
1320
class cmd_selftest(Command):
638
1321
"""Run internal test suite"""
639
1322
hidden = True
640
def run(self):
641
failures, tests = 0, 0
642
643
import doctest, bzrlib.store, bzrlib.tests
644
bzrlib.trace.verbose = False
645
646
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
647
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
648
mf, mt = doctest.testmod(m)
649
failures += mf
650
tests += mt
651
print '%-40s %3d tests' % (m.__name__, mt),
652
if mf:
653
print '%3d FAILED!' % mf
654
else:
655
print
656
657
print '%-40s %3d tests' % ('total', tests),
658
if failures:
659
print '%3d FAILED!' % failures
660
else:
661
print
662
1323
takes_options = ['verbose']
1324
def run(self, verbose=False):
1325
from bzrlib.selftest import selftest
1326
return int(not selftest(verbose=verbose))
663
1327
664
1328
665
1329
class cmd_version(Command):
666
"""Show version of bzr"""
1330
"""Show version of bzr."""
667
1331
def run(self):
668
1332
show_version()
669
1333
670
1334
def show_version():
671
1335
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1336
# is bzrlib itself in a branch?
1337
bzrrev = bzrlib.get_bzr_revision()
1338
if bzrrev:
1339
print " (bzr checkout, revision %d {%s})" % bzrrev
672
1340
print bzrlib.__copyright__
673
1341
print "http://bazaar-ng.org/"
674
1342
print
683
1351
def run(self):
684
1352
print "it sure does!"
685
1353
1354
def parse_spec(spec):
1355
"""
1356
>>> parse_spec(None)
1357
[None, None]
1358
>>> parse_spec("./")
1359
['./', None]
1360
>>> parse_spec("../@")
1361
['..', -1]
1362
>>> parse_spec("../f/@35")
1363
['../f', 35]
1364
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1365
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1366
"""
1367
if spec is None:
1368
return [None, None]
1369
if '/@' in spec:
1370
parsed = spec.split('/@')
1371
assert len(parsed) == 2
1372
if parsed[1] == "":
1373
parsed[1] = -1
1374
else:
1375
try:
1376
parsed[1] = int(parsed[1])
1377
except ValueError:
1378
pass # We can allow stuff like ./@revid:blahblahblah
1379
else:
1380
assert parsed[1] >=0
1381
else:
1382
parsed = [spec, None]
1383
return parsed
1384
1385
1386
1387
class cmd_merge(Command):
1388
"""Perform a three-way merge of trees.
1389
1390
The SPEC parameters are working tree or revision specifiers. Working trees
1391
are specified using standard paths or urls. No component of a directory
1392
path may begin with '@'.
1393
1394
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1395
1396
Revisions are specified using a dirname/@revno pair, where dirname is the
1397
branch directory and revno is the revision within that branch. If no revno
1398
is specified, the latest revision is used.
1399
1400
Revision examples: './@127', 'foo/@', '../@1'
1401
1402
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1403
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1404
as the BASE.
1405
1406
merge refuses to run if there are any uncommitted changes, unless
1407
--force is given.
1408
"""
1409
takes_args = ['other_spec', 'base_spec?']
1410
takes_options = ['force', 'merge-type']
1411
1412
def run(self, other_spec, base_spec=None, force=False, merge_type=None):
1413
from bzrlib.merge import merge
1414
from bzrlib.merge_core import ApplyMerge3
1415
if merge_type is None:
1416
merge_type = ApplyMerge3
1417
merge(parse_spec(other_spec), parse_spec(base_spec),
1418
check_clean=(not force), merge_type=merge_type)
1419
1420
1421
class cmd_revert(Command):
1422
"""Reverse all changes since the last commit.
1423
1424
Only versioned files are affected. Specify filenames to revert only
1425
those files. By default, any files that are changed will be backed up
1426
first. Backup files have a '~' appended to their name.
1427
"""
1428
takes_options = ['revision', 'no-backup']
1429
takes_args = ['file*']
1430
aliases = ['merge-revert']
1431
1432
def run(self, revision=None, no_backup=False, file_list=None):
1433
from bzrlib.merge import merge
1434
if file_list is not None:
1435
if len(file_list) == 0:
1436
raise BzrCommandError("No files specified")
1437
if revision is None:
1438
revision = [-1]
1439
elif len(revision) != 1:
1440
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1441
merge(('.', revision[0]), parse_spec('.'),
1442
check_clean=False,
1443
ignore_zero=True,
1444
backup_files=not no_backup,
1445
file_list=file_list)
1446
686
1447
687
1448
class cmd_assert_fail(Command):
688
1449
"""Test reporting of assertion failures"""
696
1457
697
1458
For a list of all available commands, say 'bzr help commands'."""
698
1459
takes_args = ['topic?']
1460
aliases = ['?']
699
1461
700
1462
def run(self, topic=None):
701
help(topic)
702
703
704
def help(topic=None):
705
if topic == None:
706
print __doc__
707
elif topic == 'commands':
708
help_commands()
709
else:
710
help_on_command(topic)
711
712
713
def help_on_command(cmdname):
714
cmdname = str(cmdname)
715
716
from inspect import getdoc
717
topic, cmdclass = get_cmd_class(cmdname)
718
719
doc = getdoc(cmdclass)
720
if doc == None:
721
raise NotImplementedError("sorry, no detailed help yet for %r" % cmdname)
722
723
if '\n' in doc:
724
short, rest = doc.split('\n', 1)
725
else:
726
short = doc
727
rest = ''
728
729
print 'usage: bzr ' + topic,
730
for aname in cmdclass.takes_args:
731
aname = aname.upper()
732
if aname[-1] in ['$', '+']:
733
aname = aname[:-1] + '...'
734
elif aname[-1] == '?':
735
aname = '[' + aname[:-1] + ']'
736
elif aname[-1] == '*':
737
aname = '[' + aname[:-1] + '...]'
738
print aname,
739
print
740
print short
741
if rest:
742
print rest
743
744
help_on_option(cmdclass.takes_options)
745
746
747
def help_on_option(options):
748
if not options:
749
return
750
751
print
752
print 'options:'
753
for on in options:
754
l = ' --' + on
755
for shortname, longname in SHORT_OPTIONS.items():
756
if longname == on:
757
l += ', -' + shortname
758
break
759
print l
760
761
762
def help_commands():
763
"""List all commands"""
764
import inspect
765
766
accu = []
767
for k, v in globals().items():
768
if k.startswith('cmd_'):
769
accu.append((k[4:].replace('_','-'), v))
770
accu.sort()
771
for cmdname, cmdclass in accu:
772
if cmdclass.hidden:
773
continue
774
print cmdname
775
help = inspect.getdoc(cmdclass)
776
if help:
777
print " " + help.split('\n', 1)[0]
778
779
780
######################################################################
781
# main routine
1463
import help
1464
help.help(topic)
1465
1466
1467
1468
1469
class cmd_plugins(Command):
1470
"""List plugins"""
1471
hidden = True
1472
def run(self):
1473
import bzrlib.plugin
1474
from inspect import getdoc
1475
from pprint import pprint
1476
for plugin in bzrlib.plugin.all_plugins:
1477
print plugin.__path__[0]
1478
d = getdoc(plugin)
1479
if d:
1480
print '\t', d.split('\n')[0]
1481
1482
#pprint(bzrlib.plugin.all_plugins)
1483
782
1484
783
1485
784
1486
# list of all available options; the rhs can be either None for an
786
1488
# the type.
787
1489
OPTIONS = {
788
1490
'all': None,
1491
'diff-options': str,
789
1492
'help': None,
1493
'file': unicode,
1494
'force': None,
1495
'format': unicode,
1496
'forward': None,
790
1497
'message': unicode,
1498
'no-recurse': None,
791
1499
'profile': None,
792
'revision': int,
1500
'revision': _parse_revision_str,
793
1501
'show-ids': None,
794
1502
'timezone': str,
795
1503
'verbose': None,
796
1504
'version': None,
797
1505
'email': None,
1506
'unchanged': None,
1507
'update': None,
1508
'long': None,
1509
'root': str,
1510
'no-backup': None,
1511
'merge-type': get_merge_type,
798
1512
}
799
1513
800
1514
SHORT_OPTIONS = {
1515
'F': 'file',
1516
'h': 'help',
801
1517
'm': 'message',
802
1518
'r': 'revision',
803
1519
'v': 'verbose',
1520
'l': 'long',
804
1521
}
805
1522
806
1523
820
1537
(['status'], {'all': True})
821
1538
>>> parse_args('commit --message=biter'.split())
822
1539
(['commit'], {'message': u'biter'})
1540
>>> parse_args('log -r 500'.split())
1541
(['log'], {'revision': [500]})
1542
>>> parse_args('log -r500..600'.split())
1543
(['log'], {'revision': [500, 600]})
1544
>>> parse_args('log -vr500..600'.split())
1545
(['log'], {'verbose': True, 'revision': [500, 600]})
1546
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1547
(['log'], {'revision': ['v500', 600]})
823
1548
"""
824
1549
args = []
825
1550
opts = {}
839
1564
else:
840
1565
optname = a[2:]
841
1566
if optname not in OPTIONS:
842
bailout('unknown long option %r' % a)
1567
raise BzrError('unknown long option %r' % a)
843
1568
else:
844
1569
shortopt = a[1:]
845
if shortopt not in SHORT_OPTIONS:
846
bailout('unknown short option %r' % a)
847
optname = SHORT_OPTIONS[shortopt]
1570
if shortopt in SHORT_OPTIONS:
1571
# Multi-character options must have a space to delimit
1572
# their value
1573
optname = SHORT_OPTIONS[shortopt]
1574
else:
1575
# Single character short options, can be chained,
1576
# and have their value appended to their name
1577
shortopt = a[1:2]
1578
if shortopt not in SHORT_OPTIONS:
1579
# We didn't find the multi-character name, and we
1580
# didn't find the single char name
1581
raise BzrError('unknown short option %r' % a)
1582
optname = SHORT_OPTIONS[shortopt]
1583
1584
if a[2:]:
1585
# There are extra things on this option
1586
# see if it is the value, or if it is another
1587
# short option
1588
optargfn = OPTIONS[optname]
1589
if optargfn is None:
1590
# This option does not take an argument, so the
1591
# next entry is another short option, pack it back
1592
# into the list
1593
argv.insert(0, '-' + a[2:])
1594
else:
1595
# This option takes an argument, so pack it
1596
# into the array
1597
optarg = a[2:]
848
1598
849
1599
if optname in opts:
850
1600
# XXX: Do we ever want to support this, e.g. for -r?
851
bailout('repeated option %r' % a)
1601
raise BzrError('repeated option %r' % a)
852
1602
853
1603
optargfn = OPTIONS[optname]
854
1604
if optargfn:
855
1605
if optarg == None:
856
1606
if not argv:
857
bailout('option %r needs an argument' % a)
1607
raise BzrError('option %r needs an argument' % a)
858
1608
else:
859
1609
optarg = argv.pop(0)
860
1610
opts[optname] = optargfn(optarg)
861
1611
else:
862
1612
if optarg != None:
863
bailout('option %r takes no argument' % optname)
1613
raise BzrError('option %r takes no argument' % optname)
864
1614
opts[optname] = True
865
1615
else:
866
1616
args.append(a)
914
1664
return argdict
915
1665
916
1666
1667
def _parse_master_args(argv):
1668
"""Parse the arguments that always go with the original command.
1669
These are things like bzr --no-plugins, etc.
1670
1671
There are now 2 types of option flags. Ones that come *before* the command,
1672
and ones that come *after* the command.
1673
Ones coming *before* the command are applied against all possible commands.
1674
And are generally applied before plugins are loaded.
1675
1676
The current list are:
1677
--builtin Allow plugins to load, but don't let them override builtin commands,
1678
they will still be allowed if they do not override a builtin.
1679
--no-plugins Don't load any plugins. This lets you get back to official source
1680
behavior.
1681
--profile Enable the hotspot profile before running the command.
1682
For backwards compatibility, this is also a non-master option.
1683
--version Spit out the version of bzr that is running and exit.
1684
This is also a non-master option.
1685
--help Run help and exit, also a non-master option (I think that should stay, though)
1686
1687
>>> argv, opts = _parse_master_args(['--test'])
1688
Traceback (most recent call last):
1689
...
1690
BzrCommandError: Invalid master option: 'test'
1691
>>> argv, opts = _parse_master_args(['--version', 'command'])
1692
>>> print argv
1693
['command']
1694
>>> print opts['version']
1695
True
1696
>>> argv, opts = _parse_master_args(['--profile', 'command', '--more-options'])
1697
>>> print argv
1698
['command', '--more-options']
1699
>>> print opts['profile']
1700
True
1701
>>> argv, opts = _parse_master_args(['--no-plugins', 'command'])
1702
>>> print argv
1703
['command']
1704
>>> print opts['no-plugins']
1705
True
1706
>>> print opts['profile']
1707
False
1708
>>> argv, opts = _parse_master_args(['command', '--profile'])
1709
>>> print argv
1710
['command', '--profile']
1711
>>> print opts['profile']
1712
False
1713
"""
1714
master_opts = {'builtin':False,
1715
'no-plugins':False,
1716
'version':False,
1717
'profile':False,
1718
'help':False
1719
}
1720
1721
for arg in argv[:]:
1722
if arg[:2] != '--': # at the first non-option, we return the rest
1723
break
1724
arg = arg[2:] # Remove '--'
1725
if arg not in master_opts:
1726
# We could say that this is not an error, that we should
1727
# just let it be handled by the main section instead
1728
raise BzrCommandError('Invalid master option: %r' % arg)
1729
argv.pop(0) # We are consuming this entry
1730
master_opts[arg] = True
1731
return argv, master_opts
1732
1733
917
1734
918
1735
def run_bzr(argv):
919
1736
"""Execute a command.
920
1737
921
1738
This is similar to main(), but without all the trappings for
922
1739
logging and error handling.
1740
1741
argv
1742
The command-line arguments, without the program name.
1743
1744
Returns a command status or raises an exception.
923
1745
"""
924
925
1746
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1747
1748
# some options like --builtin and --no-plugins have special effects
1749
argv, master_opts = _parse_master_args(argv)
1750
if not master_opts['no-plugins']:
1751
from bzrlib.plugin import load_plugins
1752
load_plugins()
1753
1754
args, opts = parse_args(argv)
1755
1756
if master_opts.get('help') or 'help' in opts:
1757
from bzrlib.help import help
1758
if argv:
1759
help(argv[0])
1760
else:
1761
help()
1762
return 0
1763
1764
if 'version' in opts:
1765
show_version()
1766
return 0
1767
1768
if args and args[0] == 'builtin':
1769
include_plugins=False
1770
args = args[1:]
926
1771
927
1772
try:
928
args, opts = parse_args(argv[1:])
929
if 'help' in opts:
930
if args:
931
help(args[0])
932
else:
933
help()
934
return 0
935
elif 'version' in opts:
936
cmd_version([], [])
937
return 0
938
1773
cmd = str(args.pop(0))
939
1774
except IndexError:
940
log_error('usage: bzr COMMAND')
941
log_error(' try "bzr help"')
1775
print >>sys.stderr, "please try 'bzr help' for help"
942
1776
return 1
943
1777
944
canonical_cmd, cmd_class = get_cmd_class(cmd)
1778
plugins_override = not (master_opts['builtin'])
1779
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
945
1780
946
# global option
1781
profile = master_opts['profile']
1782
# For backwards compatibility, I would rather stick with --profile being a
1783
# master/global option
947
1784
if 'profile' in opts:
948
1785
profile = True
949
1786
del opts['profile']
950
else:
951
profile = False
952
1787
953
1788
# check options are reasonable
954
1789
allowed = cmd_class.takes_options
955
1790
for oname in opts:
956
1791
if oname not in allowed:
957
raise BzrCommandError("option %r is not allowed for command %r"
1792
raise BzrCommandError("option '--%s' is not allowed for command %r"
958
1793
% (oname, cmd))
959
1794
960
1795
# mix arguments and options into one dictionary
964
1799
cmdopts[k.replace('-', '_')] = v
965
1800
966
1801
if profile:
967
import hotshot
1802
import hotshot, tempfile
968
1803
pffileno, pfname = tempfile.mkstemp()
969
1804
try:
970
1805
prof = hotshot.Profile(pfname)
979
1814
## print_stats seems hardcoded to stdout
980
1815
stats.print_stats(20)
981
1816
982
return ret
1817
return ret.status
983
1818
984
1819
finally:
985
1820
os.close(pffileno)
986
1821
os.remove(pfname)
987
1822
else:
988
cmdobj = cmd_class(cmdopts, cmdargs) or 0
989
990
991
992
def _report_exception(e, summary, quiet=False):
1823
return cmd_class(cmdopts, cmdargs).status
1824
1825
1826
def _report_exception(summary, quiet=False):
993
1827
import traceback
994
1828
log_error('bzr: ' + summary)
995
bzrlib.trace.log_exception(e)
1829
bzrlib.trace.log_exception()
996
1830
997
1831
if not quiet:
998
1832
tb = sys.exc_info()[2]
1004
1838
1005
1839
1006
1840
def main(argv):
1007
import errno
1008
1841
1009
bzrlib.trace.create_tracefile(argv)
1842
bzrlib.trace.open_tracefile(argv)
1010
1843
1011
1844
try:
1012
1845
try:
1013
ret = run_bzr(argv)
1014
# do this here to catch EPIPE
1015
sys.stdout.flush()
1016
return ret
1846
try:
1847
return run_bzr(argv[1:])
1848
finally:
1849
# do this here inside the exception wrappers to catch EPIPE
1850
sys.stdout.flush()
1017
1851
except BzrError, e:
1018
1852
quiet = isinstance(e, (BzrCommandError))
1019
_report_exception(e, 'error: ' + e.args[0], quiet=quiet)
1853
_report_exception('error: ' + e.args[0], quiet=quiet)
1020
1854
if len(e.args) > 1:
1021
1855
for h in e.args[1]:
1022
1856
# some explanation or hints
1026
1860
msg = 'assertion failed'
1027
1861
if str(e):
1028
1862
msg += ': ' + str(e)
1029
_report_exception(e, msg)
1863
_report_exception(msg)
1030
1864
return 2
1031
1865
except KeyboardInterrupt, e:
1032
_report_exception(e, 'interrupted', quiet=True)
1866
_report_exception('interrupted', quiet=True)
1033
1867
return 2
1034
1868
except Exception, e:
1869
import errno
1035
1870
quiet = False
1036
if isinstance(e, IOError) and e.errno == errno.EPIPE:
1871
if (isinstance(e, IOError)
1872
and hasattr(e, 'errno')
1873
and e.errno == errno.EPIPE):
1037
1874
quiet = True
1038
1875
msg = 'broken pipe'
1039
1876
else:
1040
1877
msg = str(e).rstrip('\n')
1041
_report_exception(e, msg, quiet)
1878
_report_exception(msg, quiet)
1042
1879
return 2
1043
1880
finally:
1044
1881
bzrlib.trace.close_trace()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1