« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 742
- compare with another revision
- download diff
- download tarball
- view history from revision 742
- Committer: Martin Pool
- Date: 2005-06-22 07:18:01 UTC
- Revision ID: mbp@sourcefrog.net-20050622071801-916bbae5bd93cf0a
- new mkdir command
- 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)
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
1287
from bzrlib.osutils import get_text_message
1074
def run(self, message=None, file=None, verbose=True, selected_list=None):
1075
from bzrlib.commit import commit
1288
1076
1289
1077
## Warning: shadows builtin file()
1290
1078
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"])
1079
raise BzrCommandError("please specify a commit message",
1080
["use either --message or --file"])
1305
1081
elif message and file:
1306
1082
raise BzrCommandError("please specify either --message or --file")
1307
1083
1309
1085
import codecs
1310
1086
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1311
1087
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"])
1088
b = Branch('.')
1089
commit(b, message, verbose=verbose, specific_files=selected_list)
1325
1090
1326
1091
1327
1092
class cmd_check(Command):
1336
1101
takes_args = ['dir?']
1337
1102
1338
1103
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
1104
import bzrlib.check
1105
bzrlib.check.check(Branch(dir))
1106
1363
1107
1364
1108
1365
1109
class cmd_upgrade(Command):
1372
1116
1373
1117
def run(self, dir='.'):
1374
1118
from bzrlib.upgrade import upgrade
1375
upgrade(find_branch(dir))
1119
upgrade(Branch(dir))
1376
1120
1377
1121
1378
1122
1381
1125
takes_options = ['email']
1382
1126
1383
1127
def run(self, email=False):
1384
try:
1385
b = bzrlib.branch.find_branch('.')
1386
except:
1387
b = None
1388
1389
1128
if email:
1390
print bzrlib.osutils.user_email(b)
1129
print bzrlib.osutils.user_email()
1391
1130
else:
1392
print bzrlib.osutils.username(b)
1131
print bzrlib.osutils.username()
1393
1132
1394
1133
1395
1134
class cmd_selftest(Command):
1396
1135
"""Run internal test suite"""
1397
1136
hidden = True
1398
takes_options = ['verbose']
1399
def run(self, verbose=False):
1137
def run(self):
1400
1138
from bzrlib.selftest import selftest
1401
return int(not selftest(verbose=verbose))
1139
return int(not selftest())
1402
1140
1403
1141
1404
1142
class cmd_version(Command):
1436
1174
['..', -1]
1437
1175
>>> parse_spec("../f/@35")
1438
1176
['../f', 35]
1439
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1440
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1441
1177
"""
1442
1178
if spec is None:
1443
1179
return [None, None]
1447
1183
if parsed[1] == "":
1448
1184
parsed[1] = -1
1449
1185
else:
1450
try:
1451
parsed[1] = int(parsed[1])
1452
except ValueError:
1453
pass # We can allow stuff like ./@revid:blahblahblah
1454
else:
1455
assert parsed[1] >=0
1186
parsed[1] = int(parsed[1])
1187
assert parsed[1] >=0
1456
1188
else:
1457
1189
parsed = [spec, None]
1458
1190
return parsed
1460
1192
1461
1193
1462
1194
class cmd_merge(Command):
1463
"""Perform a three-way merge.
1464
1465
The branch is the branch you will merge from. By default, it will merge
1466
the latest revision. If you specify a revision, that revision will be
1467
merged. If you specify two revisions, the first will be used as a BASE,
1468
and the second one as OTHER. Revision numbers are always relative to the
1469
specified branch.
1470
1471
Examples:
1472
1473
To merge the latest revision from bzr.dev
1474
bzr merge ../bzr.dev
1475
1476
To merge changes up to and including revision 82 from bzr.dev
1477
bzr merge -r 82 ../bzr.dev
1478
1479
To merge the changes introduced by 82, without previous changes:
1480
bzr merge -r 81..82 ../bzr.dev
1481
1195
"""Perform a three-way merge of trees.
1196
1197
The SPEC parameters are working tree or revision specifiers. Working trees
1198
are specified using standard paths or urls. No component of a directory
1199
path may begin with '@'.
1200
1201
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1202
1203
Revisions are specified using a dirname/@revno pair, where dirname is the
1204
branch directory and revno is the revision within that branch. If no revno
1205
is specified, the latest revision is used.
1206
1207
Revision examples: './@127', 'foo/@', '../@1'
1208
1209
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1210
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1211
as the BASE.
1212
1482
1213
merge refuses to run if there are any uncommitted changes, unless
1483
1214
--force is given.
1484
1215
"""
1485
takes_args = ['branch?']
1486
takes_options = ['revision', 'force', 'merge-type']
1216
takes_args = ['other_spec', 'base_spec?']
1217
takes_options = ['force']
1487
1218
1488
def run(self, branch='.', revision=None, force=False,
1489
merge_type=None):
1219
def run(self, other_spec, base_spec=None, force=False):
1490
1220
from bzrlib.merge import merge
1491
from bzrlib.merge_core import ApplyMerge3
1492
if merge_type is None:
1493
merge_type = ApplyMerge3
1494
1495
if revision is None or len(revision) < 1:
1496
base = (None, None)
1497
other = (branch, -1)
1498
else:
1499
if len(revision) == 1:
1500
other = (branch, revision[0])
1501
base = (None, None)
1502
else:
1503
assert len(revision) == 2
1504
if None in revision:
1505
raise BzrCommandError(
1506
"Merge doesn't permit that revision specifier.")
1507
base = (branch, revision[0])
1508
other = (branch, revision[1])
1509
1510
merge(other, base, check_clean=(not force), merge_type=merge_type)
1221
merge(parse_spec(other_spec), parse_spec(base_spec),
1222
check_clean=(not force))
1511
1223
1512
1224
1513
1225
class cmd_revert(Command):
1514
1226
"""Reverse all changes since the last commit.
1515
1227
1516
Only versioned files are affected. Specify filenames to revert only
1517
those files. By default, any files that are changed will be backed up
1518
first. Backup files have a '~' appended to their name.
1228
Only versioned files are affected.
1229
1230
TODO: Store backups of any files that will be reverted, so
1231
that the revert can be undone.
1519
1232
"""
1520
takes_options = ['revision', 'no-backup']
1521
takes_args = ['file*']
1522
aliases = ['merge-revert']
1233
takes_options = ['revision']
1523
1234
1524
def run(self, revision=None, no_backup=False, file_list=None):
1235
def run(self, revision=-1):
1525
1236
from bzrlib.merge import merge
1526
if file_list is not None:
1527
if len(file_list) == 0:
1528
raise BzrCommandError("No files specified")
1529
if revision is None:
1530
revision = [-1]
1531
elif len(revision) != 1:
1532
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1533
merge(('.', revision[0]), parse_spec('.'),
1237
merge(('.', revision), parse_spec('.'),
1534
1238
check_clean=False,
1535
ignore_zero=True,
1536
backup_files=not no_backup,
1537
file_list=file_list)
1239
ignore_zero=True)
1538
1240
1539
1241
1540
1242
class cmd_assert_fail(Command):
1556
1258
help.help(topic)
1557
1259
1558
1260
1559
class cmd_shell_complete(Command):
1560
"""Show appropriate completions for context.
1561
1562
For a list of all available commands, say 'bzr shell-complete'."""
1563
takes_args = ['context?']
1564
aliases = ['s-c']
1565
hidden = True
1566
1567
def run(self, context=None):
1568
import shellcomplete
1569
shellcomplete.shellcomplete(context)
1570
1571
1572
class cmd_missing(Command):
1573
"""What is missing in this branch relative to other branch.
1574
"""
1575
takes_args = ['remote?']
1576
aliases = ['mis', 'miss']
1577
# We don't have to add quiet to the list, because
1578
# unknown options are parsed as booleans
1579
takes_options = ['verbose', 'quiet']
1580
1581
def run(self, remote=None, verbose=False, quiet=False):
1582
from bzrlib.branch import find_branch, DivergedBranches
1583
from bzrlib.errors import BzrCommandError
1584
from bzrlib.missing import get_parent, show_missing
1585
1586
if verbose and quiet:
1587
raise BzrCommandError('Cannot pass both quiet and verbose')
1588
1589
b = find_branch('.')
1590
parent = get_parent(b)
1591
if remote is None:
1592
if parent is None:
1593
raise BzrCommandError("No missing location known or specified.")
1594
else:
1595
if not quiet:
1596
print "Using last location: %s" % parent
1597
remote = parent
1598
elif parent is None:
1599
# We only update x-pull if it did not exist, missing should not change the parent
1600
b.controlfile('x-pull', 'wb').write(remote + '\n')
1601
br_remote = find_branch(remote)
1602
1603
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1604
1605
1606
class cmd_plugins(Command):
1607
"""List plugins"""
1261
class cmd_update_stat_cache(Command):
1262
"""Update stat-cache mapping inodes to SHA-1 hashes.
1263
1264
For testing only."""
1608
1265
hidden = True
1609
1266
def run(self):
1610
import bzrlib.plugin
1611
from inspect import getdoc
1612
from pprint import pprint
1613
for plugin in bzrlib.plugin.all_plugins:
1614
print plugin.__path__[0]
1615
d = getdoc(plugin)
1616
if d:
1617
print '\t', d.split('\n')[0]
1618
1619
#pprint(bzrlib.plugin.all_plugins)
1267
import statcache
1268
b = Branch('.')
1269
statcache.update_cache(b.base, b.read_working_inventory())
1620
1270
1621
1271
1622
1272
1635
1285
'no-recurse': None,
1636
1286
'profile': None,
1637
1287
'revision': _parse_revision_str,
1638
'short': None,
1639
1288
'show-ids': None,
1640
1289
'timezone': str,
1641
1290
'verbose': None,
1642
1291
'version': None,
1643
1292
'email': None,
1644
'unchanged': None,
1645
1293
'update': None,
1646
'long': None,
1647
'root': str,
1648
'no-backup': None,
1649
'merge-type': get_merge_type,
1650
1294
}
1651
1295
1652
1296
SHORT_OPTIONS = {
1655
1299
'm': 'message',
1656
1300
'r': 'revision',
1657
1301
'v': 'verbose',
1658
'l': 'long',
1659
1302
}
1660
1303
1661
1304
1676
1319
>>> parse_args('commit --message=biter'.split())
1677
1320
(['commit'], {'message': u'biter'})
1678
1321
>>> parse_args('log -r 500'.split())
1679
(['log'], {'revision': [500]})
1680
>>> parse_args('log -r500..600'.split())
1322
(['log'], {'revision': 500})
1323
>>> parse_args('log -r500:600'.split())
1681
1324
(['log'], {'revision': [500, 600]})
1682
>>> parse_args('log -vr500..600'.split())
1325
>>> parse_args('log -vr500:600'.split())
1683
1326
(['log'], {'verbose': True, 'revision': [500, 600]})
1684
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1685
(['log'], {'revision': ['v500', 600]})
1327
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1328
Traceback (most recent call last):
1329
...
1330
ValueError: invalid literal for int(): v500
1686
1331
"""
1687
1332
args = []
1688
1333
opts = {}
1802
1447
return argdict
1803
1448
1804
1449
1450
def _parse_master_args(argv):
1451
"""Parse the arguments that always go with the original command.
1452
These are things like bzr --no-plugins, etc.
1453
1454
There are now 2 types of option flags. Ones that come *before* the command,
1455
and ones that come *after* the command.
1456
Ones coming *before* the command are applied against all possible commands.
1457
And are generally applied before plugins are loaded.
1458
1459
The current list are:
1460
--builtin Allow plugins to load, but don't let them override builtin commands,
1461
they will still be allowed if they do not override a builtin.
1462
--no-plugins Don't load any plugins. This lets you get back to official source
1463
behavior.
1464
--profile Enable the hotspot profile before running the command.
1465
For backwards compatibility, this is also a non-master option.
1466
--version Spit out the version of bzr that is running and exit.
1467
This is also a non-master option.
1468
--help Run help and exit, also a non-master option (I think that should stay, though)
1469
1470
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1471
Traceback (most recent call last):
1472
...
1473
BzrCommandError: Invalid master option: 'test'
1474
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1475
>>> print argv
1476
['command']
1477
>>> print opts['version']
1478
True
1479
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1480
>>> print argv
1481
['command', '--more-options']
1482
>>> print opts['profile']
1483
True
1484
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1485
>>> print argv
1486
['command']
1487
>>> print opts['no-plugins']
1488
True
1489
>>> print opts['profile']
1490
False
1491
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1492
>>> print argv
1493
['command', '--profile']
1494
>>> print opts['profile']
1495
False
1496
"""
1497
master_opts = {'builtin':False,
1498
'no-plugins':False,
1499
'version':False,
1500
'profile':False,
1501
'help':False
1502
}
1503
1504
# This is the point where we could hook into argv[0] to determine
1505
# what front-end is supposed to be run
1506
# For now, we are just ignoring it.
1507
cmd_name = argv.pop(0)
1508
for arg in argv[:]:
1509
if arg[:2] != '--': # at the first non-option, we return the rest
1510
break
1511
arg = arg[2:] # Remove '--'
1512
if arg not in master_opts:
1513
# We could say that this is not an error, that we should
1514
# just let it be handled by the main section instead
1515
raise BzrCommandError('Invalid master option: %r' % arg)
1516
argv.pop(0) # We are consuming this entry
1517
master_opts[arg] = True
1518
return argv, master_opts
1519
1520
1805
1521
1806
1522
def run_bzr(argv):
1807
1523
"""Execute a command.
1808
1524
1809
1525
This is similar to main(), but without all the trappings for
1810
1526
logging and error handling.
1811
1812
argv
1813
The command-line arguments, without the program name from argv[0]
1814
1815
Returns a command status or raises an exception.
1816
1817
Special master options: these must come before the command because
1818
they control how the command is interpreted.
1819
1820
--no-plugins
1821
Do not load plugin modules at all
1822
1823
--builtin
1824
Only use builtin commands. (Plugins are still allowed to change
1825
other behaviour.)
1826
1827
--profile
1828
Run under the Python profiler.
1829
1527
"""
1830
1831
1528
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1832
1833
opt_profile = opt_no_plugins = opt_builtin = False
1834
1835
# --no-plugins is handled specially at a very early stage. We need
1836
# to load plugins before doing other command parsing so that they
1837
# can override commands, but this needs to happen first.
1838
1839
for a in argv[:]:
1840
if a == '--profile':
1841
opt_profile = True
1842
elif a == '--no-plugins':
1843
opt_no_plugins = True
1844
elif a == '--builtin':
1845
opt_builtin = True
1846
else:
1847
break
1848
argv.remove(a)
1849
1850
if not opt_no_plugins:
1851
from bzrlib.plugin import load_plugins
1852
load_plugins()
1853
1854
args, opts = parse_args(argv)
1855
1856
if 'help' in opts:
1857
from bzrlib.help import help
1858
if args:
1859
help(args[0])
1860
else:
1861
help()
1862
return 0
1863
1864
if 'version' in opts:
1865
show_version()
1866
return 0
1867
1529
1868
if not args:
1869
print >>sys.stderr, "please try 'bzr help' for help"
1530
try:
1531
# some options like --builtin and --no-plugins have special effects
1532
argv, master_opts = _parse_master_args(argv)
1533
if 'no-plugins' not in master_opts:
1534
bzrlib.load_plugins()
1535
1536
args, opts = parse_args(argv)
1537
1538
if master_opts['help']:
1539
from bzrlib.help import help
1540
if argv:
1541
help(argv[0])
1542
else:
1543
help()
1544
return 0
1545
1546
if 'help' in opts:
1547
from bzrlib.help import help
1548
if args:
1549
help(args[0])
1550
else:
1551
help()
1552
return 0
1553
elif 'version' in opts:
1554
show_version()
1555
return 0
1556
elif args and args[0] == 'builtin':
1557
include_plugins=False
1558
args = args[1:]
1559
cmd = str(args.pop(0))
1560
except IndexError:
1561
import help
1562
help.help()
1870
1563
return 1
1871
1872
cmd = str(args.pop(0))
1873
1874
canonical_cmd, cmd_class = \
1875
get_cmd_class(cmd, plugins_override=not opt_builtin)
1564
1565
1566
plugins_override = not (master_opts['builtin'])
1567
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1568
1569
profile = master_opts['profile']
1570
# For backwards compatibility, I would rather stick with --profile being a
1571
# master/global option
1572
if 'profile' in opts:
1573
profile = True
1574
del opts['profile']
1876
1575
1877
1576
# check options are reasonable
1878
1577
allowed = cmd_class.takes_options
1887
1586
for k, v in opts.items():
1888
1587
cmdopts[k.replace('-', '_')] = v
1889
1588
1890
if opt_profile:
1589
if profile:
1891
1590
import hotshot, tempfile
1892
1591
pffileno, pfname = tempfile.mkstemp()
1893
1592
try:
1914
1613
1915
1614
def _report_exception(summary, quiet=False):
1916
1615
import traceback
1917
1918
1616
log_error('bzr: ' + summary)
1919
1617
bzrlib.trace.log_exception()
1920
1618
1921
if os.environ.get('BZR_DEBUG'):
1922
traceback.print_exc()
1923
1924
1619
if not quiet:
1925
sys.stderr.write('\n')
1926
1620
tb = sys.exc_info()[2]
1927
1621
exinfo = traceback.extract_tb(tb)
1928
1622
if exinfo:
1932
1626
1933
1627
1934
1628
def main(argv):
1629
import errno
1935
1630
1936
bzrlib.trace.open_tracefile(argv)
1631
bzrlib.open_tracefile(argv)
1937
1632
1938
1633
try:
1939
1634
try:
1940
1635
try:
1941
return run_bzr(argv[1:])
1636
return run_bzr(argv)
1942
1637
finally:
1943
1638
# do this here inside the exception wrappers to catch EPIPE
1944
1639
sys.stdout.flush()
1945
1640
except BzrError, e:
1946
1641
quiet = isinstance(e, (BzrCommandError))
1947
_report_exception('error: ' + str(e), quiet=quiet)
1642
_report_exception('error: ' + e.args[0], quiet=quiet)
1948
1643
if len(e.args) > 1:
1949
1644
for h in e.args[1]:
1950
1645
# some explanation or hints
1960
1655
_report_exception('interrupted', quiet=True)
1961
1656
return 2
1962
1657
except Exception, e:
1963
import errno
1964
1658
quiet = False
1965
1659
if (isinstance(e, IOError)
1966
1660
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1