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