1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""builtin bzr commands"""
22
from shutil import rmtree
27
from bzrlib.branch import Branch
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.commands import Command, display_command
30
from bzrlib.revision import common_ancestor
31
import bzrlib.errors as errors
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
NotBranchError, DivergedBranches, NotConflicted,
34
NoSuchFile, NoWorkingTree, FileInWrongBranch,
36
from bzrlib.log import show_one_log
37
from bzrlib.merge import Merge3Merger
38
from bzrlib.option import Option
39
from bzrlib.progress import DummyProgress, ProgressPhase
40
from bzrlib.revisionspec import RevisionSpec
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
43
from bzrlib.transport.local import LocalTransport
45
from bzrlib.workingtree import WorkingTree
48
def tree_files(file_list, default_branch=u'.'):
50
return internal_tree_files(file_list, default_branch)
51
except FileInWrongBranch, e:
52
raise BzrCommandError("%s is not in the same branch as %s" %
53
(e.path, file_list[0]))
55
def internal_tree_files(file_list, default_branch=u'.'):
57
Return a branch and list of branch-relative paths.
58
If supplied file_list is empty or None, the branch default will be used,
59
and returned file_list will match the original.
61
if file_list is None or len(file_list) == 0:
62
return WorkingTree.open_containing(default_branch)[0], file_list
63
tree = WorkingTree.open_containing(file_list[0])[0]
65
for filename in file_list:
67
new_list.append(tree.relpath(filename))
68
except errors.PathNotChild:
69
raise FileInWrongBranch(tree.branch, filename)
73
def get_format_type(typestring):
74
"""Parse and return a format specifier."""
75
if typestring == "metadir":
76
return bzrdir.BzrDirMetaFormat1()
77
if typestring == "knit":
78
format = bzrdir.BzrDirMetaFormat1()
79
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
81
msg = "No known bzr-dir format %s. Supported types are: metadir\n" %\
83
raise BzrCommandError(msg)
86
# TODO: Make sure no commands unconditionally use the working directory as a
87
# branch. If a filename argument is used, the first of them should be used to
88
# specify the branch. (Perhaps this can be factored out into some kind of
89
# Argument class, representing a file in a branch, where the first occurrence
92
class cmd_status(Command):
93
"""Display status summary.
95
This reports on versioned and unknown files, reporting them
96
grouped by state. Possible states are:
99
Versioned in the working copy but not in the previous revision.
102
Versioned in the previous revision but removed or deleted
106
Path of this file changed from the previous revision;
107
the text may also have changed. This includes files whose
108
parent directory was renamed.
111
Text has changed since the previous revision.
114
Nothing about this file has changed since the previous revision.
115
Only shown with --all.
118
Not versioned and not matching an ignore pattern.
120
To see ignored files use 'bzr ignored'. For details in the
121
changes to file texts, use 'bzr diff'.
123
If no arguments are specified, the status of the entire working
124
directory is shown. Otherwise, only the status of the specified
125
files or directories is reported. If a directory is given, status
126
is reported for everything inside that directory.
128
If a revision argument is given, the status is calculated against
129
that revision, or between two revisions if two are provided.
132
# TODO: --no-recurse, --recurse options
134
takes_args = ['file*']
135
takes_options = ['all', 'show-ids', 'revision']
136
aliases = ['st', 'stat']
139
def run(self, all=False, show_ids=False, file_list=None, revision=None):
140
tree, file_list = tree_files(file_list)
142
from bzrlib.status import show_tree_status
143
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
144
specific_files=file_list, revision=revision)
147
class cmd_cat_revision(Command):
148
"""Write out metadata for a revision.
150
The revision to print can either be specified by a specific
151
revision identifier, or you can use --revision.
155
takes_args = ['revision_id?']
156
takes_options = ['revision']
159
def run(self, revision_id=None, revision=None):
161
if revision_id is not None and revision is not None:
162
raise BzrCommandError('You can only supply one of revision_id or --revision')
163
if revision_id is None and revision is None:
164
raise BzrCommandError('You must supply either --revision or a revision_id')
165
b = WorkingTree.open_containing(u'.')[0].branch
166
if revision_id is not None:
167
sys.stdout.write(b.repository.get_revision_xml(revision_id))
168
elif revision is not None:
171
raise BzrCommandError('You cannot specify a NULL revision.')
172
revno, rev_id = rev.in_history(b)
173
sys.stdout.write(b.repository.get_revision_xml(rev_id))
176
class cmd_revno(Command):
177
"""Show current revision number.
179
This is equal to the number of revisions on this branch."""
180
takes_args = ['location?']
182
def run(self, location=u'.'):
183
print Branch.open_containing(location)[0].revno()
186
class cmd_revision_info(Command):
187
"""Show revision number and revision id for a given revision identifier.
190
takes_args = ['revision_info*']
191
takes_options = ['revision']
193
def run(self, revision=None, revision_info_list=[]):
196
if revision is not None:
197
revs.extend(revision)
198
if revision_info_list is not None:
199
for rev in revision_info_list:
200
revs.append(RevisionSpec(rev))
202
raise BzrCommandError('You must supply a revision identifier')
204
b = WorkingTree.open_containing(u'.')[0].branch
207
revinfo = rev.in_history(b)
208
if revinfo.revno is None:
209
print ' %s' % revinfo.rev_id
211
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
214
class cmd_add(Command):
215
"""Add specified files or directories.
217
In non-recursive mode, all the named items are added, regardless
218
of whether they were previously ignored. A warning is given if
219
any of the named files are already versioned.
221
In recursive mode (the default), files are treated the same way
222
but the behaviour for directories is different. Directories that
223
are already versioned do not give a warning. All directories,
224
whether already versioned or not, are searched for files or
225
subdirectories that are neither versioned or ignored, and these
226
are added. This search proceeds recursively into versioned
227
directories. If no names are given '.' is assumed.
229
Therefore simply saying 'bzr add' will version all files that
230
are currently unknown.
232
Adding a file whose parent directory is not versioned will
233
implicitly add the parent, and so on up to the root. This means
234
you should never need to explictly add a directory, they'll just
235
get added when you add a file in the directory.
237
--dry-run will show which files would be added, but not actually
240
takes_args = ['file*']
241
takes_options = ['no-recurse', 'dry-run', 'verbose']
243
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
248
# This is pointless, but I'd rather not raise an error
249
action = bzrlib.add.add_action_null
251
action = bzrlib.add.add_action_print
253
action = bzrlib.add.add_action_add
255
action = bzrlib.add.add_action_add_and_print
257
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
260
for glob in sorted(ignored.keys()):
261
match_len = len(ignored[glob])
263
for path in ignored[glob]:
264
print "ignored %s matching \"%s\"" % (path, glob)
266
print "ignored %d file(s) matching \"%s\"" % (match_len,
268
print "If you wish to add some of these files, please add them"\
272
class cmd_mkdir(Command):
273
"""Create a new versioned directory.
275
This is equivalent to creating the directory and then adding it.
277
takes_args = ['dir+']
279
def run(self, dir_list):
282
wt, dd = WorkingTree.open_containing(d)
287
class cmd_relpath(Command):
288
"""Show path of a file relative to root"""
289
takes_args = ['filename']
293
def run(self, filename):
294
tree, relpath = WorkingTree.open_containing(filename)
298
class cmd_inventory(Command):
299
"""Show inventory of the current working copy or a revision.
301
It is possible to limit the output to a particular entry
302
type using the --kind option. For example; --kind file.
304
takes_options = ['revision', 'show-ids', 'kind']
307
def run(self, revision=None, show_ids=False, kind=None):
308
if kind and kind not in ['file', 'directory', 'symlink']:
309
raise BzrCommandError('invalid kind specified')
310
tree = WorkingTree.open_containing(u'.')[0]
312
inv = tree.read_working_inventory()
314
if len(revision) > 1:
315
raise BzrCommandError('bzr inventory --revision takes'
316
' exactly one revision identifier')
317
inv = tree.branch.repository.get_revision_inventory(
318
revision[0].in_history(tree.branch).rev_id)
320
for path, entry in inv.entries():
321
if kind and kind != entry.kind:
324
print '%-50s %s' % (path, entry.file_id)
329
class cmd_mv(Command):
330
"""Move or rename a file.
333
bzr mv OLDNAME NEWNAME
334
bzr mv SOURCE... DESTINATION
336
If the last argument is a versioned directory, all the other names
337
are moved into it. Otherwise, there must be exactly two arguments
338
and the file is changed to a new name, which must not already exist.
340
Files cannot be moved between branches.
342
takes_args = ['names*']
343
aliases = ['move', 'rename']
345
def run(self, names_list):
346
if len(names_list) < 2:
347
raise BzrCommandError("missing file argument")
348
tree, rel_names = tree_files(names_list)
350
if os.path.isdir(names_list[-1]):
351
# move into existing directory
352
for pair in tree.move(rel_names[:-1], rel_names[-1]):
353
print "%s => %s" % pair
355
if len(names_list) != 2:
356
raise BzrCommandError('to mv multiple files the destination '
357
'must be a versioned directory')
358
tree.rename_one(rel_names[0], rel_names[1])
359
print "%s => %s" % (rel_names[0], rel_names[1])
362
class cmd_pull(Command):
363
"""Turn this branch into a mirror of another branch.
365
If there is no default location set, the first pull will set it. After
366
that, you can omit the location to use the default. To change the
367
default, use --remember.
369
This command only works on branches that have not diverged. Branches are
370
considered diverged if the destination branch's most recent commit is one
371
that has not been merged (directly or indirectly) into the parent.
373
If branches have diverged, you can use 'bzr merge' to pull the text changes
374
from one into the other. Once one branch has merged, the other should
375
be able to pull it again.
377
If you want to forget your local changes and just update your branch to
378
match the remote one, use --overwrite.
380
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
381
takes_args = ['location?']
383
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
384
# FIXME: too much stuff is in the command class
386
tree_to = WorkingTree.open_containing(u'.')[0]
387
branch_to = tree_to.branch
388
except NoWorkingTree:
390
branch_to = Branch.open_containing(u'.')[0]
391
stored_loc = branch_to.get_parent()
393
if stored_loc is None:
394
raise BzrCommandError("No pull location known or specified.")
396
print "Using saved location: %s" % stored_loc
397
location = stored_loc
399
br_from = Branch.open(location)
403
elif len(revision) == 1:
404
rev_id = revision[0].in_history(br_from).rev_id
406
raise BzrCommandError('bzr pull --revision takes one value.')
408
old_rh = branch_to.revision_history()
409
if tree_to is not None:
410
count = tree_to.pull(br_from, overwrite, rev_id)
412
count = branch_to.pull(br_from, overwrite, rev_id)
414
if branch_to.get_parent() is None or remember:
415
branch_to.set_parent(location)
416
note('%d revision(s) pulled.' % (count,))
419
new_rh = branch_to.revision_history()
422
from bzrlib.log import show_changed_revisions
423
show_changed_revisions(branch_to, old_rh, new_rh)
426
class cmd_push(Command):
427
"""Update a mirror of this branch.
429
The target branch will not have its working tree populated because this
430
is both expensive, and is not supported on remote file systems.
432
Some smart servers or protocols *may* put the working tree in place in
435
If there is no default push location set, the first push will set it.
436
After that, you can omit the location to use the default. To change the
437
default, use --remember.
439
This command only works on branches that have not diverged. Branches are
440
considered diverged if the destination branch's most recent commit is one
441
that has not been merged (directly or indirectly) by the source branch.
443
If branches have diverged, you can use 'bzr push --overwrite' to replace
444
the other branch completely, discarding its unmerged changes.
446
If you want to ensure you have the different changes in the other branch,
447
do a merge (see bzr help merge) from the other branch, and commit that.
448
After that you will be able to do a push without '--overwrite'.
450
takes_options = ['remember', 'overwrite',
451
Option('create-prefix',
452
help='Create the path leading up to the branch '
453
'if it does not already exist')]
454
takes_args = ['location?']
456
def run(self, location=None, remember=False, overwrite=False,
457
create_prefix=False, verbose=False):
458
# FIXME: Way too big! Put this into a function called from the
460
from bzrlib.transport import get_transport
462
tree_from = WorkingTree.open_containing(u'.')[0]
463
br_from = tree_from.branch
464
stored_loc = tree_from.branch.get_push_location()
466
if stored_loc is None:
467
raise BzrCommandError("No push location known or specified.")
469
print "Using saved location: %s" % stored_loc
470
location = stored_loc
472
dir_to = bzrlib.bzrdir.BzrDir.open(location)
473
br_to = dir_to.open_branch()
474
except NotBranchError:
476
transport = get_transport(location).clone('..')
477
if not create_prefix:
479
transport.mkdir(transport.relpath(location))
481
raise BzrCommandError("Parent directory of %s "
482
"does not exist." % location)
484
current = transport.base
485
needed = [(transport, transport.relpath(location))]
488
transport, relpath = needed[-1]
489
transport.mkdir(relpath)
492
new_transport = transport.clone('..')
493
needed.append((new_transport,
494
new_transport.relpath(transport.base)))
495
if new_transport.base == transport.base:
496
raise BzrCommandError("Could not create "
498
dir_to = br_from.bzrdir.clone(location)
499
br_to = dir_to.open_branch()
500
old_rh = br_to.revision_history()
503
tree_to = dir_to.open_workingtree()
504
except errors.NotLocalUrl:
505
# TODO: This should be updated for branches which don't have a
506
# working tree, as opposed to ones where we just couldn't
508
warning('This transport does not update the working '
509
'tree of: %s' % (br_to.base,))
510
count = br_to.pull(br_from, overwrite)
511
except NoWorkingTree:
512
count = br_to.pull(br_from, overwrite)
514
count = tree_to.pull(br_from, overwrite)
515
except DivergedBranches:
516
raise BzrCommandError("These branches have diverged."
517
" Try a merge then push with overwrite.")
518
if br_from.get_push_location() is None or remember:
519
br_from.set_push_location(location)
520
note('%d revision(s) pushed.' % (count,))
523
new_rh = br_to.revision_history()
526
from bzrlib.log import show_changed_revisions
527
show_changed_revisions(br_to, old_rh, new_rh)
530
class cmd_branch(Command):
531
"""Create a new copy of a branch.
533
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
534
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
536
To retrieve the branch as of a particular revision, supply the --revision
537
parameter, as in "branch foo/bar -r 5".
539
--basis is to speed up branching from remote branches. When specified, it
540
copies all the file-contents, inventory and revision data from the basis
541
branch before copying anything from the remote branch.
543
takes_args = ['from_location', 'to_location?']
544
takes_options = ['revision', 'basis']
545
aliases = ['get', 'clone']
547
def run(self, from_location, to_location=None, revision=None, basis=None):
550
elif len(revision) > 1:
551
raise BzrCommandError(
552
'bzr branch --revision takes exactly 1 revision value')
554
br_from = Branch.open(from_location)
556
if e.errno == errno.ENOENT:
557
raise BzrCommandError('Source location "%s" does not'
558
' exist.' % to_location)
563
if basis is not None:
564
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
567
if len(revision) == 1 and revision[0] is not None:
568
revision_id = revision[0].in_history(br_from)[1]
570
# FIXME - wt.last_revision, fallback to branch, fall back to
571
# None or perhaps NULL_REVISION to mean copy nothing
573
revision_id = br_from.last_revision()
574
if to_location is None:
575
to_location = os.path.basename(from_location.rstrip("/\\"))
578
name = os.path.basename(to_location) + '\n'
580
os.mkdir(to_location)
582
if e.errno == errno.EEXIST:
583
raise BzrCommandError('Target directory "%s" already'
584
' exists.' % to_location)
585
if e.errno == errno.ENOENT:
586
raise BzrCommandError('Parent of "%s" does not exist.' %
591
# preserve whatever source format we have.
592
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
593
branch = dir.open_branch()
594
except bzrlib.errors.NoSuchRevision:
596
msg = "The branch %s has no revision %s." % (from_location, revision[0])
597
raise BzrCommandError(msg)
598
except bzrlib.errors.UnlistableBranch:
600
msg = "The branch %s cannot be used as a --basis" % (basis,)
601
raise BzrCommandError(msg)
603
branch.control_files.put_utf8('branch-name', name)
605
note('Branched %d revision(s).' % branch.revno())
610
class cmd_checkout(Command):
611
"""Create a new checkout of an existing branch.
613
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
614
the branch found in '.'. This is useful if you have removed the working tree
615
or if it was never created - i.e. if you pushed the branch to its current
618
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
619
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
621
To retrieve the branch as of a particular revision, supply the --revision
622
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
623
out of date [so you cannot commit] but it may be useful (i.e. to examine old
626
--basis is to speed up checking out from remote branches. When specified, it
627
uses the inventory and file contents from the basis branch in preference to the
628
branch being checked out. [Not implemented yet.]
630
takes_args = ['branch_location?', 'to_location?']
631
takes_options = ['revision', # , 'basis']
632
Option('lightweight',
633
help="perform a lightweight checkout. Lightweight "
634
"checkouts depend on access to the branch for "
635
"every operation. Normal checkouts can perform "
636
"common operations like diff and status without "
637
"such access, and also support local commits."
641
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
645
elif len(revision) > 1:
646
raise BzrCommandError(
647
'bzr checkout --revision takes exactly 1 revision value')
648
if branch_location is None:
649
branch_location = bzrlib.osutils.getcwd()
650
to_location = branch_location
651
source = Branch.open(branch_location)
652
if len(revision) == 1 and revision[0] is not None:
653
revision_id = revision[0].in_history(source)[1]
656
if to_location is None:
657
to_location = os.path.basename(branch_location.rstrip("/\\"))
658
# if the source and to_location are the same,
659
# and there is no working tree,
660
# then reconstitute a branch
661
if (bzrlib.osutils.abspath(to_location) ==
662
bzrlib.osutils.abspath(branch_location)):
664
source.bzrdir.open_workingtree()
665
except errors.NoWorkingTree:
666
source.bzrdir.create_workingtree()
669
os.mkdir(to_location)
671
if e.errno == errno.EEXIST:
672
raise BzrCommandError('Target directory "%s" already'
673
' exists.' % to_location)
674
if e.errno == errno.ENOENT:
675
raise BzrCommandError('Parent of "%s" does not exist.' %
679
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
680
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
683
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
684
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
686
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
687
to_location, force_new_tree=False)
688
checkout = checkout_branch.bzrdir
689
checkout_branch.bind(source)
690
if revision_id is not None:
691
rh = checkout_branch.revision_history()
692
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
693
checkout.create_workingtree(revision_id)
695
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
698
class cmd_renames(Command):
699
"""Show list of renamed files.
701
# TODO: Option to show renames between two historical versions.
703
# TODO: Only show renames under dir, rather than in the whole branch.
704
takes_args = ['dir?']
707
def run(self, dir=u'.'):
708
tree = WorkingTree.open_containing(dir)[0]
709
old_inv = tree.basis_tree().inventory
710
new_inv = tree.read_working_inventory()
712
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
714
for old_name, new_name in renames:
715
print "%s => %s" % (old_name, new_name)
718
class cmd_update(Command):
719
"""Update a tree to have the latest code committed to its branch.
721
This will perform a merge into the working tree, and may generate
722
conflicts. If you have any local changes, you will still
723
need to commit them after the update for the update to be complete.
725
If you want to discard your local changes, you can just do a
726
'bzr revert' instead of 'bzr commit' after the update.
728
takes_args = ['dir?']
730
def run(self, dir='.'):
731
tree = WorkingTree.open_containing(dir)[0]
734
if tree.last_revision() == tree.branch.last_revision():
735
# may be up to date, check master too.
736
master = tree.branch.get_master_branch()
737
if master is None or master.last_revision == tree.last_revision():
738
note("Tree is up to date.")
740
conflicts = tree.update()
741
note('Updated to revision %d.' %
742
(tree.branch.revision_id_to_revno(tree.last_revision()),))
751
class cmd_info(Command):
752
"""Show statistical information about a branch."""
753
takes_args = ['branch?']
754
takes_options = ['verbose']
757
def run(self, branch=None, verbose=False):
759
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0],
763
class cmd_remove(Command):
764
"""Make a file unversioned.
766
This makes bzr stop tracking changes to a versioned file. It does
767
not delete the working copy.
769
takes_args = ['file+']
770
takes_options = ['verbose']
773
def run(self, file_list, verbose=False):
774
tree, file_list = tree_files(file_list)
775
tree.remove(file_list, verbose=verbose)
778
class cmd_file_id(Command):
779
"""Print file_id of a particular file or directory.
781
The file_id is assigned when the file is first added and remains the
782
same through all revisions where the file exists, even when it is
786
takes_args = ['filename']
788
def run(self, filename):
789
tree, relpath = WorkingTree.open_containing(filename)
790
i = tree.inventory.path2id(relpath)
792
raise BzrError("%r is not a versioned file" % filename)
797
class cmd_file_path(Command):
798
"""Print path of file_ids to a file or directory.
800
This prints one line for each directory down to the target,
801
starting at the branch root."""
803
takes_args = ['filename']
805
def run(self, filename):
806
tree, relpath = WorkingTree.open_containing(filename)
808
fid = inv.path2id(relpath)
810
raise BzrError("%r is not a versioned file" % filename)
811
for fip in inv.get_idpath(fid):
815
class cmd_reconcile(Command):
816
"""Reconcile bzr metadata in a branch.
818
This can correct data mismatches that may have been caused by
819
previous ghost operations or bzr upgrades. You should only
820
need to run this command if 'bzr check' or a bzr developer
821
advises you to run it.
823
If a second branch is provided, cross-branch reconciliation is
824
also attempted, which will check that data like the tree root
825
id which was not present in very early bzr versions is represented
826
correctly in both branches.
828
At the same time it is run it may recompress data resulting in
829
a potential saving in disk space or performance gain.
831
The branch *MUST* be on a listable system such as local disk or sftp.
833
takes_args = ['branch?']
835
def run(self, branch="."):
836
from bzrlib.reconcile import reconcile
837
dir = bzrlib.bzrdir.BzrDir.open(branch)
841
class cmd_revision_history(Command):
842
"""Display list of revision ids on this branch."""
846
branch = WorkingTree.open_containing(u'.')[0].branch
847
for patchid in branch.revision_history():
851
class cmd_ancestry(Command):
852
"""List all revisions merged into this branch."""
856
tree = WorkingTree.open_containing(u'.')[0]
858
# FIXME. should be tree.last_revision
859
for revision_id in b.repository.get_ancestry(b.last_revision()):
863
class cmd_init(Command):
864
"""Make a directory into a versioned branch.
866
Use this to create an empty branch, or before importing an
869
Recipe for importing a tree of files:
874
bzr commit -m 'imported project'
876
takes_args = ['location?']
879
help='Create a specific format rather than the'
880
' current default format. Currently this '
881
' option only accepts "metadir"',
882
type=get_format_type),
884
def run(self, location=None, format=None):
885
from bzrlib.branch import Branch
889
# The path has to exist to initialize a
890
# branch inside of it.
891
# Just using os.mkdir, since I don't
892
# believe that we want to create a bunch of
893
# locations if the user supplies an extended path
894
if not os.path.exists(location):
896
bzrdir.BzrDir.create_branch_convenience(location, format=format)
899
class cmd_init_repository(Command):
900
"""Create a shared repository to keep branches in."""
901
takes_args = ["location"]
902
takes_options = [Option('format',
903
help='Use a specific format rather than the'
904
' current default format. Currently this'
905
' option only accepts "metadir" and "knit"'
906
' WARNING: the knit format is currently unstable'
907
' and only for experimental use.',
908
type=get_format_type),
910
help='Allows branches in repository to have'
912
aliases = ["init-repo"]
913
def run(self, location, format=None, trees=False):
914
from bzrlib.bzrdir import BzrDirMetaFormat1
915
from bzrlib.transport import get_transport
917
format = BzrDirMetaFormat1()
918
get_transport(location).mkdir('')
919
newdir = format.initialize(location)
920
repo = newdir.create_repository(shared=True)
921
repo.set_make_working_trees(trees)
924
class cmd_diff(Command):
925
"""Show differences in working tree.
927
If files are listed, only the changes in those files are listed.
928
Otherwise, all changes for the tree are listed.
935
# TODO: Allow diff across branches.
936
# TODO: Option to use external diff command; could be GNU diff, wdiff,
937
# or a graphical diff.
939
# TODO: Python difflib is not exactly the same as unidiff; should
940
# either fix it up or prefer to use an external diff.
942
# TODO: If a directory is given, diff everything under that.
944
# TODO: Selected-file diff is inefficient and doesn't show you
947
# TODO: This probably handles non-Unix newlines poorly.
949
takes_args = ['file*']
950
takes_options = ['revision', 'diff-options']
951
aliases = ['di', 'dif']
954
def run(self, revision=None, file_list=None, diff_options=None):
955
from bzrlib.diff import diff_cmd_helper, show_diff_trees
957
tree1, file_list = internal_tree_files(file_list)
961
except FileInWrongBranch:
962
if len(file_list) != 2:
963
raise BzrCommandError("Files are in different branches")
965
tree1, file1 = WorkingTree.open_containing(file_list[0])
966
tree2, file2 = WorkingTree.open_containing(file_list[1])
967
if file1 != "" or file2 != "":
968
# FIXME diff those two files. rbc 20051123
969
raise BzrCommandError("Files are in different branches")
971
if revision is not None:
972
if tree2 is not None:
973
raise BzrCommandError("Can't specify -r with two branches")
974
if (len(revision) == 1) or (revision[1].spec is None):
975
return diff_cmd_helper(tree1, file_list, diff_options,
977
elif len(revision) == 2:
978
return diff_cmd_helper(tree1, file_list, diff_options,
979
revision[0], revision[1])
981
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
983
if tree2 is not None:
984
return show_diff_trees(tree1, tree2, sys.stdout,
985
specific_files=file_list,
986
external_diff_options=diff_options)
988
return diff_cmd_helper(tree1, file_list, diff_options)
991
class cmd_deleted(Command):
992
"""List files deleted in the working tree.
994
# TODO: Show files deleted since a previous revision, or
995
# between two revisions.
996
# TODO: Much more efficient way to do this: read in new
997
# directories with readdir, rather than stating each one. Same
998
# level of effort but possibly much less IO. (Or possibly not,
999
# if the directories are very large...)
1001
def run(self, show_ids=False):
1002
tree = WorkingTree.open_containing(u'.')[0]
1003
old = tree.basis_tree()
1004
for path, ie in old.inventory.iter_entries():
1005
if not tree.has_id(ie.file_id):
1007
print '%-50s %s' % (path, ie.file_id)
1012
class cmd_modified(Command):
1013
"""List files modified in working tree."""
1017
from bzrlib.delta import compare_trees
1019
tree = WorkingTree.open_containing(u'.')[0]
1020
td = compare_trees(tree.basis_tree(), tree)
1022
for path, id, kind, text_modified, meta_modified in td.modified:
1027
class cmd_added(Command):
1028
"""List files added in working tree."""
1032
wt = WorkingTree.open_containing(u'.')[0]
1033
basis_inv = wt.basis_tree().inventory
1036
if file_id in basis_inv:
1038
path = inv.id2path(file_id)
1039
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1045
class cmd_root(Command):
1046
"""Show the tree root directory.
1048
The root is the nearest enclosing directory with a .bzr control
1050
takes_args = ['filename?']
1052
def run(self, filename=None):
1053
"""Print the branch root."""
1054
tree = WorkingTree.open_containing(filename)[0]
1058
class cmd_log(Command):
1059
"""Show log of a branch, file, or directory.
1061
By default show the log of the branch containing the working directory.
1063
To request a range of logs, you can use the command -r begin..end
1064
-r revision requests a specific revision, -r ..end or -r begin.. are
1070
bzr log -r -10.. http://server/branch
1073
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1075
takes_args = ['location?']
1076
takes_options = [Option('forward',
1077
help='show from oldest to newest'),
1080
help='show files changed in each revision'),
1081
'show-ids', 'revision',
1085
help='show revisions whose message matches this regexp',
1090
def run(self, location=None, timezone='original',
1100
from bzrlib.log import log_formatter, show_log
1102
assert message is None or isinstance(message, basestring), \
1103
"invalid message argument %r" % message
1104
direction = (forward and 'forward') or 'reverse'
1109
# find the file id to log:
1111
dir, fp = bzrdir.BzrDir.open_containing(location)
1112
b = dir.open_branch()
1116
inv = dir.open_workingtree().inventory
1117
except (errors.NotBranchError, errors.NotLocalUrl):
1118
# either no tree, or is remote.
1119
inv = b.basis_tree().inventory
1120
file_id = inv.path2id(fp)
1123
# FIXME ? log the current subdir only RBC 20060203
1124
dir, relpath = bzrdir.BzrDir.open_containing('.')
1125
b = dir.open_branch()
1127
if revision is None:
1130
elif len(revision) == 1:
1131
rev1 = rev2 = revision[0].in_history(b).revno
1132
elif len(revision) == 2:
1133
if revision[0].spec is None:
1134
# missing begin-range means first revision
1137
rev1 = revision[0].in_history(b).revno
1139
if revision[1].spec is None:
1140
# missing end-range means last known revision
1143
rev2 = revision[1].in_history(b).revno
1145
raise BzrCommandError('bzr log --revision takes one or two values.')
1147
# By this point, the revision numbers are converted to the +ve
1148
# form if they were supplied in the -ve form, so we can do
1149
# this comparison in relative safety
1151
(rev2, rev1) = (rev1, rev2)
1153
mutter('encoding log as %r', bzrlib.user_encoding)
1155
# use 'replace' so that we don't abort if trying to write out
1156
# in e.g. the default C locale.
1157
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1159
if (log_format == None):
1160
default = bzrlib.config.BranchConfig(b).log_format()
1161
log_format = get_log_format(long=long, short=short, line=line, default=default)
1163
lf = log_formatter(log_format,
1166
show_timezone=timezone)
1172
direction=direction,
1173
start_revision=rev1,
1178
def get_log_format(long=False, short=False, line=False, default='long'):
1179
log_format = default
1183
log_format = 'short'
1189
class cmd_touching_revisions(Command):
1190
"""Return revision-ids which affected a particular file.
1192
A more user-friendly interface is "bzr log FILE"."""
1194
takes_args = ["filename"]
1196
def run(self, filename):
1197
tree, relpath = WorkingTree.open_containing(filename)
1199
inv = tree.read_working_inventory()
1200
file_id = inv.path2id(relpath)
1201
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1202
print "%6d %s" % (revno, what)
1205
class cmd_ls(Command):
1206
"""List files in a tree.
1208
# TODO: Take a revision or remote path and list that tree instead.
1210
takes_options = ['verbose', 'revision',
1211
Option('non-recursive',
1212
help='don\'t recurse into sub-directories'),
1214
help='Print all paths from the root of the branch.'),
1215
Option('unknown', help='Print unknown files'),
1216
Option('versioned', help='Print versioned files'),
1217
Option('ignored', help='Print ignored files'),
1219
Option('null', help='Null separate the files'),
1222
def run(self, revision=None, verbose=False,
1223
non_recursive=False, from_root=False,
1224
unknown=False, versioned=False, ignored=False,
1227
if verbose and null:
1228
raise BzrCommandError('Cannot set both --verbose and --null')
1229
all = not (unknown or versioned or ignored)
1231
selection = {'I':ignored, '?':unknown, 'V':versioned}
1233
tree, relpath = WorkingTree.open_containing(u'.')
1238
if revision is not None:
1239
tree = tree.branch.repository.revision_tree(
1240
revision[0].in_history(tree.branch).rev_id)
1241
for fp, fc, kind, fid, entry in tree.list_files():
1242
if fp.startswith(relpath):
1243
fp = fp[len(relpath):]
1244
if non_recursive and '/' in fp:
1246
if not all and not selection[fc]:
1249
kindch = entry.kind_character()
1250
print '%-8s %s%s' % (fc, fp, kindch)
1252
sys.stdout.write(fp)
1253
sys.stdout.write('\0')
1259
class cmd_unknowns(Command):
1260
"""List unknown files."""
1263
from bzrlib.osutils import quotefn
1264
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1268
class cmd_ignore(Command):
1269
"""Ignore a command or pattern.
1271
To remove patterns from the ignore list, edit the .bzrignore file.
1273
If the pattern contains a slash, it is compared to the whole path
1274
from the branch root. Otherwise, it is compared to only the last
1275
component of the path. To match a file only in the root directory,
1278
Ignore patterns are case-insensitive on case-insensitive systems.
1280
Note: wildcards must be quoted from the shell on Unix.
1283
bzr ignore ./Makefile
1284
bzr ignore '*.class'
1286
# TODO: Complain if the filename is absolute
1287
takes_args = ['name_pattern']
1289
def run(self, name_pattern):
1290
from bzrlib.atomicfile import AtomicFile
1293
tree, relpath = WorkingTree.open_containing(u'.')
1294
ifn = tree.abspath('.bzrignore')
1296
if os.path.exists(ifn):
1299
igns = f.read().decode('utf-8')
1305
# TODO: If the file already uses crlf-style termination, maybe
1306
# we should use that for the newly added lines?
1308
if igns and igns[-1] != '\n':
1310
igns += name_pattern + '\n'
1313
f = AtomicFile(ifn, 'wt')
1314
f.write(igns.encode('utf-8'))
1319
inv = tree.inventory
1320
if inv.path2id('.bzrignore'):
1321
mutter('.bzrignore is already versioned')
1323
mutter('need to make new .bzrignore file versioned')
1324
tree.add(['.bzrignore'])
1327
class cmd_ignored(Command):
1328
"""List ignored files and the patterns that matched them.
1330
See also: bzr ignore"""
1333
tree = WorkingTree.open_containing(u'.')[0]
1334
for path, file_class, kind, file_id, entry in tree.list_files():
1335
if file_class != 'I':
1337
## XXX: Slightly inefficient since this was already calculated
1338
pat = tree.is_ignored(path)
1339
print '%-50s %s' % (path, pat)
1342
class cmd_lookup_revision(Command):
1343
"""Lookup the revision-id from a revision-number
1346
bzr lookup-revision 33
1349
takes_args = ['revno']
1352
def run(self, revno):
1356
raise BzrCommandError("not a valid revision-number: %r" % revno)
1358
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1361
class cmd_export(Command):
1362
"""Export past revision to destination directory.
1364
If no revision is specified this exports the last committed revision.
1366
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1367
given, try to find the format with the extension. If no extension
1368
is found exports to a directory (equivalent to --format=dir).
1370
Root may be the top directory for tar, tgz and tbz2 formats. If none
1371
is given, the top directory will be the root name of the file.
1373
Note: export of tree with non-ascii filenames to zip is not supported.
1375
Supported formats Autodetected by extension
1376
----------------- -------------------------
1379
tbz2 .tar.bz2, .tbz2
1383
takes_args = ['dest']
1384
takes_options = ['revision', 'format', 'root']
1385
def run(self, dest, revision=None, format=None, root=None):
1387
from bzrlib.export import export
1388
tree = WorkingTree.open_containing(u'.')[0]
1390
if revision is None:
1391
# should be tree.last_revision FIXME
1392
rev_id = b.last_revision()
1394
if len(revision) != 1:
1395
raise BzrError('bzr export --revision takes exactly 1 argument')
1396
rev_id = revision[0].in_history(b).rev_id
1397
t = b.repository.revision_tree(rev_id)
1399
export(t, dest, format, root)
1400
except errors.NoSuchExportFormat, e:
1401
raise BzrCommandError('Unsupported export format: %s' % e.format)
1404
class cmd_cat(Command):
1405
"""Write a file's text from a previous revision."""
1407
takes_options = ['revision']
1408
takes_args = ['filename']
1411
def run(self, filename, revision=None):
1412
if revision is not None and len(revision) != 1:
1413
raise BzrCommandError("bzr cat --revision takes exactly one number")
1416
tree, relpath = WorkingTree.open_containing(filename)
1418
except NotBranchError:
1422
b, relpath = Branch.open_containing(filename)
1423
if revision is None:
1424
revision_id = b.last_revision()
1426
revision_id = revision[0].in_history(b).rev_id
1427
b.print_file(relpath, revision_id)
1430
class cmd_local_time_offset(Command):
1431
"""Show the offset in seconds from GMT to local time."""
1435
print bzrlib.osutils.local_time_offset()
1439
class cmd_commit(Command):
1440
"""Commit changes into a new revision.
1442
If no arguments are given, the entire tree is committed.
1444
If selected files are specified, only changes to those files are
1445
committed. If a directory is specified then the directory and everything
1446
within it is committed.
1448
A selected-file commit may fail in some cases where the committed
1449
tree would be invalid, such as trying to commit a file in a
1450
newly-added directory that is not itself committed.
1452
# TODO: Run hooks on tree to-be-committed, and after commit.
1454
# TODO: Strict commit that fails if there are deleted files.
1455
# (what does "deleted files" mean ??)
1457
# TODO: Give better message for -s, --summary, used by tla people
1459
# XXX: verbose currently does nothing
1461
takes_args = ['selected*']
1462
takes_options = ['message', 'verbose',
1464
help='commit even if nothing has changed'),
1465
Option('file', type=str,
1467
help='file containing commit message'),
1469
help="refuse to commit if there are unknown "
1470
"files in the working tree."),
1472
help="perform a local only commit in a bound "
1473
"branch. Such commits are not pushed to "
1474
"the master branch until a normal commit "
1478
aliases = ['ci', 'checkin']
1480
def run(self, message=None, file=None, verbose=True, selected_list=None,
1481
unchanged=False, strict=False, local=False):
1482
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1483
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1485
from bzrlib.msgeditor import edit_commit_message, \
1486
make_commit_message_template
1487
from tempfile import TemporaryFile
1490
# TODO: Need a blackbox test for invoking the external editor; may be
1491
# slightly problematic to run this cross-platform.
1493
# TODO: do more checks that the commit will succeed before
1494
# spending the user's valuable time typing a commit message.
1496
# TODO: if the commit *does* happen to fail, then save the commit
1497
# message to a temporary file where it can be recovered
1498
tree, selected_list = tree_files(selected_list)
1499
if local and not tree.branch.get_bound_location():
1500
raise errors.LocalRequiresBoundBranch()
1501
if message is None and not file:
1502
template = make_commit_message_template(tree, selected_list)
1503
message = edit_commit_message(template)
1505
raise BzrCommandError("please specify a commit message"
1506
" with either --message or --file")
1507
elif message and file:
1508
raise BzrCommandError("please specify either --message or --file")
1512
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1515
raise BzrCommandError("empty commit message specified")
1518
reporter = ReportCommitToLog()
1520
reporter = NullCommitReporter()
1523
tree.commit(message, specific_files=selected_list,
1524
allow_pointless=unchanged, strict=strict, local=local,
1526
except PointlessCommit:
1527
# FIXME: This should really happen before the file is read in;
1528
# perhaps prepare the commit; get the message; then actually commit
1529
raise BzrCommandError("no changes to commit",
1530
["use --unchanged to commit anyhow"])
1531
except ConflictsInTree:
1532
raise BzrCommandError("Conflicts detected in working tree. "
1533
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1534
except StrictCommitFailed:
1535
raise BzrCommandError("Commit refused because there are unknown "
1536
"files in the working tree.")
1537
except errors.BoundBranchOutOfDate, e:
1538
raise BzrCommandError(str(e)
1539
+ ' Either unbind, update, or'
1540
' pass --local to commit.')
1543
class cmd_check(Command):
1544
"""Validate consistency of branch history.
1546
This command checks various invariants about the branch storage to
1547
detect data corruption or bzr bugs.
1549
takes_args = ['branch?']
1550
takes_options = ['verbose']
1552
def run(self, branch=None, verbose=False):
1553
from bzrlib.check import check
1555
tree = WorkingTree.open_containing()[0]
1556
branch = tree.branch
1558
branch = Branch.open(branch)
1559
check(branch, verbose)
1562
class cmd_scan_cache(Command):
1565
from bzrlib.hashcache import HashCache
1571
print '%6d stats' % c.stat_count
1572
print '%6d in hashcache' % len(c._cache)
1573
print '%6d files removed from cache' % c.removed_count
1574
print '%6d hashes updated' % c.update_count
1575
print '%6d files changed too recently to cache' % c.danger_count
1581
class cmd_upgrade(Command):
1582
"""Upgrade branch storage to current format.
1584
The check command or bzr developers may sometimes advise you to run
1585
this command. When the default format has changed you may also be warned
1586
during other operations to upgrade.
1588
takes_args = ['url?']
1591
help='Upgrade to a specific format rather than the'
1592
' current default format. Currently this'
1593
' option only accepts "metadir" and "knit".'
1594
' WARNING: the knit format is currently'
1595
' unstable and only for experimental use.',
1596
type=get_format_type),
1600
def run(self, url='.', format=None):
1601
from bzrlib.upgrade import upgrade
1602
upgrade(url, format)
1605
class cmd_whoami(Command):
1606
"""Show bzr user id."""
1607
takes_options = ['email']
1610
def run(self, email=False):
1612
b = WorkingTree.open_containing(u'.')[0].branch
1613
config = bzrlib.config.BranchConfig(b)
1614
except NotBranchError:
1615
config = bzrlib.config.GlobalConfig()
1618
print config.user_email()
1620
print config.username()
1623
class cmd_nick(Command):
1624
"""Print or set the branch nickname.
1626
If unset, the tree root directory name is used as the nickname
1627
To print the current nickname, execute with no argument.
1629
takes_args = ['nickname?']
1630
def run(self, nickname=None):
1631
branch = Branch.open_containing(u'.')[0]
1632
if nickname is None:
1633
self.printme(branch)
1635
branch.nick = nickname
1638
def printme(self, branch):
1642
class cmd_selftest(Command):
1643
"""Run internal test suite.
1645
This creates temporary test directories in the working directory,
1646
but not existing data is affected. These directories are deleted
1647
if the tests pass, or left behind to help in debugging if they
1648
fail and --keep-output is specified.
1650
If arguments are given, they are regular expressions that say
1651
which tests should run.
1653
If the global option '--no-plugins' is given, plugins are not loaded
1654
before running the selftests. This has two effects: features provided or
1655
modified by plugins will not be tested, and tests provided by plugins will
1660
bzr --no-plugins selftest -v
1662
# TODO: --list should give a list of all available tests
1664
# NB: this is used from the class without creating an instance, which is
1665
# why it does not have a self parameter.
1666
def get_transport_type(typestring):
1667
"""Parse and return a transport specifier."""
1668
if typestring == "sftp":
1669
from bzrlib.transport.sftp import SFTPAbsoluteServer
1670
return SFTPAbsoluteServer
1671
if typestring == "memory":
1672
from bzrlib.transport.memory import MemoryServer
1674
if typestring == "fakenfs":
1675
from bzrlib.transport.fakenfs import FakeNFSServer
1676
return FakeNFSServer
1677
msg = "No known transport type %s. Supported types are: sftp\n" %\
1679
raise BzrCommandError(msg)
1682
takes_args = ['testspecs*']
1683
takes_options = ['verbose',
1684
Option('one', help='stop when one test fails'),
1685
Option('keep-output',
1686
help='keep output directories when tests fail'),
1688
help='Use a different transport by default '
1689
'throughout the test suite.',
1690
type=get_transport_type),
1693
def run(self, testspecs_list=None, verbose=False, one=False,
1694
keep_output=False, transport=None):
1696
from bzrlib.tests import selftest
1697
# we don't want progress meters from the tests to go to the
1698
# real output; and we don't want log messages cluttering up
1700
save_ui = bzrlib.ui.ui_factory
1701
bzrlib.trace.info('running tests...')
1703
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1704
if testspecs_list is not None:
1705
pattern = '|'.join(testspecs_list)
1708
result = selftest(verbose=verbose,
1710
stop_on_failure=one,
1711
keep_output=keep_output,
1712
transport=transport)
1714
bzrlib.trace.info('tests passed')
1716
bzrlib.trace.info('tests failed')
1717
return int(not result)
1719
bzrlib.ui.ui_factory = save_ui
1722
def _get_bzr_branch():
1723
"""If bzr is run from a branch, return Branch or None"""
1724
import bzrlib.errors
1725
from bzrlib.branch import Branch
1726
from bzrlib.osutils import abspath
1727
from os.path import dirname
1730
branch = Branch.open(dirname(abspath(dirname(__file__))))
1732
except bzrlib.errors.BzrError:
1737
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1738
# is bzrlib itself in a branch?
1739
branch = _get_bzr_branch()
1741
rh = branch.revision_history()
1743
print " bzr checkout, revision %d" % (revno,)
1744
print " nick: %s" % (branch.nick,)
1746
print " revid: %s" % (rh[-1],)
1747
print bzrlib.__copyright__
1748
print "http://bazaar-ng.org/"
1750
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1751
print "you may use, modify and redistribute it under the terms of the GNU"
1752
print "General Public License version 2 or later."
1755
class cmd_version(Command):
1756
"""Show version of bzr."""
1761
class cmd_rocks(Command):
1762
"""Statement of optimism."""
1766
print "it sure does!"
1769
class cmd_find_merge_base(Command):
1770
"""Find and print a base revision for merging two branches.
1772
# TODO: Options to specify revisions on either side, as if
1773
# merging only part of the history.
1774
takes_args = ['branch', 'other']
1778
def run(self, branch, other):
1779
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1781
branch1 = Branch.open_containing(branch)[0]
1782
branch2 = Branch.open_containing(other)[0]
1784
history_1 = branch1.revision_history()
1785
history_2 = branch2.revision_history()
1787
last1 = branch1.last_revision()
1788
last2 = branch2.last_revision()
1790
source = MultipleRevisionSources(branch1.repository,
1793
base_rev_id = common_ancestor(last1, last2, source)
1795
print 'merge base is revision %s' % base_rev_id
1799
if base_revno is None:
1800
raise bzrlib.errors.UnrelatedBranches()
1802
print ' r%-6d in %s' % (base_revno, branch)
1804
other_revno = branch2.revision_id_to_revno(base_revid)
1806
print ' r%-6d in %s' % (other_revno, other)
1810
class cmd_merge(Command):
1811
"""Perform a three-way merge.
1813
The branch is the branch you will merge from. By default, it will
1814
merge the latest revision. If you specify a revision, that
1815
revision will be merged. If you specify two revisions, the first
1816
will be used as a BASE, and the second one as OTHER. Revision
1817
numbers are always relative to the specified branch.
1819
By default, bzr will try to merge in all new work from the other
1820
branch, automatically determining an appropriate base. If this
1821
fails, you may need to give an explicit base.
1823
Merge will do its best to combine the changes in two branches, but there
1824
are some kinds of problems only a human can fix. When it encounters those,
1825
it will mark a conflict. A conflict means that you need to fix something,
1826
before you should commit.
1828
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
1832
To merge the latest revision from bzr.dev
1833
bzr merge ../bzr.dev
1835
To merge changes up to and including revision 82 from bzr.dev
1836
bzr merge -r 82 ../bzr.dev
1838
To merge the changes introduced by 82, without previous changes:
1839
bzr merge -r 81..82 ../bzr.dev
1841
merge refuses to run if there are any uncommitted changes, unless
1844
takes_args = ['branch?']
1845
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1846
Option('show-base', help="Show base revision text in "
1849
def run(self, branch=None, revision=None, force=False, merge_type=None,
1850
show_base=False, reprocess=False):
1851
if merge_type is None:
1852
merge_type = Merge3Merger
1854
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1856
raise BzrCommandError("No merge location known or specified.")
1858
print "Using saved location: %s" % branch
1859
if revision is None or len(revision) < 1:
1861
other = [branch, -1]
1862
other_branch, path = Branch.open_containing(branch)
1864
if len(revision) == 1:
1866
other_branch, path = Branch.open_containing(branch)
1867
revno = revision[0].in_history(other_branch).revno
1868
other = [branch, revno]
1870
assert len(revision) == 2
1871
if None in revision:
1872
raise BzrCommandError(
1873
"Merge doesn't permit that revision specifier.")
1874
b, path = Branch.open_containing(branch)
1876
base = [branch, revision[0].in_history(b).revno]
1877
other = [branch, revision[1].in_history(b).revno]
1879
interesting_files = [path]
1881
interesting_files = None
1882
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1885
conflict_count = merge(other, base, check_clean=(not force),
1886
merge_type=merge_type,
1887
reprocess=reprocess,
1888
show_base=show_base,
1889
pb=pb, file_list=interesting_files)
1892
if conflict_count != 0:
1896
except bzrlib.errors.AmbiguousBase, e:
1897
m = ("sorry, bzr can't determine the right merge base yet\n"
1898
"candidates are:\n "
1899
+ "\n ".join(e.bases)
1901
"please specify an explicit base with -r,\n"
1902
"and (if you want) report this to the bzr developers\n")
1906
class cmd_remerge(Command):
1909
takes_args = ['file*']
1910
takes_options = ['merge-type', 'reprocess',
1911
Option('show-base', help="Show base revision text in "
1914
def run(self, file_list=None, merge_type=None, show_base=False,
1916
from bzrlib.merge import merge_inner, transform_tree
1917
if merge_type is None:
1918
merge_type = Merge3Merger
1919
tree, file_list = tree_files(file_list)
1922
pending_merges = tree.pending_merges()
1923
if len(pending_merges) != 1:
1924
raise BzrCommandError("Sorry, remerge only works after normal"
1925
+ " merges. Not cherrypicking or"
1927
repository = tree.branch.repository
1928
base_revision = common_ancestor(tree.branch.last_revision(),
1929
pending_merges[0], repository)
1930
base_tree = repository.revision_tree(base_revision)
1931
other_tree = repository.revision_tree(pending_merges[0])
1932
interesting_ids = None
1933
if file_list is not None:
1934
interesting_ids = set()
1935
for filename in file_list:
1936
file_id = tree.path2id(filename)
1938
raise NotVersionedError(filename)
1939
interesting_ids.add(file_id)
1940
if tree.kind(file_id) != "directory":
1943
for name, ie in tree.inventory.iter_entries(file_id):
1944
interesting_ids.add(ie.file_id)
1945
transform_tree(tree, tree.basis_tree(), interesting_ids)
1946
if file_list is None:
1947
restore_files = list(tree.iter_conflicts())
1949
restore_files = file_list
1950
for filename in restore_files:
1952
restore(tree.abspath(filename))
1953
except NotConflicted:
1955
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1957
interesting_ids = interesting_ids,
1958
other_rev_id=pending_merges[0],
1959
merge_type=merge_type,
1960
show_base=show_base,
1961
reprocess=reprocess)
1969
class cmd_revert(Command):
1970
"""Reverse all changes since the last commit.
1972
Only versioned files are affected. Specify filenames to revert only
1973
those files. By default, any files that are changed will be backed up
1974
first. Backup files have a '~' appended to their name.
1976
takes_options = ['revision', 'no-backup']
1977
takes_args = ['file*']
1978
aliases = ['merge-revert']
1980
def run(self, revision=None, no_backup=False, file_list=None):
1981
from bzrlib.commands import parse_spec
1982
if file_list is not None:
1983
if len(file_list) == 0:
1984
raise BzrCommandError("No files specified")
1988
tree, file_list = tree_files(file_list)
1989
if revision is None:
1990
# FIXME should be tree.last_revision
1991
rev_id = tree.last_revision()
1992
elif len(revision) != 1:
1993
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1995
rev_id = revision[0].in_history(tree.branch).rev_id
1996
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1998
tree.revert(file_list,
1999
tree.branch.repository.revision_tree(rev_id),
2005
class cmd_assert_fail(Command):
2006
"""Test reporting of assertion failures"""
2009
assert False, "always fails"
2012
class cmd_help(Command):
2013
"""Show help on a command or other topic.
2015
For a list of all available commands, say 'bzr help commands'."""
2016
takes_options = [Option('long', 'show help on all commands')]
2017
takes_args = ['topic?']
2018
aliases = ['?', '--help', '-?', '-h']
2021
def run(self, topic=None, long=False):
2023
if topic is None and long:
2028
class cmd_shell_complete(Command):
2029
"""Show appropriate completions for context.
2031
For a list of all available commands, say 'bzr shell-complete'."""
2032
takes_args = ['context?']
2037
def run(self, context=None):
2038
import shellcomplete
2039
shellcomplete.shellcomplete(context)
2042
class cmd_fetch(Command):
2043
"""Copy in history from another branch but don't merge it.
2045
This is an internal method used for pull and merge."""
2047
takes_args = ['from_branch', 'to_branch']
2048
def run(self, from_branch, to_branch):
2049
from bzrlib.fetch import Fetcher
2050
from bzrlib.branch import Branch
2051
from_b = Branch.open(from_branch)
2052
to_b = Branch.open(to_branch)
2053
Fetcher(to_b, from_b)
2056
class cmd_missing(Command):
2057
"""Show unmerged/unpulled revisions between two branches.
2059
OTHER_BRANCH may be local or remote."""
2060
takes_args = ['other_branch?']
2061
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2063
'Display changes in the local branch only'),
2064
Option('theirs-only',
2065
'Display changes in the remote branch only'),
2074
def run(self, other_branch=None, reverse=False, mine_only=False,
2075
theirs_only=False, log_format=None, long=False, short=False, line=False,
2076
show_ids=False, verbose=False):
2077
from bzrlib.missing import find_unmerged, iter_log_data
2078
from bzrlib.log import log_formatter
2079
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2080
parent = local_branch.get_parent()
2081
if other_branch is None:
2082
other_branch = parent
2083
if other_branch is None:
2084
raise BzrCommandError("No missing location known or specified.")
2085
print "Using last location: " + local_branch.get_parent()
2086
remote_branch = bzrlib.branch.Branch.open(other_branch)
2087
local_branch.lock_write()
2088
if remote_branch.base == local_branch.base:
2089
remote_branch = local_branch
2091
remote_branch.lock_read()
2093
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2094
if (log_format == None):
2095
default = bzrlib.config.BranchConfig(local_branch).log_format()
2096
log_format = get_log_format(long=long, short=short, line=line, default=default)
2097
lf = log_formatter(log_format, sys.stdout,
2099
show_timezone='original')
2100
if reverse is False:
2101
local_extra.reverse()
2102
remote_extra.reverse()
2103
if local_extra and not theirs_only:
2104
print "You have %d extra revision(s):" % len(local_extra)
2105
for data in iter_log_data(local_extra, local_branch.repository,
2108
printed_local = True
2110
printed_local = False
2111
if remote_extra and not mine_only:
2112
if printed_local is True:
2114
print "You are missing %d revision(s):" % len(remote_extra)
2115
for data in iter_log_data(remote_extra, remote_branch.repository,
2118
if not remote_extra and not local_extra:
2120
print "Branches are up to date."
2123
if parent is None and other_branch is not None:
2124
local_branch.set_parent(other_branch)
2127
local_branch.unlock()
2129
remote_branch.unlock()
2132
class cmd_plugins(Command):
2137
import bzrlib.plugin
2138
from inspect import getdoc
2139
for name, plugin in bzrlib.plugin.all_plugins().items():
2140
if hasattr(plugin, '__path__'):
2141
print plugin.__path__[0]
2142
elif hasattr(plugin, '__file__'):
2143
print plugin.__file__
2149
print '\t', d.split('\n')[0]
2152
class cmd_testament(Command):
2153
"""Show testament (signing-form) of a revision."""
2154
takes_options = ['revision', 'long']
2155
takes_args = ['branch?']
2157
def run(self, branch=u'.', revision=None, long=False):
2158
from bzrlib.testament import Testament
2159
b = WorkingTree.open_containing(branch)[0].branch
2162
if revision is None:
2163
rev_id = b.last_revision()
2165
rev_id = revision[0].in_history(b).rev_id
2166
t = Testament.from_revision(b.repository, rev_id)
2168
sys.stdout.writelines(t.as_text_lines())
2170
sys.stdout.write(t.as_short_text())
2175
class cmd_annotate(Command):
2176
"""Show the origin of each line in a file.
2178
This prints out the given file with an annotation on the left side
2179
indicating which revision, author and date introduced the change.
2181
If the origin is the same for a run of consecutive lines, it is
2182
shown only at the top, unless the --all option is given.
2184
# TODO: annotate directories; showing when each file was last changed
2185
# TODO: annotate a previous version of a file
2186
# TODO: if the working copy is modified, show annotations on that
2187
# with new uncommitted lines marked
2188
aliases = ['blame', 'praise']
2189
takes_args = ['filename']
2190
takes_options = [Option('all', help='show annotations on all lines'),
2191
Option('long', help='show date in annotations'),
2195
def run(self, filename, all=False, long=False):
2196
from bzrlib.annotate import annotate_file
2197
tree, relpath = WorkingTree.open_containing(filename)
2198
branch = tree.branch
2201
file_id = tree.inventory.path2id(relpath)
2202
tree = branch.repository.revision_tree(branch.last_revision())
2203
file_version = tree.inventory[file_id].revision
2204
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2209
class cmd_re_sign(Command):
2210
"""Create a digital signature for an existing revision."""
2211
# TODO be able to replace existing ones.
2213
hidden = True # is this right ?
2214
takes_args = ['revision_id*']
2215
takes_options = ['revision']
2217
def run(self, revision_id_list=None, revision=None):
2218
import bzrlib.config as config
2219
import bzrlib.gpg as gpg
2220
if revision_id_list is not None and revision is not None:
2221
raise BzrCommandError('You can only supply one of revision_id or --revision')
2222
if revision_id_list is None and revision is None:
2223
raise BzrCommandError('You must supply either --revision or a revision_id')
2224
b = WorkingTree.open_containing(u'.')[0].branch
2225
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2226
if revision_id_list is not None:
2227
for revision_id in revision_id_list:
2228
b.repository.sign_revision(revision_id, gpg_strategy)
2229
elif revision is not None:
2230
if len(revision) == 1:
2231
revno, rev_id = revision[0].in_history(b)
2232
b.repository.sign_revision(rev_id, gpg_strategy)
2233
elif len(revision) == 2:
2234
# are they both on rh- if so we can walk between them
2235
# might be nice to have a range helper for arbitrary
2236
# revision paths. hmm.
2237
from_revno, from_revid = revision[0].in_history(b)
2238
to_revno, to_revid = revision[1].in_history(b)
2239
if to_revid is None:
2240
to_revno = b.revno()
2241
if from_revno is None or to_revno is None:
2242
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2243
for revno in range(from_revno, to_revno + 1):
2244
b.repository.sign_revision(b.get_rev_id(revno),
2247
raise BzrCommandError('Please supply either one revision, or a range.')
2250
class cmd_bind(Command):
2251
"""Bind the current branch to a master branch.
2253
After binding, commits must succeed on the master branch
2254
before they are executed on the local one.
2257
takes_args = ['location']
2260
def run(self, location=None):
2261
b, relpath = Branch.open_containing(u'.')
2262
b_other = Branch.open(location)
2265
except DivergedBranches:
2266
raise BzrCommandError('These branches have diverged.'
2267
' Try merging, and then bind again.')
2270
class cmd_unbind(Command):
2271
"""Bind the current branch to its parent.
2273
After unbinding, the local branch is considered independent.
2280
b, relpath = Branch.open_containing(u'.')
2282
raise BzrCommandError('Local branch is not bound')
2285
class cmd_uncommit(bzrlib.commands.Command):
2286
"""Remove the last committed revision.
2288
By supplying the --all flag, it will not only remove the entry
2289
from revision_history, but also remove all of the entries in the
2292
--verbose will print out what is being removed.
2293
--dry-run will go through all the motions, but not actually
2296
In the future, uncommit will create a changeset, which can then
2300
# TODO: jam 20060108 Add an option to allow uncommit to remove
2301
# unreferenced information in 'branch-as-repostory' branches.
2302
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2303
# information in shared branches as well.
2304
takes_options = ['verbose', 'revision',
2305
Option('dry-run', help='Don\'t actually make changes'),
2306
Option('force', help='Say yes to all questions.')]
2307
takes_args = ['location?']
2310
def run(self, location=None,
2311
dry_run=False, verbose=False,
2312
revision=None, force=False):
2313
from bzrlib.branch import Branch
2314
from bzrlib.log import log_formatter
2316
from bzrlib.uncommit import uncommit
2318
if location is None:
2320
control, relpath = bzrdir.BzrDir.open_containing(location)
2322
tree = control.open_workingtree()
2324
except (errors.NoWorkingTree, errors.NotLocalUrl):
2326
b = control.open_branch()
2328
if revision is None:
2330
rev_id = b.last_revision()
2332
revno, rev_id = revision[0].in_history(b)
2334
print 'No revisions to uncommit.'
2336
for r in range(revno, b.revno()+1):
2337
rev_id = b.get_rev_id(r)
2338
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2339
lf.show(r, b.repository.get_revision(rev_id), None)
2342
print 'Dry-run, pretending to remove the above revisions.'
2344
val = raw_input('Press <enter> to continue')
2346
print 'The above revision(s) will be removed.'
2348
val = raw_input('Are you sure [y/N]? ')
2349
if val.lower() not in ('y', 'yes'):
2353
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2357
class cmd_break_lock(Command):
2358
"""Break a dead lock on a repository, branch or working directory.
2360
CAUTION: Locks should only be broken when you are sure that the process
2361
holding the lock has been stopped.
2366
takes_args = ['location']
2367
takes_options = [Option('show',
2368
help="just show information on the lock, " \
2371
def run(self, location, show=False):
2372
raise NotImplementedError("sorry, break-lock is not complete yet; "
2373
"you can remove the 'held' directory manually to break the lock")
2376
# command-line interpretation helper for merge-related commands
2377
def merge(other_revision, base_revision,
2378
check_clean=True, ignore_zero=False,
2379
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2380
file_list=None, show_base=False, reprocess=False,
2381
pb=DummyProgress()):
2382
"""Merge changes into a tree.
2385
list(path, revno) Base for three-way merge.
2386
If [None, None] then a base will be automatically determined.
2388
list(path, revno) Other revision for three-way merge.
2390
Directory to merge changes into; '.' by default.
2392
If true, this_dir must have no uncommitted changes before the
2394
ignore_zero - If true, suppress the "zero conflicts" message when
2395
there are no conflicts; should be set when doing something we expect
2396
to complete perfectly.
2397
file_list - If supplied, merge only changes to selected files.
2399
All available ancestors of other_revision and base_revision are
2400
automatically pulled into the branch.
2402
The revno may be -1 to indicate the last revision on the branch, which is
2405
This function is intended for use from the command line; programmatic
2406
clients might prefer to call merge.merge_inner(), which has less magic
2409
from bzrlib.merge import Merger
2410
if this_dir is None:
2412
this_tree = WorkingTree.open_containing(this_dir)[0]
2413
if show_base and not merge_type is Merge3Merger:
2414
raise BzrCommandError("Show-base is not supported for this merge"
2415
" type. %s" % merge_type)
2416
if reprocess and not merge_type is Merge3Merger:
2417
raise BzrCommandError("Reprocess is not supported for this merge"
2418
" type. %s" % merge_type)
2419
if reprocess and show_base:
2420
raise BzrCommandError("Cannot reprocess and show base.")
2422
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2423
merger.pp = ProgressPhase("Merge phase", 5, pb)
2424
merger.pp.next_phase()
2425
merger.check_basis(check_clean)
2426
merger.set_other(other_revision)
2427
merger.pp.next_phase()
2428
merger.set_base(base_revision)
2429
if merger.base_rev_id == merger.other_rev_id:
2430
note('Nothing to do.')
2432
merger.backup_files = backup_files
2433
merger.merge_type = merge_type
2434
merger.set_interesting_files(file_list)
2435
merger.show_base = show_base
2436
merger.reprocess = reprocess
2437
conflicts = merger.do_merge()
2438
if file_list is None:
2439
merger.set_pending()
2445
# these get imported and then picked up by the scan for cmd_*
2446
# TODO: Some more consistent way to split command definitions across files;
2447
# we do need to load at least some information about them to know of
2448
# aliases. ideally we would avoid loading the implementation until the
2449
# details were needed.
2450
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2451
from bzrlib.sign_my_commits import cmd_sign_my_commits
2452
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2453
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
