« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 737
- compare with another revision
- download diff
- download tarball
- view history from revision 737
- Committer: Martin Pool
- Date: 2005-06-22 06:38:18 UTC
- Revision ID: mbp@sourcefrog.net-20050622063818-cd8d21b14bd4b636
- add plugin patch, still being integrated
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
# TODO: Split the command framework away from the actual commands.
19
20
# TODO: probably should say which arguments are candidates for glob
21
# expansion on windows and do that at the command level.
22
23
import sys
24
import os
18
19
import sys, os
25
20
26
21
import bzrlib
27
from bzrlib.trace import mutter, note, log_error, warning
22
from bzrlib.trace import mutter, note, log_error
28
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
29
from bzrlib.branch import find_branch
30
from bzrlib import BZRDIR
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
26
format_date
31
27
32
28
33
29
plugin_cmds = {}
34
30
35
31
36
def register_command(cmd):
32
def register_plugin_command(cmd):
37
33
"Utility function to help register a command"
38
34
global plugin_cmds
39
35
k = cmd.__name__
56
52
assert cmd.startswith("cmd_")
57
53
return cmd[4:].replace('_','-')
58
54
59
60
55
def _parse_revision_str(revstr):
61
"""This handles a revision string -> revno.
62
63
This always returns a list. The list will have one element for
64
65
It supports integers directly, but everything else it
66
defers for passing to Branch.get_revision_info()
67
68
>>> _parse_revision_str('234')
69
[234]
70
>>> _parse_revision_str('234..567')
71
[234, 567]
72
>>> _parse_revision_str('..')
73
[None, None]
74
>>> _parse_revision_str('..234')
75
[None, 234]
76
>>> _parse_revision_str('234..')
77
[234, None]
78
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
79
[234, 456, 789]
80
>>> _parse_revision_str('234....789') # Error?
81
[234, None, 789]
82
>>> _parse_revision_str('revid:test@other.com-234234')
83
['revid:test@other.com-234234']
84
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
85
['revid:test@other.com-234234', 'revid:test@other.com-234235']
86
>>> _parse_revision_str('revid:test@other.com-234234..23')
87
['revid:test@other.com-234234', 23]
88
>>> _parse_revision_str('date:2005-04-12')
89
['date:2005-04-12']
90
>>> _parse_revision_str('date:2005-04-12 12:24:33')
91
['date:2005-04-12 12:24:33']
92
>>> _parse_revision_str('date:2005-04-12T12:24:33')
93
['date:2005-04-12T12:24:33']
94
>>> _parse_revision_str('date:2005-04-12,12:24:33')
95
['date:2005-04-12,12:24:33']
96
>>> _parse_revision_str('-5..23')
97
[-5, 23]
98
>>> _parse_revision_str('-5')
99
[-5]
100
>>> _parse_revision_str('123a')
101
['123a']
102
>>> _parse_revision_str('abc')
103
['abc']
56
"""This handles a revision string -> revno.
57
58
There are several possibilities:
59
60
'234' -> 234
61
'234:345' -> [234, 345]
62
':234' -> [None, 234]
63
'234:' -> [234, None]
64
65
In the future we will also support:
66
'uuid:blah-blah-blah' -> ?
67
'hash:blahblahblah' -> ?
68
potentially:
69
'tag:mytag' -> ?
104
70
"""
105
import re
106
old_format_re = re.compile('\d*:\d*')
107
m = old_format_re.match(revstr)
108
if m:
109
warning('Colon separator for revision numbers is deprecated.'
110
' Use .. instead')
111
revs = []
112
for rev in revstr.split(':'):
113
if rev:
114
revs.append(int(rev))
115
else:
116
revs.append(None)
117
return revs
118
revs = []
119
for x in revstr.split('..'):
120
if not x:
121
revs.append(None)
122
else:
123
try:
124
revs.append(int(x))
125
except ValueError:
126
revs.append(x)
71
if revstr.find(':') != -1:
72
revs = revstr.split(':')
73
if len(revs) > 2:
74
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
75
76
if not revs[0]:
77
revs[0] = None
78
else:
79
revs[0] = int(revs[0])
80
81
if not revs[1]:
82
revs[1] = None
83
else:
84
revs[1] = int(revs[1])
85
else:
86
revs = int(revstr)
127
87
return revs
128
88
129
89
130
def get_merge_type(typestring):
131
"""Attempt to find the merge class/factory associated with a string."""
132
from merge import merge_types
133
try:
134
return merge_types[typestring][0]
135
except KeyError:
136
templ = '%s%%7s: %%s' % (' '*12)
137
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
138
type_list = '\n'.join(lines)
139
msg = "No known merge type %s. Supported types are:\n%s" %\
140
(typestring, type_list)
141
raise BzrCommandError(msg)
142
143
144
def get_merge_type(typestring):
145
"""Attempt to find the merge class/factory associated with a string."""
146
from merge import merge_types
147
try:
148
return merge_types[typestring][0]
149
except KeyError:
150
templ = '%s%%7s: %%s' % (' '*12)
151
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
152
type_list = '\n'.join(lines)
153
msg = "No known merge type %s. Supported types are:\n%s" %\
154
(typestring, type_list)
155
raise BzrCommandError(msg)
156
157
158
90
159
91
def _get_cmd_dict(plugins_override=True):
160
92
d = {}
233
165
assert isinstance(arguments, dict)
234
166
cmdargs = options.copy()
235
167
cmdargs.update(arguments)
236
if self.__doc__ == Command.__doc__:
237
from warnings import warn
238
warn("No help message set for %r" % self)
168
assert self.__doc__ != Command.__doc__, \
169
("No help message set for %r" % self)
239
170
self.status = self.run(**cmdargs)
240
if self.status is None:
241
self.status = 0
242
171
243
172
244
173
def run(self):
256
185
class ExternalCommand(Command):
257
186
"""Class to wrap external commands.
258
187
259
We cheat a little here, when get_cmd_class() calls us we actually
260
give it back an object we construct that has the appropriate path,
261
help, options etc for the specified command.
262
263
When run_bzr() tries to instantiate that 'class' it gets caught by
264
the __call__ method, which we override to call the Command.__init__
265
method. That then calls our run method which is pretty straight
266
forward.
267
268
The only wrinkle is that we have to map bzr's dictionary of options
269
and arguments back into command line options and arguments for the
270
script.
188
We cheat a little here, when get_cmd_class() calls us we actually give it back
189
an object we construct that has the appropriate path, help, options etc for the
190
specified command.
191
192
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
193
method, which we override to call the Command.__init__ method. That then calls
194
our run method which is pretty straight forward.
195
196
The only wrinkle is that we have to map bzr's dictionary of options and arguments
197
back into command line options and arguments for the script.
271
198
"""
272
199
273
200
def find_command(cls, cmd):
370
297
directory is shown. Otherwise, only the status of the specified
371
298
files or directories is reported. If a directory is given, status
372
299
is reported for everything inside that directory.
373
374
If a revision is specified, the changes since that revision are shown.
375
300
"""
376
301
takes_args = ['file*']
377
takes_options = ['all', 'show-ids', 'revision']
302
takes_options = ['all', 'show-ids']
378
303
aliases = ['st', 'stat']
379
304
380
305
def run(self, all=False, show_ids=False, file_list=None):
381
306
if file_list:
382
b = find_branch(file_list[0])
307
b = Branch(file_list[0])
383
308
file_list = [b.relpath(x) for x in file_list]
384
309
# special case: only one path was given and it's the root
385
310
# of the branch
386
311
if file_list == ['']:
387
312
file_list = None
388
313
else:
389
b = find_branch('.')
390
391
from bzrlib.status import show_status
392
show_status(b, show_unchanged=all, show_ids=show_ids,
393
specific_files=file_list)
314
b = Branch('.')
315
import status
316
status.show_status(b, show_unchanged=all, show_ids=show_ids,
317
specific_files=file_list)
394
318
395
319
396
320
class cmd_cat_revision(Command):
400
324
takes_args = ['revision_id']
401
325
402
326
def run(self, revision_id):
403
from bzrlib.xml import pack_xml
404
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
327
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
405
328
406
329
407
330
class cmd_revno(Command):
409
332
410
333
This is equal to the number of revisions on this branch."""
411
334
def run(self):
412
print find_branch('.').revno()
413
414
class cmd_revision_info(Command):
415
"""Show revision number and revision id for a given revision identifier.
416
"""
417
hidden = True
418
takes_args = ['revision_info*']
419
takes_options = ['revision']
420
def run(self, revision=None, revision_info_list=None):
421
from bzrlib.branch import find_branch
422
423
revs = []
424
if revision is not None:
425
revs.extend(revision)
426
if revision_info_list is not None:
427
revs.extend(revision_info_list)
428
if len(revs) == 0:
429
raise BzrCommandError('You must supply a revision identifier')
430
431
b = find_branch('.')
432
433
for rev in revs:
434
print '%4d %s' % b.get_revision_info(rev)
335
print Branch('.').revno()
435
336
436
337
437
338
class cmd_add(Command):
447
348
whether already versioned or not, are searched for files or
448
349
subdirectories that are neither versioned or ignored, and these
449
350
are added. This search proceeds recursively into versioned
450
directories. If no names are given '.' is assumed.
351
directories.
451
352
452
Therefore simply saying 'bzr add' will version all files that
353
Therefore simply saying 'bzr add .' will version all files that
453
354
are currently unknown.
454
355
455
356
TODO: Perhaps adding a file whose directly is not versioned should
456
357
recursively add that parent, rather than giving an error?
457
358
"""
458
takes_args = ['file*']
359
takes_args = ['file+']
459
360
takes_options = ['verbose', 'no-recurse']
460
361
461
362
def run(self, file_list, verbose=False, no_recurse=False):
462
from bzrlib.add import smart_add
463
smart_add(file_list, verbose, not no_recurse)
464
465
466
467
class cmd_mkdir(Command):
468
"""Create a new versioned directory.
469
470
This is equivalent to creating the directory and then adding it.
471
"""
472
takes_args = ['dir+']
473
474
def run(self, dir_list):
475
b = None
476
477
for d in dir_list:
478
os.mkdir(d)
479
if not b:
480
b = find_branch(d)
481
b.add([d], verbose=True)
363
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
482
364
483
365
484
366
class cmd_relpath(Command):
487
369
hidden = True
488
370
489
371
def run(self, filename):
490
print find_branch(filename).relpath(filename)
372
print Branch(filename).relpath(filename)
491
373
492
374
493
375
496
378
takes_options = ['revision', 'show-ids']
497
379
498
380
def run(self, revision=None, show_ids=False):
499
b = find_branch('.')
381
b = Branch('.')
500
382
if revision == None:
501
383
inv = b.read_working_inventory()
502
384
else:
503
if len(revision) > 1:
504
raise BzrCommandError('bzr inventory --revision takes'
505
' exactly one revision identifier')
506
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
385
inv = b.get_revision_inventory(b.lookup_revision(revision))
507
386
508
387
for path, entry in inv.entries():
509
388
if show_ids:
522
401
"""
523
402
takes_args = ['source$', 'dest']
524
403
def run(self, source_list, dest):
525
b = find_branch('.')
404
b = Branch('.')
526
405
527
# TODO: glob expansion on windows?
528
406
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
529
407
530
408
545
423
takes_args = ['from_name', 'to_name']
546
424
547
425
def run(self, from_name, to_name):
548
b = find_branch('.')
426
b = Branch('.')
549
427
b.rename_one(b.relpath(from_name), b.relpath(to_name))
550
428
551
429
552
430
553
class cmd_mv(Command):
554
"""Move or rename a file.
555
556
usage:
557
bzr mv OLDNAME NEWNAME
558
bzr mv SOURCE... DESTINATION
559
560
If the last argument is a versioned directory, all the other names
561
are moved into it. Otherwise, there must be exactly two arguments
562
and the file is changed to a new name, which must not already exist.
563
564
Files cannot be moved between branches.
565
"""
566
takes_args = ['names*']
567
def run(self, names_list):
568
if len(names_list) < 2:
569
raise BzrCommandError("missing file argument")
570
b = find_branch(names_list[0])
571
572
rel_names = [b.relpath(x) for x in names_list]
573
574
if os.path.isdir(names_list[-1]):
575
# move into existing directory
576
b.move(rel_names[:-1], rel_names[-1])
577
else:
578
if len(names_list) != 2:
579
raise BzrCommandError('to mv multiple files the destination '
580
'must be a versioned directory')
581
b.move(rel_names[0], rel_names[1])
582
583
584
431
585
432
586
433
class cmd_pull(Command):
601
448
602
449
def run(self, location=None):
603
450
from bzrlib.merge import merge
604
import tempfile
605
from shutil import rmtree
606
451
import errno
607
452
608
br_to = find_branch('.')
453
br_to = Branch('.')
609
454
stored_loc = None
610
455
try:
611
456
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
612
457
except IOError, e:
613
if e.errno != errno.ENOENT:
458
if errno == errno.ENOENT:
614
459
raise
615
460
if location is None:
616
461
if stored_loc is None:
618
463
else:
619
464
print "Using last location: %s" % stored_loc
620
465
location = stored_loc
621
cache_root = tempfile.mkdtemp()
622
from bzrlib.branch import DivergedBranches
466
from branch import find_branch, DivergedBranches
623
467
br_from = find_branch(location)
624
468
location = pull_loc(br_from)
625
469
old_revno = br_to.revno()
626
470
try:
627
from branch import find_cached_branch, DivergedBranches
628
br_from = find_cached_branch(location, cache_root)
629
location = pull_loc(br_from)
630
old_revno = br_to.revno()
631
try:
632
br_to.update_revisions(br_from)
633
except DivergedBranches:
634
raise BzrCommandError("These branches have diverged."
635
" Try merge.")
636
637
merge(('.', -1), ('.', old_revno), check_clean=False)
638
if location != stored_loc:
639
br_to.controlfile("x-pull", "wb").write(location + "\n")
640
finally:
641
rmtree(cache_root)
471
br_to.update_revisions(br_from)
472
except DivergedBranches:
473
raise BzrCommandError("These branches have diverged. Try merge.")
474
475
merge(('.', -1), ('.', old_revno), check_clean=False)
476
if location != stored_loc:
477
br_to.controlfile("x-pull", "wb").write(location + "\n")
642
478
643
479
644
480
653
489
"""
654
490
takes_args = ['from_location', 'to_location?']
655
491
takes_options = ['revision']
656
aliases = ['get', 'clone']
657
492
658
493
def run(self, from_location, to_location=None, revision=None):
659
494
import errno
660
495
from bzrlib.merge import merge
661
from bzrlib.branch import DivergedBranches, \
662
find_cached_branch, Branch
496
from branch import find_branch, DivergedBranches, NoSuchRevision
663
497
from shutil import rmtree
664
from meta_store import CachedStore
665
import tempfile
666
cache_root = tempfile.mkdtemp()
667
668
if revision is None:
669
revision = [None]
670
elif len(revision) > 1:
671
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
672
673
try:
674
try:
675
br_from = find_cached_branch(from_location, cache_root)
676
except OSError, e:
677
if e.errno == errno.ENOENT:
678
raise BzrCommandError('Source location "%s" does not'
679
' exist.' % to_location)
680
else:
681
raise
682
683
if to_location is None:
684
to_location = os.path.basename(from_location.rstrip("/\\"))
685
686
try:
687
os.mkdir(to_location)
688
except OSError, e:
689
if e.errno == errno.EEXIST:
690
raise BzrCommandError('Target directory "%s" already'
691
' exists.' % to_location)
692
if e.errno == errno.ENOENT:
693
raise BzrCommandError('Parent of "%s" does not exist.' %
694
to_location)
695
else:
696
raise
697
br_to = Branch(to_location, init=True)
698
699
br_to.set_root_id(br_from.get_root_id())
700
701
if revision:
702
if revision[0] is None:
703
revno = br_from.revno()
704
else:
705
revno, rev_id = br_from.get_revision_info(revision[0])
706
try:
707
br_to.update_revisions(br_from, stop_revision=revno)
708
except bzrlib.errors.NoSuchRevision:
709
rmtree(to_location)
710
msg = "The branch %s has no revision %d." % (from_location,
711
revno)
712
raise BzrCommandError(msg)
713
714
merge((to_location, -1), (to_location, 0), this_dir=to_location,
715
check_clean=False, ignore_zero=True)
716
from_location = pull_loc(br_from)
717
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
718
finally:
719
rmtree(cache_root)
498
try:
499
br_from = find_branch(from_location)
500
except OSError, e:
501
if e.errno == errno.ENOENT:
502
raise BzrCommandError('Source location "%s" does not exist.' %
503
to_location)
504
else:
505
raise
506
507
if to_location is None:
508
to_location = os.path.basename(from_location.rstrip("/\\"))
509
510
try:
511
os.mkdir(to_location)
512
except OSError, e:
513
if e.errno == errno.EEXIST:
514
raise BzrCommandError('Target directory "%s" already exists.' %
515
to_location)
516
if e.errno == errno.ENOENT:
517
raise BzrCommandError('Parent of "%s" does not exist.' %
518
to_location)
519
else:
520
raise
521
br_to = Branch(to_location, init=True)
522
523
try:
524
br_to.update_revisions(br_from, stop_revision=revision)
525
except NoSuchRevision:
526
rmtree(to_location)
527
msg = "The branch %s has no revision %d." % (from_location,
528
revision)
529
raise BzrCommandError(msg)
530
merge((to_location, -1), (to_location, 0), this_dir=to_location,
531
check_clean=False, ignore_zero=True)
532
from_location = pull_loc(br_from)
533
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
720
534
721
535
722
536
def pull_loc(branch):
739
553
takes_args = ['dir?']
740
554
741
555
def run(self, dir='.'):
742
b = find_branch(dir)
556
b = Branch(dir)
743
557
old_inv = b.basis_tree().inventory
744
558
new_inv = b.read_working_inventory()
745
559
756
570
def run(self, branch=None):
757
571
import info
758
572
573
from branch import find_branch
759
574
b = find_branch(branch)
760
575
info.show_info(b)
761
576
770
585
takes_options = ['verbose']
771
586
772
587
def run(self, file_list, verbose=False):
773
b = find_branch(file_list[0])
588
b = Branch(file_list[0])
774
589
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
775
590
776
591
784
599
hidden = True
785
600
takes_args = ['filename']
786
601
def run(self, filename):
787
b = find_branch(filename)
602
b = Branch(filename)
788
603
i = b.inventory.path2id(b.relpath(filename))
789
604
if i == None:
790
605
raise BzrError("%r is not a versioned file" % filename)
800
615
hidden = True
801
616
takes_args = ['filename']
802
617
def run(self, filename):
803
b = find_branch(filename)
618
b = Branch(filename)
804
619
inv = b.inventory
805
620
fid = inv.path2id(b.relpath(filename))
806
621
if fid == None:
813
628
"""Display list of revision ids on this branch."""
814
629
hidden = True
815
630
def run(self):
816
for patchid in find_branch('.').revision_history():
631
for patchid in Branch('.').revision_history():
817
632
print patchid
818
633
819
634
820
635
class cmd_directories(Command):
821
636
"""Display list of versioned directories in this branch."""
822
637
def run(self):
823
for name, ie in find_branch('.').read_working_inventory().directories():
638
for name, ie in Branch('.').read_working_inventory().directories():
824
639
if name == '':
825
640
print '.'
826
641
else:
841
656
bzr commit -m 'imported project'
842
657
"""
843
658
def run(self):
844
from bzrlib.branch import Branch
845
659
Branch('.', init=True)
846
660
847
661
851
665
If files are listed, only the changes in those files are listed.
852
666
Otherwise, all changes for the tree are listed.
853
667
668
TODO: Given two revision arguments, show the difference between them.
669
854
670
TODO: Allow diff across branches.
855
671
856
672
TODO: Option to use external diff command; could be GNU diff, wdiff,
865
681
deleted files.
866
682
867
683
TODO: This probably handles non-Unix newlines poorly.
868
869
examples:
870
bzr diff
871
bzr diff -r1
872
bzr diff -r1:2
873
684
"""
874
685
875
686
takes_args = ['file*']
878
689
879
690
def run(self, revision=None, file_list=None, diff_options=None):
880
691
from bzrlib.diff import show_diff
692
from bzrlib import find_branch
881
693
882
694
if file_list:
883
695
b = find_branch(file_list[0])
886
698
# just pointing to top-of-tree
887
699
file_list = None
888
700
else:
889
b = find_branch('.')
701
b = Branch('.')
702
703
show_diff(b, revision, specific_files=file_list,
704
external_diff_options=diff_options)
890
705
891
if revision is not None:
892
if len(revision) == 1:
893
show_diff(b, revision[0], specific_files=file_list,
894
external_diff_options=diff_options)
895
elif len(revision) == 2:
896
show_diff(b, revision[0], specific_files=file_list,
897
external_diff_options=diff_options,
898
revision2=revision[1])
899
else:
900
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
901
else:
902
show_diff(b, None, specific_files=file_list,
903
external_diff_options=diff_options)
904
706
905
707
906
708
911
713
TODO: Show files deleted since a previous revision, or between two revisions.
912
714
"""
913
715
def run(self, show_ids=False):
914
b = find_branch('.')
716
b = Branch('.')
915
717
old = b.basis_tree()
916
718
new = b.working_tree()
917
719
932
734
"""List files modified in working tree."""
933
735
hidden = True
934
736
def run(self):
935
from bzrlib.delta import compare_trees
936
937
b = find_branch('.')
938
td = compare_trees(b.basis_tree(), b.working_tree())
939
940
for path, id, kind in td.modified:
941
print path
737
import statcache
738
b = Branch('.')
739
inv = b.read_working_inventory()
740
sc = statcache.update_cache(b, inv)
741
basis = b.basis_tree()
742
basis_inv = basis.inventory
743
744
# We used to do this through iter_entries(), but that's slow
745
# when most of the files are unmodified, as is usually the
746
# case. So instead we iterate by inventory entry, and only
747
# calculate paths as necessary.
748
749
for file_id in basis_inv:
750
cacheentry = sc.get(file_id)
751
if not cacheentry: # deleted
752
continue
753
ie = basis_inv[file_id]
754
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
755
path = inv.id2path(file_id)
756
print path
942
757
943
758
944
759
946
761
"""List files added in working tree."""
947
762
hidden = True
948
763
def run(self):
949
b = find_branch('.')
764
b = Branch('.')
950
765
wt = b.working_tree()
951
766
basis_inv = b.basis_tree().inventory
952
767
inv = wt.inventory
968
783
takes_args = ['filename?']
969
784
def run(self, filename=None):
970
785
"""Print the branch root."""
786
from branch import find_branch
971
787
b = find_branch(filename)
972
788
print getattr(b, 'base', None) or getattr(b, 'baseurl')
973
789
979
795
-r revision requests a specific revision, -r :end or -r begin: are
980
796
also valid.
981
797
982
--message allows you to give a regular expression, which will be evaluated
983
so that only matching entries will be displayed.
984
985
798
TODO: Make --revision support uuid: and hash: [future tag:] notation.
986
799
987
800
"""
988
801
989
802
takes_args = ['filename?']
990
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
991
'long', 'message', 'short',]
803
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
992
804
993
805
def run(self, filename=None, timezone='original',
994
806
verbose=False,
995
807
show_ids=False,
996
808
forward=False,
997
revision=None,
998
message=None,
999
long=False,
1000
short=False):
1001
from bzrlib.branch import find_branch
1002
from bzrlib.log import log_formatter, show_log
809
revision=None):
810
from bzrlib import show_log, find_branch
1003
811
import codecs
1004
812
1005
813
direction = (forward and 'forward') or 'reverse'
1015
823
b = find_branch('.')
1016
824
file_id = None
1017
825
1018
if revision is None:
1019
rev1 = None
1020
rev2 = None
1021
elif len(revision) == 1:
1022
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1023
elif len(revision) == 2:
1024
rev1 = b.get_revision_info(revision[0])[0]
1025
rev2 = b.get_revision_info(revision[1])[0]
826
if revision == None:
827
revision = [None, None]
828
elif isinstance(revision, int):
829
revision = [revision, revision]
1026
830
else:
1027
raise BzrCommandError('bzr log --revision takes one or two values.')
1028
1029
if rev1 == 0:
1030
rev1 = None
1031
if rev2 == 0:
1032
rev2 = None
831
# pair of revisions?
832
pass
833
834
assert len(revision) == 2
1033
835
1034
836
mutter('encoding log as %r' % bzrlib.user_encoding)
1035
837
1037
839
# in e.g. the default C locale.
1038
840
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1039
841
1040
if not short:
1041
log_format = 'long'
1042
else:
1043
log_format = 'short'
1044
lf = log_formatter(log_format,
1045
show_ids=show_ids,
1046
to_file=outf,
1047
show_timezone=timezone)
1048
1049
show_log(b,
1050
lf,
1051
file_id,
842
show_log(b, file_id,
843
show_timezone=timezone,
1052
844
verbose=verbose,
845
show_ids=show_ids,
846
to_file=outf,
1053
847
direction=direction,
1054
start_revision=rev1,
1055
end_revision=rev2,
1056
search=message)
848
start_revision=revision[0],
849
end_revision=revision[1])
1057
850
1058
851
1059
852
1064
857
hidden = True
1065
858
takes_args = ["filename"]
1066
859
def run(self, filename):
1067
b = find_branch(filename)
860
b = Branch(filename)
1068
861
inv = b.read_working_inventory()
1069
862
file_id = inv.path2id(b.relpath(filename))
1070
863
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1078
871
"""
1079
872
hidden = True
1080
873
def run(self, revision=None, verbose=False):
1081
b = find_branch('.')
874
b = Branch('.')
1082
875
if revision == None:
1083
876
tree = b.working_tree()
1084
877
else:
1102
895
class cmd_unknowns(Command):
1103
896
"""List unknown files."""
1104
897
def run(self):
1105
from bzrlib.osutils import quotefn
1106
for f in find_branch('.').unknowns():
898
for f in Branch('.').unknowns():
1107
899
print quotefn(f)
1108
900
1109
901
1131
923
from bzrlib.atomicfile import AtomicFile
1132
924
import os.path
1133
925
1134
b = find_branch('.')
926
b = Branch('.')
1135
927
ifn = b.abspath('.bzrignore')
1136
928
1137
929
if os.path.exists(ifn):
1171
963
1172
964
See also: bzr ignore"""
1173
965
def run(self):
1174
tree = find_branch('.').working_tree()
966
tree = Branch('.').working_tree()
1175
967
for path, file_class, kind, file_id in tree.list_files():
1176
968
if file_class != 'I':
1177
969
continue
1195
987
except ValueError:
1196
988
raise BzrCommandError("not a valid revision-number: %r" % revno)
1197
989
1198
print find_branch('.').lookup_revision(revno)
990
print Branch('.').lookup_revision(revno)
1199
991
1200
992
1201
993
class cmd_export(Command):
1204
996
If no revision is specified this exports the last committed revision.
1205
997
1206
998
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1207
given, try to find the format with the extension. If no extension
1208
is found exports to a directory (equivalent to --format=dir).
1209
1210
Root may be the top directory for tar, tgz and tbz2 formats. If none
1211
is given, the top directory will be the root name of the file."""
999
given, exports to a directory (equivalent to --format=dir)."""
1212
1000
# TODO: list known exporters
1213
1001
takes_args = ['dest']
1214
takes_options = ['revision', 'format', 'root']
1215
def run(self, dest, revision=None, format=None, root=None):
1216
import os.path
1217
b = find_branch('.')
1218
if revision is None:
1219
rev_id = b.last_patch()
1002
takes_options = ['revision', 'format']
1003
def run(self, dest, revision=None, format='dir'):
1004
b = Branch('.')
1005
if revision == None:
1006
rh = b.revision_history()[-1]
1220
1007
else:
1221
if len(revision) != 1:
1222
raise BzrError('bzr export --revision takes exactly 1 argument')
1223
revno, rev_id = b.get_revision_info(revision[0])
1224
t = b.revision_tree(rev_id)
1225
root, ext = os.path.splitext(dest)
1226
if not format:
1227
if ext in (".tar",):
1228
format = "tar"
1229
elif ext in (".gz", ".tgz"):
1230
format = "tgz"
1231
elif ext in (".bz2", ".tbz2"):
1232
format = "tbz2"
1233
else:
1234
format = "dir"
1235
t.export(dest, format, root)
1008
rh = b.lookup_revision(int(revision))
1009
t = b.revision_tree(rh)
1010
t.export(dest, format)
1236
1011
1237
1012
1238
1013
class cmd_cat(Command):
1244
1019
def run(self, filename, revision=None):
1245
1020
if revision == None:
1246
1021
raise BzrCommandError("bzr cat requires a revision number")
1247
elif len(revision) != 1:
1248
raise BzrCommandError("bzr cat --revision takes exactly one number")
1249
b = find_branch('.')
1250
b.print_file(b.relpath(filename), revision[0])
1022
b = Branch('.')
1023
b.print_file(b.relpath(filename), int(revision))
1251
1024
1252
1025
1253
1026
class cmd_local_time_offset(Command):
1260
1033
1261
1034
class cmd_commit(Command):
1262
1035
"""Commit changes into a new revision.
1263
1264
If no arguments are given, the entire tree is committed.
1265
1036
1266
1037
If selected files are specified, only changes to those files are
1267
committed. If a directory is specified then the directory and everything
1268
within it is committed.
1038
committed. If a directory is specified then its contents are also
1039
committed.
1269
1040
1270
1041
A selected-file commit may fail in some cases where the committed
1271
1042
tree would be invalid, such as trying to commit a file in a
1276
1047
TODO: Strict commit that fails if there are unknown or deleted files.
1277
1048
"""
1278
1049
takes_args = ['selected*']
1279
takes_options = ['message', 'file', 'verbose', 'unchanged']
1050
takes_options = ['message', 'file', 'verbose']
1280
1051
aliases = ['ci', 'checkin']
1281
1052
1282
# TODO: Give better message for -s, --summary, used by tla people
1283
1284
def run(self, message=None, file=None, verbose=True, selected_list=None,
1285
unchanged=False):
1286
from bzrlib.errors import PointlessCommit
1287
from bzrlib.osutils import get_text_message
1053
def run(self, message=None, file=None, verbose=True, selected_list=None):
1054
from bzrlib.commit import commit
1288
1055
1289
1056
## Warning: shadows builtin file()
1290
1057
if not message and not file:
1291
# FIXME: Ugly; change status code to send to a provided function?
1292
1293
import cStringIO
1294
stdout = sys.stdout
1295
catcher = cStringIO.StringIO()
1296
sys.stdout = catcher
1297
cmd_status({"file_list":selected_list}, {})
1298
info = catcher.getvalue()
1299
sys.stdout = stdout
1300
message = get_text_message(info)
1301
1302
if message is None:
1303
raise BzrCommandError("please specify a commit message",
1304
["use either --message or --file"])
1058
raise BzrCommandError("please specify a commit message",
1059
["use either --message or --file"])
1305
1060
elif message and file:
1306
1061
raise BzrCommandError("please specify either --message or --file")
1307
1062
1309
1064
import codecs
1310
1065
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1311
1066
1312
b = find_branch('.')
1313
if selected_list:
1314
selected_list = [b.relpath(s) for s in selected_list]
1315
1316
try:
1317
b.commit(message, verbose=verbose,
1318
specific_files=selected_list,
1319
allow_pointless=unchanged)
1320
except PointlessCommit:
1321
# FIXME: This should really happen before the file is read in;
1322
# perhaps prepare the commit; get the message; then actually commit
1323
raise BzrCommandError("no changes to commit",
1324
["use --unchanged to commit anyhow"])
1067
b = Branch('.')
1068
commit(b, message, verbose=verbose, specific_files=selected_list)
1325
1069
1326
1070
1327
1071
class cmd_check(Command):
1336
1080
takes_args = ['dir?']
1337
1081
1338
1082
def run(self, dir='.'):
1339
from bzrlib.check import check
1340
check(find_branch(dir))
1341
1342
1343
1344
class cmd_scan_cache(Command):
1345
hidden = True
1346
def run(self):
1347
from bzrlib.hashcache import HashCache
1348
import os
1349
1350
c = HashCache('.')
1351
c.read()
1352
c.scan()
1353
1354
print '%6d stats' % c.stat_count
1355
print '%6d in hashcache' % len(c._cache)
1356
print '%6d files removed from cache' % c.removed_count
1357
print '%6d hashes updated' % c.update_count
1358
print '%6d files changed too recently to cache' % c.danger_count
1359
1360
if c.needs_write:
1361
c.write()
1362
1083
import bzrlib.check
1084
bzrlib.check.check(Branch(dir))
1085
1363
1086
1364
1087
1365
1088
class cmd_upgrade(Command):
1372
1095
1373
1096
def run(self, dir='.'):
1374
1097
from bzrlib.upgrade import upgrade
1375
upgrade(find_branch(dir))
1098
upgrade(Branch(dir))
1376
1099
1377
1100
1378
1101
1390
1113
class cmd_selftest(Command):
1391
1114
"""Run internal test suite"""
1392
1115
hidden = True
1393
takes_options = ['verbose']
1394
def run(self, verbose=False):
1116
def run(self):
1395
1117
from bzrlib.selftest import selftest
1396
return int(not selftest(verbose=verbose))
1118
return int(not selftest())
1397
1119
1398
1120
1399
1121
class cmd_version(Command):
1431
1153
['..', -1]
1432
1154
>>> parse_spec("../f/@35")
1433
1155
['../f', 35]
1434
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1435
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1436
1156
"""
1437
1157
if spec is None:
1438
1158
return [None, None]
1442
1162
if parsed[1] == "":
1443
1163
parsed[1] = -1
1444
1164
else:
1445
try:
1446
parsed[1] = int(parsed[1])
1447
except ValueError:
1448
pass # We can allow stuff like ./@revid:blahblahblah
1449
else:
1450
assert parsed[1] >=0
1165
parsed[1] = int(parsed[1])
1166
assert parsed[1] >=0
1451
1167
else:
1452
1168
parsed = [spec, None]
1453
1169
return parsed
1455
1171
1456
1172
1457
1173
class cmd_merge(Command):
1458
"""Perform a three-way merge.
1459
1460
The branch is the branch you will merge from. By default, it will merge
1461
the latest revision. If you specify a revision, that revision will be
1462
merged. If you specify two revisions, the first will be used as a BASE,
1463
and the second one as OTHER. Revision numbers are always relative to the
1464
specified branch.
1465
1466
Examples:
1467
1468
To merge the latest revision from bzr.dev
1469
bzr merge ../bzr.dev
1470
1471
To merge changes up to and including revision 82 from bzr.dev
1472
bzr merge -r 82 ../bzr.dev
1473
1474
To merge the changes introduced by 82, without previous changes:
1475
bzr merge -r 81..82 ../bzr.dev
1476
1174
"""Perform a three-way merge of trees.
1175
1176
The SPEC parameters are working tree or revision specifiers. Working trees
1177
are specified using standard paths or urls. No component of a directory
1178
path may begin with '@'.
1179
1180
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1181
1182
Revisions are specified using a dirname/@revno pair, where dirname is the
1183
branch directory and revno is the revision within that branch. If no revno
1184
is specified, the latest revision is used.
1185
1186
Revision examples: './@127', 'foo/@', '../@1'
1187
1188
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1189
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1190
as the BASE.
1191
1477
1192
merge refuses to run if there are any uncommitted changes, unless
1478
1193
--force is given.
1479
1194
"""
1480
takes_args = ['branch?']
1481
takes_options = ['revision', 'force', 'merge-type']
1195
takes_args = ['other_spec', 'base_spec?']
1196
takes_options = ['force']
1482
1197
1483
def run(self, branch='.', revision=None, force=False,
1484
merge_type=None):
1198
def run(self, other_spec, base_spec=None, force=False):
1485
1199
from bzrlib.merge import merge
1486
from bzrlib.merge_core import ApplyMerge3
1487
if merge_type is None:
1488
merge_type = ApplyMerge3
1489
1490
if revision is None or len(revision) < 1:
1491
base = (None, None)
1492
other = (branch, -1)
1493
else:
1494
if len(revision) == 1:
1495
other = (branch, revision[0])
1496
base = (None, None)
1497
else:
1498
assert len(revision) == 2
1499
if None in revision:
1500
raise BzrCommandError(
1501
"Merge doesn't permit that revision specifier.")
1502
base = (branch, revision[0])
1503
other = (branch, revision[1])
1504
1505
merge(other, base, check_clean=(not force), merge_type=merge_type)
1200
merge(parse_spec(other_spec), parse_spec(base_spec),
1201
check_clean=(not force))
1506
1202
1507
1203
1508
1204
class cmd_revert(Command):
1509
1205
"""Reverse all changes since the last commit.
1510
1206
1511
Only versioned files are affected. Specify filenames to revert only
1512
those files. By default, any files that are changed will be backed up
1513
first. Backup files have a '~' appended to their name.
1207
Only versioned files are affected.
1208
1209
TODO: Store backups of any files that will be reverted, so
1210
that the revert can be undone.
1514
1211
"""
1515
takes_options = ['revision', 'no-backup']
1516
takes_args = ['file*']
1517
aliases = ['merge-revert']
1212
takes_options = ['revision']
1518
1213
1519
def run(self, revision=None, no_backup=False, file_list=None):
1214
def run(self, revision=-1):
1520
1215
from bzrlib.merge import merge
1521
if file_list is not None:
1522
if len(file_list) == 0:
1523
raise BzrCommandError("No files specified")
1524
if revision is None:
1525
revision = [-1]
1526
elif len(revision) != 1:
1527
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1528
merge(('.', revision[0]), parse_spec('.'),
1216
merge(('.', revision), parse_spec('.'),
1529
1217
check_clean=False,
1530
ignore_zero=True,
1531
backup_files=not no_backup,
1532
file_list=file_list)
1218
ignore_zero=True)
1533
1219
1534
1220
1535
1221
class cmd_assert_fail(Command):
1551
1237
help.help(topic)
1552
1238
1553
1239
1554
1555
1556
class cmd_missing(Command):
1557
"""What is missing in this branch relative to other branch.
1558
"""
1559
takes_args = ['remote?']
1560
aliases = ['mis', 'miss']
1561
# We don't have to add quiet to the list, because
1562
# unknown options are parsed as booleans
1563
takes_options = ['verbose', 'quiet']
1564
1565
def run(self, remote=None, verbose=False, quiet=False):
1566
from bzrlib.branch import find_branch, DivergedBranches
1567
from bzrlib.errors import BzrCommandError
1568
from bzrlib.missing import get_parent, show_missing
1569
1570
if verbose and quiet:
1571
raise BzrCommandError('Cannot pass both quiet and verbose')
1572
1573
b = find_branch('.')
1574
parent = get_parent(b)
1575
if remote is None:
1576
if parent is None:
1577
raise BzrCommandError("No missing location known or specified.")
1578
else:
1579
if not quiet:
1580
print "Using last location: %s" % parent
1581
remote = parent
1582
elif parent is None:
1583
# We only update x-pull if it did not exist, missing should not change the parent
1584
b.controlfile('x-pull', 'wb').write(remote + '\n')
1585
br_remote = find_branch(remote)
1586
1587
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1588
1589
1590
class cmd_plugins(Command):
1591
"""List plugins"""
1240
class cmd_update_stat_cache(Command):
1241
"""Update stat-cache mapping inodes to SHA-1 hashes.
1242
1243
For testing only."""
1592
1244
hidden = True
1593
1245
def run(self):
1594
import bzrlib.plugin
1595
from inspect import getdoc
1596
from pprint import pprint
1597
for plugin in bzrlib.plugin.all_plugins:
1598
print plugin.__path__[0]
1599
d = getdoc(plugin)
1600
if d:
1601
print '\t', d.split('\n')[0]
1602
1603
#pprint(bzrlib.plugin.all_plugins)
1246
import statcache
1247
b = Branch('.')
1248
statcache.update_cache(b.base, b.read_working_inventory())
1604
1249
1605
1250
1606
1251
1619
1264
'no-recurse': None,
1620
1265
'profile': None,
1621
1266
'revision': _parse_revision_str,
1622
'short': None,
1623
1267
'show-ids': None,
1624
1268
'timezone': str,
1625
1269
'verbose': None,
1626
1270
'version': None,
1627
1271
'email': None,
1628
'unchanged': None,
1629
1272
'update': None,
1630
'long': None,
1631
'root': str,
1632
'no-backup': None,
1633
'merge-type': get_merge_type,
1634
1273
}
1635
1274
1636
1275
SHORT_OPTIONS = {
1639
1278
'm': 'message',
1640
1279
'r': 'revision',
1641
1280
'v': 'verbose',
1642
'l': 'long',
1643
1281
}
1644
1282
1645
1283
1660
1298
>>> parse_args('commit --message=biter'.split())
1661
1299
(['commit'], {'message': u'biter'})
1662
1300
>>> parse_args('log -r 500'.split())
1663
(['log'], {'revision': [500]})
1664
>>> parse_args('log -r500..600'.split())
1301
(['log'], {'revision': 500})
1302
>>> parse_args('log -r500:600'.split())
1665
1303
(['log'], {'revision': [500, 600]})
1666
>>> parse_args('log -vr500..600'.split())
1304
>>> parse_args('log -vr500:600'.split())
1667
1305
(['log'], {'verbose': True, 'revision': [500, 600]})
1668
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1669
(['log'], {'revision': ['v500', 600]})
1306
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1307
Traceback (most recent call last):
1308
...
1309
ValueError: invalid literal for int(): v500
1670
1310
"""
1671
1311
args = []
1672
1312
opts = {}
1786
1426
return argdict
1787
1427
1788
1428
1429
def _parse_master_args(argv):
1430
"""Parse the arguments that always go with the original command.
1431
These are things like bzr --no-plugins, etc.
1432
1433
There are now 2 types of option flags. Ones that come *before* the command,
1434
and ones that come *after* the command.
1435
Ones coming *before* the command are applied against all possible commands.
1436
And are generally applied before plugins are loaded.
1437
1438
The current list are:
1439
--builtin Allow plugins to load, but don't let them override builtin commands,
1440
they will still be allowed if they do not override a builtin.
1441
--no-plugins Don't load any plugins. This lets you get back to official source
1442
behavior.
1443
--profile Enable the hotspot profile before running the command.
1444
For backwards compatibility, this is also a non-master option.
1445
--version Spit out the version of bzr that is running and exit.
1446
This is also a non-master option.
1447
--help Run help and exit, also a non-master option (I think that should stay, though)
1448
1449
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1450
Traceback (most recent call last):
1451
...
1452
BzrCommandError: Invalid master option: 'test'
1453
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1454
>>> print argv
1455
['command']
1456
>>> print opts['version']
1457
True
1458
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1459
>>> print argv
1460
['command', '--more-options']
1461
>>> print opts['profile']
1462
True
1463
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1464
>>> print argv
1465
['command']
1466
>>> print opts['no-plugins']
1467
True
1468
>>> print opts['profile']
1469
False
1470
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1471
>>> print argv
1472
['command', '--profile']
1473
>>> print opts['profile']
1474
False
1475
"""
1476
master_opts = {'builtin':False,
1477
'no-plugins':False,
1478
'version':False,
1479
'profile':False,
1480
'help':False
1481
}
1482
1483
# This is the point where we could hook into argv[0] to determine
1484
# what front-end is supposed to be run
1485
# For now, we are just ignoring it.
1486
cmd_name = argv.pop(0)
1487
for arg in argv[:]:
1488
if arg[:2] != '--': # at the first non-option, we return the rest
1489
break
1490
arg = arg[2:] # Remove '--'
1491
if arg not in master_opts:
1492
# We could say that this is not an error, that we should
1493
# just let it be handled by the main section instead
1494
raise BzrCommandError('Invalid master option: %r' % arg)
1495
argv.pop(0) # We are consuming this entry
1496
master_opts[arg] = True
1497
return argv, master_opts
1498
1499
1789
1500
1790
1501
def run_bzr(argv):
1791
1502
"""Execute a command.
1792
1503
1793
1504
This is similar to main(), but without all the trappings for
1794
1505
logging and error handling.
1795
1796
argv
1797
The command-line arguments, without the program name from argv[0]
1798
1799
Returns a command status or raises an exception.
1800
1801
Special master options: these must come before the command because
1802
they control how the command is interpreted.
1803
1804
--no-plugins
1805
Do not load plugin modules at all
1806
1807
--builtin
1808
Only use builtin commands. (Plugins are still allowed to change
1809
other behaviour.)
1810
1811
--profile
1812
Run under the Python profiler.
1813
1506
"""
1814
1815
1507
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1816
1817
opt_profile = opt_no_plugins = opt_builtin = False
1818
1819
# --no-plugins is handled specially at a very early stage. We need
1820
# to load plugins before doing other command parsing so that they
1821
# can override commands, but this needs to happen first.
1822
1823
for a in argv[:]:
1824
if a == '--profile':
1825
opt_profile = True
1826
elif a == '--no-plugins':
1827
opt_no_plugins = True
1828
elif a == '--builtin':
1829
opt_builtin = True
1830
else:
1831
break
1832
argv.remove(a)
1833
1834
if not opt_no_plugins:
1835
from bzrlib.plugin import load_plugins
1836
load_plugins()
1837
1838
args, opts = parse_args(argv)
1839
1840
if 'help' in opts:
1841
from bzrlib.help import help
1842
if args:
1843
help(args[0])
1844
else:
1845
help()
1846
return 0
1847
1848
if 'version' in opts:
1849
show_version()
1850
return 0
1851
1508
1852
if not args:
1853
print >>sys.stderr, "please try 'bzr help' for help"
1509
try:
1510
# some options like --builtin and --no-plugins have special effects
1511
argv, master_opts = _parse_master_args(argv)
1512
if 'no-plugins' not in master_opts:
1513
bzrlib.load_plugins()
1514
1515
args, opts = parse_args(argv)
1516
1517
if master_opts['help']:
1518
from bzrlib.help import help
1519
if argv:
1520
help(argv[0])
1521
else:
1522
help()
1523
return 0
1524
1525
if 'help' in opts:
1526
from bzrlib.help import help
1527
if args:
1528
help(args[0])
1529
else:
1530
help()
1531
return 0
1532
elif 'version' in opts:
1533
show_version()
1534
return 0
1535
elif args and args[0] == 'builtin':
1536
include_plugins=False
1537
args = args[1:]
1538
cmd = str(args.pop(0))
1539
except IndexError:
1540
import help
1541
help.help()
1854
1542
return 1
1855
1856
cmd = str(args.pop(0))
1857
1858
canonical_cmd, cmd_class = \
1859
get_cmd_class(cmd, plugins_override=not opt_builtin)
1543
1544
1545
plugins_override = not (master_opts['builtin'])
1546
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1547
1548
profile = master_opts['profile']
1549
# For backwards compatibility, I would rather stick with --profile being a
1550
# master/global option
1551
if 'profile' in opts:
1552
profile = True
1553
del opts['profile']
1860
1554
1861
1555
# check options are reasonable
1862
1556
allowed = cmd_class.takes_options
1871
1565
for k, v in opts.items():
1872
1566
cmdopts[k.replace('-', '_')] = v
1873
1567
1874
if opt_profile:
1568
if profile:
1875
1569
import hotshot, tempfile
1876
1570
pffileno, pfname = tempfile.mkstemp()
1877
1571
try:
1898
1592
1899
1593
def _report_exception(summary, quiet=False):
1900
1594
import traceback
1901
1902
1595
log_error('bzr: ' + summary)
1903
1596
bzrlib.trace.log_exception()
1904
1597
1905
if os.environ.get('BZR_DEBUG'):
1906
traceback.print_exc()
1907
1908
1598
if not quiet:
1909
sys.stderr.write('\n')
1910
1599
tb = sys.exc_info()[2]
1911
1600
exinfo = traceback.extract_tb(tb)
1912
1601
if exinfo:
1916
1605
1917
1606
1918
1607
def main(argv):
1608
import errno
1919
1609
1920
bzrlib.trace.open_tracefile(argv)
1610
bzrlib.open_tracefile(argv)
1921
1611
1922
1612
try:
1923
1613
try:
1924
1614
try:
1925
return run_bzr(argv[1:])
1615
return run_bzr(argv)
1926
1616
finally:
1927
1617
# do this here inside the exception wrappers to catch EPIPE
1928
1618
sys.stdout.flush()
1929
1619
except BzrError, e:
1930
1620
quiet = isinstance(e, (BzrCommandError))
1931
_report_exception('error: ' + str(e), quiet=quiet)
1621
_report_exception('error: ' + e.args[0], quiet=quiet)
1932
1622
if len(e.args) > 1:
1933
1623
for h in e.args[1]:
1934
1624
# some explanation or hints
1944
1634
_report_exception('interrupted', quiet=True)
1945
1635
return 2
1946
1636
except Exception, e:
1947
import errno
1948
1637
quiet = False
1949
1638
if (isinstance(e, IOError)
1950
1639
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1