« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1137
- compare with another revision
- download diff
- download tarball
- view history from revision 1137
- Committer: Martin Pool
- Date: 2005-08-29 06:56:22 UTC
- Revision ID: mbp@sourcefrog.net-20050829065622-5aa7add87c38f188
- additional trace messages for plugins
- files added:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- elementtree/ => bzrlib/util/elementtree/
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
1
# Copyright (C) 2004, 2005 by Martin Pool
2
# Copyright (C) 2005 by Canonical Ltd
3
1
# Copyright (C) 2004, 2005 by Canonical Ltd
4
2
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
16
14
# along with this program; if not, write to the Free Software
17
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
16
19
"""Bazaar-NG -- a free distributed version-control tool
20
21
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
22
23
Current limitation include:
24
25
* Metadata format is not stable yet -- you may need to
26
discard history in the future.
27
28
* Insufficient error handling.
29
30
* Many commands unimplemented or partially implemented.
31
32
* Space-inefficient storage.
33
34
* No merge operators yet.
35
36
Interesting commands::
37
38
bzr help [COMMAND]
39
Show help screen
40
bzr version
41
Show software version/licence/non-warranty.
42
bzr init
43
Start versioning the current directory
44
bzr add FILE...
45
Make files versioned.
46
bzr log
47
Show revision history.
48
bzr diff
49
Show changes from last revision to working copy.
50
bzr commit -m 'MESSAGE'
51
Store current state as new revision.
52
bzr export REVNO DESTINATION
53
Export the branch state at a previous version.
54
bzr status
55
Show summary of pending changes.
56
bzr remove FILE...
57
Make a file not versioned.
58
bzr info
59
Show statistics about this branch.
60
"""
61
62
63
64
65
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
66
import traceback, socket, fnmatch, difflib
67
from os import path
68
from sets import Set
69
from pprint import pprint
70
from stat import *
71
from glob import glob
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
# TODO: Help messages for options.
24
25
# TODO: Define arguments by objects, rather than just using names.
26
# Those objects can specify the expected type of the argument, which
27
# would help with validation and shell completion.
28
29
30
import sys
31
import os
72
32
73
33
import bzrlib
74
from bzrlib.store import ImmutableStore
75
from bzrlib.trace import mutter, note, log_error
76
from bzrlib.errors import bailout, BzrError
77
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
78
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
79
from bzrlib.revision import Revision
80
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
81
format_date
82
83
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
84
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
85
86
## standard representation
87
NONE_STRING = '(none)'
88
EMPTY = 'empty'
89
90
91
## TODO: Perhaps a different version of inventory commands that
92
## returns iterators...
93
94
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
95
96
## TODO: Some kind of locking on branches. Perhaps there should be a
97
## parameter to the branch object saying whether we want a read or
98
## write lock; release it from destructor. Perhaps don't even need a
99
## read lock to look at immutable objects?
100
101
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
102
## to compare output?
103
104
## TODO: Some kind of global code to generate the right Branch object
105
## to work on. Almost, but not quite all, commands need one, and it
106
## can be taken either from their parameters or their working
107
## directory.
108
109
## TODO: rename command, needed soon: check destination doesn't exist
110
## either in working copy or tree; move working copy; update
111
## inventory; write out
112
113
## TODO: move command; check destination is a directory and will not
114
## clash; move it.
115
116
## TODO: command to show renames, one per line, as to->from
117
118
119
120
121
def cmd_status(all=False):
34
import bzrlib.trace
35
from bzrlib.trace import mutter, note, log_error, warning
36
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
37
from bzrlib.branch import find_branch
38
from bzrlib import BZRDIR
39
40
41
plugin_cmds = {}
42
43
44
def register_command(cmd):
45
"Utility function to help register a command"
46
global plugin_cmds
47
k = cmd.__name__
48
if k.startswith("cmd_"):
49
k_unsquished = _unsquish_command_name(k)
50
else:
51
k_unsquished = k
52
if not plugin_cmds.has_key(k_unsquished):
53
plugin_cmds[k_unsquished] = cmd
54
mutter('registered plugin command %s', k_unsquished)
55
else:
56
log_error('Two plugins defined the same command: %r' % k)
57
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
58
59
60
def _squish_command_name(cmd):
61
return 'cmd_' + cmd.replace('-', '_')
62
63
64
def _unsquish_command_name(cmd):
65
assert cmd.startswith("cmd_")
66
return cmd[4:].replace('_','-')
67
68
69
def _parse_revision_str(revstr):
70
"""This handles a revision string -> revno.
71
72
This always returns a list. The list will have one element for
73
74
It supports integers directly, but everything else it
75
defers for passing to Branch.get_revision_info()
76
77
>>> _parse_revision_str('234')
78
[234]
79
>>> _parse_revision_str('234..567')
80
[234, 567]
81
>>> _parse_revision_str('..')
82
[None, None]
83
>>> _parse_revision_str('..234')
84
[None, 234]
85
>>> _parse_revision_str('234..')
86
[234, None]
87
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
88
[234, 456, 789]
89
>>> _parse_revision_str('234....789') # Error?
90
[234, None, 789]
91
>>> _parse_revision_str('revid:test@other.com-234234')
92
['revid:test@other.com-234234']
93
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
94
['revid:test@other.com-234234', 'revid:test@other.com-234235']
95
>>> _parse_revision_str('revid:test@other.com-234234..23')
96
['revid:test@other.com-234234', 23]
97
>>> _parse_revision_str('date:2005-04-12')
98
['date:2005-04-12']
99
>>> _parse_revision_str('date:2005-04-12 12:24:33')
100
['date:2005-04-12 12:24:33']
101
>>> _parse_revision_str('date:2005-04-12T12:24:33')
102
['date:2005-04-12T12:24:33']
103
>>> _parse_revision_str('date:2005-04-12,12:24:33')
104
['date:2005-04-12,12:24:33']
105
>>> _parse_revision_str('-5..23')
106
[-5, 23]
107
>>> _parse_revision_str('-5')
108
[-5]
109
>>> _parse_revision_str('123a')
110
['123a']
111
>>> _parse_revision_str('abc')
112
['abc']
113
"""
114
import re
115
old_format_re = re.compile('\d*:\d*')
116
m = old_format_re.match(revstr)
117
if m:
118
warning('Colon separator for revision numbers is deprecated.'
119
' Use .. instead')
120
revs = []
121
for rev in revstr.split(':'):
122
if rev:
123
revs.append(int(rev))
124
else:
125
revs.append(None)
126
return revs
127
revs = []
128
for x in revstr.split('..'):
129
if not x:
130
revs.append(None)
131
else:
132
try:
133
revs.append(int(x))
134
except ValueError:
135
revs.append(x)
136
return revs
137
138
139
def get_merge_type(typestring):
140
"""Attempt to find the merge class/factory associated with a string."""
141
from merge import merge_types
142
try:
143
return merge_types[typestring][0]
144
except KeyError:
145
templ = '%s%%7s: %%s' % (' '*12)
146
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
147
type_list = '\n'.join(lines)
148
msg = "No known merge type %s. Supported types are:\n%s" %\
149
(typestring, type_list)
150
raise BzrCommandError(msg)
151
152
153
def get_merge_type(typestring):
154
"""Attempt to find the merge class/factory associated with a string."""
155
from merge import merge_types
156
try:
157
return merge_types[typestring][0]
158
except KeyError:
159
templ = '%s%%7s: %%s' % (' '*12)
160
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
161
type_list = '\n'.join(lines)
162
msg = "No known merge type %s. Supported types are:\n%s" %\
163
(typestring, type_list)
164
raise BzrCommandError(msg)
165
166
167
168
def _get_cmd_dict(plugins_override=True):
169
d = {}
170
for k, v in globals().iteritems():
171
if k.startswith("cmd_"):
172
d[_unsquish_command_name(k)] = v
173
# If we didn't load plugins, the plugin_cmds dict will be empty
174
if plugins_override:
175
d.update(plugin_cmds)
176
else:
177
d2 = plugin_cmds.copy()
178
d2.update(d)
179
d = d2
180
return d
181
182
183
def get_all_cmds(plugins_override=True):
184
"""Return canonical name and class for all registered commands."""
185
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
186
yield k,v
187
188
189
def get_cmd_class(cmd, plugins_override=True):
190
"""Return the canonical name and command class for a command.
191
"""
192
cmd = str(cmd) # not unicode
193
194
# first look up this command under the specified name
195
cmds = _get_cmd_dict(plugins_override=plugins_override)
196
mutter("all commands: %r", cmds.keys())
197
try:
198
return cmd, cmds[cmd]
199
except KeyError:
200
pass
201
202
# look for any command which claims this as an alias
203
for cmdname, cmdclass in cmds.iteritems():
204
if cmd in cmdclass.aliases:
205
return cmdname, cmdclass
206
207
cmdclass = ExternalCommand.find_command(cmd)
208
if cmdclass:
209
return cmd, cmdclass
210
211
raise BzrCommandError("unknown command %r" % cmd)
212
213
214
class Command(object):
215
"""Base class for commands.
216
217
The docstring for an actual command should give a single-line
218
summary, then a complete description of the command. A grammar
219
description will be inserted.
220
221
takes_args
222
List of argument forms, marked with whether they are optional,
223
repeated, etc.
224
225
takes_options
226
List of options that may be given for this command.
227
228
hidden
229
If true, this command isn't advertised.
230
"""
231
aliases = []
232
233
takes_args = []
234
takes_options = []
235
236
hidden = False
237
238
def __init__(self, options, arguments):
239
"""Construct and run the command.
240
241
Sets self.status to the return value of run()."""
242
assert isinstance(options, dict)
243
assert isinstance(arguments, dict)
244
cmdargs = options.copy()
245
cmdargs.update(arguments)
246
if self.__doc__ == Command.__doc__:
247
from warnings import warn
248
warn("No help message set for %r" % self)
249
self.status = self.run(**cmdargs)
250
if self.status is None:
251
self.status = 0
252
253
254
def run(self):
255
"""Override this in sub-classes.
256
257
This is invoked with the options and arguments bound to
258
keyword parameters.
259
260
Return 0 or None if the command was successful, or a shell
261
error code if not.
262
"""
263
return 0
264
265
266
class ExternalCommand(Command):
267
"""Class to wrap external commands.
268
269
We cheat a little here, when get_cmd_class() calls us we actually
270
give it back an object we construct that has the appropriate path,
271
help, options etc for the specified command.
272
273
When run_bzr() tries to instantiate that 'class' it gets caught by
274
the __call__ method, which we override to call the Command.__init__
275
method. That then calls our run method which is pretty straight
276
forward.
277
278
The only wrinkle is that we have to map bzr's dictionary of options
279
and arguments back into command line options and arguments for the
280
script.
281
"""
282
283
def find_command(cls, cmd):
284
import os.path
285
bzrpath = os.environ.get('BZRPATH', '')
286
287
for dir in bzrpath.split(os.pathsep):
288
path = os.path.join(dir, cmd)
289
if os.path.isfile(path):
290
return ExternalCommand(path)
291
292
return None
293
294
find_command = classmethod(find_command)
295
296
def __init__(self, path):
297
self.path = path
298
299
pipe = os.popen('%s --bzr-usage' % path, 'r')
300
self.takes_options = pipe.readline().split()
301
302
for opt in self.takes_options:
303
if not opt in OPTIONS:
304
raise BzrError("Unknown option '%s' returned by external command %s"
305
% (opt, path))
306
307
# TODO: Is there any way to check takes_args is valid here?
308
self.takes_args = pipe.readline().split()
309
310
if pipe.close() is not None:
311
raise BzrError("Failed funning '%s --bzr-usage'" % path)
312
313
pipe = os.popen('%s --bzr-help' % path, 'r')
314
self.__doc__ = pipe.read()
315
if pipe.close() is not None:
316
raise BzrError("Failed funning '%s --bzr-help'" % path)
317
318
def __call__(self, options, arguments):
319
Command.__init__(self, options, arguments)
320
return self
321
322
def run(self, **kargs):
323
opts = []
324
args = []
325
326
keys = kargs.keys()
327
keys.sort()
328
for name in keys:
329
optname = name.replace('_','-')
330
value = kargs[name]
331
if OPTIONS.has_key(optname):
332
# it's an option
333
opts.append('--%s' % optname)
334
if value is not None and value is not True:
335
opts.append(str(value))
336
else:
337
# it's an arg, or arg list
338
if type(value) is not list:
339
value = [value]
340
for v in value:
341
if v is not None:
342
args.append(str(v))
343
344
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
345
return self.status
346
347
348
class cmd_status(Command):
122
349
"""Display status summary.
123
350
124
For each file there is a single line giving its file state and name.
125
The name is that in the current revision unless it is deleted or
126
missing, in which case the old name is shown.
127
128
:todo: Don't show unchanged files unless ``--all`` is given?
129
"""
130
Branch('.').show_status(show_all=all)
131
132
133
134
######################################################################
135
# examining history
136
def cmd_get_revision(revision_id):
137
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
138
139
140
def cmd_get_file_text(text_id):
141
"""Get contents of a file by hash."""
142
sf = Branch('.').text_store[text_id]
143
pumpfile(sf, sys.stdout)
144
145
146
147
######################################################################
148
# commands
149
150
151
def cmd_revno():
152
"""Show number of revisions on this branch"""
153
print Branch('.').revno()
154
155
156
157
def cmd_add(file_list, verbose=False):
351
This reports on versioned and unknown files, reporting them
352
grouped by state. Possible states are:
353
354
added
355
Versioned in the working copy but not in the previous revision.
356
357
removed
358
Versioned in the previous revision but removed or deleted
359
in the working copy.
360
361
renamed
362
Path of this file changed from the previous revision;
363
the text may also have changed. This includes files whose
364
parent directory was renamed.
365
366
modified
367
Text has changed since the previous revision.
368
369
unchanged
370
Nothing about this file has changed since the previous revision.
371
Only shown with --all.
372
373
unknown
374
Not versioned and not matching an ignore pattern.
375
376
To see ignored files use 'bzr ignored'. For details in the
377
changes to file texts, use 'bzr diff'.
378
379
If no arguments are specified, the status of the entire working
380
directory is shown. Otherwise, only the status of the specified
381
files or directories is reported. If a directory is given, status
382
is reported for everything inside that directory.
383
384
If a revision is specified, the changes since that revision are shown.
385
"""
386
takes_args = ['file*']
387
takes_options = ['all', 'show-ids', 'revision']
388
aliases = ['st', 'stat']
389
390
def run(self, all=False, show_ids=False, file_list=None):
391
if file_list:
392
b = find_branch(file_list[0])
393
file_list = [b.relpath(x) for x in file_list]
394
# special case: only one path was given and it's the root
395
# of the branch
396
if file_list == ['']:
397
file_list = None
398
else:
399
b = find_branch('.')
400
401
from bzrlib.status import show_status
402
show_status(b, show_unchanged=all, show_ids=show_ids,
403
specific_files=file_list)
404
405
406
class cmd_cat_revision(Command):
407
"""Write out metadata for a revision."""
408
409
hidden = True
410
takes_args = ['revision_id']
411
412
def run(self, revision_id):
413
from bzrlib.xml import pack_xml
414
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
415
416
417
class cmd_revno(Command):
418
"""Show current revision number.
419
420
This is equal to the number of revisions on this branch."""
421
def run(self):
422
print find_branch('.').revno()
423
424
class cmd_revision_info(Command):
425
"""Show revision number and revision id for a given revision identifier.
426
"""
427
hidden = True
428
takes_args = ['revision_info*']
429
takes_options = ['revision']
430
def run(self, revision=None, revision_info_list=None):
431
from bzrlib.branch import find_branch
432
433
revs = []
434
if revision is not None:
435
revs.extend(revision)
436
if revision_info_list is not None:
437
revs.extend(revision_info_list)
438
if len(revs) == 0:
439
raise BzrCommandError('You must supply a revision identifier')
440
441
b = find_branch('.')
442
443
for rev in revs:
444
print '%4d %s' % b.get_revision_info(rev)
445
446
447
class cmd_add(Command):
158
448
"""Add specified files or directories.
159
449
160
450
In non-recursive mode, all the named items are added, regardless
167
457
whether already versioned or not, are searched for files or
168
458
subdirectories that are neither versioned or ignored, and these
169
459
are added. This search proceeds recursively into versioned
170
directories.
460
directories. If no names are given '.' is assumed.
171
461
172
Therefore simply saying 'bzr add .' will version all files that
462
Therefore simply saying 'bzr add' will version all files that
173
463
are currently unknown.
174
"""
175
bzrlib.add.smart_add(file_list, verbose)
176
177
178
def cmd_relpath(filename):
179
"""Show path of file relative to root"""
180
print Branch(filename).relpath(filename)
181
182
183
184
def cmd_inventory(revision=None):
185
"""Show inventory of the current working copy."""
186
## TODO: Also optionally show a previous inventory
187
## TODO: Format options
188
b = Branch('.')
189
if revision == None:
190
inv = b.read_working_inventory()
464
465
TODO: Perhaps adding a file whose directly is not versioned should
466
recursively add that parent, rather than giving an error?
467
"""
468
takes_args = ['file*']
469
takes_options = ['verbose', 'no-recurse']
470
471
def run(self, file_list, verbose=False, no_recurse=False):
472
from bzrlib.add import smart_add
473
474
recurse = not no_recurse
475
for path, kind, file_id in smart_add(file_list, verbose, recurse):
476
print 'added', path
477
478
479
480
class cmd_mkdir(Command):
481
"""Create a new versioned directory.
482
483
This is equivalent to creating the directory and then adding it.
484
"""
485
takes_args = ['dir+']
486
487
def run(self, dir_list):
488
b = None
489
490
for d in dir_list:
491
os.mkdir(d)
492
if not b:
493
b = find_branch(d)
494
b.add([d])
495
print 'added', d
496
497
498
class cmd_relpath(Command):
499
"""Show path of a file relative to root"""
500
takes_args = ['filename']
501
hidden = True
502
503
def run(self, filename):
504
print find_branch(filename).relpath(filename)
505
506
507
508
class cmd_inventory(Command):
509
"""Show inventory of the current working copy or a revision."""
510
takes_options = ['revision', 'show-ids']
511
512
def run(self, revision=None, show_ids=False):
513
b = find_branch('.')
514
if revision == None:
515
inv = b.read_working_inventory()
516
else:
517
if len(revision) > 1:
518
raise BzrCommandError('bzr inventory --revision takes'
519
' exactly one revision identifier')
520
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
521
522
for path, entry in inv.entries():
523
if show_ids:
524
print '%-50s %s' % (path, entry.file_id)
525
else:
526
print path
527
528
529
class cmd_move(Command):
530
"""Move files to a different directory.
531
532
examples:
533
bzr move *.txt doc
534
535
The destination must be a versioned directory in the same branch.
536
"""
537
takes_args = ['source$', 'dest']
538
def run(self, source_list, dest):
539
b = find_branch('.')
540
541
# TODO: glob expansion on windows?
542
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
543
544
545
class cmd_rename(Command):
546
"""Change the name of an entry.
547
548
examples:
549
bzr rename frob.c frobber.c
550
bzr rename src/frob.c lib/frob.c
551
552
It is an error if the destination name exists.
553
554
See also the 'move' command, which moves files into a different
555
directory without changing their name.
556
557
TODO: Some way to rename multiple files without invoking bzr for each
558
one?"""
559
takes_args = ['from_name', 'to_name']
560
561
def run(self, from_name, to_name):
562
b = find_branch('.')
563
b.rename_one(b.relpath(from_name), b.relpath(to_name))
564
565
566
567
class cmd_mv(Command):
568
"""Move or rename a file.
569
570
usage:
571
bzr mv OLDNAME NEWNAME
572
bzr mv SOURCE... DESTINATION
573
574
If the last argument is a versioned directory, all the other names
575
are moved into it. Otherwise, there must be exactly two arguments
576
and the file is changed to a new name, which must not already exist.
577
578
Files cannot be moved between branches.
579
"""
580
takes_args = ['names*']
581
def run(self, names_list):
582
if len(names_list) < 2:
583
raise BzrCommandError("missing file argument")
584
b = find_branch(names_list[0])
585
586
rel_names = [b.relpath(x) for x in names_list]
587
588
if os.path.isdir(names_list[-1]):
589
# move into existing directory
590
for pair in b.move(rel_names[:-1], rel_names[-1]):
591
print "%s => %s" % pair
592
else:
593
if len(names_list) != 2:
594
raise BzrCommandError('to mv multiple files the destination '
595
'must be a versioned directory')
596
for pair in b.move(rel_names[0], rel_names[1]):
597
print "%s => %s" % pair
598
599
600
601
602
class cmd_pull(Command):
603
"""Pull any changes from another branch into the current one.
604
605
If the location is omitted, the last-used location will be used.
606
Both the revision history and the working directory will be
607
updated.
608
609
This command only works on branches that have not diverged. Branches are
610
considered diverged if both branches have had commits without first
611
pulling from the other.
612
613
If branches have diverged, you can use 'bzr merge' to pull the text changes
614
from one into the other.
615
"""
616
takes_args = ['location?']
617
618
def run(self, location=None):
619
from bzrlib.merge import merge
620
import tempfile
621
from shutil import rmtree
622
import errno
623
624
br_to = find_branch('.')
625
stored_loc = None
626
try:
627
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
628
except IOError, e:
629
if e.errno != errno.ENOENT:
630
raise
631
if location is None:
632
if stored_loc is None:
633
raise BzrCommandError("No pull location known or specified.")
634
else:
635
print "Using last location: %s" % stored_loc
636
location = stored_loc
637
cache_root = tempfile.mkdtemp()
638
from bzrlib.branch import DivergedBranches
639
br_from = find_branch(location)
640
location = pull_loc(br_from)
641
old_revno = br_to.revno()
642
try:
643
from branch import find_cached_branch, DivergedBranches
644
br_from = find_cached_branch(location, cache_root)
645
location = pull_loc(br_from)
646
old_revno = br_to.revno()
647
try:
648
br_to.update_revisions(br_from)
649
except DivergedBranches:
650
raise BzrCommandError("These branches have diverged."
651
" Try merge.")
652
653
merge(('.', -1), ('.', old_revno), check_clean=False)
654
if location != stored_loc:
655
br_to.controlfile("x-pull", "wb").write(location + "\n")
656
finally:
657
rmtree(cache_root)
658
659
660
661
class cmd_branch(Command):
662
"""Create a new copy of a branch.
663
664
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
665
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
666
667
To retrieve the branch as of a particular revision, supply the --revision
668
parameter, as in "branch foo/bar -r 5".
669
"""
670
takes_args = ['from_location', 'to_location?']
671
takes_options = ['revision']
672
aliases = ['get', 'clone']
673
674
def run(self, from_location, to_location=None, revision=None):
675
import errno
676
from bzrlib.merge import merge
677
from bzrlib.branch import DivergedBranches, \
678
find_cached_branch, Branch
679
from shutil import rmtree
680
from meta_store import CachedStore
681
import tempfile
682
cache_root = tempfile.mkdtemp()
683
684
if revision is None:
685
revision = [None]
686
elif len(revision) > 1:
687
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
688
689
try:
690
try:
691
br_from = find_cached_branch(from_location, cache_root)
692
except OSError, e:
693
if e.errno == errno.ENOENT:
694
raise BzrCommandError('Source location "%s" does not'
695
' exist.' % to_location)
696
else:
697
raise
698
699
if to_location is None:
700
to_location = os.path.basename(from_location.rstrip("/\\"))
701
702
try:
703
os.mkdir(to_location)
704
except OSError, e:
705
if e.errno == errno.EEXIST:
706
raise BzrCommandError('Target directory "%s" already'
707
' exists.' % to_location)
708
if e.errno == errno.ENOENT:
709
raise BzrCommandError('Parent of "%s" does not exist.' %
710
to_location)
711
else:
712
raise
713
br_to = Branch(to_location, init=True)
714
715
br_to.set_root_id(br_from.get_root_id())
716
717
if revision:
718
if revision[0] is None:
719
revno = br_from.revno()
720
else:
721
revno, rev_id = br_from.get_revision_info(revision[0])
722
try:
723
br_to.update_revisions(br_from, stop_revision=revno)
724
except bzrlib.errors.NoSuchRevision:
725
rmtree(to_location)
726
msg = "The branch %s has no revision %d." % (from_location,
727
revno)
728
raise BzrCommandError(msg)
729
730
merge((to_location, -1), (to_location, 0), this_dir=to_location,
731
check_clean=False, ignore_zero=True)
732
from_location = pull_loc(br_from)
733
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
734
finally:
735
rmtree(cache_root)
736
737
738
def pull_loc(branch):
739
# TODO: Should perhaps just make attribute be 'base' in
740
# RemoteBranch and Branch?
741
if hasattr(branch, "baseurl"):
742
return branch.baseurl
191
743
else:
192
inv = b.get_revision_inventory(b.lookup_revision(revision))
193
194
for path, entry in inv.iter_entries():
195
print '%-50s %s' % (entry.file_id, path)
196
197
198
199
def cmd_mv(source_list, dest):
200
b = Branch('.')
201
202
b.rename([b.relpath(s) for s in source_list], b.relpath(dest))
203
204
205
206
def cmd_renames(dir='.'):
744
return branch.base
745
746
747
748
class cmd_renames(Command):
207
749
"""Show list of renamed files.
208
750
209
usage: bzr renames [BRANCH]
210
211
TODO: Option to show renames between two historical versions.
212
213
TODO: Only show renames under dir, rather than in the whole branch.
214
"""
215
b = Branch(dir)
216
old_inv = b.basis_tree().inventory
217
new_inv = b.read_working_inventory()
218
219
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
220
renames.sort()
221
for old_name, new_name in renames:
222
print "%s => %s" % (old_name, new_name)
223
224
225
226
def cmd_info():
227
"""info: Show statistical information for this branch
228
229
usage: bzr info"""
230
import info
231
info.show_info(Branch('.'))
232
233
234
235
def cmd_remove(file_list, verbose=False):
236
b = Branch(file_list[0])
237
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
238
239
240
241
def cmd_file_id(filename):
242
b = Branch(filename)
243
i = b.inventory.path2id(b.relpath(filename))
244
if i is None:
245
bailout("%s is not a versioned file" % filename)
246
else:
247
print i
248
249
250
def cmd_find_filename(fileid):
251
n = find_filename(fileid)
252
if n is None:
253
bailout("%s is not a live file id" % fileid)
254
else:
255
print n
256
257
258
def cmd_revision_history():
259
for patchid in Branch('.').revision_history():
260
print patchid
261
262
263
def cmd_directories():
264
for name, ie in Branch('.').read_working_inventory().directories():
265
if name == '':
266
print '.'
267
else:
268
print name
269
270
271
def cmd_missing():
272
for name, ie in Branch('.').working_tree().missing():
273
print name
274
275
276
def cmd_init():
277
# TODO: Check we're not already in a working directory? At the
278
# moment you'll get an ugly error.
279
280
# TODO: What if we're in a subdirectory of a branch? Would like
281
# to allow that, but then the parent may need to understand that
282
# the children have disappeared, or should they be versioned in
283
# both?
284
285
# TODO: Take an argument/option for branch name.
286
Branch('.', init=True)
287
288
289
def cmd_diff(revision=None):
290
"""bzr diff: Show differences in working tree.
291
292
usage: bzr diff [-r REV]
293
294
--revision REV
295
Show changes since REV, rather than predecessor.
296
297
TODO: Given two revision arguments, show the difference between them.
298
299
TODO: Allow diff across branches.
300
301
TODO: Option to use external diff command; could be GNU diff, wdiff,
302
or a graphical diff.
303
304
TODO: Diff selected files.
305
"""
306
307
## TODO: Shouldn't be in the cmd function.
308
309
b = Branch('.')
310
311
if revision == None:
312
old_tree = b.basis_tree()
313
else:
314
old_tree = b.revision_tree(b.lookup_revision(revision))
315
316
new_tree = b.working_tree()
317
old_inv = old_tree.inventory
318
new_inv = new_tree.inventory
319
320
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
321
old_label = ''
322
new_label = ''
323
324
DEVNULL = '/dev/null'
325
# Windows users, don't panic about this filename -- it is a
326
# special signal to GNU patch that the file should be created or
327
# deleted respectively.
328
329
# TODO: Generation of pseudo-diffs for added/deleted files could
330
# be usefully made into a much faster special case.
331
332
# TODO: Better to return them in sorted order I think.
333
334
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
335
d = None
336
337
# Don't show this by default; maybe do it if an option is passed
338
# idlabel = ' {%s}' % fid
339
idlabel = ''
340
341
# FIXME: Something about the diff format makes patch unhappy
342
# with newly-added files.
343
344
def diffit(oldlines, newlines, **kw):
345
# FIXME: difflib is wrong if there is no trailing newline.
346
347
# Special workaround for Python2.3, where difflib fails if
348
# both sequences are empty.
349
if oldlines or newlines:
350
sys.stdout.writelines(difflib.unified_diff(oldlines, newlines, **kw))
351
print
352
353
if file_state in ['.', '?', 'I']:
354
continue
355
elif file_state == 'A':
356
print '*** added %s %r' % (kind, new_name)
357
if kind == 'file':
358
diffit([],
359
new_tree.get_file(fid).readlines(),
360
fromfile=DEVNULL,
361
tofile=new_label + new_name + idlabel)
362
elif file_state == 'D':
363
assert isinstance(old_name, types.StringTypes)
364
print '*** deleted %s %r' % (kind, old_name)
365
if kind == 'file':
366
diffit(old_tree.get_file(fid).readlines(), [],
367
fromfile=old_label + old_name + idlabel,
368
tofile=DEVNULL)
369
elif file_state in ['M', 'R']:
370
if file_state == 'M':
371
assert kind == 'file'
372
assert old_name == new_name
373
print '*** modified %s %r' % (kind, new_name)
374
elif file_state == 'R':
375
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
376
377
if kind == 'file':
378
diffit(old_tree.get_file(fid).readlines(),
379
new_tree.get_file(fid).readlines(),
380
fromfile=old_label + old_name + idlabel,
381
tofile=new_label + new_name)
382
else:
383
bailout("can't represent state %s {%s}" % (file_state, fid))
384
385
386
387
def cmd_deleted(show_ids=False):
751
TODO: Option to show renames between two historical versions.
752
753
TODO: Only show renames under dir, rather than in the whole branch.
754
"""
755
takes_args = ['dir?']
756
757
def run(self, dir='.'):
758
b = find_branch(dir)
759
old_inv = b.basis_tree().inventory
760
new_inv = b.read_working_inventory()
761
762
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
763
renames.sort()
764
for old_name, new_name in renames:
765
print "%s => %s" % (old_name, new_name)
766
767
768
class cmd_info(Command):
769
"""Show statistical information about a branch."""
770
takes_args = ['branch?']
771
772
def run(self, branch=None):
773
import info
774
775
b = find_branch(branch)
776
info.show_info(b)
777
778
779
class cmd_remove(Command):
780
"""Make a file unversioned.
781
782
This makes bzr stop tracking changes to a versioned file. It does
783
not delete the working copy.
784
"""
785
takes_args = ['file+']
786
takes_options = ['verbose']
787
788
def run(self, file_list, verbose=False):
789
b = find_branch(file_list[0])
790
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
791
792
793
class cmd_file_id(Command):
794
"""Print file_id of a particular file or directory.
795
796
The file_id is assigned when the file is first added and remains the
797
same through all revisions where the file exists, even when it is
798
moved or renamed.
799
"""
800
hidden = True
801
takes_args = ['filename']
802
def run(self, filename):
803
b = find_branch(filename)
804
i = b.inventory.path2id(b.relpath(filename))
805
if i == None:
806
raise BzrError("%r is not a versioned file" % filename)
807
else:
808
print i
809
810
811
class cmd_file_path(Command):
812
"""Print path of file_ids to a file or directory.
813
814
This prints one line for each directory down to the target,
815
starting at the branch root."""
816
hidden = True
817
takes_args = ['filename']
818
def run(self, filename):
819
b = find_branch(filename)
820
inv = b.inventory
821
fid = inv.path2id(b.relpath(filename))
822
if fid == None:
823
raise BzrError("%r is not a versioned file" % filename)
824
for fip in inv.get_idpath(fid):
825
print fip
826
827
828
class cmd_revision_history(Command):
829
"""Display list of revision ids on this branch."""
830
hidden = True
831
def run(self):
832
for patchid in find_branch('.').revision_history():
833
print patchid
834
835
836
class cmd_directories(Command):
837
"""Display list of versioned directories in this branch."""
838
def run(self):
839
for name, ie in find_branch('.').read_working_inventory().directories():
840
if name == '':
841
print '.'
842
else:
843
print name
844
845
846
class cmd_init(Command):
847
"""Make a directory into a versioned branch.
848
849
Use this to create an empty branch, or before importing an
850
existing project.
851
852
Recipe for importing a tree of files:
853
cd ~/project
854
bzr init
855
bzr add -v .
856
bzr status
857
bzr commit -m 'imported project'
858
"""
859
def run(self):
860
from bzrlib.branch import Branch
861
Branch('.', init=True)
862
863
864
class cmd_diff(Command):
865
"""Show differences in working tree.
866
867
If files are listed, only the changes in those files are listed.
868
Otherwise, all changes for the tree are listed.
869
870
TODO: Allow diff across branches.
871
872
TODO: Option to use external diff command; could be GNU diff, wdiff,
873
or a graphical diff.
874
875
TODO: Python difflib is not exactly the same as unidiff; should
876
either fix it up or prefer to use an external diff.
877
878
TODO: If a directory is given, diff everything under that.
879
880
TODO: Selected-file diff is inefficient and doesn't show you
881
deleted files.
882
883
TODO: This probably handles non-Unix newlines poorly.
884
885
examples:
886
bzr diff
887
bzr diff -r1
888
bzr diff -r1:2
889
"""
890
891
takes_args = ['file*']
892
takes_options = ['revision', 'diff-options']
893
aliases = ['di', 'dif']
894
895
def run(self, revision=None, file_list=None, diff_options=None):
896
from bzrlib.diff import show_diff
897
898
if file_list:
899
b = find_branch(file_list[0])
900
file_list = [b.relpath(f) for f in file_list]
901
if file_list == ['']:
902
# just pointing to top-of-tree
903
file_list = None
904
else:
905
b = find_branch('.')
906
907
if revision is not None:
908
if len(revision) == 1:
909
show_diff(b, revision[0], specific_files=file_list,
910
external_diff_options=diff_options)
911
elif len(revision) == 2:
912
show_diff(b, revision[0], specific_files=file_list,
913
external_diff_options=diff_options,
914
revision2=revision[1])
915
else:
916
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
917
else:
918
show_diff(b, None, specific_files=file_list,
919
external_diff_options=diff_options)
920
921
922
923
924
class cmd_deleted(Command):
388
925
"""List files deleted in the working tree.
389
926
390
TODO: Show files deleted since a previous revision, or between two revisions.
927
TODO: Show files deleted since a previous revision, or between two revisions.
391
928
"""
392
b = Branch('.')
393
old = b.basis_tree()
394
new = b.working_tree()
395
396
## TODO: Much more efficient way to do this: read in new
397
## directories with readdir, rather than stating each one. Same
398
## level of effort but possibly much less IO. (Or possibly not,
399
## if the directories are very large...)
400
401
for path, ie in old.inventory.iter_entries():
402
if not new.has_id(ie.file_id):
403
if show_ids:
404
print '%-50s %s' % (path, ie.file_id)
405
else:
406
print path
407
408
409
410
def cmd_parse_inventory():
411
import cElementTree
412
413
cElementTree.ElementTree().parse(file('.bzr/inventory'))
414
415
416
417
def cmd_load_inventory():
418
inv = Branch('.').basis_tree().inventory
419
420
421
422
def cmd_dump_new_inventory():
423
import bzrlib.newinventory
424
inv = Branch('.').basis_tree().inventory
425
bzrlib.newinventory.write_inventory(inv, sys.stdout)
426
427
428
def cmd_load_new_inventory():
429
import bzrlib.newinventory
430
bzrlib.newinventory.read_new_inventory(sys.stdin)
431
432
433
def cmd_dump_slacker_inventory():
434
import bzrlib.newinventory
435
inv = Branch('.').basis_tree().inventory
436
bzrlib.newinventory.write_slacker_inventory(inv, sys.stdout)
437
438
439
440
def cmd_root(filename=None):
441
"""Print the branch root."""
442
print bzrlib.branch.find_branch_root(filename)
443
444
445
def cmd_log(timezone='original'):
929
def run(self, show_ids=False):
930
b = find_branch('.')
931
old = b.basis_tree()
932
new = b.working_tree()
933
934
## TODO: Much more efficient way to do this: read in new
935
## directories with readdir, rather than stating each one. Same
936
## level of effort but possibly much less IO. (Or possibly not,
937
## if the directories are very large...)
938
939
for path, ie in old.inventory.iter_entries():
940
if not new.has_id(ie.file_id):
941
if show_ids:
942
print '%-50s %s' % (path, ie.file_id)
943
else:
944
print path
945
946
947
class cmd_modified(Command):
948
"""List files modified in working tree."""
949
hidden = True
950
def run(self):
951
from bzrlib.delta import compare_trees
952
953
b = find_branch('.')
954
td = compare_trees(b.basis_tree(), b.working_tree())
955
956
for path, id, kind in td.modified:
957
print path
958
959
960
961
class cmd_added(Command):
962
"""List files added in working tree."""
963
hidden = True
964
def run(self):
965
b = find_branch('.')
966
wt = b.working_tree()
967
basis_inv = b.basis_tree().inventory
968
inv = wt.inventory
969
for file_id in inv:
970
if file_id in basis_inv:
971
continue
972
path = inv.id2path(file_id)
973
if not os.access(b.abspath(path), os.F_OK):
974
continue
975
print path
976
977
978
979
class cmd_root(Command):
980
"""Show the tree root directory.
981
982
The root is the nearest enclosing directory with a .bzr control
983
directory."""
984
takes_args = ['filename?']
985
def run(self, filename=None):
986
"""Print the branch root."""
987
b = find_branch(filename)
988
print getattr(b, 'base', None) or getattr(b, 'baseurl')
989
990
991
class cmd_log(Command):
446
992
"""Show log of this branch.
447
993
448
:todo: Options for utc; to show ids; to limit range; etc.
994
To request a range of logs, you can use the command -r begin:end
995
-r revision requests a specific revision, -r :end or -r begin: are
996
also valid.
997
998
--message allows you to give a regular expression, which will be evaluated
999
so that only matching entries will be displayed.
1000
1001
TODO: Make --revision support uuid: and hash: [future tag:] notation.
1002
449
1003
"""
450
Branch('.').write_log(show_timezone=timezone)
451
452
453
def cmd_ls(revision=None, verbose=False):
1004
1005
takes_args = ['filename?']
1006
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
1007
'long', 'message', 'short',]
1008
1009
def run(self, filename=None, timezone='original',
1010
verbose=False,
1011
show_ids=False,
1012
forward=False,
1013
revision=None,
1014
message=None,
1015
long=False,
1016
short=False):
1017
from bzrlib.branch import find_branch
1018
from bzrlib.log import log_formatter, show_log
1019
import codecs
1020
1021
direction = (forward and 'forward') or 'reverse'
1022
1023
if filename:
1024
b = find_branch(filename)
1025
fp = b.relpath(filename)
1026
if fp:
1027
file_id = b.read_working_inventory().path2id(fp)
1028
else:
1029
file_id = None # points to branch root
1030
else:
1031
b = find_branch('.')
1032
file_id = None
1033
1034
if revision is None:
1035
rev1 = None
1036
rev2 = None
1037
elif len(revision) == 1:
1038
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1039
elif len(revision) == 2:
1040
rev1 = b.get_revision_info(revision[0])[0]
1041
rev2 = b.get_revision_info(revision[1])[0]
1042
else:
1043
raise BzrCommandError('bzr log --revision takes one or two values.')
1044
1045
if rev1 == 0:
1046
rev1 = None
1047
if rev2 == 0:
1048
rev2 = None
1049
1050
mutter('encoding log as %r' % bzrlib.user_encoding)
1051
1052
# use 'replace' so that we don't abort if trying to write out
1053
# in e.g. the default C locale.
1054
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1055
1056
if not short:
1057
log_format = 'long'
1058
else:
1059
log_format = 'short'
1060
lf = log_formatter(log_format,
1061
show_ids=show_ids,
1062
to_file=outf,
1063
show_timezone=timezone)
1064
1065
show_log(b,
1066
lf,
1067
file_id,
1068
verbose=verbose,
1069
direction=direction,
1070
start_revision=rev1,
1071
end_revision=rev2,
1072
search=message)
1073
1074
1075
1076
class cmd_touching_revisions(Command):
1077
"""Return revision-ids which affected a particular file.
1078
1079
A more user-friendly interface is "bzr log FILE"."""
1080
hidden = True
1081
takes_args = ["filename"]
1082
def run(self, filename):
1083
b = find_branch(filename)
1084
inv = b.read_working_inventory()
1085
file_id = inv.path2id(b.relpath(filename))
1086
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1087
print "%6d %s" % (revno, what)
1088
1089
1090
class cmd_ls(Command):
454
1091
"""List files in a tree.
455
1092
456
:todo: Take a revision or remote path and list that tree instead.
1093
TODO: Take a revision or remote path and list that tree instead.
457
1094
"""
458
b = Branch('.')
459
if revision == None:
460
tree = b.working_tree()
461
else:
462
tree = b.revision_tree(b.lookup_revision(revision))
463
464
for fp, fc, kind, fid in tree.list_files():
465
if verbose:
466
if kind == 'directory':
467
kindch = '/'
468
elif kind == 'file':
469
kindch = ''
1095
hidden = True
1096
def run(self, revision=None, verbose=False):
1097
b = find_branch('.')
1098
if revision == None:
1099
tree = b.working_tree()
1100
else:
1101
tree = b.revision_tree(b.lookup_revision(revision))
1102
1103
for fp, fc, kind, fid in tree.list_files():
1104
if verbose:
1105
if kind == 'directory':
1106
kindch = '/'
1107
elif kind == 'file':
1108
kindch = ''
1109
else:
1110
kindch = '???'
1111
1112
print '%-8s %s%s' % (fc, fp, kindch)
470
1113
else:
471
kindch = '???'
472
473
print '%-8s %s%s' % (fc, fp, kindch)
474
else:
475
print fp
476
477
478
479
def cmd_unknowns():
480
"""List unknown files"""
481
for f in Branch('.').unknowns():
482
print quotefn(f)
483
484
485
486
def cmd_ignored(verbose=True):
1114
print fp
1115
1116
1117
1118
class cmd_unknowns(Command):
1119
"""List unknown files."""
1120
def run(self):
1121
from bzrlib.osutils import quotefn
1122
for f in find_branch('.').unknowns():
1123
print quotefn(f)
1124
1125
1126
1127
class cmd_ignore(Command):
1128
"""Ignore a command or pattern.
1129
1130
To remove patterns from the ignore list, edit the .bzrignore file.
1131
1132
If the pattern contains a slash, it is compared to the whole path
1133
from the branch root. Otherwise, it is comapred to only the last
1134
component of the path.
1135
1136
Ignore patterns are case-insensitive on case-insensitive systems.
1137
1138
Note: wildcards must be quoted from the shell on Unix.
1139
1140
examples:
1141
bzr ignore ./Makefile
1142
bzr ignore '*.class'
1143
"""
1144
takes_args = ['name_pattern']
1145
1146
def run(self, name_pattern):
1147
from bzrlib.atomicfile import AtomicFile
1148
import os.path
1149
1150
b = find_branch('.')
1151
ifn = b.abspath('.bzrignore')
1152
1153
if os.path.exists(ifn):
1154
f = open(ifn, 'rt')
1155
try:
1156
igns = f.read().decode('utf-8')
1157
finally:
1158
f.close()
1159
else:
1160
igns = ''
1161
1162
# TODO: If the file already uses crlf-style termination, maybe
1163
# we should use that for the newly added lines?
1164
1165
if igns and igns[-1] != '\n':
1166
igns += '\n'
1167
igns += name_pattern + '\n'
1168
1169
try:
1170
f = AtomicFile(ifn, 'wt')
1171
f.write(igns.encode('utf-8'))
1172
f.commit()
1173
finally:
1174
f.close()
1175
1176
inv = b.working_tree().inventory
1177
if inv.path2id('.bzrignore'):
1178
mutter('.bzrignore is already versioned')
1179
else:
1180
mutter('need to make new .bzrignore file versioned')
1181
b.add(['.bzrignore'])
1182
1183
1184
1185
class cmd_ignored(Command):
487
1186
"""List ignored files and the patterns that matched them.
488
"""
489
tree = Branch('.').working_tree()
490
for path, file_class, kind, id in tree.list_files():
491
if file_class != 'I':
492
continue
493
## XXX: Slightly inefficient since this was already calculated
494
pat = tree.is_ignored(path)
495
print '%-50s %s' % (path, pat)
496
497
498
def cmd_lookup_revision(revno):
499
try:
500
revno = int(revno)
501
except ValueError:
502
bailout("usage: lookup-revision REVNO",
503
["REVNO is a non-negative revision number for this branch"])
504
505
print Branch('.').lookup_revision(revno) or NONE_STRING
506
507
508
509
def cmd_export(revno, dest):
510
"""Export past revision to destination directory."""
511
b = Branch('.')
512
rh = b.lookup_revision(int(revno))
513
t = b.revision_tree(rh)
514
t.export(dest)
515
516
517
518
######################################################################
519
# internal/test commands
520
521
522
def cmd_uuid():
523
"""Print a newly-generated UUID."""
524
print bzrlib.osutils.uuid()
525
526
527
528
def cmd_local_time_offset():
529
print bzrlib.osutils.local_time_offset()
530
531
532
533
def cmd_commit(message=None, verbose=False):
534
"""Commit changes to a new revision.
535
536
--message MESSAGE
537
Description of changes in this revision; free form text.
538
It is recommended that the first line be a single-sentence
539
summary.
540
--verbose
541
Show status of changed files,
542
543
TODO: Commit only selected files.
544
545
TODO: Run hooks on tree to-be-committed, and after commit.
546
547
TODO: Strict commit that fails if there are unknown or deleted files.
548
"""
549
550
if not message:
551
bailout("please specify a commit message")
552
Branch('.').commit(message, verbose=verbose)
553
554
555
def cmd_check(dir='.'):
556
"""check: Consistency check of branch history.
557
558
usage: bzr check [-v] [BRANCH]
559
560
options:
561
--verbose, -v Show progress of checking.
562
563
This command checks various invariants about the branch storage to
564
detect data corruption or bzr bugs.
565
"""
566
import bzrlib.check
567
bzrlib.check.check(Branch(dir, find_root=False))
568
569
570
def cmd_is(pred, *rest):
571
"""Test whether PREDICATE is true."""
572
try:
573
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
574
except KeyError:
575
bailout("unknown predicate: %s" % quotefn(pred))
576
577
try:
578
cmd_handler(*rest)
579
except BzrCheckError:
580
# by default we don't print the message so that this can
581
# be used from shell scripts without producing noise
582
sys.exit(1)
583
584
585
def cmd_username():
586
print bzrlib.osutils.username()
587
588
589
def cmd_user_email():
590
print bzrlib.osutils.user_email()
591
592
593
def cmd_gen_revision_id():
594
import time
595
print bzrlib.branch._gen_revision_id(time.time())
596
597
598
def cmd_selftest(verbose=False):
1187
1188
See also: bzr ignore"""
1189
def run(self):
1190
tree = find_branch('.').working_tree()
1191
for path, file_class, kind, file_id in tree.list_files():
1192
if file_class != 'I':
1193
continue
1194
## XXX: Slightly inefficient since this was already calculated
1195
pat = tree.is_ignored(path)
1196
print '%-50s %s' % (path, pat)
1197
1198
1199
class cmd_lookup_revision(Command):
1200
"""Lookup the revision-id from a revision-number
1201
1202
example:
1203
bzr lookup-revision 33
1204
"""
1205
hidden = True
1206
takes_args = ['revno']
1207
1208
def run(self, revno):
1209
try:
1210
revno = int(revno)
1211
except ValueError:
1212
raise BzrCommandError("not a valid revision-number: %r" % revno)
1213
1214
print find_branch('.').lookup_revision(revno)
1215
1216
1217
class cmd_export(Command):
1218
"""Export past revision to destination directory.
1219
1220
If no revision is specified this exports the last committed revision.
1221
1222
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1223
given, try to find the format with the extension. If no extension
1224
is found exports to a directory (equivalent to --format=dir).
1225
1226
Root may be the top directory for tar, tgz and tbz2 formats. If none
1227
is given, the top directory will be the root name of the file."""
1228
# TODO: list known exporters
1229
takes_args = ['dest']
1230
takes_options = ['revision', 'format', 'root']
1231
def run(self, dest, revision=None, format=None, root=None):
1232
import os.path
1233
b = find_branch('.')
1234
if revision is None:
1235
rev_id = b.last_patch()
1236
else:
1237
if len(revision) != 1:
1238
raise BzrError('bzr export --revision takes exactly 1 argument')
1239
revno, rev_id = b.get_revision_info(revision[0])
1240
t = b.revision_tree(rev_id)
1241
root, ext = os.path.splitext(dest)
1242
if not format:
1243
if ext in (".tar",):
1244
format = "tar"
1245
elif ext in (".gz", ".tgz"):
1246
format = "tgz"
1247
elif ext in (".bz2", ".tbz2"):
1248
format = "tbz2"
1249
else:
1250
format = "dir"
1251
t.export(dest, format, root)
1252
1253
1254
class cmd_cat(Command):
1255
"""Write a file's text from a previous revision."""
1256
1257
takes_options = ['revision']
1258
takes_args = ['filename']
1259
1260
def run(self, filename, revision=None):
1261
if revision == None:
1262
raise BzrCommandError("bzr cat requires a revision number")
1263
elif len(revision) != 1:
1264
raise BzrCommandError("bzr cat --revision takes exactly one number")
1265
b = find_branch('.')
1266
b.print_file(b.relpath(filename), revision[0])
1267
1268
1269
class cmd_local_time_offset(Command):
1270
"""Show the offset in seconds from GMT to local time."""
1271
hidden = True
1272
def run(self):
1273
print bzrlib.osutils.local_time_offset()
1274
1275
1276
1277
class cmd_commit(Command):
1278
"""Commit changes into a new revision.
1279
1280
If no arguments are given, the entire tree is committed.
1281
1282
If selected files are specified, only changes to those files are
1283
committed. If a directory is specified then the directory and everything
1284
within it is committed.
1285
1286
A selected-file commit may fail in some cases where the committed
1287
tree would be invalid, such as trying to commit a file in a
1288
newly-added directory that is not itself committed.
1289
1290
TODO: Run hooks on tree to-be-committed, and after commit.
1291
1292
TODO: Strict commit that fails if there are unknown or deleted files.
1293
"""
1294
takes_args = ['selected*']
1295
takes_options = ['message', 'file', 'verbose', 'unchanged']
1296
aliases = ['ci', 'checkin']
1297
1298
# TODO: Give better message for -s, --summary, used by tla people
1299
1300
def run(self, message=None, file=None, verbose=True, selected_list=None,
1301
unchanged=False):
1302
from bzrlib.errors import PointlessCommit
1303
from bzrlib.osutils import get_text_message
1304
1305
## Warning: shadows builtin file()
1306
if not message and not file:
1307
# FIXME: Ugly; change status code to send to a provided function?
1308
1309
import cStringIO
1310
stdout = sys.stdout
1311
catcher = cStringIO.StringIO()
1312
sys.stdout = catcher
1313
cmd_status({"file_list":selected_list}, {})
1314
info = catcher.getvalue()
1315
sys.stdout = stdout
1316
message = get_text_message(info)
1317
1318
if message is None:
1319
raise BzrCommandError("please specify a commit message",
1320
["use either --message or --file"])
1321
elif message and file:
1322
raise BzrCommandError("please specify either --message or --file")
1323
1324
if file:
1325
import codecs
1326
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1327
1328
b = find_branch('.')
1329
if selected_list:
1330
selected_list = [b.relpath(s) for s in selected_list]
1331
1332
try:
1333
b.commit(message, verbose=verbose,
1334
specific_files=selected_list,
1335
allow_pointless=unchanged)
1336
except PointlessCommit:
1337
# FIXME: This should really happen before the file is read in;
1338
# perhaps prepare the commit; get the message; then actually commit
1339
raise BzrCommandError("no changes to commit",
1340
["use --unchanged to commit anyhow"])
1341
1342
1343
class cmd_check(Command):
1344
"""Validate consistency of branch history.
1345
1346
This command checks various invariants about the branch storage to
1347
detect data corruption or bzr bugs.
1348
1349
If given the --update flag, it will update some optional fields
1350
to help ensure data consistency.
1351
"""
1352
takes_args = ['dir?']
1353
1354
def run(self, dir='.'):
1355
from bzrlib.check import check
1356
1357
check(find_branch(dir))
1358
1359
1360
class cmd_scan_cache(Command):
1361
hidden = True
1362
def run(self):
1363
from bzrlib.hashcache import HashCache
1364
import os
1365
1366
c = HashCache('.')
1367
c.read()
1368
c.scan()
1369
1370
print '%6d stats' % c.stat_count
1371
print '%6d in hashcache' % len(c._cache)
1372
print '%6d files removed from cache' % c.removed_count
1373
print '%6d hashes updated' % c.update_count
1374
print '%6d files changed too recently to cache' % c.danger_count
1375
1376
if c.needs_write:
1377
c.write()
1378
1379
1380
1381
class cmd_upgrade(Command):
1382
"""Upgrade branch storage to current format.
1383
1384
The check command or bzr developers may sometimes advise you to run
1385
this command.
1386
"""
1387
takes_args = ['dir?']
1388
1389
def run(self, dir='.'):
1390
from bzrlib.upgrade import upgrade
1391
upgrade(find_branch(dir))
1392
1393
1394
1395
class cmd_whoami(Command):
1396
"""Show bzr user id."""
1397
takes_options = ['email']
1398
1399
def run(self, email=False):
1400
try:
1401
b = bzrlib.branch.find_branch('.')
1402
except:
1403
b = None
1404
1405
if email:
1406
print bzrlib.osutils.user_email(b)
1407
else:
1408
print bzrlib.osutils.username(b)
1409
1410
1411
class cmd_selftest(Command):
599
1412
"""Run internal test suite"""
600
## -v, if present, is seen by doctest; the argument is just here
601
## so our parser doesn't complain
602
603
## TODO: --verbose option
604
605
failures, tests = 0, 0
606
607
import doctest, bzrlib.store, bzrlib.tests
608
bzrlib.trace.verbose = False
609
610
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
611
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
612
mf, mt = doctest.testmod(m)
613
failures += mf
614
tests += mt
615
print '%-40s %3d tests' % (m.__name__, mt),
616
if mf:
617
print '%3d FAILED!' % mf
618
else:
619
print
620
621
print '%-40s %3d tests' % ('total', tests),
622
if failures:
623
print '%3d FAILED!' % failures
624
else:
625
print
626
627
628
629
# deprecated
630
cmd_doctest = cmd_selftest
631
632
633
######################################################################
634
# help
635
636
637
def cmd_help(topic=None):
638
if topic == None:
639
print __doc__
640
return
641
642
# otherwise, maybe the name of a command?
643
try:
644
cmdfn = globals()['cmd_' + topic.replace('-', '_')]
645
except KeyError:
646
bailout("no help for %r" % topic)
647
648
doc = cmdfn.__doc__
649
if doc == None:
650
bailout("sorry, no detailed help yet for %r" % topic)
651
652
print doc
653
654
655
656
657
def cmd_version():
1413
hidden = True
1414
takes_options = ['verbose']
1415
def run(self, verbose=False):
1416
import bzrlib.ui
1417
from bzrlib.selftest import selftest
1418
1419
# we don't want progress meters from the tests to go to the
1420
# real output; and we don't want log messages cluttering up
1421
# the real logs.
1422
1423
save_ui = bzrlib.ui.ui_factory
1424
bzrlib.trace.info('running tests...')
1425
try:
1426
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1427
result = selftest(verbose=verbose)
1428
if result:
1429
bzrlib.trace.info('tests passed')
1430
else:
1431
bzrlib.trace.info('tests failed')
1432
return int(not result)
1433
finally:
1434
bzrlib.ui.ui_factory = save_ui
1435
1436
1437
class cmd_version(Command):
1438
"""Show version of bzr."""
1439
def run(self):
1440
show_version()
1441
1442
def show_version():
658
1443
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1444
# is bzrlib itself in a branch?
1445
bzrrev = bzrlib.get_bzr_revision()
1446
if bzrrev:
1447
print " (bzr checkout, revision %d {%s})" % bzrrev
659
1448
print bzrlib.__copyright__
660
1449
print "http://bazaar-ng.org/"
661
1450
print
662
print \
663
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
664
you may use, modify and redistribute it under the terms of the GNU
665
General Public License version 2 or later."""
666
667
668
def cmd_rocks():
1451
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1452
print "you may use, modify and redistribute it under the terms of the GNU"
1453
print "General Public License version 2 or later."
1454
1455
1456
class cmd_rocks(Command):
669
1457
"""Statement of optimism."""
670
print "it sure does!"
671
672
673
674
######################################################################
675
# main routine
1458
hidden = True
1459
def run(self):
1460
print "it sure does!"
1461
1462
def parse_spec(spec):
1463
"""
1464
>>> parse_spec(None)
1465
[None, None]
1466
>>> parse_spec("./")
1467
['./', None]
1468
>>> parse_spec("../@")
1469
['..', -1]
1470
>>> parse_spec("../f/@35")
1471
['../f', 35]
1472
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1473
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1474
"""
1475
if spec is None:
1476
return [None, None]
1477
if '/@' in spec:
1478
parsed = spec.split('/@')
1479
assert len(parsed) == 2
1480
if parsed[1] == "":
1481
parsed[1] = -1
1482
else:
1483
try:
1484
parsed[1] = int(parsed[1])
1485
except ValueError:
1486
pass # We can allow stuff like ./@revid:blahblahblah
1487
else:
1488
assert parsed[1] >=0
1489
else:
1490
parsed = [spec, None]
1491
return parsed
1492
1493
1494
1495
class cmd_find_merge_base(Command):
1496
"""Find and print a base revision for merging two branches.
1497
1498
TODO: Options to specify revisions on either side, as if
1499
merging only part of the history.
1500
"""
1501
takes_args = ['branch', 'other']
1502
hidden = True
1503
1504
def run(self, branch, other):
1505
branch1 = find_branch(branch)
1506
branch2 = find_branch(other)
1507
1508
base_revno, base_revid = branch1.common_ancestor(branch2)
1509
1510
if base_revno is None:
1511
raise bzrlib.errors.UnrelatedBranches()
1512
1513
print 'merge base is revision %s' % base_revid
1514
print ' r%-6d in %s' % (base_revno, branch)
1515
1516
other_revno = branch2.revision_id_to_revno(base_revid)
1517
1518
print ' r%-6d in %s' % (other_revno, other)
1519
1520
1521
1522
class cmd_merge(Command):
1523
"""Perform a three-way merge.
1524
1525
The branch is the branch you will merge from. By default, it will merge
1526
the latest revision. If you specify a revision, that revision will be
1527
merged. If you specify two revisions, the first will be used as a BASE,
1528
and the second one as OTHER. Revision numbers are always relative to the
1529
specified branch.
1530
1531
Examples:
1532
1533
To merge the latest revision from bzr.dev
1534
bzr merge ../bzr.dev
1535
1536
To merge changes up to and including revision 82 from bzr.dev
1537
bzr merge -r 82 ../bzr.dev
1538
1539
To merge the changes introduced by 82, without previous changes:
1540
bzr merge -r 81..82 ../bzr.dev
1541
1542
merge refuses to run if there are any uncommitted changes, unless
1543
--force is given.
1544
"""
1545
takes_args = ['branch?']
1546
takes_options = ['revision', 'force', 'merge-type']
1547
1548
def run(self, branch='.', revision=None, force=False,
1549
merge_type=None):
1550
from bzrlib.merge import merge
1551
from bzrlib.merge_core import ApplyMerge3
1552
if merge_type is None:
1553
merge_type = ApplyMerge3
1554
1555
if revision is None or len(revision) < 1:
1556
base = (None, None)
1557
other = (branch, -1)
1558
else:
1559
if len(revision) == 1:
1560
other = (branch, revision[0])
1561
base = (None, None)
1562
else:
1563
assert len(revision) == 2
1564
if None in revision:
1565
raise BzrCommandError(
1566
"Merge doesn't permit that revision specifier.")
1567
base = (branch, revision[0])
1568
other = (branch, revision[1])
1569
1570
merge(other, base, check_clean=(not force), merge_type=merge_type)
1571
1572
1573
class cmd_revert(Command):
1574
"""Reverse all changes since the last commit.
1575
1576
Only versioned files are affected. Specify filenames to revert only
1577
those files. By default, any files that are changed will be backed up
1578
first. Backup files have a '~' appended to their name.
1579
"""
1580
takes_options = ['revision', 'no-backup']
1581
takes_args = ['file*']
1582
aliases = ['merge-revert']
1583
1584
def run(self, revision=None, no_backup=False, file_list=None):
1585
from bzrlib.merge import merge
1586
if file_list is not None:
1587
if len(file_list) == 0:
1588
raise BzrCommandError("No files specified")
1589
if revision is None:
1590
revision = [-1]
1591
elif len(revision) != 1:
1592
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1593
merge(('.', revision[0]), parse_spec('.'),
1594
check_clean=False,
1595
ignore_zero=True,
1596
backup_files=not no_backup,
1597
file_list=file_list)
1598
1599
1600
class cmd_assert_fail(Command):
1601
"""Test reporting of assertion failures"""
1602
hidden = True
1603
def run(self):
1604
assert False, "always fails"
1605
1606
1607
class cmd_help(Command):
1608
"""Show help on a command or other topic.
1609
1610
For a list of all available commands, say 'bzr help commands'."""
1611
takes_options = ['long']
1612
takes_args = ['topic?']
1613
aliases = ['?']
1614
1615
def run(self, topic=None, long=False):
1616
import help
1617
if topic is None and long:
1618
topic = "commands"
1619
help.help(topic)
1620
1621
1622
class cmd_shell_complete(Command):
1623
"""Show appropriate completions for context.
1624
1625
For a list of all available commands, say 'bzr shell-complete'."""
1626
takes_args = ['context?']
1627
aliases = ['s-c']
1628
hidden = True
1629
1630
def run(self, context=None):
1631
import shellcomplete
1632
shellcomplete.shellcomplete(context)
1633
1634
1635
class cmd_missing(Command):
1636
"""What is missing in this branch relative to other branch.
1637
"""
1638
takes_args = ['remote?']
1639
aliases = ['mis', 'miss']
1640
# We don't have to add quiet to the list, because
1641
# unknown options are parsed as booleans
1642
takes_options = ['verbose', 'quiet']
1643
1644
def run(self, remote=None, verbose=False, quiet=False):
1645
from bzrlib.branch import find_branch, DivergedBranches
1646
from bzrlib.errors import BzrCommandError
1647
from bzrlib.missing import get_parent, show_missing
1648
1649
if verbose and quiet:
1650
raise BzrCommandError('Cannot pass both quiet and verbose')
1651
1652
b = find_branch('.')
1653
parent = get_parent(b)
1654
if remote is None:
1655
if parent is None:
1656
raise BzrCommandError("No missing location known or specified.")
1657
else:
1658
if not quiet:
1659
print "Using last location: %s" % parent
1660
remote = parent
1661
elif parent is None:
1662
# We only update x-pull if it did not exist, missing should not change the parent
1663
b.controlfile('x-pull', 'wb').write(remote + '\n')
1664
br_remote = find_branch(remote)
1665
1666
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1667
1668
1669
1670
class cmd_plugins(Command):
1671
"""List plugins"""
1672
hidden = True
1673
def run(self):
1674
import bzrlib.plugin
1675
from inspect import getdoc
1676
from pprint import pprint
1677
for plugin in bzrlib.plugin.all_plugins:
1678
if hasattr(plugin, '__path__'):
1679
print plugin.__path__[0]
1680
else:
1681
print `plugin`
1682
d = getdoc(plugin)
1683
if d:
1684
print '\t', d.split('\n')[0]
1685
1686
#pprint(bzrlib.plugin.all_plugins)
1687
676
1688
677
1689
678
1690
# list of all available options; the rhs can be either None for an
680
1692
# the type.
681
1693
OPTIONS = {
682
1694
'all': None,
1695
'diff-options': str,
683
1696
'help': None,
1697
'file': unicode,
1698
'force': None,
1699
'format': unicode,
1700
'forward': None,
684
1701
'message': unicode,
1702
'no-recurse': None,
685
1703
'profile': None,
686
'revision': int,
1704
'revision': _parse_revision_str,
1705
'short': None,
687
1706
'show-ids': None,
688
1707
'timezone': str,
689
1708
'verbose': None,
690
1709
'version': None,
1710
'email': None,
1711
'unchanged': None,
1712
'update': None,
1713
'long': None,
1714
'root': str,
1715
'no-backup': None,
1716
'merge-type': get_merge_type,
691
1717
}
692
1718
693
1719
SHORT_OPTIONS = {
1720
'F': 'file',
1721
'h': 'help',
694
1722
'm': 'message',
695
1723
'r': 'revision',
696
1724
'v': 'verbose',
1725
'l': 'long',
697
1726
}
698
1727
699
# List of options that apply to particular commands; commands not
700
# listed take none.
701
cmd_options = {
702
'add': ['verbose'],
703
'commit': ['message', 'verbose'],
704
'deleted': ['show-ids'],
705
'diff': ['revision'],
706
'inventory': ['revision'],
707
'log': ['timezone'],
708
'ls': ['revision', 'verbose'],
709
'remove': ['verbose'],
710
'status': ['all'],
711
}
712
713
714
cmd_args = {
715
'add': ['file+'],
716
'commit': [],
717
'diff': [],
718
'export': ['revno', 'dest'],
719
'file-id': ['filename'],
720
'get-file-text': ['text_id'],
721
'get-inventory': ['inventory_id'],
722
'get-revision': ['revision_id'],
723
'get-revision-inventory': ['revision_id'],
724
'help': ['topic?'],
725
'init': [],
726
'log': [],
727
'lookup-revision': ['revno'],
728
'mv': ['source$', 'dest'],
729
'relpath': ['filename'],
730
'remove': ['file+'],
731
'renames': ['dir?'],
732
'root': ['filename?'],
733
'status': [],
734
}
735
736
1728
737
1729
def parse_args(argv):
738
1730
"""Parse command line.
750
1742
(['status'], {'all': True})
751
1743
>>> parse_args('commit --message=biter'.split())
752
1744
(['commit'], {'message': u'biter'})
1745
>>> parse_args('log -r 500'.split())
1746
(['log'], {'revision': [500]})
1747
>>> parse_args('log -r500..600'.split())
1748
(['log'], {'revision': [500, 600]})
1749
>>> parse_args('log -vr500..600'.split())
1750
(['log'], {'verbose': True, 'revision': [500, 600]})
1751
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1752
(['log'], {'revision': ['v500', 600]})
753
1753
"""
754
1754
args = []
755
1755
opts = {}
759
1759
while argv:
760
1760
a = argv.pop(0)
761
1761
if a[0] == '-':
1762
# option names must not be unicode
1763
a = str(a)
762
1764
optarg = None
763
1765
if a[1] == '-':
764
1766
mutter(" got option %r" % a)
767
1769
else:
768
1770
optname = a[2:]
769
1771
if optname not in OPTIONS:
770
bailout('unknown long option %r' % a)
1772
raise BzrError('unknown long option %r' % a)
771
1773
else:
772
1774
shortopt = a[1:]
773
if shortopt not in SHORT_OPTIONS:
774
bailout('unknown short option %r' % a)
775
optname = SHORT_OPTIONS[shortopt]
1775
if shortopt in SHORT_OPTIONS:
1776
# Multi-character options must have a space to delimit
1777
# their value
1778
optname = SHORT_OPTIONS[shortopt]
1779
else:
1780
# Single character short options, can be chained,
1781
# and have their value appended to their name
1782
shortopt = a[1:2]
1783
if shortopt not in SHORT_OPTIONS:
1784
# We didn't find the multi-character name, and we
1785
# didn't find the single char name
1786
raise BzrError('unknown short option %r' % a)
1787
optname = SHORT_OPTIONS[shortopt]
1788
1789
if a[2:]:
1790
# There are extra things on this option
1791
# see if it is the value, or if it is another
1792
# short option
1793
optargfn = OPTIONS[optname]
1794
if optargfn is None:
1795
# This option does not take an argument, so the
1796
# next entry is another short option, pack it back
1797
# into the list
1798
argv.insert(0, '-' + a[2:])
1799
else:
1800
# This option takes an argument, so pack it
1801
# into the array
1802
optarg = a[2:]
776
1803
777
1804
if optname in opts:
778
1805
# XXX: Do we ever want to support this, e.g. for -r?
779
bailout('repeated option %r' % a)
1806
raise BzrError('repeated option %r' % a)
780
1807
781
1808
optargfn = OPTIONS[optname]
782
1809
if optargfn:
783
1810
if optarg == None:
784
1811
if not argv:
785
bailout('option %r needs an argument' % a)
1812
raise BzrError('option %r needs an argument' % a)
786
1813
else:
787
1814
optarg = argv.pop(0)
788
1815
opts[optname] = optargfn(optarg)
789
1816
else:
790
1817
if optarg != None:
791
bailout('option %r takes no argument' % optname)
1818
raise BzrError('option %r takes no argument' % optname)
792
1819
opts[optname] = True
793
1820
else:
794
1821
args.append(a)
797
1824
798
1825
799
1826
800
def _match_args(cmd, args):
801
"""Check non-option arguments match required pattern.
802
1827
803
>>> _match_args('status', ['asdasdsadasd'])
804
Traceback (most recent call last):
805
...
806
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
807
>>> _match_args('add', ['asdasdsadasd'])
808
{'file_list': ['asdasdsadasd']}
809
>>> _match_args('add', 'abc def gj'.split())
810
{'file_list': ['abc', 'def', 'gj']}
811
"""
812
# match argument pattern
813
argform = cmd_args.get(cmd, [])
1828
def _match_argform(cmd, takes_args, args):
814
1829
argdict = {}
815
# TODO: Need a way to express 'cp SRC... DEST', where it matches
816
# all but one.
817
1830
818
# step through args and argform, allowing appropriate 0-many matches
819
for ap in argform:
1831
# step through args and takes_args, allowing appropriate 0-many matches
1832
for ap in takes_args:
820
1833
argname = ap[:-1]
821
1834
if ap[-1] == '?':
822
1835
if args:
823
1836
argdict[argname] = args.pop(0)
824
elif ap[-1] == '*':
825
assert 0
1837
elif ap[-1] == '*': # all remaining arguments
1838
if args:
1839
argdict[argname + '_list'] = args[:]
1840
args = []
1841
else:
1842
argdict[argname + '_list'] = None
826
1843
elif ap[-1] == '+':
827
1844
if not args:
828
bailout("command %r needs one or more %s"
1845
raise BzrCommandError("command %r needs one or more %s"
829
1846
% (cmd, argname.upper()))
830
1847
else:
831
1848
argdict[argname + '_list'] = args[:]
832
1849
args = []
833
1850
elif ap[-1] == '$': # all but one
834
1851
if len(args) < 2:
835
bailout("command %r needs one or more %s"
1852
raise BzrCommandError("command %r needs one or more %s"
836
1853
% (cmd, argname.upper()))
837
1854
argdict[argname + '_list'] = args[:-1]
838
1855
args[:-1] = []
840
1857
# just a plain arg
841
1858
argname = ap
842
1859
if not args:
843
bailout("command %r requires argument %s"
1860
raise BzrCommandError("command %r requires argument %s"
844
1861
% (cmd, argname.upper()))
845
1862
else:
846
1863
argdict[argname] = args.pop(0)
847
1864
848
1865
if args:
849
bailout("extra arguments to command %s: %r"
850
% (cmd, args))
1866
raise BzrCommandError("extra argument to command %s: %s"
1867
% (cmd, args[0]))
851
1868
852
1869
return argdict
853
1870
857
1874
"""Execute a command.
858
1875
859
1876
This is similar to main(), but without all the trappings for
860
logging and error handling.
1877
logging and error handling.
1878
1879
argv
1880
The command-line arguments, without the program name from argv[0]
1881
1882
Returns a command status or raises an exception.
1883
1884
Special master options: these must come before the command because
1885
they control how the command is interpreted.
1886
1887
--no-plugins
1888
Do not load plugin modules at all
1889
1890
--builtin
1891
Only use builtin commands. (Plugins are still allowed to change
1892
other behaviour.)
1893
1894
--profile
1895
Run under the Python profiler.
861
1896
"""
862
try:
863
args, opts = parse_args(argv[1:])
864
if 'help' in opts:
865
# TODO: pass down other arguments in case they asked for
866
# help on a command name?
867
if args:
868
cmd_help(args[0])
869
else:
870
cmd_help()
871
return 0
872
elif 'version' in opts:
873
cmd_version()
874
return 0
875
cmd = args.pop(0)
876
except IndexError:
877
log_error('usage: bzr COMMAND\n')
878
log_error(' try "bzr help"\n')
879
return 1
880
881
try:
882
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
883
except KeyError:
884
bailout("unknown command " + `cmd`)
885
886
# global option
887
if 'profile' in opts:
888
profile = True
889
del opts['profile']
890
else:
891
profile = False
1897
1898
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1899
1900
opt_profile = opt_no_plugins = opt_builtin = False
1901
1902
# --no-plugins is handled specially at a very early stage. We need
1903
# to load plugins before doing other command parsing so that they
1904
# can override commands, but this needs to happen first.
1905
1906
for a in argv[:]:
1907
if a == '--profile':
1908
opt_profile = True
1909
elif a == '--no-plugins':
1910
opt_no_plugins = True
1911
elif a == '--builtin':
1912
opt_builtin = True
1913
else:
1914
break
1915
argv.remove(a)
1916
1917
if not opt_no_plugins:
1918
from bzrlib.plugin import load_plugins
1919
load_plugins()
1920
1921
args, opts = parse_args(argv)
1922
1923
if 'help' in opts:
1924
from bzrlib.help import help
1925
if args:
1926
help(args[0])
1927
else:
1928
help()
1929
return 0
1930
1931
if 'version' in opts:
1932
show_version()
1933
return 0
1934
1935
if not args:
1936
from bzrlib.help import help
1937
help(None)
1938
return 0
1939
1940
cmd = str(args.pop(0))
1941
1942
canonical_cmd, cmd_class = \
1943
get_cmd_class(cmd, plugins_override=not opt_builtin)
892
1944
893
1945
# check options are reasonable
894
allowed = cmd_options.get(cmd, [])
1946
allowed = cmd_class.takes_options
895
1947
for oname in opts:
896
1948
if oname not in allowed:
897
bailout("option %r is not allowed for command %r"
898
% (oname, cmd))
1949
raise BzrCommandError("option '--%s' is not allowed for command %r"
1950
% (oname, cmd))
899
1951
900
1952
# mix arguments and options into one dictionary
901
cmdargs = _match_args(cmd, args)
1953
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1954
cmdopts = {}
902
1955
for k, v in opts.items():
903
cmdargs[k.replace('-', '_')] = v
904
905
if profile:
906
import hotshot
907
prof = hotshot.Profile('.bzr.profile')
908
ret = prof.runcall(cmd_handler, **cmdargs) or 0
909
prof.close()
910
911
import hotshot.stats
912
stats = hotshot.stats.load('.bzr.profile')
913
#stats.strip_dirs()
914
stats.sort_stats('time')
915
stats.print_stats(20)
1956
cmdopts[k.replace('-', '_')] = v
1957
1958
if opt_profile:
1959
import hotshot, tempfile
1960
pffileno, pfname = tempfile.mkstemp()
1961
try:
1962
prof = hotshot.Profile(pfname)
1963
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1964
prof.close()
1965
1966
import hotshot.stats
1967
stats = hotshot.stats.load(pfname)
1968
#stats.strip_dirs()
1969
stats.sort_stats('time')
1970
## XXX: Might like to write to stderr or the trace file instead but
1971
## print_stats seems hardcoded to stdout
1972
stats.print_stats(20)
1973
1974
return ret.status
1975
1976
finally:
1977
os.close(pffileno)
1978
os.remove(pfname)
916
1979
else:
917
return cmd_handler(**cmdargs) or 0
918
1980
return cmd_class(cmdopts, cmdargs).status
919
1981
920
1982
921
1983
def main(argv):
922
## TODO: Handle command-line options; probably know what options are valid for
923
## each command
924
925
## TODO: If the arguments are wrong, give a usage message rather
926
## than just a backtrace.
927
928
bzrlib.trace.create_tracefile(argv)
1984
import bzrlib.ui
929
1985
1986
bzrlib.trace.log_startup(argv)
1987
1988
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1989
930
1990
try:
931
ret = run_bzr(argv)
932
return ret
1991
try:
1992
return run_bzr(argv[1:])
1993
finally:
1994
# do this here inside the exception wrappers to catch EPIPE
1995
sys.stdout.flush()
1996
except BzrCommandError, e:
1997
# command line syntax error, etc
1998
log_error(str(e))
1999
return 1
933
2000
except BzrError, e:
934
log_error('bzr: error: ' + e.args[0] + '\n')
935
if len(e.args) > 1:
936
for h in e.args[1]:
937
log_error(' ' + h + '\n')
2001
bzrlib.trace.log_exception()
938
2002
return 1
2003
except AssertionError, e:
2004
bzrlib.trace.log_exception('assertion failed: ' + str(e))
2005
return 3
2006
except KeyboardInterrupt, e:
2007
bzrlib.trace.note('interrupted')
2008
return 2
939
2009
except Exception, e:
940
log_error('bzr: exception: %s\n' % e)
941
log_error(' see .bzr.log for details\n')
942
traceback.print_exc(None, bzrlib.trace._tracefile)
943
traceback.print_exc(None, sys.stderr)
944
return 1
945
946
# TODO: Maybe nicer handling of IOError?
947
2010
import errno
2011
if (isinstance(e, IOError)
2012
and hasattr(e, 'errno')
2013
and e.errno == errno.EPIPE):
2014
bzrlib.trace.note('broken pipe')
2015
return 2
2016
else:
2017
bzrlib.trace.log_exception()
2018
return 2
948
2019
949
2020
950
2021
if __name__ == '__main__':
951
2022
sys.exit(main(sys.argv))
952
##import profile
953
##profile.run('main(sys.argv)')
954
Loggerhead is a web-based interface for Breezy
Version: 2.0.1