« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 690
- compare with another revision
- download diff
- download tarball
- view history from revision 690
- Committer: Martin Pool
- Date: 2005-06-15 04:24:01 UTC
- Revision ID: mbp@sourcefrog.net-20050615042401-02a29d106bece661
add-bzr-to-baz allows multiple arguments
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/selftest/whitebox.py => bzrlib/whitebox.py
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
# TODO: Split the command framework away from the actual commands.
19
20
# TODO: probably should say which arguments are candidates for glob
21
# expansion on windows and do that at the command level.
22
23
import sys
24
import os
18
19
import sys, os
25
20
26
21
import bzrlib
27
from bzrlib.trace import mutter, note, log_error, warning
28
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
29
from bzrlib.branch import find_branch
30
from bzrlib import BZRDIR
31
32
33
plugin_cmds = {}
34
35
36
def register_command(cmd):
37
"Utility function to help register a command"
38
global plugin_cmds
39
k = cmd.__name__
40
if k.startswith("cmd_"):
41
k_unsquished = _unsquish_command_name(k)
42
else:
43
k_unsquished = k
44
if not plugin_cmds.has_key(k_unsquished):
45
plugin_cmds[k_unsquished] = cmd
46
else:
47
log_error('Two plugins defined the same command: %r' % k)
48
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
22
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
26
format_date
49
27
50
28
51
29
def _squish_command_name(cmd):
56
34
assert cmd.startswith("cmd_")
57
35
return cmd[4:].replace('_','-')
58
36
59
60
37
def _parse_revision_str(revstr):
61
"""This handles a revision string -> revno.
62
63
This always returns a list. The list will have one element for
64
65
It supports integers directly, but everything else it
66
defers for passing to Branch.get_revision_info()
67
68
>>> _parse_revision_str('234')
69
[234]
70
>>> _parse_revision_str('234..567')
71
[234, 567]
72
>>> _parse_revision_str('..')
73
[None, None]
74
>>> _parse_revision_str('..234')
75
[None, 234]
76
>>> _parse_revision_str('234..')
77
[234, None]
78
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
79
[234, 456, 789]
80
>>> _parse_revision_str('234....789') # Error?
81
[234, None, 789]
82
>>> _parse_revision_str('revid:test@other.com-234234')
83
['revid:test@other.com-234234']
84
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
85
['revid:test@other.com-234234', 'revid:test@other.com-234235']
86
>>> _parse_revision_str('revid:test@other.com-234234..23')
87
['revid:test@other.com-234234', 23]
88
>>> _parse_revision_str('date:2005-04-12')
89
['date:2005-04-12']
90
>>> _parse_revision_str('date:2005-04-12 12:24:33')
91
['date:2005-04-12 12:24:33']
92
>>> _parse_revision_str('date:2005-04-12T12:24:33')
93
['date:2005-04-12T12:24:33']
94
>>> _parse_revision_str('date:2005-04-12,12:24:33')
95
['date:2005-04-12,12:24:33']
96
>>> _parse_revision_str('-5..23')
97
[-5, 23]
98
>>> _parse_revision_str('-5')
99
[-5]
100
>>> _parse_revision_str('123a')
101
['123a']
102
>>> _parse_revision_str('abc')
103
['abc']
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
104
52
"""
105
import re
106
old_format_re = re.compile('\d*:\d*')
107
m = old_format_re.match(revstr)
108
if m:
109
warning('Colon separator for revision numbers is deprecated.'
110
' Use .. instead')
111
revs = []
112
for rev in revstr.split(':'):
113
if rev:
114
revs.append(int(rev))
115
else:
116
revs.append(None)
117
return revs
118
revs = []
119
for x in revstr.split('..'):
120
if not x:
121
revs.append(None)
122
else:
123
try:
124
revs.append(int(x))
125
except ValueError:
126
revs.append(x)
53
if revstr.find(':') != -1:
54
revs = revstr.split(':')
55
if len(revs) > 2:
56
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
57
58
if not revs[0]:
59
revs[0] = None
60
else:
61
revs[0] = int(revs[0])
62
63
if not revs[1]:
64
revs[1] = None
65
else:
66
revs[1] = int(revs[1])
67
else:
68
revs = int(revstr)
127
69
return revs
128
70
129
130
def get_merge_type(typestring):
131
"""Attempt to find the merge class/factory associated with a string."""
132
from merge import merge_types
133
try:
134
return merge_types[typestring][0]
135
except KeyError:
136
templ = '%s%%7s: %%s' % (' '*12)
137
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
138
type_list = '\n'.join(lines)
139
msg = "No known merge type %s. Supported types are:\n%s" %\
140
(typestring, type_list)
141
raise BzrCommandError(msg)
142
143
144
def get_merge_type(typestring):
145
"""Attempt to find the merge class/factory associated with a string."""
146
from merge import merge_types
147
try:
148
return merge_types[typestring][0]
149
except KeyError:
150
templ = '%s%%7s: %%s' % (' '*12)
151
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
152
type_list = '\n'.join(lines)
153
msg = "No known merge type %s. Supported types are:\n%s" %\
154
(typestring, type_list)
155
raise BzrCommandError(msg)
156
157
158
159
def _get_cmd_dict(plugins_override=True):
71
def _find_plugins():
72
"""Find all python files which are plugins, and load their commands
73
to add to the list of "all commands"
74
75
The environment variable BZRPATH is considered a delimited set of
76
paths to look through. Each entry is searched for *.py files.
77
If a directory is found, it is also searched, but they are
78
not searched recursively. This allows you to revctl the plugins.
79
80
Inside the plugin should be a series of cmd_* function, which inherit from
81
the bzrlib.commands.Command class.
82
"""
83
bzrpath = os.environ.get('BZRPLUGINPATH', '')
84
85
plugin_cmds = {}
86
if not bzrpath:
87
return plugin_cmds
88
_platform_extensions = {
89
'win32':'.pyd',
90
'cygwin':'.dll',
91
'darwin':'.dylib',
92
'linux2':'.so'
93
}
94
if _platform_extensions.has_key(sys.platform):
95
platform_extension = _platform_extensions[sys.platform]
96
else:
97
platform_extension = None
98
for d in bzrpath.split(os.pathsep):
99
plugin_names = {} # This should really be a set rather than a dict
100
for f in os.listdir(d):
101
if f.endswith('.py'):
102
f = f[:-3]
103
elif f.endswith('.pyc') or f.endswith('.pyo'):
104
f = f[:-4]
105
elif platform_extension and f.endswith(platform_extension):
106
f = f[:-len(platform_extension)]
107
if f.endswidth('module'):
108
f = f[:-len('module')]
109
else:
110
continue
111
if not plugin_names.has_key(f):
112
plugin_names[f] = True
113
114
plugin_names = plugin_names.keys()
115
plugin_names.sort()
116
try:
117
sys.path.insert(0, d)
118
for name in plugin_names:
119
try:
120
old_module = None
121
try:
122
if sys.modules.has_key(name):
123
old_module = sys.modules[name]
124
del sys.modules[name]
125
plugin = __import__(name, locals())
126
for k in dir(plugin):
127
if k.startswith('cmd_'):
128
k_unsquished = _unsquish_command_name(k)
129
if not plugin_cmds.has_key(k_unsquished):
130
plugin_cmds[k_unsquished] = getattr(plugin, k)
131
else:
132
log_error('Two plugins defined the same command: %r' % k)
133
log_error('Not loading the one in %r in dir %r' % (name, d))
134
finally:
135
if old_module:
136
sys.modules[name] = old_module
137
except ImportError, e:
138
log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))
139
finally:
140
sys.path.pop(0)
141
return plugin_cmds
142
143
def _get_cmd_dict(include_plugins=True):
160
144
d = {}
161
145
for k, v in globals().iteritems():
162
146
if k.startswith("cmd_"):
163
147
d[_unsquish_command_name(k)] = v
164
# If we didn't load plugins, the plugin_cmds dict will be empty
165
if plugins_override:
166
d.update(plugin_cmds)
167
else:
168
d2 = plugin_cmds.copy()
169
d2.update(d)
170
d = d2
148
if include_plugins:
149
d.update(_find_plugins())
171
150
return d
172
173
151
174
def get_all_cmds(plugins_override=True):
152
def get_all_cmds(include_plugins=True):
175
153
"""Return canonical name and class for all registered commands."""
176
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
154
for k, v in _get_cmd_dict(include_plugins=include_plugins).iteritems():
177
155
yield k,v
178
156
179
157
180
def get_cmd_class(cmd, plugins_override=True):
158
def get_cmd_class(cmd,include_plugins=True):
181
159
"""Return the canonical name and command class for a command.
182
160
"""
183
161
cmd = str(cmd) # not unicode
184
162
185
163
# first look up this command under the specified name
186
cmds = _get_cmd_dict(plugins_override=plugins_override)
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
187
165
try:
188
166
return cmd, cmds[cmd]
189
167
except KeyError:
233
211
assert isinstance(arguments, dict)
234
212
cmdargs = options.copy()
235
213
cmdargs.update(arguments)
236
if self.__doc__ == Command.__doc__:
237
from warnings import warn
238
warn("No help message set for %r" % self)
214
assert self.__doc__ != Command.__doc__, \
215
("No help message set for %r" % self)
239
216
self.status = self.run(**cmdargs)
240
if self.status is None:
241
self.status = 0
242
217
243
218
244
219
def run(self):
256
231
class ExternalCommand(Command):
257
232
"""Class to wrap external commands.
258
233
259
We cheat a little here, when get_cmd_class() calls us we actually
260
give it back an object we construct that has the appropriate path,
261
help, options etc for the specified command.
262
263
When run_bzr() tries to instantiate that 'class' it gets caught by
264
the __call__ method, which we override to call the Command.__init__
265
method. That then calls our run method which is pretty straight
266
forward.
267
268
The only wrinkle is that we have to map bzr's dictionary of options
269
and arguments back into command line options and arguments for the
270
script.
234
We cheat a little here, when get_cmd_class() calls us we actually give it back
235
an object we construct that has the appropriate path, help, options etc for the
236
specified command.
237
238
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
239
method, which we override to call the Command.__init__ method. That then calls
240
our run method which is pretty straight forward.
241
242
The only wrinkle is that we have to map bzr's dictionary of options and arguments
243
back into command line options and arguments for the script.
271
244
"""
272
245
273
246
def find_command(cls, cmd):
291
264
292
265
for opt in self.takes_options:
293
266
if not opt in OPTIONS:
294
raise BzrError("Unknown option '%s' returned by external command %s"
295
% (opt, path))
267
bailout("Unknown option '%s' returned by external command %s"
268
% (opt, path))
296
269
297
270
# TODO: Is there any way to check takes_args is valid here?
298
271
self.takes_args = pipe.readline().split()
299
272
300
273
if pipe.close() is not None:
301
raise BzrError("Failed funning '%s --bzr-usage'" % path)
274
bailout("Failed funning '%s --bzr-usage'" % path)
302
275
303
276
pipe = os.popen('%s --bzr-help' % path, 'r')
304
277
self.__doc__ = pipe.read()
305
278
if pipe.close() is not None:
306
raise BzrError("Failed funning '%s --bzr-help'" % path)
279
bailout("Failed funning '%s --bzr-help'" % path)
307
280
308
281
def __call__(self, options, arguments):
309
282
Command.__init__(self, options, arguments)
370
343
directory is shown. Otherwise, only the status of the specified
371
344
files or directories is reported. If a directory is given, status
372
345
is reported for everything inside that directory.
373
374
If a revision is specified, the changes since that revision are shown.
375
346
"""
376
347
takes_args = ['file*']
377
takes_options = ['all', 'show-ids', 'revision']
348
takes_options = ['all', 'show-ids']
378
349
aliases = ['st', 'stat']
379
350
380
351
def run(self, all=False, show_ids=False, file_list=None):
381
352
if file_list:
382
b = find_branch(file_list[0])
353
b = Branch(file_list[0])
383
354
file_list = [b.relpath(x) for x in file_list]
384
355
# special case: only one path was given and it's the root
385
356
# of the branch
386
357
if file_list == ['']:
387
358
file_list = None
388
359
else:
389
b = find_branch('.')
390
391
from bzrlib.status import show_status
392
show_status(b, show_unchanged=all, show_ids=show_ids,
393
specific_files=file_list)
360
b = Branch('.')
361
import status
362
status.show_status(b, show_unchanged=all, show_ids=show_ids,
363
specific_files=file_list)
394
364
395
365
396
366
class cmd_cat_revision(Command):
400
370
takes_args = ['revision_id']
401
371
402
372
def run(self, revision_id):
403
from bzrlib.xml import pack_xml
404
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
373
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
405
374
406
375
407
376
class cmd_revno(Command):
409
378
410
379
This is equal to the number of revisions on this branch."""
411
380
def run(self):
412
print find_branch('.').revno()
413
414
class cmd_revision_info(Command):
415
"""Show revision number and revision id for a given revision identifier.
416
"""
417
hidden = True
418
takes_args = ['revision_info*']
419
takes_options = ['revision']
420
def run(self, revision=None, revision_info_list=None):
421
from bzrlib.branch import find_branch
422
423
revs = []
424
if revision is not None:
425
revs.extend(revision)
426
if revision_info_list is not None:
427
revs.extend(revision_info_list)
428
if len(revs) == 0:
429
raise BzrCommandError('You must supply a revision identifier')
430
431
b = find_branch('.')
432
433
for rev in revs:
434
print '%4d %s' % b.get_revision_info(rev)
381
print Branch('.').revno()
435
382
436
383
437
384
class cmd_add(Command):
447
394
whether already versioned or not, are searched for files or
448
395
subdirectories that are neither versioned or ignored, and these
449
396
are added. This search proceeds recursively into versioned
450
directories. If no names are given '.' is assumed.
397
directories.
451
398
452
Therefore simply saying 'bzr add' will version all files that
399
Therefore simply saying 'bzr add .' will version all files that
453
400
are currently unknown.
454
401
455
402
TODO: Perhaps adding a file whose directly is not versioned should
456
403
recursively add that parent, rather than giving an error?
457
404
"""
458
takes_args = ['file*']
405
takes_args = ['file+']
459
406
takes_options = ['verbose', 'no-recurse']
460
407
461
408
def run(self, file_list, verbose=False, no_recurse=False):
462
from bzrlib.add import smart_add
463
smart_add(file_list, verbose, not no_recurse)
464
465
466
467
class cmd_mkdir(Command):
468
"""Create a new versioned directory.
469
470
This is equivalent to creating the directory and then adding it.
471
"""
472
takes_args = ['dir+']
473
474
def run(self, dir_list):
475
b = None
476
477
for d in dir_list:
478
os.mkdir(d)
479
if not b:
480
b = find_branch(d)
481
b.add([d], verbose=True)
409
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
482
410
483
411
484
412
class cmd_relpath(Command):
487
415
hidden = True
488
416
489
417
def run(self, filename):
490
print find_branch(filename).relpath(filename)
418
print Branch(filename).relpath(filename)
491
419
492
420
493
421
496
424
takes_options = ['revision', 'show-ids']
497
425
498
426
def run(self, revision=None, show_ids=False):
499
b = find_branch('.')
427
b = Branch('.')
500
428
if revision == None:
501
429
inv = b.read_working_inventory()
502
430
else:
503
if len(revision) > 1:
504
raise BzrCommandError('bzr inventory --revision takes'
505
' exactly one revision identifier')
506
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
431
inv = b.get_revision_inventory(b.lookup_revision(revision))
507
432
508
433
for path, entry in inv.entries():
509
434
if show_ids:
522
447
"""
523
448
takes_args = ['source$', 'dest']
524
449
def run(self, source_list, dest):
525
b = find_branch('.')
450
b = Branch('.')
526
451
527
# TODO: glob expansion on windows?
528
452
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
529
453
530
454
545
469
takes_args = ['from_name', 'to_name']
546
470
547
471
def run(self, from_name, to_name):
548
b = find_branch('.')
472
b = Branch('.')
549
473
b.rename_one(b.relpath(from_name), b.relpath(to_name))
550
474
551
475
552
476
553
class cmd_mv(Command):
554
"""Move or rename a file.
555
556
usage:
557
bzr mv OLDNAME NEWNAME
558
bzr mv SOURCE... DESTINATION
559
560
If the last argument is a versioned directory, all the other names
561
are moved into it. Otherwise, there must be exactly two arguments
562
and the file is changed to a new name, which must not already exist.
563
564
Files cannot be moved between branches.
565
"""
566
takes_args = ['names*']
567
def run(self, names_list):
568
if len(names_list) < 2:
569
raise BzrCommandError("missing file argument")
570
b = find_branch(names_list[0])
571
572
rel_names = [b.relpath(x) for x in names_list]
573
574
if os.path.isdir(names_list[-1]):
575
# move into existing directory
576
b.move(rel_names[:-1], rel_names[-1])
577
else:
578
if len(names_list) != 2:
579
raise BzrCommandError('to mv multiple files the destination '
580
'must be a versioned directory')
581
b.move(rel_names[0], rel_names[1])
582
583
584
477
585
478
586
479
class cmd_pull(Command):
601
494
602
495
def run(self, location=None):
603
496
from bzrlib.merge import merge
604
import tempfile
605
from shutil import rmtree
606
497
import errno
607
498
608
br_to = find_branch('.')
499
br_to = Branch('.')
609
500
stored_loc = None
610
501
try:
611
502
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
612
503
except IOError, e:
613
if e.errno != errno.ENOENT:
504
if errno == errno.ENOENT:
614
505
raise
615
506
if location is None:
616
if stored_loc is None:
617
raise BzrCommandError("No pull location known or specified.")
618
else:
619
print "Using last location: %s" % stored_loc
620
location = stored_loc
621
cache_root = tempfile.mkdtemp()
622
from bzrlib.branch import DivergedBranches
507
location = stored_loc
508
if location is None:
509
raise BzrCommandError("No pull location known or specified.")
510
from branch import find_branch, DivergedBranches
623
511
br_from = find_branch(location)
624
512
location = pull_loc(br_from)
625
513
old_revno = br_to.revno()
626
514
try:
627
from branch import find_cached_branch, DivergedBranches
628
br_from = find_cached_branch(location, cache_root)
629
location = pull_loc(br_from)
630
old_revno = br_to.revno()
631
try:
632
br_to.update_revisions(br_from)
633
except DivergedBranches:
634
raise BzrCommandError("These branches have diverged."
635
" Try merge.")
636
637
merge(('.', -1), ('.', old_revno), check_clean=False)
638
if location != stored_loc:
639
br_to.controlfile("x-pull", "wb").write(location + "\n")
640
finally:
641
rmtree(cache_root)
515
br_to.update_revisions(br_from)
516
except DivergedBranches:
517
raise BzrCommandError("These branches have diverged. Try merge.")
518
519
merge(('.', -1), ('.', old_revno), check_clean=False)
520
if location != stored_loc:
521
br_to.controlfile("x-pull", "wb").write(location + "\n")
642
522
643
523
644
524
653
533
"""
654
534
takes_args = ['from_location', 'to_location?']
655
535
takes_options = ['revision']
656
aliases = ['get', 'clone']
657
536
658
537
def run(self, from_location, to_location=None, revision=None):
659
538
import errno
660
539
from bzrlib.merge import merge
661
from bzrlib.branch import DivergedBranches, \
662
find_cached_branch, Branch
540
from branch import find_branch, DivergedBranches, NoSuchRevision
663
541
from shutil import rmtree
664
from meta_store import CachedStore
665
import tempfile
666
cache_root = tempfile.mkdtemp()
667
668
if revision is None:
669
revision = [None]
670
elif len(revision) > 1:
671
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
672
673
try:
674
try:
675
br_from = find_cached_branch(from_location, cache_root)
676
except OSError, e:
677
if e.errno == errno.ENOENT:
678
raise BzrCommandError('Source location "%s" does not'
679
' exist.' % to_location)
680
else:
681
raise
682
683
if to_location is None:
684
to_location = os.path.basename(from_location.rstrip("/\\"))
685
686
try:
687
os.mkdir(to_location)
688
except OSError, e:
689
if e.errno == errno.EEXIST:
690
raise BzrCommandError('Target directory "%s" already'
691
' exists.' % to_location)
692
if e.errno == errno.ENOENT:
693
raise BzrCommandError('Parent of "%s" does not exist.' %
694
to_location)
695
else:
696
raise
697
br_to = Branch(to_location, init=True)
698
699
br_to.set_root_id(br_from.get_root_id())
700
701
if revision:
702
if revision[0] is None:
703
revno = br_from.revno()
704
else:
705
revno, rev_id = br_from.get_revision_info(revision[0])
706
try:
707
br_to.update_revisions(br_from, stop_revision=revno)
708
except bzrlib.errors.NoSuchRevision:
709
rmtree(to_location)
710
msg = "The branch %s has no revision %d." % (from_location,
711
revno)
712
raise BzrCommandError(msg)
713
714
merge((to_location, -1), (to_location, 0), this_dir=to_location,
715
check_clean=False, ignore_zero=True)
716
from_location = pull_loc(br_from)
717
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
718
finally:
719
rmtree(cache_root)
542
try:
543
br_from = find_branch(from_location)
544
except OSError, e:
545
if e.errno == errno.ENOENT:
546
raise BzrCommandError('Source location "%s" does not exist.' %
547
to_location)
548
else:
549
raise
550
551
if to_location is None:
552
to_location = os.path.basename(from_location.rstrip("/\\"))
553
554
try:
555
os.mkdir(to_location)
556
except OSError, e:
557
if e.errno == errno.EEXIST:
558
raise BzrCommandError('Target directory "%s" already exists.' %
559
to_location)
560
if e.errno == errno.ENOENT:
561
raise BzrCommandError('Parent of "%s" does not exist.' %
562
to_location)
563
else:
564
raise
565
br_to = Branch(to_location, init=True)
566
567
try:
568
br_to.update_revisions(br_from, stop_revision=revision)
569
except NoSuchRevision:
570
rmtree(to_location)
571
msg = "The branch %s has no revision %d." % (from_location,
572
revision)
573
raise BzrCommandError(msg)
574
merge((to_location, -1), (to_location, 0), this_dir=to_location,
575
check_clean=False)
576
from_location = pull_loc(br_from)
577
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
720
578
721
579
722
580
def pull_loc(branch):
739
597
takes_args = ['dir?']
740
598
741
599
def run(self, dir='.'):
742
b = find_branch(dir)
600
b = Branch(dir)
743
601
old_inv = b.basis_tree().inventory
744
602
new_inv = b.read_working_inventory()
745
603
756
614
def run(self, branch=None):
757
615
import info
758
616
617
from branch import find_branch
759
618
b = find_branch(branch)
760
619
info.show_info(b)
761
620
770
629
takes_options = ['verbose']
771
630
772
631
def run(self, file_list, verbose=False):
773
b = find_branch(file_list[0])
632
b = Branch(file_list[0])
774
633
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
775
634
776
635
784
643
hidden = True
785
644
takes_args = ['filename']
786
645
def run(self, filename):
787
b = find_branch(filename)
646
b = Branch(filename)
788
647
i = b.inventory.path2id(b.relpath(filename))
789
648
if i == None:
790
raise BzrError("%r is not a versioned file" % filename)
649
bailout("%r is not a versioned file" % filename)
791
650
else:
792
651
print i
793
652
800
659
hidden = True
801
660
takes_args = ['filename']
802
661
def run(self, filename):
803
b = find_branch(filename)
662
b = Branch(filename)
804
663
inv = b.inventory
805
664
fid = inv.path2id(b.relpath(filename))
806
665
if fid == None:
807
raise BzrError("%r is not a versioned file" % filename)
666
bailout("%r is not a versioned file" % filename)
808
667
for fip in inv.get_idpath(fid):
809
668
print fip
810
669
813
672
"""Display list of revision ids on this branch."""
814
673
hidden = True
815
674
def run(self):
816
for patchid in find_branch('.').revision_history():
675
for patchid in Branch('.').revision_history():
817
676
print patchid
818
677
819
678
820
679
class cmd_directories(Command):
821
680
"""Display list of versioned directories in this branch."""
822
681
def run(self):
823
for name, ie in find_branch('.').read_working_inventory().directories():
682
for name, ie in Branch('.').read_working_inventory().directories():
824
683
if name == '':
825
684
print '.'
826
685
else:
841
700
bzr commit -m 'imported project'
842
701
"""
843
702
def run(self):
844
from bzrlib.branch import Branch
845
703
Branch('.', init=True)
846
704
847
705
851
709
If files are listed, only the changes in those files are listed.
852
710
Otherwise, all changes for the tree are listed.
853
711
712
TODO: Given two revision arguments, show the difference between them.
713
854
714
TODO: Allow diff across branches.
855
715
856
716
TODO: Option to use external diff command; could be GNU diff, wdiff,
865
725
deleted files.
866
726
867
727
TODO: This probably handles non-Unix newlines poorly.
868
869
examples:
870
bzr diff
871
bzr diff -r1
872
bzr diff -r1:2
873
728
"""
874
729
875
730
takes_args = ['file*']
878
733
879
734
def run(self, revision=None, file_list=None, diff_options=None):
880
735
from bzrlib.diff import show_diff
736
from bzrlib import find_branch
881
737
882
738
if file_list:
883
739
b = find_branch(file_list[0])
886
742
# just pointing to top-of-tree
887
743
file_list = None
888
744
else:
889
b = find_branch('.')
745
b = Branch('.')
746
747
show_diff(b, revision, specific_files=file_list,
748
external_diff_options=diff_options)
890
749
891
if revision is not None:
892
if len(revision) == 1:
893
show_diff(b, revision[0], specific_files=file_list,
894
external_diff_options=diff_options)
895
elif len(revision) == 2:
896
show_diff(b, revision[0], specific_files=file_list,
897
external_diff_options=diff_options,
898
revision2=revision[1])
899
else:
900
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
901
else:
902
show_diff(b, None, specific_files=file_list,
903
external_diff_options=diff_options)
904
750
905
751
906
752
911
757
TODO: Show files deleted since a previous revision, or between two revisions.
912
758
"""
913
759
def run(self, show_ids=False):
914
b = find_branch('.')
760
b = Branch('.')
915
761
old = b.basis_tree()
916
762
new = b.working_tree()
917
763
932
778
"""List files modified in working tree."""
933
779
hidden = True
934
780
def run(self):
935
from bzrlib.delta import compare_trees
936
937
b = find_branch('.')
938
td = compare_trees(b.basis_tree(), b.working_tree())
939
940
for path, id, kind in td.modified:
941
print path
781
import statcache
782
b = Branch('.')
783
inv = b.read_working_inventory()
784
sc = statcache.update_cache(b, inv)
785
basis = b.basis_tree()
786
basis_inv = basis.inventory
787
788
# We used to do this through iter_entries(), but that's slow
789
# when most of the files are unmodified, as is usually the
790
# case. So instead we iterate by inventory entry, and only
791
# calculate paths as necessary.
792
793
for file_id in basis_inv:
794
cacheentry = sc.get(file_id)
795
if not cacheentry: # deleted
796
continue
797
ie = basis_inv[file_id]
798
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
799
path = inv.id2path(file_id)
800
print path
942
801
943
802
944
803
946
805
"""List files added in working tree."""
947
806
hidden = True
948
807
def run(self):
949
b = find_branch('.')
808
b = Branch('.')
950
809
wt = b.working_tree()
951
810
basis_inv = b.basis_tree().inventory
952
811
inv = wt.inventory
968
827
takes_args = ['filename?']
969
828
def run(self, filename=None):
970
829
"""Print the branch root."""
830
from branch import find_branch
971
831
b = find_branch(filename)
972
832
print getattr(b, 'base', None) or getattr(b, 'baseurl')
973
833
979
839
-r revision requests a specific revision, -r :end or -r begin: are
980
840
also valid.
981
841
982
--message allows you to give a regular expression, which will be evaluated
983
so that only matching entries will be displayed.
984
985
842
TODO: Make --revision support uuid: and hash: [future tag:] notation.
986
843
987
844
"""
988
845
989
846
takes_args = ['filename?']
990
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
991
'long', 'message', 'short',]
847
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
992
848
993
849
def run(self, filename=None, timezone='original',
994
850
verbose=False,
995
851
show_ids=False,
996
852
forward=False,
997
revision=None,
998
message=None,
999
long=False,
1000
short=False):
1001
from bzrlib.branch import find_branch
1002
from bzrlib.log import log_formatter, show_log
853
revision=None):
854
from bzrlib import show_log, find_branch
1003
855
import codecs
1004
856
1005
857
direction = (forward and 'forward') or 'reverse'
1015
867
b = find_branch('.')
1016
868
file_id = None
1017
869
1018
if revision is None:
1019
rev1 = None
1020
rev2 = None
1021
elif len(revision) == 1:
1022
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1023
elif len(revision) == 2:
1024
rev1 = b.get_revision_info(revision[0])[0]
1025
rev2 = b.get_revision_info(revision[1])[0]
870
if revision == None:
871
revision = [None, None]
872
elif isinstance(revision, int):
873
revision = [revision, revision]
1026
874
else:
1027
raise BzrCommandError('bzr log --revision takes one or two values.')
1028
1029
if rev1 == 0:
1030
rev1 = None
1031
if rev2 == 0:
1032
rev2 = None
875
# pair of revisions?
876
pass
877
878
assert len(revision) == 2
1033
879
1034
880
mutter('encoding log as %r' % bzrlib.user_encoding)
1035
881
1037
883
# in e.g. the default C locale.
1038
884
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1039
885
1040
if not short:
1041
log_format = 'long'
1042
else:
1043
log_format = 'short'
1044
lf = log_formatter(log_format,
1045
show_ids=show_ids,
1046
to_file=outf,
1047
show_timezone=timezone)
1048
1049
show_log(b,
1050
lf,
1051
file_id,
886
show_log(b, file_id,
887
show_timezone=timezone,
1052
888
verbose=verbose,
889
show_ids=show_ids,
890
to_file=outf,
1053
891
direction=direction,
1054
start_revision=rev1,
1055
end_revision=rev2,
1056
search=message)
892
start_revision=revision[0],
893
end_revision=revision[1])
1057
894
1058
895
1059
896
1064
901
hidden = True
1065
902
takes_args = ["filename"]
1066
903
def run(self, filename):
1067
b = find_branch(filename)
904
b = Branch(filename)
1068
905
inv = b.read_working_inventory()
1069
906
file_id = inv.path2id(b.relpath(filename))
1070
907
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1078
915
"""
1079
916
hidden = True
1080
917
def run(self, revision=None, verbose=False):
1081
b = find_branch('.')
918
b = Branch('.')
1082
919
if revision == None:
1083
920
tree = b.working_tree()
1084
921
else:
1102
939
class cmd_unknowns(Command):
1103
940
"""List unknown files."""
1104
941
def run(self):
1105
from bzrlib.osutils import quotefn
1106
for f in find_branch('.').unknowns():
942
for f in Branch('.').unknowns():
1107
943
print quotefn(f)
1108
944
1109
945
1131
967
from bzrlib.atomicfile import AtomicFile
1132
968
import os.path
1133
969
1134
b = find_branch('.')
970
b = Branch('.')
1135
971
ifn = b.abspath('.bzrignore')
1136
972
1137
973
if os.path.exists(ifn):
1171
1007
1172
1008
See also: bzr ignore"""
1173
1009
def run(self):
1174
tree = find_branch('.').working_tree()
1010
tree = Branch('.').working_tree()
1175
1011
for path, file_class, kind, file_id in tree.list_files():
1176
1012
if file_class != 'I':
1177
1013
continue
1195
1031
except ValueError:
1196
1032
raise BzrCommandError("not a valid revision-number: %r" % revno)
1197
1033
1198
print find_branch('.').lookup_revision(revno)
1034
print Branch('.').lookup_revision(revno)
1199
1035
1200
1036
1201
1037
class cmd_export(Command):
1204
1040
If no revision is specified this exports the last committed revision.
1205
1041
1206
1042
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1207
given, try to find the format with the extension. If no extension
1208
is found exports to a directory (equivalent to --format=dir).
1209
1210
Root may be the top directory for tar, tgz and tbz2 formats. If none
1211
is given, the top directory will be the root name of the file."""
1043
given, exports to a directory (equivalent to --format=dir)."""
1212
1044
# TODO: list known exporters
1213
1045
takes_args = ['dest']
1214
takes_options = ['revision', 'format', 'root']
1215
def run(self, dest, revision=None, format=None, root=None):
1216
import os.path
1217
b = find_branch('.')
1218
if revision is None:
1219
rev_id = b.last_patch()
1046
takes_options = ['revision', 'format']
1047
def run(self, dest, revision=None, format='dir'):
1048
b = Branch('.')
1049
if revision == None:
1050
rh = b.revision_history()[-1]
1220
1051
else:
1221
if len(revision) != 1:
1222
raise BzrError('bzr export --revision takes exactly 1 argument')
1223
revno, rev_id = b.get_revision_info(revision[0])
1224
t = b.revision_tree(rev_id)
1225
root, ext = os.path.splitext(dest)
1226
if not format:
1227
if ext in (".tar",):
1228
format = "tar"
1229
elif ext in (".gz", ".tgz"):
1230
format = "tgz"
1231
elif ext in (".bz2", ".tbz2"):
1232
format = "tbz2"
1233
else:
1234
format = "dir"
1235
t.export(dest, format, root)
1052
rh = b.lookup_revision(int(revision))
1053
t = b.revision_tree(rh)
1054
t.export(dest, format)
1236
1055
1237
1056
1238
1057
class cmd_cat(Command):
1244
1063
def run(self, filename, revision=None):
1245
1064
if revision == None:
1246
1065
raise BzrCommandError("bzr cat requires a revision number")
1247
elif len(revision) != 1:
1248
raise BzrCommandError("bzr cat --revision takes exactly one number")
1249
b = find_branch('.')
1250
b.print_file(b.relpath(filename), revision[0])
1066
b = Branch('.')
1067
b.print_file(b.relpath(filename), int(revision))
1251
1068
1252
1069
1253
1070
class cmd_local_time_offset(Command):
1260
1077
1261
1078
class cmd_commit(Command):
1262
1079
"""Commit changes into a new revision.
1263
1264
If no arguments are given, the entire tree is committed.
1265
1080
1266
1081
If selected files are specified, only changes to those files are
1267
committed. If a directory is specified then the directory and everything
1268
within it is committed.
1082
committed. If a directory is specified then its contents are also
1083
committed.
1269
1084
1270
1085
A selected-file commit may fail in some cases where the committed
1271
1086
tree would be invalid, such as trying to commit a file in a
1276
1091
TODO: Strict commit that fails if there are unknown or deleted files.
1277
1092
"""
1278
1093
takes_args = ['selected*']
1279
takes_options = ['message', 'file', 'verbose', 'unchanged']
1094
takes_options = ['message', 'file', 'verbose']
1280
1095
aliases = ['ci', 'checkin']
1281
1096
1282
# TODO: Give better message for -s, --summary, used by tla people
1283
1284
def run(self, message=None, file=None, verbose=True, selected_list=None,
1285
unchanged=False):
1286
from bzrlib.errors import PointlessCommit
1287
from bzrlib.osutils import get_text_message
1097
def run(self, message=None, file=None, verbose=True, selected_list=None):
1098
from bzrlib.commit import commit
1288
1099
1289
1100
## Warning: shadows builtin file()
1290
1101
if not message and not file:
1291
# FIXME: Ugly; change status code to send to a provided function?
1292
1293
import cStringIO
1294
stdout = sys.stdout
1295
catcher = cStringIO.StringIO()
1296
sys.stdout = catcher
1297
cmd_status({"file_list":selected_list}, {})
1298
info = catcher.getvalue()
1299
sys.stdout = stdout
1300
message = get_text_message(info)
1301
1302
if message is None:
1303
raise BzrCommandError("please specify a commit message",
1304
["use either --message or --file"])
1102
raise BzrCommandError("please specify a commit message",
1103
["use either --message or --file"])
1305
1104
elif message and file:
1306
1105
raise BzrCommandError("please specify either --message or --file")
1307
1106
1309
1108
import codecs
1310
1109
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1311
1110
1312
b = find_branch('.')
1313
if selected_list:
1314
selected_list = [b.relpath(s) for s in selected_list]
1315
1316
try:
1317
b.commit(message, verbose=verbose,
1318
specific_files=selected_list,
1319
allow_pointless=unchanged)
1320
except PointlessCommit:
1321
# FIXME: This should really happen before the file is read in;
1322
# perhaps prepare the commit; get the message; then actually commit
1323
raise BzrCommandError("no changes to commit",
1324
["use --unchanged to commit anyhow"])
1111
b = Branch('.')
1112
commit(b, message, verbose=verbose, specific_files=selected_list)
1325
1113
1326
1114
1327
1115
class cmd_check(Command):
1334
1122
to help ensure data consistency.
1335
1123
"""
1336
1124
takes_args = ['dir?']
1337
1338
def run(self, dir='.'):
1339
from bzrlib.check import check
1340
check(find_branch(dir))
1341
1342
1343
1344
class cmd_scan_cache(Command):
1345
hidden = True
1346
def run(self):
1347
from bzrlib.hashcache import HashCache
1348
import os
1349
1350
c = HashCache('.')
1351
c.read()
1352
c.scan()
1353
1354
print '%6d stats' % c.stat_count
1355
print '%6d in hashcache' % len(c._cache)
1356
print '%6d files removed from cache' % c.removed_count
1357
print '%6d hashes updated' % c.update_count
1358
print '%6d files changed too recently to cache' % c.danger_count
1359
1360
if c.needs_write:
1361
c.write()
1362
1363
1364
1365
class cmd_upgrade(Command):
1366
"""Upgrade branch storage to current format.
1367
1368
This should normally be used only after the check command tells
1369
you to run it.
1370
"""
1371
takes_args = ['dir?']
1372
1373
def run(self, dir='.'):
1374
from bzrlib.upgrade import upgrade
1375
upgrade(find_branch(dir))
1125
takes_options = ['update']
1126
1127
def run(self, dir='.', update=False):
1128
import bzrlib.check
1129
bzrlib.check.check(Branch(dir), update=update)
1376
1130
1377
1131
1378
1132
1381
1135
takes_options = ['email']
1382
1136
1383
1137
def run(self, email=False):
1384
try:
1385
b = bzrlib.branch.find_branch('.')
1386
except:
1387
b = None
1388
1389
1138
if email:
1390
print bzrlib.osutils.user_email(b)
1139
print bzrlib.osutils.user_email()
1391
1140
else:
1392
print bzrlib.osutils.username(b)
1141
print bzrlib.osutils.username()
1393
1142
1394
1143
1395
1144
class cmd_selftest(Command):
1396
1145
"""Run internal test suite"""
1397
1146
hidden = True
1398
takes_options = ['verbose']
1399
def run(self, verbose=False):
1147
def run(self):
1400
1148
from bzrlib.selftest import selftest
1401
return int(not selftest(verbose=verbose))
1149
if selftest():
1150
return 0
1151
else:
1152
return 1
1153
1402
1154
1403
1155
1404
1156
class cmd_version(Command):
1436
1188
['..', -1]
1437
1189
>>> parse_spec("../f/@35")
1438
1190
['../f', 35]
1439
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1440
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1441
1191
"""
1442
1192
if spec is None:
1443
1193
return [None, None]
1447
1197
if parsed[1] == "":
1448
1198
parsed[1] = -1
1449
1199
else:
1450
try:
1451
parsed[1] = int(parsed[1])
1452
except ValueError:
1453
pass # We can allow stuff like ./@revid:blahblahblah
1454
else:
1455
assert parsed[1] >=0
1200
parsed[1] = int(parsed[1])
1201
assert parsed[1] >=0
1456
1202
else:
1457
1203
parsed = [spec, None]
1458
1204
return parsed
1460
1206
1461
1207
1462
1208
class cmd_merge(Command):
1463
"""Perform a three-way merge.
1464
1465
The branch is the branch you will merge from. By default, it will merge
1466
the latest revision. If you specify a revision, that revision will be
1467
merged. If you specify two revisions, the first will be used as a BASE,
1468
and the second one as OTHER. Revision numbers are always relative to the
1469
specified branch.
1470
1471
Examples:
1472
1473
To merge the latest revision from bzr.dev
1474
bzr merge ../bzr.dev
1475
1476
To merge changes up to and including revision 82 from bzr.dev
1477
bzr merge -r 82 ../bzr.dev
1478
1479
To merge the changes introduced by 82, without previous changes:
1480
bzr merge -r 81..82 ../bzr.dev
1481
1209
"""Perform a three-way merge of trees.
1210
1211
The SPEC parameters are working tree or revision specifiers. Working trees
1212
are specified using standard paths or urls. No component of a directory
1213
path may begin with '@'.
1214
1215
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1216
1217
Revisions are specified using a dirname/@revno pair, where dirname is the
1218
branch directory and revno is the revision within that branch. If no revno
1219
is specified, the latest revision is used.
1220
1221
Revision examples: './@127', 'foo/@', '../@1'
1222
1223
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1224
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1225
as the BASE.
1226
1482
1227
merge refuses to run if there are any uncommitted changes, unless
1483
1228
--force is given.
1484
1229
"""
1485
takes_args = ['branch?']
1486
takes_options = ['revision', 'force', 'merge-type']
1230
takes_args = ['other_spec', 'base_spec?']
1231
takes_options = ['force']
1487
1232
1488
def run(self, branch='.', revision=None, force=False,
1489
merge_type=None):
1233
def run(self, other_spec, base_spec=None, force=False):
1490
1234
from bzrlib.merge import merge
1491
from bzrlib.merge_core import ApplyMerge3
1492
if merge_type is None:
1493
merge_type = ApplyMerge3
1494
1495
if revision is None or len(revision) < 1:
1496
base = (None, None)
1497
other = (branch, -1)
1498
else:
1499
if len(revision) == 1:
1500
other = (branch, revision[0])
1501
base = (None, None)
1502
else:
1503
assert len(revision) == 2
1504
if None in revision:
1505
raise BzrCommandError(
1506
"Merge doesn't permit that revision specifier.")
1507
base = (branch, revision[0])
1508
other = (branch, revision[1])
1509
1510
merge(other, base, check_clean=(not force), merge_type=merge_type)
1235
merge(parse_spec(other_spec), parse_spec(base_spec),
1236
check_clean=(not force))
1511
1237
1512
1238
1513
1239
class cmd_revert(Command):
1514
1240
"""Reverse all changes since the last commit.
1515
1241
1516
Only versioned files are affected. Specify filenames to revert only
1517
those files. By default, any files that are changed will be backed up
1518
first. Backup files have a '~' appended to their name.
1242
Only versioned files are affected.
1243
1244
TODO: Store backups of any files that will be reverted, so
1245
that the revert can be undone.
1519
1246
"""
1520
takes_options = ['revision', 'no-backup']
1521
takes_args = ['file*']
1522
aliases = ['merge-revert']
1247
takes_options = ['revision']
1523
1248
1524
def run(self, revision=None, no_backup=False, file_list=None):
1249
def run(self, revision=-1):
1525
1250
from bzrlib.merge import merge
1526
if file_list is not None:
1527
if len(file_list) == 0:
1528
raise BzrCommandError("No files specified")
1529
if revision is None:
1530
revision = [-1]
1531
elif len(revision) != 1:
1532
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1533
merge(('.', revision[0]), parse_spec('.'),
1251
merge(('.', revision), parse_spec('.'),
1534
1252
check_clean=False,
1535
ignore_zero=True,
1536
backup_files=not no_backup,
1537
file_list=file_list)
1253
ignore_zero=True)
1538
1254
1539
1255
1540
1256
class cmd_assert_fail(Command):
1556
1272
help.help(topic)
1557
1273
1558
1274
1559
class cmd_shell_complete(Command):
1560
"""Show appropriate completions for context.
1561
1562
For a list of all available commands, say 'bzr shell-complete'."""
1563
takes_args = ['context?']
1564
aliases = ['s-c']
1565
hidden = True
1566
1567
def run(self, context=None):
1568
import shellcomplete
1569
shellcomplete.shellcomplete(context)
1570
1571
1572
class cmd_missing(Command):
1573
"""What is missing in this branch relative to other branch.
1574
"""
1575
takes_args = ['remote?']
1576
aliases = ['mis', 'miss']
1577
# We don't have to add quiet to the list, because
1578
# unknown options are parsed as booleans
1579
takes_options = ['verbose', 'quiet']
1580
1581
def run(self, remote=None, verbose=False, quiet=False):
1582
from bzrlib.branch import find_branch, DivergedBranches
1583
from bzrlib.errors import BzrCommandError
1584
from bzrlib.missing import get_parent, show_missing
1585
1586
if verbose and quiet:
1587
raise BzrCommandError('Cannot pass both quiet and verbose')
1588
1589
b = find_branch('.')
1590
parent = get_parent(b)
1591
if remote is None:
1592
if parent is None:
1593
raise BzrCommandError("No missing location known or specified.")
1594
else:
1595
if not quiet:
1596
print "Using last location: %s" % parent
1597
remote = parent
1598
elif parent is None:
1599
# We only update x-pull if it did not exist, missing should not change the parent
1600
b.controlfile('x-pull', 'wb').write(remote + '\n')
1601
br_remote = find_branch(remote)
1602
1603
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1604
1605
1606
class cmd_plugins(Command):
1607
"""List plugins"""
1275
class cmd_update_stat_cache(Command):
1276
"""Update stat-cache mapping inodes to SHA-1 hashes.
1277
1278
For testing only."""
1608
1279
hidden = True
1609
1280
def run(self):
1610
import bzrlib.plugin
1611
from inspect import getdoc
1612
from pprint import pprint
1613
for plugin in bzrlib.plugin.all_plugins:
1614
print plugin.__path__[0]
1615
d = getdoc(plugin)
1616
if d:
1617
print '\t', d.split('\n')[0]
1618
1619
#pprint(bzrlib.plugin.all_plugins)
1281
import statcache
1282
b = Branch('.')
1283
statcache.update_cache(b.base, b.read_working_inventory())
1620
1284
1621
1285
1622
1286
1635
1299
'no-recurse': None,
1636
1300
'profile': None,
1637
1301
'revision': _parse_revision_str,
1638
'short': None,
1639
1302
'show-ids': None,
1640
1303
'timezone': str,
1641
1304
'verbose': None,
1642
1305
'version': None,
1643
1306
'email': None,
1644
'unchanged': None,
1645
1307
'update': None,
1646
'long': None,
1647
'root': str,
1648
'no-backup': None,
1649
'merge-type': get_merge_type,
1650
1308
}
1651
1309
1652
1310
SHORT_OPTIONS = {
1655
1313
'm': 'message',
1656
1314
'r': 'revision',
1657
1315
'v': 'verbose',
1658
'l': 'long',
1659
1316
}
1660
1317
1661
1318
1676
1333
>>> parse_args('commit --message=biter'.split())
1677
1334
(['commit'], {'message': u'biter'})
1678
1335
>>> parse_args('log -r 500'.split())
1679
(['log'], {'revision': [500]})
1680
>>> parse_args('log -r500..600'.split())
1336
(['log'], {'revision': 500})
1337
>>> parse_args('log -r500:600'.split())
1681
1338
(['log'], {'revision': [500, 600]})
1682
>>> parse_args('log -vr500..600'.split())
1339
>>> parse_args('log -vr500:600'.split())
1683
1340
(['log'], {'verbose': True, 'revision': [500, 600]})
1684
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1685
(['log'], {'revision': ['v500', 600]})
1341
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1342
Traceback (most recent call last):
1343
...
1344
ValueError: invalid literal for int(): v500
1686
1345
"""
1687
1346
args = []
1688
1347
opts = {}
1702
1361
else:
1703
1362
optname = a[2:]
1704
1363
if optname not in OPTIONS:
1705
raise BzrError('unknown long option %r' % a)
1364
bailout('unknown long option %r' % a)
1706
1365
else:
1707
1366
shortopt = a[1:]
1708
1367
if shortopt in SHORT_OPTIONS:
1716
1375
if shortopt not in SHORT_OPTIONS:
1717
1376
# We didn't find the multi-character name, and we
1718
1377
# didn't find the single char name
1719
raise BzrError('unknown short option %r' % a)
1378
bailout('unknown short option %r' % a)
1720
1379
optname = SHORT_OPTIONS[shortopt]
1721
1380
1722
1381
if a[2:]:
1736
1395
1737
1396
if optname in opts:
1738
1397
# XXX: Do we ever want to support this, e.g. for -r?
1739
raise BzrError('repeated option %r' % a)
1398
bailout('repeated option %r' % a)
1740
1399
1741
1400
optargfn = OPTIONS[optname]
1742
1401
if optargfn:
1743
1402
if optarg == None:
1744
1403
if not argv:
1745
raise BzrError('option %r needs an argument' % a)
1404
bailout('option %r needs an argument' % a)
1746
1405
else:
1747
1406
optarg = argv.pop(0)
1748
1407
opts[optname] = optargfn(optarg)
1749
1408
else:
1750
1409
if optarg != None:
1751
raise BzrError('option %r takes no argument' % optname)
1410
bailout('option %r takes no argument' % optname)
1752
1411
opts[optname] = True
1753
1412
else:
1754
1413
args.append(a)
1808
1467
1809
1468
This is similar to main(), but without all the trappings for
1810
1469
logging and error handling.
1811
1812
argv
1813
The command-line arguments, without the program name from argv[0]
1814
1815
Returns a command status or raises an exception.
1816
1817
Special master options: these must come before the command because
1818
they control how the command is interpreted.
1819
1820
--no-plugins
1821
Do not load plugin modules at all
1822
1823
--builtin
1824
Only use builtin commands. (Plugins are still allowed to change
1825
other behaviour.)
1826
1827
--profile
1828
Run under the Python profiler.
1829
1470
"""
1830
1831
1471
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1832
1833
opt_profile = opt_no_plugins = opt_builtin = False
1834
1835
# --no-plugins is handled specially at a very early stage. We need
1836
# to load plugins before doing other command parsing so that they
1837
# can override commands, but this needs to happen first.
1838
1839
for a in argv[:]:
1840
if a == '--profile':
1841
opt_profile = True
1842
elif a == '--no-plugins':
1843
opt_no_plugins = True
1844
elif a == '--builtin':
1845
opt_builtin = True
1846
else:
1847
break
1848
argv.remove(a)
1849
1850
if not opt_no_plugins:
1851
from bzrlib.plugin import load_plugins
1852
load_plugins()
1853
1854
args, opts = parse_args(argv)
1855
1856
if 'help' in opts:
1857
from bzrlib.help import help
1858
if args:
1859
help(args[0])
1860
else:
1861
help()
1862
return 0
1863
1864
if 'version' in opts:
1865
show_version()
1866
return 0
1867
1472
1868
if not args:
1869
print >>sys.stderr, "please try 'bzr help' for help"
1473
include_plugins=True
1474
try:
1475
args, opts = parse_args(argv[1:])
1476
if 'help' in opts:
1477
import help
1478
if args:
1479
help.help(args[0])
1480
else:
1481
help.help()
1482
return 0
1483
elif 'version' in opts:
1484
show_version()
1485
return 0
1486
elif args and args[0] == 'builtin':
1487
include_plugins=False
1488
args = args[1:]
1489
cmd = str(args.pop(0))
1490
except IndexError:
1491
import help
1492
help.help()
1870
1493
return 1
1871
1872
cmd = str(args.pop(0))
1873
1874
canonical_cmd, cmd_class = \
1875
get_cmd_class(cmd, plugins_override=not opt_builtin)
1494
1495
1496
canonical_cmd, cmd_class = get_cmd_class(cmd,include_plugins=include_plugins)
1497
1498
# global option
1499
if 'profile' in opts:
1500
profile = True
1501
del opts['profile']
1502
else:
1503
profile = False
1876
1504
1877
1505
# check options are reasonable
1878
1506
allowed = cmd_class.takes_options
1887
1515
for k, v in opts.items():
1888
1516
cmdopts[k.replace('-', '_')] = v
1889
1517
1890
if opt_profile:
1518
if profile:
1891
1519
import hotshot, tempfile
1892
1520
pffileno, pfname = tempfile.mkstemp()
1893
1521
try:
1914
1542
1915
1543
def _report_exception(summary, quiet=False):
1916
1544
import traceback
1917
1918
1545
log_error('bzr: ' + summary)
1919
1546
bzrlib.trace.log_exception()
1920
1547
1921
if os.environ.get('BZR_DEBUG'):
1922
traceback.print_exc()
1923
1924
1548
if not quiet:
1925
sys.stderr.write('\n')
1926
1549
tb = sys.exc_info()[2]
1927
1550
exinfo = traceback.extract_tb(tb)
1928
1551
if exinfo:
1932
1555
1933
1556
1934
1557
def main(argv):
1558
import errno
1935
1559
1936
bzrlib.trace.open_tracefile(argv)
1560
bzrlib.open_tracefile(argv)
1937
1561
1938
1562
try:
1939
1563
try:
1940
1564
try:
1941
return run_bzr(argv[1:])
1565
return run_bzr(argv)
1942
1566
finally:
1943
1567
# do this here inside the exception wrappers to catch EPIPE
1944
1568
sys.stdout.flush()
1945
1569
except BzrError, e:
1946
1570
quiet = isinstance(e, (BzrCommandError))
1947
_report_exception('error: ' + str(e), quiet=quiet)
1571
_report_exception('error: ' + e.args[0], quiet=quiet)
1948
1572
if len(e.args) > 1:
1949
1573
for h in e.args[1]:
1950
1574
# some explanation or hints
1960
1584
_report_exception('interrupted', quiet=True)
1961
1585
return 2
1962
1586
except Exception, e:
1963
import errno
1964
1587
quiet = False
1965
1588
if (isinstance(e, IOError)
1966
1589
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1