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