« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1530.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1530.2.1
- Committer: Robert Collins
- Date: 2005-12-24 02:20:45 UTC
- mto: (1185.50.57 bzr-jam-integration)
- mto: This revision was merged to the branch mainline in revision 1550.
- Revision ID: robertc@robertcollins.net-20051224022045-14efc8dfa0e1a4e9
Start tests for api usage.
- files added:
- INSTALL
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files removed:
- bzrlib/mdiff.py
- files renamed:
- bzr-man.py => bzr_man.py
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/selftest/ => bzrlib/tests/
- 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/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/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/teststatus.py => bzrlib/tests/test_status.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- tools/testweave.py => bzrlib/tests/test_weave.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- bzrlib/ui.py => bzrlib/ui/__init__.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/newinventory.py => contrib/newinventory.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
25
from bzrlib.branch import find_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.
63
109
files or directories is reported. If a directory is given, status
64
110
is reported for everything inside that directory.
65
111
66
If a revision is specified, the changes since that revision are shown.
112
If a revision argument is given, the status is calculated against
113
that revision, or between two revisions if two are provided.
67
114
"""
115
116
# TODO: --no-recurse, --recurse options
117
68
118
takes_args = ['file*']
69
119
takes_options = ['all', 'show-ids', 'revision']
70
120
aliases = ['st', 'stat']
71
121
72
def run(self, all=False, show_ids=False, file_list=None):
73
if file_list:
74
b = find_branch(file_list[0])
75
file_list = [b.relpath(x) for x in file_list]
76
# special case: only one path was given and it's the root
77
# of the branch
78
if file_list == ['']:
79
file_list = None
80
else:
81
b = find_branch('.')
122
@display_command
123
def run(self, all=False, show_ids=False, file_list=None, revision=None):
124
tree, file_list = tree_files(file_list)
82
125
83
126
from bzrlib.status import show_status
84
show_status(b, show_unchanged=all, show_ids=show_ids,
85
specific_files=file_list)
127
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
128
specific_files=file_list, revision=revision)
86
129
87
130
88
131
class cmd_cat_revision(Command):
89
"""Write out metadata for a revision."""
132
"""Write out metadata for a revision.
133
134
The revision to print can either be specified by a specific
135
revision identifier, or you can use --revision.
136
"""
90
137
91
138
hidden = True
92
takes_args = ['revision_id']
139
takes_args = ['revision_id?']
140
takes_options = ['revision']
93
141
94
def run(self, revision_id):
95
from bzrlib.xml import pack_xml
96
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
142
@display_command
143
def run(self, revision_id=None, revision=None):
97
144
145
if revision_id is not None and revision is not None:
146
raise BzrCommandError('You can only supply one of revision_id or --revision')
147
if revision_id is None and revision is None:
148
raise BzrCommandError('You must supply either --revision or a revision_id')
149
b = WorkingTree.open_containing(u'.')[0].branch
150
if revision_id is not None:
151
sys.stdout.write(b.get_revision_xml(revision_id))
152
elif revision is not None:
153
for rev in revision:
154
if rev is None:
155
raise BzrCommandError('You cannot specify a NULL revision.')
156
revno, rev_id = rev.in_history(b)
157
sys.stdout.write(b.get_revision_xml(rev_id))
158
98
159
99
160
class cmd_revno(Command):
100
161
"""Show current revision number.
101
162
102
163
This is equal to the number of revisions on this branch."""
103
def run(self):
104
print find_branch('.').revno()
164
takes_args = ['location?']
165
@display_command
166
def run(self, location=u'.'):
167
print Branch.open_containing(location)[0].revno()
168
105
169
106
170
class cmd_revision_info(Command):
107
171
"""Show revision number and revision id for a given revision identifier.
109
173
hidden = True
110
174
takes_args = ['revision_info*']
111
175
takes_options = ['revision']
112
def run(self, revision=None, revision_info_list=None):
113
from bzrlib.branch import find_branch
176
@display_command
177
def run(self, revision=None, revision_info_list=[]):
114
178
115
179
revs = []
116
180
if revision is not None:
117
181
revs.extend(revision)
118
182
if revision_info_list is not None:
119
revs.extend(revision_info_list)
183
for rev in revision_info_list:
184
revs.append(RevisionSpec(rev))
120
185
if len(revs) == 0:
121
186
raise BzrCommandError('You must supply a revision identifier')
122
187
123
b = find_branch('.')
188
b = WorkingTree.open_containing(u'.')[0].branch
124
189
125
190
for rev in revs:
126
print '%4d %s' % b.get_revision_info(rev)
191
revinfo = rev.in_history(b)
192
if revinfo.revno is None:
193
print ' %s' % revinfo.rev_id
194
else:
195
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
127
196
128
197
129
198
class cmd_add(Command):
144
213
Therefore simply saying 'bzr add' will version all files that
145
214
are currently unknown.
146
215
147
TODO: Perhaps adding a file whose directly is not versioned should
148
recursively add that parent, rather than giving an error?
216
Adding a file whose parent directory is not versioned will
217
implicitly add the parent, and so on up to the root. This means
218
you should never need to explictly add a directory, they'll just
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.
149
223
"""
150
224
takes_args = ['file*']
151
takes_options = ['verbose', 'no-recurse']
152
153
def run(self, file_list, verbose=False, no_recurse=False):
154
# verbose currently has no effect
155
from bzrlib.add import smart_add, add_reporter_print
156
smart_add(file_list, not no_recurse, add_reporter_print)
157
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."
158
254
159
255
160
256
class cmd_mkdir(Command):
165
261
takes_args = ['dir+']
166
262
167
263
def run(self, dir_list):
168
b = None
169
170
264
for d in dir_list:
171
265
os.mkdir(d)
172
if not b:
173
b = find_branch(d)
174
b.add([d])
266
wt, dd = WorkingTree.open_containing(d)
267
wt.add([dd])
175
268
print 'added', d
176
269
177
270
180
273
takes_args = ['filename']
181
274
hidden = True
182
275
276
@display_command
183
277
def run(self, filename):
184
print find_branch(filename).relpath(filename)
185
278
tree, relpath = WorkingTree.open_containing(filename)
279
print relpath
186
280
187
281
188
282
class cmd_inventory(Command):
189
"""Show inventory of the current working copy or a revision."""
190
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']
191
289
192
def run(self, revision=None, show_ids=False):
193
b = find_branch('.')
194
if revision == None:
195
inv = b.read_working_inventory()
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]
295
if revision is None:
296
inv = tree.read_working_inventory()
196
297
else:
197
298
if len(revision) > 1:
198
299
raise BzrCommandError('bzr inventory --revision takes'
199
300
' exactly one revision identifier')
200
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
301
inv = tree.branch.get_revision_inventory(
302
revision[0].in_history(tree.branch).rev_id)
201
303
202
304
for path, entry in inv.entries():
305
if kind and kind != entry.kind:
306
continue
203
307
if show_ids:
204
308
print '%-50s %s' % (path, entry.file_id)
205
309
else:
216
320
"""
217
321
takes_args = ['source$', 'dest']
218
322
def run(self, source_list, dest):
219
b = find_branch('.')
220
323
tree, source_list = tree_files(source_list)
221
324
# TODO: glob expansion on windows?
222
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
325
tree.move(source_list, tree.relpath(dest))
223
326
224
327
225
328
class cmd_rename(Command):
233
336
234
337
See also the 'move' command, which moves files into a different
235
338
directory without changing their name.
236
237
TODO: Some way to rename multiple files without invoking bzr for each
238
one?"""
339
"""
340
# TODO: Some way to rename multiple files without invoking
341
# bzr for each one?"""
239
342
takes_args = ['from_name', 'to_name']
240
343
241
344
def run(self, from_name, to_name):
242
b = find_branch('.')
243
b.rename_one(b.relpath(from_name), b.relpath(to_name))
244
345
tree, (from_name, to_name) = tree_files((from_name, to_name))
346
tree.rename_one(from_name, to_name)
245
347
246
348
247
349
class cmd_mv(Command):
261
363
def run(self, names_list):
262
364
if len(names_list) < 2:
263
365
raise BzrCommandError("missing file argument")
264
b = find_branch(names_list[0])
265
266
rel_names = [b.relpath(x) for x in names_list]
366
tree, rel_names = tree_files(names_list)
267
367
268
368
if os.path.isdir(names_list[-1]):
269
369
# move into existing directory
270
for pair in b.move(rel_names[:-1], rel_names[-1]):
370
for pair in tree.move(rel_names[:-1], rel_names[-1]):
271
371
print "%s => %s" % pair
272
372
else:
273
373
if len(names_list) != 2:
274
374
raise BzrCommandError('to mv multiple files the destination '
275
375
'must be a versioned directory')
276
for pair in b.move(rel_names[0], rel_names[1]):
277
print "%s => %s" % pair
376
tree.rename_one(rel_names[0], rel_names[1])
377
print "%s => %s" % (rel_names[0], rel_names[1])
278
378
279
379
280
281
282
380
class cmd_pull(Command):
283
381
"""Pull any changes from another branch into the current one.
284
382
285
If the location is omitted, the last-used location will be used.
286
Both the revision history and the working directory will be
287
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.
288
386
289
387
This command only works on branches that have not diverged. Branches are
290
388
considered diverged if both branches have had commits without first
291
389
pulling from the other.
292
390
293
391
If branches have diverged, you can use 'bzr merge' to pull the text changes
294
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.
295
397
"""
398
takes_options = ['remember', 'overwrite', 'verbose']
296
399
takes_args = ['location?']
297
400
298
def run(self, location=None):
401
def run(self, location=None, remember=False, overwrite=False, verbose=False):
299
402
from bzrlib.merge import merge
300
import tempfile
301
403
from shutil import rmtree
302
404
import errno
303
from bzrlib.branch import pull_loc
304
305
br_to = find_branch('.')
306
stored_loc = None
307
try:
308
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
309
except IOError, e:
310
if e.errno != errno.ENOENT:
311
raise
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()
312
408
if location is None:
313
409
if stored_loc is None:
314
410
raise BzrCommandError("No pull location known or specified.")
315
411
else:
316
print "Using last location: %s" % stored_loc
317
location = stored_loc
318
cache_root = tempfile.mkdtemp()
319
from bzrlib.branch import DivergedBranches
320
br_from = find_branch(location)
321
location = pull_loc(br_from)
322
old_revno = br_to.revno()
323
try:
324
from branch import find_cached_branch, DivergedBranches
325
br_from = find_cached_branch(location, cache_root)
326
location = pull_loc(br_from)
327
old_revno = br_to.revno()
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:
328
508
try:
329
br_to.update_revisions(br_from)
330
except DivergedBranches:
331
raise BzrCommandError("These branches have diverged."
332
" Try merge.")
333
334
merge(('.', -1), ('.', old_revno), check_clean=False)
335
if location != stored_loc:
336
br_to.controlfile("x-pull", "wb").write(location + "\n")
337
finally:
338
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,))
339
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)
340
531
341
532
342
533
class cmd_branch(Command):
347
538
348
539
To retrieve the branch as of a particular revision, supply the --revision
349
540
parameter, as in "branch foo/bar -r 5".
541
542
--basis is to speed up branching from remote branches. When specified, it
543
copies all the file-contents, inventory and revision data from the basis
544
branch before copying anything from the remote branch.
350
545
"""
351
546
takes_args = ['from_location', 'to_location?']
352
takes_options = ['revision']
547
takes_options = ['revision', 'basis']
353
548
aliases = ['get', 'clone']
354
549
355
def run(self, from_location, to_location=None, revision=None):
356
from bzrlib.branch import copy_branch, find_cached_branch
357
import tempfile
550
def run(self, from_location, to_location=None, revision=None, basis=None):
551
from bzrlib.clone import copy_branch
358
552
import errno
359
553
from shutil import rmtree
360
cache_root = tempfile.mkdtemp()
361
try:
362
if revision is None:
363
revision = [None]
364
elif len(revision) > 1:
365
raise BzrCommandError(
366
'bzr branch --revision takes exactly 1 revision value')
367
try:
368
br_from = find_cached_branch(from_location, cache_root)
369
except OSError, e:
370
if e.errno == errno.ENOENT:
371
raise BzrCommandError('Source location "%s" does not'
372
' exist.' % to_location)
373
else:
374
raise
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:
569
if basis is not None:
570
basis_branch = WorkingTree.open_containing(basis)[0].branch
571
else:
572
basis_branch = None
573
if len(revision) == 1 and revision[0] is not None:
574
revision_id = revision[0].in_history(br_from)[1]
575
else:
576
revision_id = None
375
577
if to_location is None:
376
578
to_location = os.path.basename(from_location.rstrip("/\\"))
579
name = None
580
else:
581
name = os.path.basename(to_location) + '\n'
377
582
try:
378
583
os.mkdir(to_location)
379
584
except OSError, e:
386
591
else:
387
592
raise
388
593
try:
389
copy_branch(br_from, to_location, revision[0])
594
copy_branch(br_from, to_location, revision_id, basis_branch)
390
595
except bzrlib.errors.NoSuchRevision:
391
596
rmtree(to_location)
392
msg = "The branch %s has no revision %d." % (from_location, revision[0])
393
raise BzrCommandError(msg)
597
msg = "The branch %s has no revision %s." % (from_location, revision[0])
598
raise BzrCommandError(msg)
599
except bzrlib.errors.UnlistableBranch:
600
rmtree(to_location)
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())
394
608
finally:
395
rmtree(cache_root)
609
br_from.unlock()
396
610
397
611
398
612
class cmd_renames(Command):
399
613
"""Show list of renamed files.
400
401
TODO: Option to show renames between two historical versions.
402
403
TODO: Only show renames under dir, rather than in the whole branch.
404
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.
405
618
takes_args = ['dir?']
406
619
407
def run(self, dir='.'):
408
b = find_branch(dir)
409
old_inv = b.basis_tree().inventory
410
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()
411
625
412
626
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
413
627
renames.sort()
419
633
"""Show statistical information about a branch."""
420
634
takes_args = ['branch?']
421
635
636
@display_command
422
637
def run(self, branch=None):
423
638
import info
424
425
b = find_branch(branch)
639
b = WorkingTree.open_containing(branch)[0].branch
426
640
info.show_info(b)
427
641
428
642
434
648
"""
435
649
takes_args = ['file+']
436
650
takes_options = ['verbose']
651
aliases = ['rm']
437
652
438
653
def run(self, file_list, verbose=False):
439
b = find_branch(file_list[0])
440
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)
441
656
442
657
443
658
class cmd_file_id(Command):
449
664
"""
450
665
hidden = True
451
666
takes_args = ['filename']
667
@display_command
452
668
def run(self, filename):
453
b = find_branch(filename)
454
i = b.inventory.path2id(b.relpath(filename))
669
tree, relpath = WorkingTree.open_containing(filename)
670
i = tree.inventory.path2id(relpath)
455
671
if i == None:
456
672
raise BzrError("%r is not a versioned file" % filename)
457
673
else:
465
681
starting at the branch root."""
466
682
hidden = True
467
683
takes_args = ['filename']
684
@display_command
468
685
def run(self, filename):
469
b = find_branch(filename)
470
inv = b.inventory
471
fid = inv.path2id(b.relpath(filename))
686
tree, relpath = WorkingTree.open_containing(filename)
687
inv = tree.inventory
688
fid = inv.path2id(relpath)
472
689
if fid == None:
473
690
raise BzrError("%r is not a versioned file" % filename)
474
691
for fip in inv.get_idpath(fid):
478
695
class cmd_revision_history(Command):
479
696
"""Display list of revision ids on this branch."""
480
697
hidden = True
698
@display_command
481
699
def run(self):
482
for patchid in find_branch('.').revision_history():
700
branch = WorkingTree.open_containing(u'.')[0].branch
701
for patchid in branch.revision_history():
483
702
print patchid
484
703
485
704
486
class cmd_directories(Command):
487
"""Display list of versioned directories in this branch."""
705
class cmd_ancestry(Command):
706
"""List all revisions merged into this branch."""
707
hidden = True
708
@display_command
488
709
def run(self):
489
for name, ie in find_branch('.').read_working_inventory().directories():
490
if name == '':
491
print '.'
492
else:
493
print name
710
tree = WorkingTree.open_containing(u'.')[0]
711
b = tree.branch
712
# FIXME. should be tree.last_revision
713
for revision_id in b.get_ancestry(b.last_revision()):
714
print revision_id
494
715
495
716
496
717
class cmd_init(Command):
502
723
Recipe for importing a tree of files:
503
724
cd ~/project
504
725
bzr init
505
bzr add -v .
726
bzr add .
506
727
bzr status
507
728
bzr commit -m 'imported project'
508
729
"""
509
def run(self):
730
takes_args = ['location?']
731
def run(self, location=None):
510
732
from bzrlib.branch import Branch
511
Branch('.', init=True)
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)
512
744
513
745
514
746
class cmd_diff(Command):
517
749
If files are listed, only the changes in those files are listed.
518
750
Otherwise, all changes for the tree are listed.
519
751
520
TODO: Allow diff across branches.
521
522
TODO: Option to use external diff command; could be GNU diff, wdiff,
523
or a graphical diff.
524
525
TODO: Python difflib is not exactly the same as unidiff; should
526
either fix it up or prefer to use an external diff.
527
528
TODO: If a directory is given, diff everything under that.
529
530
TODO: Selected-file diff is inefficient and doesn't show you
531
deleted files.
532
533
TODO: This probably handles non-Unix newlines poorly.
534
535
752
examples:
536
753
bzr diff
537
754
bzr diff -r1
538
bzr diff -r1:2
755
bzr diff -r1..2
539
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.
540
770
541
771
takes_args = ['file*']
542
772
takes_options = ['revision', 'diff-options']
543
773
aliases = ['di', 'dif']
544
774
775
@display_command
545
776
def run(self, revision=None, file_list=None, diff_options=None):
546
777
from bzrlib.diff import show_diff
547
548
if file_list:
549
b = find_branch(file_list[0])
550
file_list = [b.relpath(f) for f in file_list]
551
if file_list == ['']:
552
# just pointing to top-of-tree
553
file_list = None
554
else:
555
b = find_branch('.')
556
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
557
792
if revision is not None:
793
if b2 is not None:
794
raise BzrCommandError("Can't specify -r with two branches")
558
795
if len(revision) == 1:
559
show_diff(b, revision[0], specific_files=file_list,
560
external_diff_options=diff_options)
796
return show_diff(tree.branch, revision[0], specific_files=file_list,
797
external_diff_options=diff_options)
561
798
elif len(revision) == 2:
562
show_diff(b, revision[0], specific_files=file_list,
563
external_diff_options=diff_options,
564
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])
565
802
else:
566
803
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
567
804
else:
568
show_diff(b, None, specific_files=file_list,
569
external_diff_options=diff_options)
570
571
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)
572
811
573
812
574
813
class cmd_deleted(Command):
575
814
"""List files deleted in the working tree.
576
577
TODO: Show files deleted since a previous revision, or between two revisions.
578
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
579
823
def run(self, show_ids=False):
580
b = find_branch('.')
581
old = b.basis_tree()
582
new = b.working_tree()
583
584
## TODO: Much more efficient way to do this: read in new
585
## directories with readdir, rather than stating each one. Same
586
## level of effort but possibly much less IO. (Or possibly not,
587
## if the directories are very large...)
588
824
tree = WorkingTree.open_containing(u'.')[0]
825
old = tree.branch.basis_tree()
589
826
for path, ie in old.inventory.iter_entries():
590
if not new.has_id(ie.file_id):
827
if not tree.has_id(ie.file_id):
591
828
if show_ids:
592
829
print '%-50s %s' % (path, ie.file_id)
593
830
else:
597
834
class cmd_modified(Command):
598
835
"""List files modified in working tree."""
599
836
hidden = True
837
@display_command
600
838
def run(self):
601
839
from bzrlib.delta import compare_trees
602
840
603
b = find_branch('.')
604
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)
605
843
606
for path, id, kind in td.modified:
844
for path, id, kind, text_modified, meta_modified in td.modified:
607
845
print path
608
846
609
847
611
849
class cmd_added(Command):
612
850
"""List files added in working tree."""
613
851
hidden = True
852
@display_command
614
853
def run(self):
615
b = find_branch('.')
616
wt = b.working_tree()
617
basis_inv = b.basis_tree().inventory
854
wt = WorkingTree.open_containing(u'.')[0]
855
basis_inv = wt.branch.basis_tree().inventory
618
856
inv = wt.inventory
619
857
for file_id in inv:
620
858
if file_id in basis_inv:
632
870
The root is the nearest enclosing directory with a .bzr control
633
871
directory."""
634
872
takes_args = ['filename?']
873
@display_command
635
874
def run(self, filename=None):
636
875
"""Print the branch root."""
637
b = find_branch(filename)
638
print getattr(b, 'base', None) or getattr(b, 'baseurl')
876
tree = WorkingTree.open_containing(filename)[0]
877
print tree.basedir
639
878
640
879
641
880
class cmd_log(Command):
642
881
"""Show log of this branch.
643
882
644
To request a range of logs, you can use the command -r begin:end
645
-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
646
885
also valid.
647
648
--message allows you to give a regular expression, which will be evaluated
649
so that only matching entries will be displayed.
650
651
TODO: Make --revision support uuid: and hash: [future tag:] notation.
652
653
886
"""
654
887
888
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
889
655
890
takes_args = ['filename?']
656
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
657
'long', 'message', 'short',]
658
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
659
902
def run(self, filename=None, timezone='original',
660
903
verbose=False,
661
904
show_ids=False,
663
906
revision=None,
664
907
message=None,
665
908
long=False,
666
short=False):
909
short=False,
910
line=False):
667
911
from bzrlib.log import log_formatter, show_log
668
912
import codecs
669
913
assert message is None or isinstance(message, basestring), \
914
"invalid message argument %r" % message
670
915
direction = (forward and 'forward') or 'reverse'
671
916
672
917
if filename:
673
b = find_branch(filename)
674
fp = b.relpath(filename)
675
if fp:
676
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)
677
933
else:
678
934
file_id = None # points to branch root
679
935
else:
680
b = find_branch('.')
936
tree, relpath = WorkingTree.open_containing(u'.')
937
b = tree.branch
681
938
file_id = None
682
939
683
940
if revision is None:
684
941
rev1 = None
685
942
rev2 = None
686
943
elif len(revision) == 1:
687
rev1 = rev2 = b.get_revision_info(revision[0])[0]
944
rev1 = rev2 = revision[0].in_history(b).revno
688
945
elif len(revision) == 2:
689
rev1 = b.get_revision_info(revision[0])[0]
690
rev2 = b.get_revision_info(revision[1])[0]
946
rev1 = revision[0].in_history(b).revno
947
rev2 = revision[1].in_history(b).revno
691
948
else:
692
949
raise BzrCommandError('bzr log --revision takes one or two values.')
693
950
694
if rev1 == 0:
695
rev1 = None
696
if rev2 == 0:
697
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)
698
956
699
mutter('encoding log as %r' % bzrlib.user_encoding)
957
mutter('encoding log as %r', bzrlib.user_encoding)
700
958
701
959
# use 'replace' so that we don't abort if trying to write out
702
960
# in e.g. the default C locale.
703
961
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
704
962
705
if not short:
706
log_format = 'long'
707
else:
708
log_format = 'short'
963
log_format = get_log_format(long=long, short=short, line=line)
709
964
lf = log_formatter(log_format,
710
965
show_ids=show_ids,
711
966
to_file=outf,
720
975
end_revision=rev2,
721
976
search=message)
722
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
723
987
724
988
725
989
class cmd_touching_revisions(Command):
728
992
A more user-friendly interface is "bzr log FILE"."""
729
993
hidden = True
730
994
takes_args = ["filename"]
995
@display_command
731
996
def run(self, filename):
732
b = find_branch(filename)
733
inv = b.read_working_inventory()
734
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)
735
1001
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
736
1002
print "%6d %s" % (revno, what)
737
1003
738
1004
739
1005
class cmd_ls(Command):
740
1006
"""List files in a tree.
741
742
TODO: Take a revision or remote path and list that tree instead.
743
1007
"""
1008
# TODO: Take a revision or remote path and list that tree instead.
744
1009
hidden = True
745
def run(self, revision=None, verbose=False):
746
b = find_branch('.')
747
if revision == None:
748
tree = b.working_tree()
749
else:
750
tree = b.revision_tree(b.lookup_revision(revision))
751
752
for fp, fc, kind, fid in tree.list_files():
753
if verbose:
754
if kind == 'directory':
755
kindch = '/'
756
elif kind == 'file':
757
kindch = ''
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()
758
1055
else:
759
kindch = '???'
760
761
print '%-8s %s%s' % (fc, fp, kindch)
762
else:
763
print fp
764
1056
print fp
765
1057
766
1058
767
1059
class cmd_unknowns(Command):
768
1060
"""List unknown files."""
1061
@display_command
769
1062
def run(self):
770
1063
from bzrlib.osutils import quotefn
771
for f in find_branch('.').unknowns():
1064
for f in WorkingTree.open_containing(u'.')[0].unknowns():
772
1065
print quotefn(f)
773
1066
774
1067
775
776
1068
class cmd_ignore(Command):
777
1069
"""Ignore a command or pattern.
778
1070
779
1071
To remove patterns from the ignore list, edit the .bzrignore file.
780
1072
781
1073
If the pattern contains a slash, it is compared to the whole path
782
from the branch root. Otherwise, it is comapred to only the last
783
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 './'.
784
1077
785
1078
Ignore patterns are case-insensitive on case-insensitive systems.
786
1079
790
1083
bzr ignore ./Makefile
791
1084
bzr ignore '*.class'
792
1085
"""
1086
# TODO: Complain if the filename is absolute
793
1087
takes_args = ['name_pattern']
794
1088
795
1089
def run(self, name_pattern):
796
1090
from bzrlib.atomicfile import AtomicFile
797
1091
import os.path
798
1092
799
b = find_branch('.')
800
ifn = b.abspath('.bzrignore')
1093
tree, relpath = WorkingTree.open_containing(u'.')
1094
ifn = tree.abspath('.bzrignore')
801
1095
802
1096
if os.path.exists(ifn):
803
1097
f = open(ifn, 'rt')
822
1116
finally:
823
1117
f.close()
824
1118
825
inv = b.working_tree().inventory
1119
inv = tree.inventory
826
1120
if inv.path2id('.bzrignore'):
827
1121
mutter('.bzrignore is already versioned')
828
1122
else:
829
1123
mutter('need to make new .bzrignore file versioned')
830
b.add(['.bzrignore'])
831
1124
tree.add(['.bzrignore'])
832
1125
833
1126
834
1127
class cmd_ignored(Command):
835
1128
"""List ignored files and the patterns that matched them.
836
1129
837
1130
See also: bzr ignore"""
1131
@display_command
838
1132
def run(self):
839
tree = find_branch('.').working_tree()
840
for path, file_class, kind, file_id in tree.list_files():
1133
tree = WorkingTree.open_containing(u'.')[0]
1134
for path, file_class, kind, file_id, entry in tree.list_files():
841
1135
if file_class != 'I':
842
1136
continue
843
1137
## XXX: Slightly inefficient since this was already calculated
854
1148
hidden = True
855
1149
takes_args = ['revno']
856
1150
1151
@display_command
857
1152
def run(self, revno):
858
1153
try:
859
1154
revno = int(revno)
860
1155
except ValueError:
861
1156
raise BzrCommandError("not a valid revision-number: %r" % revno)
862
1157
863
print find_branch('.').lookup_revision(revno)
1158
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
864
1159
865
1160
866
1161
class cmd_export(Command):
873
1168
is found exports to a directory (equivalent to --format=dir).
874
1169
875
1170
Root may be the top directory for tar, tgz and tbz2 formats. If none
876
is given, the top directory will be the root name of the file."""
877
# 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
"""
878
1183
takes_args = ['dest']
879
1184
takes_options = ['revision', 'format', 'root']
880
1185
def run(self, dest, revision=None, format=None, root=None):
881
1186
import os.path
882
b = find_branch('.')
1187
from bzrlib.export import export
1188
tree = WorkingTree.open_containing(u'.')[0]
1189
b = tree.branch
883
1190
if revision is None:
884
rev_id = b.last_patch()
1191
# should be tree.last_revision FIXME
1192
rev_id = b.last_revision()
885
1193
else:
886
1194
if len(revision) != 1:
887
1195
raise BzrError('bzr export --revision takes exactly 1 argument')
888
revno, rev_id = b.get_revision_info(revision[0])
1196
rev_id = revision[0].in_history(b).rev_id
889
1197
t = b.revision_tree(rev_id)
890
root, ext = os.path.splitext(dest)
891
if not format:
892
if ext in (".tar",):
893
format = "tar"
894
elif ext in (".gz", ".tgz"):
895
format = "tgz"
896
elif ext in (".bz2", ".tbz2"):
897
format = "tbz2"
898
else:
899
format = "dir"
900
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)
901
1202
902
1203
903
1204
class cmd_cat(Command):
906
1207
takes_options = ['revision']
907
1208
takes_args = ['filename']
908
1209
1210
@display_command
909
1211
def run(self, filename, revision=None):
910
if revision == None:
911
raise BzrCommandError("bzr cat requires a revision number")
912
elif len(revision) != 1:
1212
if revision is not None and len(revision) != 1:
913
1213
raise BzrCommandError("bzr cat --revision takes exactly one number")
914
b = find_branch('.')
915
b.print_file(b.relpath(filename), revision[0])
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)
916
1228
917
1229
918
1230
class cmd_local_time_offset(Command):
919
1231
"""Show the offset in seconds from GMT to local time."""
920
1232
hidden = True
1233
@display_command
921
1234
def run(self):
922
1235
print bzrlib.osutils.local_time_offset()
923
1236
935
1248
A selected-file commit may fail in some cases where the committed
936
1249
tree would be invalid, such as trying to commit a file in a
937
1250
newly-added directory that is not itself committed.
938
939
TODO: Run hooks on tree to-be-committed, and after commit.
940
941
TODO: Strict commit that fails if there are unknown or deleted files.
942
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
943
1261
takes_args = ['selected*']
944
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
]
945
1272
aliases = ['ci', 'checkin']
946
1273
947
# TODO: Give better message for -s, --summary, used by tla people
948
949
1274
def run(self, message=None, file=None, verbose=True, selected_list=None,
950
unchanged=False):
951
from bzrlib.errors import PointlessCommit
952
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
953
1280
from bzrlib.status import show_status
954
from cStringIO import StringIO
955
956
b = find_branch('.')
957
if selected_list:
958
selected_list = [b.relpath(s) for s in selected_list]
959
960
if not message and not file:
961
catcher = StringIO()
962
show_status(b, specific_files=selected_list,
963
to_file=catcher)
964
message = edit_commit_message(catcher.getvalue())
965
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)
966
1296
if message is None:
967
1297
raise BzrCommandError("please specify a commit message"
968
1298
" with either --message or --file")
973
1303
import codecs
974
1304
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
975
1305
1306
if message == "":
1307
raise BzrCommandError("empty commit message specified")
1308
976
1309
try:
977
b.commit(message, verbose=verbose,
978
specific_files=selected_list,
979
allow_pointless=unchanged)
1310
tree.commit(message, specific_files=selected_list,
1311
allow_pointless=unchanged, strict=strict)
980
1312
except PointlessCommit:
981
1313
# FIXME: This should really happen before the file is read in;
982
1314
# perhaps prepare the commit; get the message; then actually commit
983
1315
raise BzrCommandError("no changes to commit",
984
1316
["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(),))
985
1324
986
1325
987
1326
class cmd_check(Command):
989
1328
990
1329
This command checks various invariants about the branch storage to
991
1330
detect data corruption or bzr bugs.
992
993
If given the --update flag, it will update some optional fields
994
to help ensure data consistency.
995
1331
"""
996
takes_args = ['dir?']
1332
takes_args = ['branch?']
1333
takes_options = ['verbose']
997
1334
998
def run(self, dir='.'):
1335
def run(self, branch=None, verbose=False):
999
1336
from bzrlib.check import check
1000
1001
check(find_branch(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)
1002
1343
1003
1344
1004
1345
class cmd_scan_cache(Command):
1006
1347
def run(self):
1007
1348
from bzrlib.hashcache import HashCache
1008
1349
1009
c = HashCache('.')
1350
c = HashCache(u'.')
1010
1351
c.read()
1011
1352
c.scan()
1012
1353
1026
1367
1027
1368
The check command or bzr developers may sometimes advise you to run
1028
1369
this command.
1370
1371
This version of this command upgrades from the full-text storage
1372
used by bzr 0.0.8 and earlier to the weave format (v5).
1029
1373
"""
1030
1374
takes_args = ['dir?']
1031
1375
1032
def run(self, dir='.'):
1376
def run(self, dir=u'.'):
1033
1377
from bzrlib.upgrade import upgrade
1034
upgrade(find_branch(dir))
1035
1378
upgrade(dir)
1036
1379
1037
1380
1038
1381
class cmd_whoami(Command):
1039
1382
"""Show bzr user id."""
1040
1383
takes_options = ['email']
1041
1384
1385
@display_command
1042
1386
def run(self, email=False):
1043
1387
try:
1044
b = bzrlib.branch.find_branch('.')
1045
except:
1046
b = None
1388
b = WorkingTree.open_containing(u'.')[0].branch
1389
config = bzrlib.config.BranchConfig(b)
1390
except NotBranchError:
1391
config = bzrlib.config.GlobalConfig()
1047
1392
1048
1393
if email:
1049
print bzrlib.osutils.user_email(b)
1050
else:
1051
print bzrlib.osutils.username(b)
1052
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
1053
1415
1054
1416
class cmd_selftest(Command):
1055
"""Run internal test suite"""
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
1056
1428
hidden = True
1057
takes_options = ['verbose', 'pattern']
1058
def run(self, 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):
1059
1438
import bzrlib.ui
1060
from bzrlib.selftest import selftest
1439
from bzrlib.tests import selftest
1061
1440
# we don't want progress meters from the tests to go to the
1062
1441
# real output; and we don't want log messages cluttering up
1063
1442
# the real logs.
1065
1444
bzrlib.trace.info('running tests...')
1066
1445
try:
1067
1446
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1068
result = selftest(verbose=verbose, pattern=pattern)
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)
1069
1455
if result:
1070
1456
bzrlib.trace.info('tests passed')
1071
1457
else:
1091
1477
1092
1478
class cmd_version(Command):
1093
1479
"""Show version of bzr."""
1480
@display_command
1094
1481
def run(self):
1095
1482
show_version()
1096
1483
1097
1484
class cmd_rocks(Command):
1098
1485
"""Statement of optimism."""
1099
1486
hidden = True
1487
@display_command
1100
1488
def run(self):
1101
1489
print "it sure does!"
1102
1490
1103
1491
1104
1492
class cmd_find_merge_base(Command):
1105
1493
"""Find and print a base revision for merging two branches.
1106
1107
TODO: Options to specify revisions on either side, as if
1108
merging only part of the history.
1109
1494
"""
1495
# TODO: Options to specify revisions on either side, as if
1496
# merging only part of the history.
1110
1497
takes_args = ['branch', 'other']
1111
1498
hidden = True
1112
1499
1500
@display_command
1113
1501
def run(self, branch, other):
1114
1502
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1115
1503
1116
branch1 = find_branch(branch)
1117
branch2 = find_branch(other)
1504
branch1 = Branch.open_containing(branch)[0]
1505
branch2 = Branch.open_containing(other)[0]
1118
1506
1119
1507
history_1 = branch1.revision_history()
1120
1508
history_2 = branch2.revision_history()
1121
1509
1122
last1 = branch1.last_patch()
1123
last2 = branch2.last_patch()
1510
last1 = branch1.last_revision()
1511
last2 = branch2.last_revision()
1124
1512
1125
1513
source = MultipleRevisionSources(branch1, branch2)
1126
1514
1169
1557
--force is given.
1170
1558
"""
1171
1559
takes_args = ['branch?']
1172
takes_options = ['revision', 'force', 'merge-type']
1560
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1561
Option('show-base', help="Show base revision text in "
1562
"conflicts")]
1173
1563
1174
def run(self, branch='.', revision=None, force=False,
1175
merge_type=None):
1564
def run(self, branch=None, revision=None, force=False, merge_type=None,
1565
show_base=False, reprocess=False):
1176
1566
from bzrlib.merge import merge
1177
1567
from bzrlib.merge_core import ApplyMerge3
1178
1568
if merge_type is None:
1179
1569
merge_type = ApplyMerge3
1180
1570
if branch is None:
1571
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1572
if branch is None:
1573
raise BzrCommandError("No merge location known or specified.")
1574
else:
1575
print "Using saved location: %s" % branch
1181
1576
if revision is None or len(revision) < 1:
1182
1577
base = [None, None]
1183
1578
other = [branch, -1]
1184
1579
else:
1185
1580
if len(revision) == 1:
1186
other = [branch, revision[0]]
1187
1581
base = [None, None]
1582
other_branch = Branch.open_containing(branch)[0]
1583
revno = revision[0].in_history(other_branch).revno
1584
other = [branch, revno]
1188
1585
else:
1189
1586
assert len(revision) == 2
1190
1587
if None in revision:
1191
1588
raise BzrCommandError(
1192
1589
"Merge doesn't permit that revision specifier.")
1193
base = [branch, revision[0]]
1194
other = [branch, revision[1]]
1590
b = Branch.open_containing(branch)[0]
1591
1592
base = [branch, revision[0].in_history(b).revno]
1593
other = [branch, revision[1].in_history(b).revno]
1195
1594
1196
1595
try:
1197
merge(other, base, check_clean=(not force), merge_type=merge_type)
1596
conflict_count = merge(other, base, check_clean=(not force),
1597
merge_type=merge_type, reprocess=reprocess,
1598
show_base=show_base)
1599
if conflict_count != 0:
1600
return 1
1601
else:
1602
return 0
1198
1603
except bzrlib.errors.AmbiguousBase, e:
1199
1604
m = ("sorry, bzr can't determine the right merge base yet\n"
1200
1605
"candidates are:\n "
1205
1610
log_error(m)
1206
1611
1207
1612
1613
class cmd_remerge(Command):
1614
"""Redo a merge.
1615
"""
1616
takes_args = ['file*']
1617
takes_options = ['merge-type', 'reprocess',
1618
Option('show-base', help="Show base revision text in "
1619
"conflicts")]
1620
1621
def run(self, file_list=None, merge_type=None, show_base=False,
1622
reprocess=False):
1623
from bzrlib.merge import merge_inner, transform_tree
1624
from bzrlib.merge_core import ApplyMerge3
1625
if merge_type is None:
1626
merge_type = ApplyMerge3
1627
tree, file_list = tree_files(file_list)
1628
tree.lock_write()
1629
try:
1630
pending_merges = tree.pending_merges()
1631
if len(pending_merges) != 1:
1632
raise BzrCommandError("Sorry, remerge only works after normal"
1633
+ " merges. Not cherrypicking or"
1634
+ "multi-merges.")
1635
base_revision = common_ancestor(tree.branch.last_revision(),
1636
pending_merges[0], tree.branch)
1637
base_tree = tree.branch.revision_tree(base_revision)
1638
other_tree = tree.branch.revision_tree(pending_merges[0])
1639
interesting_ids = None
1640
if file_list is not None:
1641
interesting_ids = set()
1642
for filename in file_list:
1643
file_id = tree.path2id(filename)
1644
interesting_ids.add(file_id)
1645
if tree.kind(file_id) != "directory":
1646
continue
1647
1648
for name, ie in tree.inventory.iter_entries(file_id):
1649
interesting_ids.add(ie.file_id)
1650
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1651
if file_list is None:
1652
restore_files = list(tree.iter_conflicts())
1653
else:
1654
restore_files = file_list
1655
for filename in restore_files:
1656
try:
1657
restore(tree.abspath(filename))
1658
except NotConflicted:
1659
pass
1660
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1661
interesting_ids = interesting_ids,
1662
other_rev_id=pending_merges[0],
1663
merge_type=merge_type,
1664
show_base=show_base,
1665
reprocess=reprocess)
1666
finally:
1667
tree.unlock()
1668
if conflicts > 0:
1669
return 1
1670
else:
1671
return 0
1672
1208
1673
class cmd_revert(Command):
1209
1674
"""Reverse all changes since the last commit.
1210
1675
1217
1682
aliases = ['merge-revert']
1218
1683
1219
1684
def run(self, revision=None, no_backup=False, file_list=None):
1220
from bzrlib.merge import merge
1221
from bzrlib.branch import Branch
1685
from bzrlib.merge import merge_inner
1222
1686
from bzrlib.commands import parse_spec
1223
1224
1687
if file_list is not None:
1225
1688
if len(file_list) == 0:
1226
1689
raise BzrCommandError("No files specified")
1690
else:
1691
file_list = []
1227
1692
if revision is None:
1228
revision = [-1]
1693
revno = -1
1694
tree = WorkingTree.open_containing(u'.')[0]
1695
# FIXME should be tree.last_revision
1696
rev_id = tree.branch.last_revision()
1229
1697
elif len(revision) != 1:
1230
1698
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1231
merge(('.', revision[0]), parse_spec('.'),
1232
check_clean=False,
1233
ignore_zero=True,
1234
backup_files=not no_backup,
1235
file_list=file_list)
1236
if not file_list:
1237
Branch('.').set_pending_merges([])
1699
else:
1700
tree, file_list = tree_files(file_list)
1701
rev_id = revision[0].in_history(tree.branch).rev_id
1702
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1703
not no_backup)
1238
1704
1239
1705
1240
1706
class cmd_assert_fail(Command):
1252
1718
takes_args = ['topic?']
1253
1719
aliases = ['?']
1254
1720
1721
@display_command
1255
1722
def run(self, topic=None, long=False):
1256
1723
import help
1257
1724
if topic is None and long:
1267
1734
aliases = ['s-c']
1268
1735
hidden = True
1269
1736
1737
@display_command
1270
1738
def run(self, context=None):
1271
1739
import shellcomplete
1272
1740
shellcomplete.shellcomplete(context)
1273
1741
1274
1742
1743
class cmd_fetch(Command):
1744
"""Copy in history from another branch but don't merge it.
1745
1746
This is an internal method used for pull and merge."""
1747
hidden = True
1748
takes_args = ['from_branch', 'to_branch']
1749
def run(self, from_branch, to_branch):
1750
from bzrlib.fetch import Fetcher
1751
from bzrlib.branch import Branch
1752
from_b = Branch.open(from_branch)
1753
to_b = Branch.open(to_branch)
1754
from_b.lock_read()
1755
try:
1756
to_b.lock_write()
1757
try:
1758
Fetcher(to_b, from_b)
1759
finally:
1760
to_b.unlock()
1761
finally:
1762
from_b.unlock()
1763
1764
1275
1765
class cmd_missing(Command):
1276
"""What is missing in this branch relative to other branch.
1277
"""
1278
takes_args = ['remote?']
1279
aliases = ['mis', 'miss']
1280
# We don't have to add quiet to the list, because
1281
# unknown options are parsed as booleans
1282
takes_options = ['verbose', 'quiet']
1283
1284
def run(self, remote=None, verbose=False, quiet=False):
1285
from bzrlib.errors import BzrCommandError
1286
from bzrlib.missing import show_missing
1287
1288
if verbose and quiet:
1289
raise BzrCommandError('Cannot pass both quiet and verbose')
1290
1291
b = find_branch('.')
1292
parent = b.get_parent()
1293
if remote is None:
1294
if parent is None:
1766
"""Show unmerged/unpulled revisions between two branches.
1767
1768
OTHER_BRANCH may be local or remote."""
1769
takes_args = ['other_branch?']
1770
takes_options = [Option('reverse', 'Reverse the order of revisions'),
1771
Option('mine-only',
1772
'Display changes in the local branch only'),
1773
Option('theirs-only',
1774
'Display changes in the remote branch only'),
1775
'line',
1776
'long',
1777
'short',
1778
'show-ids',
1779
'verbose'
1780
]
1781
1782
def run(self, other_branch=None, reverse=False, mine_only=False,
1783
theirs_only=False, long=True, short=False, line=False,
1784
show_ids=False, verbose=False):
1785
from bzrlib.missing import find_unmerged, iter_log_data
1786
from bzrlib.log import log_formatter
1787
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
1788
parent = local_branch.get_parent()
1789
if other_branch is None:
1790
other_branch = parent
1791
if other_branch is None:
1295
1792
raise BzrCommandError("No missing location known or specified.")
1296
else:
1297
if not quiet:
1298
print "Using last location: %s" % parent
1299
remote = parent
1300
elif parent is None:
1301
# We only update x-pull if it did not exist, missing should not change the parent
1302
b.controlfile('x-pull', 'wb').write(remote + '\n')
1303
br_remote = find_branch(remote)
1304
1305
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1306
1793
print "Using last location: " + local_branch.get_parent()
1794
remote_branch = bzrlib.branch.Branch.open(other_branch)
1795
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1796
log_format = get_log_format(long=long, short=short, line=line)
1797
lf = log_formatter(log_format, sys.stdout,
1798
show_ids=show_ids,
1799
show_timezone='original')
1800
if reverse is False:
1801
local_extra.reverse()
1802
remote_extra.reverse()
1803
if local_extra and not theirs_only:
1804
print "You have %d extra revision(s):" % len(local_extra)
1805
for data in iter_log_data(local_extra, local_branch, verbose):
1806
lf.show(*data)
1807
printed_local = True
1808
else:
1809
printed_local = False
1810
if remote_extra and not mine_only:
1811
if printed_local is True:
1812
print "\n\n"
1813
print "You are missing %d revision(s):" % len(remote_extra)
1814
for data in iter_log_data(remote_extra, remote_branch, verbose):
1815
lf.show(*data)
1816
if not remote_extra and not local_extra:
1817
status_code = 0
1818
print "Branches are up to date."
1819
else:
1820
status_code = 1
1821
if parent is None and other_branch is not None:
1822
local_branch.set_parent(other_branch)
1823
return status_code
1307
1824
1308
1825
1309
1826
class cmd_plugins(Command):
1310
1827
"""List plugins"""
1311
1828
hidden = True
1829
@display_command
1312
1830
def run(self):
1313
1831
import bzrlib.plugin
1314
1832
from inspect import getdoc
1315
for plugin in bzrlib.plugin.all_plugins:
1833
for name, plugin in bzrlib.plugin.all_plugins().items():
1316
1834
if hasattr(plugin, '__path__'):
1317
1835
print plugin.__path__[0]
1318
1836
elif hasattr(plugin, '__file__'):
1325
1843
print '\t', d.split('\n')[0]
1326
1844
1327
1845
1846
class cmd_testament(Command):
1847
"""Show testament (signing-form) of a revision."""
1848
takes_options = ['revision', 'long']
1849
takes_args = ['branch?']
1850
@display_command
1851
def run(self, branch=u'.', revision=None, long=False):
1852
from bzrlib.testament import Testament
1853
b = WorkingTree.open_containing(branch)[0].branch
1854
b.lock_read()
1855
try:
1856
if revision is None:
1857
rev_id = b.last_revision()
1858
else:
1859
rev_id = revision[0].in_history(b).rev_id
1860
t = Testament.from_revision(b, rev_id)
1861
if long:
1862
sys.stdout.writelines(t.as_text_lines())
1863
else:
1864
sys.stdout.write(t.as_short_text())
1865
finally:
1866
b.unlock()
1867
1868
1869
class cmd_annotate(Command):
1870
"""Show the origin of each line in a file.
1871
1872
This prints out the given file with an annotation on the left side
1873
indicating which revision, author and date introduced the change.
1874
1875
If the origin is the same for a run of consecutive lines, it is
1876
shown only at the top, unless the --all option is given.
1877
"""
1878
# TODO: annotate directories; showing when each file was last changed
1879
# TODO: annotate a previous version of a file
1880
# TODO: if the working copy is modified, show annotations on that
1881
# with new uncommitted lines marked
1882
aliases = ['blame', 'praise']
1883
takes_args = ['filename']
1884
takes_options = [Option('all', help='show annotations on all lines'),
1885
Option('long', help='show date in annotations'),
1886
]
1887
1888
@display_command
1889
def run(self, filename, all=False, long=False):
1890
from bzrlib.annotate import annotate_file
1891
tree, relpath = WorkingTree.open_containing(filename)
1892
branch = tree.branch
1893
branch.lock_read()
1894
try:
1895
file_id = tree.inventory.path2id(relpath)
1896
tree = branch.revision_tree(branch.last_revision())
1897
file_version = tree.inventory[file_id].revision
1898
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1899
finally:
1900
branch.unlock()
1901
1902
1903
class cmd_re_sign(Command):
1904
"""Create a digital signature for an existing revision."""
1905
# TODO be able to replace existing ones.
1906
1907
hidden = True # is this right ?
1908
takes_args = ['revision_id?']
1909
takes_options = ['revision']
1910
1911
def run(self, revision_id=None, revision=None):
1912
import bzrlib.config as config
1913
import bzrlib.gpg as gpg
1914
if revision_id is not None and revision is not None:
1915
raise BzrCommandError('You can only supply one of revision_id or --revision')
1916
if revision_id is None and revision is None:
1917
raise BzrCommandError('You must supply either --revision or a revision_id')
1918
b = WorkingTree.open_containing(u'.')[0].branch
1919
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1920
if revision_id is not None:
1921
b.sign_revision(revision_id, gpg_strategy)
1922
elif revision is not None:
1923
if len(revision) == 1:
1924
revno, rev_id = revision[0].in_history(b)
1925
b.sign_revision(rev_id, gpg_strategy)
1926
elif len(revision) == 2:
1927
# are they both on rh- if so we can walk between them
1928
# might be nice to have a range helper for arbitrary
1929
# revision paths. hmm.
1930
from_revno, from_revid = revision[0].in_history(b)
1931
to_revno, to_revid = revision[1].in_history(b)
1932
if to_revid is None:
1933
to_revno = b.revno()
1934
if from_revno is None or to_revno is None:
1935
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1936
for revno in range(from_revno, to_revno + 1):
1937
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1938
else:
1939
raise BzrCommandError('Please supply either one revision, or a range.')
1940
1941
1942
class cmd_uncommit(bzrlib.commands.Command):
1943
"""Remove the last committed revision.
1944
1945
By supplying the --all flag, it will not only remove the entry
1946
from revision_history, but also remove all of the entries in the
1947
stores.
1948
1949
--verbose will print out what is being removed.
1950
--dry-run will go through all the motions, but not actually
1951
remove anything.
1952
1953
In the future, uncommit will create a changeset, which can then
1954
be re-applied.
1955
"""
1956
takes_options = ['all', 'verbose', 'revision',
1957
Option('dry-run', help='Don\'t actually make changes'),
1958
Option('force', help='Say yes to all questions.')]
1959
takes_args = ['location?']
1960
aliases = []
1961
1962
def run(self, location=None, all=False,
1963
dry_run=False, verbose=False,
1964
revision=None, force=False):
1965
from bzrlib.branch import Branch
1966
from bzrlib.log import log_formatter
1967
import sys
1968
from bzrlib.uncommit import uncommit
1969
1970
if location is None:
1971
location = u'.'
1972
b, relpath = Branch.open_containing(location)
1973
1974
if revision is None:
1975
revno = b.revno()
1976
rev_id = b.last_revision()
1977
else:
1978
revno, rev_id = revision[0].in_history(b)
1979
if rev_id is None:
1980
print 'No revisions to uncommit.'
1981
1982
for r in range(revno, b.revno()+1):
1983
rev_id = b.get_rev_id(r)
1984
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1985
lf.show(r, b.get_revision(rev_id), None)
1986
1987
if dry_run:
1988
print 'Dry-run, pretending to remove the above revisions.'
1989
if not force:
1990
val = raw_input('Press <enter> to continue')
1991
else:
1992
print 'The above revision(s) will be removed.'
1993
if not force:
1994
val = raw_input('Are you sure [y/N]? ')
1995
if val.lower() not in ('y', 'yes'):
1996
print 'Canceled'
1997
return 0
1998
1999
uncommit(b, remove_files=all,
2000
dry_run=dry_run, verbose=verbose,
2001
revno=revno)
2002
2003
2004
# these get imported and then picked up by the scan for cmd_*
2005
# TODO: Some more consistent way to split command definitions across files;
2006
# we do need to load at least some information about them to know of
2007
# aliases.
2008
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
Loggerhead is a web-based interface for Breezy
Version: 2.0.1