« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1308
- compare with another revision
- download diff
- download tarball
- view history from revision 1308
- Committer: Martin Pool
- Date: 2005-09-16 09:56:24 UTC
- Revision ID: mbp@sourcefrog.net-20050916095623-ca0dff452934f21f
- make progress bar more tolerant of out-of-range values
- 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
- 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/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_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_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/store/weave.py => bzrlib/weavestore.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- bzrlib/upgrade.py => tools/history2weaves.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
27
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
22
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?)
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.branch import find_branch
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
28
72
29
73
30
class cmd_status(Command):
74
31
"""Display status summary.
106
63
files or directories is reported. If a directory is given, status
107
64
is reported for everything inside that directory.
108
65
109
If a revision argument is given, the status is calculated against
110
that revision, or between two revisions if two are provided.
66
If a revision is specified, the changes since that revision are shown.
111
67
"""
112
113
# TODO: --no-recurse, --recurse options
114
115
68
takes_args = ['file*']
116
69
takes_options = ['all', 'show-ids', 'revision']
117
70
aliases = ['st', 'stat']
118
71
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)
72
def run(self, all=False, show_ids=False, file_list=None):
73
if file_list:
74
b = find_branch(file_list[0])
75
file_list = [b.relpath(x) for x in file_list]
76
# special case: only one path was given and it's the root
77
# of the branch
78
if file_list == ['']:
79
file_list = None
80
else:
81
b = find_branch('.')
122
82
123
83
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)
84
show_status(b, show_unchanged=all, show_ids=show_ids,
85
specific_files=file_list)
126
86
127
87
128
88
class cmd_cat_revision(Command):
129
"""Write out metadata for a revision.
130
131
The revision to print can either be specified by a specific
132
revision identifier, or you can use --revision.
133
"""
89
"""Write out metadata for a revision."""
134
90
135
91
hidden = True
136
takes_args = ['revision_id?']
137
takes_options = ['revision']
92
takes_args = ['revision_id']
138
93
139
@display_command
140
def run(self, revision_id=None, revision=None):
94
def run(self, revision_id):
95
b = find_branch('.')
96
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
141
97
142
if revision_id is not None and revision is not None:
143
raise BzrCommandError('You can only supply one of revision_id or --revision')
144
if revision_id is None and revision is None:
145
raise BzrCommandError('You must supply either --revision or a revision_id')
146
b = WorkingTree.open_containing(u'.')[0].branch
147
if revision_id is not None:
148
sys.stdout.write(b.repository.get_revision_xml(revision_id))
149
elif revision is not None:
150
for rev in revision:
151
if rev is None:
152
raise BzrCommandError('You cannot specify a NULL revision.')
153
revno, rev_id = rev.in_history(b)
154
sys.stdout.write(b.repository.get_revision_xml(rev_id))
155
156
98
157
99
class cmd_revno(Command):
158
100
"""Show current revision number.
159
101
160
102
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()
103
def run(self):
104
print find_branch('.').revno()
165
105
166
106
167
107
class cmd_revision_info(Command):
170
110
hidden = True
171
111
takes_args = ['revision_info*']
172
112
takes_options = ['revision']
173
@display_command
174
def run(self, revision=None, revision_info_list=[]):
113
def run(self, revision=None, revision_info_list=None):
114
from bzrlib.branch import find_branch
175
115
176
116
revs = []
177
117
if revision is not None:
178
118
revs.extend(revision)
179
119
if revision_info_list is not None:
180
for rev in revision_info_list:
181
revs.append(RevisionSpec(rev))
120
revs.extend(revision_info_list)
182
121
if len(revs) == 0:
183
122
raise BzrCommandError('You must supply a revision identifier')
184
123
185
b = WorkingTree.open_containing(u'.')[0].branch
124
b = find_branch('.')
186
125
187
126
for rev in revs:
188
revinfo = rev.in_history(b)
189
if revinfo.revno is None:
190
print ' %s' % revinfo.rev_id
191
else:
192
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
127
print '%4d %s' % b.get_revision_info(rev)
193
128
194
129
195
130
class cmd_add(Command):
210
145
Therefore simply saying 'bzr add' will version all files that
211
146
are currently unknown.
212
147
213
Adding a file whose parent directory is not versioned will
214
implicitly add the parent, and so on up to the root. This means
215
you should never need to explictly add a directory, they'll just
216
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.
148
TODO: Perhaps adding a file whose directly is not versioned should
149
recursively add that parent, rather than giving an error?
220
150
"""
221
151
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."
152
takes_options = ['verbose', 'no-recurse']
153
154
def run(self, file_list, verbose=False, no_recurse=False):
155
# verbose currently has no effect
156
from bzrlib.add import smart_add, add_reporter_print
157
smart_add(file_list, not no_recurse, add_reporter_print)
158
251
159
252
160
253
161
class cmd_mkdir(Command):
258
166
takes_args = ['dir+']
259
167
260
168
def run(self, dir_list):
169
b = None
170
261
171
for d in dir_list:
262
172
os.mkdir(d)
263
wt, dd = WorkingTree.open_containing(d)
264
wt.add([dd])
173
if not b:
174
b = find_branch(d)
175
b.add([d])
265
176
print 'added', d
266
177
267
178
270
181
takes_args = ['filename']
271
182
hidden = True
272
183
273
@display_command
274
184
def run(self, filename):
275
tree, relpath = WorkingTree.open_containing(filename)
276
print relpath
185
print find_branch(filename).relpath(filename)
186
277
187
278
188
279
189
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']
190
"""Show inventory of the current working copy or a revision."""
191
takes_options = ['revision', 'show-ids']
286
192
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]
292
if revision is None:
293
inv = tree.read_working_inventory()
193
def run(self, revision=None, show_ids=False):
194
b = find_branch('.')
195
if revision == None:
196
inv = b.read_working_inventory()
294
197
else:
295
198
if len(revision) > 1:
296
199
raise BzrCommandError('bzr inventory --revision takes'
297
200
' exactly one revision identifier')
298
inv = tree.branch.repository.get_revision_inventory(
299
revision[0].in_history(tree.branch).rev_id)
201
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
300
202
301
203
for path, entry in inv.entries():
302
if kind and kind != entry.kind:
303
continue
304
204
if show_ids:
305
205
print '%-50s %s' % (path, entry.file_id)
306
206
else:
317
217
"""
318
218
takes_args = ['source$', 'dest']
319
219
def run(self, source_list, dest):
320
tree, source_list = tree_files(source_list)
220
b = find_branch('.')
221
321
222
# TODO: glob expansion on windows?
322
tree.move(source_list, tree.relpath(dest))
223
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
323
224
324
225
325
226
class cmd_rename(Command):
333
234
334
235
See also the 'move' command, which moves files into a different
335
236
directory without changing their name.
336
"""
337
# TODO: Some way to rename multiple files without invoking
338
# bzr for each one?"""
237
238
TODO: Some way to rename multiple files without invoking bzr for each
239
one?"""
339
240
takes_args = ['from_name', 'to_name']
340
241
341
242
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)
243
b = find_branch('.')
244
b.rename_one(b.relpath(from_name), b.relpath(to_name))
245
344
246
345
247
346
248
class cmd_mv(Command):
360
262
def run(self, names_list):
361
263
if len(names_list) < 2:
362
264
raise BzrCommandError("missing file argument")
363
tree, rel_names = tree_files(names_list)
265
b = find_branch(names_list[0])
266
267
rel_names = [b.relpath(x) for x in names_list]
364
268
365
269
if os.path.isdir(names_list[-1]):
366
270
# move into existing directory
367
for pair in tree.move(rel_names[:-1], rel_names[-1]):
271
for pair in b.move(rel_names[:-1], rel_names[-1]):
368
272
print "%s => %s" % pair
369
273
else:
370
274
if len(names_list) != 2:
371
275
raise BzrCommandError('to mv multiple files the destination '
372
276
'must be a versioned directory')
373
tree.rename_one(rel_names[0], rel_names[1])
374
print "%s => %s" % (rel_names[0], rel_names[1])
277
for pair in b.move(rel_names[0], rel_names[1]):
278
print "%s => %s" % pair
375
279
376
280
281
282
377
283
class cmd_pull(Command):
378
284
"""Pull any changes from another branch into the current one.
379
285
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.
286
If the location is omitted, the last-used location will be used.
287
Both the revision history and the working directory will be
288
updated.
383
289
384
290
This command only works on branches that have not diverged. Branches are
385
291
considered diverged if both branches have had commits without first
386
292
pulling from the other.
387
293
388
294
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.
295
from one into the other.
394
296
"""
395
takes_options = ['remember', 'overwrite', 'verbose']
396
297
takes_args = ['location?']
397
298
398
def run(self, location=None, remember=False, overwrite=False, verbose=False):
299
def run(self, location=None):
300
from bzrlib.merge import merge
301
import tempfile
399
302
from shutil import rmtree
400
303
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()
304
from bzrlib.branch import pull_loc
305
306
br_to = find_branch('.')
307
stored_loc = None
308
try:
309
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
310
except IOError, e:
311
if e.errno != errno.ENOENT:
312
raise
404
313
if location is None:
405
314
if stored_loc is None:
406
315
raise BzrCommandError("No pull location known or specified.")
407
316
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:
317
print "Using last location: %s" % stored_loc
318
location = stored_loc
319
cache_root = tempfile.mkdtemp()
320
from bzrlib.branch import DivergedBranches
321
br_from = find_branch(location)
322
location = pull_loc(br_from)
323
old_revno = br_to.revno()
324
try:
325
from branch import find_cached_branch, DivergedBranches
326
br_from = find_cached_branch(location, cache_root)
327
location = pull_loc(br_from)
328
old_revno = br_to.revno()
507
329
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,))
330
br_to.update_revisions(br_from)
331
except DivergedBranches:
332
raise BzrCommandError("These branches have diverged."
333
" Try merge.")
334
335
merge(('.', -1), ('.', old_revno), check_clean=False)
336
if location != stored_loc:
337
br_to.controlfile("x-pull", "wb").write(location + "\n")
338
finally:
339
rmtree(cache_root)
523
340
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
341
531
342
532
343
class cmd_branch(Command):
537
348
538
349
To retrieve the branch as of a particular revision, supply the --revision
539
350
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
351
"""
545
352
takes_args = ['from_location', 'to_location?']
546
takes_options = ['revision', 'basis']
353
takes_options = ['revision']
547
354
aliases = ['get', 'clone']
548
355
549
def run(self, from_location, to_location=None, revision=None, basis=None):
356
def run(self, from_location, to_location=None, revision=None):
357
from bzrlib.branch import copy_branch, find_cached_branch
358
import tempfile
550
359
import errno
551
360
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()
361
cache_root = tempfile.mkdtemp()
362
try:
363
if revision is None:
364
revision = [None]
365
elif len(revision) > 1:
366
raise BzrCommandError(
367
'bzr branch --revision takes exactly 1 revision value')
368
try:
369
br_from = find_cached_branch(from_location, cache_root)
370
except OSError, e:
371
if e.errno == errno.ENOENT:
372
raise BzrCommandError('Source location "%s" does not'
373
' exist.' % to_location)
374
else:
375
raise
578
376
if to_location is None:
579
377
to_location = os.path.basename(from_location.rstrip("/\\"))
580
name = None
581
else:
582
name = os.path.basename(to_location) + '\n'
583
378
try:
584
379
os.mkdir(to_location)
585
380
except OSError, e:
592
387
else:
593
388
raise
594
389
try:
595
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
596
branch = dir.open_branch()
390
copy_branch(br_from, to_location, revision[0])
597
391
except bzrlib.errors.NoSuchRevision:
598
392
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())
393
msg = "The branch %s has no revision %d." % (from_location, revision[0])
394
raise BzrCommandError(msg)
610
395
finally:
611
br_from.unlock()
396
rmtree(cache_root)
612
397
613
398
614
399
class cmd_renames(Command):
615
400
"""Show list of renamed files.
401
402
TODO: Option to show renames between two historical versions.
403
404
TODO: Only show renames under dir, rather than in the whole branch.
616
405
"""
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
406
takes_args = ['dir?']
621
407
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()
408
def run(self, dir='.'):
409
b = find_branch(dir)
410
old_inv = b.basis_tree().inventory
411
new_inv = b.read_working_inventory()
627
412
628
413
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
629
414
renames.sort()
635
420
"""Show statistical information about a branch."""
636
421
takes_args = ['branch?']
637
422
638
@display_command
639
423
def run(self, branch=None):
640
424
import info
641
b = WorkingTree.open_containing(branch)[0].branch
425
426
b = find_branch(branch)
642
427
info.show_info(b)
643
428
644
429
650
435
"""
651
436
takes_args = ['file+']
652
437
takes_options = ['verbose']
653
aliases = ['rm']
654
438
655
439
def run(self, file_list, verbose=False):
656
tree, file_list = tree_files(file_list)
657
tree.remove(file_list, verbose=verbose)
440
b = find_branch(file_list[0])
441
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
658
442
659
443
660
444
class cmd_file_id(Command):
666
450
"""
667
451
hidden = True
668
452
takes_args = ['filename']
669
@display_command
670
453
def run(self, filename):
671
tree, relpath = WorkingTree.open_containing(filename)
672
i = tree.inventory.path2id(relpath)
454
b = find_branch(filename)
455
i = b.inventory.path2id(b.relpath(filename))
673
456
if i == None:
674
457
raise BzrError("%r is not a versioned file" % filename)
675
458
else:
683
466
starting at the branch root."""
684
467
hidden = True
685
468
takes_args = ['filename']
686
@display_command
687
469
def run(self, filename):
688
tree, relpath = WorkingTree.open_containing(filename)
689
inv = tree.inventory
690
fid = inv.path2id(relpath)
470
b = find_branch(filename)
471
inv = b.inventory
472
fid = inv.path2id(b.relpath(filename))
691
473
if fid == None:
692
474
raise BzrError("%r is not a versioned file" % filename)
693
475
for fip in inv.get_idpath(fid):
697
479
class cmd_revision_history(Command):
698
480
"""Display list of revision ids on this branch."""
699
481
hidden = True
700
@display_command
701
482
def run(self):
702
branch = WorkingTree.open_containing(u'.')[0].branch
703
for patchid in branch.revision_history():
483
for patchid in find_branch('.').revision_history():
704
484
print patchid
705
485
706
486
707
487
class cmd_ancestry(Command):
708
488
"""List all revisions merged into this branch."""
709
489
hidden = True
710
@display_command
711
490
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()):
491
b = find_branch('.')
492
for revision_id in b.get_ancestry(b.last_revision()):
716
493
print revision_id
717
494
718
495
496
class cmd_directories(Command):
497
"""Display list of versioned directories in this branch."""
498
def run(self):
499
for name, ie in find_branch('.').read_working_inventory().directories():
500
if name == '':
501
print '.'
502
else:
503
print name
504
505
719
506
class cmd_init(Command):
720
507
"""Make a directory into a versioned branch.
721
508
725
512
Recipe for importing a tree of files:
726
513
cd ~/project
727
514
bzr init
728
bzr add .
515
bzr add -v .
729
516
bzr status
730
517
bzr commit -m 'imported project'
731
518
"""
732
takes_args = ['location?']
733
def run(self, location=None):
519
def run(self):
734
520
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)
521
Branch('.', init=True)
746
522
747
523
748
524
class cmd_diff(Command):
751
527
If files are listed, only the changes in those files are listed.
752
528
Otherwise, all changes for the tree are listed.
753
529
530
TODO: Allow diff across branches.
531
532
TODO: Option to use external diff command; could be GNU diff, wdiff,
533
or a graphical diff.
534
535
TODO: Python difflib is not exactly the same as unidiff; should
536
either fix it up or prefer to use an external diff.
537
538
TODO: If a directory is given, diff everything under that.
539
540
TODO: Selected-file diff is inefficient and doesn't show you
541
deleted files.
542
543
TODO: This probably handles non-Unix newlines poorly.
544
754
545
examples:
755
546
bzr diff
756
547
bzr diff -r1
757
bzr diff -r1..2
548
bzr diff -r1:2
758
549
"""
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
550
773
551
takes_args = ['file*']
774
552
takes_options = ['revision', 'diff-options']
775
553
aliases = ['di', 'dif']
776
554
777
@display_command
778
555
def run(self, revision=None, file_list=None, diff_options=None):
779
556
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
557
558
if file_list:
559
b = find_branch(file_list[0])
560
file_list = [b.relpath(f) for f in file_list]
561
if file_list == ['']:
562
# just pointing to top-of-tree
563
file_list = None
564
else:
565
b = find_branch('.')
566
794
567
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)
568
if len(revision) == 1:
569
show_diff(b, revision[0], specific_files=file_list,
570
external_diff_options=diff_options)
800
571
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])
572
show_diff(b, revision[0], specific_files=file_list,
573
external_diff_options=diff_options,
574
revision2=revision[1])
804
575
else:
805
576
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
806
577
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)
578
show_diff(b, None, specific_files=file_list,
579
external_diff_options=diff_options)
580
581
813
582
814
583
815
584
class cmd_deleted(Command):
816
585
"""List files deleted in the working tree.
586
587
TODO: Show files deleted since a previous revision, or between two revisions.
817
588
"""
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
589
def run(self, show_ids=False):
826
tree = WorkingTree.open_containing(u'.')[0]
827
old = tree.basis_tree()
590
b = find_branch('.')
591
old = b.basis_tree()
592
new = b.working_tree()
593
594
## TODO: Much more efficient way to do this: read in new
595
## directories with readdir, rather than stating each one. Same
596
## level of effort but possibly much less IO. (Or possibly not,
597
## if the directories are very large...)
598
828
599
for path, ie in old.inventory.iter_entries():
829
if not tree.has_id(ie.file_id):
600
if not new.has_id(ie.file_id):
830
601
if show_ids:
831
602
print '%-50s %s' % (path, ie.file_id)
832
603
else:
836
607
class cmd_modified(Command):
837
608
"""List files modified in working tree."""
838
609
hidden = True
839
@display_command
840
610
def run(self):
841
611
from bzrlib.delta import compare_trees
842
612
843
tree = WorkingTree.open_containing(u'.')[0]
844
td = compare_trees(tree.basis_tree(), tree)
613
b = find_branch('.')
614
td = compare_trees(b.basis_tree(), b.working_tree())
845
615
846
for path, id, kind, text_modified, meta_modified in td.modified:
616
for path, id, kind in td.modified:
847
617
print path
848
618
849
619
851
621
class cmd_added(Command):
852
622
"""List files added in working tree."""
853
623
hidden = True
854
@display_command
855
624
def run(self):
856
wt = WorkingTree.open_containing(u'.')[0]
857
basis_inv = wt.basis_tree().inventory
625
b = find_branch('.')
626
wt = b.working_tree()
627
basis_inv = b.basis_tree().inventory
858
628
inv = wt.inventory
859
629
for file_id in inv:
860
630
if file_id in basis_inv:
861
631
continue
862
632
path = inv.id2path(file_id)
863
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
633
if not os.access(b.abspath(path), os.F_OK):
864
634
continue
865
635
print path
866
636
872
642
The root is the nearest enclosing directory with a .bzr control
873
643
directory."""
874
644
takes_args = ['filename?']
875
@display_command
876
645
def run(self, filename=None):
877
646
"""Print the branch root."""
878
tree = WorkingTree.open_containing(filename)[0]
879
print tree.basedir
647
b = find_branch(filename)
648
print getattr(b, 'base', None) or getattr(b, 'baseurl')
880
649
881
650
882
651
class cmd_log(Command):
883
652
"""Show log of this branch.
884
653
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
654
To request a range of logs, you can use the command -r begin:end
655
-r revision requests a specific revision, -r :end or -r begin: are
887
656
also valid.
657
658
--message allows you to give a regular expression, which will be evaluated
659
so that only matching entries will be displayed.
660
661
TODO: Make --revision support uuid: and hash: [future tag:] notation.
662
888
663
"""
889
664
890
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
891
892
665
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
666
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
667
'long', 'message', 'short',]
668
904
669
def run(self, filename=None, timezone='original',
905
670
verbose=False,
906
671
show_ids=False,
908
673
revision=None,
909
674
message=None,
910
675
long=False,
911
short=False,
912
line=False):
676
short=False):
913
677
from bzrlib.log import log_formatter, show_log
914
678
import codecs
915
assert message is None or isinstance(message, basestring), \
916
"invalid message argument %r" % message
679
917
680
direction = (forward and 'forward') or 'reverse'
918
681
919
# log everything
920
file_id = None
921
682
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)
683
b = find_branch(filename)
684
fp = b.relpath(filename)
685
if fp:
686
file_id = b.read_working_inventory().path2id(fp)
687
else:
688
file_id = None # points to branch root
934
689
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()
690
b = find_branch('.')
691
file_id = None
939
692
940
693
if revision is None:
941
694
rev1 = None
942
695
rev2 = None
943
696
elif len(revision) == 1:
944
rev1 = rev2 = revision[0].in_history(b).revno
697
rev1 = rev2 = b.get_revision_info(revision[0])[0]
945
698
elif len(revision) == 2:
946
rev1 = revision[0].in_history(b).revno
947
rev2 = revision[1].in_history(b).revno
699
rev1 = b.get_revision_info(revision[0])[0]
700
rev2 = b.get_revision_info(revision[1])[0]
948
701
else:
949
702
raise BzrCommandError('bzr log --revision takes one or two values.')
950
703
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)
704
if rev1 == 0:
705
rev1 = None
706
if rev2 == 0:
707
rev2 = None
956
708
957
mutter('encoding log as %r', bzrlib.user_encoding)
709
mutter('encoding log as %r' % bzrlib.user_encoding)
958
710
959
711
# use 'replace' so that we don't abort if trying to write out
960
712
# in e.g. the default C locale.
961
713
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
962
714
963
log_format = get_log_format(long=long, short=short, line=line)
715
if not short:
716
log_format = 'long'
717
else:
718
log_format = 'short'
964
719
lf = log_formatter(log_format,
965
720
show_ids=show_ids,
966
721
to_file=outf,
976
731
search=message)
977
732
978
733
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
734
990
735
class cmd_touching_revisions(Command):
991
736
"""Return revision-ids which affected a particular file.
993
738
A more user-friendly interface is "bzr log FILE"."""
994
739
hidden = True
995
740
takes_args = ["filename"]
996
@display_command
997
741
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)
742
b = find_branch(filename)
743
inv = b.read_working_inventory()
744
file_id = inv.path2id(b.relpath(filename))
1002
745
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1003
746
print "%6d %s" % (revno, what)
1004
747
1005
748
1006
749
class cmd_ls(Command):
1007
750
"""List files in a tree.
751
752
TODO: Take a revision or remote path and list that tree instead.
1008
753
"""
1009
# TODO: Take a revision or remote path and list that tree instead.
1010
754
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()
755
def run(self, revision=None, verbose=False):
756
b = find_branch('.')
757
if revision == None:
758
tree = b.working_tree()
759
else:
760
tree = b.revision_tree(b.lookup_revision(revision))
761
762
for fp, fc, kind, fid in tree.list_files():
763
if verbose:
764
if kind == 'directory':
765
kindch = '/'
766
elif kind == 'file':
767
kindch = ''
1056
768
else:
1057
print fp
769
kindch = '???'
770
771
print '%-8s %s%s' % (fc, fp, kindch)
772
else:
773
print fp
774
1058
775
1059
776
1060
777
class cmd_unknowns(Command):
1061
778
"""List unknown files."""
1062
@display_command
1063
779
def run(self):
1064
780
from bzrlib.osutils import quotefn
1065
for f in WorkingTree.open_containing(u'.')[0].unknowns():
781
for f in find_branch('.').unknowns():
1066
782
print quotefn(f)
1067
783
1068
784
785
1069
786
class cmd_ignore(Command):
1070
787
"""Ignore a command or pattern.
1071
788
1072
789
To remove patterns from the ignore list, edit the .bzrignore file.
1073
790
1074
791
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 './'.
792
from the branch root. Otherwise, it is comapred to only the last
793
component of the path.
1078
794
1079
795
Ignore patterns are case-insensitive on case-insensitive systems.
1080
796
1084
800
bzr ignore ./Makefile
1085
801
bzr ignore '*.class'
1086
802
"""
1087
# TODO: Complain if the filename is absolute
1088
803
takes_args = ['name_pattern']
1089
804
1090
805
def run(self, name_pattern):
1091
806
from bzrlib.atomicfile import AtomicFile
1092
807
import os.path
1093
808
1094
tree, relpath = WorkingTree.open_containing(u'.')
1095
ifn = tree.abspath('.bzrignore')
809
b = find_branch('.')
810
ifn = b.abspath('.bzrignore')
1096
811
1097
812
if os.path.exists(ifn):
1098
813
f = open(ifn, 'rt')
1117
832
finally:
1118
833
f.close()
1119
834
1120
inv = tree.inventory
835
inv = b.working_tree().inventory
1121
836
if inv.path2id('.bzrignore'):
1122
837
mutter('.bzrignore is already versioned')
1123
838
else:
1124
839
mutter('need to make new .bzrignore file versioned')
1125
tree.add(['.bzrignore'])
840
b.add(['.bzrignore'])
841
1126
842
1127
843
1128
844
class cmd_ignored(Command):
1129
845
"""List ignored files and the patterns that matched them.
1130
846
1131
847
See also: bzr ignore"""
1132
@display_command
1133
848
def run(self):
1134
tree = WorkingTree.open_containing(u'.')[0]
1135
for path, file_class, kind, file_id, entry in tree.list_files():
849
tree = find_branch('.').working_tree()
850
for path, file_class, kind, file_id in tree.list_files():
1136
851
if file_class != 'I':
1137
852
continue
1138
853
## XXX: Slightly inefficient since this was already calculated
1149
864
hidden = True
1150
865
takes_args = ['revno']
1151
866
1152
@display_command
1153
867
def run(self, revno):
1154
868
try:
1155
869
revno = int(revno)
1156
870
except ValueError:
1157
871
raise BzrCommandError("not a valid revision-number: %r" % revno)
1158
872
1159
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
873
print find_branch('.').lookup_revision(revno)
1160
874
1161
875
1162
876
class cmd_export(Command):
1169
883
is found exports to a directory (equivalent to --format=dir).
1170
884
1171
885
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
"""
886
is given, the top directory will be the root name of the file."""
887
# TODO: list known exporters
1184
888
takes_args = ['dest']
1185
889
takes_options = ['revision', 'format', 'root']
1186
890
def run(self, dest, revision=None, format=None, root=None):
1187
891
import os.path
1188
from bzrlib.export import export
1189
tree = WorkingTree.open_containing(u'.')[0]
1190
b = tree.branch
892
b = find_branch('.')
1191
893
if revision is None:
1192
# should be tree.last_revision FIXME
1193
894
rev_id = b.last_revision()
1194
895
else:
1195
896
if len(revision) != 1:
1196
897
raise BzrError('bzr export --revision takes exactly 1 argument')
1197
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)
898
revno, rev_id = b.get_revision_info(revision[0])
899
t = b.revision_tree(rev_id)
900
root, ext = os.path.splitext(dest)
901
if not format:
902
if ext in (".tar",):
903
format = "tar"
904
elif ext in (".gz", ".tgz"):
905
format = "tgz"
906
elif ext in (".bz2", ".tbz2"):
907
format = "tbz2"
908
else:
909
format = "dir"
910
t.export(dest, format, root)
1203
911
1204
912
1205
913
class cmd_cat(Command):
1208
916
takes_options = ['revision']
1209
917
takes_args = ['filename']
1210
918
1211
@display_command
1212
919
def run(self, filename, revision=None):
1213
if revision is not None and len(revision) != 1:
920
if revision == None:
921
raise BzrCommandError("bzr cat requires a revision number")
922
elif len(revision) != 1:
1214
923
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)
924
b = find_branch('.')
925
b.print_file(b.relpath(filename), revision[0])
1229
926
1230
927
1231
928
class cmd_local_time_offset(Command):
1232
929
"""Show the offset in seconds from GMT to local time."""
1233
930
hidden = True
1234
@display_command
1235
931
def run(self):
1236
932
print bzrlib.osutils.local_time_offset()
1237
933
1249
945
A selected-file commit may fail in some cases where the committed
1250
946
tree would be invalid, such as trying to commit a file in a
1251
947
newly-added directory that is not itself committed.
948
949
TODO: Run hooks on tree to-be-committed, and after commit.
950
951
TODO: Strict commit that fails if there are unknown or deleted files.
1252
952
"""
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 ??)
953
takes_args = ['selected*']
954
takes_options = ['message', 'file', 'verbose', 'unchanged']
955
aliases = ['ci', 'checkin']
1257
956
1258
957
# TODO: Give better message for -s, --summary, used by tla people
1259
958
1260
959
# XXX: verbose currently does nothing
1261
1262
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
]
1273
aliases = ['ci', 'checkin']
1274
960
1275
961
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
962
unchanged=False):
963
from bzrlib.errors import PointlessCommit
964
from bzrlib.msgeditor import edit_commit_message
1281
965
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)
966
from cStringIO import StringIO
967
968
b = find_branch('.')
969
if selected_list:
970
selected_list = [b.relpath(s) for s in selected_list]
971
972
if not message and not file:
973
catcher = StringIO()
974
show_status(b, specific_files=selected_list,
975
to_file=catcher)
976
message = edit_commit_message(catcher.getvalue())
977
1297
978
if message is None:
1298
979
raise BzrCommandError("please specify a commit message"
1299
980
" with either --message or --file")
1304
985
import codecs
1305
986
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1306
987
1307
if message == "":
1308
raise BzrCommandError("empty commit message specified")
1309
1310
988
try:
1311
tree.commit(message, specific_files=selected_list,
1312
allow_pointless=unchanged, strict=strict)
989
b.commit(message,
990
specific_files=selected_list,
991
allow_pointless=unchanged)
1313
992
except PointlessCommit:
1314
993
# FIXME: This should really happen before the file is read in;
1315
994
# perhaps prepare the commit; get the message; then actually commit
1316
995
raise BzrCommandError("no changes to commit",
1317
996
["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
997
1326
998
1327
999
class cmd_check(Command):
1329
1001
1330
1002
This command checks various invariants about the branch storage to
1331
1003
detect data corruption or bzr bugs.
1004
1005
If given the --update flag, it will update some optional fields
1006
to help ensure data consistency.
1332
1007
"""
1333
takes_args = ['branch?']
1334
takes_options = ['verbose']
1008
takes_args = ['dir?']
1335
1009
1336
def run(self, branch=None, verbose=False):
1010
def run(self, dir='.'):
1337
1011
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)
1012
1013
check(find_branch(dir))
1344
1014
1345
1015
1346
1016
class cmd_scan_cache(Command):
1348
1018
def run(self):
1349
1019
from bzrlib.hashcache import HashCache
1350
1020
1351
c = HashCache(u'.')
1021
c = HashCache('.')
1352
1022
c.read()
1353
1023
c.scan()
1354
1024
1367
1037
"""Upgrade branch storage to current format.
1368
1038
1369
1039
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.
1040
this command.
1372
1041
"""
1373
takes_args = ['url?']
1042
takes_args = ['dir?']
1374
1043
1375
def run(self, url='.'):
1044
def run(self, dir='.'):
1376
1045
from bzrlib.upgrade import upgrade
1377
upgrade(url)
1046
upgrade(find_branch(dir))
1047
1378
1048
1379
1049
1380
1050
class cmd_whoami(Command):
1381
1051
"""Show bzr user id."""
1382
1052
takes_options = ['email']
1383
1053
1384
@display_command
1385
1054
def run(self, email=False):
1386
1055
try:
1387
b = WorkingTree.open_containing(u'.')[0].branch
1388
config = bzrlib.config.BranchConfig(b)
1389
except NotBranchError:
1390
config = bzrlib.config.GlobalConfig()
1056
b = bzrlib.branch.find_branch('.')
1057
except:
1058
b = None
1391
1059
1392
1060
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
1061
print bzrlib.osutils.user_email(b)
1062
else:
1063
print bzrlib.osutils.username(b)
1415
1064
1416
1065
1417
1066
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
1067
"""Run internal test suite"""
1453
1068
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):
1069
takes_options = ['verbose', 'pattern']
1070
def run(self, verbose=False, pattern=".*"):
1467
1071
import bzrlib.ui
1468
from bzrlib.tests import selftest
1072
from bzrlib.selftest import selftest
1469
1073
# we don't want progress meters from the tests to go to the
1470
1074
# real output; and we don't want log messages cluttering up
1471
1075
# the real logs.
1473
1077
bzrlib.trace.info('running tests...')
1474
1078
try:
1475
1079
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)
1080
result = selftest(verbose=verbose, pattern=pattern)
1485
1081
if result:
1486
1082
bzrlib.trace.info('tests passed')
1487
1083
else:
1491
1087
bzrlib.ui.ui_factory = save_ui
1492
1088
1493
1089
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
1090
def show_version():
1509
1091
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1510
1092
# 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],)
1093
bzrrev = bzrlib.get_bzr_revision()
1094
if bzrrev:
1095
print " (bzr checkout, revision %d {%s})" % bzrrev
1519
1096
print bzrlib.__copyright__
1520
1097
print "http://bazaar-ng.org/"
1521
1098
print
1526
1103
1527
1104
class cmd_version(Command):
1528
1105
"""Show version of bzr."""
1529
@display_command
1530
1106
def run(self):
1531
1107
show_version()
1532
1108
1533
1109
class cmd_rocks(Command):
1534
1110
"""Statement of optimism."""
1535
1111
hidden = True
1536
@display_command
1537
1112
def run(self):
1538
1113
print "it sure does!"
1539
1114
1540
1115
1541
1116
class cmd_find_merge_base(Command):
1542
1117
"""Find and print a base revision for merging two branches.
1118
1119
TODO: Options to specify revisions on either side, as if
1120
merging only part of the history.
1543
1121
"""
1544
# TODO: Options to specify revisions on either side, as if
1545
# merging only part of the history.
1546
1122
takes_args = ['branch', 'other']
1547
1123
hidden = True
1548
1124
1549
@display_command
1550
1125
def run(self, branch, other):
1551
1126
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1552
1127
1553
branch1 = Branch.open_containing(branch)[0]
1554
branch2 = Branch.open_containing(other)[0]
1128
branch1 = find_branch(branch)
1129
branch2 = find_branch(other)
1555
1130
1556
1131
history_1 = branch1.revision_history()
1557
1132
history_2 = branch2.revision_history()
1559
1134
last1 = branch1.last_revision()
1560
1135
last2 = branch2.last_revision()
1561
1136
1562
source = MultipleRevisionSources(branch1.repository,
1563
branch2.repository)
1137
source = MultipleRevisionSources(branch1, branch2)
1564
1138
1565
1139
base_rev_id = common_ancestor(last1, last2, source)
1566
1140
1607
1181
--force is given.
1608
1182
"""
1609
1183
takes_args = ['branch?']
1610
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1611
Option('show-base', help="Show base revision text in "
1612
"conflicts")]
1184
takes_options = ['revision', 'force', 'merge-type']
1613
1185
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
1186
def run(self, branch='.', revision=None, force=False,
1187
merge_type=None):
1188
from bzrlib.merge import merge
1189
from bzrlib.merge_core import ApplyMerge3
1617
1190
if merge_type is None:
1618
1191
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
1192
1625
1193
if revision is None or len(revision) < 1:
1626
1194
base = [None, None]
1627
1195
other = [branch, -1]
1628
1196
else:
1629
1197
if len(revision) == 1:
1198
other = [branch, revision[0]]
1630
1199
base = [None, None]
1631
other_branch = Branch.open_containing(branch)[0]
1632
revno = revision[0].in_history(other_branch).revno
1633
other = [branch, revno]
1634
1200
else:
1635
1201
assert len(revision) == 2
1636
1202
if None in revision:
1637
1203
raise BzrCommandError(
1638
1204
"Merge doesn't permit that revision specifier.")
1639
b = Branch.open_containing(branch)[0]
1640
1641
base = [branch, revision[0].in_history(b).revno]
1642
other = [branch, revision[1].in_history(b).revno]
1205
base = [branch, revision[0]]
1206
other = [branch, revision[1]]
1643
1207
1644
1208
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
1209
merge(other, base, check_clean=(not force), merge_type=merge_type)
1652
1210
except bzrlib.errors.AmbiguousBase, e:
1653
1211
m = ("sorry, bzr can't determine the right merge base yet\n"
1654
1212
"candidates are:\n "
1659
1217
log_error(m)
1660
1218
1661
1219
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
1220
class cmd_revert(Command):
1724
1221
"""Reverse all changes since the last commit.
1725
1222
1732
1229
aliases = ['merge-revert']
1733
1230
1734
1231
def run(self, revision=None, no_backup=False, file_list=None):
1232
from bzrlib.merge import merge
1233
from bzrlib.branch import Branch
1735
1234
from bzrlib.commands import parse_spec
1235
1736
1236
if file_list is not None:
1737
1237
if len(file_list) == 0:
1738
1238
raise BzrCommandError("No files specified")
1739
else:
1740
file_list = []
1741
1742
tree, file_list = tree_files(file_list)
1743
1239
if revision is None:
1744
# FIXME should be tree.last_revision
1745
rev_id = tree.branch.last_revision()
1240
revision = [-1]
1746
1241
elif len(revision) != 1:
1747
1242
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1748
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)
1243
merge(('.', revision[0]), parse_spec('.'),
1244
check_clean=False,
1245
ignore_zero=True,
1246
backup_files=not no_backup,
1247
file_list=file_list)
1248
if not file_list:
1249
Branch('.').set_pending_merges([])
1752
1250
1753
1251
1754
1252
class cmd_assert_fail(Command):
1766
1264
takes_args = ['topic?']
1767
1265
aliases = ['?']
1768
1266
1769
@display_command
1770
1267
def run(self, topic=None, long=False):
1771
1268
import help
1772
1269
if topic is None and long:
1782
1279
aliases = ['s-c']
1783
1280
hidden = True
1784
1281
1785
@display_command
1786
1282
def run(self, context=None):
1787
1283
import shellcomplete
1788
1284
shellcomplete.shellcomplete(context)
1797
1293
def run(self, from_branch, to_branch):
1798
1294
from bzrlib.fetch import Fetcher
1799
1295
from bzrlib.branch import Branch
1800
from_b = Branch.open(from_branch)
1801
to_b = Branch.open(to_branch)
1296
from_b = Branch(from_branch)
1297
to_b = Branch(to_branch)
1802
1298
Fetcher(to_b, from_b)
1299
1803
1300
1804
1301
1805
1302
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:
1303
"""What is missing in this branch relative to other branch.
1304
"""
1305
# TODO: rewrite this in terms of ancestry so that it shows only
1306
# unmerged things
1307
1308
takes_args = ['remote?']
1309
aliases = ['mis', 'miss']
1310
# We don't have to add quiet to the list, because
1311
# unknown options are parsed as booleans
1312
takes_options = ['verbose', 'quiet']
1313
1314
def run(self, remote=None, verbose=False, quiet=False):
1315
from bzrlib.errors import BzrCommandError
1316
from bzrlib.missing import show_missing
1317
1318
if verbose and quiet:
1319
raise BzrCommandError('Cannot pass both quiet and verbose')
1320
1321
b = find_branch('.')
1322
parent = b.get_parent()
1323
if remote is None:
1324
if parent is None:
1832
1325
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
1326
else:
1327
if not quiet:
1328
print "Using last location: %s" % parent
1329
remote = parent
1330
elif parent is None:
1331
# We only update x-pull if it did not exist, missing should not change the parent
1332
b.controlfile('x-pull', 'wb').write(remote + '\n')
1333
br_remote = find_branch(remote)
1334
1335
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1336
1866
1337
1867
1338
1868
1339
class cmd_plugins(Command):
1869
1340
"""List plugins"""
1870
1341
hidden = True
1871
@display_command
1872
1342
def run(self):
1873
1343
import bzrlib.plugin
1874
1344
from inspect import getdoc
1875
for name, plugin in bzrlib.plugin.all_plugins().items():
1345
for plugin in bzrlib.plugin.all_plugins:
1876
1346
if hasattr(plugin, '__path__'):
1877
1347
print plugin.__path__[0]
1878
1348
elif hasattr(plugin, '__file__'):
1885
1355
print '\t', d.split('\n')[0]
1886
1356
1887
1357
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