« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 443
- compare with another revision
- download diff
- download tarball
- view history from revision 443
- Committer: Martin Pool
- Date: 2005-05-10 08:15:58 UTC
- Revision ID: mbp@sourcefrog.net-20050510081558-9a38e2c46ba4ebc4
- Patch from Fredrik Lundh to check Python version and
try to find a better one if it's too old.
Patched to try to prevent infinite loops in wierd configurations,
and to log to stderr.
try to find a better one if it's too old.
Patched to try to prevent infinite loops in wierd configurations,
and to log to stderr.
- files added:
- bzrlib/statcache.py
- files removed:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- tools
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
16
16
17
17
18
18
19
import sys, os
19
import sys, os, time, os.path
20
from sets import Set
20
21
21
22
import bzrlib
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__])
23
from bzrlib.trace import mutter, note, log_error
24
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
26
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
27
from bzrlib.revision import Revision
28
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
29
format_date
44
30
45
31
46
32
def _squish_command_name(cmd):
51
37
assert cmd.startswith("cmd_")
52
38
return cmd[4:].replace('_','-')
53
39
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 = {}
40
def get_all_cmds():
41
"""Return canonical name and class for all registered commands."""
142
42
for k, v in globals().iteritems():
143
43
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):
44
yield _unsquish_command_name(k), v
45
46
def get_cmd_class(cmd):
162
47
"""Return the canonical name and command class for a command.
163
48
"""
164
49
cmd = str(cmd) # not unicode
165
50
166
51
# first look up this command under the specified name
167
cmds = _get_cmd_dict(plugins_override=plugins_override)
168
52
try:
169
return cmd, cmds[cmd]
53
return cmd, globals()[_squish_command_name(cmd)]
170
54
except KeyError:
171
55
pass
172
56
173
57
# look for any command which claims this as an alias
174
for cmdname, cmdclass in cmds.iteritems():
58
for cmdname, cmdclass in get_all_cmds():
175
59
if cmd in cmdclass.aliases:
176
60
return cmdname, cmdclass
177
61
182
66
raise BzrCommandError("unknown command %r" % cmd)
183
67
184
68
185
class Command(object):
69
class Command:
186
70
"""Base class for commands.
187
71
188
72
The docstring for an actual command should give a single-line
214
98
assert isinstance(arguments, dict)
215
99
cmdargs = options.copy()
216
100
cmdargs.update(arguments)
217
if self.__doc__ == Command.__doc__:
218
from warnings import warn
219
warn("No help message set for %r" % self)
101
assert self.__doc__ != Command.__doc__, \
102
("No help message set for %r" % self)
220
103
self.status = self.run(**cmdargs)
221
if self.status is None:
222
self.status = 0
223
104
224
105
225
106
def run(self):
250
131
"""
251
132
252
133
def find_command(cls, cmd):
253
import os.path
254
134
bzrpath = os.environ.get('BZRPATH', '')
255
135
256
for dir in bzrpath.split(os.pathsep):
136
for dir in bzrpath.split(':'):
257
137
path = os.path.join(dir, cmd)
258
138
if os.path.isfile(path):
259
139
return ExternalCommand(path)
265
145
def __init__(self, path):
266
146
self.path = path
267
147
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
150
268
151
pipe = os.popen('%s --bzr-usage' % path, 'r')
269
152
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
153
self.takes_args = pipe.readline().split()
278
279
if pipe.close() is not None:
280
raise BzrError("Failed funning '%s --bzr-usage'" % path)
154
pipe.close()
281
155
282
156
pipe = os.popen('%s --bzr-help' % path, 'r')
283
157
self.__doc__ = pipe.read()
284
if pipe.close() is not None:
285
raise BzrError("Failed funning '%s --bzr-help'" % path)
158
pipe.close()
286
159
287
160
def __call__(self, options, arguments):
288
161
Command.__init__(self, options, arguments)
295
168
keys = kargs.keys()
296
169
keys.sort()
297
170
for name in keys:
298
optname = name.replace('_','-')
299
171
value = kargs[name]
300
if OPTIONS.has_key(optname):
172
if OPTIONS.has_key(name):
301
173
# it's an option
302
opts.append('--%s' % optname)
174
opts.append('--%s' % name)
303
175
if value is not None and value is not True:
304
176
opts.append(str(value))
305
177
else:
317
189
class cmd_status(Command):
318
190
"""Display status summary.
319
191
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.
192
For each file there is a single line giving its file state and name.
193
The name is that in the current revision unless it is deleted or
194
missing, in which case the old name is shown.
354
195
"""
355
196
takes_args = ['file*']
356
takes_options = ['all', 'show-ids', 'revision']
197
takes_options = ['all']
357
198
aliases = ['st', 'stat']
358
199
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)
200
def run(self, all=False, file_list=None):
201
b = Branch('.', lock_mode='r')
202
b.show_status(show_all=all, file_list=file_list)
373
203
374
204
375
205
class cmd_cat_revision(Command):
379
209
takes_args = ['revision_id']
380
210
381
211
def run(self, revision_id):
382
from bzrlib.xml import pack_xml
383
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
212
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
384
213
385
214
386
215
class cmd_revno(Command):
388
217
389
218
This is equal to the number of revisions on this branch."""
390
219
def run(self):
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)
220
print Branch('.').revno()
414
221
415
222
416
223
class cmd_add(Command):
426
233
whether already versioned or not, are searched for files or
427
234
subdirectories that are neither versioned or ignored, and these
428
235
are added. This search proceeds recursively into versioned
429
directories. If no names are given '.' is assumed.
236
directories.
430
237
431
Therefore simply saying 'bzr add' will version all files that
238
Therefore simply saying 'bzr add .' will version all files that
432
239
are currently unknown.
433
240
434
241
TODO: Perhaps adding a file whose directly is not versioned should
435
242
recursively add that parent, rather than giving an error?
436
243
"""
437
takes_args = ['file*']
438
takes_options = ['verbose', 'no-recurse']
244
takes_args = ['file+']
245
takes_options = ['verbose']
439
246
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)
247
def run(self, file_list, verbose=False):
248
bzrlib.add.smart_add(file_list, verbose)
461
249
462
250
463
251
class cmd_relpath(Command):
464
252
"""Show path of a file relative to root"""
465
253
takes_args = ['filename']
466
hidden = True
467
254
468
255
def run(self, filename):
469
print find_branch(filename).relpath(filename)
256
print Branch(filename).relpath(filename)
470
257
471
258
472
259
473
260
class cmd_inventory(Command):
474
261
"""Show inventory of the current working copy or a revision."""
475
takes_options = ['revision', 'show-ids']
262
takes_options = ['revision']
476
263
477
def run(self, revision=None, show_ids=False):
478
b = find_branch('.')
264
def run(self, revision=None):
265
b = Branch('.')
479
266
if revision == None:
480
267
inv = b.read_working_inventory()
481
268
else:
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]))
269
inv = b.get_revision_inventory(b.lookup_revision(revision))
486
270
487
for path, entry in inv.entries():
488
if show_ids:
489
print '%-50s %s' % (path, entry.file_id)
490
else:
491
print path
271
for path, entry in inv.iter_entries():
272
print '%-50s %s' % (entry.file_id, path)
492
273
493
274
494
275
class cmd_move(Command):
501
282
"""
502
283
takes_args = ['source$', 'dest']
503
284
def run(self, source_list, dest):
504
b = find_branch('.')
285
b = Branch('.')
505
286
506
287
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
507
288
523
304
takes_args = ['from_name', 'to_name']
524
305
525
306
def run(self, from_name, to_name):
526
b = find_branch('.')
307
b = Branch('.')
527
308
b.rename_one(b.relpath(from_name), b.relpath(to_name))
528
309
529
310
530
311
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
678
312
class cmd_renames(Command):
679
313
"""Show list of renamed files.
680
314
685
319
takes_args = ['dir?']
686
320
687
321
def run(self, dir='.'):
688
b = find_branch(dir)
322
b = Branch(dir)
689
323
old_inv = b.basis_tree().inventory
690
324
new_inv = b.read_working_inventory()
691
325
696
330
697
331
698
332
class cmd_info(Command):
699
"""Show statistical information about a branch."""
700
takes_args = ['branch?']
701
702
def run(self, branch=None):
333
"""Show statistical information for this branch"""
334
def run(self):
703
335
import info
704
705
b = find_branch(branch)
706
info.show_info(b)
336
info.show_info(Branch('.'))
707
337
708
338
709
339
class cmd_remove(Command):
716
346
takes_options = ['verbose']
717
347
718
348
def run(self, file_list, verbose=False):
719
b = find_branch(file_list[0])
349
b = Branch(file_list[0])
720
350
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
721
351
722
352
730
360
hidden = True
731
361
takes_args = ['filename']
732
362
def run(self, filename):
733
b = find_branch(filename)
363
b = Branch(filename)
734
364
i = b.inventory.path2id(b.relpath(filename))
735
365
if i == None:
736
raise BzrError("%r is not a versioned file" % filename)
366
bailout("%r is not a versioned file" % filename)
737
367
else:
738
368
print i
739
369
746
376
hidden = True
747
377
takes_args = ['filename']
748
378
def run(self, filename):
749
b = find_branch(filename)
379
b = Branch(filename)
750
380
inv = b.inventory
751
381
fid = inv.path2id(b.relpath(filename))
752
382
if fid == None:
753
raise BzrError("%r is not a versioned file" % filename)
383
bailout("%r is not a versioned file" % filename)
754
384
for fip in inv.get_idpath(fid):
755
385
print fip
756
386
757
387
758
388
class cmd_revision_history(Command):
759
389
"""Display list of revision ids on this branch."""
760
hidden = True
761
390
def run(self):
762
for patchid in find_branch('.').revision_history():
391
for patchid in Branch('.').revision_history():
763
392
print patchid
764
393
765
394
766
395
class cmd_directories(Command):
767
396
"""Display list of versioned directories in this branch."""
768
397
def run(self):
769
for name, ie in find_branch('.').read_working_inventory().directories():
398
for name, ie in Branch('.').read_working_inventory().directories():
770
399
if name == '':
771
400
print '.'
772
401
else:
787
416
bzr commit -m 'imported project'
788
417
"""
789
418
def run(self):
790
from bzrlib.branch import Branch
791
419
Branch('.', init=True)
792
420
793
421
816
444
"""
817
445
818
446
takes_args = ['file*']
819
takes_options = ['revision', 'diff-options']
820
aliases = ['di', 'dif']
447
takes_options = ['revision']
448
aliases = ['di']
821
449
822
def run(self, revision=None, file_list=None, diff_options=None):
450
def run(self, revision=None, file_list=None):
823
451
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]
840
452
841
show_diff(b, base_rev, specific_files=file_list,
842
external_diff_options=diff_options)
453
show_diff(Branch('.'), revision, file_list)
843
454
844
455
845
456
851
462
TODO: Show files deleted since a previous revision, or between two revisions.
852
463
"""
853
464
def run(self, show_ids=False):
854
b = find_branch('.')
465
b = Branch('.')
855
466
old = b.basis_tree()
856
467
new = b.working_tree()
857
468
872
483
"""List files modified in working tree."""
873
484
hidden = True
874
485
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
486
import statcache
487
b = Branch('.')
488
inv = b.read_working_inventory()
489
sc = statcache.update_cache(b, inv)
490
basis = b.basis_tree()
491
basis_inv = basis.inventory
492
493
# We used to do this through iter_entries(), but that's slow
494
# when most of the files are unmodified, as is usually the
495
# case. So instead we iterate by inventory entry, and only
496
# calculate paths as necessary.
497
498
for file_id in basis_inv:
499
cacheentry = sc.get(file_id)
500
if not cacheentry: # deleted
501
continue
502
ie = basis_inv[file_id]
503
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
504
path = inv.id2path(file_id)
505
print path
882
506
883
507
884
508
886
510
"""List files added in working tree."""
887
511
hidden = True
888
512
def run(self):
889
b = find_branch('.')
513
b = Branch('.')
890
514
wt = b.working_tree()
891
515
basis_inv = b.basis_tree().inventory
892
516
inv = wt.inventory
908
532
takes_args = ['filename?']
909
533
def run(self, filename=None):
910
534
"""Print the branch root."""
535
from branch import find_branch
911
536
b = find_branch(filename)
912
537
print getattr(b, 'base', None) or getattr(b, 'baseurl')
913
538
915
540
class cmd_log(Command):
916
541
"""Show log of this branch.
917
542
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
543
TODO: Option to limit range.
544
545
TODO: Perhaps show most-recent first with an option for last.
927
546
"""
928
929
547
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
548
takes_options = ['timezone', 'verbose', 'show-ids']
549
def run(self, filename=None, timezone='original', verbose=False, show_ids=False):
550
from branch import find_branch
551
b = find_branch((filename or '.'), lock_mode='r')
945
552
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)
553
filename = b.relpath(filename)
554
bzrlib.show_log(b, filename,
555
show_timezone=timezone,
556
verbose=verbose,
557
show_ids=show_ids)
995
558
996
559
997
560
998
561
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"."""
562
"""Return revision-ids which affected a particular file."""
1002
563
hidden = True
1003
564
takes_args = ["filename"]
1004
565
def run(self, filename):
1005
b = find_branch(filename)
566
b = Branch(filename, lock_mode='r')
1006
567
inv = b.read_working_inventory()
1007
568
file_id = inv.path2id(b.relpath(filename))
1008
569
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1016
577
"""
1017
578
hidden = True
1018
579
def run(self, revision=None, verbose=False):
1019
b = find_branch('.')
580
b = Branch('.')
1020
581
if revision == None:
1021
582
tree = b.working_tree()
1022
583
else:
1038
599
1039
600
1040
601
class cmd_unknowns(Command):
1041
"""List unknown files."""
602
"""List unknown files"""
1042
603
def run(self):
1043
from bzrlib.osutils import quotefn
1044
for f in find_branch('.').unknowns():
604
for f in Branch('.').unknowns():
1045
605
print quotefn(f)
1046
606
1047
607
1048
608
1049
609
class cmd_ignore(Command):
1050
"""Ignore a command or pattern.
610
"""Ignore a command or pattern
1051
611
1052
612
To remove patterns from the ignore list, edit the .bzrignore file.
1053
613
1067
627
1068
628
def run(self, name_pattern):
1069
629
from bzrlib.atomicfile import AtomicFile
1070
import os.path
630
import codecs
1071
631
1072
b = find_branch('.')
632
b = Branch('.')
1073
633
ifn = b.abspath('.bzrignore')
1074
634
635
# FIXME: probably doesn't handle non-ascii patterns
636
1075
637
if os.path.exists(ifn):
1076
f = open(ifn, 'rt')
1077
try:
1078
igns = f.read().decode('utf-8')
1079
finally:
1080
f.close()
638
f = b.controlfile(ifn, 'rt')
639
igns = f.read()
640
f.close()
1081
641
else:
1082
642
igns = ''
1083
643
1084
# TODO: If the file already uses crlf-style termination, maybe
1085
# we should use that for the newly added lines?
1086
1087
644
if igns and igns[-1] != '\n':
1088
645
igns += '\n'
1089
646
igns += name_pattern + '\n'
1090
647
1091
try:
1092
f = AtomicFile(ifn, 'wt')
1093
f.write(igns.encode('utf-8'))
1094
f.commit()
1095
finally:
1096
f.close()
648
f = AtomicFile(ifn, 'wt')
649
f.write(igns)
650
f.commit()
1097
651
1098
652
inv = b.working_tree().inventory
1099
653
if inv.path2id('.bzrignore'):
1109
663
1110
664
See also: bzr ignore"""
1111
665
def run(self):
1112
tree = find_branch('.').working_tree()
666
tree = Branch('.').working_tree()
1113
667
for path, file_class, kind, file_id in tree.list_files():
1114
668
if file_class != 'I':
1115
669
continue
1133
687
except ValueError:
1134
688
raise BzrCommandError("not a valid revision-number: %r" % revno)
1135
689
1136
print find_branch('.').lookup_revision(revno)
690
print Branch('.').lookup_revision(revno)
1137
691
1138
692
1139
693
class cmd_export(Command):
1140
694
"""Export past revision to destination directory.
1141
695
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
696
If no revision is specified this exports the last committed revision."""
1151
697
takes_args = ['dest']
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()
698
takes_options = ['revision']
699
def run(self, dest, revision=None):
700
b = Branch('.')
701
if revision == None:
702
rh = b.revision_history()[-1]
1158
703
else:
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)
704
rh = b.lookup_revision(int(revision))
705
t = b.revision_tree(rh)
706
t.export(dest)
1174
707
1175
708
1176
709
class cmd_cat(Command):
1182
715
def run(self, filename, revision=None):
1183
716
if revision == None:
1184
717
raise BzrCommandError("bzr cat requires a revision number")
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])
718
b = Branch('.')
719
b.print_file(b.relpath(filename), int(revision))
1189
720
1190
721
1191
722
class cmd_local_time_offset(Command):
1199
730
class cmd_commit(Command):
1200
731
"""Commit changes into a new revision.
1201
732
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.
733
TODO: Commit only selected files.
1209
734
1210
735
TODO: Run hooks on tree to-be-committed, and after commit.
1211
736
1212
737
TODO: Strict commit that fails if there are unknown or deleted files.
1213
738
"""
1214
takes_args = ['selected*']
1215
takes_options = ['message', 'file', 'verbose', 'unchanged']
739
takes_options = ['message', 'file', 'verbose']
1216
740
aliases = ['ci', 'checkin']
1217
741
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
742
def run(self, message=None, file=None, verbose=False):
1223
743
## Warning: shadows builtin file()
1224
744
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"])
745
raise BzrCommandError("please specify a commit message",
746
["use either --message or --file"])
1237
747
elif message and file:
1238
748
raise BzrCommandError("please specify either --message or --file")
1239
749
1241
751
import codecs
1242
752
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1243
753
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"])
754
Branch('.').commit(message, verbose=verbose)
1255
755
1256
756
1257
757
class cmd_check(Command):
1259
759
1260
760
This command checks various invariants about the branch storage to
1261
761
detect data corruption or bzr bugs.
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))
762
"""
763
takes_args = ['dir?']
764
def run(self, dir='.'):
765
import bzrlib.check
766
bzrlib.check.check(Branch(dir, find_root=False))
1306
767
1307
768
1308
769
1320
781
class cmd_selftest(Command):
1321
782
"""Run internal test suite"""
1322
783
hidden = True
1323
takes_options = ['verbose']
1324
def run(self, verbose=False):
1325
from bzrlib.selftest import selftest
1326
return int(not selftest(verbose=verbose))
784
def run(self):
785
failures, tests = 0, 0
786
787
import doctest, bzrlib.store, bzrlib.tests
788
bzrlib.trace.verbose = False
789
790
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
791
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
792
mf, mt = doctest.testmod(m)
793
failures += mf
794
tests += mt
795
print '%-40s %3d tests' % (m.__name__, mt),
796
if mf:
797
print '%3d FAILED!' % mf
798
else:
799
print
800
801
print '%-40s %3d tests' % ('total', tests),
802
if failures:
803
print '%3d FAILED!' % failures
804
else:
805
print
806
1327
807
1328
808
1329
809
class cmd_version(Command):
1330
"""Show version of bzr."""
810
"""Show version of bzr"""
1331
811
def run(self):
1332
812
show_version()
1333
813
1334
814
def show_version():
1335
815
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
1340
816
print bzrlib.__copyright__
1341
817
print "http://bazaar-ng.org/"
1342
818
print
1351
827
def run(self):
1352
828
print "it sure does!"
1353
829
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
1422
class cmd_revert(Command):
1423
"""Restore selected files from a previous revision.
1424
"""
1425
takes_args = ['file+']
1426
def run(self, file_list):
1427
from bzrlib.branch import find_branch
1428
1429
if not file_list:
1430
file_list = ['.']
1431
1432
b = find_branch(file_list[0])
1433
1434
b.revert([b.relpath(f) for f in file_list])
1435
1436
1437
class cmd_merge_revert(Command):
1438
"""Reverse all changes since the last commit.
1439
1440
Only versioned files are affected. By default, any files that are changed
1441
will be backed up first. Backup files have a '~' appended to their name.
1442
"""
1443
takes_options = ['revision', 'no-backup']
1444
1445
def run(self, revision=None, no_backup=False):
1446
from bzrlib.merge import merge
1447
if revision is None:
1448
revision = [-1]
1449
elif len(revision) != 1:
1450
raise BzrCommandError('bzr merge-revert --revision takes exactly 1 argument')
1451
merge(('.', revision[0]), parse_spec('.'),
1452
check_clean=False,
1453
ignore_zero=True,
1454
backup_files=not no_backup)
1455
1456
830
1457
831
class cmd_assert_fail(Command):
1458
832
"""Test reporting of assertion failures"""
1473
847
help.help(topic)
1474
848
1475
849
1476
1477
1478
class cmd_plugins(Command):
1479
"""List plugins"""
850
class cmd_update_stat_cache(Command):
851
"""Update stat-cache mapping inodes to SHA-1 hashes.
852
853
For testing only."""
1480
854
hidden = True
1481
855
def run(self):
1482
import bzrlib.plugin
1483
from inspect import getdoc
1484
from pprint import pprint
1485
for plugin in bzrlib.plugin.all_plugins:
1486
print plugin.__path__[0]
1487
d = getdoc(plugin)
1488
if d:
1489
print '\t', d.split('\n')[0]
1490
1491
#pprint(bzrlib.plugin.all_plugins)
1492
856
import statcache
857
b = Branch('.')
858
statcache.update_cache(b)
859
860
861
######################################################################
862
# main routine
1493
863
1494
864
1495
865
# list of all available options; the rhs can be either None for an
1497
867
# the type.
1498
868
OPTIONS = {
1499
869
'all': None,
1500
'diff-options': str,
1501
870
'help': None,
1502
871
'file': unicode,
1503
'force': None,
1504
'format': unicode,
1505
'forward': None,
1506
872
'message': unicode,
1507
'no-recurse': None,
1508
873
'profile': None,
1509
'revision': _parse_revision_str,
874
'revision': int,
1510
875
'show-ids': None,
1511
876
'timezone': str,
1512
877
'verbose': None,
1513
878
'version': None,
1514
879
'email': None,
1515
'unchanged': None,
1516
'update': None,
1517
'long': None,
1518
'root': str,
1519
'no-backup': None,
1520
'merge-type': get_merge_type,
1521
880
}
1522
881
1523
882
SHORT_OPTIONS = {
883
'm': 'message',
1524
884
'F': 'file',
1525
'h': 'help',
1526
'm': 'message',
1527
885
'r': 'revision',
1528
886
'v': 'verbose',
1529
'l': 'long',
1530
887
}
1531
888
1532
889
1546
903
(['status'], {'all': True})
1547
904
>>> parse_args('commit --message=biter'.split())
1548
905
(['commit'], {'message': u'biter'})
1549
>>> parse_args('log -r 500'.split())
1550
(['log'], {'revision': [500]})
1551
>>> parse_args('log -r500..600'.split())
1552
(['log'], {'revision': [500, 600]})
1553
>>> parse_args('log -vr500..600'.split())
1554
(['log'], {'verbose': True, 'revision': [500, 600]})
1555
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1556
(['log'], {'revision': ['v500', 600]})
1557
906
"""
1558
907
args = []
1559
908
opts = {}
1573
922
else:
1574
923
optname = a[2:]
1575
924
if optname not in OPTIONS:
1576
raise BzrError('unknown long option %r' % a)
925
bailout('unknown long option %r' % a)
1577
926
else:
1578
927
shortopt = a[1:]
1579
if shortopt in SHORT_OPTIONS:
1580
# Multi-character options must have a space to delimit
1581
# their value
1582
optname = SHORT_OPTIONS[shortopt]
1583
else:
1584
# Single character short options, can be chained,
1585
# and have their value appended to their name
1586
shortopt = a[1:2]
1587
if shortopt not in SHORT_OPTIONS:
1588
# We didn't find the multi-character name, and we
1589
# didn't find the single char name
1590
raise BzrError('unknown short option %r' % a)
1591
optname = SHORT_OPTIONS[shortopt]
1592
1593
if a[2:]:
1594
# There are extra things on this option
1595
# see if it is the value, or if it is another
1596
# short option
1597
optargfn = OPTIONS[optname]
1598
if optargfn is None:
1599
# This option does not take an argument, so the
1600
# next entry is another short option, pack it back
1601
# into the list
1602
argv.insert(0, '-' + a[2:])
1603
else:
1604
# This option takes an argument, so pack it
1605
# into the array
1606
optarg = a[2:]
928
if shortopt not in SHORT_OPTIONS:
929
bailout('unknown short option %r' % a)
930
optname = SHORT_OPTIONS[shortopt]
1607
931
1608
932
if optname in opts:
1609
933
# XXX: Do we ever want to support this, e.g. for -r?
1610
raise BzrError('repeated option %r' % a)
934
bailout('repeated option %r' % a)
1611
935
1612
936
optargfn = OPTIONS[optname]
1613
937
if optargfn:
1614
938
if optarg == None:
1615
939
if not argv:
1616
raise BzrError('option %r needs an argument' % a)
940
bailout('option %r needs an argument' % a)
1617
941
else:
1618
942
optarg = argv.pop(0)
1619
943
opts[optname] = optargfn(optarg)
1620
944
else:
1621
945
if optarg != None:
1622
raise BzrError('option %r takes no argument' % optname)
946
bailout('option %r takes no argument' % optname)
1623
947
opts[optname] = True
1624
948
else:
1625
949
args.append(a)
1673
997
return argdict
1674
998
1675
999
1676
def _parse_master_args(argv):
1677
"""Parse the arguments that always go with the original command.
1678
These are things like bzr --no-plugins, etc.
1679
1680
There are now 2 types of option flags. Ones that come *before* the command,
1681
and ones that come *after* the command.
1682
Ones coming *before* the command are applied against all possible commands.
1683
And are generally applied before plugins are loaded.
1684
1685
The current list are:
1686
--builtin Allow plugins to load, but don't let them override builtin commands,
1687
they will still be allowed if they do not override a builtin.
1688
--no-plugins Don't load any plugins. This lets you get back to official source
1689
behavior.
1690
--profile Enable the hotspot profile before running the command.
1691
For backwards compatibility, this is also a non-master option.
1692
--version Spit out the version of bzr that is running and exit.
1693
This is also a non-master option.
1694
--help Run help and exit, also a non-master option (I think that should stay, though)
1695
1696
>>> argv, opts = _parse_master_args(['--test'])
1697
Traceback (most recent call last):
1698
...
1699
BzrCommandError: Invalid master option: 'test'
1700
>>> argv, opts = _parse_master_args(['--version', 'command'])
1701
>>> print argv
1702
['command']
1703
>>> print opts['version']
1704
True
1705
>>> argv, opts = _parse_master_args(['--profile', 'command', '--more-options'])
1706
>>> print argv
1707
['command', '--more-options']
1708
>>> print opts['profile']
1709
True
1710
>>> argv, opts = _parse_master_args(['--no-plugins', 'command'])
1711
>>> print argv
1712
['command']
1713
>>> print opts['no-plugins']
1714
True
1715
>>> print opts['profile']
1716
False
1717
>>> argv, opts = _parse_master_args(['command', '--profile'])
1718
>>> print argv
1719
['command', '--profile']
1720
>>> print opts['profile']
1721
False
1722
"""
1723
master_opts = {'builtin':False,
1724
'no-plugins':False,
1725
'version':False,
1726
'profile':False,
1727
'help':False
1728
}
1729
1730
for arg in argv[:]:
1731
if arg[:2] != '--': # at the first non-option, we return the rest
1732
break
1733
arg = arg[2:] # Remove '--'
1734
if arg not in master_opts:
1735
# We could say that this is not an error, that we should
1736
# just let it be handled by the main section instead
1737
raise BzrCommandError('Invalid master option: %r' % arg)
1738
argv.pop(0) # We are consuming this entry
1739
master_opts[arg] = True
1740
return argv, master_opts
1741
1742
1743
1000
1744
1001
def run_bzr(argv):
1745
1002
"""Execute a command.
1746
1003
1747
1004
This is similar to main(), but without all the trappings for
1748
1005
logging and error handling.
1749
1750
argv
1751
The command-line arguments, without the program name.
1752
1753
Returns a command status or raises an exception.
1754
1006
"""
1755
1007
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1756
1757
# some options like --builtin and --no-plugins have special effects
1758
argv, master_opts = _parse_master_args(argv)
1759
if not master_opts['no-plugins']:
1760
from bzrlib.plugin import load_plugins
1761
load_plugins()
1762
1763
args, opts = parse_args(argv)
1764
1765
if master_opts.get('help') or 'help' in opts:
1766
from bzrlib.help import help
1767
if argv:
1768
help(argv[0])
1769
else:
1770
help()
1771
return 0
1772
1773
if 'version' in opts:
1774
show_version()
1775
return 0
1776
1777
if args and args[0] == 'builtin':
1778
include_plugins=False
1779
args = args[1:]
1780
1008
1781
1009
try:
1010
args, opts = parse_args(argv[1:])
1011
if 'help' in opts:
1012
import help
1013
if args:
1014
help.help(args[0])
1015
else:
1016
help.help()
1017
return 0
1018
elif 'version' in opts:
1019
show_version()
1020
return 0
1782
1021
cmd = str(args.pop(0))
1783
1022
except IndexError:
1784
print >>sys.stderr, "please try 'bzr help' for help"
1023
log_error('usage: bzr COMMAND')
1024
log_error(' try "bzr help"')
1785
1025
return 1
1786
1026
1787
plugins_override = not (master_opts['builtin'])
1788
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1027
canonical_cmd, cmd_class = get_cmd_class(cmd)
1789
1028
1790
profile = master_opts['profile']
1791
# For backwards compatibility, I would rather stick with --profile being a
1792
# master/global option
1029
# global option
1793
1030
if 'profile' in opts:
1794
1031
profile = True
1795
1032
del opts['profile']
1033
else:
1034
profile = False
1796
1035
1797
1036
# check options are reasonable
1798
1037
allowed = cmd_class.takes_options
1829
1068
os.close(pffileno)
1830
1069
os.remove(pfname)
1831
1070
else:
1832
return cmd_class(cmdopts, cmdargs).status
1071
cmdobj = cmd_class(cmdopts, cmdargs).status
1833
1072
1834
1073
1835
1074
def _report_exception(summary, quiet=False):
1847
1086
1848
1087
1849
1088
def main(argv):
1089
import errno
1850
1090
1851
bzrlib.trace.open_tracefile(argv)
1091
bzrlib.open_tracefile(argv)
1852
1092
1853
1093
try:
1854
1094
try:
1855
1095
try:
1856
return run_bzr(argv[1:])
1096
return run_bzr(argv)
1857
1097
finally:
1858
1098
# do this here inside the exception wrappers to catch EPIPE
1859
1099
sys.stdout.flush()
1875
1115
_report_exception('interrupted', quiet=True)
1876
1116
return 2
1877
1117
except Exception, e:
1878
import errno
1879
1118
quiet = False
1880
1119
if (isinstance(e, IOError)
1881
1120
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1