« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1393.1.3
- compare with another revision
- download diff
- download tarball
- view history from revision 1393.1.3
- Committer: Martin Pool
- Date: 2005-09-29 05:06:14 UTC
- mto: (1185.12.2) (1393.1.12)
- mto: This revision was merged to the branch mainline in revision 1396.
- Revision ID: mbp@sourcefrog.net-20050929050614-a41e6f72af36bb4c
- better error on failing to import bzrlib
- files added:
- bzrlib/mdiff.py
- files removed:
- BRANCH.TODO
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/blackbox/test_revision_info.py => bzrlib/selftest/test_revision_info.py
- bzrlib/tests/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_fetch.py => bzrlib/selftest/testfetch.py
- bzrlib/tests/test_graph.py => bzrlib/selftest/testgraph.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge.py => bzrlib/selftest/testmerge.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/test_store.py => bzrlib/selftest/teststore.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/store/weave.py => bzrlib/weavestore.py
- files modified:
- .rsyncexclude
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
"""builtin bzr commands"""
18
19
# DO NOT change this to cStringIO - it results in control files
20
# written as UCS4
21
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
22
# RBC 20051018
23
24
from StringIO import StringIO
17
25
18
import sys
26
19
import os
27
20
28
21
import bzrlib
22
import bzrlib.trace
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
25
from bzrlib.branch import Branch
29
26
from bzrlib import BZRDIR
30
from bzrlib.commands import Command, display_command
31
from bzrlib.branch import Branch
32
from bzrlib.revision import common_ancestor
33
import bzrlib.errors as errors
34
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch)
37
from bzrlib.option import Option
38
from bzrlib.revisionspec import RevisionSpec
39
import bzrlib.trace
40
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
41
from bzrlib.workingtree import WorkingTree
42
from bzrlib.log import show_one_log
43
44
45
def tree_files(file_list, default_branch=u'.'):
46
try:
47
return internal_tree_files(file_list, default_branch)
48
except FileInWrongBranch, e:
49
raise BzrCommandError("%s is not in the same branch as %s" %
50
(e.path, file_list[0]))
51
52
def internal_tree_files(file_list, default_branch=u'.'):
53
"""\
54
Return a branch and list of branch-relative paths.
55
If supplied file_list is empty or None, the branch default will be used,
56
and returned file_list will match the original.
57
"""
58
if file_list is None or len(file_list) == 0:
59
return WorkingTree.open_containing(default_branch)[0], file_list
60
tree = WorkingTree.open_containing(file_list[0])[0]
61
new_list = []
62
for filename in file_list:
63
try:
64
new_list.append(tree.relpath(filename))
65
except errors.PathNotChild:
66
raise FileInWrongBranch(tree.branch, filename)
67
return tree, new_list
68
69
70
# TODO: Make sure no commands unconditionally use the working directory as a
71
# branch. If a filename argument is used, the first of them should be used to
72
# specify the branch. (Perhaps this can be factored out into some kind of
73
# Argument class, representing a file in a branch, where the first occurrence
74
# opens the branch?)
27
from bzrlib.commands import Command
28
75
29
76
30
class cmd_status(Command):
77
31
"""Display status summary.
112
66
If a revision argument is given, the status is calculated against
113
67
that revision, or between two revisions if two are provided.
114
68
"""
115
116
# TODO: --no-recurse, --recurse options
117
69
# XXX: FIXME: bzr status should accept a -r option to show changes
70
# relative to a revision, or between revisions
71
118
72
takes_args = ['file*']
119
73
takes_options = ['all', 'show-ids', 'revision']
120
74
aliases = ['st', 'stat']
121
75
122
@display_command
123
76
def run(self, all=False, show_ids=False, file_list=None, revision=None):
124
tree, file_list = tree_files(file_list)
77
if file_list:
78
b = Branch.open_containing(file_list[0])
79
file_list = [b.relpath(x) for x in file_list]
80
# special case: only one path was given and it's the root
81
# of the branch
82
if file_list == ['']:
83
file_list = None
84
else:
85
b = Branch.open_containing('.')
125
86
126
87
from bzrlib.status import show_status
127
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
88
show_status(b, show_unchanged=all, show_ids=show_ids,
128
89
specific_files=file_list, revision=revision)
129
90
130
91
139
100
takes_args = ['revision_id?']
140
101
takes_options = ['revision']
141
102
142
@display_command
143
103
def run(self, revision_id=None, revision=None):
104
from bzrlib.revisionspec import RevisionSpec
144
105
145
106
if revision_id is not None and revision is not None:
146
107
raise BzrCommandError('You can only supply one of revision_id or --revision')
147
108
if revision_id is None and revision is None:
148
109
raise BzrCommandError('You must supply either --revision or a revision_id')
149
b = WorkingTree.open_containing(u'.')[0].branch
110
b = Branch.open_containing('.')
150
111
if revision_id is not None:
151
sys.stdout.write(b.get_revision_xml(revision_id))
112
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
152
113
elif revision is not None:
153
114
for rev in revision:
154
115
if rev is None:
155
116
raise BzrCommandError('You cannot specify a NULL revision.')
156
117
revno, rev_id = rev.in_history(b)
157
sys.stdout.write(b.get_revision_xml(rev_id))
118
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
158
119
159
120
160
121
class cmd_revno(Command):
161
122
"""Show current revision number.
162
123
163
124
This is equal to the number of revisions on this branch."""
164
takes_args = ['location?']
165
@display_command
166
def run(self, location=u'.'):
167
print Branch.open_containing(location)[0].revno()
125
def run(self):
126
print Branch.open_containing('.').revno()
168
127
169
128
170
129
class cmd_revision_info(Command):
173
132
hidden = True
174
133
takes_args = ['revision_info*']
175
134
takes_options = ['revision']
176
@display_command
177
135
def run(self, revision=None, revision_info_list=[]):
136
from bzrlib.revisionspec import RevisionSpec
178
137
179
138
revs = []
180
139
if revision is not None:
185
144
if len(revs) == 0:
186
145
raise BzrCommandError('You must supply a revision identifier')
187
146
188
b = WorkingTree.open_containing(u'.')[0].branch
147
b = Branch.open_containing('.')
189
148
190
149
for rev in revs:
191
150
revinfo = rev.in_history(b)
217
176
implicitly add the parent, and so on up to the root. This means
218
177
you should never need to explictly add a directory, they'll just
219
178
get added when you add a file in the directory.
220
221
--dry-run will show which files would be added, but not actually
222
add them.
223
179
"""
224
180
takes_args = ['file*']
225
takes_options = ['no-recurse', 'dry-run', 'verbose']
226
227
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
228
import bzrlib.add
229
230
if dry_run:
231
if is_quiet():
232
# This is pointless, but I'd rather not raise an error
233
action = bzrlib.add.add_action_null
234
else:
235
action = bzrlib.add.add_action_print
236
elif is_quiet():
237
action = bzrlib.add.add_action_add
238
else:
239
action = bzrlib.add.add_action_add_and_print
240
241
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
242
action)
243
if len(ignored) > 0:
244
for glob in sorted(ignored.keys()):
245
match_len = len(ignored[glob])
246
if verbose:
247
for path in ignored[glob]:
248
print "ignored %s matching \"%s\"" % (path, glob)
249
else:
250
print "ignored %d file(s) matching \"%s\"" % (match_len,
251
glob)
252
print "If you wish to add some of these files, please add them"\
253
" by name."
181
takes_options = ['verbose', 'no-recurse']
182
183
def run(self, file_list, verbose=False, no_recurse=False):
184
# verbose currently has no effect
185
from bzrlib.add import smart_add, add_reporter_print
186
smart_add(file_list, not no_recurse, add_reporter_print)
187
254
188
255
189
256
190
class cmd_mkdir(Command):
261
195
takes_args = ['dir+']
262
196
263
197
def run(self, dir_list):
198
b = None
199
264
200
for d in dir_list:
265
201
os.mkdir(d)
266
wt, dd = WorkingTree.open_containing(d)
267
wt.add([dd])
202
if not b:
203
b = Branch.open_containing(d)
204
b.add([d])
268
205
print 'added', d
269
206
270
207
273
210
takes_args = ['filename']
274
211
hidden = True
275
212
276
@display_command
277
213
def run(self, filename):
278
tree, relpath = WorkingTree.open_containing(filename)
279
print relpath
214
print Branch.open_containing(filename).relpath(filename)
215
280
216
281
217
282
218
class cmd_inventory(Command):
283
"""Show inventory of the current working copy or a revision.
284
285
It is possible to limit the output to a particular entry
286
type using the --kind option. For example; --kind file.
287
"""
288
takes_options = ['revision', 'show-ids', 'kind']
219
"""Show inventory of the current working copy or a revision."""
220
takes_options = ['revision', 'show-ids']
289
221
290
@display_command
291
def run(self, revision=None, show_ids=False, kind=None):
292
if kind and kind not in ['file', 'directory', 'symlink']:
293
raise BzrCommandError('invalid kind specified')
294
tree = WorkingTree.open_containing(u'.')[0]
222
def run(self, revision=None, show_ids=False):
223
b = Branch.open_containing('.')
295
224
if revision is None:
296
inv = tree.read_working_inventory()
225
inv = b.read_working_inventory()
297
226
else:
298
227
if len(revision) > 1:
299
228
raise BzrCommandError('bzr inventory --revision takes'
300
229
' exactly one revision identifier')
301
inv = tree.branch.get_revision_inventory(
302
revision[0].in_history(tree.branch).rev_id)
230
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
303
231
304
232
for path, entry in inv.entries():
305
if kind and kind != entry.kind:
306
continue
307
233
if show_ids:
308
234
print '%-50s %s' % (path, entry.file_id)
309
235
else:
320
246
"""
321
247
takes_args = ['source$', 'dest']
322
248
def run(self, source_list, dest):
323
tree, source_list = tree_files(source_list)
249
b = Branch.open_containing('.')
250
324
251
# TODO: glob expansion on windows?
325
tree.move(source_list, tree.relpath(dest))
252
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
326
253
327
254
328
255
class cmd_rename(Command):
336
263
337
264
See also the 'move' command, which moves files into a different
338
265
directory without changing their name.
339
"""
340
# TODO: Some way to rename multiple files without invoking
341
# bzr for each one?"""
266
267
TODO: Some way to rename multiple files without invoking bzr for each
268
one?"""
342
269
takes_args = ['from_name', 'to_name']
343
270
344
271
def run(self, from_name, to_name):
345
tree, (from_name, to_name) = tree_files((from_name, to_name))
346
tree.rename_one(from_name, to_name)
272
b = Branch.open_containing('.')
273
b.rename_one(b.relpath(from_name), b.relpath(to_name))
274
347
275
348
276
349
277
class cmd_mv(Command):
363
291
def run(self, names_list):
364
292
if len(names_list) < 2:
365
293
raise BzrCommandError("missing file argument")
366
tree, rel_names = tree_files(names_list)
294
b = Branch.open_containing(names_list[0])
295
296
rel_names = [b.relpath(x) for x in names_list]
367
297
368
298
if os.path.isdir(names_list[-1]):
369
299
# move into existing directory
370
for pair in tree.move(rel_names[:-1], rel_names[-1]):
300
for pair in b.move(rel_names[:-1], rel_names[-1]):
371
301
print "%s => %s" % pair
372
302
else:
373
303
if len(names_list) != 2:
374
304
raise BzrCommandError('to mv multiple files the destination '
375
305
'must be a versioned directory')
376
tree.rename_one(rel_names[0], rel_names[1])
306
b.rename_one(rel_names[0], rel_names[1])
377
307
print "%s => %s" % (rel_names[0], rel_names[1])
378
308
379
309
310
311
380
312
class cmd_pull(Command):
381
313
"""Pull any changes from another branch into the current one.
382
314
383
If there is no default location set, the first pull will set it. After
384
that, you can omit the location to use the default. To change the
385
default, use --remember.
315
If the location is omitted, the last-used location will be used.
316
Both the revision history and the working directory will be
317
updated.
386
318
387
319
This command only works on branches that have not diverged. Branches are
388
320
considered diverged if both branches have had commits without first
389
321
pulling from the other.
390
322
391
323
If branches have diverged, you can use 'bzr merge' to pull the text changes
392
from one into the other. Once one branch has merged, the other should
393
be able to pull it again.
394
395
If you want to forget your local changes and just update your branch to
396
match the remote one, use --overwrite.
324
from one into the other.
397
325
"""
398
takes_options = ['remember', 'overwrite', 'verbose']
399
326
takes_args = ['location?']
400
327
401
def run(self, location=None, remember=False, overwrite=False, verbose=False):
328
def run(self, location=None):
402
329
from bzrlib.merge import merge
330
import tempfile
403
331
from shutil import rmtree
404
332
import errno
405
# FIXME: too much stuff is in the command class
406
tree_to = WorkingTree.open_containing(u'.')[0]
407
stored_loc = tree_to.branch.get_parent()
333
334
br_to = Branch.open_containing('.')
335
stored_loc = br_to.get_parent()
408
336
if location is None:
409
337
if stored_loc is None:
410
338
raise BzrCommandError("No pull location known or specified.")
411
339
else:
412
print "Using saved location: %s" % stored_loc
413
location = stored_loc
414
415
br_from = Branch.open(location)
416
br_to = tree_to.branch
417
418
old_rh = br_to.revision_history()
419
count = tree_to.pull(br_from, overwrite)
420
421
if br_to.get_parent() is None or remember:
422
br_to.set_parent(location)
423
note('%d revision(s) pulled.' % (count,))
424
425
if verbose:
426
new_rh = tree_to.branch.revision_history()
427
if old_rh != new_rh:
428
# Something changed
429
from bzrlib.log import show_changed_revisions
430
show_changed_revisions(tree_to.branch, old_rh, new_rh)
431
432
433
class cmd_push(Command):
434
"""Push this branch into another branch.
435
436
The remote branch will not have its working tree populated because this
437
is both expensive, and may not be supported on the remote file system.
438
439
Some smart servers or protocols *may* put the working tree in place.
440
441
If there is no default push location set, the first push will set it.
442
After that, you can omit the location to use the default. To change the
443
default, use --remember.
444
445
This command only works on branches that have not diverged. Branches are
446
considered diverged if the branch being pushed to is not an older version
447
of this branch.
448
449
If branches have diverged, you can use 'bzr push --overwrite' to replace
450
the other branch completely.
451
452
If you want to ensure you have the different changes in the other branch,
453
do a merge (see bzr help merge) from the other branch, and commit that
454
before doing a 'push --overwrite'.
455
"""
456
takes_options = ['remember', 'overwrite',
457
Option('create-prefix',
458
help='Create the path leading up to the branch '
459
'if it does not already exist')]
460
takes_args = ['location?']
461
462
def run(self, location=None, remember=False, overwrite=False,
463
create_prefix=False, verbose=False):
464
# FIXME: Way too big! Put this into a function called from the
465
# command.
466
import errno
467
from shutil import rmtree
468
from bzrlib.transport import get_transport
469
470
tree_from = WorkingTree.open_containing(u'.')[0]
471
br_from = tree_from.branch
472
stored_loc = tree_from.branch.get_push_location()
473
if location is None:
474
if stored_loc is None:
475
raise BzrCommandError("No push location known or specified.")
476
else:
477
print "Using saved location: %s" % stored_loc
478
location = stored_loc
479
try:
480
br_to = Branch.open(location)
481
except NotBranchError:
482
# create a branch.
483
transport = get_transport(location).clone('..')
484
if not create_prefix:
485
try:
486
transport.mkdir(transport.relpath(location))
487
except NoSuchFile:
488
raise BzrCommandError("Parent directory of %s "
489
"does not exist." % location)
490
else:
491
current = transport.base
492
needed = [(transport, transport.relpath(location))]
493
while needed:
494
try:
495
transport, relpath = needed[-1]
496
transport.mkdir(relpath)
497
needed.pop()
498
except NoSuchFile:
499
new_transport = transport.clone('..')
500
needed.append((new_transport,
501
new_transport.relpath(transport.base)))
502
if new_transport.base == transport.base:
503
raise BzrCommandError("Could not creeate "
504
"path prefix.")
505
br_to = Branch.initialize(location)
506
old_rh = br_to.revision_history()
507
try:
340
print "Using last location: %s" % stored_loc
341
location = stored_loc
342
cache_root = tempfile.mkdtemp()
343
from bzrlib.errors import DivergedBranches
344
br_from = Branch.open_containing(location)
345
location = br_from.base
346
old_revno = br_to.revno()
347
try:
348
from bzrlib.errors import DivergedBranches
349
br_from = Branch.open(location)
350
br_from.setup_caching(cache_root)
351
location = br_from.base
352
old_revno = br_to.revno()
508
353
try:
509
tree_to = br_to.working_tree()
510
except NoWorkingTree:
511
# TODO: This should be updated for branches which don't have a
512
# working tree, as opposed to ones where we just couldn't
513
# update the tree.
514
warning('Unable to update the working tree of: %s' % (br_to.base,))
515
count = br_to.pull(br_from, overwrite)
516
else:
517
count = tree_to.pull(br_from, overwrite)
518
except DivergedBranches:
519
raise BzrCommandError("These branches have diverged."
520
" Try a merge then push with overwrite.")
521
if br_from.get_push_location() is None or remember:
522
br_from.set_push_location(location)
523
note('%d revision(s) pushed.' % (count,))
354
br_to.update_revisions(br_from)
355
except DivergedBranches:
356
raise BzrCommandError("These branches have diverged."
357
" Try merge.")
358
359
merge(('.', -1), ('.', old_revno), check_clean=False)
360
if location != stored_loc:
361
br_to.set_parent(location)
362
finally:
363
rmtree(cache_root)
524
364
525
if verbose:
526
new_rh = br_to.revision_history()
527
if old_rh != new_rh:
528
# Something changed
529
from bzrlib.log import show_changed_revisions
530
show_changed_revisions(br_to, old_rh, new_rh)
531
365
532
366
533
367
class cmd_branch(Command):
548
382
aliases = ['get', 'clone']
549
383
550
384
def run(self, from_location, to_location=None, revision=None, basis=None):
551
from bzrlib.clone import copy_branch
385
from bzrlib.branch import copy_branch
386
import tempfile
552
387
import errno
553
388
from shutil import rmtree
554
if revision is None:
555
revision = [None]
556
elif len(revision) > 1:
557
raise BzrCommandError(
558
'bzr branch --revision takes exactly 1 revision value')
559
try:
560
br_from = Branch.open(from_location)
561
except OSError, e:
562
if e.errno == errno.ENOENT:
563
raise BzrCommandError('Source location "%s" does not'
564
' exist.' % to_location)
565
else:
566
raise
567
br_from.lock_read()
568
try:
389
cache_root = tempfile.mkdtemp()
390
try:
391
if revision is None:
392
revision = [None]
393
elif len(revision) > 1:
394
raise BzrCommandError(
395
'bzr branch --revision takes exactly 1 revision value')
396
try:
397
br_from = Branch.open(from_location)
398
except OSError, e:
399
if e.errno == errno.ENOENT:
400
raise BzrCommandError('Source location "%s" does not'
401
' exist.' % to_location)
402
else:
403
raise
404
br_from.setup_caching(cache_root)
569
405
if basis is not None:
570
basis_branch = WorkingTree.open_containing(basis)[0].branch
406
basis_branch = Branch.open_containing(basis)
571
407
else:
572
408
basis_branch = None
573
409
if len(revision) == 1 and revision[0] is not None:
576
412
revision_id = None
577
413
if to_location is None:
578
414
to_location = os.path.basename(from_location.rstrip("/\\"))
579
name = None
580
else:
581
name = os.path.basename(to_location) + '\n'
582
415
try:
583
416
os.mkdir(to_location)
584
417
except OSError, e:
594
427
copy_branch(br_from, to_location, revision_id, basis_branch)
595
428
except bzrlib.errors.NoSuchRevision:
596
429
rmtree(to_location)
597
msg = "The branch %s has no revision %s." % (from_location, revision[0])
430
msg = "The branch %s has no revision %d." % (from_location, revision[0])
598
431
raise BzrCommandError(msg)
599
432
except bzrlib.errors.UnlistableBranch:
600
rmtree(to_location)
601
433
msg = "The branch %s cannot be used as a --basis"
602
raise BzrCommandError(msg)
603
branch = Branch.open(to_location)
604
if name:
605
name = StringIO(name)
606
branch.put_controlfile('branch-name', name)
607
note('Branched %d revision(s).' % branch.revno())
608
434
finally:
609
br_from.unlock()
435
rmtree(cache_root)
610
436
611
437
612
438
class cmd_renames(Command):
613
439
"""Show list of renamed files.
440
441
TODO: Option to show renames between two historical versions.
442
443
TODO: Only show renames under dir, rather than in the whole branch.
614
444
"""
615
# TODO: Option to show renames between two historical versions.
616
617
# TODO: Only show renames under dir, rather than in the whole branch.
618
445
takes_args = ['dir?']
619
446
620
@display_command
621
def run(self, dir=u'.'):
622
tree = WorkingTree.open_containing(dir)[0]
623
old_inv = tree.branch.basis_tree().inventory
624
new_inv = tree.read_working_inventory()
447
def run(self, dir='.'):
448
b = Branch.open_containing(dir)
449
old_inv = b.basis_tree().inventory
450
new_inv = b.read_working_inventory()
625
451
626
452
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
627
453
renames.sort()
633
459
"""Show statistical information about a branch."""
634
460
takes_args = ['branch?']
635
461
636
@display_command
637
462
def run(self, branch=None):
638
463
import info
639
b = WorkingTree.open_containing(branch)[0].branch
464
465
b = Branch.open_containing(branch)
640
466
info.show_info(b)
641
467
642
468
648
474
"""
649
475
takes_args = ['file+']
650
476
takes_options = ['verbose']
651
aliases = ['rm']
652
477
653
478
def run(self, file_list, verbose=False):
654
tree, file_list = tree_files(file_list)
655
tree.remove(file_list, verbose=verbose)
479
b = Branch.open_containing(file_list[0])
480
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
656
481
657
482
658
483
class cmd_file_id(Command):
664
489
"""
665
490
hidden = True
666
491
takes_args = ['filename']
667
@display_command
668
492
def run(self, filename):
669
tree, relpath = WorkingTree.open_containing(filename)
670
i = tree.inventory.path2id(relpath)
493
b = Branch.open_containing(filename)
494
i = b.inventory.path2id(b.relpath(filename))
671
495
if i == None:
672
496
raise BzrError("%r is not a versioned file" % filename)
673
497
else:
681
505
starting at the branch root."""
682
506
hidden = True
683
507
takes_args = ['filename']
684
@display_command
685
508
def run(self, filename):
686
tree, relpath = WorkingTree.open_containing(filename)
687
inv = tree.inventory
688
fid = inv.path2id(relpath)
509
b = Branch.open_containing(filename)
510
inv = b.inventory
511
fid = inv.path2id(b.relpath(filename))
689
512
if fid == None:
690
513
raise BzrError("%r is not a versioned file" % filename)
691
514
for fip in inv.get_idpath(fid):
695
518
class cmd_revision_history(Command):
696
519
"""Display list of revision ids on this branch."""
697
520
hidden = True
698
@display_command
699
521
def run(self):
700
branch = WorkingTree.open_containing(u'.')[0].branch
701
for patchid in branch.revision_history():
522
for patchid in Branch.open_containing('.').revision_history():
702
523
print patchid
703
524
704
525
705
526
class cmd_ancestry(Command):
706
527
"""List all revisions merged into this branch."""
707
528
hidden = True
708
@display_command
709
529
def run(self):
710
tree = WorkingTree.open_containing(u'.')[0]
711
b = tree.branch
712
# FIXME. should be tree.last_revision
530
b = find_branch('.')
713
531
for revision_id in b.get_ancestry(b.last_revision()):
714
532
print revision_id
715
533
716
534
535
class cmd_directories(Command):
536
"""Display list of versioned directories in this branch."""
537
def run(self):
538
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
539
if name == '':
540
print '.'
541
else:
542
print name
543
544
717
545
class cmd_init(Command):
718
546
"""Make a directory into a versioned branch.
719
547
723
551
Recipe for importing a tree of files:
724
552
cd ~/project
725
553
bzr init
726
bzr add .
554
bzr add -v .
727
555
bzr status
728
556
bzr commit -m 'imported project'
729
557
"""
730
takes_args = ['location?']
731
def run(self, location=None):
558
def run(self):
732
559
from bzrlib.branch import Branch
733
if location is None:
734
location = u'.'
735
else:
736
# The path has to exist to initialize a
737
# branch inside of it.
738
# Just using os.mkdir, since I don't
739
# believe that we want to create a bunch of
740
# locations if the user supplies an extended path
741
if not os.path.exists(location):
742
os.mkdir(location)
743
Branch.initialize(location)
560
Branch.initialize('.')
744
561
745
562
746
563
class cmd_diff(Command):
749
566
If files are listed, only the changes in those files are listed.
750
567
Otherwise, all changes for the tree are listed.
751
568
569
TODO: Allow diff across branches.
570
571
TODO: Option to use external diff command; could be GNU diff, wdiff,
572
or a graphical diff.
573
574
TODO: Python difflib is not exactly the same as unidiff; should
575
either fix it up or prefer to use an external diff.
576
577
TODO: If a directory is given, diff everything under that.
578
579
TODO: Selected-file diff is inefficient and doesn't show you
580
deleted files.
581
582
TODO: This probably handles non-Unix newlines poorly.
583
752
584
examples:
753
585
bzr diff
754
586
bzr diff -r1
755
587
bzr diff -r1..2
756
588
"""
757
# TODO: Allow diff across branches.
758
# TODO: Option to use external diff command; could be GNU diff, wdiff,
759
# or a graphical diff.
760
761
# TODO: Python difflib is not exactly the same as unidiff; should
762
# either fix it up or prefer to use an external diff.
763
764
# TODO: If a directory is given, diff everything under that.
765
766
# TODO: Selected-file diff is inefficient and doesn't show you
767
# deleted files.
768
769
# TODO: This probably handles non-Unix newlines poorly.
770
589
771
590
takes_args = ['file*']
772
591
takes_options = ['revision', 'diff-options']
773
592
aliases = ['di', 'dif']
774
593
775
@display_command
776
594
def run(self, revision=None, file_list=None, diff_options=None):
777
595
from bzrlib.diff import show_diff
778
try:
779
tree, file_list = internal_tree_files(file_list)
780
b = None
781
b2 = None
782
except FileInWrongBranch:
783
if len(file_list) != 2:
784
raise BzrCommandError("Files are in different branches")
785
786
b, file1 = Branch.open_containing(file_list[0])
787
b2, file2 = Branch.open_containing(file_list[1])
788
if file1 != "" or file2 != "":
789
# FIXME diff those two files. rbc 20051123
790
raise BzrCommandError("Files are in different branches")
791
file_list = None
596
597
if file_list:
598
b = Branch.open_containing(file_list[0])
599
file_list = [b.relpath(f) for f in file_list]
600
if file_list == ['']:
601
# just pointing to top-of-tree
602
file_list = None
603
else:
604
b = Branch.open_containing('.')
605
792
606
if revision is not None:
793
if b2 is not None:
794
raise BzrCommandError("Can't specify -r with two branches")
795
607
if len(revision) == 1:
796
return show_diff(tree.branch, revision[0], specific_files=file_list,
797
external_diff_options=diff_options)
608
show_diff(b, revision[0], specific_files=file_list,
609
external_diff_options=diff_options)
798
610
elif len(revision) == 2:
799
return show_diff(tree.branch, revision[0], specific_files=file_list,
800
external_diff_options=diff_options,
801
revision2=revision[1])
611
show_diff(b, revision[0], specific_files=file_list,
612
external_diff_options=diff_options,
613
revision2=revision[1])
802
614
else:
803
615
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
804
616
else:
805
if b is not None:
806
return show_diff(b, None, specific_files=file_list,
807
external_diff_options=diff_options, b2=b2)
808
else:
809
return show_diff(tree.branch, None, specific_files=file_list,
810
external_diff_options=diff_options)
617
show_diff(b, None, specific_files=file_list,
618
external_diff_options=diff_options)
619
620
811
621
812
622
813
623
class cmd_deleted(Command):
814
624
"""List files deleted in the working tree.
625
626
TODO: Show files deleted since a previous revision, or between two revisions.
815
627
"""
816
# TODO: Show files deleted since a previous revision, or
817
# between two revisions.
818
# TODO: Much more efficient way to do this: read in new
819
# directories with readdir, rather than stating each one. Same
820
# level of effort but possibly much less IO. (Or possibly not,
821
# if the directories are very large...)
822
@display_command
823
628
def run(self, show_ids=False):
824
tree = WorkingTree.open_containing(u'.')[0]
825
old = tree.branch.basis_tree()
629
b = Branch.open_containing('.')
630
old = b.basis_tree()
631
new = b.working_tree()
632
633
## TODO: Much more efficient way to do this: read in new
634
## directories with readdir, rather than stating each one. Same
635
## level of effort but possibly much less IO. (Or possibly not,
636
## if the directories are very large...)
637
826
638
for path, ie in old.inventory.iter_entries():
827
if not tree.has_id(ie.file_id):
639
if not new.has_id(ie.file_id):
828
640
if show_ids:
829
641
print '%-50s %s' % (path, ie.file_id)
830
642
else:
834
646
class cmd_modified(Command):
835
647
"""List files modified in working tree."""
836
648
hidden = True
837
@display_command
838
649
def run(self):
839
650
from bzrlib.delta import compare_trees
840
651
841
tree = WorkingTree.open_containing(u'.')[0]
842
td = compare_trees(tree.branch.basis_tree(), tree)
652
b = Branch.open_containing('.')
653
td = compare_trees(b.basis_tree(), b.working_tree())
843
654
844
for path, id, kind, text_modified, meta_modified in td.modified:
655
for path, id, kind in td.modified:
845
656
print path
846
657
847
658
849
660
class cmd_added(Command):
850
661
"""List files added in working tree."""
851
662
hidden = True
852
@display_command
853
663
def run(self):
854
wt = WorkingTree.open_containing(u'.')[0]
855
basis_inv = wt.branch.basis_tree().inventory
664
b = Branch.open_containing('.')
665
wt = b.working_tree()
666
basis_inv = b.basis_tree().inventory
856
667
inv = wt.inventory
857
668
for file_id in inv:
858
669
if file_id in basis_inv:
870
681
The root is the nearest enclosing directory with a .bzr control
871
682
directory."""
872
683
takes_args = ['filename?']
873
@display_command
874
684
def run(self, filename=None):
875
685
"""Print the branch root."""
876
tree = WorkingTree.open_containing(filename)[0]
877
print tree.basedir
686
b = Branch.open_containing(filename)
687
print b.base
878
688
879
689
880
690
class cmd_log(Command):
881
691
"""Show log of this branch.
882
692
883
To request a range of logs, you can use the command -r begin..end
884
-r revision requests a specific revision, -r ..end or -r begin.. are
693
To request a range of logs, you can use the command -r begin:end
694
-r revision requests a specific revision, -r :end or -r begin: are
885
695
also valid.
696
697
--message allows you to give a regular expression, which will be evaluated
698
so that only matching entries will be displayed.
699
700
TODO: Make --revision support uuid: and hash: [future tag:] notation.
701
886
702
"""
887
703
888
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
889
890
704
takes_args = ['filename?']
891
takes_options = [Option('forward',
892
help='show from oldest to newest'),
893
'timezone', 'verbose',
894
'show-ids', 'revision',
895
'line', 'long',
896
Option('message',
897
help='show revisions whose message matches this regexp',
898
type=str),
899
'short',
900
]
901
@display_command
705
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
706
'long', 'message', 'short',]
707
902
708
def run(self, filename=None, timezone='original',
903
709
verbose=False,
904
710
show_ids=False,
906
712
revision=None,
907
713
message=None,
908
714
long=False,
909
short=False,
910
line=False):
715
short=False):
911
716
from bzrlib.log import log_formatter, show_log
912
717
import codecs
913
assert message is None or isinstance(message, basestring), \
914
"invalid message argument %r" % message
718
915
719
direction = (forward and 'forward') or 'reverse'
916
720
917
721
if filename:
918
# might be a tree:
919
tree = None
920
try:
921
tree, fp = WorkingTree.open_containing(filename)
922
b = tree.branch
923
if fp != '':
924
inv = tree.read_working_inventory()
925
except NotBranchError:
926
pass
927
if tree is None:
928
b, fp = Branch.open_containing(filename)
929
if fp != '':
930
inv = b.get_inventory(b.last_revision())
931
if fp != '':
932
file_id = inv.path2id(fp)
722
b = Branch.open_containing(filename)
723
fp = b.relpath(filename)
724
if fp:
725
file_id = b.read_working_inventory().path2id(fp)
933
726
else:
934
727
file_id = None # points to branch root
935
728
else:
936
tree, relpath = WorkingTree.open_containing(u'.')
937
b = tree.branch
729
b = Branch.open_containing('.')
938
730
file_id = None
939
731
940
732
if revision is None:
948
740
else:
949
741
raise BzrCommandError('bzr log --revision takes one or two values.')
950
742
951
# By this point, the revision numbers are converted to the +ve
952
# form if they were supplied in the -ve form, so we can do
953
# this comparison in relative safety
954
if rev1 > rev2:
955
(rev2, rev1) = (rev1, rev2)
743
if rev1 == 0:
744
rev1 = None
745
if rev2 == 0:
746
rev2 = None
956
747
957
mutter('encoding log as %r', bzrlib.user_encoding)
748
mutter('encoding log as %r' % bzrlib.user_encoding)
958
749
959
750
# use 'replace' so that we don't abort if trying to write out
960
751
# in e.g. the default C locale.
961
752
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
962
753
963
log_format = get_log_format(long=long, short=short, line=line)
754
if not short:
755
log_format = 'long'
756
else:
757
log_format = 'short'
964
758
lf = log_formatter(log_format,
965
759
show_ids=show_ids,
966
760
to_file=outf,
975
769
end_revision=rev2,
976
770
search=message)
977
771
978
def get_log_format(long=False, short=False, line=False, default='long'):
979
log_format = default
980
if long:
981
log_format = 'long'
982
if short:
983
log_format = 'short'
984
if line:
985
log_format = 'line'
986
return log_format
987
772
988
773
989
774
class cmd_touching_revisions(Command):
992
777
A more user-friendly interface is "bzr log FILE"."""
993
778
hidden = True
994
779
takes_args = ["filename"]
995
@display_command
996
780
def run(self, filename):
997
tree, relpath = WorkingTree.open_containing(filename)
998
b = tree.branch
999
inv = tree.read_working_inventory()
1000
file_id = inv.path2id(relpath)
781
b = Branch.open_containing(filename)
782
inv = b.read_working_inventory()
783
file_id = inv.path2id(b.relpath(filename))
1001
784
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1002
785
print "%6d %s" % (revno, what)
1003
786
1004
787
1005
788
class cmd_ls(Command):
1006
789
"""List files in a tree.
790
791
TODO: Take a revision or remote path and list that tree instead.
1007
792
"""
1008
# TODO: Take a revision or remote path and list that tree instead.
1009
793
hidden = True
1010
takes_options = ['verbose', 'revision',
1011
Option('non-recursive',
1012
help='don\'t recurse into sub-directories'),
1013
Option('from-root',
1014
help='Print all paths from the root of the branch.'),
1015
Option('unknown', help='Print unknown files'),
1016
Option('versioned', help='Print versioned files'),
1017
Option('ignored', help='Print ignored files'),
1018
1019
Option('null', help='Null separate the files'),
1020
]
1021
@display_command
1022
def run(self, revision=None, verbose=False,
1023
non_recursive=False, from_root=False,
1024
unknown=False, versioned=False, ignored=False,
1025
null=False):
1026
1027
if verbose and null:
1028
raise BzrCommandError('Cannot set both --verbose and --null')
1029
all = not (unknown or versioned or ignored)
1030
1031
selection = {'I':ignored, '?':unknown, 'V':versioned}
1032
1033
tree, relpath = WorkingTree.open_containing(u'.')
1034
if from_root:
1035
relpath = u''
1036
elif relpath:
1037
relpath += '/'
1038
if revision is not None:
1039
tree = tree.branch.revision_tree(
1040
revision[0].in_history(tree.branch).rev_id)
1041
for fp, fc, kind, fid, entry in tree.list_files():
1042
if fp.startswith(relpath):
1043
fp = fp[len(relpath):]
1044
if non_recursive and '/' in fp:
1045
continue
1046
if not all and not selection[fc]:
1047
continue
1048
if verbose:
1049
kindch = entry.kind_character()
1050
print '%-8s %s%s' % (fc, fp, kindch)
1051
elif null:
1052
sys.stdout.write(fp)
1053
sys.stdout.write('\0')
1054
sys.stdout.flush()
794
def run(self, revision=None, verbose=False):
795
b = Branch.open_containing('.')
796
if revision == None:
797
tree = b.working_tree()
798
else:
799
tree = b.revision_tree(revision.in_history(b).rev_id)
800
801
for fp, fc, kind, fid in tree.list_files():
802
if verbose:
803
if kind == 'directory':
804
kindch = '/'
805
elif kind == 'file':
806
kindch = ''
1055
807
else:
1056
print fp
808
kindch = '???'
809
810
print '%-8s %s%s' % (fc, fp, kindch)
811
else:
812
print fp
813
1057
814
1058
815
1059
816
class cmd_unknowns(Command):
1060
817
"""List unknown files."""
1061
@display_command
1062
818
def run(self):
1063
819
from bzrlib.osutils import quotefn
1064
for f in WorkingTree.open_containing(u'.')[0].unknowns():
820
for f in Branch.open_containing('.').unknowns():
1065
821
print quotefn(f)
1066
822
1067
823
824
1068
825
class cmd_ignore(Command):
1069
826
"""Ignore a command or pattern.
1070
827
1071
828
To remove patterns from the ignore list, edit the .bzrignore file.
1072
829
1073
830
If the pattern contains a slash, it is compared to the whole path
1074
from the branch root. Otherwise, it is compared to only the last
1075
component of the path. To match a file only in the root directory,
1076
prepend './'.
831
from the branch root. Otherwise, it is comapred to only the last
832
component of the path.
1077
833
1078
834
Ignore patterns are case-insensitive on case-insensitive systems.
1079
835
1083
839
bzr ignore ./Makefile
1084
840
bzr ignore '*.class'
1085
841
"""
1086
# TODO: Complain if the filename is absolute
1087
842
takes_args = ['name_pattern']
1088
843
1089
844
def run(self, name_pattern):
1090
845
from bzrlib.atomicfile import AtomicFile
1091
846
import os.path
1092
847
1093
tree, relpath = WorkingTree.open_containing(u'.')
1094
ifn = tree.abspath('.bzrignore')
848
b = Branch.open_containing('.')
849
ifn = b.abspath('.bzrignore')
1095
850
1096
851
if os.path.exists(ifn):
1097
852
f = open(ifn, 'rt')
1116
871
finally:
1117
872
f.close()
1118
873
1119
inv = tree.inventory
874
inv = b.working_tree().inventory
1120
875
if inv.path2id('.bzrignore'):
1121
876
mutter('.bzrignore is already versioned')
1122
877
else:
1123
878
mutter('need to make new .bzrignore file versioned')
1124
tree.add(['.bzrignore'])
879
b.add(['.bzrignore'])
880
1125
881
1126
882
1127
883
class cmd_ignored(Command):
1128
884
"""List ignored files and the patterns that matched them.
1129
885
1130
886
See also: bzr ignore"""
1131
@display_command
1132
887
def run(self):
1133
tree = WorkingTree.open_containing(u'.')[0]
1134
for path, file_class, kind, file_id, entry in tree.list_files():
888
tree = Branch.open_containing('.').working_tree()
889
for path, file_class, kind, file_id in tree.list_files():
1135
890
if file_class != 'I':
1136
891
continue
1137
892
## XXX: Slightly inefficient since this was already calculated
1148
903
hidden = True
1149
904
takes_args = ['revno']
1150
905
1151
@display_command
1152
906
def run(self, revno):
1153
907
try:
1154
908
revno = int(revno)
1155
909
except ValueError:
1156
910
raise BzrCommandError("not a valid revision-number: %r" % revno)
1157
911
1158
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
912
print Branch.open_containing('.').get_rev_id(revno)
1159
913
1160
914
1161
915
class cmd_export(Command):
1168
922
is found exports to a directory (equivalent to --format=dir).
1169
923
1170
924
Root may be the top directory for tar, tgz and tbz2 formats. If none
1171
is given, the top directory will be the root name of the file.
1172
1173
Note: export of tree with non-ascii filenames to zip is not supported.
1174
1175
Supported formats Autodetected by extension
1176
----------------- -------------------------
1177
dir -
1178
tar .tar
1179
tbz2 .tar.bz2, .tbz2
1180
tgz .tar.gz, .tgz
1181
zip .zip
1182
"""
925
is given, the top directory will be the root name of the file."""
926
# TODO: list known exporters
1183
927
takes_args = ['dest']
1184
928
takes_options = ['revision', 'format', 'root']
1185
929
def run(self, dest, revision=None, format=None, root=None):
1186
930
import os.path
1187
from bzrlib.export import export
1188
tree = WorkingTree.open_containing(u'.')[0]
1189
b = tree.branch
931
b = Branch.open_containing('.')
1190
932
if revision is None:
1191
# should be tree.last_revision FIXME
1192
933
rev_id = b.last_revision()
1193
934
else:
1194
935
if len(revision) != 1:
1195
936
raise BzrError('bzr export --revision takes exactly 1 argument')
1196
937
rev_id = revision[0].in_history(b).rev_id
1197
938
t = b.revision_tree(rev_id)
1198
try:
1199
export(t, dest, format, root)
1200
except errors.NoSuchExportFormat, e:
1201
raise BzrCommandError('Unsupported export format: %s' % e.format)
939
root, ext = os.path.splitext(dest)
940
if not format:
941
if ext in (".tar",):
942
format = "tar"
943
elif ext in (".gz", ".tgz"):
944
format = "tgz"
945
elif ext in (".bz2", ".tbz2"):
946
format = "tbz2"
947
else:
948
format = "dir"
949
t.export(dest, format, root)
1202
950
1203
951
1204
952
class cmd_cat(Command):
1207
955
takes_options = ['revision']
1208
956
takes_args = ['filename']
1209
957
1210
@display_command
1211
958
def run(self, filename, revision=None):
1212
if revision is not None and len(revision) != 1:
959
if revision is None:
960
raise BzrCommandError("bzr cat requires a revision number")
961
elif len(revision) != 1:
1213
962
raise BzrCommandError("bzr cat --revision takes exactly one number")
1214
tree = None
1215
try:
1216
tree, relpath = WorkingTree.open_containing(filename)
1217
b = tree.branch
1218
except NotBranchError:
1219
pass
1220
1221
if tree is None:
1222
b, relpath = Branch.open_containing(filename)
1223
if revision is None:
1224
revision_id = b.last_revision()
1225
else:
1226
revision_id = revision[0].in_history(b).rev_id
1227
b.print_file(relpath, revision_id)
963
b = Branch.open_containing('.')
964
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
1228
965
1229
966
1230
967
class cmd_local_time_offset(Command):
1231
968
"""Show the offset in seconds from GMT to local time."""
1232
969
hidden = True
1233
@display_command
1234
970
def run(self):
1235
971
print bzrlib.osutils.local_time_offset()
1236
972
1248
984
A selected-file commit may fail in some cases where the committed
1249
985
tree would be invalid, such as trying to commit a file in a
1250
986
newly-added directory that is not itself committed.
987
988
TODO: Run hooks on tree to-be-committed, and after commit.
989
990
TODO: Strict commit that fails if there are unknown or deleted files.
1251
991
"""
1252
# TODO: Run hooks on tree to-be-committed, and after commit.
1253
1254
# TODO: Strict commit that fails if there are deleted files.
1255
# (what does "deleted files" mean ??)
992
takes_args = ['selected*']
993
takes_options = ['message', 'file', 'verbose', 'unchanged']
994
aliases = ['ci', 'checkin']
1256
995
1257
996
# TODO: Give better message for -s, --summary, used by tla people
1258
997
1259
998
# XXX: verbose currently does nothing
1260
1261
takes_args = ['selected*']
1262
takes_options = ['message', 'verbose',
1263
Option('unchanged',
1264
help='commit even if nothing has changed'),
1265
Option('file', type=str,
1266
argname='msgfile',
1267
help='file containing commit message'),
1268
Option('strict',
1269
help="refuse to commit if there are unknown "
1270
"files in the working tree."),
1271
]
1272
aliases = ['ci', 'checkin']
1273
999
1274
1000
def run(self, message=None, file=None, verbose=True, selected_list=None,
1275
unchanged=False, strict=False):
1276
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1277
StrictCommitFailed)
1278
from bzrlib.msgeditor import edit_commit_message, \
1279
make_commit_message_template
1001
unchanged=False):
1002
from bzrlib.errors import PointlessCommit
1003
from bzrlib.msgeditor import edit_commit_message
1280
1004
from bzrlib.status import show_status
1281
from tempfile import TemporaryFile
1282
import codecs
1283
1284
# TODO: Need a blackbox test for invoking the external editor; may be
1285
# slightly problematic to run this cross-platform.
1286
1287
# TODO: do more checks that the commit will succeed before
1288
# spending the user's valuable time typing a commit message.
1289
#
1290
# TODO: if the commit *does* happen to fail, then save the commit
1291
# message to a temporary file where it can be recovered
1292
tree, selected_list = tree_files(selected_list)
1293
if message is None and not file:
1294
template = make_commit_message_template(tree, selected_list)
1295
message = edit_commit_message(template)
1005
from cStringIO import StringIO
1006
1007
b = Branch.open_containing('.')
1008
if selected_list:
1009
selected_list = [b.relpath(s) for s in selected_list]
1010
1011
if not message and not file:
1012
catcher = StringIO()
1013
show_status(b, specific_files=selected_list,
1014
to_file=catcher)
1015
message = edit_commit_message(catcher.getvalue())
1016
1296
1017
if message is None:
1297
1018
raise BzrCommandError("please specify a commit message"
1298
1019
" with either --message or --file")
1303
1024
import codecs
1304
1025
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1305
1026
1306
if message == "":
1307
raise BzrCommandError("empty commit message specified")
1308
1309
1027
try:
1310
tree.commit(message, specific_files=selected_list,
1311
allow_pointless=unchanged, strict=strict)
1028
b.commit(message,
1029
specific_files=selected_list,
1030
allow_pointless=unchanged)
1312
1031
except PointlessCommit:
1313
1032
# FIXME: This should really happen before the file is read in;
1314
1033
# perhaps prepare the commit; get the message; then actually commit
1315
1034
raise BzrCommandError("no changes to commit",
1316
1035
["use --unchanged to commit anyhow"])
1317
except ConflictsInTree:
1318
raise BzrCommandError("Conflicts detected in working tree. "
1319
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1320
except StrictCommitFailed:
1321
raise BzrCommandError("Commit refused because there are unknown "
1322
"files in the working tree.")
1323
note('Committed revision %d.' % (tree.branch.revno(),))
1324
1036
1325
1037
1326
1038
class cmd_check(Command):
1329
1041
This command checks various invariants about the branch storage to
1330
1042
detect data corruption or bzr bugs.
1331
1043
"""
1332
takes_args = ['branch?']
1333
takes_options = ['verbose']
1044
takes_args = ['dir?']
1334
1045
1335
def run(self, branch=None, verbose=False):
1046
def run(self, dir='.'):
1336
1047
from bzrlib.check import check
1337
if branch is None:
1338
tree = WorkingTree.open_containing()[0]
1339
branch = tree.branch
1340
else:
1341
branch = Branch.open(branch)
1342
check(branch, verbose)
1048
1049
check(Branch.open_containing(dir))
1343
1050
1344
1051
1345
1052
class cmd_scan_cache(Command):
1347
1054
def run(self):
1348
1055
from bzrlib.hashcache import HashCache
1349
1056
1350
c = HashCache(u'.')
1057
c = HashCache('.')
1351
1058
c.read()
1352
1059
c.scan()
1353
1060
1373
1080
"""
1374
1081
takes_args = ['dir?']
1375
1082
1376
def run(self, dir=u'.'):
1083
def run(self, dir='.'):
1377
1084
from bzrlib.upgrade import upgrade
1378
1085
upgrade(dir)
1379
1086
1382
1089
"""Show bzr user id."""
1383
1090
takes_options = ['email']
1384
1091
1385
@display_command
1386
1092
def run(self, email=False):
1387
1093
try:
1388
b = WorkingTree.open_containing(u'.')[0].branch
1389
config = bzrlib.config.BranchConfig(b)
1094
b = bzrlib.branch.Branch.open_containing('.')
1390
1095
except NotBranchError:
1391
config = bzrlib.config.GlobalConfig()
1096
b = None
1392
1097
1393
1098
if email:
1394
print config.user_email()
1395
else:
1396
print config.username()
1397
1398
class cmd_nick(Command):
1399
"""\
1400
Print or set the branch nickname.
1401
If unset, the tree root directory name is used as the nickname
1402
To print the current nickname, execute with no argument.
1403
"""
1404
takes_args = ['nickname?']
1405
def run(self, nickname=None):
1406
branch = Branch.open_containing(u'.')[0]
1407
if nickname is None:
1408
self.printme(branch)
1409
else:
1410
branch.nick = nickname
1411
1412
@display_command
1413
def printme(self, branch):
1414
print branch.nick
1099
print bzrlib.osutils.user_email(b)
1100
else:
1101
print bzrlib.osutils.username(b)
1102
1415
1103
1416
1104
class cmd_selftest(Command):
1417
"""Run internal test suite.
1418
1419
This creates temporary test directories in the working directory,
1420
but not existing data is affected. These directories are deleted
1421
if the tests pass, or left behind to help in debugging if they
1422
fail and --keep-output is specified.
1423
1424
If arguments are given, they are regular expressions that say
1425
which tests should run.
1426
"""
1427
# TODO: --list should give a list of all available tests
1105
"""Run internal test suite"""
1428
1106
hidden = True
1429
takes_args = ['testspecs*']
1430
takes_options = ['verbose',
1431
Option('one', help='stop when one test fails'),
1432
Option('keep-output',
1433
help='keep output directories when tests fail')
1434
]
1435
1436
def run(self, testspecs_list=None, verbose=False, one=False,
1437
keep_output=False):
1107
takes_options = ['verbose', 'pattern']
1108
def run(self, verbose=False, pattern=".*"):
1438
1109
import bzrlib.ui
1439
from bzrlib.tests import selftest
1110
from bzrlib.selftest import selftest
1440
1111
# we don't want progress meters from the tests to go to the
1441
1112
# real output; and we don't want log messages cluttering up
1442
1113
# the real logs.
1444
1115
bzrlib.trace.info('running tests...')
1445
1116
try:
1446
1117
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1447
if testspecs_list is not None:
1448
pattern = '|'.join(testspecs_list)
1449
else:
1450
pattern = ".*"
1451
result = selftest(verbose=verbose,
1452
pattern=pattern,
1453
stop_on_failure=one,
1454
keep_output=keep_output)
1118
result = selftest(verbose=verbose, pattern=pattern)
1455
1119
if result:
1456
1120
bzrlib.trace.info('tests passed')
1457
1121
else:
1461
1125
bzrlib.ui.ui_factory = save_ui
1462
1126
1463
1127
1464
def _get_bzr_branch():
1465
"""If bzr is run from a branch, return Branch or None"""
1466
import bzrlib.errors
1467
from bzrlib.branch import Branch
1468
from bzrlib.osutils import abspath
1469
from os.path import dirname
1470
1471
try:
1472
branch = Branch.open(dirname(abspath(dirname(__file__))))
1473
return branch
1474
except bzrlib.errors.BzrError:
1475
return None
1476
1477
1478
1128
def show_version():
1479
1129
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1480
1130
# is bzrlib itself in a branch?
1481
branch = _get_bzr_branch()
1482
if branch:
1483
rh = branch.revision_history()
1484
revno = len(rh)
1485
print " bzr checkout, revision %d" % (revno,)
1486
print " nick: %s" % (branch.nick,)
1487
if rh:
1488
print " revid: %s" % (rh[-1],)
1131
bzrrev = bzrlib.get_bzr_revision()
1132
if bzrrev:
1133
print " (bzr checkout, revision %d {%s})" % bzrrev
1489
1134
print bzrlib.__copyright__
1490
1135
print "http://bazaar-ng.org/"
1491
1136
print
1496
1141
1497
1142
class cmd_version(Command):
1498
1143
"""Show version of bzr."""
1499
@display_command
1500
1144
def run(self):
1501
1145
show_version()
1502
1146
1503
1147
class cmd_rocks(Command):
1504
1148
"""Statement of optimism."""
1505
1149
hidden = True
1506
@display_command
1507
1150
def run(self):
1508
1151
print "it sure does!"
1509
1152
1510
1153
1511
1154
class cmd_find_merge_base(Command):
1512
1155
"""Find and print a base revision for merging two branches.
1156
1157
TODO: Options to specify revisions on either side, as if
1158
merging only part of the history.
1513
1159
"""
1514
# TODO: Options to specify revisions on either side, as if
1515
# merging only part of the history.
1516
1160
takes_args = ['branch', 'other']
1517
1161
hidden = True
1518
1162
1519
@display_command
1520
1163
def run(self, branch, other):
1521
1164
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1522
1165
1523
branch1 = Branch.open_containing(branch)[0]
1524
branch2 = Branch.open_containing(other)[0]
1166
branch1 = Branch.open_containing(branch)
1167
branch2 = Branch.open_containing(other)
1525
1168
1526
1169
history_1 = branch1.revision_history()
1527
1170
history_2 = branch2.revision_history()
1576
1219
--force is given.
1577
1220
"""
1578
1221
takes_args = ['branch?']
1579
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1580
Option('show-base', help="Show base revision text in "
1581
"conflicts")]
1222
takes_options = ['revision', 'force', 'merge-type']
1582
1223
1583
def run(self, branch=None, revision=None, force=False, merge_type=None,
1584
show_base=False, reprocess=False):
1224
def run(self, branch='.', revision=None, force=False,
1225
merge_type=None):
1585
1226
from bzrlib.merge import merge
1586
1227
from bzrlib.merge_core import ApplyMerge3
1587
1228
if merge_type is None:
1588
1229
merge_type = ApplyMerge3
1589
if branch is None:
1590
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1591
if branch is None:
1592
raise BzrCommandError("No merge location known or specified.")
1593
else:
1594
print "Using saved location: %s" % branch
1230
1595
1231
if revision is None or len(revision) < 1:
1596
1232
base = [None, None]
1597
1233
other = [branch, -1]
1598
1234
else:
1599
1235
if len(revision) == 1:
1600
1236
base = [None, None]
1601
other_branch = Branch.open_containing(branch)[0]
1602
revno = revision[0].in_history(other_branch).revno
1603
other = [branch, revno]
1237
other = [branch, revision[0].in_history(branch).revno]
1604
1238
else:
1605
1239
assert len(revision) == 2
1606
1240
if None in revision:
1607
1241
raise BzrCommandError(
1608
1242
"Merge doesn't permit that revision specifier.")
1609
b = Branch.open_containing(branch)[0]
1243
from bzrlib.branch import Branch
1244
b = Branch.open(branch)
1610
1245
1611
1246
base = [branch, revision[0].in_history(b).revno]
1612
1247
other = [branch, revision[1].in_history(b).revno]
1613
1248
1614
1249
try:
1615
conflict_count = merge(other, base, check_clean=(not force),
1616
merge_type=merge_type, reprocess=reprocess,
1617
show_base=show_base)
1618
if conflict_count != 0:
1619
return 1
1620
else:
1621
return 0
1250
merge(other, base, check_clean=(not force), merge_type=merge_type)
1622
1251
except bzrlib.errors.AmbiguousBase, e:
1623
1252
m = ("sorry, bzr can't determine the right merge base yet\n"
1624
1253
"candidates are:\n "
1629
1258
log_error(m)
1630
1259
1631
1260
1632
class cmd_remerge(Command):
1633
"""Redo a merge.
1634
"""
1635
takes_args = ['file*']
1636
takes_options = ['merge-type', 'reprocess',
1637
Option('show-base', help="Show base revision text in "
1638
"conflicts")]
1639
1640
def run(self, file_list=None, merge_type=None, show_base=False,
1641
reprocess=False):
1642
from bzrlib.merge import merge_inner, transform_tree
1643
from bzrlib.merge_core import ApplyMerge3
1644
if merge_type is None:
1645
merge_type = ApplyMerge3
1646
tree, file_list = tree_files(file_list)
1647
tree.lock_write()
1648
try:
1649
pending_merges = tree.pending_merges()
1650
if len(pending_merges) != 1:
1651
raise BzrCommandError("Sorry, remerge only works after normal"
1652
+ " merges. Not cherrypicking or"
1653
+ "multi-merges.")
1654
base_revision = common_ancestor(tree.branch.last_revision(),
1655
pending_merges[0], tree.branch)
1656
base_tree = tree.branch.revision_tree(base_revision)
1657
other_tree = tree.branch.revision_tree(pending_merges[0])
1658
interesting_ids = None
1659
if file_list is not None:
1660
interesting_ids = set()
1661
for filename in file_list:
1662
file_id = tree.path2id(filename)
1663
interesting_ids.add(file_id)
1664
if tree.kind(file_id) != "directory":
1665
continue
1666
1667
for name, ie in tree.inventory.iter_entries(file_id):
1668
interesting_ids.add(ie.file_id)
1669
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1670
if file_list is None:
1671
restore_files = list(tree.iter_conflicts())
1672
else:
1673
restore_files = file_list
1674
for filename in restore_files:
1675
try:
1676
restore(tree.abspath(filename))
1677
except NotConflicted:
1678
pass
1679
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1680
interesting_ids = interesting_ids,
1681
other_rev_id=pending_merges[0],
1682
merge_type=merge_type,
1683
show_base=show_base,
1684
reprocess=reprocess)
1685
finally:
1686
tree.unlock()
1687
if conflicts > 0:
1688
return 1
1689
else:
1690
return 0
1691
1692
1261
class cmd_revert(Command):
1693
1262
"""Reverse all changes since the last commit.
1694
1263
1701
1270
aliases = ['merge-revert']
1702
1271
1703
1272
def run(self, revision=None, no_backup=False, file_list=None):
1704
from bzrlib.merge import merge_inner
1273
from bzrlib.merge import merge
1274
from bzrlib.branch import Branch
1705
1275
from bzrlib.commands import parse_spec
1276
1706
1277
if file_list is not None:
1707
1278
if len(file_list) == 0:
1708
1279
raise BzrCommandError("No files specified")
1709
else:
1710
file_list = []
1711
1280
if revision is None:
1712
1281
revno = -1
1713
tree = WorkingTree.open_containing(u'.')[0]
1714
# FIXME should be tree.last_revision
1715
rev_id = tree.branch.last_revision()
1716
1282
elif len(revision) != 1:
1717
1283
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1718
1284
else:
1719
tree, file_list = tree_files(file_list)
1720
rev_id = revision[0].in_history(tree.branch).rev_id
1721
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1722
not no_backup)
1285
b = Branch.open_containing('.')
1286
revno = revision[0].in_history(b).revno
1287
merge(('.', revno), parse_spec('.'),
1288
check_clean=False,
1289
ignore_zero=True,
1290
backup_files=not no_backup,
1291
file_list=file_list)
1292
if not file_list:
1293
Branch.open_containing('.').set_pending_merges([])
1723
1294
1724
1295
1725
1296
class cmd_assert_fail(Command):
1737
1308
takes_args = ['topic?']
1738
1309
aliases = ['?']
1739
1310
1740
@display_command
1741
1311
def run(self, topic=None, long=False):
1742
1312
import help
1743
1313
if topic is None and long:
1753
1323
aliases = ['s-c']
1754
1324
hidden = True
1755
1325
1756
@display_command
1757
1326
def run(self, context=None):
1758
1327
import shellcomplete
1759
1328
shellcomplete.shellcomplete(context)
1768
1337
def run(self, from_branch, to_branch):
1769
1338
from bzrlib.fetch import Fetcher
1770
1339
from bzrlib.branch import Branch
1771
from_b = Branch.open(from_branch)
1772
to_b = Branch.open(to_branch)
1773
from_b.lock_read()
1774
try:
1775
to_b.lock_write()
1776
try:
1777
Fetcher(to_b, from_b)
1778
finally:
1779
to_b.unlock()
1780
finally:
1781
from_b.unlock()
1340
from_b = Branch(from_branch)
1341
to_b = Branch(to_branch)
1342
Fetcher(to_b, from_b)
1343
1782
1344
1783
1345
1784
1346
class cmd_missing(Command):
1785
"""Show unmerged/unpulled revisions between two branches.
1786
1787
OTHER_BRANCH may be local or remote."""
1788
takes_args = ['other_branch?']
1789
takes_options = [Option('reverse', 'Reverse the order of revisions'),
1790
Option('mine-only',
1791
'Display changes in the local branch only'),
1792
Option('theirs-only',
1793
'Display changes in the remote branch only'),
1794
'line',
1795
'long',
1796
'short',
1797
'show-ids',
1798
'verbose'
1799
]
1800
1801
def run(self, other_branch=None, reverse=False, mine_only=False,
1802
theirs_only=False, long=True, short=False, line=False,
1803
show_ids=False, verbose=False):
1804
from bzrlib.missing import find_unmerged, iter_log_data
1805
from bzrlib.log import log_formatter
1806
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
1807
parent = local_branch.get_parent()
1808
if other_branch is None:
1809
other_branch = parent
1810
if other_branch is None:
1347
"""What is missing in this branch relative to other branch.
1348
"""
1349
# TODO: rewrite this in terms of ancestry so that it shows only
1350
# unmerged things
1351
1352
takes_args = ['remote?']
1353
aliases = ['mis', 'miss']
1354
# We don't have to add quiet to the list, because
1355
# unknown options are parsed as booleans
1356
takes_options = ['verbose', 'quiet']
1357
1358
def run(self, remote=None, verbose=False, quiet=False):
1359
from bzrlib.errors import BzrCommandError
1360
from bzrlib.missing import show_missing
1361
1362
if verbose and quiet:
1363
raise BzrCommandError('Cannot pass both quiet and verbose')
1364
1365
b = Branch.open_containing('.')
1366
parent = b.get_parent()
1367
if remote is None:
1368
if parent is None:
1811
1369
raise BzrCommandError("No missing location known or specified.")
1812
print "Using last location: " + local_branch.get_parent()
1813
remote_branch = bzrlib.branch.Branch.open(other_branch)
1814
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1815
log_format = get_log_format(long=long, short=short, line=line)
1816
lf = log_formatter(log_format, sys.stdout,
1817
show_ids=show_ids,
1818
show_timezone='original')
1819
if reverse is False:
1820
local_extra.reverse()
1821
remote_extra.reverse()
1822
if local_extra and not theirs_only:
1823
print "You have %d extra revision(s):" % len(local_extra)
1824
for data in iter_log_data(local_extra, local_branch, verbose):
1825
lf.show(*data)
1826
printed_local = True
1827
else:
1828
printed_local = False
1829
if remote_extra and not mine_only:
1830
if printed_local is True:
1831
print "\n\n"
1832
print "You are missing %d revision(s):" % len(remote_extra)
1833
for data in iter_log_data(remote_extra, remote_branch, verbose):
1834
lf.show(*data)
1835
if not remote_extra and not local_extra:
1836
status_code = 0
1837
print "Branches are up to date."
1838
else:
1839
status_code = 1
1840
if parent is None and other_branch is not None:
1841
local_branch.set_parent(other_branch)
1842
return status_code
1370
else:
1371
if not quiet:
1372
print "Using last location: %s" % parent
1373
remote = parent
1374
elif parent is None:
1375
# We only update parent if it did not exist, missing
1376
# should not change the parent
1377
b.set_parent(remote)
1378
br_remote = Branch.open_containing(remote)
1379
1380
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1381
1843
1382
1844
1383
1845
1384
class cmd_plugins(Command):
1846
1385
"""List plugins"""
1847
1386
hidden = True
1848
@display_command
1849
1387
def run(self):
1850
1388
import bzrlib.plugin
1851
1389
from inspect import getdoc
1852
for name, plugin in bzrlib.plugin.all_plugins().items():
1390
for plugin in bzrlib.plugin.all_plugins:
1853
1391
if hasattr(plugin, '__path__'):
1854
1392
print plugin.__path__[0]
1855
1393
elif hasattr(plugin, '__file__'):
1862
1400
print '\t', d.split('\n')[0]
1863
1401
1864
1402
1865
class cmd_testament(Command):
1866
"""Show testament (signing-form) of a revision."""
1867
takes_options = ['revision', 'long']
1868
takes_args = ['branch?']
1869
@display_command
1870
def run(self, branch=u'.', revision=None, long=False):
1871
from bzrlib.testament import Testament
1872
b = WorkingTree.open_containing(branch)[0].branch
1873
b.lock_read()
1874
try:
1875
if revision is None:
1876
rev_id = b.last_revision()
1877
else:
1878
rev_id = revision[0].in_history(b).rev_id
1879
t = Testament.from_revision(b, rev_id)
1880
if long:
1881
sys.stdout.writelines(t.as_text_lines())
1882
else:
1883
sys.stdout.write(t.as_short_text())
1884
finally:
1885
b.unlock()
1886
1887
1888
class cmd_annotate(Command):
1889
"""Show the origin of each line in a file.
1890
1891
This prints out the given file with an annotation on the left side
1892
indicating which revision, author and date introduced the change.
1893
1894
If the origin is the same for a run of consecutive lines, it is
1895
shown only at the top, unless the --all option is given.
1896
"""
1897
# TODO: annotate directories; showing when each file was last changed
1898
# TODO: annotate a previous version of a file
1899
# TODO: if the working copy is modified, show annotations on that
1900
# with new uncommitted lines marked
1901
aliases = ['blame', 'praise']
1902
takes_args = ['filename']
1903
takes_options = [Option('all', help='show annotations on all lines'),
1904
Option('long', help='show date in annotations'),
1905
]
1906
1907
@display_command
1908
def run(self, filename, all=False, long=False):
1909
from bzrlib.annotate import annotate_file
1910
tree, relpath = WorkingTree.open_containing(filename)
1911
branch = tree.branch
1912
branch.lock_read()
1913
try:
1914
file_id = tree.inventory.path2id(relpath)
1915
tree = branch.revision_tree(branch.last_revision())
1916
file_version = tree.inventory[file_id].revision
1917
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1918
finally:
1919
branch.unlock()
1920
1921
1922
class cmd_re_sign(Command):
1923
"""Create a digital signature for an existing revision."""
1924
# TODO be able to replace existing ones.
1925
1926
hidden = True # is this right ?
1927
takes_args = ['revision_id?']
1928
takes_options = ['revision']
1929
1930
def run(self, revision_id=None, revision=None):
1931
import bzrlib.config as config
1932
import bzrlib.gpg as gpg
1933
if revision_id is not None and revision is not None:
1934
raise BzrCommandError('You can only supply one of revision_id or --revision')
1935
if revision_id is None and revision is None:
1936
raise BzrCommandError('You must supply either --revision or a revision_id')
1937
b = WorkingTree.open_containing(u'.')[0].branch
1938
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1939
if revision_id is not None:
1940
b.sign_revision(revision_id, gpg_strategy)
1941
elif revision is not None:
1942
if len(revision) == 1:
1943
revno, rev_id = revision[0].in_history(b)
1944
b.sign_revision(rev_id, gpg_strategy)
1945
elif len(revision) == 2:
1946
# are they both on rh- if so we can walk between them
1947
# might be nice to have a range helper for arbitrary
1948
# revision paths. hmm.
1949
from_revno, from_revid = revision[0].in_history(b)
1950
to_revno, to_revid = revision[1].in_history(b)
1951
if to_revid is None:
1952
to_revno = b.revno()
1953
if from_revno is None or to_revno is None:
1954
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1955
for revno in range(from_revno, to_revno + 1):
1956
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1957
else:
1958
raise BzrCommandError('Please supply either one revision, or a range.')
1959
1960
1961
class cmd_uncommit(bzrlib.commands.Command):
1962
"""Remove the last committed revision.
1963
1964
By supplying the --all flag, it will not only remove the entry
1965
from revision_history, but also remove all of the entries in the
1966
stores.
1967
1968
--verbose will print out what is being removed.
1969
--dry-run will go through all the motions, but not actually
1970
remove anything.
1971
1972
In the future, uncommit will create a changeset, which can then
1973
be re-applied.
1974
"""
1975
takes_options = ['all', 'verbose', 'revision',
1976
Option('dry-run', help='Don\'t actually make changes'),
1977
Option('force', help='Say yes to all questions.')]
1978
takes_args = ['location?']
1979
aliases = []
1980
1981
def run(self, location=None, all=False,
1982
dry_run=False, verbose=False,
1983
revision=None, force=False):
1984
from bzrlib.branch import Branch
1985
from bzrlib.log import log_formatter
1986
import sys
1987
from bzrlib.uncommit import uncommit
1988
1989
if location is None:
1990
location = u'.'
1991
b, relpath = Branch.open_containing(location)
1992
1993
if revision is None:
1994
revno = b.revno()
1995
rev_id = b.last_revision()
1996
else:
1997
revno, rev_id = revision[0].in_history(b)
1998
if rev_id is None:
1999
print 'No revisions to uncommit.'
2000
2001
for r in range(revno, b.revno()+1):
2002
rev_id = b.get_rev_id(r)
2003
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2004
lf.show(r, b.get_revision(rev_id), None)
2005
2006
if dry_run:
2007
print 'Dry-run, pretending to remove the above revisions.'
2008
if not force:
2009
val = raw_input('Press <enter> to continue')
2010
else:
2011
print 'The above revision(s) will be removed.'
2012
if not force:
2013
val = raw_input('Are you sure [y/N]? ')
2014
if val.lower() not in ('y', 'yes'):
2015
print 'Canceled'
2016
return 0
2017
2018
uncommit(b, remove_files=all,
2019
dry_run=dry_run, verbose=verbose,
2020
revno=revno)
2021
2022
2023
# these get imported and then picked up by the scan for cmd_*
2024
# TODO: Some more consistent way to split command definitions across files;
2025
# we do need to load at least some information about them to know of
2026
# aliases.
2027
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
Loggerhead is a web-based interface for Breezy
Version: 2.0.1