« back to all changes in this revision
Viewing changes to bzr.py
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:08:15 UTC
- Revision ID: mbp@sourcefrog.net-20050309040815-13242001617e4a06
import from baz patch-364
- files added:
- bzrlib/tests.py
- files removed:
- .bzrignore
- contrib
- contrib/bash
- contrib/zsh
- doc
- elementtree
- notes
- patches
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
added
removed
bzr.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
#! /usr/bin/python
2
3
4
# Copyright (C) 2004, 2005 by Martin Pool
5
# Copyright (C) 2005 by Canonical Ltd
6
2
7
3
8
# This program is free software; you can redistribute it and/or modify
4
9
# it under the terms of the GNU General Public License as published by
14
19
# along with this program; if not, write to the Free Software
15
20
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
21
17
18
19
import sys, os
22
"""Bazaar-NG -- a free distributed version-control tool
23
24
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
25
26
Current limitation include:
27
28
* Metadata format is not stable yet -- you may need to
29
discard history in the future.
30
31
* No handling of subdirectories, symlinks or any non-text files.
32
33
* Insufficient error handling.
34
35
* Many commands unimplemented or partially implemented.
36
37
* Space-inefficient storage.
38
39
* No merge operators yet.
40
41
Interesting commands::
42
43
bzr help
44
Show summary help screen
45
bzr version
46
Show software version/licence/non-warranty.
47
bzr init
48
Start versioning the current directory
49
bzr add FILE...
50
Make files versioned.
51
bzr log
52
Show revision history.
53
bzr diff
54
Show changes from last revision to working copy.
55
bzr commit -m 'MESSAGE'
56
Store current state as new revision.
57
bzr export REVNO DESTINATION
58
Export the branch state at a previous version.
59
bzr status
60
Show summary of pending changes.
61
bzr remove FILE...
62
Make a file not versioned.
63
"""
64
65
# not currently working:
66
# bzr check
67
# Run internal consistency checks.
68
# bzr info
69
# Show some information about this branch.
70
71
72
73
__copyright__ = "Copyright 2005 Canonical Development Ltd."
74
__author__ = "Martin Pool <mbp@canonical.com>"
75
__docformat__ = "restructuredtext en"
76
__version__ = '0.0.0'
77
78
79
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
80
import traceback, socket, fnmatch, difflib
81
from os import path
82
from sets import Set
83
from pprint import pprint
84
from stat import *
85
from glob import glob
86
from ElementTree import Element, ElementTree, SubElement
20
87
21
88
import bzrlib
89
from bzrlib.store import ImmutableStore
22
90
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, \
91
from bzrlib.errors import bailout, BzrError
92
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
93
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
94
from bzrlib.revision import Revision
95
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
26
96
format_date
27
97
28
29
def _squish_command_name(cmd):
30
return 'cmd_' + cmd.replace('-', '_')
31
32
33
def _unsquish_command_name(cmd):
34
assert cmd.startswith("cmd_")
35
return cmd[4:].replace('_','-')
36
37
def _parse_revision_str(revstr):
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' -> ?
52
"""
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)
69
return revs
70
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):
144
d = {}
145
for k, v in globals().iteritems():
146
if k.startswith("cmd_"):
147
d[_unsquish_command_name(k)] = v
148
if include_plugins:
149
d.update(_find_plugins())
150
return d
151
152
def get_all_cmds(include_plugins=True):
153
"""Return canonical name and class for all registered commands."""
154
for k, v in _get_cmd_dict(include_plugins=include_plugins).iteritems():
155
yield k,v
156
157
158
def get_cmd_class(cmd,include_plugins=True):
159
"""Return the canonical name and command class for a command.
160
"""
161
cmd = str(cmd) # not unicode
162
163
# first look up this command under the specified name
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
165
try:
166
return cmd, cmds[cmd]
167
except KeyError:
168
pass
169
170
# look for any command which claims this as an alias
171
for cmdname, cmdclass in cmds.iteritems():
172
if cmd in cmdclass.aliases:
173
return cmdname, cmdclass
174
175
cmdclass = ExternalCommand.find_command(cmd)
176
if cmdclass:
177
return cmd, cmdclass
178
179
raise BzrCommandError("unknown command %r" % cmd)
180
181
182
class Command(object):
183
"""Base class for commands.
184
185
The docstring for an actual command should give a single-line
186
summary, then a complete description of the command. A grammar
187
description will be inserted.
188
189
takes_args
190
List of argument forms, marked with whether they are optional,
191
repeated, etc.
192
193
takes_options
194
List of options that may be given for this command.
195
196
hidden
197
If true, this command isn't advertised.
198
"""
199
aliases = []
200
201
takes_args = []
202
takes_options = []
203
204
hidden = False
205
206
def __init__(self, options, arguments):
207
"""Construct and run the command.
208
209
Sets self.status to the return value of run()."""
210
assert isinstance(options, dict)
211
assert isinstance(arguments, dict)
212
cmdargs = options.copy()
213
cmdargs.update(arguments)
214
assert self.__doc__ != Command.__doc__, \
215
("No help message set for %r" % self)
216
self.status = self.run(**cmdargs)
217
218
219
def run(self):
220
"""Override this in sub-classes.
221
222
This is invoked with the options and arguments bound to
223
keyword parameters.
224
225
Return 0 or None if the command was successful, or a shell
226
error code if not.
227
"""
228
return 0
229
230
231
class ExternalCommand(Command):
232
"""Class to wrap external commands.
233
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.
244
"""
245
246
def find_command(cls, cmd):
247
import os.path
248
bzrpath = os.environ.get('BZRPATH', '')
249
250
for dir in bzrpath.split(os.pathsep):
251
path = os.path.join(dir, cmd)
252
if os.path.isfile(path):
253
return ExternalCommand(path)
254
255
return None
256
257
find_command = classmethod(find_command)
258
259
def __init__(self, path):
260
self.path = path
261
262
# TODO: If either of these fail, we should detect that and
263
# assume that path is not really a bzr plugin after all.
264
265
pipe = os.popen('%s --bzr-usage' % path, 'r')
266
self.takes_options = pipe.readline().split()
267
self.takes_args = pipe.readline().split()
268
pipe.close()
269
270
pipe = os.popen('%s --bzr-help' % path, 'r')
271
self.__doc__ = pipe.read()
272
pipe.close()
273
274
def __call__(self, options, arguments):
275
Command.__init__(self, options, arguments)
276
return self
277
278
def run(self, **kargs):
279
opts = []
280
args = []
281
282
keys = kargs.keys()
283
keys.sort()
284
for name in keys:
285
value = kargs[name]
286
if OPTIONS.has_key(name):
287
# it's an option
288
opts.append('--%s' % name)
289
if value is not None and value is not True:
290
opts.append(str(value))
291
else:
292
# it's an arg, or arg list
293
if type(value) is not list:
294
value = [value]
295
for v in value:
296
if v is not None:
297
args.append(str(v))
298
299
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
300
return self.status
301
302
303
class cmd_status(Command):
98
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
99
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
100
101
## standard representation
102
NONE_STRING = '(none)'
103
EMPTY = 'empty'
104
105
106
## TODO: Perhaps a different version of inventory commands that
107
## returns iterators...
108
109
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
110
111
## TODO: Some kind of locking on branches. Perhaps there should be a
112
## parameter to the branch object saying whether we want a read or
113
## write lock; release it from destructor. Perhaps don't even need a
114
## read lock to look at immutable objects?
115
116
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
117
## to compare output?
118
119
## TODO: Is ElementTree really all that much better for our purposes?
120
## Perhaps using the standard MiniDOM would be enough?
121
122
123
124
125
126
127
######################################################################
128
# check status
129
130
131
def cmd_status(all=False):
304
132
"""Display status summary.
305
133
306
This reports on versioned and unknown files, reporting them
307
grouped by state. Possible states are:
308
309
added
310
Versioned in the working copy but not in the previous revision.
311
312
removed
313
Versioned in the previous revision but removed or deleted
314
in the working copy.
315
316
renamed
317
Path of this file changed from the previous revision;
318
the text may also have changed. This includes files whose
319
parent directory was renamed.
320
321
modified
322
Text has changed since the previous revision.
323
324
unchanged
325
Nothing about this file has changed since the previous revision.
326
Only shown with --all.
327
328
unknown
329
Not versioned and not matching an ignore pattern.
330
331
To see ignored files use 'bzr ignored'. For details in the
332
changes to file texts, use 'bzr diff'.
333
334
If no arguments are specified, the status of the entire working
335
directory is shown. Otherwise, only the status of the specified
336
files or directories is reported. If a directory is given, status
337
is reported for everything inside that directory.
338
"""
339
takes_args = ['file*']
340
takes_options = ['all', 'show-ids']
341
aliases = ['st', 'stat']
342
343
def run(self, all=False, show_ids=False, file_list=None):
344
if file_list:
345
b = Branch(file_list[0])
346
file_list = [b.relpath(x) for x in file_list]
347
# special case: only one path was given and it's the root
348
# of the branch
349
if file_list == ['']:
350
file_list = None
351
else:
352
b = Branch('.')
353
import status
354
status.show_status(b, show_unchanged=all, show_ids=show_ids,
355
specific_files=file_list)
356
357
358
class cmd_cat_revision(Command):
359
"""Write out metadata for a revision."""
360
361
hidden = True
362
takes_args = ['revision_id']
363
364
def run(self, revision_id):
365
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
366
367
368
class cmd_revno(Command):
369
"""Show current revision number.
370
371
This is equal to the number of revisions on this branch."""
372
def run(self):
373
print Branch('.').revno()
374
375
376
class cmd_add(Command):
377
"""Add specified files or directories.
378
379
In non-recursive mode, all the named items are added, regardless
380
of whether they were previously ignored. A warning is given if
381
any of the named files are already versioned.
382
383
In recursive mode (the default), files are treated the same way
384
but the behaviour for directories is different. Directories that
385
are already versioned do not give a warning. All directories,
386
whether already versioned or not, are searched for files or
387
subdirectories that are neither versioned or ignored, and these
388
are added. This search proceeds recursively into versioned
389
directories.
390
391
Therefore simply saying 'bzr add .' will version all files that
392
are currently unknown.
393
394
TODO: Perhaps adding a file whose directly is not versioned should
395
recursively add that parent, rather than giving an error?
396
"""
397
takes_args = ['file+']
398
takes_options = ['verbose', 'no-recurse']
399
400
def run(self, file_list, verbose=False, no_recurse=False):
401
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
402
403
404
class cmd_relpath(Command):
405
"""Show path of a file relative to root"""
406
takes_args = ['filename']
407
hidden = True
408
409
def run(self, filename):
410
print Branch(filename).relpath(filename)
411
412
413
414
class cmd_inventory(Command):
415
"""Show inventory of the current working copy or a revision."""
416
takes_options = ['revision', 'show-ids']
417
418
def run(self, revision=None, show_ids=False):
419
b = Branch('.')
420
if revision == None:
421
inv = b.read_working_inventory()
422
else:
423
inv = b.get_revision_inventory(b.lookup_revision(revision))
424
425
for path, entry in inv.entries():
426
if show_ids:
427
print '%-50s %s' % (path, entry.file_id)
428
else:
429
print path
430
431
432
class cmd_move(Command):
433
"""Move files to a different directory.
434
435
examples:
436
bzr move *.txt doc
437
438
The destination must be a versioned directory in the same branch.
439
"""
440
takes_args = ['source$', 'dest']
441
def run(self, source_list, dest):
442
b = Branch('.')
443
444
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
445
446
447
class cmd_rename(Command):
448
"""Change the name of an entry.
449
450
examples:
451
bzr rename frob.c frobber.c
452
bzr rename src/frob.c lib/frob.c
453
454
It is an error if the destination name exists.
455
456
See also the 'move' command, which moves files into a different
457
directory without changing their name.
458
459
TODO: Some way to rename multiple files without invoking bzr for each
460
one?"""
461
takes_args = ['from_name', 'to_name']
462
463
def run(self, from_name, to_name):
464
b = Branch('.')
465
b.rename_one(b.relpath(from_name), b.relpath(to_name))
466
467
468
469
470
471
class cmd_pull(Command):
472
"""Pull any changes from another branch into the current one.
473
474
If the location is omitted, the last-used location will be used.
475
Both the revision history and the working directory will be
476
updated.
477
478
This command only works on branches that have not diverged. Branches are
479
considered diverged if both branches have had commits without first
480
pulling from the other.
481
482
If branches have diverged, you can use 'bzr merge' to pull the text changes
483
from one into the other.
484
"""
485
takes_args = ['location?']
486
487
def run(self, location=None):
488
from bzrlib.merge import merge
489
import errno
490
491
br_to = Branch('.')
492
stored_loc = None
493
try:
494
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
495
except IOError, e:
496
if errno == errno.ENOENT:
497
raise
498
if location is None:
499
location = stored_loc
500
if location is None:
501
raise BzrCommandError("No pull location known or specified.")
502
from branch import find_branch, DivergedBranches
503
br_from = find_branch(location)
504
location = pull_loc(br_from)
505
old_revno = br_to.revno()
506
try:
507
br_to.update_revisions(br_from)
508
except DivergedBranches:
509
raise BzrCommandError("These branches have diverged. Try merge.")
510
511
merge(('.', -1), ('.', old_revno), check_clean=False)
512
if location != stored_loc:
513
br_to.controlfile("x-pull", "wb").write(location + "\n")
514
515
516
517
class cmd_branch(Command):
518
"""Create a new copy of a branch.
519
520
If the TO_LOCATION is omitted, the last component of the
521
FROM_LOCATION will be used. In other words,
522
"branch ../foo/bar" will attempt to create ./bar.
523
"""
524
takes_args = ['from_location', 'to_location?']
525
526
def run(self, from_location, to_location=None):
527
import errno
528
from bzrlib.merge import merge
529
530
if to_location is None:
531
to_location = os.path.basename(from_location)
532
# FIXME: If there's a trailing slash, keep removing them
533
# until we find the right bit
534
535
try:
536
os.mkdir(to_location)
537
except OSError, e:
538
if e.errno == errno.EEXIST:
539
raise BzrCommandError('Target directory "%s" already exists.' %
540
to_location)
541
if e.errno == errno.ENOENT:
542
raise BzrCommandError('Parent of "%s" does not exist.' %
543
to_location)
544
else:
545
raise
546
br_to = Branch(to_location, init=True)
547
from branch import find_branch, DivergedBranches
548
try:
549
br_from = find_branch(from_location)
550
except OSError, e:
551
if e.errno == errno.ENOENT:
552
raise BzrCommandError('Source location "%s" does not exist.' %
553
to_location)
554
else:
555
raise
556
557
from_location = pull_loc(br_from)
558
br_to.update_revisions(br_from)
559
merge((to_location, -1), (to_location, 0), this_dir=to_location,
560
check_clean=False)
561
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
562
563
564
def pull_loc(branch):
565
# TODO: Should perhaps just make attribute be 'base' in
566
# RemoteBranch and Branch?
567
if hasattr(branch, "baseurl"):
568
return branch.baseurl
569
else:
570
return branch.base
571
572
573
574
class cmd_renames(Command):
575
"""Show list of renamed files.
576
577
TODO: Option to show renames between two historical versions.
578
579
TODO: Only show renames under dir, rather than in the whole branch.
580
"""
581
takes_args = ['dir?']
582
583
def run(self, dir='.'):
584
b = Branch(dir)
585
old_inv = b.basis_tree().inventory
586
new_inv = b.read_working_inventory()
587
588
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
589
renames.sort()
590
for old_name, new_name in renames:
591
print "%s => %s" % (old_name, new_name)
592
593
594
class cmd_info(Command):
595
"""Show statistical information about a branch."""
596
takes_args = ['branch?']
597
598
def run(self, branch=None):
599
import info
600
601
from branch import find_branch
602
b = find_branch(branch)
603
info.show_info(b)
604
605
606
class cmd_remove(Command):
607
"""Make a file unversioned.
608
609
This makes bzr stop tracking changes to a versioned file. It does
610
not delete the working copy.
611
"""
612
takes_args = ['file+']
613
takes_options = ['verbose']
614
615
def run(self, file_list, verbose=False):
616
b = Branch(file_list[0])
617
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
618
619
620
class cmd_file_id(Command):
621
"""Print file_id of a particular file or directory.
622
623
The file_id is assigned when the file is first added and remains the
624
same through all revisions where the file exists, even when it is
625
moved or renamed.
626
"""
627
hidden = True
628
takes_args = ['filename']
629
def run(self, filename):
630
b = Branch(filename)
631
i = b.inventory.path2id(b.relpath(filename))
632
if i == None:
633
bailout("%r is not a versioned file" % filename)
634
else:
635
print i
636
637
638
class cmd_file_path(Command):
639
"""Print path of file_ids to a file or directory.
640
641
This prints one line for each directory down to the target,
642
starting at the branch root."""
643
hidden = True
644
takes_args = ['filename']
645
def run(self, filename):
646
b = Branch(filename)
647
inv = b.inventory
648
fid = inv.path2id(b.relpath(filename))
649
if fid == None:
650
bailout("%r is not a versioned file" % filename)
651
for fip in inv.get_idpath(fid):
652
print fip
653
654
655
class cmd_revision_history(Command):
656
"""Display list of revision ids on this branch."""
657
hidden = True
658
def run(self):
659
for patchid in Branch('.').revision_history():
660
print patchid
661
662
663
class cmd_directories(Command):
664
"""Display list of versioned directories in this branch."""
665
def run(self):
666
for name, ie in Branch('.').read_working_inventory().directories():
667
if name == '':
668
print '.'
669
else:
670
print name
671
672
673
class cmd_init(Command):
674
"""Make a directory into a versioned branch.
675
676
Use this to create an empty branch, or before importing an
677
existing project.
678
679
Recipe for importing a tree of files:
680
cd ~/project
681
bzr init
682
bzr add -v .
683
bzr status
684
bzr commit -m 'imported project'
685
"""
686
def run(self):
687
Branch('.', init=True)
688
689
690
class cmd_diff(Command):
691
"""Show differences in working tree.
692
693
If files are listed, only the changes in those files are listed.
694
Otherwise, all changes for the tree are listed.
695
696
TODO: Given two revision arguments, show the difference between them.
697
698
TODO: Allow diff across branches.
699
700
TODO: Option to use external diff command; could be GNU diff, wdiff,
701
or a graphical diff.
702
703
TODO: Python difflib is not exactly the same as unidiff; should
704
either fix it up or prefer to use an external diff.
705
706
TODO: If a directory is given, diff everything under that.
707
708
TODO: Selected-file diff is inefficient and doesn't show you
709
deleted files.
710
711
TODO: This probably handles non-Unix newlines poorly.
712
"""
713
714
takes_args = ['file*']
715
takes_options = ['revision', 'diff-options']
716
aliases = ['di', 'dif']
717
718
def run(self, revision=None, file_list=None, diff_options=None):
719
from bzrlib.diff import show_diff
720
from bzrlib import find_branch
721
722
if file_list:
723
b = find_branch(file_list[0])
724
file_list = [b.relpath(f) for f in file_list]
725
if file_list == ['']:
726
# just pointing to top-of-tree
727
file_list = None
728
else:
729
b = Branch('.')
730
731
show_diff(b, revision, specific_files=file_list,
732
external_diff_options=diff_options)
733
734
735
736
737
738
class cmd_deleted(Command):
739
"""List files deleted in the working tree.
740
741
TODO: Show files deleted since a previous revision, or between two revisions.
742
"""
743
def run(self, show_ids=False):
744
b = Branch('.')
745
old = b.basis_tree()
746
new = b.working_tree()
747
748
## TODO: Much more efficient way to do this: read in new
749
## directories with readdir, rather than stating each one. Same
750
## level of effort but possibly much less IO. (Or possibly not,
751
## if the directories are very large...)
752
753
for path, ie in old.inventory.iter_entries():
754
if not new.has_id(ie.file_id):
755
if show_ids:
756
print '%-50s %s' % (path, ie.file_id)
757
else:
758
print path
759
760
761
class cmd_modified(Command):
762
"""List files modified in working tree."""
763
hidden = True
764
def run(self):
765
import statcache
766
b = Branch('.')
134
For each file there is a single line giving its file state and name.
135
The name is that in the current revision unless it is deleted or
136
missing, in which case the old name is shown.
137
138
:todo: Don't show unchanged files unless ``--all`` is given?
139
"""
140
Branch('.').show_status(show_all=all)
141
142
143
144
######################################################################
145
# examining history
146
def cmd_get_revision(revision_id):
147
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
148
149
150
def cmd_get_inventory(inventory_id):
151
"""Return inventory in XML by hash"""
152
Branch('.').get_inventory(inventory_hash).write_xml(sys.stdout)
153
154
155
def cmd_get_revision_inventory(revision_id):
156
"""Output inventory for a revision."""
157
b = Branch('.')
158
b.get_revision_inventory(revision_id).write_xml(sys.stdout)
159
160
161
def cmd_get_file_text(text_id):
162
"""Get contents of a file by hash."""
163
sf = Branch('.').text_store[text_id]
164
pumpfile(sf, sys.stdout)
165
166
167
168
######################################################################
169
# commands
170
171
172
def cmd_revno():
173
"""Show number of revisions on this branch"""
174
print Branch('.').revno()
175
176
177
def cmd_add(file_list, verbose=False):
178
"""Add specified files.
179
180
Fails if the files are already added.
181
"""
182
Branch('.').add(file_list, verbose=verbose)
183
184
185
def cmd_inventory(revision=None):
186
"""Show inventory of the current working copy."""
187
## TODO: Also optionally show a previous inventory
188
## TODO: Format options
189
b = Branch('.')
190
if revision == None:
767
191
inv = b.read_working_inventory()
768
sc = statcache.update_cache(b, inv)
769
basis = b.basis_tree()
770
basis_inv = basis.inventory
771
772
# We used to do this through iter_entries(), but that's slow
773
# when most of the files are unmodified, as is usually the
774
# case. So instead we iterate by inventory entry, and only
775
# calculate paths as necessary.
776
777
for file_id in basis_inv:
778
cacheentry = sc.get(file_id)
779
if not cacheentry: # deleted
780
continue
781
ie = basis_inv[file_id]
782
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
783
path = inv.id2path(file_id)
784
print path
785
786
787
788
class cmd_added(Command):
789
"""List files added in working tree."""
790
hidden = True
791
def run(self):
792
b = Branch('.')
793
wt = b.working_tree()
794
basis_inv = b.basis_tree().inventory
795
inv = wt.inventory
796
for file_id in inv:
797
if file_id in basis_inv:
798
continue
799
path = inv.id2path(file_id)
800
if not os.access(b.abspath(path), os.F_OK):
801
continue
802
print path
803
804
805
806
class cmd_root(Command):
807
"""Show the tree root directory.
808
809
The root is the nearest enclosing directory with a .bzr control
810
directory."""
811
takes_args = ['filename?']
812
def run(self, filename=None):
813
"""Print the branch root."""
814
from branch import find_branch
815
b = find_branch(filename)
816
print getattr(b, 'base', None) or getattr(b, 'baseurl')
817
818
819
class cmd_log(Command):
192
else:
193
inv = b.get_revision_inventory(b.lookup_revision(revision))
194
195
for path, entry in inv.iter_entries():
196
print '%-50s %s' % (entry.file_id, path)
197
198
199
200
def cmd_info():
201
b = Branch('.')
202
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
203
print 'revision number:', b.revno()
204
print 'number of versioned files:', len(b.read_working_inventory())
205
206
207
def cmd_remove(file_list, verbose=False):
208
Branch('.').remove(file_list, verbose=verbose)
209
210
211
212
def cmd_file_id(filename):
213
i = Branch('.').read_working_inventory().path2id(filename)
214
if i is None:
215
bailout("%s is not a versioned file" % filename)
216
else:
217
print i
218
219
220
def cmd_find_filename(fileid):
221
n = find_filename(fileid)
222
if n is None:
223
bailout("%s is not a live file id" % fileid)
224
else:
225
print n
226
227
228
def cmd_revision_history():
229
for patchid in Branch('.').revision_history():
230
print patchid
231
232
233
234
def cmd_init():
235
# TODO: Check we're not already in a working directory? At the
236
# moment you'll get an ugly error.
237
238
# TODO: What if we're in a subdirectory of a branch? Would like
239
# to allow that, but then the parent may need to understand that
240
# the children have disappeared, or should they be versioned in
241
# both?
242
243
# TODO: Take an argument/option for branch name.
244
Branch('.', init=True)
245
246
247
def cmd_diff(revision=None):
248
"""Show diff from basis to working copy.
249
250
:todo: Take one or two revision arguments, look up those trees,
251
and diff them.
252
253
:todo: Allow diff across branches.
254
255
:todo: Mangle filenames in diff to be more relevant.
256
257
:todo: Shouldn't be in the cmd function.
258
"""
259
260
b = Branch('.')
261
262
if revision == None:
263
old_tree = b.basis_tree()
264
else:
265
old_tree = b.revision_tree(b.lookup_revision(revision))
266
267
new_tree = b.working_tree()
268
old_inv = old_tree.inventory
269
new_inv = new_tree.inventory
270
271
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
272
old_label = ''
273
new_label = ''
274
275
DEVNULL = '/dev/null'
276
# Windows users, don't panic about this filename -- it is a
277
# special signal to GNU patch that the file should be created or
278
# deleted respectively.
279
280
# TODO: Generation of pseudo-diffs for added/deleted files could
281
# be usefully made into a much faster special case.
282
283
# TODO: Better to return them in sorted order I think.
284
285
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
286
d = None
287
288
# Don't show this by default; maybe do it if an option is passed
289
# idlabel = ' {%s}' % fid
290
idlabel = ''
291
292
# FIXME: Something about the diff format makes patch unhappy
293
# with newly-added files.
294
295
def diffit(*a, **kw):
296
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
297
print
298
299
if file_state in ['.', '?', 'I']:
300
continue
301
elif file_state == 'A':
302
print '*** added %s %r' % (kind, new_name)
303
if kind == 'file':
304
diffit([],
305
new_tree.get_file(fid).readlines(),
306
fromfile=DEVNULL,
307
tofile=new_label + new_name + idlabel)
308
elif file_state == 'D':
309
assert isinstance(old_name, types.StringTypes)
310
print '*** deleted %s %r' % (kind, old_name)
311
if kind == 'file':
312
diffit(old_tree.get_file(fid).readlines(), [],
313
fromfile=old_label + old_name + idlabel,
314
tofile=DEVNULL)
315
elif file_state in ['M', 'R']:
316
if file_state == 'M':
317
assert kind == 'file'
318
assert old_name == new_name
319
print '*** modified %s %r' % (kind, new_name)
320
elif file_state == 'R':
321
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
322
323
if kind == 'file':
324
diffit(old_tree.get_file(fid).readlines(),
325
new_tree.get_file(fid).readlines(),
326
fromfile=old_label + old_name + idlabel,
327
tofile=new_label + new_name)
328
else:
329
bailout("can't represent state %s {%s}" % (file_state, fid))
330
331
332
333
def cmd_log():
820
334
"""Show log of this branch.
821
335
822
To request a range of logs, you can use the command -r begin:end
823
-r revision requests a specific revision, -r :end or -r begin: are
824
also valid.
825
826
TODO: Make --revision support uuid: and hash: [future tag:] notation.
827
336
:todo: Options for utc; to show ids; to limit range; etc.
828
337
"""
829
830
takes_args = ['filename?']
831
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
832
833
def run(self, filename=None, timezone='original',
834
verbose=False,
835
show_ids=False,
836
forward=False,
837
revision=None):
838
from bzrlib import show_log, find_branch
839
import codecs
840
841
direction = (forward and 'forward') or 'reverse'
842
843
if filename:
844
b = find_branch(filename)
845
fp = b.relpath(filename)
846
if fp:
847
file_id = b.read_working_inventory().path2id(fp)
848
else:
849
file_id = None # points to branch root
850
else:
851
b = find_branch('.')
852
file_id = None
853
854
if revision == None:
855
revision = [None, None]
856
elif isinstance(revision, int):
857
revision = [revision, revision]
858
else:
859
# pair of revisions?
860
pass
861
862
assert len(revision) == 2
863
864
mutter('encoding log as %r' % bzrlib.user_encoding)
865
866
# use 'replace' so that we don't abort if trying to write out
867
# in e.g. the default C locale.
868
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
869
870
show_log(b, file_id,
871
show_timezone=timezone,
872
verbose=verbose,
873
show_ids=show_ids,
874
to_file=outf,
875
direction=direction,
876
start_revision=revision[0],
877
end_revision=revision[1])
878
879
880
881
class cmd_touching_revisions(Command):
882
"""Return revision-ids which affected a particular file.
883
884
A more user-friendly interface is "bzr log FILE"."""
885
hidden = True
886
takes_args = ["filename"]
887
def run(self, filename):
888
b = Branch(filename)
889
inv = b.read_working_inventory()
890
file_id = inv.path2id(b.relpath(filename))
891
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
892
print "%6d %s" % (revno, what)
893
894
895
class cmd_ls(Command):
338
Branch('.').write_log()
339
340
341
def cmd_ls(revision=None, verbose=False):
896
342
"""List files in a tree.
897
343
898
TODO: Take a revision or remote path and list that tree instead.
344
:todo: Take a revision or remote path and list that tree instead.
899
345
"""
900
hidden = True
901
def run(self, revision=None, verbose=False):
902
b = Branch('.')
903
if revision == None:
904
tree = b.working_tree()
905
else:
906
tree = b.revision_tree(b.lookup_revision(revision))
907
908
for fp, fc, kind, fid in tree.list_files():
909
if verbose:
910
if kind == 'directory':
911
kindch = '/'
912
elif kind == 'file':
913
kindch = ''
914
else:
915
kindch = '???'
916
917
print '%-8s %s%s' % (fc, fp, kindch)
346
b = Branch('.')
347
if revision == None:
348
tree = b.working_tree()
349
else:
350
tree = b.revision_tree(b.lookup_revision(revision))
351
352
for fp, fc, kind, fid in tree.list_files():
353
if verbose:
354
if kind == 'directory':
355
kindch = '/'
356
elif kind == 'file':
357
kindch = ''
918
358
else:
919
print fp
920
921
922
923
class cmd_unknowns(Command):
924
"""List unknown files."""
925
def run(self):
926
for f in Branch('.').unknowns():
927
print quotefn(f)
928
929
930
931
class cmd_ignore(Command):
932
"""Ignore a command or pattern.
933
934
To remove patterns from the ignore list, edit the .bzrignore file.
935
936
If the pattern contains a slash, it is compared to the whole path
937
from the branch root. Otherwise, it is comapred to only the last
938
component of the path.
939
940
Ignore patterns are case-insensitive on case-insensitive systems.
941
942
Note: wildcards must be quoted from the shell on Unix.
943
944
examples:
945
bzr ignore ./Makefile
946
bzr ignore '*.class'
947
"""
948
takes_args = ['name_pattern']
949
950
def run(self, name_pattern):
951
from bzrlib.atomicfile import AtomicFile
952
import os.path
953
954
b = Branch('.')
955
ifn = b.abspath('.bzrignore')
956
957
if os.path.exists(ifn):
958
f = open(ifn, 'rt')
959
try:
960
igns = f.read().decode('utf-8')
961
finally:
962
f.close()
963
else:
964
igns = ''
965
966
# TODO: If the file already uses crlf-style termination, maybe
967
# we should use that for the newly added lines?
968
969
if igns and igns[-1] != '\n':
970
igns += '\n'
971
igns += name_pattern + '\n'
972
973
try:
974
f = AtomicFile(ifn, 'wt')
975
f.write(igns.encode('utf-8'))
976
f.commit()
977
finally:
978
f.close()
979
980
inv = b.working_tree().inventory
981
if inv.path2id('.bzrignore'):
982
mutter('.bzrignore is already versioned')
983
else:
984
mutter('need to make new .bzrignore file versioned')
985
b.add(['.bzrignore'])
986
987
988
989
class cmd_ignored(Command):
990
"""List ignored files and the patterns that matched them.
991
992
See also: bzr ignore"""
993
def run(self):
994
tree = Branch('.').working_tree()
995
for path, file_class, kind, file_id in tree.list_files():
996
if file_class != 'I':
997
continue
998
## XXX: Slightly inefficient since this was already calculated
999
pat = tree.is_ignored(path)
1000
print '%-50s %s' % (path, pat)
1001
1002
1003
class cmd_lookup_revision(Command):
1004
"""Lookup the revision-id from a revision-number
1005
1006
example:
1007
bzr lookup-revision 33
1008
"""
1009
hidden = True
1010
takes_args = ['revno']
1011
1012
def run(self, revno):
1013
try:
1014
revno = int(revno)
1015
except ValueError:
1016
raise BzrCommandError("not a valid revision-number: %r" % revno)
1017
1018
print Branch('.').lookup_revision(revno)
1019
1020
1021
class cmd_export(Command):
1022
"""Export past revision to destination directory.
1023
1024
If no revision is specified this exports the last committed revision."""
1025
takes_args = ['dest']
1026
takes_options = ['revision']
1027
def run(self, dest, revision=None):
1028
b = Branch('.')
1029
if revision == None:
1030
rh = b.revision_history()[-1]
1031
else:
1032
rh = b.lookup_revision(int(revision))
1033
t = b.revision_tree(rh)
1034
t.export(dest)
1035
1036
1037
class cmd_cat(Command):
1038
"""Write a file's text from a previous revision."""
1039
1040
takes_options = ['revision']
1041
takes_args = ['filename']
1042
1043
def run(self, filename, revision=None):
1044
if revision == None:
1045
raise BzrCommandError("bzr cat requires a revision number")
1046
b = Branch('.')
1047
b.print_file(b.relpath(filename), int(revision))
1048
1049
1050
class cmd_local_time_offset(Command):
1051
"""Show the offset in seconds from GMT to local time."""
1052
hidden = True
1053
def run(self):
1054
print bzrlib.osutils.local_time_offset()
1055
1056
1057
1058
class cmd_commit(Command):
1059
"""Commit changes into a new revision.
1060
1061
If selected files are specified, only changes to those files are
1062
committed. If a directory is specified then its contents are also
1063
committed.
1064
1065
A selected-file commit may fail in some cases where the committed
1066
tree would be invalid, such as trying to commit a file in a
1067
newly-added directory that is not itself committed.
1068
1069
TODO: Run hooks on tree to-be-committed, and after commit.
1070
1071
TODO: Strict commit that fails if there are unknown or deleted files.
1072
"""
1073
takes_args = ['selected*']
1074
takes_options = ['message', 'file', 'verbose']
1075
aliases = ['ci', 'checkin']
1076
1077
def run(self, message=None, file=None, verbose=True, selected_list=None):
1078
from bzrlib.commit import commit
1079
1080
## Warning: shadows builtin file()
1081
if not message and not file:
1082
raise BzrCommandError("please specify a commit message",
1083
["use either --message or --file"])
1084
elif message and file:
1085
raise BzrCommandError("please specify either --message or --file")
359
kindch = '???'
360
361
print '%-8s %s%s' % (fc, fp, kindch)
362
else:
363
print fp
364
365
366
367
def cmd_unknowns():
368
"""List unknown files"""
369
for f in Branch('.').unknowns():
370
print quotefn(f)
371
372
373
def cmd_lookup_revision(revno):
374
try:
375
revno = int(revno)
376
except ValueError:
377
bailout("usage: lookup-revision REVNO",
378
["REVNO is a non-negative revision number for this branch"])
379
380
print Branch('.').lookup_revision(revno) or NONE_STRING
381
382
383
384
def cmd_export(revno, dest):
385
"""Export past revision to destination directory."""
386
b = Branch('.')
387
rh = b.lookup_revision(int(revno))
388
t = b.revision_tree(rh)
389
t.export(dest)
390
391
392
393
######################################################################
394
# internal/test commands
395
396
397
def cmd_uuid():
398
"""Print a newly-generated UUID."""
399
print uuid()
400
401
402
403
def cmd_commit(message, verbose=False):
404
Branch('.').commit(message, verbose=verbose)
405
406
407
def cmd_check():
408
"""Check consistency of the branch."""
409
check()
410
411
412
def cmd_is(pred, *rest):
413
"""Test whether PREDICATE is true."""
414
try:
415
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
416
except KeyError:
417
bailout("unknown predicate: %s" % quotefn(pred))
1086
418
1087
if file:
1088
import codecs
1089
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1090
1091
b = Branch('.')
1092
commit(b, message, verbose=verbose, specific_files=selected_list)
1093
1094
1095
class cmd_check(Command):
1096
"""Validate consistency of branch history.
1097
1098
This command checks various invariants about the branch storage to
1099
detect data corruption or bzr bugs.
1100
"""
1101
takes_args = ['dir?']
1102
def run(self, dir='.'):
1103
import bzrlib.check
1104
bzrlib.check.check(Branch(dir))
1105
1106
1107
1108
class cmd_whoami(Command):
1109
"""Show bzr user id."""
1110
takes_options = ['email']
419
try:
420
cmd_handler(*rest)
421
except BzrCheckError:
422
# by default we don't print the message so that this can
423
# be used from shell scripts without producing noise
424
sys.exit(1)
425
426
427
def cmd_username():
428
print bzrlib.osutils.username()
429
430
431
def cmd_user_email():
432
print bzrlib.osutils.user_email()
433
434
435
def cmd_gen_revision_id():
436
import time
437
print bzrlib.branch._gen_revision_id(time.time())
438
439
440
def cmd_doctest():
441
"""Run internal doctest suite"""
442
## -v, if present, is seen by doctest; the argument is just here
443
## so our parser doesn't complain
444
445
## TODO: --verbose option
1111
446
1112
def run(self, email=False):
1113
if email:
1114
print bzrlib.osutils.user_email()
1115
else:
1116
print bzrlib.osutils.username()
1117
1118
1119
class cmd_selftest(Command):
1120
"""Run internal test suite"""
1121
hidden = True
1122
def run(self):
1123
from bzrlib.selftest import selftest
1124
if selftest():
1125
return 0
1126
else:
1127
return 1
1128
1129
1130
1131
class cmd_version(Command):
1132
"""Show version of bzr."""
1133
def run(self):
1134
show_version()
1135
1136
def show_version():
1137
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1138
# is bzrlib itself in a branch?
1139
bzrrev = bzrlib.get_bzr_revision()
1140
if bzrrev:
1141
print " (bzr checkout, revision %d {%s})" % bzrrev
1142
print bzrlib.__copyright__
447
import bzr, doctest, bzrlib.store
448
bzrlib.trace.verbose = False
449
doctest.testmod(bzr)
450
doctest.testmod(bzrlib.store)
451
doctest.testmod(bzrlib.inventory)
452
doctest.testmod(bzrlib.branch)
453
doctest.testmod(bzrlib.osutils)
454
doctest.testmod(bzrlib.tree)
455
456
# more strenuous tests;
457
import bzrlib.tests
458
doctest.testmod(bzrlib.tests)
459
460
461
######################################################################
462
# help
463
464
465
def cmd_help():
466
# TODO: Specific help for particular commands
467
print __doc__
468
469
470
def cmd_version():
471
print "bzr (bazaar-ng) %s" % __version__
472
print __copyright__
1143
473
print "http://bazaar-ng.org/"
1144
474
print
1145
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1146
print "you may use, modify and redistribute it under the terms of the GNU"
1147
print "General Public License version 2 or later."
1148
1149
1150
class cmd_rocks(Command):
475
print \
476
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
477
you may use, modify and redistribute it under the terms of the GNU
478
General Public License version 2 or later."""
479
480
481
def cmd_rocks():
1151
482
"""Statement of optimism."""
1152
hidden = True
1153
def run(self):
1154
print "it sure does!"
1155
1156
def parse_spec(spec):
1157
"""
1158
>>> parse_spec(None)
1159
[None, None]
1160
>>> parse_spec("./")
1161
['./', None]
1162
>>> parse_spec("../@")
1163
['..', -1]
1164
>>> parse_spec("../f/@35")
1165
['../f', 35]
1166
"""
1167
if spec is None:
1168
return [None, None]
1169
if '/@' in spec:
1170
parsed = spec.split('/@')
1171
assert len(parsed) == 2
1172
if parsed[1] == "":
1173
parsed[1] = -1
1174
else:
1175
parsed[1] = int(parsed[1])
1176
assert parsed[1] >=0
1177
else:
1178
parsed = [spec, None]
1179
return parsed
1180
1181
1182
1183
class cmd_merge(Command):
1184
"""Perform a three-way merge of trees.
1185
1186
The SPEC parameters are working tree or revision specifiers. Working trees
1187
are specified using standard paths or urls. No component of a directory
1188
path may begin with '@'.
1189
1190
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1191
1192
Revisions are specified using a dirname/@revno pair, where dirname is the
1193
branch directory and revno is the revision within that branch. If no revno
1194
is specified, the latest revision is used.
1195
1196
Revision examples: './@127', 'foo/@', '../@1'
1197
1198
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1199
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1200
as the BASE.
1201
1202
merge refuses to run if there are any uncommitted changes, unless
1203
--force is given.
1204
"""
1205
takes_args = ['other_spec', 'base_spec?']
1206
takes_options = ['force']
1207
1208
def run(self, other_spec, base_spec=None, force=False):
1209
from bzrlib.merge import merge
1210
merge(parse_spec(other_spec), parse_spec(base_spec),
1211
check_clean=(not force))
1212
1213
1214
class cmd_revert(Command):
1215
"""Reverse all changes since the last commit.
1216
1217
Only versioned files are affected.
1218
1219
TODO: Store backups of any files that will be reverted, so
1220
that the revert can be undone.
1221
"""
1222
takes_options = ['revision']
1223
1224
def run(self, revision=-1):
1225
from bzrlib.merge import merge
1226
merge(('.', revision), parse_spec('.'),
1227
check_clean=False,
1228
ignore_zero=True)
1229
1230
1231
class cmd_assert_fail(Command):
1232
"""Test reporting of assertion failures"""
1233
hidden = True
1234
def run(self):
1235
assert False, "always fails"
1236
1237
1238
class cmd_help(Command):
1239
"""Show help on a command or other topic.
1240
1241
For a list of all available commands, say 'bzr help commands'."""
1242
takes_args = ['topic?']
1243
aliases = ['?']
1244
1245
def run(self, topic=None):
1246
import help
1247
help.help(topic)
1248
1249
1250
class cmd_update_stat_cache(Command):
1251
"""Update stat-cache mapping inodes to SHA-1 hashes.
1252
1253
For testing only."""
1254
hidden = True
1255
def run(self):
1256
import statcache
1257
b = Branch('.')
1258
statcache.update_cache(b.base, b.read_working_inventory())
1259
483
print "it sure does!"
484
485
486
487
######################################################################
488
# main routine
1260
489
1261
490
1262
491
# list of all available options; the rhs can be either None for an
1264
493
# the type.
1265
494
OPTIONS = {
1266
495
'all': None,
1267
'diff-options': str,
1268
496
'help': None,
1269
'file': unicode,
1270
'force': None,
1271
'forward': None,
1272
497
'message': unicode,
1273
'no-recurse': None,
1274
'profile': None,
1275
'revision': _parse_revision_str,
498
'revision': int,
1276
499
'show-ids': None,
1277
'timezone': str,
1278
500
'verbose': None,
1279
501
'version': None,
1280
'email': None,
1281
502
}
1282
503
1283
504
SHORT_OPTIONS = {
1284
'F': 'file',
1285
'h': 'help',
1286
505
'm': 'message',
1287
506
'r': 'revision',
1288
507
'v': 'verbose',
1289
508
}
1290
509
510
# List of options that apply to particular commands; commands not
511
# listed take none.
512
cmd_options = {
513
'add': ['verbose'],
514
'commit': ['message', 'verbose'],
515
'diff': ['revision'],
516
'inventory': ['revision'],
517
'ls': ['revision', 'verbose'],
518
'status': ['all'],
519
'log': ['show-ids'],
520
'remove': ['verbose'],
521
}
522
523
524
cmd_args = {
525
'init': [],
526
'add': ['file+'],
527
'commit': [],
528
'diff': [],
529
'file-id': ['filename'],
530
'get-file-text': ['text_id'],
531
'get-inventory': ['inventory_id'],
532
'get-revision': ['revision_id'],
533
'get-revision-inventory': ['revision_id'],
534
'log': [],
535
'lookup-revision': ['revno'],
536
'export': ['revno', 'dest'],
537
'remove': ['file+'],
538
'status': [],
539
}
540
1291
541
1292
542
def parse_args(argv):
1293
543
"""Parse command line.
1297
547
lookup table, something about the available options, what optargs
1298
548
they take, and which commands will accept them.
1299
549
1300
>>> parse_args('--help'.split())
550
>>> parse_args('bzr --help'.split())
1301
551
([], {'help': True})
1302
>>> parse_args('--version'.split())
552
>>> parse_args('bzr --version'.split())
1303
553
([], {'version': True})
1304
>>> parse_args('status --all'.split())
554
>>> parse_args('bzr status --all'.split())
1305
555
(['status'], {'all': True})
1306
>>> parse_args('commit --message=biter'.split())
1307
(['commit'], {'message': u'biter'})
1308
556
"""
1309
557
args = []
1310
558
opts = {}
1311
559
1312
560
# TODO: Maybe handle '--' to end options?
1313
561
1314
while argv:
1315
a = argv.pop(0)
562
it = iter(argv[1:])
563
while it:
564
a = it.next()
1316
565
if a[0] == '-':
1317
# option names must not be unicode
1318
a = str(a)
1319
optarg = None
1320
566
if a[1] == '-':
1321
567
mutter(" got option %r" % a)
1322
if '=' in a:
1323
optname, optarg = a[2:].split('=', 1)
1324
else:
1325
optname = a[2:]
568
optname = a[2:]
1326
569
if optname not in OPTIONS:
1327
570
bailout('unknown long option %r' % a)
1328
571
else:
1334
577
if optname in opts:
1335
578
# XXX: Do we ever want to support this, e.g. for -r?
1336
579
bailout('repeated option %r' % a)
1337
1338
580
optargfn = OPTIONS[optname]
1339
581
if optargfn:
1340
if optarg == None:
1341
if not argv:
1342
bailout('option %r needs an argument' % a)
1343
else:
1344
optarg = argv.pop(0)
1345
opts[optname] = optargfn(optarg)
582
if not it:
583
bailout('option %r needs an argument' % a)
584
opts[optname] = optargfn(it.next())
585
mutter(" option argument %r" % opts[optname])
1346
586
else:
1347
if optarg != None:
1348
bailout('option %r takes no argument' % optname)
587
# takes no option argument
1349
588
opts[optname] = True
589
elif a[:1] == '-':
590
bailout('unknown short option %r' % a)
1350
591
else:
1351
592
args.append(a)
1352
593
1354
595
1355
596
1356
597
598
def _match_args(cmd, args):
599
"""Check non-option arguments match required pattern.
1357
600
1358
def _match_argform(cmd, takes_args, args):
601
>>> _match_args('status', ['asdasdsadasd'])
602
Traceback (most recent call last):
603
...
604
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
605
>>> _match_args('add', ['asdasdsadasd'])
606
{'file_list': ['asdasdsadasd']}
607
>>> _match_args('add', 'abc def gj'.split())
608
{'file_list': ['abc', 'def', 'gj']}
609
"""
610
# match argument pattern
611
argform = cmd_args.get(cmd, [])
1359
612
argdict = {}
1360
1361
# step through args and takes_args, allowing appropriate 0-many matches
1362
for ap in takes_args:
613
# TODO: Need a way to express 'cp SRC... DEST', where it matches
614
# all but one.
615
for ap in argform:
1363
616
argname = ap[:-1]
1364
617
if ap[-1] == '?':
1365
if args:
1366
argdict[argname] = args.pop(0)
1367
elif ap[-1] == '*': # all remaining arguments
1368
if args:
1369
argdict[argname + '_list'] = args[:]
1370
args = []
1371
else:
1372
argdict[argname + '_list'] = None
618
assert 0
619
elif ap[-1] == '*':
620
assert 0
1373
621
elif ap[-1] == '+':
1374
622
if not args:
1375
raise BzrCommandError("command %r needs one or more %s"
623
bailout("command %r needs one or more %s"
1376
624
% (cmd, argname.upper()))
1377
625
else:
1378
626
argdict[argname + '_list'] = args[:]
1379
627
args = []
1380
elif ap[-1] == '$': # all but one
1381
if len(args) < 2:
1382
raise BzrCommandError("command %r needs one or more %s"
1383
% (cmd, argname.upper()))
1384
argdict[argname + '_list'] = args[:-1]
1385
args[:-1] = []
1386
628
else:
1387
629
# just a plain arg
1388
630
argname = ap
1389
631
if not args:
1390
raise BzrCommandError("command %r requires argument %s"
632
bailout("command %r requires argument %s"
1391
633
% (cmd, argname.upper()))
1392
634
else:
1393
635
argdict[argname] = args.pop(0)
1394
636
1395
637
if args:
1396
raise BzrCommandError("extra argument to command %s: %s"
1397
% (cmd, args[0]))
638
bailout("extra arguments to command %s: %r"
639
% (cmd, args))
1398
640
1399
641
return argdict
1400
642
1404
646
"""Execute a command.
1405
647
1406
648
This is similar to main(), but without all the trappings for
1407
logging and error handling.
649
logging and error handling.
1408
650
"""
1409
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1410
1411
include_plugins=True
1412
651
try:
1413
args, opts = parse_args(argv[1:])
652
args, opts = parse_args(argv)
1414
653
if 'help' in opts:
1415
import help
1416
if args:
1417
help.help(args[0])
1418
else:
1419
help.help()
654
# TODO: pass down other arguments in case they asked for
655
# help on a command name?
656
cmd_help()
1420
657
return 0
1421
658
elif 'version' in opts:
1422
show_version()
659
cmd_version()
1423
660
return 0
1424
elif args and args[0] == 'builtin':
1425
include_plugins=False
1426
args = args[1:]
1427
cmd = str(args.pop(0))
661
cmd = args.pop(0)
1428
662
except IndexError:
1429
import help
1430
help.help()
663
log_error('usage: bzr COMMAND\n')
664
log_error(' try "bzr help"\n')
1431
665
return 1
1432
1433
1434
canonical_cmd, cmd_class = get_cmd_class(cmd,include_plugins=include_plugins)
1435
1436
# global option
1437
if 'profile' in opts:
1438
profile = True
1439
del opts['profile']
1440
else:
1441
profile = False
666
667
try:
668
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
669
except KeyError:
670
bailout("unknown command " + `cmd`)
671
672
# TODO: special --profile option to turn on the Python profiler
1442
673
1443
674
# check options are reasonable
1444
allowed = cmd_class.takes_options
675
allowed = cmd_options.get(cmd, [])
1445
676
for oname in opts:
1446
677
if oname not in allowed:
1447
raise BzrCommandError("option '--%s' is not allowed for command %r"
1448
% (oname, cmd))
1449
1450
# mix arguments and options into one dictionary
1451
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1452
cmdopts = {}
1453
for k, v in opts.items():
1454
cmdopts[k.replace('-', '_')] = v
1455
1456
if profile:
1457
import hotshot, tempfile
1458
pffileno, pfname = tempfile.mkstemp()
1459
try:
1460
prof = hotshot.Profile(pfname)
1461
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1462
prof.close()
1463
1464
import hotshot.stats
1465
stats = hotshot.stats.load(pfname)
1466
#stats.strip_dirs()
1467
stats.sort_stats('time')
1468
## XXX: Might like to write to stderr or the trace file instead but
1469
## print_stats seems hardcoded to stdout
1470
stats.print_stats(20)
1471
1472
return ret.status
1473
1474
finally:
1475
os.close(pffileno)
1476
os.remove(pfname)
1477
else:
1478
return cmd_class(cmdopts, cmdargs).status
1479
1480
1481
def _report_exception(summary, quiet=False):
1482
import traceback
1483
log_error('bzr: ' + summary)
1484
bzrlib.trace.log_exception()
1485
1486
if not quiet:
1487
tb = sys.exc_info()[2]
1488
exinfo = traceback.extract_tb(tb)
1489
if exinfo:
1490
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1491
sys.stderr.write(' see ~/.bzr.log for debug information\n')
678
bailout("option %r is not allowed for command %r"
679
% (oname, cmd))
680
681
cmdargs = _match_args(cmd, args)
682
cmdargs.update(opts)
683
684
ret = cmd_handler(**cmdargs) or 0
1492
685
1493
686
1494
687
1495
688
def main(argv):
1496
import errno
1497
1498
bzrlib.open_tracefile(argv)
689
## TODO: Handle command-line options; probably know what options are valid for
690
## each command
691
692
## TODO: If the arguments are wrong, give a usage message rather
693
## than just a backtrace.
1499
694
1500
695
try:
1501
try:
1502
try:
1503
return run_bzr(argv)
1504
finally:
1505
# do this here inside the exception wrappers to catch EPIPE
1506
sys.stdout.flush()
1507
except BzrError, e:
1508
quiet = isinstance(e, (BzrCommandError))
1509
_report_exception('error: ' + e.args[0], quiet=quiet)
1510
if len(e.args) > 1:
1511
for h in e.args[1]:
1512
# some explanation or hints
1513
log_error(' ' + h)
1514
return 1
1515
except AssertionError, e:
1516
msg = 'assertion failed'
1517
if str(e):
1518
msg += ': ' + str(e)
1519
_report_exception(msg)
1520
return 2
1521
except KeyboardInterrupt, e:
1522
_report_exception('interrupted', quiet=True)
1523
return 2
1524
except Exception, e:
1525
quiet = False
1526
if (isinstance(e, IOError)
1527
and hasattr(e, 'errno')
1528
and e.errno == errno.EPIPE):
1529
quiet = True
1530
msg = 'broken pipe'
1531
else:
1532
msg = str(e).rstrip('\n')
1533
_report_exception(msg, quiet)
1534
return 2
1535
finally:
1536
bzrlib.trace.close_trace()
696
t = bzrlib.trace._tracefile
697
t.write('-' * 60 + '\n')
698
t.write('bzr invoked at %s\n' % format_date(time.time()))
699
t.write(' by %s on %s\n' % (bzrlib.osutils.username(), socket.gethostname()))
700
t.write(' arguments: %r\n' % argv)
701
702
starttime = os.times()[4]
703
704
import platform
705
t.write(' platform: %s\n' % platform.platform())
706
t.write(' python: %s\n' % platform.python_version())
707
708
ret = run_bzr(argv)
709
710
times = os.times()
711
mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum"
712
% times[:4])
713
mutter(" %.3f elapsed" % (times[4] - starttime))
714
715
return ret
716
except BzrError, e:
717
log_error('bzr: error: ' + e.args[0] + '\n')
718
if len(e.args) > 1:
719
for h in e.args[1]:
720
log_error(' ' + h + '\n')
721
return 1
722
except Exception, e:
723
log_error('bzr: exception: %s\n' % e)
724
log_error(' see .bzr.log for details\n')
725
traceback.print_exc(None, bzrlib.trace._tracefile)
726
traceback.print_exc(None, sys.stderr)
727
return 1
728
729
# TODO: Maybe nicer handling of IOError?
730
1537
731
1538
732
1539
733
if __name__ == '__main__':
1540
734
sys.exit(main(sys.argv))
735
##import profile
736
##profile.run('main(sys.argv)')
737
Loggerhead is a web-based interface for Breezy
Version: 2.0.1