« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 788
- compare with another revision
- download diff
- download tarball
- view history from revision 788
- Committer: Martin Pool
- Date: 2005-06-27 01:26:11 UTC
- Revision ID: mbp@sourcefrog.net-20050627012611-4effb7007553fde1
- tweak rsync upload script
- files added:
- bzrlib/statcache.py
- plugins/changeset
- files removed:
- HACKING
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/plugins/ => plugins/
- 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 = {}
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)
363
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
464
364
465
365
466
366
472
372
takes_args = ['dir+']
473
373
474
374
def run(self, dir_list):
375
import os
376
import bzrlib.branch
377
475
378
b = None
476
379
477
380
for d in dir_list:
478
381
os.mkdir(d)
479
382
if not b:
480
b = find_branch(d)
383
b = bzrlib.branch.Branch(d)
481
384
b.add([d], verbose=True)
482
385
483
386
487
390
hidden = True
488
391
489
392
def run(self, filename):
490
print find_branch(filename).relpath(filename)
393
print Branch(filename).relpath(filename)
491
394
492
395
493
396
496
399
takes_options = ['revision', 'show-ids']
497
400
498
401
def run(self, revision=None, show_ids=False):
499
b = find_branch('.')
402
b = Branch('.')
500
403
if revision == None:
501
404
inv = b.read_working_inventory()
502
405
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]))
406
inv = b.get_revision_inventory(b.lookup_revision(revision))
507
407
508
408
for path, entry in inv.entries():
509
409
if show_ids:
522
422
"""
523
423
takes_args = ['source$', 'dest']
524
424
def run(self, source_list, dest):
525
b = find_branch('.')
425
b = Branch('.')
526
426
527
# TODO: glob expansion on windows?
528
427
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
529
428
530
429
545
444
takes_args = ['from_name', 'to_name']
546
445
547
446
def run(self, from_name, to_name):
548
b = find_branch('.')
447
b = Branch('.')
549
448
b.rename_one(b.relpath(from_name), b.relpath(to_name))
550
449
551
450
552
451
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
452
585
453
586
454
class cmd_pull(Command):
601
469
602
470
def run(self, location=None):
603
471
from bzrlib.merge import merge
604
import tempfile
605
from shutil import rmtree
606
472
import errno
607
473
608
br_to = find_branch('.')
474
br_to = Branch('.')
609
475
stored_loc = None
610
476
try:
611
477
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
612
478
except IOError, e:
613
if e.errno != errno.ENOENT:
479
if errno == errno.ENOENT:
614
480
raise
615
481
if location is None:
616
482
if stored_loc is None:
618
484
else:
619
485
print "Using last location: %s" % stored_loc
620
486
location = stored_loc
621
cache_root = tempfile.mkdtemp()
622
from bzrlib.branch import DivergedBranches
487
from branch import find_branch, DivergedBranches
623
488
br_from = find_branch(location)
624
489
location = pull_loc(br_from)
625
490
old_revno = br_to.revno()
626
491
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)
492
br_to.update_revisions(br_from)
493
except DivergedBranches:
494
raise BzrCommandError("These branches have diverged. Try merge.")
495
496
merge(('.', -1), ('.', old_revno), check_clean=False)
497
if location != stored_loc:
498
br_to.controlfile("x-pull", "wb").write(location + "\n")
642
499
643
500
644
501
653
510
"""
654
511
takes_args = ['from_location', 'to_location?']
655
512
takes_options = ['revision']
656
aliases = ['get', 'clone']
657
513
658
514
def run(self, from_location, to_location=None, revision=None):
659
515
import errno
660
516
from bzrlib.merge import merge
661
from bzrlib.branch import DivergedBranches, \
662
find_cached_branch, Branch
517
from branch import find_branch, DivergedBranches, NoSuchRevision
663
518
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)
519
try:
520
br_from = find_branch(from_location)
521
except OSError, e:
522
if e.errno == errno.ENOENT:
523
raise BzrCommandError('Source location "%s" does not exist.' %
524
to_location)
525
else:
526
raise
527
528
if to_location is None:
529
to_location = os.path.basename(from_location.rstrip("/\\"))
530
531
try:
532
os.mkdir(to_location)
533
except OSError, e:
534
if e.errno == errno.EEXIST:
535
raise BzrCommandError('Target directory "%s" already exists.' %
536
to_location)
537
if e.errno == errno.ENOENT:
538
raise BzrCommandError('Parent of "%s" does not exist.' %
539
to_location)
540
else:
541
raise
542
br_to = Branch(to_location, init=True)
543
544
try:
545
br_to.update_revisions(br_from, stop_revision=revision)
546
except NoSuchRevision:
547
rmtree(to_location)
548
msg = "The branch %s has no revision %d." % (from_location,
549
revision)
550
raise BzrCommandError(msg)
551
merge((to_location, -1), (to_location, 0), this_dir=to_location,
552
check_clean=False, ignore_zero=True)
553
from_location = pull_loc(br_from)
554
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
720
555
721
556
722
557
def pull_loc(branch):
739
574
takes_args = ['dir?']
740
575
741
576
def run(self, dir='.'):
742
b = find_branch(dir)
577
b = Branch(dir)
743
578
old_inv = b.basis_tree().inventory
744
579
new_inv = b.read_working_inventory()
745
580
756
591
def run(self, branch=None):
757
592
import info
758
593
594
from branch import find_branch
759
595
b = find_branch(branch)
760
596
info.show_info(b)
761
597
770
606
takes_options = ['verbose']
771
607
772
608
def run(self, file_list, verbose=False):
773
b = find_branch(file_list[0])
609
b = Branch(file_list[0])
774
610
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
775
611
776
612
784
620
hidden = True
785
621
takes_args = ['filename']
786
622
def run(self, filename):
787
b = find_branch(filename)
623
b = Branch(filename)
788
624
i = b.inventory.path2id(b.relpath(filename))
789
625
if i == None:
790
626
raise BzrError("%r is not a versioned file" % filename)
800
636
hidden = True
801
637
takes_args = ['filename']
802
638
def run(self, filename):
803
b = find_branch(filename)
639
b = Branch(filename)
804
640
inv = b.inventory
805
641
fid = inv.path2id(b.relpath(filename))
806
642
if fid == None:
813
649
"""Display list of revision ids on this branch."""
814
650
hidden = True
815
651
def run(self):
816
for patchid in find_branch('.').revision_history():
652
for patchid in Branch('.').revision_history():
817
653
print patchid
818
654
819
655
820
656
class cmd_directories(Command):
821
657
"""Display list of versioned directories in this branch."""
822
658
def run(self):
823
for name, ie in find_branch('.').read_working_inventory().directories():
659
for name, ie in Branch('.').read_working_inventory().directories():
824
660
if name == '':
825
661
print '.'
826
662
else:
841
677
bzr commit -m 'imported project'
842
678
"""
843
679
def run(self):
844
from bzrlib.branch import Branch
845
680
Branch('.', init=True)
846
681
847
682
851
686
If files are listed, only the changes in those files are listed.
852
687
Otherwise, all changes for the tree are listed.
853
688
689
TODO: Given two revision arguments, show the difference between them.
690
854
691
TODO: Allow diff across branches.
855
692
856
693
TODO: Option to use external diff command; could be GNU diff, wdiff,
865
702
deleted files.
866
703
867
704
TODO: This probably handles non-Unix newlines poorly.
868
869
examples:
870
bzr diff
871
bzr diff -r1
872
bzr diff -r1:2
873
705
"""
874
706
875
707
takes_args = ['file*']
878
710
879
711
def run(self, revision=None, file_list=None, diff_options=None):
880
712
from bzrlib.diff import show_diff
713
from bzrlib import find_branch
881
714
882
715
if file_list:
883
716
b = find_branch(file_list[0])
886
719
# just pointing to top-of-tree
887
720
file_list = None
888
721
else:
889
b = find_branch('.')
722
b = Branch('.')
723
724
show_diff(b, revision, specific_files=file_list,
725
external_diff_options=diff_options)
890
726
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
727
905
728
906
729
911
734
TODO: Show files deleted since a previous revision, or between two revisions.
912
735
"""
913
736
def run(self, show_ids=False):
914
b = find_branch('.')
737
b = Branch('.')
915
738
old = b.basis_tree()
916
739
new = b.working_tree()
917
740
932
755
"""List files modified in working tree."""
933
756
hidden = True
934
757
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
758
import statcache
759
b = Branch('.')
760
inv = b.read_working_inventory()
761
sc = statcache.update_cache(b, inv)
762
basis = b.basis_tree()
763
basis_inv = basis.inventory
764
765
# We used to do this through iter_entries(), but that's slow
766
# when most of the files are unmodified, as is usually the
767
# case. So instead we iterate by inventory entry, and only
768
# calculate paths as necessary.
769
770
for file_id in basis_inv:
771
cacheentry = sc.get(file_id)
772
if not cacheentry: # deleted
773
continue
774
ie = basis_inv[file_id]
775
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
776
path = inv.id2path(file_id)
777
print path
942
778
943
779
944
780
946
782
"""List files added in working tree."""
947
783
hidden = True
948
784
def run(self):
949
b = find_branch('.')
785
b = Branch('.')
950
786
wt = b.working_tree()
951
787
basis_inv = b.basis_tree().inventory
952
788
inv = wt.inventory
968
804
takes_args = ['filename?']
969
805
def run(self, filename=None):
970
806
"""Print the branch root."""
807
from branch import find_branch
971
808
b = find_branch(filename)
972
809
print getattr(b, 'base', None) or getattr(b, 'baseurl')
973
810
979
816
-r revision requests a specific revision, -r :end or -r begin: are
980
817
also valid.
981
818
982
--message allows you to give a regular expression, which will be evaluated
983
so that only matching entries will be displayed.
984
985
819
TODO: Make --revision support uuid: and hash: [future tag:] notation.
986
820
987
821
"""
988
822
989
823
takes_args = ['filename?']
990
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
991
'long', 'message', 'short',]
824
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
992
825
993
826
def run(self, filename=None, timezone='original',
994
827
verbose=False,
995
828
show_ids=False,
996
829
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
830
revision=None):
831
from bzrlib import show_log, find_branch
1003
832
import codecs
1004
833
1005
834
direction = (forward and 'forward') or 'reverse'
1015
844
b = find_branch('.')
1016
845
file_id = None
1017
846
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]
847
if revision == None:
848
revision = [None, None]
849
elif isinstance(revision, int):
850
revision = [revision, revision]
1026
851
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
852
# pair of revisions?
853
pass
854
855
assert len(revision) == 2
1033
856
1034
857
mutter('encoding log as %r' % bzrlib.user_encoding)
1035
858
1037
860
# in e.g. the default C locale.
1038
861
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1039
862
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,
863
show_log(b, file_id,
864
show_timezone=timezone,
1052
865
verbose=verbose,
866
show_ids=show_ids,
867
to_file=outf,
1053
868
direction=direction,
1054
start_revision=rev1,
1055
end_revision=rev2,
1056
search=message)
869
start_revision=revision[0],
870
end_revision=revision[1])
1057
871
1058
872
1059
873
1064
878
hidden = True
1065
879
takes_args = ["filename"]
1066
880
def run(self, filename):
1067
b = find_branch(filename)
881
b = Branch(filename)
1068
882
inv = b.read_working_inventory()
1069
883
file_id = inv.path2id(b.relpath(filename))
1070
884
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1078
892
"""
1079
893
hidden = True
1080
894
def run(self, revision=None, verbose=False):
1081
b = find_branch('.')
895
b = Branch('.')
1082
896
if revision == None:
1083
897
tree = b.working_tree()
1084
898
else:
1102
916
class cmd_unknowns(Command):
1103
917
"""List unknown files."""
1104
918
def run(self):
1105
from bzrlib.osutils import quotefn
1106
for f in find_branch('.').unknowns():
919
for f in Branch('.').unknowns():
1107
920
print quotefn(f)
1108
921
1109
922
1131
944
from bzrlib.atomicfile import AtomicFile
1132
945
import os.path
1133
946
1134
b = find_branch('.')
947
b = Branch('.')
1135
948
ifn = b.abspath('.bzrignore')
1136
949
1137
950
if os.path.exists(ifn):
1171
984
1172
985
See also: bzr ignore"""
1173
986
def run(self):
1174
tree = find_branch('.').working_tree()
987
tree = Branch('.').working_tree()
1175
988
for path, file_class, kind, file_id in tree.list_files():
1176
989
if file_class != 'I':
1177
990
continue
1195
1008
except ValueError:
1196
1009
raise BzrCommandError("not a valid revision-number: %r" % revno)
1197
1010
1198
print find_branch('.').lookup_revision(revno)
1011
print Branch('.').lookup_revision(revno)
1199
1012
1200
1013
1201
1014
class cmd_export(Command):
1204
1017
If no revision is specified this exports the last committed revision.
1205
1018
1206
1019
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."""
1020
given, exports to a directory (equivalent to --format=dir)."""
1212
1021
# TODO: list known exporters
1213
1022
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()
1023
takes_options = ['revision', 'format']
1024
def run(self, dest, revision=None, format='dir'):
1025
b = Branch('.')
1026
if revision == None:
1027
rh = b.revision_history()[-1]
1220
1028
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)
1029
rh = b.lookup_revision(int(revision))
1030
t = b.revision_tree(rh)
1031
t.export(dest, format)
1236
1032
1237
1033
1238
1034
class cmd_cat(Command):
1244
1040
def run(self, filename, revision=None):
1245
1041
if revision == None:
1246
1042
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])
1043
b = Branch('.')
1044
b.print_file(b.relpath(filename), int(revision))
1251
1045
1252
1046
1253
1047
class cmd_local_time_offset(Command):
1260
1054
1261
1055
class cmd_commit(Command):
1262
1056
"""Commit changes into a new revision.
1263
1264
If no arguments are given, the entire tree is committed.
1265
1057
1266
1058
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.
1059
committed. If a directory is specified then its contents are also
1060
committed.
1269
1061
1270
1062
A selected-file commit may fail in some cases where the committed
1271
1063
tree would be invalid, such as trying to commit a file in a
1276
1068
TODO: Strict commit that fails if there are unknown or deleted files.
1277
1069
"""
1278
1070
takes_args = ['selected*']
1279
takes_options = ['message', 'file', 'verbose', 'unchanged']
1071
takes_options = ['message', 'file', 'verbose']
1280
1072
aliases = ['ci', 'checkin']
1281
1073
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
1074
def run(self, message=None, file=None, verbose=True, selected_list=None):
1075
from bzrlib.commit import commit
1287
1076
from bzrlib.osutils import get_text_message
1288
1077
1289
1078
## Warning: shadows builtin file()
1290
1079
if not message and not file:
1291
# FIXME: Ugly; change status code to send to a provided function?
1292
1293
1080
import cStringIO
1294
1081
stdout = sys.stdout
1295
1082
catcher = cStringIO.StringIO()
1309
1096
import codecs
1310
1097
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1311
1098
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"])
1099
b = Branch('.')
1100
commit(b, message, verbose=verbose, specific_files=selected_list)
1325
1101
1326
1102
1327
1103
class cmd_check(Command):
1336
1112
takes_args = ['dir?']
1337
1113
1338
1114
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
1115
import bzrlib.check
1116
bzrlib.check.check(Branch(dir))
1117
1363
1118
1364
1119
1365
1120
class cmd_upgrade(Command):
1372
1127
1373
1128
def run(self, dir='.'):
1374
1129
from bzrlib.upgrade import upgrade
1375
upgrade(find_branch(dir))
1130
upgrade(Branch(dir))
1376
1131
1377
1132
1378
1133
1390
1145
class cmd_selftest(Command):
1391
1146
"""Run internal test suite"""
1392
1147
hidden = True
1393
takes_options = ['verbose']
1394
def run(self, verbose=False):
1148
def run(self):
1395
1149
from bzrlib.selftest import selftest
1396
return int(not selftest(verbose=verbose))
1150
return int(not selftest())
1397
1151
1398
1152
1399
1153
class cmd_version(Command):
1431
1185
['..', -1]
1432
1186
>>> parse_spec("../f/@35")
1433
1187
['../f', 35]
1434
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1435
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1436
1188
"""
1437
1189
if spec is None:
1438
1190
return [None, None]
1442
1194
if parsed[1] == "":
1443
1195
parsed[1] = -1
1444
1196
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
1197
parsed[1] = int(parsed[1])
1198
assert parsed[1] >=0
1451
1199
else:
1452
1200
parsed = [spec, None]
1453
1201
return parsed
1455
1203
1456
1204
1457
1205
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
1206
"""Perform a three-way merge of trees.
1207
1208
The SPEC parameters are working tree or revision specifiers. Working trees
1209
are specified using standard paths or urls. No component of a directory
1210
path may begin with '@'.
1211
1212
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1213
1214
Revisions are specified using a dirname/@revno pair, where dirname is the
1215
branch directory and revno is the revision within that branch. If no revno
1216
is specified, the latest revision is used.
1217
1218
Revision examples: './@127', 'foo/@', '../@1'
1219
1220
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1221
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1222
as the BASE.
1223
1477
1224
merge refuses to run if there are any uncommitted changes, unless
1478
1225
--force is given.
1479
1226
"""
1480
takes_args = ['branch?']
1481
takes_options = ['revision', 'force', 'merge-type']
1227
takes_args = ['other_spec', 'base_spec?']
1228
takes_options = ['force']
1482
1229
1483
def run(self, branch='.', revision=None, force=False,
1484
merge_type=None):
1230
def run(self, other_spec, base_spec=None, force=False):
1485
1231
from bzrlib.merge import merge
1486
from bzrlib.merge_core import ApplyMerge3
1487
if merge_type is None:
1488
merge_type = ApplyMerge3
1232
merge(parse_spec(other_spec), parse_spec(base_spec),
1233
check_clean=(not force))
1489
1234
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)
1506
1235
1507
1236
1508
1237
class cmd_revert(Command):
1238
"""Restore selected files from a previous revision.
1239
"""
1240
takes_args = ['file+']
1241
def run(self, file_list):
1242
from bzrlib.branch import find_branch
1243
1244
if not file_list:
1245
file_list = ['.']
1246
1247
b = find_branch(file_list[0])
1248
1249
b.revert([b.relpath(f) for f in file_list])
1250
1251
1252
class cmd_merge_revert(Command):
1509
1253
"""Reverse all changes since the last commit.
1510
1254
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.
1255
Only versioned files are affected.
1256
1257
TODO: Store backups of any files that will be reverted, so
1258
that the revert can be undone.
1514
1259
"""
1515
takes_options = ['revision', 'no-backup']
1516
takes_args = ['file*']
1517
aliases = ['merge-revert']
1260
takes_options = ['revision']
1518
1261
1519
def run(self, revision=None, no_backup=False, file_list=None):
1262
def run(self, revision=-1):
1520
1263
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('.'),
1264
merge(('.', revision), parse_spec('.'),
1529
1265
check_clean=False,
1530
ignore_zero=True,
1531
backup_files=not no_backup,
1532
file_list=file_list)
1266
ignore_zero=True)
1533
1267
1534
1268
1535
1269
class cmd_assert_fail(Command):
1551
1285
help.help(topic)
1552
1286
1553
1287
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)
1288
class cmd_update_stat_cache(Command):
1289
"""Update stat-cache mapping inodes to SHA-1 hashes.
1290
1291
For testing only."""
1292
hidden = True
1293
def run(self):
1294
import statcache
1295
b = Branch('.')
1296
statcache.update_cache(b.base, b.read_working_inventory())
1297
1588
1298
1589
1299
1590
1300
class cmd_plugins(Command):
1592
1302
hidden = True
1593
1303
def run(self):
1594
1304
import bzrlib.plugin
1595
from inspect import getdoc
1596
1305
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)
1306
pprint(bzrlib.plugin.all_plugins)
1604
1307
1605
1308
1606
1309
1619
1322
'no-recurse': None,
1620
1323
'profile': None,
1621
1324
'revision': _parse_revision_str,
1622
'short': None,
1623
1325
'show-ids': None,
1624
1326
'timezone': str,
1625
1327
'verbose': None,
1626
1328
'version': None,
1627
1329
'email': None,
1628
'unchanged': None,
1629
1330
'update': None,
1630
'long': None,
1631
'root': str,
1632
'no-backup': None,
1633
'merge-type': get_merge_type,
1634
1331
}
1635
1332
1636
1333
SHORT_OPTIONS = {
1639
1336
'm': 'message',
1640
1337
'r': 'revision',
1641
1338
'v': 'verbose',
1642
'l': 'long',
1643
1339
}
1644
1340
1645
1341
1660
1356
>>> parse_args('commit --message=biter'.split())
1661
1357
(['commit'], {'message': u'biter'})
1662
1358
>>> parse_args('log -r 500'.split())
1663
(['log'], {'revision': [500]})
1664
>>> parse_args('log -r500..600'.split())
1359
(['log'], {'revision': 500})
1360
>>> parse_args('log -r500:600'.split())
1665
1361
(['log'], {'revision': [500, 600]})
1666
>>> parse_args('log -vr500..600'.split())
1362
>>> parse_args('log -vr500:600'.split())
1667
1363
(['log'], {'verbose': True, 'revision': [500, 600]})
1668
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1669
(['log'], {'revision': ['v500', 600]})
1364
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1365
Traceback (most recent call last):
1366
...
1367
ValueError: invalid literal for int(): v500
1670
1368
"""
1671
1369
args = []
1672
1370
opts = {}
1786
1484
return argdict
1787
1485
1788
1486
1487
def _parse_master_args(argv):
1488
"""Parse the arguments that always go with the original command.
1489
These are things like bzr --no-plugins, etc.
1490
1491
There are now 2 types of option flags. Ones that come *before* the command,
1492
and ones that come *after* the command.
1493
Ones coming *before* the command are applied against all possible commands.
1494
And are generally applied before plugins are loaded.
1495
1496
The current list are:
1497
--builtin Allow plugins to load, but don't let them override builtin commands,
1498
they will still be allowed if they do not override a builtin.
1499
--no-plugins Don't load any plugins. This lets you get back to official source
1500
behavior.
1501
--profile Enable the hotspot profile before running the command.
1502
For backwards compatibility, this is also a non-master option.
1503
--version Spit out the version of bzr that is running and exit.
1504
This is also a non-master option.
1505
--help Run help and exit, also a non-master option (I think that should stay, though)
1506
1507
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1508
Traceback (most recent call last):
1509
...
1510
BzrCommandError: Invalid master option: 'test'
1511
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1512
>>> print argv
1513
['command']
1514
>>> print opts['version']
1515
True
1516
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1517
>>> print argv
1518
['command', '--more-options']
1519
>>> print opts['profile']
1520
True
1521
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1522
>>> print argv
1523
['command']
1524
>>> print opts['no-plugins']
1525
True
1526
>>> print opts['profile']
1527
False
1528
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1529
>>> print argv
1530
['command', '--profile']
1531
>>> print opts['profile']
1532
False
1533
"""
1534
master_opts = {'builtin':False,
1535
'no-plugins':False,
1536
'version':False,
1537
'profile':False,
1538
'help':False
1539
}
1540
1541
# This is the point where we could hook into argv[0] to determine
1542
# what front-end is supposed to be run
1543
# For now, we are just ignoring it.
1544
cmd_name = argv.pop(0)
1545
for arg in argv[:]:
1546
if arg[:2] != '--': # at the first non-option, we return the rest
1547
break
1548
arg = arg[2:] # Remove '--'
1549
if arg not in master_opts:
1550
# We could say that this is not an error, that we should
1551
# just let it be handled by the main section instead
1552
raise BzrCommandError('Invalid master option: %r' % arg)
1553
argv.pop(0) # We are consuming this entry
1554
master_opts[arg] = True
1555
return argv, master_opts
1556
1557
1789
1558
1790
1559
def run_bzr(argv):
1791
1560
"""Execute a command.
1792
1561
1793
1562
This is similar to main(), but without all the trappings for
1794
1563
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
1564
"""
1814
1815
1565
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
1566
1852
if not args:
1853
print >>sys.stderr, "please try 'bzr help' for help"
1567
try:
1568
# some options like --builtin and --no-plugins have special effects
1569
argv, master_opts = _parse_master_args(argv)
1570
if not master_opts['no-plugins']:
1571
bzrlib.load_plugins()
1572
1573
args, opts = parse_args(argv)
1574
1575
if master_opts['help']:
1576
from bzrlib.help import help
1577
if argv:
1578
help(argv[0])
1579
else:
1580
help()
1581
return 0
1582
1583
if 'help' in opts:
1584
from bzrlib.help import help
1585
if args:
1586
help(args[0])
1587
else:
1588
help()
1589
return 0
1590
elif 'version' in opts:
1591
show_version()
1592
return 0
1593
elif args and args[0] == 'builtin':
1594
include_plugins=False
1595
args = args[1:]
1596
cmd = str(args.pop(0))
1597
except IndexError:
1598
import help
1599
help.help()
1854
1600
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)
1601
1602
1603
plugins_override = not (master_opts['builtin'])
1604
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1605
1606
profile = master_opts['profile']
1607
# For backwards compatibility, I would rather stick with --profile being a
1608
# master/global option
1609
if 'profile' in opts:
1610
profile = True
1611
del opts['profile']
1860
1612
1861
1613
# check options are reasonable
1862
1614
allowed = cmd_class.takes_options
1871
1623
for k, v in opts.items():
1872
1624
cmdopts[k.replace('-', '_')] = v
1873
1625
1874
if opt_profile:
1626
if profile:
1875
1627
import hotshot, tempfile
1876
1628
pffileno, pfname = tempfile.mkstemp()
1877
1629
try:
1898
1650
1899
1651
def _report_exception(summary, quiet=False):
1900
1652
import traceback
1901
1902
1653
log_error('bzr: ' + summary)
1903
1654
bzrlib.trace.log_exception()
1904
1655
1905
if os.environ.get('BZR_DEBUG'):
1906
traceback.print_exc()
1907
1908
1656
if not quiet:
1909
sys.stderr.write('\n')
1910
1657
tb = sys.exc_info()[2]
1911
1658
exinfo = traceback.extract_tb(tb)
1912
1659
if exinfo:
1916
1663
1917
1664
1918
1665
def main(argv):
1666
import errno
1919
1667
1920
bzrlib.trace.open_tracefile(argv)
1668
bzrlib.open_tracefile(argv)
1921
1669
1922
1670
try:
1923
1671
try:
1924
1672
try:
1925
return run_bzr(argv[1:])
1673
return run_bzr(argv)
1926
1674
finally:
1927
1675
# do this here inside the exception wrappers to catch EPIPE
1928
1676
sys.stdout.flush()
1929
1677
except BzrError, e:
1930
1678
quiet = isinstance(e, (BzrCommandError))
1931
_report_exception('error: ' + str(e), quiet=quiet)
1679
_report_exception('error: ' + e.args[0], quiet=quiet)
1932
1680
if len(e.args) > 1:
1933
1681
for h in e.args[1]:
1934
1682
# some explanation or hints
1944
1692
_report_exception('interrupted', quiet=True)
1945
1693
return 2
1946
1694
except Exception, e:
1947
import errno
1948
1695
quiet = False
1949
1696
if (isinstance(e, IOError)
1950
1697
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1