« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1544
- compare with another revision
- download diff
- download tarball
- view history from revision 1544
- Committer: Martin Pool
- Date: 2006-01-13 06:31:42 UTC
- Revision ID: mbp@sourcefrog.net-20060113063142-8e706dc1483c69e1
Bump version to 0.8pre
- files added:
- BRANCH.TODO
- bzrlib/export
- bzrlib/tests/blackbox
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files removed:
- bzrlib/mdiff.py
- files renamed:
- bzr-man.py => bzr_man.py
- bzrlib/plugins/conflicts.py => bzrlib/conflicts.py
- bzrlib/selftest/ => bzrlib/tests/
- bzrlib/selftest/test_revision_info.py => bzrlib/tests/blackbox/test_revision_info.py
- bzrlib/selftest/blackbox.py => bzrlib/tests/blackbox/test_too_much.py
- bzrlib/selftest/versioning.py => bzrlib/tests/blackbox/test_versioning.py
- bzrlib/selftest/testbranch.py => bzrlib/tests/test_branch.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testfetch.py => bzrlib/tests/test_fetch.py
- bzrlib/selftest/testgraph.py => bzrlib/tests/test_graph.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testinv.py => bzrlib/tests/test_inv.py
- bzrlib/selftest/testlog.py => bzrlib/tests/test_log.py
- bzrlib/selftest/testmerge.py => bzrlib/tests/test_merge.py
- bzrlib/selftest/testmerge3.py => bzrlib/tests/test_merge3.py
- bzrlib/selftest/plugins.py => bzrlib/tests/test_plugins.py
- bzrlib/selftest/testrevision.py => bzrlib/tests/test_revision.py
- bzrlib/selftest/testrevisionnamespaces.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/selftest/testsampler.py => bzrlib/tests/test_sampler.py
- bzrlib/selftest/teststatus.py => bzrlib/tests/test_status.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- bzrlib/selftest/testtransport.py => bzrlib/tests/test_transport.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- bzrlib/selftest/testworkingtree.py => bzrlib/tests/test_workingtree.py
- bzrlib/ui.py => bzrlib/ui/__init__.py
- files modified:
- .bzrignore
- 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
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
18
25
import sys
19
26
import os
20
27
21
28
import bzrlib
29
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
22
39
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
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
28
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?)
29
75
30
76
class cmd_status(Command):
31
77
"""Display status summary.
66
112
If a revision argument is given, the status is calculated against
67
113
that revision, or between two revisions if two are provided.
68
114
"""
69
# XXX: FIXME: bzr status should accept a -r option to show changes
70
# relative to a revision, or between revisions
71
115
116
# TODO: --no-recurse, --recurse options
117
72
118
takes_args = ['file*']
73
takes_options = ['all', 'show-ids']
119
takes_options = ['all', 'show-ids', 'revision']
74
120
aliases = ['st', 'stat']
75
121
122
@display_command
76
123
def run(self, all=False, show_ids=False, file_list=None, revision=None):
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('.')
124
tree, file_list = tree_files(file_list)
86
125
87
126
from bzrlib.status import show_status
88
show_status(b, show_unchanged=all, show_ids=show_ids,
127
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
89
128
specific_files=file_list, revision=revision)
90
129
91
130
100
139
takes_args = ['revision_id?']
101
140
takes_options = ['revision']
102
141
142
@display_command
103
143
def run(self, revision_id=None, revision=None):
104
from bzrlib.revisionspec import RevisionSpec
105
144
106
145
if revision_id is not None and revision is not None:
107
146
raise BzrCommandError('You can only supply one of revision_id or --revision')
108
147
if revision_id is None and revision is None:
109
148
raise BzrCommandError('You must supply either --revision or a revision_id')
110
b = Branch.open_containing('.')
149
b = WorkingTree.open_containing(u'.')[0].branch
111
150
if revision_id is not None:
112
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
151
sys.stdout.write(b.get_revision_xml(revision_id))
113
152
elif revision is not None:
114
153
for rev in revision:
115
154
if rev is None:
116
155
raise BzrCommandError('You cannot specify a NULL revision.')
117
156
revno, rev_id = rev.in_history(b)
118
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
157
sys.stdout.write(b.get_revision_xml(rev_id))
119
158
120
159
121
160
class cmd_revno(Command):
122
161
"""Show current revision number.
123
162
124
163
This is equal to the number of revisions on this branch."""
125
def run(self):
126
print Branch.open_containing('.').revno()
164
takes_args = ['location?']
165
@display_command
166
def run(self, location=u'.'):
167
print Branch.open_containing(location)[0].revno()
127
168
128
169
129
170
class cmd_revision_info(Command):
132
173
hidden = True
133
174
takes_args = ['revision_info*']
134
175
takes_options = ['revision']
176
@display_command
135
177
def run(self, revision=None, revision_info_list=[]):
136
from bzrlib.revisionspec import RevisionSpec
137
178
138
179
revs = []
139
180
if revision is not None:
144
185
if len(revs) == 0:
145
186
raise BzrCommandError('You must supply a revision identifier')
146
187
147
b = Branch.open_containing('.')
188
b = WorkingTree.open_containing(u'.')[0].branch
148
189
149
190
for rev in revs:
150
191
revinfo = rev.in_history(b)
176
217
implicitly add the parent, and so on up to the root. This means
177
218
you should never need to explictly add a directory, they'll just
178
219
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.
179
223
"""
180
224
takes_args = ['file*']
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
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."
188
254
189
255
190
256
class cmd_mkdir(Command):
195
261
takes_args = ['dir+']
196
262
197
263
def run(self, dir_list):
198
b = None
199
200
264
for d in dir_list:
201
265
os.mkdir(d)
202
if not b:
203
b = Branch.open_containing(d)
204
b.add([d])
266
wt, dd = WorkingTree.open_containing(d)
267
wt.add([dd])
205
268
print 'added', d
206
269
207
270
210
273
takes_args = ['filename']
211
274
hidden = True
212
275
276
@display_command
213
277
def run(self, filename):
214
print Branch.open_containing(filename).relpath(filename)
215
278
tree, relpath = WorkingTree.open_containing(filename)
279
print relpath
216
280
217
281
218
282
class cmd_inventory(Command):
219
"""Show inventory of the current working copy or a revision."""
220
takes_options = ['revision', 'show-ids']
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']
221
289
222
def run(self, revision=None, show_ids=False):
223
b = Branch.open_containing('.')
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]
224
295
if revision is None:
225
inv = b.read_working_inventory()
296
inv = tree.read_working_inventory()
226
297
else:
227
298
if len(revision) > 1:
228
299
raise BzrCommandError('bzr inventory --revision takes'
229
300
' exactly one revision identifier')
230
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
301
inv = tree.branch.get_revision_inventory(
302
revision[0].in_history(tree.branch).rev_id)
231
303
232
304
for path, entry in inv.entries():
305
if kind and kind != entry.kind:
306
continue
233
307
if show_ids:
234
308
print '%-50s %s' % (path, entry.file_id)
235
309
else:
246
320
"""
247
321
takes_args = ['source$', 'dest']
248
322
def run(self, source_list, dest):
249
b = Branch.open_containing('.')
250
323
tree, source_list = tree_files(source_list)
251
324
# TODO: glob expansion on windows?
252
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
325
tree.move(source_list, tree.relpath(dest))
253
326
254
327
255
328
class cmd_rename(Command):
263
336
264
337
See also the 'move' command, which moves files into a different
265
338
directory without changing their name.
266
267
TODO: Some way to rename multiple files without invoking bzr for each
268
one?"""
339
"""
340
# TODO: Some way to rename multiple files without invoking
341
# bzr for each one?"""
269
342
takes_args = ['from_name', 'to_name']
270
343
271
344
def run(self, from_name, to_name):
272
b = Branch.open_containing('.')
273
b.rename_one(b.relpath(from_name), b.relpath(to_name))
274
345
tree, (from_name, to_name) = tree_files((from_name, to_name))
346
tree.rename_one(from_name, to_name)
275
347
276
348
277
349
class cmd_mv(Command):
291
363
def run(self, names_list):
292
364
if len(names_list) < 2:
293
365
raise BzrCommandError("missing file argument")
294
b = Branch.open_containing(names_list[0])
295
296
rel_names = [b.relpath(x) for x in names_list]
366
tree, rel_names = tree_files(names_list)
297
367
298
368
if os.path.isdir(names_list[-1]):
299
369
# move into existing directory
300
for pair in b.move(rel_names[:-1], rel_names[-1]):
370
for pair in tree.move(rel_names[:-1], rel_names[-1]):
301
371
print "%s => %s" % pair
302
372
else:
303
373
if len(names_list) != 2:
304
374
raise BzrCommandError('to mv multiple files the destination '
305
375
'must be a versioned directory')
306
b.rename_one(rel_names[0], rel_names[1])
376
tree.rename_one(rel_names[0], rel_names[1])
307
377
print "%s => %s" % (rel_names[0], rel_names[1])
308
378
309
379
310
311
312
380
class cmd_pull(Command):
313
381
"""Pull any changes from another branch into the current one.
314
382
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.
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.
318
386
319
387
This command only works on branches that have not diverged. Branches are
320
388
considered diverged if both branches have had commits without first
321
389
pulling from the other.
322
390
323
391
If branches have diverged, you can use 'bzr merge' to pull the text changes
324
from one into the other.
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.
325
397
"""
326
takes_options = ['remember']
398
takes_options = ['remember', 'overwrite', 'verbose']
327
399
takes_args = ['location?']
328
400
329
def run(self, location=None, remember=False):
401
def run(self, location=None, remember=False, overwrite=False, verbose=False):
330
402
from bzrlib.merge import merge
331
import tempfile
332
403
from shutil import rmtree
333
404
import errno
334
335
br_to = Branch.open_containing('.')
336
stored_loc = br_to.get_parent()
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()
337
408
if location is None:
338
409
if stored_loc is None:
339
410
raise BzrCommandError("No pull location known or specified.")
340
411
else:
341
412
print "Using saved location: %s" % stored_loc
342
413
location = stored_loc
343
cache_root = tempfile.mkdtemp()
344
from bzrlib.errors import DivergedBranches
345
br_from = Branch.open_containing(location)
346
location = br_from.base
347
old_revno = br_to.revno()
348
try:
349
from bzrlib.errors import DivergedBranches
350
br_from = Branch.open(location)
351
br_from.setup_caching(cache_root)
352
location = br_from.base
353
old_revno = br_to.revno()
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:
354
508
try:
355
br_to.update_revisions(br_from)
356
except DivergedBranches:
357
raise BzrCommandError("These branches have diverged."
358
" Try merge.")
359
360
merge(('.', -1), ('.', old_revno), check_clean=False)
361
if stored_loc is None or remember:
362
br_to.set_parent(location)
363
finally:
364
rmtree(cache_root)
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,))
365
524
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)
366
531
367
532
368
533
class cmd_branch(Command):
384
549
385
550
def run(self, from_location, to_location=None, revision=None, basis=None):
386
551
from bzrlib.clone import copy_branch
387
import tempfile
388
552
import errno
389
553
from shutil import rmtree
390
cache_root = tempfile.mkdtemp()
391
try:
392
if revision is None:
393
revision = [None]
394
elif len(revision) > 1:
395
raise BzrCommandError(
396
'bzr branch --revision takes exactly 1 revision value')
397
try:
398
br_from = Branch.open(from_location)
399
except OSError, e:
400
if e.errno == errno.ENOENT:
401
raise BzrCommandError('Source location "%s" does not'
402
' exist.' % to_location)
403
else:
404
raise
405
br_from.setup_caching(cache_root)
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:
406
569
if basis is not None:
407
basis_branch = Branch.open_containing(basis)
570
basis_branch = WorkingTree.open_containing(basis)[0].branch
408
571
else:
409
572
basis_branch = None
410
573
if len(revision) == 1 and revision[0] is not None:
413
576
revision_id = None
414
577
if to_location is None:
415
578
to_location = os.path.basename(from_location.rstrip("/\\"))
579
name = None
580
else:
581
name = os.path.basename(to_location) + '\n'
416
582
try:
417
583
os.mkdir(to_location)
418
584
except OSError, e:
428
594
copy_branch(br_from, to_location, revision_id, basis_branch)
429
595
except bzrlib.errors.NoSuchRevision:
430
596
rmtree(to_location)
431
msg = "The branch %s has no revision %d." % (from_location, revision[0])
597
msg = "The branch %s has no revision %s." % (from_location, revision[0])
432
598
raise BzrCommandError(msg)
433
599
except bzrlib.errors.UnlistableBranch:
600
rmtree(to_location)
434
601
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())
435
608
finally:
436
rmtree(cache_root)
609
br_from.unlock()
437
610
438
611
439
612
class cmd_renames(Command):
440
613
"""Show list of renamed files.
441
442
TODO: Option to show renames between two historical versions.
443
444
TODO: Only show renames under dir, rather than in the whole branch.
445
614
"""
615
# TODO: Option to show renames between two historical versions.
616
617
# TODO: Only show renames under dir, rather than in the whole branch.
446
618
takes_args = ['dir?']
447
619
448
def run(self, dir='.'):
449
b = Branch.open_containing(dir)
450
old_inv = b.basis_tree().inventory
451
new_inv = b.read_working_inventory()
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()
452
625
453
626
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
454
627
renames.sort()
460
633
"""Show statistical information about a branch."""
461
634
takes_args = ['branch?']
462
635
636
@display_command
463
637
def run(self, branch=None):
464
638
import info
465
466
b = Branch.open_containing(branch)
639
b = WorkingTree.open_containing(branch)[0].branch
467
640
info.show_info(b)
468
641
469
642
475
648
"""
476
649
takes_args = ['file+']
477
650
takes_options = ['verbose']
651
aliases = ['rm']
478
652
479
653
def run(self, file_list, verbose=False):
480
b = Branch.open_containing(file_list[0])
481
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
654
tree, file_list = tree_files(file_list)
655
tree.remove(file_list, verbose=verbose)
482
656
483
657
484
658
class cmd_file_id(Command):
490
664
"""
491
665
hidden = True
492
666
takes_args = ['filename']
667
@display_command
493
668
def run(self, filename):
494
b = Branch.open_containing(filename)
495
i = b.inventory.path2id(b.relpath(filename))
669
tree, relpath = WorkingTree.open_containing(filename)
670
i = tree.inventory.path2id(relpath)
496
671
if i == None:
497
672
raise BzrError("%r is not a versioned file" % filename)
498
673
else:
506
681
starting at the branch root."""
507
682
hidden = True
508
683
takes_args = ['filename']
684
@display_command
509
685
def run(self, filename):
510
b = Branch.open_containing(filename)
511
inv = b.inventory
512
fid = inv.path2id(b.relpath(filename))
686
tree, relpath = WorkingTree.open_containing(filename)
687
inv = tree.inventory
688
fid = inv.path2id(relpath)
513
689
if fid == None:
514
690
raise BzrError("%r is not a versioned file" % filename)
515
691
for fip in inv.get_idpath(fid):
519
695
class cmd_revision_history(Command):
520
696
"""Display list of revision ids on this branch."""
521
697
hidden = True
698
@display_command
522
699
def run(self):
523
for patchid in Branch.open_containing('.').revision_history():
700
branch = WorkingTree.open_containing(u'.')[0].branch
701
for patchid in branch.revision_history():
524
702
print patchid
525
703
526
704
527
705
class cmd_ancestry(Command):
528
706
"""List all revisions merged into this branch."""
529
707
hidden = True
708
@display_command
530
709
def run(self):
531
b = find_branch('.')
710
tree = WorkingTree.open_containing(u'.')[0]
711
b = tree.branch
712
# FIXME. should be tree.last_revision
532
713
for revision_id in b.get_ancestry(b.last_revision()):
533
714
print revision_id
534
715
535
716
536
class cmd_directories(Command):
537
"""Display list of versioned directories in this branch."""
538
def run(self):
539
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
540
if name == '':
541
print '.'
542
else:
543
print name
544
545
546
717
class cmd_init(Command):
547
718
"""Make a directory into a versioned branch.
548
719
552
723
Recipe for importing a tree of files:
553
724
cd ~/project
554
725
bzr init
555
bzr add -v .
726
bzr add .
556
727
bzr status
557
728
bzr commit -m 'imported project'
558
729
"""
559
def run(self):
560
Branch.initialize('.')
730
takes_args = ['location?']
731
def run(self, location=None):
732
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)
561
744
562
745
563
746
class cmd_diff(Command):
566
749
If files are listed, only the changes in those files are listed.
567
750
Otherwise, all changes for the tree are listed.
568
751
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
584
752
examples:
585
753
bzr diff
586
754
bzr diff -r1
587
755
bzr diff -r1..2
588
756
"""
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.
589
770
590
771
takes_args = ['file*']
591
772
takes_options = ['revision', 'diff-options']
592
773
aliases = ['di', 'dif']
593
774
775
@display_command
594
776
def run(self, revision=None, file_list=None, diff_options=None):
595
777
from bzrlib.diff import show_diff
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
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
606
792
if revision is not None:
793
if b2 is not None:
794
raise BzrCommandError("Can't specify -r with two branches")
607
795
if len(revision) == 1:
608
show_diff(b, revision[0], specific_files=file_list,
609
external_diff_options=diff_options)
796
return show_diff(tree.branch, revision[0], specific_files=file_list,
797
external_diff_options=diff_options)
610
798
elif len(revision) == 2:
611
show_diff(b, revision[0], specific_files=file_list,
612
external_diff_options=diff_options,
613
revision2=revision[1])
799
return show_diff(tree.branch, revision[0], specific_files=file_list,
800
external_diff_options=diff_options,
801
revision2=revision[1])
614
802
else:
615
803
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
616
804
else:
617
show_diff(b, None, specific_files=file_list,
618
external_diff_options=diff_options)
619
620
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)
621
811
622
812
623
813
class cmd_deleted(Command):
624
814
"""List files deleted in the working tree.
625
626
TODO: Show files deleted since a previous revision, or between two revisions.
627
815
"""
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
628
823
def run(self, show_ids=False):
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
824
tree = WorkingTree.open_containing(u'.')[0]
825
old = tree.branch.basis_tree()
638
826
for path, ie in old.inventory.iter_entries():
639
if not new.has_id(ie.file_id):
827
if not tree.has_id(ie.file_id):
640
828
if show_ids:
641
829
print '%-50s %s' % (path, ie.file_id)
642
830
else:
646
834
class cmd_modified(Command):
647
835
"""List files modified in working tree."""
648
836
hidden = True
837
@display_command
649
838
def run(self):
650
839
from bzrlib.delta import compare_trees
651
840
652
b = Branch.open_containing('.')
653
td = compare_trees(b.basis_tree(), b.working_tree())
841
tree = WorkingTree.open_containing(u'.')[0]
842
td = compare_trees(tree.branch.basis_tree(), tree)
654
843
655
844
for path, id, kind, text_modified, meta_modified in td.modified:
656
845
print path
660
849
class cmd_added(Command):
661
850
"""List files added in working tree."""
662
851
hidden = True
852
@display_command
663
853
def run(self):
664
b = Branch.open_containing('.')
665
wt = b.working_tree()
666
basis_inv = b.basis_tree().inventory
854
wt = WorkingTree.open_containing(u'.')[0]
855
basis_inv = wt.branch.basis_tree().inventory
667
856
inv = wt.inventory
668
857
for file_id in inv:
669
858
if file_id in basis_inv:
681
870
The root is the nearest enclosing directory with a .bzr control
682
871
directory."""
683
872
takes_args = ['filename?']
873
@display_command
684
874
def run(self, filename=None):
685
875
"""Print the branch root."""
686
b = Branch.open_containing(filename)
687
print b.base
876
tree = WorkingTree.open_containing(filename)[0]
877
print tree.basedir
688
878
689
879
690
880
class cmd_log(Command):
691
881
"""Show log of this branch.
692
882
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
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
695
885
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
886
"""
700
887
701
888
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
702
889
703
890
takes_args = ['filename?']
704
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
705
'long', 'message', 'short',]
706
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
707
902
def run(self, filename=None, timezone='original',
708
903
verbose=False,
709
904
show_ids=False,
711
906
revision=None,
712
907
message=None,
713
908
long=False,
714
short=False):
909
short=False,
910
line=False):
715
911
from bzrlib.log import log_formatter, show_log
716
912
import codecs
717
913
assert message is None or isinstance(message, basestring), \
914
"invalid message argument %r" % message
718
915
direction = (forward and 'forward') or 'reverse'
719
916
720
917
if filename:
721
b = Branch.open_containing(filename)
722
fp = b.relpath(filename)
723
if fp:
724
file_id = b.read_working_inventory().path2id(fp)
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)
725
933
else:
726
934
file_id = None # points to branch root
727
935
else:
728
b = Branch.open_containing('.')
936
tree, relpath = WorkingTree.open_containing(u'.')
937
b = tree.branch
729
938
file_id = None
730
939
731
940
if revision is None:
739
948
else:
740
949
raise BzrCommandError('bzr log --revision takes one or two values.')
741
950
742
if rev1 == 0:
743
rev1 = None
744
if rev2 == 0:
745
rev2 = None
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)
746
956
747
mutter('encoding log as %r' % bzrlib.user_encoding)
957
mutter('encoding log as %r', bzrlib.user_encoding)
748
958
749
959
# use 'replace' so that we don't abort if trying to write out
750
960
# in e.g. the default C locale.
751
961
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
752
962
753
if not short:
754
log_format = 'long'
755
else:
756
log_format = 'short'
963
log_format = get_log_format(long=long, short=short, line=line)
757
964
lf = log_formatter(log_format,
758
965
show_ids=show_ids,
759
966
to_file=outf,
768
975
end_revision=rev2,
769
976
search=message)
770
977
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
771
987
772
988
773
989
class cmd_touching_revisions(Command):
776
992
A more user-friendly interface is "bzr log FILE"."""
777
993
hidden = True
778
994
takes_args = ["filename"]
995
@display_command
779
996
def run(self, filename):
780
b = Branch.open_containing(filename)
781
inv = b.read_working_inventory()
782
file_id = inv.path2id(b.relpath(filename))
997
tree, relpath = WorkingTree.open_containing(filename)
998
b = tree.branch
999
inv = tree.read_working_inventory()
1000
file_id = inv.path2id(relpath)
783
1001
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
784
1002
print "%6d %s" % (revno, what)
785
1003
786
1004
787
1005
class cmd_ls(Command):
788
1006
"""List files in a tree.
789
790
TODO: Take a revision or remote path and list that tree instead.
791
1007
"""
1008
# TODO: Take a revision or remote path and list that tree instead.
792
1009
hidden = True
793
def run(self, revision=None, verbose=False):
794
b = Branch.open_containing('.')
795
if revision == None:
796
tree = b.working_tree()
797
else:
798
tree = b.revision_tree(revision.in_history(b).rev_id)
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)
799
1041
for fp, fc, kind, fid, entry in tree.list_files():
800
if verbose:
801
kindch = entry.kind_character()
802
print '%-8s %s%s' % (fc, fp, kindch)
803
else:
804
print fp
805
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()
1055
else:
1056
print fp
806
1057
807
1058
808
1059
class cmd_unknowns(Command):
809
1060
"""List unknown files."""
1061
@display_command
810
1062
def run(self):
811
1063
from bzrlib.osutils import quotefn
812
for f in Branch.open_containing('.').unknowns():
1064
for f in WorkingTree.open_containing(u'.')[0].unknowns():
813
1065
print quotefn(f)
814
1066
815
1067
816
817
1068
class cmd_ignore(Command):
818
1069
"""Ignore a command or pattern.
819
1070
820
1071
To remove patterns from the ignore list, edit the .bzrignore file.
821
1072
822
1073
If the pattern contains a slash, it is compared to the whole path
823
from the branch root. Otherwise, it is comapred to only the last
824
component of the 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 './'.
825
1077
826
1078
Ignore patterns are case-insensitive on case-insensitive systems.
827
1079
831
1083
bzr ignore ./Makefile
832
1084
bzr ignore '*.class'
833
1085
"""
1086
# TODO: Complain if the filename is absolute
834
1087
takes_args = ['name_pattern']
835
1088
836
1089
def run(self, name_pattern):
837
1090
from bzrlib.atomicfile import AtomicFile
838
1091
import os.path
839
1092
840
b = Branch.open_containing('.')
841
ifn = b.abspath('.bzrignore')
1093
tree, relpath = WorkingTree.open_containing(u'.')
1094
ifn = tree.abspath('.bzrignore')
842
1095
843
1096
if os.path.exists(ifn):
844
1097
f = open(ifn, 'rt')
863
1116
finally:
864
1117
f.close()
865
1118
866
inv = b.working_tree().inventory
1119
inv = tree.inventory
867
1120
if inv.path2id('.bzrignore'):
868
1121
mutter('.bzrignore is already versioned')
869
1122
else:
870
1123
mutter('need to make new .bzrignore file versioned')
871
b.add(['.bzrignore'])
872
1124
tree.add(['.bzrignore'])
873
1125
874
1126
875
1127
class cmd_ignored(Command):
876
1128
"""List ignored files and the patterns that matched them.
877
1129
878
1130
See also: bzr ignore"""
1131
@display_command
879
1132
def run(self):
880
tree = Branch.open_containing('.').working_tree()
1133
tree = WorkingTree.open_containing(u'.')[0]
881
1134
for path, file_class, kind, file_id, entry in tree.list_files():
882
1135
if file_class != 'I':
883
1136
continue
895
1148
hidden = True
896
1149
takes_args = ['revno']
897
1150
1151
@display_command
898
1152
def run(self, revno):
899
1153
try:
900
1154
revno = int(revno)
901
1155
except ValueError:
902
1156
raise BzrCommandError("not a valid revision-number: %r" % revno)
903
1157
904
print Branch.open_containing('.').get_rev_id(revno)
1158
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
905
1159
906
1160
907
1161
class cmd_export(Command):
914
1168
is found exports to a directory (equivalent to --format=dir).
915
1169
916
1170
Root may be the top directory for tar, tgz and tbz2 formats. If none
917
is given, the top directory will be the root name of the file."""
918
# TODO: list known exporters
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
"""
919
1183
takes_args = ['dest']
920
1184
takes_options = ['revision', 'format', 'root']
921
1185
def run(self, dest, revision=None, format=None, root=None):
922
1186
import os.path
923
b = Branch.open_containing('.')
1187
from bzrlib.export import export
1188
tree = WorkingTree.open_containing(u'.')[0]
1189
b = tree.branch
924
1190
if revision is None:
1191
# should be tree.last_revision FIXME
925
1192
rev_id = b.last_revision()
926
1193
else:
927
1194
if len(revision) != 1:
928
1195
raise BzrError('bzr export --revision takes exactly 1 argument')
929
1196
rev_id = revision[0].in_history(b).rev_id
930
1197
t = b.revision_tree(rev_id)
931
arg_root, ext = os.path.splitext(os.path.basename(dest))
932
if ext in ('.gz', '.bz2'):
933
new_root, new_ext = os.path.splitext(arg_root)
934
if new_ext == '.tar':
935
arg_root = new_root
936
ext = new_ext + ext
937
if root is None:
938
root = arg_root
939
if not format:
940
if ext in (".tar",):
941
format = "tar"
942
elif ext in (".tar.gz", ".tgz"):
943
format = "tgz"
944
elif ext in (".tar.bz2", ".tbz2"):
945
format = "tbz2"
946
else:
947
format = "dir"
948
t.export(dest, format, root)
1198
try:
1199
export(t, dest, format, root)
1200
except errors.NoSuchExportFormat, e:
1201
raise BzrCommandError('Unsupported export format: %s' % e.format)
949
1202
950
1203
951
1204
class cmd_cat(Command):
954
1207
takes_options = ['revision']
955
1208
takes_args = ['filename']
956
1209
1210
@display_command
957
1211
def run(self, filename, revision=None):
958
if revision is None:
959
raise BzrCommandError("bzr cat requires a revision number")
960
elif len(revision) != 1:
1212
if revision is not None and len(revision) != 1:
961
1213
raise BzrCommandError("bzr cat --revision takes exactly one number")
962
b = Branch.open_containing('.')
963
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
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)
964
1228
965
1229
966
1230
class cmd_local_time_offset(Command):
967
1231
"""Show the offset in seconds from GMT to local time."""
968
1232
hidden = True
1233
@display_command
969
1234
def run(self):
970
1235
print bzrlib.osutils.local_time_offset()
971
1236
983
1248
A selected-file commit may fail in some cases where the committed
984
1249
tree would be invalid, such as trying to commit a file in a
985
1250
newly-added directory that is not itself committed.
986
987
TODO: Run hooks on tree to-be-committed, and after commit.
988
989
TODO: Strict commit that fails if there are unknown or deleted files.
990
1251
"""
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 ??)
1256
1257
# TODO: Give better message for -s, --summary, used by tla people
1258
1259
# XXX: verbose currently does nothing
1260
991
1261
takes_args = ['selected*']
992
takes_options = ['message', 'file', 'verbose', 'unchanged']
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
]
993
1272
aliases = ['ci', 'checkin']
994
1273
995
# TODO: Give better message for -s, --summary, used by tla people
996
997
# XXX: verbose currently does nothing
998
999
1274
def run(self, message=None, file=None, verbose=True, selected_list=None,
1000
unchanged=False):
1001
from bzrlib.errors import PointlessCommit, ConflictsInTree
1002
from bzrlib.msgeditor import edit_commit_message
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
1003
1280
from bzrlib.status import show_status
1004
from cStringIO import StringIO
1005
1006
b = Branch.open_containing('.')
1007
if selected_list:
1008
selected_list = [b.relpath(s) for s in selected_list]
1009
1010
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)
1011
1293
if message is None 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
1294
template = make_commit_message_template(tree, selected_list)
1295
message = edit_commit_message(template)
1017
1296
if message is None:
1018
1297
raise BzrCommandError("please specify a commit message"
1019
1298
" with either --message or --file")
1028
1307
raise BzrCommandError("empty commit message specified")
1029
1308
1030
1309
try:
1031
b.commit(message,
1032
specific_files=selected_list,
1033
allow_pointless=unchanged)
1310
tree.commit(message, specific_files=selected_list,
1311
allow_pointless=unchanged, strict=strict)
1034
1312
except PointlessCommit:
1035
1313
# FIXME: This should really happen before the file is read in;
1036
1314
# perhaps prepare the commit; get the message; then actually commit
1039
1317
except ConflictsInTree:
1040
1318
raise BzrCommandError("Conflicts detected in working tree. "
1041
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(),))
1042
1324
1043
1325
1044
1326
class cmd_check(Command):
1047
1329
This command checks various invariants about the branch storage to
1048
1330
detect data corruption or bzr bugs.
1049
1331
"""
1050
takes_args = ['dir?']
1332
takes_args = ['branch?']
1333
takes_options = ['verbose']
1051
1334
1052
def run(self, dir='.'):
1335
def run(self, branch=None, verbose=False):
1053
1336
from bzrlib.check import check
1054
1055
check(Branch.open_containing(dir))
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)
1056
1343
1057
1344
1058
1345
class cmd_scan_cache(Command):
1060
1347
def run(self):
1061
1348
from bzrlib.hashcache import HashCache
1062
1349
1063
c = HashCache('.')
1350
c = HashCache(u'.')
1064
1351
c.read()
1065
1352
c.scan()
1066
1353
1086
1373
"""
1087
1374
takes_args = ['dir?']
1088
1375
1089
def run(self, dir='.'):
1376
def run(self, dir=u'.'):
1090
1377
from bzrlib.upgrade import upgrade
1091
1378
upgrade(dir)
1092
1379
1095
1382
"""Show bzr user id."""
1096
1383
takes_options = ['email']
1097
1384
1385
@display_command
1098
1386
def run(self, email=False):
1099
1387
try:
1100
b = bzrlib.branch.Branch.open_containing('.')
1388
b = WorkingTree.open_containing(u'.')[0].branch
1389
config = bzrlib.config.BranchConfig(b)
1101
1390
except NotBranchError:
1102
b = None
1391
config = bzrlib.config.GlobalConfig()
1103
1392
1104
1393
if email:
1105
print bzrlib.osutils.user_email(b)
1106
else:
1107
print bzrlib.osutils.username(b)
1108
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
1109
1415
1110
1416
class cmd_selftest(Command):
1111
1417
"""Run internal test suite.
1113
1419
This creates temporary test directories in the working directory,
1114
1420
but not existing data is affected. These directories are deleted
1115
1421
if the tests pass, or left behind to help in debugging if they
1116
fail.
1422
fail and --keep-output is specified.
1117
1423
1118
1424
If arguments are given, they are regular expressions that say
1119
which tests should run."""
1425
which tests should run.
1426
"""
1120
1427
# TODO: --list should give a list of all available tests
1121
1428
hidden = True
1122
takes_args = ['testnames*']
1123
takes_options = ['verbose', 'pattern']
1124
def run(self, testnames_list=None, verbose=False, pattern=".*"):
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):
1125
1438
import bzrlib.ui
1126
from bzrlib.selftest import selftest
1439
from bzrlib.tests import selftest
1127
1440
# we don't want progress meters from the tests to go to the
1128
1441
# real output; and we don't want log messages cluttering up
1129
1442
# the real logs.
1131
1444
bzrlib.trace.info('running tests...')
1132
1445
try:
1133
1446
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1447
if testspecs_list is not None:
1448
pattern = '|'.join(testspecs_list)
1449
else:
1450
pattern = ".*"
1134
1451
result = selftest(verbose=verbose,
1135
1452
pattern=pattern,
1136
testnames=testnames_list)
1453
stop_on_failure=one,
1454
keep_output=keep_output)
1137
1455
if result:
1138
1456
bzrlib.trace.info('tests passed')
1139
1457
else:
1143
1461
bzrlib.ui.ui_factory = save_ui
1144
1462
1145
1463
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
1146
1478
def show_version():
1147
1479
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1148
1480
# is bzrlib itself in a branch?
1149
bzrrev = bzrlib.get_bzr_revision()
1150
if bzrrev:
1151
print " (bzr checkout, revision %d {%s})" % bzrrev
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],)
1152
1489
print bzrlib.__copyright__
1153
1490
print "http://bazaar-ng.org/"
1154
1491
print
1159
1496
1160
1497
class cmd_version(Command):
1161
1498
"""Show version of bzr."""
1499
@display_command
1162
1500
def run(self):
1163
1501
show_version()
1164
1502
1165
1503
class cmd_rocks(Command):
1166
1504
"""Statement of optimism."""
1167
1505
hidden = True
1506
@display_command
1168
1507
def run(self):
1169
1508
print "it sure does!"
1170
1509
1171
1510
1172
1511
class cmd_find_merge_base(Command):
1173
1512
"""Find and print a base revision for merging two branches.
1174
1175
TODO: Options to specify revisions on either side, as if
1176
merging only part of the history.
1177
1513
"""
1514
# TODO: Options to specify revisions on either side, as if
1515
# merging only part of the history.
1178
1516
takes_args = ['branch', 'other']
1179
1517
hidden = True
1180
1518
1519
@display_command
1181
1520
def run(self, branch, other):
1182
1521
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1183
1522
1184
branch1 = Branch.open_containing(branch)
1185
branch2 = Branch.open_containing(other)
1523
branch1 = Branch.open_containing(branch)[0]
1524
branch2 = Branch.open_containing(other)[0]
1186
1525
1187
1526
history_1 = branch1.revision_history()
1188
1527
history_2 = branch2.revision_history()
1237
1576
--force is given.
1238
1577
"""
1239
1578
takes_args = ['branch?']
1240
takes_options = ['revision', 'force', 'merge-type']
1579
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1580
Option('show-base', help="Show base revision text in "
1581
"conflicts")]
1241
1582
1242
def run(self, branch=None, revision=None, force=False,
1243
merge_type=None):
1583
def run(self, branch=None, revision=None, force=False, merge_type=None,
1584
show_base=False, reprocess=False):
1244
1585
from bzrlib.merge import merge
1245
1586
from bzrlib.merge_core import ApplyMerge3
1246
1587
if merge_type is None:
1247
1588
merge_type = ApplyMerge3
1248
1589
if branch is None:
1249
branch = Branch.open_containing('.').get_parent()
1590
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1250
1591
if branch is None:
1251
1592
raise BzrCommandError("No merge location known or specified.")
1252
1593
else:
1257
1598
else:
1258
1599
if len(revision) == 1:
1259
1600
base = [None, None]
1260
other = [branch, revision[0].in_history(branch).revno]
1601
other_branch = Branch.open_containing(branch)[0]
1602
revno = revision[0].in_history(other_branch).revno
1603
other = [branch, revno]
1261
1604
else:
1262
1605
assert len(revision) == 2
1263
1606
if None in revision:
1264
1607
raise BzrCommandError(
1265
1608
"Merge doesn't permit that revision specifier.")
1266
b = Branch.open(branch)
1609
b = Branch.open_containing(branch)[0]
1267
1610
1268
1611
base = [branch, revision[0].in_history(b).revno]
1269
1612
other = [branch, revision[1].in_history(b).revno]
1270
1613
1271
1614
try:
1272
merge(other, base, check_clean=(not force), merge_type=merge_type)
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
1273
1622
except bzrlib.errors.AmbiguousBase, e:
1274
1623
m = ("sorry, bzr can't determine the right merge base yet\n"
1275
1624
"candidates are:\n "
1280
1629
log_error(m)
1281
1630
1282
1631
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
1283
1692
class cmd_revert(Command):
1284
1693
"""Reverse all changes since the last commit.
1285
1694
1292
1701
aliases = ['merge-revert']
1293
1702
1294
1703
def run(self, revision=None, no_backup=False, file_list=None):
1295
from bzrlib.merge import merge
1704
from bzrlib.merge import merge_inner
1296
1705
from bzrlib.commands import parse_spec
1297
1298
1706
if file_list is not None:
1299
1707
if len(file_list) == 0:
1300
1708
raise BzrCommandError("No files specified")
1709
else:
1710
file_list = []
1301
1711
if revision is None:
1302
1712
revno = -1
1713
tree = WorkingTree.open_containing(u'.')[0]
1714
# FIXME should be tree.last_revision
1715
rev_id = tree.branch.last_revision()
1303
1716
elif len(revision) != 1:
1304
1717
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1305
1718
else:
1306
b = Branch.open_containing('.')
1307
revno = revision[0].in_history(b).revno
1308
merge(('.', revno), parse_spec('.'),
1309
check_clean=False,
1310
ignore_zero=True,
1311
backup_files=not no_backup,
1312
file_list=file_list)
1313
if not file_list:
1314
Branch.open_containing('.').set_pending_merges([])
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)
1315
1723
1316
1724
1317
1725
class cmd_assert_fail(Command):
1329
1737
takes_args = ['topic?']
1330
1738
aliases = ['?']
1331
1739
1740
@display_command
1332
1741
def run(self, topic=None, long=False):
1333
1742
import help
1334
1743
if topic is None and long:
1344
1753
aliases = ['s-c']
1345
1754
hidden = True
1346
1755
1756
@display_command
1347
1757
def run(self, context=None):
1348
1758
import shellcomplete
1349
1759
shellcomplete.shellcomplete(context)
1358
1768
def run(self, from_branch, to_branch):
1359
1769
from bzrlib.fetch import Fetcher
1360
1770
from bzrlib.branch import Branch
1361
from_b = Branch(from_branch)
1362
to_b = Branch(to_branch)
1363
Fetcher(to_b, from_b)
1364
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()
1365
1782
1366
1783
1367
1784
class cmd_missing(Command):
1368
"""What is missing in this branch relative to other branch.
1369
"""
1370
# TODO: rewrite this in terms of ancestry so that it shows only
1371
# unmerged things
1372
1373
takes_args = ['remote?']
1374
aliases = ['mis', 'miss']
1375
# We don't have to add quiet to the list, because
1376
# unknown options are parsed as booleans
1377
takes_options = ['verbose', 'quiet']
1378
1379
def run(self, remote=None, verbose=False, quiet=False):
1380
from bzrlib.errors import BzrCommandError
1381
from bzrlib.missing import show_missing
1382
1383
if verbose and quiet:
1384
raise BzrCommandError('Cannot pass both quiet and verbose')
1385
1386
b = Branch.open_containing('.')
1387
parent = b.get_parent()
1388
if remote is None:
1389
if parent is None:
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:
1390
1811
raise BzrCommandError("No missing location known or specified.")
1391
else:
1392
if not quiet:
1393
print "Using last location: %s" % parent
1394
remote = parent
1395
elif parent is None:
1396
# We only update parent if it did not exist, missing
1397
# should not change the parent
1398
b.set_parent(remote)
1399
br_remote = Branch.open_containing(remote)
1400
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
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
1401
1843
1402
1844
1403
1845
class cmd_plugins(Command):
1404
1846
"""List plugins"""
1405
1847
hidden = True
1848
@display_command
1406
1849
def run(self):
1407
1850
import bzrlib.plugin
1408
1851
from inspect import getdoc
1409
for plugin in bzrlib.plugin.all_plugins:
1852
for name, plugin in bzrlib.plugin.all_plugins().items():
1410
1853
if hasattr(plugin, '__path__'):
1411
1854
print plugin.__path__[0]
1412
1855
elif hasattr(plugin, '__file__'):
1419
1862
print '\t', d.split('\n')[0]
1420
1863
1421
1864
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