1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
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
17
"""builtin bzr commands"""
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
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
from bzrlib.conflicts import ConflictList
45
from bzrlib.commands import Command, display_command
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
47
NotBranchError, DivergedBranches, NotConflicted,
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
54
from bzrlib.revisionspec import RevisionSpec
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
57
from bzrlib.workingtree import WorkingTree
60
def tree_files(file_list, default_branch=u'.'):
62
return internal_tree_files(file_list, default_branch)
63
except FileInWrongBranch, e:
64
raise BzrCommandError("%s is not in the same branch as %s" %
65
(e.path, file_list[0]))
68
# XXX: Bad function name; should possibly also be a class method of
69
# WorkingTree rather than a function.
70
def internal_tree_files(file_list, default_branch=u'.'):
71
"""Convert command-line paths to a WorkingTree and relative paths.
73
This is typically used for command-line processors that take one or
74
more filenames, and infer the workingtree that contains them.
76
The filenames given are not required to exist.
78
:param file_list: Filenames to convert.
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
82
:return: workingtree, [relative_paths]
84
if file_list is None or len(file_list) == 0:
85
return WorkingTree.open_containing(default_branch)[0], file_list
86
tree = WorkingTree.open_containing(file_list[0])[0]
88
for filename in file_list:
90
new_list.append(tree.relpath(filename))
91
except errors.PathNotChild:
92
raise FileInWrongBranch(tree.branch, filename)
96
def get_format_type(typestring):
97
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
100
if typestring == "default":
101
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
110
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
111
"metaweave and weave" % typestring
112
raise BzrCommandError(msg)
115
# TODO: Make sure no commands unconditionally use the working directory as a
116
# branch. If a filename argument is used, the first of them should be used to
117
# specify the branch. (Perhaps this can be factored out into some kind of
118
# Argument class, representing a file in a branch, where the first occurrence
30
121
class cmd_status(Command):
31
122
"""Display status summary.
63
150
files or directories is reported. If a directory is given, status
64
151
is reported for everything inside that directory.
66
If a revision is specified, the changes since that revision are shown.
153
If a revision argument is given, the status is calculated against
154
that revision, or between two revisions if two are provided.
157
# TODO: --no-recurse, --recurse options
68
159
takes_args = ['file*']
69
takes_options = ['all', 'show-ids', 'revision']
160
takes_options = ['show-ids', 'revision']
70
161
aliases = ['st', 'stat']
163
encoding_type = 'replace'
72
def run(self, all=False, show_ids=False, file_list=None):
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
166
def run(self, show_ids=False, file_list=None, revision=None):
167
from bzrlib.status import show_tree_status
169
tree, file_list = tree_files(file_list)
83
from bzrlib.status import show_status
84
show_status(b, show_unchanged=all, show_ids=show_ids,
85
specific_files=file_list)
171
show_tree_status(tree, show_ids=show_ids,
172
specific_files=file_list, revision=revision,
88
176
class cmd_cat_revision(Command):
89
"""Write out metadata for a revision."""
177
"""Write out metadata for a revision.
179
The revision to print can either be specified by a specific
180
revision identifier, or you can use --revision.
92
takes_args = ['revision_id']
94
def run(self, revision_id):
96
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
184
takes_args = ['revision_id?']
185
takes_options = ['revision']
186
# cat-revision is more for frontends so should be exact
190
def run(self, revision_id=None, revision=None):
192
if revision_id is not None and revision is not None:
193
raise BzrCommandError('You can only supply one of revision_id or --revision')
194
if revision_id is None and revision is None:
195
raise BzrCommandError('You must supply either --revision or a revision_id')
196
b = WorkingTree.open_containing(u'.')[0].branch
198
# TODO: jam 20060112 should cat-revision always output utf-8?
199
if revision_id is not None:
200
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
201
elif revision is not None:
204
raise BzrCommandError('You cannot specify a NULL revision.')
205
revno, rev_id = rev.in_history(b)
206
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
99
209
class cmd_revno(Command):
100
210
"""Show current revision number.
102
This is equal to the number of revisions on this branch."""
104
print find_branch('.').revno()
212
This is equal to the number of revisions on this branch.
215
takes_args = ['location?']
218
def run(self, location=u'.'):
219
self.outf.write(str(Branch.open_containing(location)[0].revno()))
220
self.outf.write('\n')
107
223
class cmd_revision_info(Command):
164
308
This is equivalent to creating the directory and then adding it.
166
311
takes_args = ['dir+']
312
encoding_type = 'replace'
168
314
def run(self, dir_list):
171
315
for d in dir_list:
317
wt, dd = WorkingTree.open_containing(d)
319
self.outf.write('added %s\n' % d)
179
322
class cmd_relpath(Command):
180
323
"""Show path of a file relative to root"""
181
325
takes_args = ['filename']
184
329
def run(self, filename):
185
print find_branch(filename).relpath(filename)
330
# TODO: jam 20050106 Can relpath return a munged path if
331
# sys.stdout encoding cannot represent it?
332
tree, relpath = WorkingTree.open_containing(filename)
333
self.outf.write(relpath)
334
self.outf.write('\n')
189
337
class cmd_inventory(Command):
190
"""Show inventory of the current working copy or a revision."""
191
takes_options = ['revision', 'show-ids']
338
"""Show inventory of the current working copy or a revision.
340
It is possible to limit the output to a particular entry
341
type using the --kind option. For example; --kind file.
344
takes_options = ['revision', 'show-ids', 'kind']
193
def run(self, revision=None, show_ids=False):
196
inv = b.read_working_inventory()
347
def run(self, revision=None, show_ids=False, kind=None):
348
if kind and kind not in ['file', 'directory', 'symlink']:
349
raise BzrCommandError('invalid kind specified')
350
tree = WorkingTree.open_containing(u'.')[0]
352
inv = tree.read_working_inventory()
198
354
if len(revision) > 1:
199
355
raise BzrCommandError('bzr inventory --revision takes'
200
356
' exactly one revision identifier')
201
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
357
inv = tree.branch.repository.get_revision_inventory(
358
revision[0].in_history(tree.branch).rev_id)
203
360
for path, entry in inv.entries():
361
if kind and kind != entry.kind:
205
print '%-50s %s' % (path, entry.file_id)
364
self.outf.write('%-50s %s\n' % (path, entry.file_id))
210
class cmd_move(Command):
211
"""Move files to a different directory.
216
The destination must be a versioned directory in the same branch.
218
takes_args = ['source$', 'dest']
219
def run(self, source_list, dest):
222
# TODO: glob expansion on windows?
223
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
226
class cmd_rename(Command):
227
"""Change the name of an entry.
230
bzr rename frob.c frobber.c
231
bzr rename src/frob.c lib/frob.c
233
It is an error if the destination name exists.
235
See also the 'move' command, which moves files into a different
236
directory without changing their name.
238
TODO: Some way to rename multiple files without invoking bzr for each
240
takes_args = ['from_name', 'to_name']
242
def run(self, from_name, to_name):
244
b.rename_one(b.relpath(from_name), b.relpath(to_name))
366
self.outf.write(path)
367
self.outf.write('\n')
248
370
class cmd_mv(Command):
259
381
Files cannot be moved between branches.
261
384
takes_args = ['names*']
385
aliases = ['move', 'rename']
386
encoding_type = 'replace'
262
388
def run(self, names_list):
389
if names_list is None:
263
392
if len(names_list) < 2:
264
393
raise BzrCommandError("missing file argument")
265
b = find_branch(names_list[0])
267
rel_names = [b.relpath(x) for x in names_list]
394
tree, rel_names = tree_files(names_list)
269
396
if os.path.isdir(names_list[-1]):
270
397
# move into existing directory
271
for pair in b.move(rel_names[:-1], rel_names[-1]):
272
print "%s => %s" % pair
398
for pair in tree.move(rel_names[:-1], rel_names[-1]):
399
self.outf.write("%s => %s\n" % pair)
274
401
if len(names_list) != 2:
275
402
raise BzrCommandError('to mv multiple files the destination '
276
403
'must be a versioned directory')
277
for pair in b.move(rel_names[0], rel_names[1]):
278
print "%s => %s" % pair
404
tree.rename_one(rel_names[0], rel_names[1])
405
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
283
408
class cmd_pull(Command):
284
"""Pull any changes from another branch into the current one.
286
If the location is omitted, the last-used location will be used.
287
Both the revision history and the working directory will be
409
"""Turn this branch into a mirror of another branch.
290
411
This command only works on branches that have not diverged. Branches are
291
considered diverged if both branches have had commits without first
292
pulling from the other.
294
If branches have diverged, you can use 'bzr merge' to pull the text changes
295
from one into the other.
412
considered diverged if the destination branch's most recent commit is one
413
that has not been merged (directly or indirectly) into the parent.
415
If branches have diverged, you can use 'bzr merge' to integrate the changes
416
from one into the other. Once one branch has merged, the other should
417
be able to pull it again.
419
If you want to forget your local changes and just update your branch to
420
match the remote one, use pull --overwrite.
422
If there is no default location set, the first pull will set it. After
423
that, you can omit the location to use the default. To change the
424
default, use --remember. The value will only be saved if the remote
425
location can be accessed.
428
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
297
429
takes_args = ['location?']
430
encoding_type = 'replace'
299
def run(self, location=None):
300
from bzrlib.merge import merge
302
from shutil import rmtree
304
from bzrlib.branch import pull_loc
306
br_to = find_branch('.')
432
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
433
# FIXME: too much stuff is in the command class
309
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
311
if e.errno != errno.ENOENT:
435
tree_to = WorkingTree.open_containing(u'.')[0]
436
branch_to = tree_to.branch
437
except NoWorkingTree:
439
branch_to = Branch.open_containing(u'.')[0]
442
if location is not None:
444
reader = bundle.read_bundle_from_url(location)
446
pass # Continue on considering this url a Branch
448
stored_loc = branch_to.get_parent()
313
449
if location is None:
314
450
if stored_loc is None:
315
451
raise BzrCommandError("No pull location known or specified.")
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()
453
display_url = urlutils.unescape_for_display(stored_loc,
455
self.outf.write("Using saved location: %s\n" % display_url)
456
location = stored_loc
459
if reader is not None:
460
install_bundle(branch_to.repository, reader)
461
branch_from = branch_to
463
branch_from = Branch.open(location)
465
if branch_to.get_parent() is None or remember:
466
branch_to.set_parent(branch_from.base)
470
if reader is not None:
471
rev_id = reader.target
472
elif len(revision) == 1:
473
rev_id = revision[0].in_history(branch_from).rev_id
475
raise BzrCommandError('bzr pull --revision takes one value.')
477
old_rh = branch_to.revision_history()
478
if tree_to is not None:
479
count = tree_to.pull(branch_from, overwrite, rev_id)
481
count = branch_to.pull(branch_from, overwrite, rev_id)
482
note('%d revision(s) pulled.' % (count,))
485
new_rh = branch_to.revision_history()
488
from bzrlib.log import show_changed_revisions
489
show_changed_revisions(branch_to, old_rh, new_rh,
493
class cmd_push(Command):
494
"""Update a mirror of this branch.
496
The target branch will not have its working tree populated because this
497
is both expensive, and is not supported on remote file systems.
499
Some smart servers or protocols *may* put the working tree in place in
502
This command only works on branches that have not diverged. Branches are
503
considered diverged if the destination branch's most recent commit is one
504
that has not been merged (directly or indirectly) by the source branch.
506
If branches have diverged, you can use 'bzr push --overwrite' to replace
507
the other branch completely, discarding its unmerged changes.
509
If you want to ensure you have the different changes in the other branch,
510
do a merge (see bzr help merge) from the other branch, and commit that.
511
After that you will be able to do a push without '--overwrite'.
513
If there is no default push location set, the first push will set it.
514
After that, you can omit the location to use the default. To change the
515
default, use --remember. The value will only be saved if the remote
516
location can be accessed.
519
takes_options = ['remember', 'overwrite', 'verbose',
520
Option('create-prefix',
521
help='Create the path leading up to the branch '
522
'if it does not already exist')]
523
takes_args = ['location?']
524
encoding_type = 'replace'
526
def run(self, location=None, remember=False, overwrite=False,
527
create_prefix=False, verbose=False):
528
# FIXME: Way too big! Put this into a function called from the
531
br_from = Branch.open_containing('.')[0]
532
stored_loc = br_from.get_push_location()
534
if stored_loc is None:
535
raise BzrCommandError("No push location known or specified.")
537
display_url = urlutils.unescape_for_display(stored_loc,
539
self.outf.write("Using saved location: %s\n" % display_url)
540
location = stored_loc
542
to_transport = transport.get_transport(location)
543
location_url = to_transport.base
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()
547
dir_to = bzrdir.BzrDir.open(location_url)
548
br_to = dir_to.open_branch()
549
except NotBranchError:
551
to_transport = to_transport.clone('..')
552
if not create_prefix:
554
relurl = to_transport.relpath(location_url)
555
mutter('creating directory %s => %s', location_url, relurl)
556
to_transport.mkdir(relurl)
558
raise BzrCommandError("Parent directory of %s "
559
"does not exist." % location)
561
current = to_transport.base
562
needed = [(to_transport, to_transport.relpath(location_url))]
565
to_transport, relpath = needed[-1]
566
to_transport.mkdir(relpath)
569
new_transport = to_transport.clone('..')
570
needed.append((new_transport,
571
new_transport.relpath(to_transport.base)))
572
if new_transport.base == to_transport.base:
573
raise BzrCommandError("Could not create "
575
dir_to = br_from.bzrdir.clone(location_url,
576
revision_id=br_from.last_revision())
577
br_to = dir_to.open_branch()
578
count = len(br_to.revision_history())
579
# We successfully created the target, remember it
580
if br_from.get_push_location() is None or remember:
581
br_from.set_push_location(br_to.base)
583
# We were able to connect to the remote location, so remember it
584
# we don't need to successfully push because of possible divergence.
585
if br_from.get_push_location() is None or remember:
586
br_from.set_push_location(br_to.base)
587
old_rh = br_to.revision_history()
330
br_to.update_revisions(br_from)
590
tree_to = dir_to.open_workingtree()
591
except errors.NotLocalUrl:
592
warning('This transport does not update the working '
593
'tree of: %s' % (br_to.base,))
594
count = br_to.pull(br_from, overwrite)
595
except NoWorkingTree:
596
count = br_to.pull(br_from, overwrite)
598
count = tree_to.pull(br_from, overwrite)
331
599
except DivergedBranches:
332
600
raise BzrCommandError("These branches have diverged."
335
merge(('.', -1), ('.', old_revno), check_clean=False)
336
if location != stored_loc:
337
br_to.controlfile("x-pull", "wb").write(location + "\n")
601
" Try a merge then push with overwrite.")
602
note('%d revision(s) pushed.' % (count,))
605
new_rh = br_to.revision_history()
608
from bzrlib.log import show_changed_revisions
609
show_changed_revisions(br_to, old_rh, new_rh,
343
613
class cmd_branch(Command):
349
619
To retrieve the branch as of a particular revision, supply the --revision
350
620
parameter, as in "branch foo/bar -r 5".
622
--basis is to speed up branching from remote branches. When specified, it
623
copies all the file-contents, inventory and revision data from the basis
624
branch before copying anything from the remote branch.
352
626
takes_args = ['from_location', 'to_location?']
353
takes_options = ['revision']
627
takes_options = ['revision', 'basis']
354
628
aliases = ['get', 'clone']
356
def run(self, from_location, to_location=None, revision=None):
357
from bzrlib.branch import copy_branch, find_cached_branch
360
from shutil import rmtree
361
cache_root = tempfile.mkdtemp()
365
elif len(revision) > 1:
366
raise BzrCommandError(
367
'bzr branch --revision takes exactly 1 revision value')
369
br_from = find_cached_branch(from_location, cache_root)
371
if e.errno == errno.ENOENT:
372
raise BzrCommandError('Source location "%s" does not'
373
' exist.' % to_location)
630
def run(self, from_location, to_location=None, revision=None, basis=None):
633
elif len(revision) > 1:
634
raise BzrCommandError(
635
'bzr branch --revision takes exactly 1 revision value')
637
br_from = Branch.open(from_location)
639
if e.errno == errno.ENOENT:
640
raise BzrCommandError('Source location "%s" does not'
641
' exist.' % to_location)
646
if basis is not None:
647
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
650
if len(revision) == 1 and revision[0] is not None:
651
revision_id = revision[0].in_history(br_from)[1]
653
# FIXME - wt.last_revision, fallback to branch, fall back to
654
# None or perhaps NULL_REVISION to mean copy nothing
656
revision_id = br_from.last_revision()
376
657
if to_location is None:
377
658
to_location = os.path.basename(from_location.rstrip("/\\"))
379
os.mkdir(to_location)
381
if e.errno == errno.EEXIST:
382
raise BzrCommandError('Target directory "%s" already'
383
' exists.' % to_location)
384
if e.errno == errno.ENOENT:
385
raise BzrCommandError('Parent of "%s" does not exist.' %
390
copy_branch(br_from, to_location, revision[0])
391
except bzrlib.errors.NoSuchRevision:
393
msg = "The branch %s has no revision %d." % (from_location, revision[0])
394
raise BzrCommandError(msg)
661
name = os.path.basename(to_location) + '\n'
663
to_transport = transport.get_transport(to_location)
665
to_transport.mkdir('.')
666
except errors.FileExists:
667
raise BzrCommandError('Target directory "%s" already'
668
' exists.' % to_location)
669
except errors.NoSuchFile:
670
raise BzrCommandError('Parent of "%s" does not exist.' %
673
# preserve whatever source format we have.
674
dir = br_from.bzrdir.sprout(to_transport.base,
675
revision_id, basis_dir)
676
branch = dir.open_branch()
677
except errors.NoSuchRevision:
678
to_transport.delete_tree('.')
679
msg = "The branch %s has no revision %s." % (from_location, revision[0])
680
raise BzrCommandError(msg)
681
except errors.UnlistableBranch:
682
osutils.rmtree(to_location)
683
msg = "The branch %s cannot be used as a --basis" % (basis,)
684
raise BzrCommandError(msg)
686
branch.control_files.put_utf8('branch-name', name)
687
note('Branched %d revision(s).' % branch.revno())
692
class cmd_checkout(Command):
693
"""Create a new checkout of an existing branch.
695
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
696
the branch found in '.'. This is useful if you have removed the working tree
697
or if it was never created - i.e. if you pushed the branch to its current
700
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
701
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
703
To retrieve the branch as of a particular revision, supply the --revision
704
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
705
out of date [so you cannot commit] but it may be useful (i.e. to examine old
708
--basis is to speed up checking out from remote branches. When specified, it
709
uses the inventory and file contents from the basis branch in preference to the
710
branch being checked out.
712
takes_args = ['branch_location?', 'to_location?']
713
takes_options = ['revision', # , 'basis']
714
Option('lightweight',
715
help="perform a lightweight checkout. Lightweight "
716
"checkouts depend on access to the branch for "
717
"every operation. Normal checkouts can perform "
718
"common operations like diff and status without "
719
"such access, and also support local commits."
724
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
728
elif len(revision) > 1:
729
raise BzrCommandError(
730
'bzr checkout --revision takes exactly 1 revision value')
731
if branch_location is None:
732
branch_location = osutils.getcwd()
733
to_location = branch_location
734
source = Branch.open(branch_location)
735
if len(revision) == 1 and revision[0] is not None:
736
revision_id = revision[0].in_history(source)[1]
739
if to_location is None:
740
to_location = os.path.basename(branch_location.rstrip("/\\"))
741
# if the source and to_location are the same,
742
# and there is no working tree,
743
# then reconstitute a branch
744
if (osutils.abspath(to_location) ==
745
osutils.abspath(branch_location)):
747
source.bzrdir.open_workingtree()
748
except errors.NoWorkingTree:
749
source.bzrdir.create_workingtree()
752
os.mkdir(to_location)
754
if e.errno == errno.EEXIST:
755
raise BzrCommandError('Target directory "%s" already'
756
' exists.' % to_location)
757
if e.errno == errno.ENOENT:
758
raise BzrCommandError('Parent of "%s" does not exist.' %
762
old_format = bzrdir.BzrDirFormat.get_default_format()
763
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
766
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
767
branch.BranchReferenceFormat().initialize(checkout, source)
769
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
770
to_location, force_new_tree=False)
771
checkout = checkout_branch.bzrdir
772
checkout_branch.bind(source)
773
if revision_id is not None:
774
rh = checkout_branch.revision_history()
775
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
776
checkout.create_workingtree(revision_id)
778
bzrdir.BzrDirFormat.set_default_format(old_format)
399
781
class cmd_renames(Command):
400
782
"""Show list of renamed files.
402
TODO: Option to show renames between two historical versions.
404
TODO: Only show renames under dir, rather than in the whole branch.
784
# TODO: Option to show renames between two historical versions.
786
# TODO: Only show renames under dir, rather than in the whole branch.
406
787
takes_args = ['dir?']
408
def run(self, dir='.'):
410
old_inv = b.basis_tree().inventory
411
new_inv = b.read_working_inventory()
413
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
790
def run(self, dir=u'.'):
791
from bzrlib.tree import find_renames
792
tree = WorkingTree.open_containing(dir)[0]
793
old_inv = tree.basis_tree().inventory
794
new_inv = tree.read_working_inventory()
795
renames = list(find_renames(old_inv, new_inv))
415
797
for old_name, new_name in renames:
416
print "%s => %s" % (old_name, new_name)
798
self.outf.write("%s => %s\n" % (old_name, new_name))
801
class cmd_update(Command):
802
"""Update a tree to have the latest code committed to its branch.
804
This will perform a merge into the working tree, and may generate
805
conflicts. If you have any local changes, you will still
806
need to commit them after the update for the update to be complete.
808
If you want to discard your local changes, you can just do a
809
'bzr revert' instead of 'bzr commit' after the update.
811
takes_args = ['dir?']
814
def run(self, dir='.'):
815
tree = WorkingTree.open_containing(dir)[0]
817
existing_pending_merges = tree.pending_merges()
819
last_rev = tree.last_revision()
820
if last_rev == tree.branch.last_revision():
821
# may be up to date, check master too.
822
master = tree.branch.get_master_branch()
823
if master is None or last_rev == master.last_revision():
824
revno = tree.branch.revision_id_to_revno(last_rev)
825
note("Tree is up to date at revision %d." % (revno,))
827
conflicts = tree.update()
828
revno = tree.branch.revision_id_to_revno(tree.last_revision())
829
note('Updated to revision %d.' % (revno,))
830
if tree.pending_merges() != existing_pending_merges:
831
note('Your local commits will now show as pending merges with '
832
"'bzr status', and can be committed with 'bzr commit'.")
419
841
class cmd_info(Command):
420
"""Show statistical information about a branch."""
421
takes_args = ['branch?']
423
def run(self, branch=None):
426
b = find_branch(branch)
842
"""Show information about a working tree, branch or repository.
844
This command will show all known locations and formats associated to the
845
tree, branch or repository. Statistical information is included with
848
Branches and working trees will also report any missing revisions.
850
takes_args = ['location?']
851
takes_options = ['verbose']
854
def run(self, location=None, verbose=False):
855
from bzrlib.info import show_bzrdir_info
856
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
430
860
class cmd_remove(Command):
448
895
same through all revisions where the file exists, even when it is
449
896
moved or renamed.
452
900
takes_args = ['filename']
453
903
def run(self, filename):
454
b = find_branch(filename)
455
i = b.inventory.path2id(b.relpath(filename))
904
tree, relpath = WorkingTree.open_containing(filename)
905
i = tree.inventory.path2id(relpath)
457
907
raise BzrError("%r is not a versioned file" % filename)
909
self.outf.write(i + '\n')
462
912
class cmd_file_path(Command):
463
913
"""Print path of file_ids to a file or directory.
465
915
This prints one line for each directory down to the target,
466
starting at the branch root."""
916
starting at the branch root.
468
920
takes_args = ['filename']
469
923
def run(self, filename):
470
b = find_branch(filename)
472
fid = inv.path2id(b.relpath(filename))
924
tree, relpath = WorkingTree.open_containing(filename)
926
fid = inv.path2id(relpath)
474
928
raise BzrError("%r is not a versioned file" % filename)
475
929
for fip in inv.get_idpath(fid):
930
self.outf.write(fip + '\n')
933
class cmd_reconcile(Command):
934
"""Reconcile bzr metadata in a branch.
936
This can correct data mismatches that may have been caused by
937
previous ghost operations or bzr upgrades. You should only
938
need to run this command if 'bzr check' or a bzr developer
939
advises you to run it.
941
If a second branch is provided, cross-branch reconciliation is
942
also attempted, which will check that data like the tree root
943
id which was not present in very early bzr versions is represented
944
correctly in both branches.
946
At the same time it is run it may recompress data resulting in
947
a potential saving in disk space or performance gain.
949
The branch *MUST* be on a listable system such as local disk or sftp.
951
takes_args = ['branch?']
953
def run(self, branch="."):
954
from bzrlib.reconcile import reconcile
955
dir = bzrdir.BzrDir.open(branch)
479
959
class cmd_revision_history(Command):
480
"""Display list of revision ids on this branch."""
960
"""Display the list of revision ids on a branch."""
961
takes_args = ['location?']
483
for patchid in find_branch('.').revision_history():
966
def run(self, location="."):
967
branch = Branch.open_containing(location)[0]
968
for revid in branch.revision_history():
969
self.outf.write(revid)
970
self.outf.write('\n')
487
973
class cmd_ancestry(Command):
488
974
"""List all revisions merged into this branch."""
975
takes_args = ['location?']
492
for revision_id in b.get_ancestry(b.last_patch()):
496
class cmd_directories(Command):
497
"""Display list of versioned directories in this branch."""
499
for name, ie in find_branch('.').read_working_inventory().directories():
980
def run(self, location="."):
982
wt = WorkingTree.open_containing(location)[0]
983
except errors.NoWorkingTree:
984
b = Branch.open(location)
985
last_revision = b.last_revision()
988
last_revision = wt.last_revision()
990
revision_ids = b.repository.get_ancestry(last_revision)
991
assert revision_ids[0] == None
993
for revision_id in revision_ids:
994
self.outf.write(revision_id + '\n')
506
997
class cmd_init(Command):
509
1000
Use this to create an empty branch, or before importing an
510
1001
existing project.
1003
If there is a repository in a parent directory of the location, then
1004
the history of the branch will be stored in the repository. Otherwise
1005
init creates a standalone branch which carries its own history in
1008
If there is already a branch at the location but it has no working tree,
1009
the tree can be populated with 'bzr checkout'.
512
1011
Recipe for importing a tree of files:
517
1016
bzr commit -m 'imported project'
520
from bzrlib.branch import Branch
521
Branch('.', init=True)
1018
takes_args = ['location?']
1021
help='Specify a format for this branch. Current'
1022
' formats are: default, knit, metaweave and'
1023
' weave. Default is knit; metaweave and'
1024
' weave are deprecated',
1025
type=get_format_type),
1027
def run(self, location=None, format=None):
1029
format = get_format_type('default')
1030
if location is None:
1033
to_transport = transport.get_transport(location)
1035
# The path has to exist to initialize a
1036
# branch inside of it.
1037
# Just using os.mkdir, since I don't
1038
# believe that we want to create a bunch of
1039
# locations if the user supplies an extended path
1040
# TODO: create-prefix
1042
to_transport.mkdir('.')
1043
except errors.FileExists:
1047
existing_bzrdir = bzrdir.BzrDir.open(location)
1048
except NotBranchError:
1049
# really a NotBzrDir error...
1050
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1052
if existing_bzrdir.has_branch():
1053
if (isinstance(to_transport, LocalTransport)
1054
and not existing_bzrdir.has_workingtree()):
1055
raise errors.BranchExistsWithoutWorkingTree(location)
1056
raise errors.AlreadyBranchError(location)
1058
existing_bzrdir.create_branch()
1059
existing_bzrdir.create_workingtree()
1062
class cmd_init_repository(Command):
1063
"""Create a shared repository to hold branches.
1065
New branches created under the repository directory will store their revisions
1066
in the repository, not in the branch directory, if the branch format supports
1072
bzr checkout --lightweight repo/trunk trunk-checkout
1076
takes_args = ["location"]
1077
takes_options = [Option('format',
1078
help='Specify a format for this repository.'
1079
' Current formats are: default, knit,'
1080
' metaweave and weave. Default is knit;'
1081
' metaweave and weave are deprecated',
1082
type=get_format_type),
1084
help='Allows branches in repository to have'
1086
aliases = ["init-repo"]
1087
def run(self, location, format=None, trees=False):
1089
format = get_format_type('default')
1091
if location is None:
1094
to_transport = transport.get_transport(location)
1096
to_transport.mkdir('.')
1097
except errors.FileExists:
1100
newdir = format.initialize_on_transport(to_transport)
1101
repo = newdir.create_repository(shared=True)
1102
repo.set_make_working_trees(trees)
524
1105
class cmd_diff(Command):
525
"""Show differences in working tree.
1106
"""Show differences in the working tree or between revisions.
527
1108
If files are listed, only the changes in those files are listed.
528
1109
Otherwise, all changes for the tree are listed.
530
TODO: Allow diff across branches.
532
TODO: Option to use external diff command; could be GNU diff, wdiff,
535
TODO: Python difflib is not exactly the same as unidiff; should
536
either fix it up or prefer to use an external diff.
538
TODO: If a directory is given, diff everything under that.
540
TODO: Selected-file diff is inefficient and doesn't show you
543
TODO: This probably handles non-Unix newlines poorly.
1111
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1112
produces patches suitable for "patch -p1".
1116
Shows the difference in the working tree versus the last commit
1118
Difference between the working tree and revision 1
1120
Difference between revision 2 and revision 1
1121
bzr diff --diff-prefix old/:new/
1122
Same as 'bzr diff' but prefix paths with old/ and new/
1123
bzr diff bzr.mine bzr.dev
1124
Show the differences between the two working trees
1126
Show just the differences for 'foo.c'
1128
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1129
# or a graphical diff.
1131
# TODO: Python difflib is not exactly the same as unidiff; should
1132
# either fix it up or prefer to use an external diff.
1134
# TODO: Selected-file diff is inefficient and doesn't show you
1137
# TODO: This probably handles non-Unix newlines poorly.
551
1139
takes_args = ['file*']
552
takes_options = ['revision', 'diff-options']
1140
takes_options = ['revision', 'diff-options', 'prefix']
553
1141
aliases = ['di', 'dif']
555
def run(self, revision=None, file_list=None, diff_options=None):
556
from bzrlib.diff import show_diff
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
1142
encoding_type = 'exact'
1145
def run(self, revision=None, file_list=None, diff_options=None,
1147
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1149
if (prefix is None) or (prefix == '0'):
1157
if not ':' in prefix:
1158
raise BzrError("--diff-prefix expects two values separated by a colon")
1159
old_label, new_label = prefix.split(":")
1162
tree1, file_list = internal_tree_files(file_list)
1166
except FileInWrongBranch:
1167
if len(file_list) != 2:
1168
raise BzrCommandError("Files are in different branches")
1170
tree1, file1 = WorkingTree.open_containing(file_list[0])
1171
tree2, file2 = WorkingTree.open_containing(file_list[1])
1172
if file1 != "" or file2 != "":
1173
# FIXME diff those two files. rbc 20051123
1174
raise BzrCommandError("Files are in different branches")
1176
except NotBranchError:
1177
if (revision is not None and len(revision) == 2
1178
and not revision[0].needs_branch()
1179
and not revision[1].needs_branch()):
1180
# If both revision specs include a branch, we can
1181
# diff them without needing a local working tree
1182
tree1, tree2 = None, None
567
1185
if revision is not None:
568
if len(revision) == 1:
569
show_diff(b, revision[0], specific_files=file_list,
570
external_diff_options=diff_options)
1186
if tree2 is not None:
1187
raise BzrCommandError("Can't specify -r with two branches")
1188
if (len(revision) == 1) or (revision[1].spec is None):
1189
return diff_cmd_helper(tree1, file_list, diff_options,
1191
old_label=old_label, new_label=new_label)
571
1192
elif len(revision) == 2:
572
show_diff(b, revision[0], specific_files=file_list,
573
external_diff_options=diff_options,
574
revision2=revision[1])
1193
return diff_cmd_helper(tree1, file_list, diff_options,
1194
revision[0], revision[1],
1195
old_label=old_label, new_label=new_label)
576
1197
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
578
show_diff(b, None, specific_files=file_list,
579
external_diff_options=diff_options)
1199
if tree2 is not None:
1200
return show_diff_trees(tree1, tree2, sys.stdout,
1201
specific_files=file_list,
1202
external_diff_options=diff_options,
1203
old_label=old_label, new_label=new_label)
1205
return diff_cmd_helper(tree1, file_list, diff_options,
1206
old_label=old_label, new_label=new_label)
584
1209
class cmd_deleted(Command):
585
1210
"""List files deleted in the working tree.
1212
# TODO: Show files deleted since a previous revision, or
1213
# between two revisions.
1214
# TODO: Much more efficient way to do this: read in new
1215
# directories with readdir, rather than stating each one. Same
1216
# level of effort but possibly much less IO. (Or possibly not,
1217
# if the directories are very large...)
1218
takes_options = ['show-ids']
587
TODO: Show files deleted since a previous revision, or between two revisions.
589
1221
def run(self, show_ids=False):
592
new = b.working_tree()
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...)
1222
tree = WorkingTree.open_containing(u'.')[0]
1223
old = tree.basis_tree()
599
1224
for path, ie in old.inventory.iter_entries():
600
if not new.has_id(ie.file_id):
1225
if not tree.has_id(ie.file_id):
1226
self.outf.write(path)
602
print '%-50s %s' % (path, ie.file_id)
1228
self.outf.write(' ')
1229
self.outf.write(ie.file_id)
1230
self.outf.write('\n')
607
1233
class cmd_modified(Command):
608
1234
"""List files modified in working tree."""
611
from bzrlib.delta import compare_trees
614
td = compare_trees(b.basis_tree(), b.working_tree())
616
for path, id, kind in td.modified:
1238
tree = WorkingTree.open_containing(u'.')[0]
1239
td = tree.changes_from(tree.basis_tree())
1240
for path, id, kind, text_modified, meta_modified in td.modified:
1241
self.outf.write(path + '\n')
621
1244
class cmd_added(Command):
622
1245
"""List files added in working tree."""
626
wt = b.working_tree()
627
basis_inv = b.basis_tree().inventory
1249
wt = WorkingTree.open_containing(u'.')[0]
1250
basis_inv = wt.basis_tree().inventory
628
1251
inv = wt.inventory
629
1252
for file_id in inv:
630
1253
if file_id in basis_inv:
632
1255
path = inv.id2path(file_id)
633
if not os.access(b.abspath(path), os.F_OK):
1256
if not os.access(osutils.abspath(path), os.F_OK):
1258
self.outf.write(path + '\n')
639
1261
class cmd_root(Command):
640
1262
"""Show the tree root directory.
642
1264
The root is the nearest enclosing directory with a .bzr control
644
1266
takes_args = ['filename?']
645
1268
def run(self, filename=None):
646
1269
"""Print the branch root."""
647
b = find_branch(filename)
648
print getattr(b, 'base', None) or getattr(b, 'baseurl')
1270
tree = WorkingTree.open_containing(filename)[0]
1271
self.outf.write(tree.basedir + '\n')
651
1274
class cmd_log(Command):
652
"""Show log of this branch.
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
1275
"""Show log of a branch, file, or directory.
1277
By default show the log of the branch containing the working directory.
1279
To request a range of logs, you can use the command -r begin..end
1280
-r revision requests a specific revision, -r ..end or -r begin.. are
658
--message allows you to give a regular expression, which will be evaluated
659
so that only matching entries will be displayed.
661
TODO: Make --revision support uuid: and hash: [future tag:] notation.
1286
bzr log -r -10.. http://server/branch
665
takes_args = ['filename?']
666
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
667
'long', 'message', 'short',]
669
def run(self, filename=None, timezone='original',
1289
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1291
takes_args = ['location?']
1292
takes_options = [Option('forward',
1293
help='show from oldest to newest'),
1296
help='show files changed in each revision'),
1297
'show-ids', 'revision',
1301
help='show revisions whose message matches this regexp',
1305
encoding_type = 'replace'
1308
def run(self, location=None, timezone='original',
677
1318
from bzrlib.log import log_formatter, show_log
1319
assert message is None or isinstance(message, basestring), \
1320
"invalid message argument %r" % message
680
1321
direction = (forward and 'forward') or 'reverse'
683
b = find_branch(filename)
684
fp = b.relpath(filename)
686
file_id = b.read_working_inventory().path2id(fp)
688
file_id = None # points to branch root
1326
# find the file id to log:
1328
dir, fp = bzrdir.BzrDir.open_containing(location)
1329
b = dir.open_branch()
1333
inv = dir.open_workingtree().inventory
1334
except (errors.NotBranchError, errors.NotLocalUrl):
1335
# either no tree, or is remote.
1336
inv = b.basis_tree().inventory
1337
file_id = inv.path2id(fp)
1340
# FIXME ? log the current subdir only RBC 20060203
1341
dir, relpath = bzrdir.BzrDir.open_containing('.')
1342
b = dir.open_branch()
693
1344
if revision is None:
696
1347
elif len(revision) == 1:
697
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1348
rev1 = rev2 = revision[0].in_history(b).revno
698
1349
elif len(revision) == 2:
699
rev1 = b.get_revision_info(revision[0])[0]
700
rev2 = b.get_revision_info(revision[1])[0]
1350
if revision[0].spec is None:
1351
# missing begin-range means first revision
1354
rev1 = revision[0].in_history(b).revno
1356
if revision[1].spec is None:
1357
# missing end-range means last known revision
1360
rev2 = revision[1].in_history(b).revno
702
1362
raise BzrCommandError('bzr log --revision takes one or two values.')
709
mutter('encoding log as %r' % bzrlib.user_encoding)
711
# use 'replace' so that we don't abort if trying to write out
712
# in e.g. the default C locale.
713
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1364
# By this point, the revision numbers are converted to the +ve
1365
# form if they were supplied in the -ve form, so we can do
1366
# this comparison in relative safety
1368
(rev2, rev1) = (rev1, rev2)
1370
if (log_format == None):
1371
default = b.get_config().log_format()
1372
log_format = get_log_format(long=long, short=short, line=line,
719
1374
lf = log_formatter(log_format,
720
1375
show_ids=show_ids,
722
1377
show_timezone=timezone)
1389
def get_log_format(long=False, short=False, line=False, default='long'):
1390
log_format = default
1394
log_format = 'short'
735
1400
class cmd_touching_revisions(Command):
736
1401
"""Return revision-ids which affected a particular file.
738
A more user-friendly interface is "bzr log FILE"."""
1403
A more user-friendly interface is "bzr log FILE".
740
1407
takes_args = ["filename"]
741
1410
def run(self, filename):
742
b = find_branch(filename)
743
inv = b.read_working_inventory()
744
file_id = inv.path2id(b.relpath(filename))
745
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
746
print "%6d %s" % (revno, what)
1411
tree, relpath = WorkingTree.open_containing(filename)
1413
inv = tree.read_working_inventory()
1414
file_id = inv.path2id(relpath)
1415
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1416
self.outf.write("%6d %s\n" % (revno, what))
749
1419
class cmd_ls(Command):
750
1420
"""List files in a tree.
752
TODO: Take a revision or remote path and list that tree instead.
1422
# TODO: Take a revision or remote path and list that tree instead.
755
def run(self, revision=None, verbose=False):
758
tree = b.working_tree()
760
tree = b.revision_tree(b.lookup_revision(revision))
762
for fp, fc, kind, fid in tree.list_files():
764
if kind == 'directory':
1424
takes_options = ['verbose', 'revision',
1425
Option('non-recursive',
1426
help='don\'t recurse into sub-directories'),
1428
help='Print all paths from the root of the branch.'),
1429
Option('unknown', help='Print unknown files'),
1430
Option('versioned', help='Print versioned files'),
1431
Option('ignored', help='Print ignored files'),
1433
Option('null', help='Null separate the files'),
1436
def run(self, revision=None, verbose=False,
1437
non_recursive=False, from_root=False,
1438
unknown=False, versioned=False, ignored=False,
1441
if verbose and null:
1442
raise BzrCommandError('Cannot set both --verbose and --null')
1443
all = not (unknown or versioned or ignored)
1445
selection = {'I':ignored, '?':unknown, 'V':versioned}
1447
tree, relpath = WorkingTree.open_containing(u'.')
1452
if revision is not None:
1453
tree = tree.branch.repository.revision_tree(
1454
revision[0].in_history(tree.branch).rev_id)
1456
for fp, fc, kind, fid, entry in tree.list_files():
1457
if fp.startswith(relpath):
1458
fp = fp[len(relpath):]
1459
if non_recursive and '/' in fp:
1461
if not all and not selection[fc]:
1464
kindch = entry.kind_character()
1465
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1467
self.outf.write(fp + '\0')
771
print '%-8s %s%s' % (fc, fp, kindch)
1470
self.outf.write(fp + '\n')
777
1473
class cmd_unknowns(Command):
778
1474
"""List unknown files."""
780
from bzrlib.osutils import quotefn
781
for f in find_branch('.').unknowns():
1477
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1478
self.outf.write(osutils.quotefn(f) + '\n')
786
1481
class cmd_ignore(Command):
945
1668
A selected-file commit may fail in some cases where the committed
946
1669
tree would be invalid, such as trying to commit a file in a
947
1670
newly-added directory that is not itself committed.
949
TODO: Run hooks on tree to-be-committed, and after commit.
951
TODO: Strict commit that fails if there are unknown or deleted files.
1672
# TODO: Run hooks on tree to-be-committed, and after commit.
1674
# TODO: Strict commit that fails if there are deleted files.
1675
# (what does "deleted files" mean ??)
1677
# TODO: Give better message for -s, --summary, used by tla people
1679
# XXX: verbose currently does nothing
953
1681
takes_args = ['selected*']
954
takes_options = ['message', 'file', 'verbose', 'unchanged']
1682
takes_options = ['message', 'verbose',
1684
help='commit even if nothing has changed'),
1685
Option('file', type=str,
1687
help='file containing commit message'),
1689
help="refuse to commit if there are unknown "
1690
"files in the working tree."),
1692
help="perform a local only commit in a bound "
1693
"branch. Such commits are not pushed to "
1694
"the master branch until a normal commit "
955
1698
aliases = ['ci', 'checkin']
957
# TODO: Give better message for -s, --summary, used by tla people
959
# XXX: verbose currently does nothing
961
1700
def run(self, message=None, file=None, verbose=True, selected_list=None,
963
from bzrlib.errors import PointlessCommit
964
from bzrlib.msgeditor import edit_commit_message
965
from bzrlib.status import show_status
966
from cStringIO import StringIO
970
selected_list = [b.relpath(s) for s in selected_list]
972
if not message and not file:
974
show_status(b, specific_files=selected_list,
976
message = edit_commit_message(catcher.getvalue())
1701
unchanged=False, strict=False, local=False):
1702
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1703
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1705
from bzrlib.msgeditor import edit_commit_message, \
1706
make_commit_message_template
1707
from tempfile import TemporaryFile
1709
# TODO: Need a blackbox test for invoking the external editor; may be
1710
# slightly problematic to run this cross-platform.
1712
# TODO: do more checks that the commit will succeed before
1713
# spending the user's valuable time typing a commit message.
1715
# TODO: if the commit *does* happen to fail, then save the commit
1716
# message to a temporary file where it can be recovered
1717
tree, selected_list = tree_files(selected_list)
1718
if selected_list == ['']:
1719
# workaround - commit of root of tree should be exactly the same
1720
# as just default commit in that tree, and succeed even though
1721
# selected-file merge commit is not done yet
1724
if local and not tree.branch.get_bound_location():
1725
raise errors.LocalRequiresBoundBranch()
1726
if message is None and not file:
1727
template = make_commit_message_template(tree, selected_list)
1728
message = edit_commit_message(template)
978
1729
if message is None:
979
1730
raise BzrCommandError("please specify a commit message"
980
1731
" with either --message or --file")
982
1733
raise BzrCommandError("please specify either --message or --file")
986
1736
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1739
raise BzrCommandError("empty commit message specified")
1742
reporter = ReportCommitToLog()
1744
reporter = NullCommitReporter()
990
specific_files=selected_list,
991
allow_pointless=unchanged)
1747
tree.commit(message, specific_files=selected_list,
1748
allow_pointless=unchanged, strict=strict, local=local,
992
1750
except PointlessCommit:
993
1751
# FIXME: This should really happen before the file is read in;
994
1752
# perhaps prepare the commit; get the message; then actually commit
995
raise BzrCommandError("no changes to commit",
996
["use --unchanged to commit anyhow"])
1753
raise BzrCommandError("no changes to commit."
1754
" use --unchanged to commit anyhow")
1755
except ConflictsInTree:
1756
raise BzrCommandError("Conflicts detected in working tree. "
1757
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1758
except StrictCommitFailed:
1759
raise BzrCommandError("Commit refused because there are unknown "
1760
"files in the working tree.")
1761
except errors.BoundBranchOutOfDate, e:
1762
raise BzrCommandError(str(e) + "\n"
1763
'To commit to master branch, run update and then commit.\n'
1764
'You can also pass --local to commit to continue working '
999
1767
class cmd_check(Command):
1000
1768
"""Validate consistency of branch history.
1002
1770
This command checks various invariants about the branch storage to
1003
1771
detect data corruption or bzr bugs.
1005
If given the --update flag, it will update some optional fields
1006
to help ensure data consistency.
1008
takes_args = ['dir?']
1773
takes_args = ['branch?']
1774
takes_options = ['verbose']
1010
def run(self, dir='.'):
1776
def run(self, branch=None, verbose=False):
1011
1777
from bzrlib.check import check
1013
check(find_branch(dir))
1779
tree = WorkingTree.open_containing()[0]
1780
branch = tree.branch
1782
branch = Branch.open(branch)
1783
check(branch, verbose)
1016
1786
class cmd_scan_cache(Command):
1031
1801
if c.needs_write:
1036
1805
class cmd_upgrade(Command):
1037
1806
"""Upgrade branch storage to current format.
1039
1808
The check command or bzr developers may sometimes advise you to run
1809
this command. When the default format has changed you may also be warned
1810
during other operations to upgrade.
1042
takes_args = ['dir?']
1044
def run(self, dir='.'):
1812
takes_args = ['url?']
1815
help='Upgrade to a specific format. Current formats'
1816
' are: default, knit, metaweave and weave.'
1817
' Default is knit; metaweave and weave are'
1819
type=get_format_type),
1823
def run(self, url='.', format=None):
1045
1824
from bzrlib.upgrade import upgrade
1046
upgrade(find_branch(dir))
1826
format = get_format_type('default')
1827
upgrade(url, format)
1050
1830
class cmd_whoami(Command):
1051
"""Show bzr user id."""
1052
takes_options = ['email']
1054
def run(self, email=False):
1831
"""Show or set bzr user id.
1835
bzr whoami 'Frank Chu <fchu@example.com>'
1837
takes_options = [ Option('email',
1838
help='display email address only'),
1840
help='set identity for the current branch instead of '
1843
takes_args = ['name?']
1844
encoding_type = 'replace'
1847
def run(self, email=False, branch=False, name=None):
1849
# use branch if we're inside one; otherwise global config
1851
c = Branch.open_containing('.')[0].get_config()
1852
except NotBranchError:
1853
c = config.GlobalConfig()
1855
self.outf.write(c.user_email() + '\n')
1857
self.outf.write(c.username() + '\n')
1860
# display a warning if an email address isn't included in the given name.
1056
b = bzrlib.branch.find_branch('.')
1862
config.extract_email_address(name)
1864
warning('"%s" does not seem to contain an email address. '
1865
'This is allowed, but not recommended.', name)
1061
print bzrlib.osutils.user_email(b)
1063
print bzrlib.osutils.username(b)
1867
# use global config unless --branch given
1869
c = Branch.open_containing('.')[0].get_config()
1871
c = config.GlobalConfig()
1872
c.set_user_option('email', name)
1875
class cmd_nick(Command):
1876
"""Print or set the branch nickname.
1878
If unset, the tree root directory name is used as the nickname
1879
To print the current nickname, execute with no argument.
1881
takes_args = ['nickname?']
1882
def run(self, nickname=None):
1883
branch = Branch.open_containing(u'.')[0]
1884
if nickname is None:
1885
self.printme(branch)
1887
branch.nick = nickname
1890
def printme(self, branch):
1066
1894
class cmd_selftest(Command):
1067
"""Run internal test suite"""
1895
"""Run internal test suite.
1897
This creates temporary test directories in the working directory,
1898
but not existing data is affected. These directories are deleted
1899
if the tests pass, or left behind to help in debugging if they
1900
fail and --keep-output is specified.
1902
If arguments are given, they are regular expressions that say
1903
which tests should run.
1905
If the global option '--no-plugins' is given, plugins are not loaded
1906
before running the selftests. This has two effects: features provided or
1907
modified by plugins will not be tested, and tests provided by plugins will
1912
bzr --no-plugins selftest -v
1914
# TODO: --list should give a list of all available tests
1916
# NB: this is used from the class without creating an instance, which is
1917
# why it does not have a self parameter.
1918
def get_transport_type(typestring):
1919
"""Parse and return a transport specifier."""
1920
if typestring == "sftp":
1921
from bzrlib.transport.sftp import SFTPAbsoluteServer
1922
return SFTPAbsoluteServer
1923
if typestring == "memory":
1924
from bzrlib.transport.memory import MemoryServer
1926
if typestring == "fakenfs":
1927
from bzrlib.transport.fakenfs import FakeNFSServer
1928
return FakeNFSServer
1929
msg = "No known transport type %s. Supported types are: sftp\n" %\
1931
raise BzrCommandError(msg)
1069
takes_options = ['verbose', 'pattern']
1070
def run(self, verbose=False, pattern=".*"):
1934
takes_args = ['testspecs*']
1935
takes_options = ['verbose',
1936
Option('one', help='stop when one test fails'),
1937
Option('keep-output',
1938
help='keep output directories when tests fail'),
1940
help='Use a different transport by default '
1941
'throughout the test suite.',
1942
type=get_transport_type),
1943
Option('benchmark', help='run the bzr bencharks.'),
1944
Option('lsprof-timed',
1945
help='generate lsprof output for benchmarked'
1946
' sections of code.'),
1949
def run(self, testspecs_list=None, verbose=None, one=False,
1950
keep_output=False, transport=None, benchmark=None,
1071
1952
import bzrlib.ui
1072
from bzrlib.selftest import selftest
1953
from bzrlib.tests import selftest
1954
import bzrlib.benchmarks as benchmarks
1073
1955
# we don't want progress meters from the tests to go to the
1074
1956
# real output; and we don't want log messages cluttering up
1075
1957
# the real logs.
1076
save_ui = bzrlib.ui.ui_factory
1077
bzrlib.trace.info('running tests...')
1958
save_ui = ui.ui_factory
1959
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1960
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1962
info('running tests...')
1079
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1080
result = selftest(verbose=verbose, pattern=pattern)
1964
ui.ui_factory = ui.SilentUIFactory()
1965
if testspecs_list is not None:
1966
pattern = '|'.join(testspecs_list)
1970
test_suite_factory = benchmarks.test_suite
1974
test_suite_factory = None
1977
result = selftest(verbose=verbose,
1979
stop_on_failure=one,
1980
keep_output=keep_output,
1981
transport=transport,
1982
test_suite_factory=test_suite_factory,
1983
lsprof_timed=lsprof_timed)
1082
bzrlib.trace.info('tests passed')
1985
info('tests passed')
1084
bzrlib.trace.info('tests failed')
1987
info('tests failed')
1085
1988
return int(not result)
1087
bzrlib.ui.ui_factory = save_ui
1990
ui.ui_factory = save_ui
1993
def _get_bzr_branch():
1994
"""If bzr is run from a branch, return Branch or None"""
1995
from os.path import dirname
1998
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
2000
except errors.BzrError:
1090
2004
def show_version():
1091
print "bzr (bazaar-ng) %s" % bzrlib.__version__
2006
print "Bazaar (bzr) %s" % bzrlib.__version__
1092
2007
# is bzrlib itself in a branch?
1093
bzrrev = bzrlib.get_bzr_revision()
1095
print " (bzr checkout, revision %d {%s})" % bzrrev
2008
branch = _get_bzr_branch()
2010
rh = branch.revision_history()
2012
print " bzr checkout, revision %d" % (revno,)
2013
print " nick: %s" % (branch.nick,)
2015
print " revid: %s" % (rh[-1],)
2016
print "Using python interpreter:", sys.executable
2018
print "Using python standard library:", os.path.dirname(site.__file__)
2019
print "Using bzrlib:",
2020
if len(bzrlib.__path__) > 1:
2021
# print repr, which is a good enough way of making it clear it's
2022
# more than one element (eg ['/foo/bar', '/foo/bzr'])
2023
print repr(bzrlib.__path__)
2025
print bzrlib.__path__[0]
1096
2028
print bzrlib.__copyright__
1097
print "http://bazaar-ng.org/"
2029
print "http://bazaar-vcs.org/"
1099
2031
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1100
2032
print "you may use, modify and redistribute it under the terms of the GNU"
1104
2036
class cmd_version(Command):
1105
2037
"""Show version of bzr."""
1109
2044
class cmd_rocks(Command):
1110
2045
"""Statement of optimism."""
1113
2051
print "it sure does!"
1116
2054
class cmd_find_merge_base(Command):
1117
"""Find and print a base revision for merging two branches.
1119
TODO: Options to specify revisions on either side, as if
1120
merging only part of the history.
2055
"""Find and print a base revision for merging two branches."""
2056
# TODO: Options to specify revisions on either side, as if
2057
# merging only part of the history.
1122
2058
takes_args = ['branch', 'other']
1125
2062
def run(self, branch, other):
1126
2063
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1128
branch1 = find_branch(branch)
1129
branch2 = find_branch(other)
2065
branch1 = Branch.open_containing(branch)[0]
2066
branch2 = Branch.open_containing(other)[0]
1131
2068
history_1 = branch1.revision_history()
1132
2069
history_2 = branch2.revision_history()
1134
last1 = branch1.last_patch()
1135
last2 = branch2.last_patch()
2071
last1 = branch1.last_revision()
2072
last2 = branch2.last_revision()
1137
source = MultipleRevisionSources(branch1, branch2)
2074
source = MultipleRevisionSources(branch1.repository,
1139
2077
base_rev_id = common_ancestor(last1, last2, source)
1141
2079
print 'merge base is revision %s' % base_rev_id
1145
if base_revno is None:
1146
raise bzrlib.errors.UnrelatedBranches()
1148
print ' r%-6d in %s' % (base_revno, branch)
1150
other_revno = branch2.revision_id_to_revno(base_revid)
1152
print ' r%-6d in %s' % (other_revno, other)
1156
2082
class cmd_merge(Command):
1157
2083
"""Perform a three-way merge.
1159
The branch is the branch you will merge from. By default, it will
1160
merge the latest revision. If you specify a revision, that
1161
revision will be merged. If you specify two revisions, the first
1162
will be used as a BASE, and the second one as OTHER. Revision
1163
numbers are always relative to the specified branch.
2085
The branch is the branch you will merge from. By default, it will merge
2086
the latest revision. If you specify a revision, that revision will be
2087
merged. If you specify two revisions, the first will be used as a BASE,
2088
and the second one as OTHER. Revision numbers are always relative to the
1165
By default bzr will try to merge in all new work from the other
2091
By default, bzr will try to merge in all new work from the other
1166
2092
branch, automatically determining an appropriate base. If this
1167
2093
fails, you may need to give an explicit base.
2095
Merge will do its best to combine the changes in two branches, but there
2096
are some kinds of problems only a human can fix. When it encounters those,
2097
it will mark a conflict. A conflict means that you need to fix something,
2098
before you should commit.
2100
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2102
If there is no default branch set, the first merge will set it. After
2103
that, you can omit the branch to use the default. To change the
2104
default, use --remember. The value will only be saved if the remote
2105
location can be accessed.
1171
2109
To merge the latest revision from bzr.dev
1180
2118
merge refuses to run if there are any uncommitted changes, unless
1181
2119
--force is given.
2121
The following merge types are available:
1183
2123
takes_args = ['branch?']
1184
takes_options = ['revision', 'force', 'merge-type']
1186
def run(self, branch='.', revision=None, force=False,
1188
from bzrlib.merge import merge
1189
from bzrlib.merge_core import ApplyMerge3
2124
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2125
Option('show-base', help="Show base revision text in "
2127
Option('uncommitted', help='Apply uncommitted changes'
2128
' from a working copy, instead of branch changes')]
2131
from merge import merge_type_help
2132
from inspect import getdoc
2133
return getdoc(self) + '\n' + merge_type_help()
2135
def run(self, branch=None, revision=None, force=False, merge_type=None,
2136
show_base=False, reprocess=False, remember=False,
1190
2138
if merge_type is None:
1191
merge_type = ApplyMerge3
2139
merge_type = Merge3Merger
2141
tree = WorkingTree.open_containing(u'.')[0]
2143
if branch is not None:
2145
reader = bundle.read_bundle_from_url(branch)
2147
pass # Continue on considering this url a Branch
2149
conflicts = merge_bundle(reader, tree, not force, merge_type,
2150
reprocess, show_base)
2156
branch = self._get_remembered_parent(tree, branch, 'Merging from')
1193
2158
if revision is None or len(revision) < 1:
1195
other = [branch, -1]
2161
other = [branch, None]
2164
other = [branch, -1]
2165
other_branch, path = Branch.open_containing(branch)
2168
raise BzrCommandError('Cannot use --uncommitted and --revision'
2169
' at the same time.')
1197
2170
if len(revision) == 1:
1198
other = [branch, revision[0]]
1199
2171
base = [None, None]
2172
other_branch, path = Branch.open_containing(branch)
2173
revno = revision[0].in_history(other_branch).revno
2174
other = [branch, revno]
1201
2176
assert len(revision) == 2
1202
2177
if None in revision:
1203
2178
raise BzrCommandError(
1204
2179
"Merge doesn't permit that revision specifier.")
1205
base = [branch, revision[0]]
1206
other = [branch, revision[1]]
2180
other_branch, path = Branch.open_containing(branch)
2182
base = [branch, revision[0].in_history(other_branch).revno]
2183
other = [branch, revision[1].in_history(other_branch).revno]
2185
if tree.branch.get_parent() is None or remember:
2186
tree.branch.set_parent(other_branch.base)
2189
interesting_files = [path]
2191
interesting_files = None
2192
pb = ui.ui_factory.nested_progress_bar()
1209
merge(other, base, check_clean=(not force), merge_type=merge_type)
1210
except bzrlib.errors.AmbiguousBase, e:
2195
conflict_count = merge(other, base, check_clean=(not force),
2196
merge_type=merge_type,
2197
reprocess=reprocess,
2198
show_base=show_base,
2199
pb=pb, file_list=interesting_files)
2202
if conflict_count != 0:
2206
except errors.AmbiguousBase, e:
1211
2207
m = ("sorry, bzr can't determine the right merge base yet\n"
1212
2208
"candidates are:\n "
1213
2209
+ "\n ".join(e.bases)
1216
2212
"and (if you want) report this to the bzr developers\n")
2215
# TODO: move up to common parent; this isn't merge-specific anymore.
2216
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2217
"""Use tree.branch's parent if none was supplied.
2219
Report if the remembered location was used.
2221
if supplied_location is not None:
2222
return supplied_location
2223
stored_location = tree.branch.get_parent()
2224
mutter("%s", stored_location)
2225
if stored_location is None:
2226
raise BzrCommandError("No location specified or remembered")
2227
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2228
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2229
return stored_location
2232
class cmd_remerge(Command):
2235
Use this if you want to try a different merge technique while resolving
2236
conflicts. Some merge techniques are better than others, and remerge
2237
lets you try different ones on different files.
2239
The options for remerge have the same meaning and defaults as the ones for
2240
merge. The difference is that remerge can (only) be run when there is a
2241
pending merge, and it lets you specify particular files.
2244
$ bzr remerge --show-base
2245
Re-do the merge of all conflicted files, and show the base text in
2246
conflict regions, in addition to the usual THIS and OTHER texts.
2248
$ bzr remerge --merge-type weave --reprocess foobar
2249
Re-do the merge of "foobar", using the weave merge algorithm, with
2250
additional processing to reduce the size of conflict regions.
2252
The following merge types are available:"""
2253
takes_args = ['file*']
2254
takes_options = ['merge-type', 'reprocess',
2255
Option('show-base', help="Show base revision text in "
2259
from merge import merge_type_help
2260
from inspect import getdoc
2261
return getdoc(self) + '\n' + merge_type_help()
2263
def run(self, file_list=None, merge_type=None, show_base=False,
2265
from bzrlib.merge import merge_inner, transform_tree
2266
if merge_type is None:
2267
merge_type = Merge3Merger
2268
tree, file_list = tree_files(file_list)
2271
pending_merges = tree.pending_merges()
2272
if len(pending_merges) != 1:
2273
raise BzrCommandError("Sorry, remerge only works after normal"
2274
" merges. Not cherrypicking or"
2276
repository = tree.branch.repository
2277
base_revision = common_ancestor(tree.branch.last_revision(),
2278
pending_merges[0], repository)
2279
base_tree = repository.revision_tree(base_revision)
2280
other_tree = repository.revision_tree(pending_merges[0])
2281
interesting_ids = None
2283
conflicts = tree.conflicts()
2284
if file_list is not None:
2285
interesting_ids = set()
2286
for filename in file_list:
2287
file_id = tree.path2id(filename)
2289
raise NotVersionedError(filename)
2290
interesting_ids.add(file_id)
2291
if tree.kind(file_id) != "directory":
2294
for name, ie in tree.inventory.iter_entries(file_id):
2295
interesting_ids.add(ie.file_id)
2296
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2297
transform_tree(tree, tree.basis_tree(), interesting_ids)
2298
tree.set_conflicts(ConflictList(new_conflicts))
2299
if file_list is None:
2300
restore_files = list(tree.iter_conflicts())
2302
restore_files = file_list
2303
for filename in restore_files:
2305
restore(tree.abspath(filename))
2306
except NotConflicted:
2308
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2310
interesting_ids=interesting_ids,
2311
other_rev_id=pending_merges[0],
2312
merge_type=merge_type,
2313
show_base=show_base,
2314
reprocess=reprocess)
1220
2322
class cmd_revert(Command):
1221
2323
"""Reverse all changes since the last commit.
1279
2386
aliases = ['s-c']
1282
2390
def run(self, context=None):
1283
2391
import shellcomplete
1284
2392
shellcomplete.shellcomplete(context)
2395
class cmd_fetch(Command):
2396
"""Copy in history from another branch but don't merge it.
2398
This is an internal method used for pull and merge."""
2400
takes_args = ['from_branch', 'to_branch']
2401
def run(self, from_branch, to_branch):
2402
from bzrlib.fetch import Fetcher
2403
from_b = Branch.open(from_branch)
2404
to_b = Branch.open(to_branch)
2405
Fetcher(to_b, from_b)
1287
2408
class cmd_missing(Command):
1288
"""What is missing in this branch relative to other branch.
1290
takes_args = ['remote?']
1291
aliases = ['mis', 'miss']
1292
# We don't have to add quiet to the list, because
1293
# unknown options are parsed as booleans
1294
takes_options = ['verbose', 'quiet']
1296
def run(self, remote=None, verbose=False, quiet=False):
1297
from bzrlib.errors import BzrCommandError
1298
from bzrlib.missing import show_missing
1300
if verbose and quiet:
1301
raise BzrCommandError('Cannot pass both quiet and verbose')
1303
b = find_branch('.')
1304
parent = b.get_parent()
1307
raise BzrCommandError("No missing location known or specified.")
1310
print "Using last location: %s" % parent
1312
elif parent is None:
1313
# We only update x-pull if it did not exist, missing should not change the parent
1314
b.controlfile('x-pull', 'wb').write(remote + '\n')
1315
br_remote = find_branch(remote)
1317
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
2409
"""Show unmerged/unpulled revisions between two branches.
2411
OTHER_BRANCH may be local or remote."""
2412
takes_args = ['other_branch?']
2413
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2415
'Display changes in the local branch only'),
2416
Option('theirs-only',
2417
'Display changes in the remote branch only'),
2425
encoding_type = 'replace'
2428
def run(self, other_branch=None, reverse=False, mine_only=False,
2429
theirs_only=False, log_format=None, long=False, short=False, line=False,
2430
show_ids=False, verbose=False):
2431
from bzrlib.missing import find_unmerged, iter_log_data
2432
from bzrlib.log import log_formatter
2433
local_branch = Branch.open_containing(u".")[0]
2434
parent = local_branch.get_parent()
2435
if other_branch is None:
2436
other_branch = parent
2437
if other_branch is None:
2438
raise BzrCommandError("No peer location known or specified.")
2439
print "Using last location: " + local_branch.get_parent()
2440
remote_branch = Branch.open(other_branch)
2441
if remote_branch.base == local_branch.base:
2442
remote_branch = local_branch
2443
local_branch.lock_read()
2445
remote_branch.lock_read()
2447
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2448
if (log_format == None):
2449
default = local_branch.get_config().log_format()
2450
log_format = get_log_format(long=long, short=short,
2451
line=line, default=default)
2452
lf = log_formatter(log_format,
2455
show_timezone='original')
2456
if reverse is False:
2457
local_extra.reverse()
2458
remote_extra.reverse()
2459
if local_extra and not theirs_only:
2460
print "You have %d extra revision(s):" % len(local_extra)
2461
for data in iter_log_data(local_extra, local_branch.repository,
2464
printed_local = True
2466
printed_local = False
2467
if remote_extra and not mine_only:
2468
if printed_local is True:
2470
print "You are missing %d revision(s):" % len(remote_extra)
2471
for data in iter_log_data(remote_extra, remote_branch.repository,
2474
if not remote_extra and not local_extra:
2476
print "Branches are up to date."
2480
remote_branch.unlock()
2482
local_branch.unlock()
2483
if not status_code and parent is None and other_branch is not None:
2484
local_branch.lock_write()
2486
# handle race conditions - a parent might be set while we run.
2487
if local_branch.get_parent() is None:
2488
local_branch.set_parent(remote_branch.base)
2490
local_branch.unlock()
1321
2494
class cmd_plugins(Command):
1322
2495
"""List plugins"""
1325
2499
import bzrlib.plugin
1326
2500
from inspect import getdoc
1327
for plugin in bzrlib.plugin.all_plugins:
2501
for name, plugin in bzrlib.plugin.all_plugins().items():
1328
2502
if hasattr(plugin, '__path__'):
1329
2503
print plugin.__path__[0]
1330
2504
elif hasattr(plugin, '__file__'):
1337
2511
print '\t', d.split('\n')[0]
2514
class cmd_testament(Command):
2515
"""Show testament (signing-form) of a revision."""
2516
takes_options = ['revision', 'long',
2517
Option('strict', help='Produce a strict-format'
2519
takes_args = ['branch?']
2521
def run(self, branch=u'.', revision=None, long=False, strict=False):
2522
from bzrlib.testament import Testament, StrictTestament
2524
testament_class = StrictTestament
2526
testament_class = Testament
2527
b = WorkingTree.open_containing(branch)[0].branch
2530
if revision is None:
2531
rev_id = b.last_revision()
2533
rev_id = revision[0].in_history(b).rev_id
2534
t = testament_class.from_revision(b.repository, rev_id)
2536
sys.stdout.writelines(t.as_text_lines())
2538
sys.stdout.write(t.as_short_text())
2543
class cmd_annotate(Command):
2544
"""Show the origin of each line in a file.
2546
This prints out the given file with an annotation on the left side
2547
indicating which revision, author and date introduced the change.
2549
If the origin is the same for a run of consecutive lines, it is
2550
shown only at the top, unless the --all option is given.
2552
# TODO: annotate directories; showing when each file was last changed
2553
# TODO: if the working copy is modified, show annotations on that
2554
# with new uncommitted lines marked
2555
aliases = ['ann', 'blame', 'praise']
2556
takes_args = ['filename']
2557
takes_options = [Option('all', help='show annotations on all lines'),
2558
Option('long', help='show date in annotations'),
2563
def run(self, filename, all=False, long=False, revision=None):
2564
from bzrlib.annotate import annotate_file
2565
tree, relpath = WorkingTree.open_containing(filename)
2566
branch = tree.branch
2569
if revision is None:
2570
revision_id = branch.last_revision()
2571
elif len(revision) != 1:
2572
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2574
revision_id = revision[0].in_history(branch).rev_id
2575
file_id = tree.inventory.path2id(relpath)
2576
tree = branch.repository.revision_tree(revision_id)
2577
file_version = tree.inventory[file_id].revision
2578
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2583
class cmd_re_sign(Command):
2584
"""Create a digital signature for an existing revision."""
2585
# TODO be able to replace existing ones.
2587
hidden = True # is this right ?
2588
takes_args = ['revision_id*']
2589
takes_options = ['revision']
2591
def run(self, revision_id_list=None, revision=None):
2592
import bzrlib.gpg as gpg
2593
if revision_id_list is not None and revision is not None:
2594
raise BzrCommandError('You can only supply one of revision_id or --revision')
2595
if revision_id_list is None and revision is None:
2596
raise BzrCommandError('You must supply either --revision or a revision_id')
2597
b = WorkingTree.open_containing(u'.')[0].branch
2598
gpg_strategy = gpg.GPGStrategy(b.get_config())
2599
if revision_id_list is not None:
2600
for revision_id in revision_id_list:
2601
b.repository.sign_revision(revision_id, gpg_strategy)
2602
elif revision is not None:
2603
if len(revision) == 1:
2604
revno, rev_id = revision[0].in_history(b)
2605
b.repository.sign_revision(rev_id, gpg_strategy)
2606
elif len(revision) == 2:
2607
# are they both on rh- if so we can walk between them
2608
# might be nice to have a range helper for arbitrary
2609
# revision paths. hmm.
2610
from_revno, from_revid = revision[0].in_history(b)
2611
to_revno, to_revid = revision[1].in_history(b)
2612
if to_revid is None:
2613
to_revno = b.revno()
2614
if from_revno is None or to_revno is None:
2615
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2616
for revno in range(from_revno, to_revno + 1):
2617
b.repository.sign_revision(b.get_rev_id(revno),
2620
raise BzrCommandError('Please supply either one revision, or a range.')
2623
class cmd_bind(Command):
2624
"""Bind the current branch to a master branch.
2626
After binding, commits must succeed on the master branch
2627
before they are executed on the local one.
2630
takes_args = ['location']
2633
def run(self, location=None):
2634
b, relpath = Branch.open_containing(u'.')
2635
b_other = Branch.open(location)
2638
except DivergedBranches:
2639
raise BzrCommandError('These branches have diverged.'
2640
' Try merging, and then bind again.')
2643
class cmd_unbind(Command):
2644
"""Unbind the current branch from its master branch.
2646
After unbinding, the local branch is considered independent.
2647
All subsequent commits will be local.
2654
b, relpath = Branch.open_containing(u'.')
2656
raise BzrCommandError('Local branch is not bound')
2659
class cmd_uncommit(Command):
2660
"""Remove the last committed revision.
2662
--verbose will print out what is being removed.
2663
--dry-run will go through all the motions, but not actually
2666
In the future, uncommit will create a revision bundle, which can then
2670
# TODO: jam 20060108 Add an option to allow uncommit to remove
2671
# unreferenced information in 'branch-as-repository' branches.
2672
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2673
# information in shared branches as well.
2674
takes_options = ['verbose', 'revision',
2675
Option('dry-run', help='Don\'t actually make changes'),
2676
Option('force', help='Say yes to all questions.')]
2677
takes_args = ['location?']
2680
def run(self, location=None,
2681
dry_run=False, verbose=False,
2682
revision=None, force=False):
2683
from bzrlib.log import log_formatter, show_log
2685
from bzrlib.uncommit import uncommit
2687
if location is None:
2689
control, relpath = bzrdir.BzrDir.open_containing(location)
2691
tree = control.open_workingtree()
2693
except (errors.NoWorkingTree, errors.NotLocalUrl):
2695
b = control.open_branch()
2698
if revision is None:
2701
# 'bzr uncommit -r 10' actually means uncommit
2702
# so that the final tree is at revno 10.
2703
# but bzrlib.uncommit.uncommit() actually uncommits
2704
# the revisions that are supplied.
2705
# So we need to offset it by one
2706
revno = revision[0].in_history(b).revno+1
2708
if revno <= b.revno():
2709
rev_id = b.get_rev_id(revno)
2711
self.outf.write('No revisions to uncommit.\n')
2714
lf = log_formatter('short',
2716
show_timezone='original')
2721
direction='forward',
2722
start_revision=revno,
2723
end_revision=b.revno())
2726
print 'Dry-run, pretending to remove the above revisions.'
2728
val = raw_input('Press <enter> to continue')
2730
print 'The above revision(s) will be removed.'
2732
val = raw_input('Are you sure [y/N]? ')
2733
if val.lower() not in ('y', 'yes'):
2737
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2741
class cmd_break_lock(Command):
2742
"""Break a dead lock on a repository, branch or working directory.
2744
CAUTION: Locks should only be broken when you are sure that the process
2745
holding the lock has been stopped.
2747
You can get information on what locks are open via the 'bzr info' command.
2752
takes_args = ['location?']
2754
def run(self, location=None, show=False):
2755
if location is None:
2757
control, relpath = bzrdir.BzrDir.open_containing(location)
2759
control.break_lock()
2760
except NotImplementedError:
2765
# command-line interpretation helper for merge-related commands
2766
def merge(other_revision, base_revision,
2767
check_clean=True, ignore_zero=False,
2768
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2769
file_list=None, show_base=False, reprocess=False,
2770
pb=DummyProgress()):
2771
"""Merge changes into a tree.
2774
list(path, revno) Base for three-way merge.
2775
If [None, None] then a base will be automatically determined.
2777
list(path, revno) Other revision for three-way merge.
2779
Directory to merge changes into; '.' by default.
2781
If true, this_dir must have no uncommitted changes before the
2783
ignore_zero - If true, suppress the "zero conflicts" message when
2784
there are no conflicts; should be set when doing something we expect
2785
to complete perfectly.
2786
file_list - If supplied, merge only changes to selected files.
2788
All available ancestors of other_revision and base_revision are
2789
automatically pulled into the branch.
2791
The revno may be -1 to indicate the last revision on the branch, which is
2794
This function is intended for use from the command line; programmatic
2795
clients might prefer to call merge.merge_inner(), which has less magic
2798
from bzrlib.merge import Merger
2799
if this_dir is None:
2801
this_tree = WorkingTree.open_containing(this_dir)[0]
2802
if show_base and not merge_type is Merge3Merger:
2803
raise BzrCommandError("Show-base is not supported for this merge"
2804
" type. %s" % merge_type)
2805
if reprocess and not merge_type.supports_reprocess:
2806
raise BzrCommandError("Conflict reduction is not supported for merge"
2807
" type %s." % merge_type)
2808
if reprocess and show_base:
2809
raise BzrCommandError("Cannot do conflict reduction and show base.")
2811
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2812
merger.pp = ProgressPhase("Merge phase", 5, pb)
2813
merger.pp.next_phase()
2814
merger.check_basis(check_clean)
2815
merger.set_other(other_revision)
2816
merger.pp.next_phase()
2817
merger.set_base(base_revision)
2818
if merger.base_rev_id == merger.other_rev_id:
2819
note('Nothing to do.')
2821
merger.backup_files = backup_files
2822
merger.merge_type = merge_type
2823
merger.set_interesting_files(file_list)
2824
merger.show_base = show_base
2825
merger.reprocess = reprocess
2826
conflicts = merger.do_merge()
2827
if file_list is None:
2828
merger.set_pending()
2834
# these get imported and then picked up by the scan for cmd_*
2835
# TODO: Some more consistent way to split command definitions across files;
2836
# we do need to load at least some information about them to know of
2837
# aliases. ideally we would avoid loading the implementation until the
2838
# details were needed.
2839
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2840
from bzrlib.bundle.commands import cmd_bundle_revisions
2841
from bzrlib.sign_my_commits import cmd_sign_my_commits
2842
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2843
cmd_weave_plan_merge, cmd_weave_merge_text