« back to all changes in this revision
Viewing changes to bzr.py
- browse files at revision 13
- compare with another revision
- download diff
- download tarball
- view history from revision 13
- Committer: mbp at sourcefrog
- Date: 2005-03-09 07:03:02 UTC
- Revision ID: mbp@sourcefrog.net-20050309070302-7067508fc801dd7b
fix up cmd_log args
- files added:
- doc/roadmap.txt
- files removed:
- .bzrignore
- elementtree
- 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
15
20
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
21
17
22
"""Bazaar-NG -- a free distributed version-control tool
18
http://bazaar-ng.org/
19
23
20
24
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
21
25
26
Current limitation include:
27
22
28
* Metadata format is not stable yet -- you may need to
23
29
discard history in the future.
24
30
31
* No handling of subdirectories, symlinks or any non-text files.
32
33
* Insufficient error handling.
34
25
35
* Many commands unimplemented or partially implemented.
26
36
27
37
* Space-inefficient storage.
28
38
29
39
* No merge operators yet.
30
40
31
Interesting commands:
41
Interesting commands::
32
42
33
bzr help [COMMAND]
34
Show help screen
43
bzr help
44
Show summary help screen
35
45
bzr version
36
Show software version/licence/non-warranty.
46
Show software version/licence/non-warranty.
37
47
bzr init
38
Start versioning the current directory
48
Start versioning the current directory
39
49
bzr add FILE...
40
Make files versioned.
50
Make files versioned.
41
51
bzr log
42
Show revision history.
43
bzr rename FROM TO
44
Rename one file.
45
bzr move FROM... DESTDIR
46
Move one or more files to a different directory.
47
bzr diff [FILE...]
48
Show changes from last revision to working copy.
52
Show revision history.
53
bzr diff
54
Show changes from last revision to working copy.
49
55
bzr commit -m 'MESSAGE'
50
Store current state as new revision.
51
bzr export [-r REVNO] DESTINATION
52
Export the branch state at a previous version.
56
Store current state as new revision.
57
bzr export REVNO DESTINATION
58
Export the branch state at a previous version.
53
59
bzr status
54
Show summary of pending changes.
60
Show summary of pending changes.
55
61
bzr remove FILE...
56
Make a file not versioned.
57
bzr info
58
Show statistics about this branch.
59
bzr check
60
Verify history is stored safely.
61
(for more type 'bzr help commands')
62
Make a file not versioned.
62
63
"""
63
64
64
65
66
67
import sys, os, time, types, shutil, tempfile, fnmatch, difflib, os.path
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
68
82
from sets import Set
69
83
from pprint import pprint
70
84
from stat import *
73
87
import bzrlib
74
88
from bzrlib.store import ImmutableStore
75
89
from bzrlib.trace import mutter, note, log_error
76
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
90
from bzrlib.errors import bailout, BzrError
77
91
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
78
92
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
79
93
from bzrlib.revision import Revision
88
102
EMPTY = 'empty'
89
103
90
104
91
CMD_ALIASES = {
92
'?': 'help',
93
'ci': 'commit',
94
'checkin': 'commit',
95
'di': 'diff',
96
'st': 'status',
97
'stat': 'status',
98
}
99
100
101
def get_cmd_class(cmd):
102
cmd = str(cmd)
103
104
cmd = CMD_ALIASES.get(cmd, cmd)
105
106
try:
107
cmd_class = globals()['cmd_' + cmd.replace('-', '_')]
108
except KeyError:
109
raise BzrError("unknown command %r" % cmd)
110
111
return cmd, cmd_class
112
113
114
115
class Command:
116
"""Base class for commands.
117
118
The docstring for an actual command should give a single-line
119
summary, then a complete description of the command. A grammar
120
description will be inserted.
121
122
takes_args
123
List of argument forms, marked with whether they are optional,
124
repeated, etc.
125
126
takes_options
127
List of options that may be given for this command.
128
129
hidden
130
If true, this command isn't advertised.
131
"""
132
aliases = []
133
134
takes_args = []
135
takes_options = []
136
137
hidden = False
138
139
def __init__(self, options, arguments):
140
"""Construct and run the command.
141
142
Sets self.status to the return value of run()."""
143
assert isinstance(options, dict)
144
assert isinstance(arguments, dict)
145
cmdargs = options.copy()
146
cmdargs.update(arguments)
147
assert self.__doc__ != Command.__doc__, \
148
("No help message set for %r" % self)
149
self.status = self.run(**cmdargs)
150
151
152
def run(self):
153
"""Override this in sub-classes.
154
155
This is invoked with the options and arguments bound to
156
keyword parameters.
157
158
Return True if the command was successful, False if not.
159
"""
160
return True
161
162
163
164
class cmd_status(Command):
105
## TODO: Perhaps a different version of inventory commands that
106
## returns iterators...
107
108
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
109
110
## TODO: Some kind of locking on branches. Perhaps there should be a
111
## parameter to the branch object saying whether we want a read or
112
## write lock; release it from destructor. Perhaps don't even need a
113
## read lock to look at immutable objects?
114
115
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
116
## to compare output?
117
118
119
120
121
######################################################################
122
# check status
123
124
125
def cmd_status(all=False):
165
126
"""Display status summary.
166
127
167
128
For each file there is a single line giving its file state and name.
168
129
The name is that in the current revision unless it is deleted or
169
130
missing, in which case the old name is shown.
170
"""
171
takes_options = ['all']
172
173
def run(self, all=False):
174
#import bzrlib.status
175
#bzrlib.status.tree_status(Branch('.'))
176
Branch('.').show_status(show_all=all)
177
178
179
class cmd_cat_revision(Command):
180
"""Write out metadata for a revision."""
181
182
hidden = True
183
takes_args = ['revision_id']
184
185
def run(self, revision_id):
186
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
187
188
189
class cmd_revno(Command):
190
"""Show current revision number.
191
192
This is equal to the number of revisions on this branch."""
193
def run(self):
194
print Branch('.').revno()
195
196
197
class cmd_add(Command):
198
"""Add specified files or directories.
199
200
In non-recursive mode, all the named items are added, regardless
201
of whether they were previously ignored. A warning is given if
202
any of the named files are already versioned.
203
204
In recursive mode (the default), files are treated the same way
205
but the behaviour for directories is different. Directories that
206
are already versioned do not give a warning. All directories,
207
whether already versioned or not, are searched for files or
208
subdirectories that are neither versioned or ignored, and these
209
are added. This search proceeds recursively into versioned
210
directories.
211
212
Therefore simply saying 'bzr add .' will version all files that
213
are currently unknown.
214
215
TODO: Perhaps adding a file whose directly is not versioned should
216
recursively add that parent, rather than giving an error?
217
"""
218
takes_args = ['file+']
219
takes_options = ['verbose']
220
221
def run(self, file_list, verbose=False):
222
bzrlib.add.smart_add(file_list, verbose)
223
224
225
def Relpath(Command):
226
"""Show path of a file relative to root"""
227
takes_args = ('filename')
228
229
def run(self):
230
print Branch(self.args['filename']).relpath(filename)
231
232
233
234
class cmd_inventory(Command):
235
"""Show inventory of the current working copy or a revision."""
236
takes_options = ['revision']
237
238
def run(self, revision=None):
239
b = Branch('.')
240
if revision == None:
241
inv = b.read_working_inventory()
242
else:
243
inv = b.get_revision_inventory(b.lookup_revision(revision))
244
245
for path, entry in inv.iter_entries():
246
print '%-50s %s' % (entry.file_id, path)
247
248
249
class cmd_move(Command):
250
"""Move files to a different directory.
251
252
examples:
253
bzr move *.txt doc
254
255
The destination must be a versioned directory in the same branch.
256
"""
257
takes_args = ['source$', 'dest']
258
def run(self, source_list, dest):
259
b = Branch('.')
260
261
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
262
263
264
class cmd_rename(Command):
265
"""Change the name of an entry.
266
267
examples:
268
bzr rename frob.c frobber.c
269
bzr rename src/frob.c lib/frob.c
270
271
It is an error if the destination name exists.
272
273
See also the 'move' command, which moves files into a different
274
directory without changing their name.
275
276
TODO: Some way to rename multiple files without invoking bzr for each
277
one?"""
278
takes_args = ['from_name', 'to_name']
279
280
def run(self, from_name, to_name):
281
b = Branch('.')
282
b.rename_one(b.relpath(from_name), b.relpath(to_name))
283
284
285
286
class cmd_renames(Command):
287
"""Show list of renamed files.
288
289
TODO: Option to show renames between two historical versions.
290
291
TODO: Only show renames under dir, rather than in the whole branch.
292
"""
293
takes_args = ['dir?']
294
295
def run(self, dir='.'):
296
b = Branch(dir)
297
old_inv = b.basis_tree().inventory
298
new_inv = b.read_working_inventory()
299
300
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
301
renames.sort()
302
for old_name, new_name in renames:
303
print "%s => %s" % (old_name, new_name)
304
305
306
class cmd_info(Command):
307
"""Show statistical information for this branch"""
308
def run(self):
309
import info
310
info.show_info(Branch('.'))
311
312
313
class cmd_remove(Command):
314
"""Make a file unversioned.
315
316
This makes bzr stop tracking changes to a versioned file. It does
317
not delete the working copy.
318
"""
319
takes_args = ['file+']
320
takes_options = ['verbose']
321
322
def run(self, file_list, verbose=False):
323
b = Branch(file_list[0])
324
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
325
326
327
class cmd_file_id(Command):
328
"""Print file_id of a particular file or directory.
329
330
The file_id is assigned when the file is first added and remains the
331
same through all revisions where the file exists, even when it is
332
moved or renamed.
333
"""
334
hidden = True
335
takes_args = ['filename']
336
def run(self, filename):
337
b = Branch(filename)
338
i = b.inventory.path2id(b.relpath(filename))
339
if i == None:
340
bailout("%r is not a versioned file" % filename)
341
else:
342
print i
343
344
345
class cmd_file_path(Command):
346
"""Print path of file_ids to a file or directory.
347
348
This prints one line for each directory down to the target,
349
starting at the branch root."""
350
hidden = True
351
takes_args = ['filename']
352
def run(self, filename):
353
b = Branch(filename)
354
inv = b.inventory
355
fid = inv.path2id(b.relpath(filename))
356
if fid == None:
357
bailout("%r is not a versioned file" % filename)
358
for fip in inv.get_idpath(fid):
359
print fip
360
361
362
class cmd_revision_history(Command):
363
"""Display list of revision ids on this branch."""
364
def run(self):
365
for patchid in Branch('.').revision_history():
366
print patchid
367
368
369
class cmd_directories(Command):
370
"""Display list of versioned directories in this branch."""
371
def run(self):
372
for name, ie in Branch('.').read_working_inventory().directories():
373
if name == '':
374
print '.'
375
else:
376
print name
377
378
379
class cmd_init(Command):
380
"""Make a directory into a versioned branch.
381
382
Use this to create an empty branch, or before importing an
383
existing project.
384
385
Recipe for importing a tree of files:
386
cd ~/project
387
bzr init
388
bzr add -v .
389
bzr status
390
bzr commit -m 'imported project'
391
"""
392
def run(self):
393
Branch('.', init=True)
394
395
396
class cmd_diff(Command):
397
"""Show differences in working tree.
398
399
If files are listed, only the changes in those files are listed.
400
Otherwise, all changes for the tree are listed.
401
402
TODO: Given two revision arguments, show the difference between them.
403
404
TODO: Allow diff across branches.
405
406
TODO: Option to use external diff command; could be GNU diff, wdiff,
407
or a graphical diff.
408
409
TODO: Python difflib is not exactly the same as unidiff; should
410
either fix it up or prefer to use an external diff.
411
412
TODO: If a directory is given, diff everything under that.
413
414
TODO: Selected-file diff is inefficient and doesn't show you
415
deleted files.
416
417
TODO: This probably handles non-Unix newlines poorly.
418
"""
419
420
takes_args = ['file*']
421
takes_options = ['revision']
422
423
def run(self, revision=None, file_list=None):
424
from bzrlib.diff import show_diff
425
426
show_diff(Branch('.'), revision, file_list)
427
428
429
class cmd_deleted(Command):
430
"""List files deleted in the working tree.
431
432
TODO: Show files deleted since a previous revision, or between two revisions.
433
"""
434
def run(self, show_ids=False):
435
b = Branch('.')
436
old = b.basis_tree()
437
new = b.working_tree()
438
439
## TODO: Much more efficient way to do this: read in new
440
## directories with readdir, rather than stating each one. Same
441
## level of effort but possibly much less IO. (Or possibly not,
442
## if the directories are very large...)
443
444
for path, ie in old.inventory.iter_entries():
445
if not new.has_id(ie.file_id):
446
if show_ids:
447
print '%-50s %s' % (path, ie.file_id)
448
else:
449
print path
450
451
class cmd_root(Command):
452
"""Show the tree root directory.
453
454
The root is the nearest enclosing directory with a .bzr control
455
directory."""
456
takes_args = ['filename?']
457
def run(self, filename=None):
458
"""Print the branch root."""
459
print bzrlib.branch.find_branch_root(filename)
460
461
462
463
class cmd_log(Command):
131
132
:todo: Don't show unchanged files unless ``--all`` is given?
133
"""
134
Branch('.').show_status(show_all=all)
135
136
137
138
######################################################################
139
# examining history
140
def cmd_get_revision(revision_id):
141
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
142
143
144
def cmd_get_inventory(inventory_id):
145
"""Return inventory in XML by hash"""
146
Branch('.').get_inventory(inventory_hash).write_xml(sys.stdout)
147
148
149
def cmd_get_revision_inventory(revision_id):
150
"""Output inventory for a revision."""
151
b = Branch('.')
152
b.get_revision_inventory(revision_id).write_xml(sys.stdout)
153
154
155
def cmd_get_file_text(text_id):
156
"""Get contents of a file by hash."""
157
sf = Branch('.').text_store[text_id]
158
pumpfile(sf, sys.stdout)
159
160
161
162
######################################################################
163
# commands
164
165
166
def cmd_revno():
167
"""Show number of revisions on this branch"""
168
print Branch('.').revno()
169
170
171
def cmd_add(file_list, verbose=False):
172
"""Add specified files.
173
174
Fails if the files are already added.
175
"""
176
Branch('.').add(file_list, verbose=verbose)
177
178
179
def cmd_inventory(revision=None):
180
"""Show inventory of the current working copy."""
181
## TODO: Also optionally show a previous inventory
182
## TODO: Format options
183
b = Branch('.')
184
if revision == None:
185
inv = b.read_working_inventory()
186
else:
187
inv = b.get_revision_inventory(b.lookup_revision(revision))
188
189
for path, entry in inv.iter_entries():
190
print '%-50s %s' % (entry.file_id, path)
191
192
193
194
def cmd_info():
195
b = Branch('.')
196
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
197
print 'revision number:', b.revno()
198
print 'number of versioned files:', len(b.read_working_inventory())
199
200
201
def cmd_remove(file_list, verbose=False):
202
Branch('.').remove(file_list, verbose=verbose)
203
204
205
206
def cmd_file_id(filename):
207
i = Branch('.').read_working_inventory().path2id(filename)
208
if i is None:
209
bailout("%s is not a versioned file" % filename)
210
else:
211
print i
212
213
214
def cmd_find_filename(fileid):
215
n = find_filename(fileid)
216
if n is None:
217
bailout("%s is not a live file id" % fileid)
218
else:
219
print n
220
221
222
def cmd_revision_history():
223
for patchid in Branch('.').revision_history():
224
print patchid
225
226
227
228
def cmd_init():
229
# TODO: Check we're not already in a working directory? At the
230
# moment you'll get an ugly error.
231
232
# TODO: What if we're in a subdirectory of a branch? Would like
233
# to allow that, but then the parent may need to understand that
234
# the children have disappeared, or should they be versioned in
235
# both?
236
237
# TODO: Take an argument/option for branch name.
238
Branch('.', init=True)
239
240
241
def cmd_diff(revision=None):
242
"""Show diff from basis to working copy.
243
244
:todo: Take one or two revision arguments, look up those trees,
245
and diff them.
246
247
:todo: Allow diff across branches.
248
249
:todo: Mangle filenames in diff to be more relevant.
250
251
:todo: Shouldn't be in the cmd function.
252
"""
253
254
b = Branch('.')
255
256
if revision == None:
257
old_tree = b.basis_tree()
258
else:
259
old_tree = b.revision_tree(b.lookup_revision(revision))
260
261
new_tree = b.working_tree()
262
old_inv = old_tree.inventory
263
new_inv = new_tree.inventory
264
265
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
266
old_label = ''
267
new_label = ''
268
269
DEVNULL = '/dev/null'
270
# Windows users, don't panic about this filename -- it is a
271
# special signal to GNU patch that the file should be created or
272
# deleted respectively.
273
274
# TODO: Generation of pseudo-diffs for added/deleted files could
275
# be usefully made into a much faster special case.
276
277
# TODO: Better to return them in sorted order I think.
278
279
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
280
d = None
281
282
# Don't show this by default; maybe do it if an option is passed
283
# idlabel = ' {%s}' % fid
284
idlabel = ''
285
286
# FIXME: Something about the diff format makes patch unhappy
287
# with newly-added files.
288
289
def diffit(*a, **kw):
290
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
291
print
292
293
if file_state in ['.', '?', 'I']:
294
continue
295
elif file_state == 'A':
296
print '*** added %s %r' % (kind, new_name)
297
if kind == 'file':
298
diffit([],
299
new_tree.get_file(fid).readlines(),
300
fromfile=DEVNULL,
301
tofile=new_label + new_name + idlabel)
302
elif file_state == 'D':
303
assert isinstance(old_name, types.StringTypes)
304
print '*** deleted %s %r' % (kind, old_name)
305
if kind == 'file':
306
diffit(old_tree.get_file(fid).readlines(), [],
307
fromfile=old_label + old_name + idlabel,
308
tofile=DEVNULL)
309
elif file_state in ['M', 'R']:
310
if file_state == 'M':
311
assert kind == 'file'
312
assert old_name == new_name
313
print '*** modified %s %r' % (kind, new_name)
314
elif file_state == 'R':
315
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
316
317
if kind == 'file':
318
diffit(old_tree.get_file(fid).readlines(),
319
new_tree.get_file(fid).readlines(),
320
fromfile=old_label + old_name + idlabel,
321
tofile=new_label + new_name)
322
else:
323
bailout("can't represent state %s {%s}" % (file_state, fid))
324
325
326
327
def cmd_log(timezone='original'):
464
328
"""Show log of this branch.
465
329
466
TODO: Options to show ids; to limit range; etc.
330
:todo: Options for utc; to show ids; to limit range; etc.
467
331
"""
468
takes_options = ['timezone', 'verbose']
469
def run(self, timezone='original', verbose=False):
470
Branch('.').write_log(show_timezone=timezone, verbose=verbose)
471
472
473
class cmd_ls(Command):
332
Branch('.').write_log(show_timezone=timezone)
333
334
335
def cmd_ls(revision=None, verbose=False):
474
336
"""List files in a tree.
475
337
476
TODO: Take a revision or remote path and list that tree instead.
338
:todo: Take a revision or remote path and list that tree instead.
477
339
"""
478
hidden = True
479
def run(self, revision=None, verbose=False):
480
b = Branch('.')
481
if revision == None:
482
tree = b.working_tree()
340
b = Branch('.')
341
if revision == None:
342
tree = b.working_tree()
343
else:
344
tree = b.revision_tree(b.lookup_revision(revision))
345
346
for fp, fc, kind, fid in tree.list_files():
347
if verbose:
348
if kind == 'directory':
349
kindch = '/'
350
elif kind == 'file':
351
kindch = ''
352
else:
353
kindch = '???'
354
355
print '%-8s %s%s' % (fc, fp, kindch)
483
356
else:
484
tree = b.revision_tree(b.lookup_revision(revision))
485
486
for fp, fc, kind, fid in tree.list_files():
487
if verbose:
488
if kind == 'directory':
489
kindch = '/'
490
elif kind == 'file':
491
kindch = ''
492
else:
493
kindch = '???'
494
495
print '%-8s %s%s' % (fc, fp, kindch)
496
else:
497
print fp
498
499
500
501
class cmd_unknowns(Command):
357
print fp
358
359
360
361
def cmd_unknowns():
502
362
"""List unknown files"""
503
def run(self):
504
for f in Branch('.').unknowns():
505
print quotefn(f)
506
507
508
509
class cmd_ignore(Command):
510
"""Ignore a command or pattern"""
511
takes_args = ['name_pattern']
512
513
def run(self, name_pattern):
514
b = Branch('.')
515
516
# XXX: This will fail if it's a hardlink; should use an AtomicFile class.
517
f = open(b.abspath('.bzrignore'), 'at')
518
f.write(name_pattern + '\n')
519
f.close()
520
521
inv = b.working_tree().inventory
522
if inv.path2id('.bzrignore'):
523
mutter('.bzrignore is already versioned')
524
else:
525
mutter('need to make new .bzrignore file versioned')
526
b.add(['.bzrignore'])
527
528
529
530
class cmd_ignored(Command):
531
"""List ignored files and the patterns that matched them."""
532
def run(self):
533
tree = Branch('.').working_tree()
534
for path, file_class, kind, file_id in tree.list_files():
535
if file_class != 'I':
536
continue
537
## XXX: Slightly inefficient since this was already calculated
538
pat = tree.is_ignored(path)
539
print '%-50s %s' % (path, pat)
540
541
542
class cmd_lookup_revision(Command):
543
"""Lookup the revision-id from a revision-number
544
545
example:
546
bzr lookup-revision 33
547
"""
548
hidden = True
549
def run(self, revno):
550
try:
551
revno = int(revno)
552
except ValueError:
553
raise BzrError("not a valid revision-number: %r" % revno)
554
555
print Branch('.').lookup_revision(revno) or NONE_STRING
556
557
558
559
class cmd_export(Command):
560
"""Export past revision to destination directory.
561
562
If no revision is specified this exports the last committed revision."""
563
takes_args = ['dest']
564
takes_options = ['revision']
565
def run(self, dest, revno=None):
566
b = Branch('.')
567
if revno == None:
568
rh = b.revision_history[-1]
569
else:
570
rh = b.lookup_revision(int(revno))
571
t = b.revision_tree(rh)
572
t.export(dest)
573
574
575
class cmd_cat(Command):
576
"""Write a file's text from a previous revision."""
577
578
takes_options = ['revision']
579
takes_args = ['filename']
580
581
def run(self, filename, revision=None):
582
if revision == None:
583
raise BzrCommandError("bzr cat requires a revision number")
584
b = Branch('.')
585
b.print_file(b.relpath(filename), int(revision))
586
587
588
class cmd_local_time_offset(Command):
589
"""Show the offset in seconds from GMT to local time."""
590
hidden = True
591
def run(self):
592
print bzrlib.osutils.local_time_offset()
593
594
595
596
class cmd_commit(Command):
597
"""Commit changes into a new revision.
598
599
TODO: Commit only selected files.
600
601
TODO: Run hooks on tree to-be-committed, and after commit.
602
603
TODO: Strict commit that fails if there are unknown or deleted files.
604
"""
605
takes_options = ['message', 'verbose']
606
607
def run(self, message=None, verbose=False):
608
if not message:
609
raise BzrCommandError("please specify a commit message")
610
Branch('.').commit(message, verbose=verbose)
611
612
613
class cmd_check(Command):
614
"""Validate consistency of branch history.
615
616
This command checks various invariants about the branch storage to
617
detect data corruption or bzr bugs.
618
"""
619
takes_args = ['dir?']
620
def run(self, dir='.'):
621
import bzrlib.check
622
bzrlib.check.check(Branch(dir, find_root=False))
623
624
625
626
class cmd_whoami(Command):
627
"""Show bzr user id."""
628
takes_options = ['email']
629
630
def run(self, email=False):
631
if email:
632
print bzrlib.osutils.user_email()
633
else:
634
print bzrlib.osutils.username()
635
636
637
class cmd_selftest(Command):
638
"""Run internal test suite"""
639
hidden = True
640
def run(self):
641
failures, tests = 0, 0
642
643
import doctest, bzrlib.store, bzrlib.tests
644
bzrlib.trace.verbose = False
645
646
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
647
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
648
mf, mt = doctest.testmod(m)
649
failures += mf
650
tests += mt
651
print '%-40s %3d tests' % (m.__name__, mt),
652
if mf:
653
print '%3d FAILED!' % mf
654
else:
655
print
656
657
print '%-40s %3d tests' % ('total', tests),
658
if failures:
659
print '%3d FAILED!' % failures
660
else:
661
print
662
663
664
665
class cmd_version(Command):
666
"""Show version of bzr"""
667
def run(self):
668
show_version()
669
670
def show_version():
671
print "bzr (bazaar-ng) %s" % bzrlib.__version__
672
print bzrlib.__copyright__
363
for f in Branch('.').unknowns():
364
print quotefn(f)
365
366
367
def cmd_lookup_revision(revno):
368
try:
369
revno = int(revno)
370
except ValueError:
371
bailout("usage: lookup-revision REVNO",
372
["REVNO is a non-negative revision number for this branch"])
373
374
print Branch('.').lookup_revision(revno) or NONE_STRING
375
376
377
378
def cmd_export(revno, dest):
379
"""Export past revision to destination directory."""
380
b = Branch('.')
381
rh = b.lookup_revision(int(revno))
382
t = b.revision_tree(rh)
383
t.export(dest)
384
385
386
387
######################################################################
388
# internal/test commands
389
390
391
def cmd_uuid():
392
"""Print a newly-generated UUID."""
393
print uuid()
394
395
396
397
def cmd_local_time_offset():
398
print bzrlib.osutils.local_time_offset()
399
400
401
402
def cmd_commit(message, verbose=False):
403
Branch('.').commit(message, verbose=verbose)
404
405
406
def cmd_check():
407
"""Check consistency of the branch."""
408
check()
409
410
411
def cmd_is(pred, *rest):
412
"""Test whether PREDICATE is true."""
413
try:
414
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
415
except KeyError:
416
bailout("unknown predicate: %s" % quotefn(pred))
417
418
try:
419
cmd_handler(*rest)
420
except BzrCheckError:
421
# by default we don't print the message so that this can
422
# be used from shell scripts without producing noise
423
sys.exit(1)
424
425
426
def cmd_username():
427
print bzrlib.osutils.username()
428
429
430
def cmd_user_email():
431
print bzrlib.osutils.user_email()
432
433
434
def cmd_gen_revision_id():
435
import time
436
print bzrlib.branch._gen_revision_id(time.time())
437
438
439
def cmd_doctest():
440
"""Run internal doctest suite"""
441
## -v, if present, is seen by doctest; the argument is just here
442
## so our parser doesn't complain
443
444
## TODO: --verbose option
445
446
import bzr, doctest, bzrlib.store
447
bzrlib.trace.verbose = False
448
doctest.testmod(bzr)
449
doctest.testmod(bzrlib.store)
450
doctest.testmod(bzrlib.inventory)
451
doctest.testmod(bzrlib.branch)
452
doctest.testmod(bzrlib.osutils)
453
doctest.testmod(bzrlib.tree)
454
455
# more strenuous tests;
456
import bzrlib.tests
457
doctest.testmod(bzrlib.tests)
458
459
460
######################################################################
461
# help
462
463
464
def cmd_help():
465
# TODO: Specific help for particular commands
466
print __doc__
467
468
469
def cmd_version():
470
print "bzr (bazaar-ng) %s" % __version__
471
print __copyright__
673
472
print "http://bazaar-ng.org/"
674
473
print
675
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
676
print "you may use, modify and redistribute it under the terms of the GNU"
677
print "General Public License version 2 or later."
678
679
680
class cmd_rocks(Command):
474
print \
475
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
476
you may use, modify and redistribute it under the terms of the GNU
477
General Public License version 2 or later."""
478
479
480
def cmd_rocks():
681
481
"""Statement of optimism."""
682
hidden = True
683
def run(self):
684
print "it sure does!"
685
686
687
class cmd_assert_fail(Command):
688
"""Test reporting of assertion failures"""
689
hidden = True
690
def run(self):
691
assert False, "always fails"
692
693
694
class cmd_help(Command):
695
"""Show help on a command or other topic.
696
697
For a list of all available commands, say 'bzr help commands'."""
698
takes_args = ['topic?']
699
700
def run(self, topic=None):
701
help(topic)
702
703
704
def help(topic=None):
705
if topic == None:
706
print __doc__
707
elif topic == 'commands':
708
help_commands()
709
else:
710
help_on_command(topic)
711
712
713
def help_on_command(cmdname):
714
cmdname = str(cmdname)
715
716
from inspect import getdoc
717
topic, cmdclass = get_cmd_class(cmdname)
718
719
doc = getdoc(cmdclass)
720
if doc == None:
721
raise NotImplementedError("sorry, no detailed help yet for %r" % cmdname)
722
723
if '\n' in doc:
724
short, rest = doc.split('\n', 1)
725
else:
726
short = doc
727
rest = ''
728
729
print 'usage: bzr ' + topic,
730
for aname in cmdclass.takes_args:
731
aname = aname.upper()
732
if aname[-1] in ['$', '+']:
733
aname = aname[:-1] + '...'
734
elif aname[-1] == '?':
735
aname = '[' + aname[:-1] + ']'
736
elif aname[-1] == '*':
737
aname = '[' + aname[:-1] + '...]'
738
print aname,
739
print
740
print short
741
if rest:
742
print rest
743
744
if cmdclass.takes_options:
745
print
746
print 'options:'
747
for on in cmdclass.takes_options:
748
print ' --%s' % on
749
750
751
def help_commands():
752
"""List all commands"""
753
import inspect
754
755
accu = []
756
for k, v in globals().items():
757
if k.startswith('cmd_'):
758
accu.append((k[4:].replace('_','-'), v))
759
accu.sort()
760
for cmdname, cmdclass in accu:
761
if cmdclass.hidden:
762
continue
763
print cmdname
764
help = inspect.getdoc(cmdclass)
765
if help:
766
print " " + help.split('\n', 1)[0]
482
print "it sure does!"
483
767
484
768
485
769
486
######################################################################
777
494
'all': None,
778
495
'help': None,
779
496
'message': unicode,
780
'profile': None,
781
497
'revision': int,
782
498
'show-ids': None,
783
499
'timezone': str,
784
500
'verbose': None,
785
501
'version': None,
786
'email': None,
787
502
}
788
503
789
504
SHORT_OPTIONS = {
792
507
'v': 'verbose',
793
508
}
794
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
'log': ['show-ids', 'timezone'],
518
'ls': ['revision', 'verbose'],
519
'remove': ['verbose'],
520
'status': ['all'],
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
795
541
796
542
def parse_args(argv):
797
543
"""Parse command line.
801
547
lookup table, something about the available options, what optargs
802
548
they take, and which commands will accept them.
803
549
804
>>> parse_args('--help'.split())
550
>>> parse_args('bzr --help'.split())
805
551
([], {'help': True})
806
>>> parse_args('--version'.split())
552
>>> parse_args('bzr --version'.split())
807
553
([], {'version': True})
808
>>> parse_args('status --all'.split())
554
>>> parse_args('bzr status --all'.split())
809
555
(['status'], {'all': True})
810
>>> parse_args('commit --message=biter'.split())
811
(['commit'], {'message': u'biter'})
812
556
"""
813
557
args = []
814
558
opts = {}
815
559
816
560
# TODO: Maybe handle '--' to end options?
817
561
818
while argv:
819
a = argv.pop(0)
562
it = iter(argv[1:])
563
while it:
564
a = it.next()
820
565
if a[0] == '-':
821
# option names must not be unicode
822
a = str(a)
823
optarg = None
824
566
if a[1] == '-':
825
567
mutter(" got option %r" % a)
826
if '=' in a:
827
optname, optarg = a[2:].split('=', 1)
828
else:
829
optname = a[2:]
568
optname = a[2:]
830
569
if optname not in OPTIONS:
831
570
bailout('unknown long option %r' % a)
832
571
else:
838
577
if optname in opts:
839
578
# XXX: Do we ever want to support this, e.g. for -r?
840
579
bailout('repeated option %r' % a)
841
842
580
optargfn = OPTIONS[optname]
843
581
if optargfn:
844
if optarg == None:
845
if not argv:
846
bailout('option %r needs an argument' % a)
847
else:
848
optarg = argv.pop(0)
849
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])
850
586
else:
851
if optarg != None:
852
bailout('option %r takes no argument' % optname)
587
# takes no option argument
853
588
opts[optname] = True
589
elif a[:1] == '-':
590
bailout('unknown short option %r' % a)
854
591
else:
855
592
args.append(a)
856
593
858
595
859
596
860
597
598
def _match_args(cmd, args):
599
"""Check non-option arguments match required pattern.
861
600
862
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, [])
863
612
argdict = {}
864
865
# step through args and takes_args, allowing appropriate 0-many matches
866
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:
867
616
argname = ap[:-1]
868
617
if ap[-1] == '?':
869
if args:
870
argdict[argname] = args.pop(0)
871
elif ap[-1] == '*': # all remaining arguments
872
if args:
873
argdict[argname + '_list'] = args[:]
874
args = []
875
else:
876
argdict[argname + '_list'] = None
618
assert 0
619
elif ap[-1] == '*':
620
assert 0
877
621
elif ap[-1] == '+':
878
622
if not args:
879
raise BzrCommandError("command %r needs one or more %s"
623
bailout("command %r needs one or more %s"
880
624
% (cmd, argname.upper()))
881
625
else:
882
626
argdict[argname + '_list'] = args[:]
883
627
args = []
884
elif ap[-1] == '$': # all but one
885
if len(args) < 2:
886
raise BzrCommandError("command %r needs one or more %s"
887
% (cmd, argname.upper()))
888
argdict[argname + '_list'] = args[:-1]
889
args[:-1] = []
890
628
else:
891
629
# just a plain arg
892
630
argname = ap
893
631
if not args:
894
raise BzrCommandError("command %r requires argument %s"
632
bailout("command %r requires argument %s"
895
633
% (cmd, argname.upper()))
896
634
else:
897
635
argdict[argname] = args.pop(0)
898
636
899
637
if args:
900
raise BzrCommandError("extra argument to command %s: %s"
901
% (cmd, args[0]))
638
bailout("extra arguments to command %s: %r"
639
% (cmd, args))
902
640
903
641
return argdict
904
642
908
646
"""Execute a command.
909
647
910
648
This is similar to main(), but without all the trappings for
911
logging and error handling.
649
logging and error handling.
912
650
"""
913
914
argv = [a.decode(bzrlib.user_encoding) for a in argv]
915
916
651
try:
917
args, opts = parse_args(argv[1:])
652
args, opts = parse_args(argv)
918
653
if 'help' in opts:
919
if args:
920
help(args[0])
921
else:
922
help()
654
# TODO: pass down other arguments in case they asked for
655
# help on a command name?
656
cmd_help()
923
657
return 0
924
658
elif 'version' in opts:
925
cmd_version([], [])
659
cmd_version()
926
660
return 0
927
cmd = str(args.pop(0))
661
cmd = args.pop(0)
928
662
except IndexError:
929
log_error('usage: bzr COMMAND')
930
log_error(' try "bzr help"')
663
log_error('usage: bzr COMMAND\n')
664
log_error(' try "bzr help"\n')
931
665
return 1
932
933
canonical_cmd, cmd_class = get_cmd_class(cmd)
934
935
# global option
936
if 'profile' in opts:
937
profile = True
938
del opts['profile']
939
else:
940
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
941
673
942
674
# check options are reasonable
943
allowed = cmd_class.takes_options
675
allowed = cmd_options.get(cmd, [])
944
676
for oname in opts:
945
677
if oname not in allowed:
946
raise BzrCommandError("option %r is not allowed for command %r"
947
% (oname, cmd))
948
949
# mix arguments and options into one dictionary
950
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
951
cmdopts = {}
952
for k, v in opts.items():
953
cmdopts[k.replace('-', '_')] = v
954
955
if profile:
956
import hotshot
957
pffileno, pfname = tempfile.mkstemp()
958
try:
959
prof = hotshot.Profile(pfname)
960
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
961
prof.close()
962
963
import hotshot.stats
964
stats = hotshot.stats.load(pfname)
965
#stats.strip_dirs()
966
stats.sort_stats('time')
967
## XXX: Might like to write to stderr or the trace file instead but
968
## print_stats seems hardcoded to stdout
969
stats.print_stats(20)
970
971
return ret
972
973
finally:
974
os.close(pffileno)
975
os.remove(pfname)
976
else:
977
cmdobj = cmd_class(cmdopts, cmdargs) or 0
978
979
980
981
def _report_exception(e, summary, quiet=False):
982
import traceback
983
log_error('bzr: ' + summary)
984
bzrlib.trace.log_exception(e)
985
986
if not quiet:
987
tb = sys.exc_info()[2]
988
exinfo = traceback.extract_tb(tb)
989
if exinfo:
990
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
991
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
992
685
993
686
994
687
995
688
def main(argv):
996
import errno
997
998
bzrlib.trace.create_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.
999
694
1000
695
try:
1001
try:
1002
ret = run_bzr(argv)
1003
# do this here to catch EPIPE
1004
sys.stdout.flush()
1005
return ret
1006
except BzrError, e:
1007
quiet = isinstance(e, (BzrCommandError))
1008
_report_exception(e, 'error: ' + e.args[0], quiet=quiet)
1009
if len(e.args) > 1:
1010
for h in e.args[1]:
1011
# some explanation or hints
1012
log_error(' ' + h)
1013
return 1
1014
except AssertionError, e:
1015
msg = 'assertion failed'
1016
if str(e):
1017
msg += ': ' + str(e)
1018
_report_exception(e, msg)
1019
return 2
1020
except KeyboardInterrupt, e:
1021
_report_exception(e, 'interrupted', quiet=True)
1022
return 2
1023
except Exception, e:
1024
quiet = False
1025
if isinstance(e, IOError) and e.errno == errno.EPIPE:
1026
quiet = True
1027
msg = 'broken pipe'
1028
else:
1029
msg = str(e).rstrip('\n')
1030
_report_exception(e, msg, quiet)
1031
return 2
1032
finally:
1033
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
1034
731
1035
732
1036
733
if __name__ == '__main__':
1037
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