« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1185.2.6
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.2.6
- Committer: Lalo Martins
- Date: 2005-09-08 00:40:15 UTC
- mto: (1185.1.22)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: lalo@exoweb.net-20050908004014-bb63b3378ac8ff58
turned get_revision_info into a RevisionSpec class
- files added:
- bzrlib/builtins.py
- files removed:
- bzrlib/plugins/checkperms
- 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
18
# TODO: probably should say which arguments are candidates for glob
21
19
# expansion on windows and do that at the command level.
22
20
27
25
# would help with validation and shell completion.
28
26
29
27
28
30
29
import sys
31
30
import os
31
from warnings import warn
32
from inspect import getdoc
32
33
33
34
import bzrlib
35
import bzrlib.trace
34
36
from bzrlib.trace import mutter, note, log_error, warning
35
37
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
36
38
from bzrlib.branch import find_branch
37
39
from bzrlib import BZRDIR
38
40
39
40
41
plugin_cmds = {}
41
42
42
43
50
51
k_unsquished = k
51
52
if not plugin_cmds.has_key(k_unsquished):
52
53
plugin_cmds[k_unsquished] = cmd
54
mutter('registered plugin command %s', k_unsquished)
53
55
else:
54
56
log_error('Two plugins defined the same command: %r' % k)
55
57
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
67
69
def _parse_revision_str(revstr):
68
70
"""This handles a revision string -> revno.
69
71
70
This always returns a list. The list will have one element for
72
This always returns a list. The list will have one element for
73
each revision.
71
74
72
75
It supports integers directly, but everything else it
73
defers for passing to Branch.get_revision_info()
76
defers for passing to RevisionSpec.
74
77
75
78
>>> _parse_revision_str('234')
76
79
[234]
160
163
msg = "No known merge type %s. Supported types are:\n%s" %\
161
164
(typestring, type_list)
162
165
raise BzrCommandError(msg)
166
167
168
def _builtin_commands():
169
import bzrlib.builtins
170
r = {}
171
builtins = bzrlib.builtins.__dict__
172
for name in builtins:
173
if name.startswith("cmd_"):
174
real_name = _unsquish_command_name(name)
175
r[real_name] = builtins[name]
176
return r
177
178
179
180
def builtin_command_names():
181
"""Return list of builtin command names."""
182
return _builtin_commands().keys()
163
183
164
184
185
def plugin_command_names():
186
return plugin_cmds.keys()
187
165
188
166
189
def _get_cmd_dict(plugins_override=True):
167
d = {}
168
for k, v in globals().iteritems():
169
if k.startswith("cmd_"):
170
d[_unsquish_command_name(k)] = v
171
# If we didn't load plugins, the plugin_cmds dict will be empty
190
"""Return name->class mapping for all commands."""
191
d = _builtin_commands()
172
192
if plugins_override:
173
193
d.update(plugin_cmds)
174
else:
175
d2 = plugin_cmds.copy()
176
d2.update(d)
177
d = d2
178
194
return d
179
195
180
196
184
200
yield k,v
185
201
186
202
187
def get_cmd_class(cmd, plugins_override=True):
203
def get_cmd_object(cmd_name, plugins_override=True):
188
204
"""Return the canonical name and command class for a command.
205
206
plugins_override
207
If true, plugin commands can override builtins.
189
208
"""
190
cmd = str(cmd) # not unicode
209
from bzrlib.externalcommand import ExternalCommand
210
211
cmd_name = str(cmd_name) # not unicode
191
212
192
213
# first look up this command under the specified name
193
214
cmds = _get_cmd_dict(plugins_override=plugins_override)
194
215
try:
195
return cmd, cmds[cmd]
216
return cmds[cmd_name]()
196
217
except KeyError:
197
218
pass
198
219
199
220
# look for any command which claims this as an alias
200
for cmdname, cmdclass in cmds.iteritems():
201
if cmd in cmdclass.aliases:
202
return cmdname, cmdclass
203
204
cmdclass = ExternalCommand.find_command(cmd)
205
if cmdclass:
206
return cmd, cmdclass
207
208
raise BzrCommandError("unknown command %r" % cmd)
221
for real_cmd_name, cmd_class in cmds.iteritems():
222
if cmd_name in cmd_class.aliases:
223
return cmd_class()
224
225
cmd_obj = ExternalCommand.find_command(cmd_name)
226
if cmd_obj:
227
return cmd_obj
228
229
raise BzrCommandError("unknown command %r" % cmd_name)
209
230
210
231
211
232
class Command(object):
212
233
"""Base class for commands.
213
234
235
Commands are the heart of the command-line bzr interface.
236
237
The command object mostly handles the mapping of command-line
238
parameters into one or more bzrlib operations, and of the results
239
into textual output.
240
241
Commands normally don't have any state. All their arguments are
242
passed in to the run method. (Subclasses may take a different
243
policy if the behaviour of the instance needs to depend on e.g. a
244
shell plugin and not just its Python class.)
245
214
246
The docstring for an actual command should give a single-line
215
247
summary, then a complete description of the command. A grammar
216
248
description will be inserted.
217
249
250
aliases
251
Other accepted names for this command.
252
218
253
takes_args
219
254
List of argument forms, marked with whether they are optional,
220
255
repeated, etc.
223
258
List of options that may be given for this command.
224
259
225
260
hidden
226
If true, this command isn't advertised.
261
If true, this command isn't advertised. This is typically
262
for commands intended for expert users.
227
263
"""
228
264
aliases = []
229
265
232
268
233
269
hidden = False
234
270
235
def __init__(self, options, arguments):
236
"""Construct and run the command.
237
238
Sets self.status to the return value of run()."""
239
assert isinstance(options, dict)
240
assert isinstance(arguments, dict)
241
cmdargs = options.copy()
242
cmdargs.update(arguments)
271
def __init__(self):
272
"""Construct an instance of this command."""
243
273
if self.__doc__ == Command.__doc__:
244
from warnings import warn
245
274
warn("No help message set for %r" % self)
246
self.status = self.run(**cmdargs)
247
if self.status is None:
248
self.status = 0
275
276
277
def run_argv(self, argv):
278
"""Parse command line and run."""
279
args, opts = parse_args(argv)
280
281
if 'help' in opts: # e.g. bzr add --help
282
from bzrlib.help import help_on_command
283
help_on_command(self.name())
284
return 0
285
286
# check options are reasonable
287
allowed = self.takes_options
288
for oname in opts:
289
if oname not in allowed:
290
raise BzrCommandError("option '--%s' is not allowed for command %r"
291
% (oname, self.name()))
292
293
# mix arguments and options into one dictionary
294
cmdargs = _match_argform(self.name(), self.takes_args, args)
295
cmdopts = {}
296
for k, v in opts.items():
297
cmdopts[k.replace('-', '_')] = v
298
299
all_cmd_args = cmdargs.copy()
300
all_cmd_args.update(cmdopts)
301
302
return self.run(**all_cmd_args)
249
303
250
304
251
305
def run(self):
252
"""Override this in sub-classes.
306
"""Actually run the command.
253
307
254
308
This is invoked with the options and arguments bound to
255
309
keyword parameters.
256
310
257
Return 0 or None if the command was successful, or a shell
258
error code if not.
311
Return 0 or None if the command was successful, or a non-zero
312
shell error code if not. It's OK for this method to allow
313
an exception to raise up.
259
314
"""
260
return 0
261
262
263
class ExternalCommand(Command):
264
"""Class to wrap external commands.
265
266
We cheat a little here, when get_cmd_class() calls us we actually
267
give it back an object we construct that has the appropriate path,
268
help, options etc for the specified command.
269
270
When run_bzr() tries to instantiate that 'class' it gets caught by
271
the __call__ method, which we override to call the Command.__init__
272
method. That then calls our run method which is pretty straight
273
forward.
274
275
The only wrinkle is that we have to map bzr's dictionary of options
276
and arguments back into command line options and arguments for the
277
script.
278
"""
279
280
def find_command(cls, cmd):
281
import os.path
282
bzrpath = os.environ.get('BZRPATH', '')
283
284
for dir in bzrpath.split(os.pathsep):
285
path = os.path.join(dir, cmd)
286
if os.path.isfile(path):
287
return ExternalCommand(path)
288
289
return None
290
291
find_command = classmethod(find_command)
292
293
def __init__(self, path):
294
self.path = path
295
296
pipe = os.popen('%s --bzr-usage' % path, 'r')
297
self.takes_options = pipe.readline().split()
298
299
for opt in self.takes_options:
300
if not opt in OPTIONS:
301
raise BzrError("Unknown option '%s' returned by external command %s"
302
% (opt, path))
303
304
# TODO: Is there any way to check takes_args is valid here?
305
self.takes_args = pipe.readline().split()
306
307
if pipe.close() is not None:
308
raise BzrError("Failed funning '%s --bzr-usage'" % path)
309
310
pipe = os.popen('%s --bzr-help' % path, 'r')
311
self.__doc__ = pipe.read()
312
if pipe.close() is not None:
313
raise BzrError("Failed funning '%s --bzr-help'" % path)
314
315
def __call__(self, options, arguments):
316
Command.__init__(self, options, arguments)
317
return self
318
319
def run(self, **kargs):
320
opts = []
321
args = []
322
323
keys = kargs.keys()
324
keys.sort()
325
for name in keys:
326
optname = name.replace('_','-')
327
value = kargs[name]
328
if OPTIONS.has_key(optname):
329
# it's an option
330
opts.append('--%s' % optname)
331
if value is not None and value is not True:
332
opts.append(str(value))
333
else:
334
# it's an arg, or arg list
335
if type(value) is not list:
336
value = [value]
337
for v in value:
338
if v is not None:
339
args.append(str(v))
340
341
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
342
return self.status
343
344
345
class cmd_status(Command):
346
"""Display status summary.
347
348
This reports on versioned and unknown files, reporting them
349
grouped by state. Possible states are:
350
351
added
352
Versioned in the working copy but not in the previous revision.
353
354
removed
355
Versioned in the previous revision but removed or deleted
356
in the working copy.
357
358
renamed
359
Path of this file changed from the previous revision;
360
the text may also have changed. This includes files whose
361
parent directory was renamed.
362
363
modified
364
Text has changed since the previous revision.
365
366
unchanged
367
Nothing about this file has changed since the previous revision.
368
Only shown with --all.
369
370
unknown
371
Not versioned and not matching an ignore pattern.
372
373
To see ignored files use 'bzr ignored'. For details in the
374
changes to file texts, use 'bzr diff'.
375
376
If no arguments are specified, the status of the entire working
377
directory is shown. Otherwise, only the status of the specified
378
files or directories is reported. If a directory is given, status
379
is reported for everything inside that directory.
380
381
If a revision is specified, the changes since that revision are shown.
382
"""
383
takes_args = ['file*']
384
takes_options = ['all', 'show-ids', 'revision']
385
aliases = ['st', 'stat']
386
387
def run(self, all=False, show_ids=False, file_list=None):
388
if file_list:
389
b = find_branch(file_list[0])
390
file_list = [b.relpath(x) for x in file_list]
391
# special case: only one path was given and it's the root
392
# of the branch
393
if file_list == ['']:
394
file_list = None
395
else:
396
b = find_branch('.')
397
398
from bzrlib.status import show_status
399
show_status(b, show_unchanged=all, show_ids=show_ids,
400
specific_files=file_list)
401
402
403
class cmd_cat_revision(Command):
404
"""Write out metadata for a revision."""
405
406
hidden = True
407
takes_args = ['revision_id']
408
409
def run(self, revision_id):
410
from bzrlib.xml import pack_xml
411
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
412
413
414
class cmd_revno(Command):
415
"""Show current revision number.
416
417
This is equal to the number of revisions on this branch."""
418
def run(self):
419
print find_branch('.').revno()
420
421
class cmd_revision_info(Command):
422
"""Show revision number and revision id for a given revision identifier.
423
"""
424
hidden = True
425
takes_args = ['revision_info*']
426
takes_options = ['revision']
427
def run(self, revision=None, revision_info_list=None):
428
from bzrlib.branch import find_branch
429
430
revs = []
431
if revision is not None:
432
revs.extend(revision)
433
if revision_info_list is not None:
434
revs.extend(revision_info_list)
435
if len(revs) == 0:
436
raise BzrCommandError('You must supply a revision identifier')
437
438
b = find_branch('.')
439
440
for rev in revs:
441
print '%4d %s' % b.get_revision_info(rev)
442
443
444
class cmd_add(Command):
445
"""Add specified files or directories.
446
447
In non-recursive mode, all the named items are added, regardless
448
of whether they were previously ignored. A warning is given if
449
any of the named files are already versioned.
450
451
In recursive mode (the default), files are treated the same way
452
but the behaviour for directories is different. Directories that
453
are already versioned do not give a warning. All directories,
454
whether already versioned or not, are searched for files or
455
subdirectories that are neither versioned or ignored, and these
456
are added. This search proceeds recursively into versioned
457
directories. If no names are given '.' is assumed.
458
459
Therefore simply saying 'bzr add' will version all files that
460
are currently unknown.
461
462
TODO: Perhaps adding a file whose directly is not versioned should
463
recursively add that parent, rather than giving an error?
464
"""
465
takes_args = ['file*']
466
takes_options = ['verbose', 'no-recurse']
467
468
def run(self, file_list, verbose=False, no_recurse=False):
469
from bzrlib.add import smart_add, _PrintAddCallback
470
smart_add(file_list, verbose, not no_recurse,
471
callback=_PrintAddCallback)
472
473
474
475
class cmd_mkdir(Command):
476
"""Create a new versioned directory.
477
478
This is equivalent to creating the directory and then adding it.
479
"""
480
takes_args = ['dir+']
481
482
def run(self, dir_list):
483
b = None
484
485
for d in dir_list:
486
os.mkdir(d)
487
if not b:
488
b = find_branch(d)
489
b.add([d], verbose=True)
490
491
492
class cmd_relpath(Command):
493
"""Show path of a file relative to root"""
494
takes_args = ['filename']
495
hidden = True
496
497
def run(self, filename):
498
print find_branch(filename).relpath(filename)
499
500
501
502
class cmd_inventory(Command):
503
"""Show inventory of the current working copy or a revision."""
504
takes_options = ['revision', 'show-ids']
505
506
def run(self, revision=None, show_ids=False):
507
b = find_branch('.')
508
if revision == None:
509
inv = b.read_working_inventory()
510
else:
511
if len(revision) > 1:
512
raise BzrCommandError('bzr inventory --revision takes'
513
' exactly one revision identifier')
514
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
515
516
for path, entry in inv.entries():
517
if show_ids:
518
print '%-50s %s' % (path, entry.file_id)
519
else:
520
print path
521
522
523
class cmd_move(Command):
524
"""Move files to a different directory.
525
526
examples:
527
bzr move *.txt doc
528
529
The destination must be a versioned directory in the same branch.
530
"""
531
takes_args = ['source$', 'dest']
532
def run(self, source_list, dest):
533
b = find_branch('.')
534
535
# TODO: glob expansion on windows?
536
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
537
538
539
class cmd_rename(Command):
540
"""Change the name of an entry.
541
542
examples:
543
bzr rename frob.c frobber.c
544
bzr rename src/frob.c lib/frob.c
545
546
It is an error if the destination name exists.
547
548
See also the 'move' command, which moves files into a different
549
directory without changing their name.
550
551
TODO: Some way to rename multiple files without invoking bzr for each
552
one?"""
553
takes_args = ['from_name', 'to_name']
554
555
def run(self, from_name, to_name):
556
b = find_branch('.')
557
b.rename_one(b.relpath(from_name), b.relpath(to_name))
558
559
560
561
class cmd_mv(Command):
562
"""Move or rename a file.
563
564
usage:
565
bzr mv OLDNAME NEWNAME
566
bzr mv SOURCE... DESTINATION
567
568
If the last argument is a versioned directory, all the other names
569
are moved into it. Otherwise, there must be exactly two arguments
570
and the file is changed to a new name, which must not already exist.
571
572
Files cannot be moved between branches.
573
"""
574
takes_args = ['names*']
575
def run(self, names_list):
576
if len(names_list) < 2:
577
raise BzrCommandError("missing file argument")
578
b = find_branch(names_list[0])
579
580
rel_names = [b.relpath(x) for x in names_list]
581
582
if os.path.isdir(names_list[-1]):
583
# move into existing directory
584
b.move(rel_names[:-1], rel_names[-1])
585
else:
586
if len(names_list) != 2:
587
raise BzrCommandError('to mv multiple files the destination '
588
'must be a versioned directory')
589
b.move(rel_names[0], rel_names[1])
590
591
592
593
594
class cmd_pull(Command):
595
"""Pull any changes from another branch into the current one.
596
597
If the location is omitted, the last-used location will be used.
598
Both the revision history and the working directory will be
599
updated.
600
601
This command only works on branches that have not diverged. Branches are
602
considered diverged if both branches have had commits without first
603
pulling from the other.
604
605
If branches have diverged, you can use 'bzr merge' to pull the text changes
606
from one into the other.
607
"""
608
takes_args = ['location?']
609
610
def run(self, location=None):
611
from bzrlib.merge import merge
612
import tempfile
613
from shutil import rmtree
614
import errno
615
from bzrlib.branch import pull_loc
616
617
br_to = find_branch('.')
618
stored_loc = None
619
try:
620
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
621
except IOError, e:
622
if e.errno != errno.ENOENT:
623
raise
624
if location is None:
625
if stored_loc is None:
626
raise BzrCommandError("No pull location known or specified.")
627
else:
628
print "Using last location: %s" % stored_loc
629
location = stored_loc
630
cache_root = tempfile.mkdtemp()
631
from bzrlib.branch import DivergedBranches
632
br_from = find_branch(location)
633
location = pull_loc(br_from)
634
old_revno = br_to.revno()
635
try:
636
from branch import find_cached_branch, DivergedBranches
637
br_from = find_cached_branch(location, cache_root)
638
location = pull_loc(br_from)
639
old_revno = br_to.revno()
640
try:
641
br_to.update_revisions(br_from)
642
except DivergedBranches:
643
raise BzrCommandError("These branches have diverged."
644
" Try merge.")
645
646
merge(('.', -1), ('.', old_revno), check_clean=False)
647
if location != stored_loc:
648
br_to.controlfile("x-pull", "wb").write(location + "\n")
649
finally:
650
rmtree(cache_root)
651
652
653
654
class cmd_branch(Command):
655
"""Create a new copy of a branch.
656
657
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
658
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
659
660
To retrieve the branch as of a particular revision, supply the --revision
661
parameter, as in "branch foo/bar -r 5".
662
"""
663
takes_args = ['from_location', 'to_location?']
664
takes_options = ['revision']
665
aliases = ['get', 'clone']
666
667
def run(self, from_location, to_location=None, revision=None):
668
from bzrlib.branch import copy_branch, find_cached_branch
669
import tempfile
670
import errno
671
cache_root = tempfile.mkdtemp()
672
try:
673
if revision is None:
674
revision = [None]
675
elif len(revision) > 1:
676
raise BzrCommandError(
677
'bzr branch --revision takes exactly 1 revision value')
678
try:
679
br_from = find_cached_branch(from_location, cache_root)
680
except OSError, e:
681
if e.errno == errno.ENOENT:
682
raise BzrCommandError('Source location "%s" does not'
683
' exist.' % to_location)
684
else:
685
raise
686
if to_location is None:
687
to_location = os.path.basename(from_location.rstrip("/\\"))
688
try:
689
os.mkdir(to_location)
690
except OSError, e:
691
if e.errno == errno.EEXIST:
692
raise BzrCommandError('Target directory "%s" already'
693
' exists.' % to_location)
694
if e.errno == errno.ENOENT:
695
raise BzrCommandError('Parent of "%s" does not exist.' %
696
to_location)
697
else:
698
raise
699
try:
700
copy_branch(br_from, to_location, revision[0])
701
except bzrlib.errors.NoSuchRevision:
702
rmtree(to_location)
703
msg = "The branch %s has no revision %d." % (from_location, revision[0])
704
raise BzrCommandError(msg)
705
finally:
706
rmtree(cache_root)
707
708
709
class cmd_renames(Command):
710
"""Show list of renamed files.
711
712
TODO: Option to show renames between two historical versions.
713
714
TODO: Only show renames under dir, rather than in the whole branch.
715
"""
716
takes_args = ['dir?']
717
718
def run(self, dir='.'):
719
b = find_branch(dir)
720
old_inv = b.basis_tree().inventory
721
new_inv = b.read_working_inventory()
722
723
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
724
renames.sort()
725
for old_name, new_name in renames:
726
print "%s => %s" % (old_name, new_name)
727
728
729
class cmd_info(Command):
730
"""Show statistical information about a branch."""
731
takes_args = ['branch?']
732
733
def run(self, branch=None):
734
import info
735
736
b = find_branch(branch)
737
info.show_info(b)
738
739
740
class cmd_remove(Command):
741
"""Make a file unversioned.
742
743
This makes bzr stop tracking changes to a versioned file. It does
744
not delete the working copy.
745
"""
746
takes_args = ['file+']
747
takes_options = ['verbose']
748
749
def run(self, file_list, verbose=False):
750
b = find_branch(file_list[0])
751
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
752
753
754
class cmd_file_id(Command):
755
"""Print file_id of a particular file or directory.
756
757
The file_id is assigned when the file is first added and remains the
758
same through all revisions where the file exists, even when it is
759
moved or renamed.
760
"""
761
hidden = True
762
takes_args = ['filename']
763
def run(self, filename):
764
b = find_branch(filename)
765
i = b.inventory.path2id(b.relpath(filename))
766
if i == None:
767
raise BzrError("%r is not a versioned file" % filename)
768
else:
769
print i
770
771
772
class cmd_file_path(Command):
773
"""Print path of file_ids to a file or directory.
774
775
This prints one line for each directory down to the target,
776
starting at the branch root."""
777
hidden = True
778
takes_args = ['filename']
779
def run(self, filename):
780
b = find_branch(filename)
781
inv = b.inventory
782
fid = inv.path2id(b.relpath(filename))
783
if fid == None:
784
raise BzrError("%r is not a versioned file" % filename)
785
for fip in inv.get_idpath(fid):
786
print fip
787
788
789
class cmd_revision_history(Command):
790
"""Display list of revision ids on this branch."""
791
hidden = True
792
def run(self):
793
for patchid in find_branch('.').revision_history():
794
print patchid
795
796
797
class cmd_directories(Command):
798
"""Display list of versioned directories in this branch."""
799
def run(self):
800
for name, ie in find_branch('.').read_working_inventory().directories():
801
if name == '':
802
print '.'
803
else:
804
print name
805
806
807
class cmd_init(Command):
808
"""Make a directory into a versioned branch.
809
810
Use this to create an empty branch, or before importing an
811
existing project.
812
813
Recipe for importing a tree of files:
814
cd ~/project
815
bzr init
816
bzr add -v .
817
bzr status
818
bzr commit -m 'imported project'
819
"""
820
def run(self):
821
from bzrlib.branch import Branch
822
Branch('.', init=True)
823
824
825
class cmd_diff(Command):
826
"""Show differences in working tree.
827
828
If files are listed, only the changes in those files are listed.
829
Otherwise, all changes for the tree are listed.
830
831
TODO: Allow diff across branches.
832
833
TODO: Option to use external diff command; could be GNU diff, wdiff,
834
or a graphical diff.
835
836
TODO: Python difflib is not exactly the same as unidiff; should
837
either fix it up or prefer to use an external diff.
838
839
TODO: If a directory is given, diff everything under that.
840
841
TODO: Selected-file diff is inefficient and doesn't show you
842
deleted files.
843
844
TODO: This probably handles non-Unix newlines poorly.
845
846
examples:
847
bzr diff
848
bzr diff -r1
849
bzr diff -r1:2
850
"""
851
852
takes_args = ['file*']
853
takes_options = ['revision', 'diff-options']
854
aliases = ['di', 'dif']
855
856
def run(self, revision=None, file_list=None, diff_options=None):
857
from bzrlib.diff import show_diff
858
859
if file_list:
860
b = find_branch(file_list[0])
861
file_list = [b.relpath(f) for f in file_list]
862
if file_list == ['']:
863
# just pointing to top-of-tree
864
file_list = None
865
else:
866
b = find_branch('.')
867
868
if revision is not None:
869
if len(revision) == 1:
870
show_diff(b, revision[0], specific_files=file_list,
871
external_diff_options=diff_options)
872
elif len(revision) == 2:
873
show_diff(b, revision[0], specific_files=file_list,
874
external_diff_options=diff_options,
875
revision2=revision[1])
876
else:
877
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
878
else:
879
show_diff(b, None, specific_files=file_list,
880
external_diff_options=diff_options)
881
882
883
884
885
class cmd_deleted(Command):
886
"""List files deleted in the working tree.
887
888
TODO: Show files deleted since a previous revision, or between two revisions.
889
"""
890
def run(self, show_ids=False):
891
b = find_branch('.')
892
old = b.basis_tree()
893
new = b.working_tree()
894
895
## TODO: Much more efficient way to do this: read in new
896
## directories with readdir, rather than stating each one. Same
897
## level of effort but possibly much less IO. (Or possibly not,
898
## if the directories are very large...)
899
900
for path, ie in old.inventory.iter_entries():
901
if not new.has_id(ie.file_id):
902
if show_ids:
903
print '%-50s %s' % (path, ie.file_id)
904
else:
905
print path
906
907
908
class cmd_modified(Command):
909
"""List files modified in working tree."""
910
hidden = True
911
def run(self):
912
from bzrlib.delta import compare_trees
913
914
b = find_branch('.')
915
td = compare_trees(b.basis_tree(), b.working_tree())
916
917
for path, id, kind in td.modified:
918
print path
919
920
921
922
class cmd_added(Command):
923
"""List files added in working tree."""
924
hidden = True
925
def run(self):
926
b = find_branch('.')
927
wt = b.working_tree()
928
basis_inv = b.basis_tree().inventory
929
inv = wt.inventory
930
for file_id in inv:
931
if file_id in basis_inv:
932
continue
933
path = inv.id2path(file_id)
934
if not os.access(b.abspath(path), os.F_OK):
935
continue
936
print path
937
938
939
940
class cmd_root(Command):
941
"""Show the tree root directory.
942
943
The root is the nearest enclosing directory with a .bzr control
944
directory."""
945
takes_args = ['filename?']
946
def run(self, filename=None):
947
"""Print the branch root."""
948
b = find_branch(filename)
949
print getattr(b, 'base', None) or getattr(b, 'baseurl')
950
951
952
class cmd_log(Command):
953
"""Show log of this branch.
954
955
To request a range of logs, you can use the command -r begin:end
956
-r revision requests a specific revision, -r :end or -r begin: are
957
also valid.
958
959
--message allows you to give a regular expression, which will be evaluated
960
so that only matching entries will be displayed.
961
962
TODO: Make --revision support uuid: and hash: [future tag:] notation.
963
964
"""
965
966
takes_args = ['filename?']
967
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
968
'long', 'message', 'short',]
969
970
def run(self, filename=None, timezone='original',
971
verbose=False,
972
show_ids=False,
973
forward=False,
974
revision=None,
975
message=None,
976
long=False,
977
short=False):
978
from bzrlib.branch import find_branch
979
from bzrlib.log import log_formatter, show_log
980
import codecs
981
982
direction = (forward and 'forward') or 'reverse'
983
984
if filename:
985
b = find_branch(filename)
986
fp = b.relpath(filename)
987
if fp:
988
file_id = b.read_working_inventory().path2id(fp)
989
else:
990
file_id = None # points to branch root
991
else:
992
b = find_branch('.')
993
file_id = None
994
995
if revision is None:
996
rev1 = None
997
rev2 = None
998
elif len(revision) == 1:
999
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1000
elif len(revision) == 2:
1001
rev1 = b.get_revision_info(revision[0])[0]
1002
rev2 = b.get_revision_info(revision[1])[0]
1003
else:
1004
raise BzrCommandError('bzr log --revision takes one or two values.')
1005
1006
if rev1 == 0:
1007
rev1 = None
1008
if rev2 == 0:
1009
rev2 = None
1010
1011
mutter('encoding log as %r' % bzrlib.user_encoding)
1012
1013
# use 'replace' so that we don't abort if trying to write out
1014
# in e.g. the default C locale.
1015
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1016
1017
if not short:
1018
log_format = 'long'
1019
else:
1020
log_format = 'short'
1021
lf = log_formatter(log_format,
1022
show_ids=show_ids,
1023
to_file=outf,
1024
show_timezone=timezone)
1025
1026
show_log(b,
1027
lf,
1028
file_id,
1029
verbose=verbose,
1030
direction=direction,
1031
start_revision=rev1,
1032
end_revision=rev2,
1033
search=message)
1034
1035
1036
1037
class cmd_touching_revisions(Command):
1038
"""Return revision-ids which affected a particular file.
1039
1040
A more user-friendly interface is "bzr log FILE"."""
1041
hidden = True
1042
takes_args = ["filename"]
1043
def run(self, filename):
1044
b = find_branch(filename)
1045
inv = b.read_working_inventory()
1046
file_id = inv.path2id(b.relpath(filename))
1047
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1048
print "%6d %s" % (revno, what)
1049
1050
1051
class cmd_ls(Command):
1052
"""List files in a tree.
1053
1054
TODO: Take a revision or remote path and list that tree instead.
1055
"""
1056
hidden = True
1057
def run(self, revision=None, verbose=False):
1058
b = find_branch('.')
1059
if revision == None:
1060
tree = b.working_tree()
1061
else:
1062
tree = b.revision_tree(b.lookup_revision(revision))
1063
1064
for fp, fc, kind, fid in tree.list_files():
1065
if verbose:
1066
if kind == 'directory':
1067
kindch = '/'
1068
elif kind == 'file':
1069
kindch = ''
1070
else:
1071
kindch = '???'
1072
1073
print '%-8s %s%s' % (fc, fp, kindch)
1074
else:
1075
print fp
1076
1077
1078
1079
class cmd_unknowns(Command):
1080
"""List unknown files."""
1081
def run(self):
1082
from bzrlib.osutils import quotefn
1083
for f in find_branch('.').unknowns():
1084
print quotefn(f)
1085
1086
1087
1088
class cmd_ignore(Command):
1089
"""Ignore a command or pattern.
1090
1091
To remove patterns from the ignore list, edit the .bzrignore file.
1092
1093
If the pattern contains a slash, it is compared to the whole path
1094
from the branch root. Otherwise, it is comapred to only the last
1095
component of the path.
1096
1097
Ignore patterns are case-insensitive on case-insensitive systems.
1098
1099
Note: wildcards must be quoted from the shell on Unix.
1100
1101
examples:
1102
bzr ignore ./Makefile
1103
bzr ignore '*.class'
1104
"""
1105
takes_args = ['name_pattern']
1106
1107
def run(self, name_pattern):
1108
from bzrlib.atomicfile import AtomicFile
1109
import os.path
1110
1111
b = find_branch('.')
1112
ifn = b.abspath('.bzrignore')
1113
1114
if os.path.exists(ifn):
1115
f = open(ifn, 'rt')
1116
try:
1117
igns = f.read().decode('utf-8')
1118
finally:
1119
f.close()
1120
else:
1121
igns = ''
1122
1123
# TODO: If the file already uses crlf-style termination, maybe
1124
# we should use that for the newly added lines?
1125
1126
if igns and igns[-1] != '\n':
1127
igns += '\n'
1128
igns += name_pattern + '\n'
1129
1130
try:
1131
f = AtomicFile(ifn, 'wt')
1132
f.write(igns.encode('utf-8'))
1133
f.commit()
1134
finally:
1135
f.close()
1136
1137
inv = b.working_tree().inventory
1138
if inv.path2id('.bzrignore'):
1139
mutter('.bzrignore is already versioned')
1140
else:
1141
mutter('need to make new .bzrignore file versioned')
1142
b.add(['.bzrignore'])
1143
1144
1145
1146
class cmd_ignored(Command):
1147
"""List ignored files and the patterns that matched them.
1148
1149
See also: bzr ignore"""
1150
def run(self):
1151
tree = find_branch('.').working_tree()
1152
for path, file_class, kind, file_id in tree.list_files():
1153
if file_class != 'I':
1154
continue
1155
## XXX: Slightly inefficient since this was already calculated
1156
pat = tree.is_ignored(path)
1157
print '%-50s %s' % (path, pat)
1158
1159
1160
class cmd_lookup_revision(Command):
1161
"""Lookup the revision-id from a revision-number
1162
1163
example:
1164
bzr lookup-revision 33
1165
"""
1166
hidden = True
1167
takes_args = ['revno']
1168
1169
def run(self, revno):
1170
try:
1171
revno = int(revno)
1172
except ValueError:
1173
raise BzrCommandError("not a valid revision-number: %r" % revno)
1174
1175
print find_branch('.').lookup_revision(revno)
1176
1177
1178
class cmd_export(Command):
1179
"""Export past revision to destination directory.
1180
1181
If no revision is specified this exports the last committed revision.
1182
1183
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1184
given, try to find the format with the extension. If no extension
1185
is found exports to a directory (equivalent to --format=dir).
1186
1187
Root may be the top directory for tar, tgz and tbz2 formats. If none
1188
is given, the top directory will be the root name of the file."""
1189
# TODO: list known exporters
1190
takes_args = ['dest']
1191
takes_options = ['revision', 'format', 'root']
1192
def run(self, dest, revision=None, format=None, root=None):
1193
import os.path
1194
b = find_branch('.')
1195
if revision is None:
1196
rev_id = b.last_patch()
1197
else:
1198
if len(revision) != 1:
1199
raise BzrError('bzr export --revision takes exactly 1 argument')
1200
revno, rev_id = b.get_revision_info(revision[0])
1201
t = b.revision_tree(rev_id)
1202
root, ext = os.path.splitext(dest)
1203
if not format:
1204
if ext in (".tar",):
1205
format = "tar"
1206
elif ext in (".gz", ".tgz"):
1207
format = "tgz"
1208
elif ext in (".bz2", ".tbz2"):
1209
format = "tbz2"
1210
else:
1211
format = "dir"
1212
t.export(dest, format, root)
1213
1214
1215
class cmd_cat(Command):
1216
"""Write a file's text from a previous revision."""
1217
1218
takes_options = ['revision']
1219
takes_args = ['filename']
1220
1221
def run(self, filename, revision=None):
1222
if revision == None:
1223
raise BzrCommandError("bzr cat requires a revision number")
1224
elif len(revision) != 1:
1225
raise BzrCommandError("bzr cat --revision takes exactly one number")
1226
b = find_branch('.')
1227
b.print_file(b.relpath(filename), revision[0])
1228
1229
1230
class cmd_local_time_offset(Command):
1231
"""Show the offset in seconds from GMT to local time."""
1232
hidden = True
1233
def run(self):
1234
print bzrlib.osutils.local_time_offset()
1235
1236
1237
1238
class cmd_commit(Command):
1239
"""Commit changes into a new revision.
1240
1241
If no arguments are given, the entire tree is committed.
1242
1243
If selected files are specified, only changes to those files are
1244
committed. If a directory is specified then the directory and everything
1245
within it is committed.
1246
1247
A selected-file commit may fail in some cases where the committed
1248
tree would be invalid, such as trying to commit a file in a
1249
newly-added directory that is not itself committed.
1250
1251
TODO: Run hooks on tree to-be-committed, and after commit.
1252
1253
TODO: Strict commit that fails if there are unknown or deleted files.
1254
"""
1255
takes_args = ['selected*']
1256
takes_options = ['message', 'file', 'verbose', 'unchanged']
1257
aliases = ['ci', 'checkin']
1258
1259
# TODO: Give better message for -s, --summary, used by tla people
1260
1261
def run(self, message=None, file=None, verbose=True, selected_list=None,
1262
unchanged=False):
1263
from bzrlib.errors import PointlessCommit
1264
from bzrlib.osutils import get_text_message
1265
1266
## Warning: shadows builtin file()
1267
if not message and not file:
1268
# FIXME: Ugly; change status code to send to a provided function?
1269
1270
import cStringIO
1271
stdout = sys.stdout
1272
catcher = cStringIO.StringIO()
1273
sys.stdout = catcher
1274
cmd_status({"file_list":selected_list}, {})
1275
info = catcher.getvalue()
1276
sys.stdout = stdout
1277
message = get_text_message(info)
1278
1279
if message is None:
1280
raise BzrCommandError("please specify a commit message",
1281
["use either --message or --file"])
1282
elif message and file:
1283
raise BzrCommandError("please specify either --message or --file")
1284
1285
if file:
1286
import codecs
1287
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1288
1289
b = find_branch('.')
1290
if selected_list:
1291
selected_list = [b.relpath(s) for s in selected_list]
1292
1293
try:
1294
b.commit(message, verbose=verbose,
1295
specific_files=selected_list,
1296
allow_pointless=unchanged)
1297
except PointlessCommit:
1298
# FIXME: This should really happen before the file is read in;
1299
# perhaps prepare the commit; get the message; then actually commit
1300
raise BzrCommandError("no changes to commit",
1301
["use --unchanged to commit anyhow"])
1302
1303
1304
class cmd_check(Command):
1305
"""Validate consistency of branch history.
1306
1307
This command checks various invariants about the branch storage to
1308
detect data corruption or bzr bugs.
1309
1310
If given the --update flag, it will update some optional fields
1311
to help ensure data consistency.
1312
"""
1313
takes_args = ['dir?']
1314
1315
def run(self, dir='.'):
1316
from bzrlib.check import check
1317
1318
check(find_branch(dir))
1319
1320
1321
class cmd_scan_cache(Command):
1322
hidden = True
1323
def run(self):
1324
from bzrlib.hashcache import HashCache
1325
import os
1326
1327
c = HashCache('.')
1328
c.read()
1329
c.scan()
1330
1331
print '%6d stats' % c.stat_count
1332
print '%6d in hashcache' % len(c._cache)
1333
print '%6d files removed from cache' % c.removed_count
1334
print '%6d hashes updated' % c.update_count
1335
print '%6d files changed too recently to cache' % c.danger_count
1336
1337
if c.needs_write:
1338
c.write()
1339
1340
1341
1342
class cmd_upgrade(Command):
1343
"""Upgrade branch storage to current format.
1344
1345
This should normally be used only after the check command tells
1346
you to run it.
1347
"""
1348
takes_args = ['dir?']
1349
1350
def run(self, dir='.'):
1351
from bzrlib.upgrade import upgrade
1352
upgrade(find_branch(dir))
1353
1354
1355
1356
class cmd_whoami(Command):
1357
"""Show bzr user id."""
1358
takes_options = ['email']
1359
1360
def run(self, email=False):
1361
try:
1362
b = bzrlib.branch.find_branch('.')
1363
except:
1364
b = None
1365
1366
if email:
1367
print bzrlib.osutils.user_email(b)
1368
else:
1369
print bzrlib.osutils.username(b)
1370
1371
1372
class cmd_selftest(Command):
1373
"""Run internal test suite"""
1374
hidden = True
1375
takes_options = ['verbose', 'pattern']
1376
def run(self, verbose=False, pattern=".*"):
1377
import bzrlib.ui
1378
from bzrlib.selftest import selftest
1379
# we don't want progress meters from the tests to go to the
1380
# real output.
1381
save_ui = bzrlib.ui.ui_factory
1382
try:
1383
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1384
return int(not selftest(verbose=verbose, pattern=pattern))
1385
finally:
1386
bzrlib.ui.ui_factory = save_ui
1387
1388
1389
class cmd_version(Command):
1390
"""Show version of bzr."""
1391
def run(self):
1392
show_version()
1393
1394
def show_version():
1395
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1396
# is bzrlib itself in a branch?
1397
bzrrev = bzrlib.get_bzr_revision()
1398
if bzrrev:
1399
print " (bzr checkout, revision %d {%s})" % bzrrev
1400
print bzrlib.__copyright__
1401
print "http://bazaar-ng.org/"
1402
print
1403
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1404
print "you may use, modify and redistribute it under the terms of the GNU"
1405
print "General Public License version 2 or later."
1406
1407
1408
class cmd_rocks(Command):
1409
"""Statement of optimism."""
1410
hidden = True
1411
def run(self):
1412
print "it sure does!"
315
raise NotImplementedError()
316
317
318
def help(self):
319
"""Return help message for this class."""
320
if self.__doc__ is Command.__doc__:
321
return None
322
return getdoc(self)
323
324
def name(self):
325
return _unsquish_command_name(self.__class__.__name__)
326
1413
327
1414
328
def parse_spec(spec):
1415
329
"""
1444
358
1445
359
1446
360
1447
class cmd_find_merge_base(Command):
1448
"""Find and print a base revision for merging two branches.
1449
1450
TODO: Options to specify revisions on either side, as if
1451
merging only part of the history.
1452
"""
1453
takes_args = ['branch', 'other']
1454
hidden = True
1455
1456
def run(self, branch, other):
1457
branch1 = find_branch(branch)
1458
branch2 = find_branch(other)
1459
1460
base_revno, base_revid = branch1.common_ancestor(branch2)
1461
1462
if base_revno is None:
1463
raise bzrlib.errors.UnrelatedBranches()
1464
1465
print 'merge base is revision %s' % base_revid
1466
print ' r%-6d in %s' % (base_revno, branch)
1467
1468
other_revno = branch2.revision_id_to_revno(base_revid)
1469
1470
print ' r%-6d in %s' % (other_revno, other)
1471
1472
1473
1474
class cmd_merge(Command):
1475
"""Perform a three-way merge.
1476
1477
The branch is the branch you will merge from. By default, it will merge
1478
the latest revision. If you specify a revision, that revision will be
1479
merged. If you specify two revisions, the first will be used as a BASE,
1480
and the second one as OTHER. Revision numbers are always relative to the
1481
specified branch.
1482
1483
Examples:
1484
1485
To merge the latest revision from bzr.dev
1486
bzr merge ../bzr.dev
1487
1488
To merge changes up to and including revision 82 from bzr.dev
1489
bzr merge -r 82 ../bzr.dev
1490
1491
To merge the changes introduced by 82, without previous changes:
1492
bzr merge -r 81..82 ../bzr.dev
1493
1494
merge refuses to run if there are any uncommitted changes, unless
1495
--force is given.
1496
"""
1497
takes_args = ['branch?']
1498
takes_options = ['revision', 'force', 'merge-type']
1499
1500
def run(self, branch='.', revision=None, force=False,
1501
merge_type=None):
1502
from bzrlib.merge import merge
1503
from bzrlib.merge_core import ApplyMerge3
1504
if merge_type is None:
1505
merge_type = ApplyMerge3
1506
1507
if revision is None or len(revision) < 1:
1508
base = (None, None)
1509
other = (branch, -1)
1510
else:
1511
if len(revision) == 1:
1512
other = (branch, revision[0])
1513
base = (None, None)
1514
else:
1515
assert len(revision) == 2
1516
if None in revision:
1517
raise BzrCommandError(
1518
"Merge doesn't permit that revision specifier.")
1519
base = (branch, revision[0])
1520
other = (branch, revision[1])
1521
1522
merge(other, base, check_clean=(not force), merge_type=merge_type)
1523
1524
1525
class cmd_revert(Command):
1526
"""Reverse all changes since the last commit.
1527
1528
Only versioned files are affected. Specify filenames to revert only
1529
those files. By default, any files that are changed will be backed up
1530
first. Backup files have a '~' appended to their name.
1531
"""
1532
takes_options = ['revision', 'no-backup']
1533
takes_args = ['file*']
1534
aliases = ['merge-revert']
1535
1536
def run(self, revision=None, no_backup=False, file_list=None):
1537
from bzrlib.merge import merge
1538
if file_list is not None:
1539
if len(file_list) == 0:
1540
raise BzrCommandError("No files specified")
1541
if revision is None:
1542
revision = [-1]
1543
elif len(revision) != 1:
1544
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1545
merge(('.', revision[0]), parse_spec('.'),
1546
check_clean=False,
1547
ignore_zero=True,
1548
backup_files=not no_backup,
1549
file_list=file_list)
1550
1551
1552
class cmd_assert_fail(Command):
1553
"""Test reporting of assertion failures"""
1554
hidden = True
1555
def run(self):
1556
assert False, "always fails"
1557
1558
1559
class cmd_help(Command):
1560
"""Show help on a command or other topic.
1561
1562
For a list of all available commands, say 'bzr help commands'."""
1563
takes_options = ['long']
1564
takes_args = ['topic?']
1565
aliases = ['?']
1566
1567
def run(self, topic=None, long=False):
1568
import help
1569
if topic is None and long:
1570
topic = "commands"
1571
help.help(topic)
1572
1573
1574
class cmd_shell_complete(Command):
1575
"""Show appropriate completions for context.
1576
1577
For a list of all available commands, say 'bzr shell-complete'."""
1578
takes_args = ['context?']
1579
aliases = ['s-c']
1580
hidden = True
1581
1582
def run(self, context=None):
1583
import shellcomplete
1584
shellcomplete.shellcomplete(context)
1585
1586
1587
class cmd_missing(Command):
1588
"""What is missing in this branch relative to other branch.
1589
"""
1590
takes_args = ['remote?']
1591
aliases = ['mis', 'miss']
1592
# We don't have to add quiet to the list, because
1593
# unknown options are parsed as booleans
1594
takes_options = ['verbose', 'quiet']
1595
1596
def run(self, remote=None, verbose=False, quiet=False):
1597
from bzrlib.branch import find_branch, DivergedBranches
1598
from bzrlib.errors import BzrCommandError
1599
from bzrlib.missing import get_parent, show_missing
1600
1601
if verbose and quiet:
1602
raise BzrCommandError('Cannot pass both quiet and verbose')
1603
1604
b = find_branch('.')
1605
parent = get_parent(b)
1606
if remote is None:
1607
if parent is None:
1608
raise BzrCommandError("No missing location known or specified.")
1609
else:
1610
if not quiet:
1611
print "Using last location: %s" % parent
1612
remote = parent
1613
elif parent is None:
1614
# We only update x-pull if it did not exist, missing should not change the parent
1615
b.controlfile('x-pull', 'wb').write(remote + '\n')
1616
br_remote = find_branch(remote)
1617
1618
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1619
1620
1621
1622
class cmd_plugins(Command):
1623
"""List plugins"""
1624
hidden = True
1625
def run(self):
1626
import bzrlib.plugin
1627
from inspect import getdoc
1628
from pprint import pprint
1629
for plugin in bzrlib.plugin.all_plugins:
1630
print plugin.__path__[0]
1631
d = getdoc(plugin)
1632
if d:
1633
print '\t', d.split('\n')[0]
1634
1635
#pprint(bzrlib.plugin.all_plugins)
1636
1637
1638
361
1639
362
# list of all available options; the rhs can be either None for an
1640
363
# option that takes no argument, or a constructor function that checks
1686
409
1687
410
>>> parse_args('--help'.split())
1688
411
([], {'help': True})
412
>>> parse_args('help -- --invalidcmd'.split())
413
(['help', '--invalidcmd'], {})
1689
414
>>> parse_args('--version'.split())
1690
415
([], {'version': True})
1691
416
>>> parse_args('status --all'.split())
1704
429
args = []
1705
430
opts = {}
1706
431
1707
# TODO: Maybe handle '--' to end options?
1708
432
argsover = False
1709
433
while argv:
1710
434
a = argv.pop(0)
1711
if a[0] == '-':
435
if not argsover and a[0] == '-':
1712
436
# option names must not be unicode
1713
437
a = str(a)
1714
438
optarg = None
1715
439
if a[1] == '-':
440
if a == '--':
441
# We've received a standalone -- No more flags
442
argsover = True
443
continue
1716
444
mutter(" got option %r" % a)
1717
445
if '=' in a:
1718
446
optname, optarg = a[2:].split('=', 1)
1820
548
1821
549
1822
550
551
def apply_profiled(the_callable, *args, **kwargs):
552
import hotshot
553
import tempfile
554
pffileno, pfname = tempfile.mkstemp()
555
try:
556
prof = hotshot.Profile(pfname)
557
try:
558
ret = prof.runcall(the_callable, *args, **kwargs) or 0
559
finally:
560
prof.close()
561
562
import hotshot.stats
563
stats = hotshot.stats.load(pfname)
564
#stats.strip_dirs()
565
stats.sort_stats('time')
566
## XXX: Might like to write to stderr or the trace file instead but
567
## print_stats seems hardcoded to stdout
568
stats.print_stats(20)
569
570
return ret
571
finally:
572
os.close(pffileno)
573
os.remove(pfname)
574
575
1823
576
def run_bzr(argv):
1824
577
"""Execute a command.
1825
578
1853
606
# to load plugins before doing other command parsing so that they
1854
607
# can override commands, but this needs to happen first.
1855
608
1856
for a in argv[:]:
609
for a in argv:
1857
610
if a == '--profile':
1858
611
opt_profile = True
1859
612
elif a == '--no-plugins':
1864
617
break
1865
618
argv.remove(a)
1866
619
620
if (not argv) or (argv[0] == '--help'):
621
from bzrlib.help import help
622
if len(argv) > 1:
623
help(argv[1])
624
else:
625
help()
626
return 0
627
628
if argv[0] == '--version':
629
from bzrlib.builtins import show_version
630
show_version()
631
return 0
632
1867
633
if not opt_no_plugins:
1868
634
from bzrlib.plugin import load_plugins
1869
635
load_plugins()
1870
636
1871
args, opts = parse_args(argv)
1872
1873
if 'help' in opts:
1874
from bzrlib.help import help
1875
if args:
1876
help(args[0])
1877
else:
1878
help()
1879
return 0
1880
1881
if 'version' in opts:
1882
show_version()
1883
return 0
1884
1885
if not args:
1886
from bzrlib.help import help
1887
help(None)
1888
return 0
1889
1890
cmd = str(args.pop(0))
1891
1892
canonical_cmd, cmd_class = \
1893
get_cmd_class(cmd, plugins_override=not opt_builtin)
1894
1895
# check options are reasonable
1896
allowed = cmd_class.takes_options
1897
for oname in opts:
1898
if oname not in allowed:
1899
raise BzrCommandError("option '--%s' is not allowed for command %r"
1900
% (oname, cmd))
1901
1902
# mix arguments and options into one dictionary
1903
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1904
cmdopts = {}
1905
for k, v in opts.items():
1906
cmdopts[k.replace('-', '_')] = v
637
cmd = str(argv.pop(0))
638
639
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1907
640
1908
641
if opt_profile:
1909
import hotshot, tempfile
1910
pffileno, pfname = tempfile.mkstemp()
1911
try:
1912
prof = hotshot.Profile(pfname)
1913
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1914
prof.close()
1915
1916
import hotshot.stats
1917
stats = hotshot.stats.load(pfname)
1918
#stats.strip_dirs()
1919
stats.sort_stats('time')
1920
## XXX: Might like to write to stderr or the trace file instead but
1921
## print_stats seems hardcoded to stdout
1922
stats.print_stats(20)
1923
1924
return ret.status
1925
1926
finally:
1927
os.close(pffileno)
1928
os.remove(pfname)
642
ret = apply_profiled(cmd_obj.run_argv, argv)
1929
643
else:
1930
return cmd_class(cmdopts, cmdargs).status
644
ret = cmd_obj.run_argv(argv)
645
return ret or 0
1931
646
1932
647
1933
648
def main(argv):
1934
649
import bzrlib.ui
1935
1936
bzrlib.trace.open_tracefile(argv)
1937
650
bzrlib.trace.log_startup(argv)
1938
651
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1939
652
1940
653
try:
Loggerhead is a web-based interface for Breezy
Version: 2.0.1