« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1185.3.4
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.3.4
- Committer: Martin Pool
- Date: 2005-09-12 08:21:24 UTC
- mfrom: (974.1.74)
- mto: (1092.2.12) (974.1.76) (1185.8.2)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: mbp@sourcefrog.net-20050912082124-c6b174bd5d971cc0
- merge improved merge base selection from aaron
aaron.bentley@utoronto.ca-20050912025534-43d7275dd948e4ad
aaron.bentley@utoronto.ca-20050912025534-43d7275dd948e4ad
- files added:
- HACKING
- bzrlib/util
- contrib/emacs
- files removed:
- plugins/changeset
- files renamed:
- plugins/ => bzrlib/plugins/
- effbot/ => bzrlib/util/effbot/
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/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
19
import sys, os
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
20
21
# TODO: Help messages for options.
22
23
# TODO: Define arguments by objects, rather than just using names.
24
# Those objects can specify the expected type of the argument, which
25
# would help with validation and shell completion.
26
27
28
29
import sys
30
import os
31
from warnings import warn
32
from inspect import getdoc
20
33
21
34
import bzrlib
35
import bzrlib.trace
22
36
from bzrlib.trace import mutter, note, log_error, warning
23
37
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
38
from bzrlib.branch import find_branch
25
39
from bzrlib import BZRDIR
26
40
27
28
41
plugin_cmds = {}
29
42
30
43
38
51
k_unsquished = k
39
52
if not plugin_cmds.has_key(k_unsquished):
40
53
plugin_cmds[k_unsquished] = cmd
54
mutter('registered plugin command %s', k_unsquished)
41
55
else:
42
56
log_error('Two plugins defined the same command: %r' % k)
43
57
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
136
150
raise BzrCommandError(msg)
137
151
138
152
153
def get_merge_type(typestring):
154
"""Attempt to find the merge class/factory associated with a string."""
155
from merge import merge_types
156
try:
157
return merge_types[typestring][0]
158
except KeyError:
159
templ = '%s%%7s: %%s' % (' '*12)
160
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
161
type_list = '\n'.join(lines)
162
msg = "No known merge type %s. Supported types are:\n%s" %\
163
(typestring, type_list)
164
raise BzrCommandError(msg)
165
166
167
def _builtin_commands():
168
import bzrlib.builtins
169
r = {}
170
builtins = bzrlib.builtins.__dict__
171
for name in builtins:
172
if name.startswith("cmd_"):
173
real_name = _unsquish_command_name(name)
174
r[real_name] = builtins[name]
175
return r
176
177
178
179
def builtin_command_names():
180
"""Return list of builtin command names."""
181
return _builtin_commands().keys()
182
183
184
def plugin_command_names():
185
return plugin_cmds.keys()
186
139
187
140
188
def _get_cmd_dict(plugins_override=True):
141
d = {}
142
for k, v in globals().iteritems():
143
if k.startswith("cmd_"):
144
d[_unsquish_command_name(k)] = v
145
# If we didn't load plugins, the plugin_cmds dict will be empty
189
"""Return name->class mapping for all commands."""
190
d = _builtin_commands()
146
191
if plugins_override:
147
192
d.update(plugin_cmds)
148
else:
149
d2 = plugin_cmds.copy()
150
d2.update(d)
151
d = d2
152
193
return d
153
194
154
195
158
199
yield k,v
159
200
160
201
161
def get_cmd_class(cmd, plugins_override=True):
202
def get_cmd_object(cmd_name, plugins_override=True):
162
203
"""Return the canonical name and command class for a command.
204
205
plugins_override
206
If true, plugin commands can override builtins.
163
207
"""
164
cmd = str(cmd) # not unicode
208
from bzrlib.externalcommand import ExternalCommand
209
210
cmd_name = str(cmd_name) # not unicode
165
211
166
212
# first look up this command under the specified name
167
213
cmds = _get_cmd_dict(plugins_override=plugins_override)
168
214
try:
169
return cmd, cmds[cmd]
215
return cmds[cmd_name]()
170
216
except KeyError:
171
217
pass
172
218
173
219
# look for any command which claims this as an alias
174
for cmdname, cmdclass in cmds.iteritems():
175
if cmd in cmdclass.aliases:
176
return cmdname, cmdclass
177
178
cmdclass = ExternalCommand.find_command(cmd)
179
if cmdclass:
180
return cmd, cmdclass
181
182
raise BzrCommandError("unknown command %r" % cmd)
220
for real_cmd_name, cmd_class in cmds.iteritems():
221
if cmd_name in cmd_class.aliases:
222
return cmd_class()
223
224
cmd_obj = ExternalCommand.find_command(cmd_name)
225
if cmd_obj:
226
return cmd_obj
227
228
raise BzrCommandError("unknown command %r" % cmd_name)
183
229
184
230
185
231
class Command(object):
186
232
"""Base class for commands.
187
233
234
Commands are the heart of the command-line bzr interface.
235
236
The command object mostly handles the mapping of command-line
237
parameters into one or more bzrlib operations, and of the results
238
into textual output.
239
240
Commands normally don't have any state. All their arguments are
241
passed in to the run method. (Subclasses may take a different
242
policy if the behaviour of the instance needs to depend on e.g. a
243
shell plugin and not just its Python class.)
244
188
245
The docstring for an actual command should give a single-line
189
246
summary, then a complete description of the command. A grammar
190
247
description will be inserted.
191
248
249
aliases
250
Other accepted names for this command.
251
192
252
takes_args
193
253
List of argument forms, marked with whether they are optional,
194
254
repeated, etc.
197
257
List of options that may be given for this command.
198
258
199
259
hidden
200
If true, this command isn't advertised.
260
If true, this command isn't advertised. This is typically
261
for commands intended for expert users.
201
262
"""
202
263
aliases = []
203
264
206
267
207
268
hidden = False
208
269
209
def __init__(self, options, arguments):
210
"""Construct and run the command.
211
212
Sets self.status to the return value of run()."""
213
assert isinstance(options, dict)
214
assert isinstance(arguments, dict)
215
cmdargs = options.copy()
216
cmdargs.update(arguments)
270
def __init__(self):
271
"""Construct an instance of this command."""
217
272
if self.__doc__ == Command.__doc__:
218
from warnings import warn
219
273
warn("No help message set for %r" % self)
220
self.status = self.run(**cmdargs)
221
if self.status is None:
222
self.status = 0
274
275
276
def run_argv(self, argv):
277
"""Parse command line and run."""
278
args, opts = parse_args(argv)
279
280
if 'help' in opts: # e.g. bzr add --help
281
from bzrlib.help import help_on_command
282
help_on_command(self.name())
283
return 0
284
285
# check options are reasonable
286
allowed = self.takes_options
287
for oname in opts:
288
if oname not in allowed:
289
raise BzrCommandError("option '--%s' is not allowed for command %r"
290
% (oname, self.name()))
291
292
# mix arguments and options into one dictionary
293
cmdargs = _match_argform(self.name(), self.takes_args, args)
294
cmdopts = {}
295
for k, v in opts.items():
296
cmdopts[k.replace('-', '_')] = v
297
298
all_cmd_args = cmdargs.copy()
299
all_cmd_args.update(cmdopts)
300
301
return self.run(**all_cmd_args)
223
302
224
303
225
304
def run(self):
226
"""Override this in sub-classes.
305
"""Actually run the command.
227
306
228
307
This is invoked with the options and arguments bound to
229
308
keyword parameters.
230
309
231
Return 0 or None if the command was successful, or a shell
232
error code if not.
310
Return 0 or None if the command was successful, or a non-zero
311
shell error code if not. It's OK for this method to allow
312
an exception to raise up.
233
313
"""
234
return 0
235
236
237
class ExternalCommand(Command):
238
"""Class to wrap external commands.
239
240
We cheat a little here, when get_cmd_class() calls us we actually give it back
241
an object we construct that has the appropriate path, help, options etc for the
242
specified command.
243
244
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
245
method, which we override to call the Command.__init__ method. That then calls
246
our run method which is pretty straight forward.
247
248
The only wrinkle is that we have to map bzr's dictionary of options and arguments
249
back into command line options and arguments for the script.
250
"""
251
252
def find_command(cls, cmd):
253
import os.path
254
bzrpath = os.environ.get('BZRPATH', '')
255
256
for dir in bzrpath.split(os.pathsep):
257
path = os.path.join(dir, cmd)
258
if os.path.isfile(path):
259
return ExternalCommand(path)
260
261
return None
262
263
find_command = classmethod(find_command)
264
265
def __init__(self, path):
266
self.path = path
267
268
pipe = os.popen('%s --bzr-usage' % path, 'r')
269
self.takes_options = pipe.readline().split()
270
271
for opt in self.takes_options:
272
if not opt in OPTIONS:
273
raise BzrError("Unknown option '%s' returned by external command %s"
274
% (opt, path))
275
276
# TODO: Is there any way to check takes_args is valid here?
277
self.takes_args = pipe.readline().split()
278
279
if pipe.close() is not None:
280
raise BzrError("Failed funning '%s --bzr-usage'" % path)
281
282
pipe = os.popen('%s --bzr-help' % path, 'r')
283
self.__doc__ = pipe.read()
284
if pipe.close() is not None:
285
raise BzrError("Failed funning '%s --bzr-help'" % path)
286
287
def __call__(self, options, arguments):
288
Command.__init__(self, options, arguments)
289
return self
290
291
def run(self, **kargs):
292
opts = []
293
args = []
294
295
keys = kargs.keys()
296
keys.sort()
297
for name in keys:
298
optname = name.replace('_','-')
299
value = kargs[name]
300
if OPTIONS.has_key(optname):
301
# it's an option
302
opts.append('--%s' % optname)
303
if value is not None and value is not True:
304
opts.append(str(value))
305
else:
306
# it's an arg, or arg list
307
if type(value) is not list:
308
value = [value]
309
for v in value:
310
if v is not None:
311
args.append(str(v))
312
313
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
314
return self.status
315
316
317
class cmd_status(Command):
318
"""Display status summary.
319
320
This reports on versioned and unknown files, reporting them
321
grouped by state. Possible states are:
322
323
added
324
Versioned in the working copy but not in the previous revision.
325
326
removed
327
Versioned in the previous revision but removed or deleted
328
in the working copy.
329
330
renamed
331
Path of this file changed from the previous revision;
332
the text may also have changed. This includes files whose
333
parent directory was renamed.
334
335
modified
336
Text has changed since the previous revision.
337
338
unchanged
339
Nothing about this file has changed since the previous revision.
340
Only shown with --all.
341
342
unknown
343
Not versioned and not matching an ignore pattern.
344
345
To see ignored files use 'bzr ignored'. For details in the
346
changes to file texts, use 'bzr diff'.
347
348
If no arguments are specified, the status of the entire working
349
directory is shown. Otherwise, only the status of the specified
350
files or directories is reported. If a directory is given, status
351
is reported for everything inside that directory.
352
353
If a revision is specified, the changes since that revision are shown.
354
"""
355
takes_args = ['file*']
356
takes_options = ['all', 'show-ids', 'revision']
357
aliases = ['st', 'stat']
358
359
def run(self, all=False, show_ids=False, file_list=None):
360
if file_list:
361
b = find_branch(file_list[0])
362
file_list = [b.relpath(x) for x in file_list]
363
# special case: only one path was given and it's the root
364
# of the branch
365
if file_list == ['']:
366
file_list = None
367
else:
368
b = find_branch('.')
369
370
from bzrlib.status import show_status
371
show_status(b, show_unchanged=all, show_ids=show_ids,
372
specific_files=file_list)
373
374
375
class cmd_cat_revision(Command):
376
"""Write out metadata for a revision."""
377
378
hidden = True
379
takes_args = ['revision_id']
380
381
def run(self, revision_id):
382
from bzrlib.xml import pack_xml
383
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
384
385
386
class cmd_revno(Command):
387
"""Show current revision number.
388
389
This is equal to the number of revisions on this branch."""
390
def run(self):
391
print find_branch('.').revno()
392
393
class cmd_revision_info(Command):
394
"""Show revision number and revision id for a given revision identifier.
395
"""
396
hidden = True
397
takes_args = ['revision_info*']
398
takes_options = ['revision']
399
def run(self, revision=None, revision_info_list=None):
400
from bzrlib.branch import find_branch
401
402
revs = []
403
if revision is not None:
404
revs.extend(revision)
405
if revision_info_list is not None:
406
revs.extend(revision_info_list)
407
if len(revs) == 0:
408
raise BzrCommandError('You must supply a revision identifier')
409
410
b = find_branch('.')
411
412
for rev in revs:
413
print '%4d %s' % b.get_revision_info(rev)
414
415
416
class cmd_add(Command):
417
"""Add specified files or directories.
418
419
In non-recursive mode, all the named items are added, regardless
420
of whether they were previously ignored. A warning is given if
421
any of the named files are already versioned.
422
423
In recursive mode (the default), files are treated the same way
424
but the behaviour for directories is different. Directories that
425
are already versioned do not give a warning. All directories,
426
whether already versioned or not, are searched for files or
427
subdirectories that are neither versioned or ignored, and these
428
are added. This search proceeds recursively into versioned
429
directories. If no names are given '.' is assumed.
430
431
Therefore simply saying 'bzr add' will version all files that
432
are currently unknown.
433
434
TODO: Perhaps adding a file whose directly is not versioned should
435
recursively add that parent, rather than giving an error?
436
"""
437
takes_args = ['file*']
438
takes_options = ['verbose', 'no-recurse']
439
440
def run(self, file_list, verbose=False, no_recurse=False):
441
from bzrlib.add import smart_add
442
smart_add(file_list, verbose, not no_recurse)
443
444
445
446
class cmd_mkdir(Command):
447
"""Create a new versioned directory.
448
449
This is equivalent to creating the directory and then adding it.
450
"""
451
takes_args = ['dir+']
452
453
def run(self, dir_list):
454
b = None
455
456
for d in dir_list:
457
os.mkdir(d)
458
if not b:
459
b = find_branch(d)
460
b.add([d], verbose=True)
461
462
463
class cmd_relpath(Command):
464
"""Show path of a file relative to root"""
465
takes_args = ['filename']
466
hidden = True
467
468
def run(self, filename):
469
print find_branch(filename).relpath(filename)
470
471
472
473
class cmd_inventory(Command):
474
"""Show inventory of the current working copy or a revision."""
475
takes_options = ['revision', 'show-ids']
476
477
def run(self, revision=None, show_ids=False):
478
b = find_branch('.')
479
if revision == None:
480
inv = b.read_working_inventory()
481
else:
482
if len(revision) > 1:
483
raise BzrCommandError('bzr inventory --revision takes'
484
' exactly one revision identifier')
485
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
486
487
for path, entry in inv.entries():
488
if show_ids:
489
print '%-50s %s' % (path, entry.file_id)
490
else:
491
print path
492
493
494
class cmd_move(Command):
495
"""Move files to a different directory.
496
497
examples:
498
bzr move *.txt doc
499
500
The destination must be a versioned directory in the same branch.
501
"""
502
takes_args = ['source$', 'dest']
503
def run(self, source_list, dest):
504
b = find_branch('.')
505
506
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
507
508
509
class cmd_rename(Command):
510
"""Change the name of an entry.
511
512
examples:
513
bzr rename frob.c frobber.c
514
bzr rename src/frob.c lib/frob.c
515
516
It is an error if the destination name exists.
517
518
See also the 'move' command, which moves files into a different
519
directory without changing their name.
520
521
TODO: Some way to rename multiple files without invoking bzr for each
522
one?"""
523
takes_args = ['from_name', 'to_name']
524
525
def run(self, from_name, to_name):
526
b = find_branch('.')
527
b.rename_one(b.relpath(from_name), b.relpath(to_name))
528
529
530
531
532
533
class cmd_pull(Command):
534
"""Pull any changes from another branch into the current one.
535
536
If the location is omitted, the last-used location will be used.
537
Both the revision history and the working directory will be
538
updated.
539
540
This command only works on branches that have not diverged. Branches are
541
considered diverged if both branches have had commits without first
542
pulling from the other.
543
544
If branches have diverged, you can use 'bzr merge' to pull the text changes
545
from one into the other.
546
"""
547
takes_args = ['location?']
548
549
def run(self, location=None):
550
from bzrlib.merge import merge
551
import tempfile
552
from shutil import rmtree
553
import errno
554
555
br_to = find_branch('.')
556
stored_loc = None
557
try:
558
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
559
except IOError, e:
560
if e.errno != errno.ENOENT:
561
raise
562
if location is None:
563
if stored_loc is None:
564
raise BzrCommandError("No pull location known or specified.")
565
else:
566
print "Using last location: %s" % stored_loc
567
location = stored_loc
568
cache_root = tempfile.mkdtemp()
569
from bzrlib.branch import DivergedBranches
570
br_from = find_branch(location)
571
location = pull_loc(br_from)
572
old_revno = br_to.revno()
573
try:
574
from branch import find_cached_branch, DivergedBranches
575
br_from = find_cached_branch(location, cache_root)
576
location = pull_loc(br_from)
577
old_revno = br_to.revno()
578
try:
579
br_to.update_revisions(br_from)
580
except DivergedBranches:
581
raise BzrCommandError("These branches have diverged."
582
" Try merge.")
583
584
merge(('.', -1), ('.', old_revno), check_clean=False)
585
if location != stored_loc:
586
br_to.controlfile("x-pull", "wb").write(location + "\n")
587
finally:
588
rmtree(cache_root)
589
590
591
592
class cmd_branch(Command):
593
"""Create a new copy of a branch.
594
595
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
596
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
597
598
To retrieve the branch as of a particular revision, supply the --revision
599
parameter, as in "branch foo/bar -r 5".
600
"""
601
takes_args = ['from_location', 'to_location?']
602
takes_options = ['revision']
603
604
def run(self, from_location, to_location=None, revision=None):
605
import errno
606
from bzrlib.merge import merge
607
from bzrlib.branch import DivergedBranches, NoSuchRevision, \
608
find_cached_branch, Branch
609
from shutil import rmtree
610
from meta_store import CachedStore
611
import tempfile
612
cache_root = tempfile.mkdtemp()
613
614
if revision is None:
615
revision = [None]
616
elif len(revision) > 1:
617
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
618
619
try:
620
try:
621
br_from = find_cached_branch(from_location, cache_root)
622
except OSError, e:
623
if e.errno == errno.ENOENT:
624
raise BzrCommandError('Source location "%s" does not'
625
' exist.' % to_location)
626
else:
627
raise
628
629
if to_location is None:
630
to_location = os.path.basename(from_location.rstrip("/\\"))
631
632
try:
633
os.mkdir(to_location)
634
except OSError, e:
635
if e.errno == errno.EEXIST:
636
raise BzrCommandError('Target directory "%s" already'
637
' exists.' % to_location)
638
if e.errno == errno.ENOENT:
639
raise BzrCommandError('Parent of "%s" does not exist.' %
640
to_location)
641
else:
642
raise
643
br_to = Branch(to_location, init=True)
644
645
br_to.set_root_id(br_from.get_root_id())
646
647
if revision:
648
if revision[0] is None:
649
revno = br_from.revno()
650
else:
651
revno, rev_id = br_from.get_revision_info(revision[0])
652
try:
653
br_to.update_revisions(br_from, stop_revision=revno)
654
except NoSuchRevision:
655
rmtree(to_location)
656
msg = "The branch %s has no revision %d." % (from_location,
657
revno)
658
raise BzrCommandError(msg)
659
660
merge((to_location, -1), (to_location, 0), this_dir=to_location,
661
check_clean=False, ignore_zero=True)
662
from_location = pull_loc(br_from)
663
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
664
finally:
665
rmtree(cache_root)
666
667
668
def pull_loc(branch):
669
# TODO: Should perhaps just make attribute be 'base' in
670
# RemoteBranch and Branch?
671
if hasattr(branch, "baseurl"):
672
return branch.baseurl
673
else:
674
return branch.base
675
676
677
678
class cmd_renames(Command):
679
"""Show list of renamed files.
680
681
TODO: Option to show renames between two historical versions.
682
683
TODO: Only show renames under dir, rather than in the whole branch.
684
"""
685
takes_args = ['dir?']
686
687
def run(self, dir='.'):
688
b = find_branch(dir)
689
old_inv = b.basis_tree().inventory
690
new_inv = b.read_working_inventory()
691
692
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
693
renames.sort()
694
for old_name, new_name in renames:
695
print "%s => %s" % (old_name, new_name)
696
697
698
class cmd_info(Command):
699
"""Show statistical information about a branch."""
700
takes_args = ['branch?']
701
702
def run(self, branch=None):
703
import info
704
705
b = find_branch(branch)
706
info.show_info(b)
707
708
709
class cmd_remove(Command):
710
"""Make a file unversioned.
711
712
This makes bzr stop tracking changes to a versioned file. It does
713
not delete the working copy.
714
"""
715
takes_args = ['file+']
716
takes_options = ['verbose']
717
718
def run(self, file_list, verbose=False):
719
b = find_branch(file_list[0])
720
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
721
722
723
class cmd_file_id(Command):
724
"""Print file_id of a particular file or directory.
725
726
The file_id is assigned when the file is first added and remains the
727
same through all revisions where the file exists, even when it is
728
moved or renamed.
729
"""
730
hidden = True
731
takes_args = ['filename']
732
def run(self, filename):
733
b = find_branch(filename)
734
i = b.inventory.path2id(b.relpath(filename))
735
if i == None:
736
raise BzrError("%r is not a versioned file" % filename)
737
else:
738
print i
739
740
741
class cmd_file_path(Command):
742
"""Print path of file_ids to a file or directory.
743
744
This prints one line for each directory down to the target,
745
starting at the branch root."""
746
hidden = True
747
takes_args = ['filename']
748
def run(self, filename):
749
b = find_branch(filename)
750
inv = b.inventory
751
fid = inv.path2id(b.relpath(filename))
752
if fid == None:
753
raise BzrError("%r is not a versioned file" % filename)
754
for fip in inv.get_idpath(fid):
755
print fip
756
757
758
class cmd_revision_history(Command):
759
"""Display list of revision ids on this branch."""
760
hidden = True
761
def run(self):
762
for patchid in find_branch('.').revision_history():
763
print patchid
764
765
766
class cmd_directories(Command):
767
"""Display list of versioned directories in this branch."""
768
def run(self):
769
for name, ie in find_branch('.').read_working_inventory().directories():
770
if name == '':
771
print '.'
772
else:
773
print name
774
775
776
class cmd_init(Command):
777
"""Make a directory into a versioned branch.
778
779
Use this to create an empty branch, or before importing an
780
existing project.
781
782
Recipe for importing a tree of files:
783
cd ~/project
784
bzr init
785
bzr add -v .
786
bzr status
787
bzr commit -m 'imported project'
788
"""
789
def run(self):
790
from bzrlib.branch import Branch
791
Branch('.', init=True)
792
793
794
class cmd_diff(Command):
795
"""Show differences in working tree.
796
797
If files are listed, only the changes in those files are listed.
798
Otherwise, all changes for the tree are listed.
799
800
TODO: Given two revision arguments, show the difference between them.
801
802
TODO: Allow diff across branches.
803
804
TODO: Option to use external diff command; could be GNU diff, wdiff,
805
or a graphical diff.
806
807
TODO: Python difflib is not exactly the same as unidiff; should
808
either fix it up or prefer to use an external diff.
809
810
TODO: If a directory is given, diff everything under that.
811
812
TODO: Selected-file diff is inefficient and doesn't show you
813
deleted files.
814
815
TODO: This probably handles non-Unix newlines poorly.
816
"""
817
818
takes_args = ['file*']
819
takes_options = ['revision', 'diff-options']
820
aliases = ['di', 'dif']
821
822
def run(self, revision=None, file_list=None, diff_options=None):
823
from bzrlib.diff import show_diff
824
825
if file_list:
826
b = find_branch(file_list[0])
827
file_list = [b.relpath(f) for f in file_list]
828
if file_list == ['']:
829
# just pointing to top-of-tree
830
file_list = None
831
else:
832
b = find_branch('.')
833
834
# TODO: Make show_diff support taking 2 arguments
835
base_rev = None
836
if revision is not None:
837
if len(revision) != 1:
838
raise BzrCommandError('bzr diff --revision takes exactly one revision identifier')
839
base_rev = revision[0]
840
841
show_diff(b, base_rev, specific_files=file_list,
842
external_diff_options=diff_options)
843
844
845
846
847
848
class cmd_deleted(Command):
849
"""List files deleted in the working tree.
850
851
TODO: Show files deleted since a previous revision, or between two revisions.
852
"""
853
def run(self, show_ids=False):
854
b = find_branch('.')
855
old = b.basis_tree()
856
new = b.working_tree()
857
858
## TODO: Much more efficient way to do this: read in new
859
## directories with readdir, rather than stating each one. Same
860
## level of effort but possibly much less IO. (Or possibly not,
861
## if the directories are very large...)
862
863
for path, ie in old.inventory.iter_entries():
864
if not new.has_id(ie.file_id):
865
if show_ids:
866
print '%-50s %s' % (path, ie.file_id)
867
else:
868
print path
869
870
871
class cmd_modified(Command):
872
"""List files modified in working tree."""
873
hidden = True
874
def run(self):
875
from bzrlib.diff import compare_trees
876
877
b = find_branch('.')
878
td = compare_trees(b.basis_tree(), b.working_tree())
879
880
for path, id, kind in td.modified:
881
print path
882
883
884
885
class cmd_added(Command):
886
"""List files added in working tree."""
887
hidden = True
888
def run(self):
889
b = find_branch('.')
890
wt = b.working_tree()
891
basis_inv = b.basis_tree().inventory
892
inv = wt.inventory
893
for file_id in inv:
894
if file_id in basis_inv:
895
continue
896
path = inv.id2path(file_id)
897
if not os.access(b.abspath(path), os.F_OK):
898
continue
899
print path
900
901
902
903
class cmd_root(Command):
904
"""Show the tree root directory.
905
906
The root is the nearest enclosing directory with a .bzr control
907
directory."""
908
takes_args = ['filename?']
909
def run(self, filename=None):
910
"""Print the branch root."""
911
b = find_branch(filename)
912
print getattr(b, 'base', None) or getattr(b, 'baseurl')
913
914
915
class cmd_log(Command):
916
"""Show log of this branch.
917
918
To request a range of logs, you can use the command -r begin:end
919
-r revision requests a specific revision, -r :end or -r begin: are
920
also valid.
921
922
--message allows you to give a regular expression, which will be evaluated
923
so that only matching entries will be displayed.
924
925
TODO: Make --revision support uuid: and hash: [future tag:] notation.
926
927
"""
928
929
takes_args = ['filename?']
930
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long', 'message']
931
932
def run(self, filename=None, timezone='original',
933
verbose=False,
934
show_ids=False,
935
forward=False,
936
revision=None,
937
message=None,
938
long=False):
939
from bzrlib.branch import find_branch
940
from bzrlib.log import log_formatter, show_log
941
import codecs
942
943
direction = (forward and 'forward') or 'reverse'
944
945
if filename:
946
b = find_branch(filename)
947
fp = b.relpath(filename)
948
if fp:
949
file_id = b.read_working_inventory().path2id(fp)
950
else:
951
file_id = None # points to branch root
952
else:
953
b = find_branch('.')
954
file_id = None
955
956
if revision is None:
957
rev1 = None
958
rev2 = None
959
elif len(revision) == 1:
960
rev1 = rev2 = b.get_revision_info(revision[0])[0]
961
elif len(revision) == 2:
962
rev1 = b.get_revision_info(revision[0])[0]
963
rev2 = b.get_revision_info(revision[1])[0]
964
else:
965
raise BzrCommandError('bzr log --revision takes one or two values.')
966
967
if rev1 == 0:
968
rev1 = None
969
if rev2 == 0:
970
rev2 = None
971
972
mutter('encoding log as %r' % bzrlib.user_encoding)
973
974
# use 'replace' so that we don't abort if trying to write out
975
# in e.g. the default C locale.
976
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
977
978
if long:
979
log_format = 'long'
980
else:
981
log_format = 'short'
982
lf = log_formatter(log_format,
983
show_ids=show_ids,
984
to_file=outf,
985
show_timezone=timezone)
986
987
show_log(b,
988
lf,
989
file_id,
990
verbose=verbose,
991
direction=direction,
992
start_revision=rev1,
993
end_revision=rev2,
994
search=message)
995
996
997
998
class cmd_touching_revisions(Command):
999
"""Return revision-ids which affected a particular file.
1000
1001
A more user-friendly interface is "bzr log FILE"."""
1002
hidden = True
1003
takes_args = ["filename"]
1004
def run(self, filename):
1005
b = find_branch(filename)
1006
inv = b.read_working_inventory()
1007
file_id = inv.path2id(b.relpath(filename))
1008
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1009
print "%6d %s" % (revno, what)
1010
1011
1012
class cmd_ls(Command):
1013
"""List files in a tree.
1014
1015
TODO: Take a revision or remote path and list that tree instead.
1016
"""
1017
hidden = True
1018
def run(self, revision=None, verbose=False):
1019
b = find_branch('.')
1020
if revision == None:
1021
tree = b.working_tree()
1022
else:
1023
tree = b.revision_tree(b.lookup_revision(revision))
1024
1025
for fp, fc, kind, fid in tree.list_files():
1026
if verbose:
1027
if kind == 'directory':
1028
kindch = '/'
1029
elif kind == 'file':
1030
kindch = ''
1031
else:
1032
kindch = '???'
1033
1034
print '%-8s %s%s' % (fc, fp, kindch)
1035
else:
1036
print fp
1037
1038
1039
1040
class cmd_unknowns(Command):
1041
"""List unknown files."""
1042
def run(self):
1043
from bzrlib.osutils import quotefn
1044
for f in find_branch('.').unknowns():
1045
print quotefn(f)
1046
1047
1048
1049
class cmd_ignore(Command):
1050
"""Ignore a command or pattern.
1051
1052
To remove patterns from the ignore list, edit the .bzrignore file.
1053
1054
If the pattern contains a slash, it is compared to the whole path
1055
from the branch root. Otherwise, it is comapred to only the last
1056
component of the path.
1057
1058
Ignore patterns are case-insensitive on case-insensitive systems.
1059
1060
Note: wildcards must be quoted from the shell on Unix.
1061
1062
examples:
1063
bzr ignore ./Makefile
1064
bzr ignore '*.class'
1065
"""
1066
takes_args = ['name_pattern']
1067
1068
def run(self, name_pattern):
1069
from bzrlib.atomicfile import AtomicFile
1070
import os.path
1071
1072
b = find_branch('.')
1073
ifn = b.abspath('.bzrignore')
1074
1075
if os.path.exists(ifn):
1076
f = open(ifn, 'rt')
1077
try:
1078
igns = f.read().decode('utf-8')
1079
finally:
1080
f.close()
1081
else:
1082
igns = ''
1083
1084
# TODO: If the file already uses crlf-style termination, maybe
1085
# we should use that for the newly added lines?
1086
1087
if igns and igns[-1] != '\n':
1088
igns += '\n'
1089
igns += name_pattern + '\n'
1090
1091
try:
1092
f = AtomicFile(ifn, 'wt')
1093
f.write(igns.encode('utf-8'))
1094
f.commit()
1095
finally:
1096
f.close()
1097
1098
inv = b.working_tree().inventory
1099
if inv.path2id('.bzrignore'):
1100
mutter('.bzrignore is already versioned')
1101
else:
1102
mutter('need to make new .bzrignore file versioned')
1103
b.add(['.bzrignore'])
1104
1105
1106
1107
class cmd_ignored(Command):
1108
"""List ignored files and the patterns that matched them.
1109
1110
See also: bzr ignore"""
1111
def run(self):
1112
tree = find_branch('.').working_tree()
1113
for path, file_class, kind, file_id in tree.list_files():
1114
if file_class != 'I':
1115
continue
1116
## XXX: Slightly inefficient since this was already calculated
1117
pat = tree.is_ignored(path)
1118
print '%-50s %s' % (path, pat)
1119
1120
1121
class cmd_lookup_revision(Command):
1122
"""Lookup the revision-id from a revision-number
1123
1124
example:
1125
bzr lookup-revision 33
1126
"""
1127
hidden = True
1128
takes_args = ['revno']
1129
1130
def run(self, revno):
1131
try:
1132
revno = int(revno)
1133
except ValueError:
1134
raise BzrCommandError("not a valid revision-number: %r" % revno)
1135
1136
print find_branch('.').lookup_revision(revno)
1137
1138
1139
class cmd_export(Command):
1140
"""Export past revision to destination directory.
1141
1142
If no revision is specified this exports the last committed revision.
1143
1144
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1145
given, try to find the format with the extension. If no extension
1146
is found exports to a directory (equivalent to --format=dir).
1147
1148
Root may be the top directory for tar, tgz and tbz2 formats. If none
1149
is given, the top directory will be the root name of the file."""
1150
# TODO: list known exporters
1151
takes_args = ['dest']
1152
takes_options = ['revision', 'format', 'root']
1153
def run(self, dest, revision=None, format=None, root=None):
1154
import os.path
1155
b = find_branch('.')
1156
if revision is None:
1157
rev_id = b.last_patch()
1158
else:
1159
if len(revision) != 1:
1160
raise BzrError('bzr export --revision takes exactly 1 argument')
1161
revno, rev_id = b.get_revision_info(revision[0])
1162
t = b.revision_tree(rev_id)
1163
root, ext = os.path.splitext(dest)
1164
if not format:
1165
if ext in (".tar",):
1166
format = "tar"
1167
elif ext in (".gz", ".tgz"):
1168
format = "tgz"
1169
elif ext in (".bz2", ".tbz2"):
1170
format = "tbz2"
1171
else:
1172
format = "dir"
1173
t.export(dest, format, root)
1174
1175
1176
class cmd_cat(Command):
1177
"""Write a file's text from a previous revision."""
1178
1179
takes_options = ['revision']
1180
takes_args = ['filename']
1181
1182
def run(self, filename, revision=None):
1183
if revision == None:
1184
raise BzrCommandError("bzr cat requires a revision number")
1185
elif len(revision) != 1:
1186
raise BzrCommandError("bzr cat --revision takes exactly one number")
1187
b = find_branch('.')
1188
b.print_file(b.relpath(filename), revision[0])
1189
1190
1191
class cmd_local_time_offset(Command):
1192
"""Show the offset in seconds from GMT to local time."""
1193
hidden = True
1194
def run(self):
1195
print bzrlib.osutils.local_time_offset()
1196
1197
1198
1199
class cmd_commit(Command):
1200
"""Commit changes into a new revision.
1201
1202
If selected files are specified, only changes to those files are
1203
committed. If a directory is specified then its contents are also
1204
committed.
1205
1206
A selected-file commit may fail in some cases where the committed
1207
tree would be invalid, such as trying to commit a file in a
1208
newly-added directory that is not itself committed.
1209
1210
TODO: Run hooks on tree to-be-committed, and after commit.
1211
1212
TODO: Strict commit that fails if there are unknown or deleted files.
1213
"""
1214
takes_args = ['selected*']
1215
takes_options = ['message', 'file', 'verbose', 'unchanged']
1216
aliases = ['ci', 'checkin']
1217
1218
def run(self, message=None, file=None, verbose=True, selected_list=None,
1219
unchanged=False):
1220
from bzrlib.errors import PointlessCommit
1221
from bzrlib.osutils import get_text_message
1222
1223
## Warning: shadows builtin file()
1224
if not message and not file:
1225
import cStringIO
1226
stdout = sys.stdout
1227
catcher = cStringIO.StringIO()
1228
sys.stdout = catcher
1229
cmd_status({"file_list":selected_list}, {})
1230
info = catcher.getvalue()
1231
sys.stdout = stdout
1232
message = get_text_message(info)
1233
1234
if message is None:
1235
raise BzrCommandError("please specify a commit message",
1236
["use either --message or --file"])
1237
elif message and file:
1238
raise BzrCommandError("please specify either --message or --file")
1239
1240
if file:
1241
import codecs
1242
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1243
1244
b = find_branch('.')
1245
1246
try:
1247
b.commit(message, verbose=verbose,
1248
specific_files=selected_list,
1249
allow_pointless=unchanged)
1250
except PointlessCommit:
1251
# FIXME: This should really happen before the file is read in;
1252
# perhaps prepare the commit; get the message; then actually commit
1253
raise BzrCommandError("no changes to commit",
1254
["use --unchanged to commit anyhow"])
1255
1256
1257
class cmd_check(Command):
1258
"""Validate consistency of branch history.
1259
1260
This command checks various invariants about the branch storage to
1261
detect data corruption or bzr bugs.
1262
1263
If given the --update flag, it will update some optional fields
1264
to help ensure data consistency.
1265
"""
1266
takes_args = ['dir?']
1267
1268
def run(self, dir='.'):
1269
from bzrlib.check import check
1270
check(find_branch(dir))
1271
1272
1273
1274
class cmd_scan_cache(Command):
1275
hidden = True
1276
def run(self):
1277
from bzrlib.hashcache import HashCache
1278
import os
1279
1280
c = HashCache('.')
1281
c.read()
1282
c.scan()
1283
1284
print '%6d stats' % c.stat_count
1285
print '%6d in hashcache' % len(c._cache)
1286
print '%6d files removed from cache' % c.removed_count
1287
print '%6d hashes updated' % c.update_count
1288
print '%6d files changed too recently to cache' % c.danger_count
1289
1290
if c.needs_write:
1291
c.write()
1292
1293
1294
1295
class cmd_upgrade(Command):
1296
"""Upgrade branch storage to current format.
1297
1298
This should normally be used only after the check command tells
1299
you to run it.
1300
"""
1301
takes_args = ['dir?']
1302
1303
def run(self, dir='.'):
1304
from bzrlib.upgrade import upgrade
1305
upgrade(find_branch(dir))
1306
1307
1308
1309
class cmd_whoami(Command):
1310
"""Show bzr user id."""
1311
takes_options = ['email']
1312
1313
def run(self, email=False):
1314
if email:
1315
print bzrlib.osutils.user_email()
1316
else:
1317
print bzrlib.osutils.username()
1318
1319
1320
class cmd_selftest(Command):
1321
"""Run internal test suite"""
1322
hidden = True
1323
takes_options = ['verbose']
1324
def run(self, verbose=False):
1325
from bzrlib.selftest import selftest
1326
return int(not selftest(verbose=verbose))
1327
1328
1329
class cmd_version(Command):
1330
"""Show version of bzr."""
1331
def run(self):
1332
show_version()
1333
1334
def show_version():
1335
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1336
# is bzrlib itself in a branch?
1337
bzrrev = bzrlib.get_bzr_revision()
1338
if bzrrev:
1339
print " (bzr checkout, revision %d {%s})" % bzrrev
1340
print bzrlib.__copyright__
1341
print "http://bazaar-ng.org/"
1342
print
1343
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1344
print "you may use, modify and redistribute it under the terms of the GNU"
1345
print "General Public License version 2 or later."
1346
1347
1348
class cmd_rocks(Command):
1349
"""Statement of optimism."""
1350
hidden = True
1351
def run(self):
1352
print "it sure does!"
314
raise NotImplementedError()
315
316
317
def help(self):
318
"""Return help message for this class."""
319
if self.__doc__ is Command.__doc__:
320
return None
321
return getdoc(self)
322
323
def name(self):
324
return _unsquish_command_name(self.__class__.__name__)
325
1353
326
1354
327
def parse_spec(spec):
1355
328
"""
1384
357
1385
358
1386
359
1387
class cmd_merge(Command):
1388
"""Perform a three-way merge of trees.
1389
1390
The SPEC parameters are working tree or revision specifiers. Working trees
1391
are specified using standard paths or urls. No component of a directory
1392
path may begin with '@'.
1393
1394
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1395
1396
Revisions are specified using a dirname/@revno pair, where dirname is the
1397
branch directory and revno is the revision within that branch. If no revno
1398
is specified, the latest revision is used.
1399
1400
Revision examples: './@127', 'foo/@', '../@1'
1401
1402
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1403
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1404
as the BASE.
1405
1406
merge refuses to run if there are any uncommitted changes, unless
1407
--force is given.
1408
"""
1409
takes_args = ['other_spec', 'base_spec?']
1410
takes_options = ['force', 'merge-type']
1411
1412
def run(self, other_spec, base_spec=None, force=False, merge_type=None):
1413
from bzrlib.merge import merge
1414
from bzrlib.merge_core import ApplyMerge3
1415
if merge_type is None:
1416
merge_type = ApplyMerge3
1417
merge(parse_spec(other_spec), parse_spec(base_spec),
1418
check_clean=(not force), merge_type=merge_type)
1419
1420
1421
1422
class cmd_revert(Command):
1423
"""Restore selected files from a previous revision.
1424
"""
1425
takes_args = ['file+']
1426
def run(self, file_list):
1427
from bzrlib.branch import find_branch
1428
1429
if not file_list:
1430
file_list = ['.']
1431
1432
b = find_branch(file_list[0])
1433
1434
b.revert([b.relpath(f) for f in file_list])
1435
1436
1437
class cmd_merge_revert(Command):
1438
"""Reverse all changes since the last commit.
1439
1440
Only versioned files are affected. By default, any files that are changed
1441
will be backed up first. Backup files have a '~' appended to their name.
1442
"""
1443
takes_options = ['revision', 'no-backup']
1444
1445
def run(self, revision=None, no_backup=False):
1446
from bzrlib.merge import merge
1447
if revision is None:
1448
revision = [-1]
1449
elif len(revision) != 1:
1450
raise BzrCommandError('bzr merge-revert --revision takes exactly 1 argument')
1451
merge(('.', revision[0]), parse_spec('.'),
1452
check_clean=False,
1453
ignore_zero=True,
1454
backup_files=not no_backup)
1455
1456
1457
class cmd_assert_fail(Command):
1458
"""Test reporting of assertion failures"""
1459
hidden = True
1460
def run(self):
1461
assert False, "always fails"
1462
1463
1464
class cmd_help(Command):
1465
"""Show help on a command or other topic.
1466
1467
For a list of all available commands, say 'bzr help commands'."""
1468
takes_args = ['topic?']
1469
aliases = ['?']
1470
1471
def run(self, topic=None):
1472
import help
1473
help.help(topic)
1474
1475
1476
1477
1478
class cmd_plugins(Command):
1479
"""List plugins"""
1480
hidden = True
1481
def run(self):
1482
import bzrlib.plugin
1483
from inspect import getdoc
1484
from pprint import pprint
1485
for plugin in bzrlib.plugin.all_plugins:
1486
print plugin.__path__[0]
1487
d = getdoc(plugin)
1488
if d:
1489
print '\t', d.split('\n')[0]
1490
1491
#pprint(bzrlib.plugin.all_plugins)
1492
1493
1494
360
1495
361
# list of all available options; the rhs can be either None for an
1496
362
# option that takes no argument, or a constructor function that checks
1507
373
'no-recurse': None,
1508
374
'profile': None,
1509
375
'revision': _parse_revision_str,
376
'short': None,
1510
377
'show-ids': None,
1511
378
'timezone': str,
1512
379
'verbose': None,
1518
385
'root': str,
1519
386
'no-backup': None,
1520
387
'merge-type': get_merge_type,
388
'pattern': str,
1521
389
}
1522
390
1523
391
SHORT_OPTIONS = {
1540
408
1541
409
>>> parse_args('--help'.split())
1542
410
([], {'help': True})
411
>>> parse_args('help -- --invalidcmd'.split())
412
(['help', '--invalidcmd'], {})
1543
413
>>> parse_args('--version'.split())
1544
414
([], {'version': True})
1545
415
>>> parse_args('status --all'.split())
1558
428
args = []
1559
429
opts = {}
1560
430
1561
# TODO: Maybe handle '--' to end options?
1562
431
argsover = False
1563
432
while argv:
1564
433
a = argv.pop(0)
1565
if a[0] == '-':
434
if not argsover and a[0] == '-':
1566
435
# option names must not be unicode
1567
436
a = str(a)
1568
437
optarg = None
1569
438
if a[1] == '-':
439
if a == '--':
440
# We've received a standalone -- No more flags
441
argsover = True
442
continue
1570
443
mutter(" got option %r" % a)
1571
444
if '=' in a:
1572
445
optname, optarg = a[2:].split('=', 1)
1673
546
return argdict
1674
547
1675
548
1676
def _parse_master_args(argv):
1677
"""Parse the arguments that always go with the original command.
1678
These are things like bzr --no-plugins, etc.
1679
1680
There are now 2 types of option flags. Ones that come *before* the command,
1681
and ones that come *after* the command.
1682
Ones coming *before* the command are applied against all possible commands.
1683
And are generally applied before plugins are loaded.
1684
1685
The current list are:
1686
--builtin Allow plugins to load, but don't let them override builtin commands,
1687
they will still be allowed if they do not override a builtin.
1688
--no-plugins Don't load any plugins. This lets you get back to official source
1689
behavior.
1690
--profile Enable the hotspot profile before running the command.
1691
For backwards compatibility, this is also a non-master option.
1692
--version Spit out the version of bzr that is running and exit.
1693
This is also a non-master option.
1694
--help Run help and exit, also a non-master option (I think that should stay, though)
1695
1696
>>> argv, opts = _parse_master_args(['--test'])
1697
Traceback (most recent call last):
1698
...
1699
BzrCommandError: Invalid master option: 'test'
1700
>>> argv, opts = _parse_master_args(['--version', 'command'])
1701
>>> print argv
1702
['command']
1703
>>> print opts['version']
1704
True
1705
>>> argv, opts = _parse_master_args(['--profile', 'command', '--more-options'])
1706
>>> print argv
1707
['command', '--more-options']
1708
>>> print opts['profile']
1709
True
1710
>>> argv, opts = _parse_master_args(['--no-plugins', 'command'])
1711
>>> print argv
1712
['command']
1713
>>> print opts['no-plugins']
1714
True
1715
>>> print opts['profile']
1716
False
1717
>>> argv, opts = _parse_master_args(['command', '--profile'])
1718
>>> print argv
1719
['command', '--profile']
1720
>>> print opts['profile']
1721
False
1722
"""
1723
master_opts = {'builtin':False,
1724
'no-plugins':False,
1725
'version':False,
1726
'profile':False,
1727
'help':False
1728
}
1729
1730
for arg in argv[:]:
1731
if arg[:2] != '--': # at the first non-option, we return the rest
1732
break
1733
arg = arg[2:] # Remove '--'
1734
if arg not in master_opts:
1735
# We could say that this is not an error, that we should
1736
# just let it be handled by the main section instead
1737
raise BzrCommandError('Invalid master option: %r' % arg)
1738
argv.pop(0) # We are consuming this entry
1739
master_opts[arg] = True
1740
return argv, master_opts
1741
549
550
def apply_profiled(the_callable, *args, **kwargs):
551
import hotshot
552
import tempfile
553
pffileno, pfname = tempfile.mkstemp()
554
try:
555
prof = hotshot.Profile(pfname)
556
try:
557
ret = prof.runcall(the_callable, *args, **kwargs) or 0
558
finally:
559
prof.close()
560
561
import hotshot.stats
562
stats = hotshot.stats.load(pfname)
563
#stats.strip_dirs()
564
stats.sort_stats('time')
565
## XXX: Might like to write to stderr or the trace file instead but
566
## print_stats seems hardcoded to stdout
567
stats.print_stats(20)
568
569
return ret
570
finally:
571
os.close(pffileno)
572
os.remove(pfname)
1742
573
1743
574
1744
575
def run_bzr(argv):
1748
579
logging and error handling.
1749
580
1750
581
argv
1751
The command-line arguments, without the program name.
582
The command-line arguments, without the program name from argv[0]
1752
583
1753
584
Returns a command status or raises an exception.
585
586
Special master options: these must come before the command because
587
they control how the command is interpreted.
588
589
--no-plugins
590
Do not load plugin modules at all
591
592
--builtin
593
Only use builtin commands. (Plugins are still allowed to change
594
other behaviour.)
595
596
--profile
597
Run under the Python profiler.
1754
598
"""
599
1755
600
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1756
601
1757
# some options like --builtin and --no-plugins have special effects
1758
argv, master_opts = _parse_master_args(argv)
1759
if not master_opts['no-plugins']:
602
opt_profile = opt_no_plugins = opt_builtin = False
603
604
# --no-plugins is handled specially at a very early stage. We need
605
# to load plugins before doing other command parsing so that they
606
# can override commands, but this needs to happen first.
607
608
for a in argv:
609
if a == '--profile':
610
opt_profile = True
611
elif a == '--no-plugins':
612
opt_no_plugins = True
613
elif a == '--builtin':
614
opt_builtin = True
615
else:
616
break
617
argv.remove(a)
618
619
if (not argv) or (argv[0] == '--help'):
620
from bzrlib.help import help
621
if len(argv) > 1:
622
help(argv[1])
623
else:
624
help()
625
return 0
626
627
if argv[0] == '--version':
628
from bzrlib.builtins import show_version
629
show_version()
630
return 0
631
632
if not opt_no_plugins:
1760
633
from bzrlib.plugin import load_plugins
1761
634
load_plugins()
1762
635
1763
args, opts = parse_args(argv)
1764
1765
if master_opts.get('help') or 'help' in opts:
1766
from bzrlib.help import help
1767
if argv:
1768
help(argv[0])
1769
else:
1770
help()
1771
return 0
1772
1773
if 'version' in opts:
1774
show_version()
1775
return 0
1776
1777
if args and args[0] == 'builtin':
1778
include_plugins=False
1779
args = args[1:]
1780
1781
try:
1782
cmd = str(args.pop(0))
1783
except IndexError:
1784
print >>sys.stderr, "please try 'bzr help' for help"
1785
return 1
1786
1787
plugins_override = not (master_opts['builtin'])
1788
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1789
1790
profile = master_opts['profile']
1791
# For backwards compatibility, I would rather stick with --profile being a
1792
# master/global option
1793
if 'profile' in opts:
1794
profile = True
1795
del opts['profile']
1796
1797
# check options are reasonable
1798
allowed = cmd_class.takes_options
1799
for oname in opts:
1800
if oname not in allowed:
1801
raise BzrCommandError("option '--%s' is not allowed for command %r"
1802
% (oname, cmd))
1803
1804
# mix arguments and options into one dictionary
1805
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1806
cmdopts = {}
1807
for k, v in opts.items():
1808
cmdopts[k.replace('-', '_')] = v
1809
1810
if profile:
1811
import hotshot, tempfile
1812
pffileno, pfname = tempfile.mkstemp()
1813
try:
1814
prof = hotshot.Profile(pfname)
1815
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1816
prof.close()
1817
1818
import hotshot.stats
1819
stats = hotshot.stats.load(pfname)
1820
#stats.strip_dirs()
1821
stats.sort_stats('time')
1822
## XXX: Might like to write to stderr or the trace file instead but
1823
## print_stats seems hardcoded to stdout
1824
stats.print_stats(20)
1825
1826
return ret.status
1827
1828
finally:
1829
os.close(pffileno)
1830
os.remove(pfname)
636
cmd = str(argv.pop(0))
637
638
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
639
640
if opt_profile:
641
ret = apply_profiled(cmd_obj.run_argv, argv)
1831
642
else:
1832
return cmd_class(cmdopts, cmdargs).status
1833
1834
1835
def _report_exception(summary, quiet=False):
1836
import traceback
1837
log_error('bzr: ' + summary)
1838
bzrlib.trace.log_exception()
1839
1840
if not quiet:
1841
tb = sys.exc_info()[2]
1842
exinfo = traceback.extract_tb(tb)
1843
if exinfo:
1844
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1845
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1846
643
ret = cmd_obj.run_argv(argv)
644
return ret or 0
1847
645
1848
646
1849
647
def main(argv):
1850
1851
bzrlib.trace.open_tracefile(argv)
648
import bzrlib.ui
649
bzrlib.trace.log_startup(argv)
650
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1852
651
1853
652
try:
1854
653
try:
1855
try:
1856
return run_bzr(argv[1:])
1857
finally:
1858
# do this here inside the exception wrappers to catch EPIPE
1859
sys.stdout.flush()
1860
except BzrError, e:
1861
quiet = isinstance(e, (BzrCommandError))
1862
_report_exception('error: ' + e.args[0], quiet=quiet)
1863
if len(e.args) > 1:
1864
for h in e.args[1]:
1865
# some explanation or hints
1866
log_error(' ' + h)
1867
return 1
1868
except AssertionError, e:
1869
msg = 'assertion failed'
1870
if str(e):
1871
msg += ': ' + str(e)
1872
_report_exception(msg)
1873
return 2
1874
except KeyboardInterrupt, e:
1875
_report_exception('interrupted', quiet=True)
1876
return 2
1877
except Exception, e:
1878
import errno
1879
quiet = False
1880
if (isinstance(e, IOError)
1881
and hasattr(e, 'errno')
1882
and e.errno == errno.EPIPE):
1883
quiet = True
1884
msg = 'broken pipe'
1885
else:
1886
msg = str(e).rstrip('\n')
1887
_report_exception(msg, quiet)
1888
return 2
1889
finally:
1890
bzrlib.trace.close_trace()
654
return run_bzr(argv[1:])
655
finally:
656
# do this here inside the exception wrappers to catch EPIPE
657
sys.stdout.flush()
658
except BzrCommandError, e:
659
# command line syntax error, etc
660
log_error(str(e))
661
return 1
662
except BzrError, e:
663
bzrlib.trace.log_exception()
664
return 1
665
except AssertionError, e:
666
bzrlib.trace.log_exception('assertion failed: ' + str(e))
667
return 3
668
except KeyboardInterrupt, e:
669
bzrlib.trace.note('interrupted')
670
return 2
671
except Exception, e:
672
import errno
673
if (isinstance(e, IOError)
674
and hasattr(e, 'errno')
675
and e.errno == errno.EPIPE):
676
bzrlib.trace.note('broken pipe')
677
return 2
678
else:
679
bzrlib.trace.log_exception()
680
return 2
1891
681
1892
682
1893
683
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1