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 hold branches.
902
New branches created under the repository directory will store their revisions
903
in the repository, not in the branch directory, if the branch format supports
908
bzr init --format=metadir repo/trunk
912
takes_args = ["location"]
913
takes_options = [Option('format',
914
help='Use a specific format rather than the'
915
' current default format. Currently this'
916
' option only accepts "metadir" and "knit"'
917
' WARNING: the knit format is currently unstable'
918
' and only for experimental use.',
919
type=get_format_type),
921
help='Allows branches in repository to have'
923
aliases = ["init-repo"]
924
def run(self, location, format=None, trees=False):
925
from bzrlib.bzrdir import BzrDirMetaFormat1
926
from bzrlib.transport import get_transport
928
format = BzrDirMetaFormat1()
929
transport = get_transport(location)
930
if not transport.has('.'):
932
newdir = format.initialize_on_transport(transport)
933
repo = newdir.create_repository(shared=True)
934
repo.set_make_working_trees(trees)
937
class cmd_diff(Command):
938
"""Show differences in working tree.
940
If files are listed, only the changes in those files are listed.
941
Otherwise, all changes for the tree are listed.
948
# TODO: Allow diff across branches.
949
# TODO: Option to use external diff command; could be GNU diff, wdiff,
950
# or a graphical diff.
952
# TODO: Python difflib is not exactly the same as unidiff; should
953
# either fix it up or prefer to use an external diff.
955
# TODO: If a directory is given, diff everything under that.
957
# TODO: Selected-file diff is inefficient and doesn't show you
960
# TODO: This probably handles non-Unix newlines poorly.
962
takes_args = ['file*']
963
takes_options = ['revision', 'diff-options']
964
aliases = ['di', 'dif']
967
def run(self, revision=None, file_list=None, diff_options=None):
968
from bzrlib.diff import diff_cmd_helper, show_diff_trees
970
tree1, file_list = internal_tree_files(file_list)
974
except FileInWrongBranch:
975
if len(file_list) != 2:
976
raise BzrCommandError("Files are in different branches")
978
tree1, file1 = WorkingTree.open_containing(file_list[0])
979
tree2, file2 = WorkingTree.open_containing(file_list[1])
980
if file1 != "" or file2 != "":
981
# FIXME diff those two files. rbc 20051123
982
raise BzrCommandError("Files are in different branches")
984
if revision is not None:
985
if tree2 is not None:
986
raise BzrCommandError("Can't specify -r with two branches")
987
if (len(revision) == 1) or (revision[1].spec is None):
988
return diff_cmd_helper(tree1, file_list, diff_options,
990
elif len(revision) == 2:
991
return diff_cmd_helper(tree1, file_list, diff_options,
992
revision[0], revision[1])
994
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
996
if tree2 is not None:
997
return show_diff_trees(tree1, tree2, sys.stdout,
998
specific_files=file_list,
999
external_diff_options=diff_options)
1001
return diff_cmd_helper(tree1, file_list, diff_options)
1004
class cmd_deleted(Command):
1005
"""List files deleted in the working tree.
1007
# TODO: Show files deleted since a previous revision, or
1008
# between two revisions.
1009
# TODO: Much more efficient way to do this: read in new
1010
# directories with readdir, rather than stating each one. Same
1011
# level of effort but possibly much less IO. (Or possibly not,
1012
# if the directories are very large...)
1014
def run(self, show_ids=False):
1015
tree = WorkingTree.open_containing(u'.')[0]
1016
old = tree.basis_tree()
1017
for path, ie in old.inventory.iter_entries():
1018
if not tree.has_id(ie.file_id):
1020
print '%-50s %s' % (path, ie.file_id)
1025
class cmd_modified(Command):
1026
"""List files modified in working tree."""
1030
from bzrlib.delta import compare_trees
1032
tree = WorkingTree.open_containing(u'.')[0]
1033
td = compare_trees(tree.basis_tree(), tree)
1035
for path, id, kind, text_modified, meta_modified in td.modified:
1040
class cmd_added(Command):
1041
"""List files added in working tree."""
1045
wt = WorkingTree.open_containing(u'.')[0]
1046
basis_inv = wt.basis_tree().inventory
1049
if file_id in basis_inv:
1051
path = inv.id2path(file_id)
1052
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1058
class cmd_root(Command):
1059
"""Show the tree root directory.
1061
The root is the nearest enclosing directory with a .bzr control
1063
takes_args = ['filename?']
1065
def run(self, filename=None):
1066
"""Print the branch root."""
1067
tree = WorkingTree.open_containing(filename)[0]
1071
class cmd_log(Command):
1072
"""Show log of a branch, file, or directory.
1074
By default show the log of the branch containing the working directory.
1076
To request a range of logs, you can use the command -r begin..end
1077
-r revision requests a specific revision, -r ..end or -r begin.. are
1083
bzr log -r -10.. http://server/branch
1086
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1088
takes_args = ['location?']
1089
takes_options = [Option('forward',
1090
help='show from oldest to newest'),
1093
help='show files changed in each revision'),
1094
'show-ids', 'revision',
1098
help='show revisions whose message matches this regexp',
1103
def run(self, location=None, timezone='original',
1113
from bzrlib.log import log_formatter, show_log
1115
assert message is None or isinstance(message, basestring), \
1116
"invalid message argument %r" % message
1117
direction = (forward and 'forward') or 'reverse'
1122
# find the file id to log:
1124
dir, fp = bzrdir.BzrDir.open_containing(location)
1125
b = dir.open_branch()
1129
inv = dir.open_workingtree().inventory
1130
except (errors.NotBranchError, errors.NotLocalUrl):
1131
# either no tree, or is remote.
1132
inv = b.basis_tree().inventory
1133
file_id = inv.path2id(fp)
1136
# FIXME ? log the current subdir only RBC 20060203
1137
dir, relpath = bzrdir.BzrDir.open_containing('.')
1138
b = dir.open_branch()
1140
if revision is None:
1143
elif len(revision) == 1:
1144
rev1 = rev2 = revision[0].in_history(b).revno
1145
elif len(revision) == 2:
1146
if revision[0].spec is None:
1147
# missing begin-range means first revision
1150
rev1 = revision[0].in_history(b).revno
1152
if revision[1].spec is None:
1153
# missing end-range means last known revision
1156
rev2 = revision[1].in_history(b).revno
1158
raise BzrCommandError('bzr log --revision takes one or two values.')
1160
# By this point, the revision numbers are converted to the +ve
1161
# form if they were supplied in the -ve form, so we can do
1162
# this comparison in relative safety
1164
(rev2, rev1) = (rev1, rev2)
1166
mutter('encoding log as %r', bzrlib.user_encoding)
1168
# use 'replace' so that we don't abort if trying to write out
1169
# in e.g. the default C locale.
1170
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1172
if (log_format == None):
1173
default = bzrlib.config.BranchConfig(b).log_format()
1174
log_format = get_log_format(long=long, short=short, line=line, default=default)
1176
lf = log_formatter(log_format,
1179
show_timezone=timezone)
1185
direction=direction,
1186
start_revision=rev1,
1191
def get_log_format(long=False, short=False, line=False, default='long'):
1192
log_format = default
1196
log_format = 'short'
1202
class cmd_touching_revisions(Command):
1203
"""Return revision-ids which affected a particular file.
1205
A more user-friendly interface is "bzr log FILE"."""
1207
takes_args = ["filename"]
1209
def run(self, filename):
1210
tree, relpath = WorkingTree.open_containing(filename)
1212
inv = tree.read_working_inventory()
1213
file_id = inv.path2id(relpath)
1214
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1215
print "%6d %s" % (revno, what)
1218
class cmd_ls(Command):
1219
"""List files in a tree.
1221
# TODO: Take a revision or remote path and list that tree instead.
1223
takes_options = ['verbose', 'revision',
1224
Option('non-recursive',
1225
help='don\'t recurse into sub-directories'),
1227
help='Print all paths from the root of the branch.'),
1228
Option('unknown', help='Print unknown files'),
1229
Option('versioned', help='Print versioned files'),
1230
Option('ignored', help='Print ignored files'),
1232
Option('null', help='Null separate the files'),
1235
def run(self, revision=None, verbose=False,
1236
non_recursive=False, from_root=False,
1237
unknown=False, versioned=False, ignored=False,
1240
if verbose and null:
1241
raise BzrCommandError('Cannot set both --verbose and --null')
1242
all = not (unknown or versioned or ignored)
1244
selection = {'I':ignored, '?':unknown, 'V':versioned}
1246
tree, relpath = WorkingTree.open_containing(u'.')
1251
if revision is not None:
1252
tree = tree.branch.repository.revision_tree(
1253
revision[0].in_history(tree.branch).rev_id)
1254
for fp, fc, kind, fid, entry in tree.list_files():
1255
if fp.startswith(relpath):
1256
fp = fp[len(relpath):]
1257
if non_recursive and '/' in fp:
1259
if not all and not selection[fc]:
1262
kindch = entry.kind_character()
1263
print '%-8s %s%s' % (fc, fp, kindch)
1265
sys.stdout.write(fp)
1266
sys.stdout.write('\0')
1272
class cmd_unknowns(Command):
1273
"""List unknown files."""
1276
from bzrlib.osutils import quotefn
1277
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1281
class cmd_ignore(Command):
1282
"""Ignore a command or pattern.
1284
To remove patterns from the ignore list, edit the .bzrignore file.
1286
If the pattern contains a slash, it is compared to the whole path
1287
from the branch root. Otherwise, it is compared to only the last
1288
component of the path. To match a file only in the root directory,
1291
Ignore patterns are case-insensitive on case-insensitive systems.
1293
Note: wildcards must be quoted from the shell on Unix.
1296
bzr ignore ./Makefile
1297
bzr ignore '*.class'
1299
# TODO: Complain if the filename is absolute
1300
takes_args = ['name_pattern']
1302
def run(self, name_pattern):
1303
from bzrlib.atomicfile import AtomicFile
1306
tree, relpath = WorkingTree.open_containing(u'.')
1307
ifn = tree.abspath('.bzrignore')
1309
if os.path.exists(ifn):
1312
igns = f.read().decode('utf-8')
1318
# TODO: If the file already uses crlf-style termination, maybe
1319
# we should use that for the newly added lines?
1321
if igns and igns[-1] != '\n':
1323
igns += name_pattern + '\n'
1326
f = AtomicFile(ifn, 'wt')
1327
f.write(igns.encode('utf-8'))
1332
inv = tree.inventory
1333
if inv.path2id('.bzrignore'):
1334
mutter('.bzrignore is already versioned')
1336
mutter('need to make new .bzrignore file versioned')
1337
tree.add(['.bzrignore'])
1340
class cmd_ignored(Command):
1341
"""List ignored files and the patterns that matched them.
1343
See also: bzr ignore"""
1346
tree = WorkingTree.open_containing(u'.')[0]
1347
for path, file_class, kind, file_id, entry in tree.list_files():
1348
if file_class != 'I':
1350
## XXX: Slightly inefficient since this was already calculated
1351
pat = tree.is_ignored(path)
1352
print '%-50s %s' % (path, pat)
1355
class cmd_lookup_revision(Command):
1356
"""Lookup the revision-id from a revision-number
1359
bzr lookup-revision 33
1362
takes_args = ['revno']
1365
def run(self, revno):
1369
raise BzrCommandError("not a valid revision-number: %r" % revno)
1371
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1374
class cmd_export(Command):
1375
"""Export past revision to destination directory.
1377
If no revision is specified this exports the last committed revision.
1379
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1380
given, try to find the format with the extension. If no extension
1381
is found exports to a directory (equivalent to --format=dir).
1383
Root may be the top directory for tar, tgz and tbz2 formats. If none
1384
is given, the top directory will be the root name of the file.
1386
Note: export of tree with non-ascii filenames to zip is not supported.
1388
Supported formats Autodetected by extension
1389
----------------- -------------------------
1392
tbz2 .tar.bz2, .tbz2
1396
takes_args = ['dest']
1397
takes_options = ['revision', 'format', 'root']
1398
def run(self, dest, revision=None, format=None, root=None):
1400
from bzrlib.export import export
1401
tree = WorkingTree.open_containing(u'.')[0]
1403
if revision is None:
1404
# should be tree.last_revision FIXME
1405
rev_id = b.last_revision()
1407
if len(revision) != 1:
1408
raise BzrError('bzr export --revision takes exactly 1 argument')
1409
rev_id = revision[0].in_history(b).rev_id
1410
t = b.repository.revision_tree(rev_id)
1412
export(t, dest, format, root)
1413
except errors.NoSuchExportFormat, e:
1414
raise BzrCommandError('Unsupported export format: %s' % e.format)
1417
class cmd_cat(Command):
1418
"""Write a file's text from a previous revision."""
1420
takes_options = ['revision']
1421
takes_args = ['filename']
1424
def run(self, filename, revision=None):
1425
if revision is not None and len(revision) != 1:
1426
raise BzrCommandError("bzr cat --revision takes exactly one number")
1429
tree, relpath = WorkingTree.open_containing(filename)
1431
except NotBranchError:
1435
b, relpath = Branch.open_containing(filename)
1436
if revision is None:
1437
revision_id = b.last_revision()
1439
revision_id = revision[0].in_history(b).rev_id
1440
b.print_file(relpath, revision_id)
1443
class cmd_local_time_offset(Command):
1444
"""Show the offset in seconds from GMT to local time."""
1448
print bzrlib.osutils.local_time_offset()
1452
class cmd_commit(Command):
1453
"""Commit changes into a new revision.
1455
If no arguments are given, the entire tree is committed.
1457
If selected files are specified, only changes to those files are
1458
committed. If a directory is specified then the directory and everything
1459
within it is committed.
1461
A selected-file commit may fail in some cases where the committed
1462
tree would be invalid, such as trying to commit a file in a
1463
newly-added directory that is not itself committed.
1465
# TODO: Run hooks on tree to-be-committed, and after commit.
1467
# TODO: Strict commit that fails if there are deleted files.
1468
# (what does "deleted files" mean ??)
1470
# TODO: Give better message for -s, --summary, used by tla people
1472
# XXX: verbose currently does nothing
1474
takes_args = ['selected*']
1475
takes_options = ['message', 'verbose',
1477
help='commit even if nothing has changed'),
1478
Option('file', type=str,
1480
help='file containing commit message'),
1482
help="refuse to commit if there are unknown "
1483
"files in the working tree."),
1485
help="perform a local only commit in a bound "
1486
"branch. Such commits are not pushed to "
1487
"the master branch until a normal commit "
1491
aliases = ['ci', 'checkin']
1493
def run(self, message=None, file=None, verbose=True, selected_list=None,
1494
unchanged=False, strict=False, local=False):
1495
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1496
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1498
from bzrlib.msgeditor import edit_commit_message, \
1499
make_commit_message_template
1500
from tempfile import TemporaryFile
1503
# TODO: Need a blackbox test for invoking the external editor; may be
1504
# slightly problematic to run this cross-platform.
1506
# TODO: do more checks that the commit will succeed before
1507
# spending the user's valuable time typing a commit message.
1509
# TODO: if the commit *does* happen to fail, then save the commit
1510
# message to a temporary file where it can be recovered
1511
tree, selected_list = tree_files(selected_list)
1512
if local and not tree.branch.get_bound_location():
1513
raise errors.LocalRequiresBoundBranch()
1514
if message is None and not file:
1515
template = make_commit_message_template(tree, selected_list)
1516
message = edit_commit_message(template)
1518
raise BzrCommandError("please specify a commit message"
1519
" with either --message or --file")
1520
elif message and file:
1521
raise BzrCommandError("please specify either --message or --file")
1525
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1528
raise BzrCommandError("empty commit message specified")
1531
reporter = ReportCommitToLog()
1533
reporter = NullCommitReporter()
1536
tree.commit(message, specific_files=selected_list,
1537
allow_pointless=unchanged, strict=strict, local=local,
1539
except PointlessCommit:
1540
# FIXME: This should really happen before the file is read in;
1541
# perhaps prepare the commit; get the message; then actually commit
1542
raise BzrCommandError("no changes to commit",
1543
["use --unchanged to commit anyhow"])
1544
except ConflictsInTree:
1545
raise BzrCommandError("Conflicts detected in working tree. "
1546
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1547
except StrictCommitFailed:
1548
raise BzrCommandError("Commit refused because there are unknown "
1549
"files in the working tree.")
1550
except errors.BoundBranchOutOfDate, e:
1551
raise BzrCommandError(str(e)
1552
+ ' Either unbind, update, or'
1553
' pass --local to commit.')
1556
class cmd_check(Command):
1557
"""Validate consistency of branch history.
1559
This command checks various invariants about the branch storage to
1560
detect data corruption or bzr bugs.
1562
takes_args = ['branch?']
1563
takes_options = ['verbose']
1565
def run(self, branch=None, verbose=False):
1566
from bzrlib.check import check
1568
tree = WorkingTree.open_containing()[0]
1569
branch = tree.branch
1571
branch = Branch.open(branch)
1572
check(branch, verbose)
1575
class cmd_scan_cache(Command):
1578
from bzrlib.hashcache import HashCache
1584
print '%6d stats' % c.stat_count
1585
print '%6d in hashcache' % len(c._cache)
1586
print '%6d files removed from cache' % c.removed_count
1587
print '%6d hashes updated' % c.update_count
1588
print '%6d files changed too recently to cache' % c.danger_count
1594
class cmd_upgrade(Command):
1595
"""Upgrade branch storage to current format.
1597
The check command or bzr developers may sometimes advise you to run
1598
this command. When the default format has changed you may also be warned
1599
during other operations to upgrade.
1601
takes_args = ['url?']
1604
help='Upgrade to a specific format rather than the'
1605
' current default format. Currently this'
1606
' option only accepts "metadir" and "knit".'
1607
' WARNING: the knit format is currently'
1608
' unstable and only for experimental use.',
1609
type=get_format_type),
1613
def run(self, url='.', format=None):
1614
from bzrlib.upgrade import upgrade
1615
upgrade(url, format)
1618
class cmd_whoami(Command):
1619
"""Show bzr user id."""
1620
takes_options = ['email']
1623
def run(self, email=False):
1625
b = WorkingTree.open_containing(u'.')[0].branch
1626
config = bzrlib.config.BranchConfig(b)
1627
except NotBranchError:
1628
config = bzrlib.config.GlobalConfig()
1631
print config.user_email()
1633
print config.username()
1636
class cmd_nick(Command):
1637
"""Print or set the branch nickname.
1639
If unset, the tree root directory name is used as the nickname
1640
To print the current nickname, execute with no argument.
1642
takes_args = ['nickname?']
1643
def run(self, nickname=None):
1644
branch = Branch.open_containing(u'.')[0]
1645
if nickname is None:
1646
self.printme(branch)
1648
branch.nick = nickname
1651
def printme(self, branch):
1655
class cmd_selftest(Command):
1656
"""Run internal test suite.
1658
This creates temporary test directories in the working directory,
1659
but not existing data is affected. These directories are deleted
1660
if the tests pass, or left behind to help in debugging if they
1661
fail and --keep-output is specified.
1663
If arguments are given, they are regular expressions that say
1664
which tests should run.
1666
If the global option '--no-plugins' is given, plugins are not loaded
1667
before running the selftests. This has two effects: features provided or
1668
modified by plugins will not be tested, and tests provided by plugins will
1673
bzr --no-plugins selftest -v
1675
# TODO: --list should give a list of all available tests
1677
# NB: this is used from the class without creating an instance, which is
1678
# why it does not have a self parameter.
1679
def get_transport_type(typestring):
1680
"""Parse and return a transport specifier."""
1681
if typestring == "sftp":
1682
from bzrlib.transport.sftp import SFTPAbsoluteServer
1683
return SFTPAbsoluteServer
1684
if typestring == "memory":
1685
from bzrlib.transport.memory import MemoryServer
1687
if typestring == "fakenfs":
1688
from bzrlib.transport.fakenfs import FakeNFSServer
1689
return FakeNFSServer
1690
msg = "No known transport type %s. Supported types are: sftp\n" %\
1692
raise BzrCommandError(msg)
1695
takes_args = ['testspecs*']
1696
takes_options = ['verbose',
1697
Option('one', help='stop when one test fails'),
1698
Option('keep-output',
1699
help='keep output directories when tests fail'),
1701
help='Use a different transport by default '
1702
'throughout the test suite.',
1703
type=get_transport_type),
1706
def run(self, testspecs_list=None, verbose=False, one=False,
1707
keep_output=False, transport=None):
1709
from bzrlib.tests import selftest
1710
# we don't want progress meters from the tests to go to the
1711
# real output; and we don't want log messages cluttering up
1713
save_ui = bzrlib.ui.ui_factory
1714
bzrlib.trace.info('running tests...')
1716
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1717
if testspecs_list is not None:
1718
pattern = '|'.join(testspecs_list)
1721
result = selftest(verbose=verbose,
1723
stop_on_failure=one,
1724
keep_output=keep_output,
1725
transport=transport)
1727
bzrlib.trace.info('tests passed')
1729
bzrlib.trace.info('tests failed')
1730
return int(not result)
1732
bzrlib.ui.ui_factory = save_ui
1735
def _get_bzr_branch():
1736
"""If bzr is run from a branch, return Branch or None"""
1737
import bzrlib.errors
1738
from bzrlib.branch import Branch
1739
from bzrlib.osutils import abspath
1740
from os.path import dirname
1743
branch = Branch.open(dirname(abspath(dirname(__file__))))
1745
except bzrlib.errors.BzrError:
1750
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1751
# is bzrlib itself in a branch?
1752
branch = _get_bzr_branch()
1754
rh = branch.revision_history()
1756
print " bzr checkout, revision %d" % (revno,)
1757
print " nick: %s" % (branch.nick,)
1759
print " revid: %s" % (rh[-1],)
1760
print bzrlib.__copyright__
1761
print "http://bazaar-ng.org/"
1763
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1764
print "you may use, modify and redistribute it under the terms of the GNU"
1765
print "General Public License version 2 or later."
1768
class cmd_version(Command):
1769
"""Show version of bzr."""
1774
class cmd_rocks(Command):
1775
"""Statement of optimism."""
1779
print "it sure does!"
1782
class cmd_find_merge_base(Command):
1783
"""Find and print a base revision for merging two branches.
1785
# TODO: Options to specify revisions on either side, as if
1786
# merging only part of the history.
1787
takes_args = ['branch', 'other']
1791
def run(self, branch, other):
1792
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1794
branch1 = Branch.open_containing(branch)[0]
1795
branch2 = Branch.open_containing(other)[0]
1797
history_1 = branch1.revision_history()
1798
history_2 = branch2.revision_history()
1800
last1 = branch1.last_revision()
1801
last2 = branch2.last_revision()
1803
source = MultipleRevisionSources(branch1.repository,
1806
base_rev_id = common_ancestor(last1, last2, source)
1808
print 'merge base is revision %s' % base_rev_id
1812
if base_revno is None:
1813
raise bzrlib.errors.UnrelatedBranches()
1815
print ' r%-6d in %s' % (base_revno, branch)
1817
other_revno = branch2.revision_id_to_revno(base_revid)
1819
print ' r%-6d in %s' % (other_revno, other)
1823
class cmd_merge(Command):
1824
"""Perform a three-way merge.
1826
The branch is the branch you will merge from. By default, it will
1827
merge the latest revision. If you specify a revision, that
1828
revision will be merged. If you specify two revisions, the first
1829
will be used as a BASE, and the second one as OTHER. Revision
1830
numbers are always relative to the specified branch.
1832
By default, bzr will try to merge in all new work from the other
1833
branch, automatically determining an appropriate base. If this
1834
fails, you may need to give an explicit base.
1836
Merge will do its best to combine the changes in two branches, but there
1837
are some kinds of problems only a human can fix. When it encounters those,
1838
it will mark a conflict. A conflict means that you need to fix something,
1839
before you should commit.
1841
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
1845
To merge the latest revision from bzr.dev
1846
bzr merge ../bzr.dev
1848
To merge changes up to and including revision 82 from bzr.dev
1849
bzr merge -r 82 ../bzr.dev
1851
To merge the changes introduced by 82, without previous changes:
1852
bzr merge -r 81..82 ../bzr.dev
1854
merge refuses to run if there are any uncommitted changes, unless
1857
takes_args = ['branch?']
1858
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1859
Option('show-base', help="Show base revision text in "
1862
def run(self, branch=None, revision=None, force=False, merge_type=None,
1863
show_base=False, reprocess=False):
1864
if merge_type is None:
1865
merge_type = Merge3Merger
1867
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1869
raise BzrCommandError("No merge location known or specified.")
1871
print "Using saved location: %s" % branch
1872
if revision is None or len(revision) < 1:
1874
other = [branch, -1]
1875
other_branch, path = Branch.open_containing(branch)
1877
if len(revision) == 1:
1879
other_branch, path = Branch.open_containing(branch)
1880
revno = revision[0].in_history(other_branch).revno
1881
other = [branch, revno]
1883
assert len(revision) == 2
1884
if None in revision:
1885
raise BzrCommandError(
1886
"Merge doesn't permit that revision specifier.")
1887
b, path = Branch.open_containing(branch)
1889
base = [branch, revision[0].in_history(b).revno]
1890
other = [branch, revision[1].in_history(b).revno]
1892
interesting_files = [path]
1894
interesting_files = None
1895
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1898
conflict_count = merge(other, base, check_clean=(not force),
1899
merge_type=merge_type,
1900
reprocess=reprocess,
1901
show_base=show_base,
1902
pb=pb, file_list=interesting_files)
1905
if conflict_count != 0:
1909
except bzrlib.errors.AmbiguousBase, e:
1910
m = ("sorry, bzr can't determine the right merge base yet\n"
1911
"candidates are:\n "
1912
+ "\n ".join(e.bases)
1914
"please specify an explicit base with -r,\n"
1915
"and (if you want) report this to the bzr developers\n")
1919
class cmd_remerge(Command):
1922
takes_args = ['file*']
1923
takes_options = ['merge-type', 'reprocess',
1924
Option('show-base', help="Show base revision text in "
1927
def run(self, file_list=None, merge_type=None, show_base=False,
1929
from bzrlib.merge import merge_inner, transform_tree
1930
if merge_type is None:
1931
merge_type = Merge3Merger
1932
tree, file_list = tree_files(file_list)
1935
pending_merges = tree.pending_merges()
1936
if len(pending_merges) != 1:
1937
raise BzrCommandError("Sorry, remerge only works after normal"
1938
+ " merges. Not cherrypicking or"
1940
repository = tree.branch.repository
1941
base_revision = common_ancestor(tree.branch.last_revision(),
1942
pending_merges[0], repository)
1943
base_tree = repository.revision_tree(base_revision)
1944
other_tree = repository.revision_tree(pending_merges[0])
1945
interesting_ids = None
1946
if file_list is not None:
1947
interesting_ids = set()
1948
for filename in file_list:
1949
file_id = tree.path2id(filename)
1951
raise NotVersionedError(filename)
1952
interesting_ids.add(file_id)
1953
if tree.kind(file_id) != "directory":
1956
for name, ie in tree.inventory.iter_entries(file_id):
1957
interesting_ids.add(ie.file_id)
1958
transform_tree(tree, tree.basis_tree(), interesting_ids)
1959
if file_list is None:
1960
restore_files = list(tree.iter_conflicts())
1962
restore_files = file_list
1963
for filename in restore_files:
1965
restore(tree.abspath(filename))
1966
except NotConflicted:
1968
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1970
interesting_ids = interesting_ids,
1971
other_rev_id=pending_merges[0],
1972
merge_type=merge_type,
1973
show_base=show_base,
1974
reprocess=reprocess)
1982
class cmd_revert(Command):
1983
"""Reverse all changes since the last commit.
1985
Only versioned files are affected. Specify filenames to revert only
1986
those files. By default, any files that are changed will be backed up
1987
first. Backup files have a '~' appended to their name.
1989
takes_options = ['revision', 'no-backup']
1990
takes_args = ['file*']
1991
aliases = ['merge-revert']
1993
def run(self, revision=None, no_backup=False, file_list=None):
1994
from bzrlib.commands import parse_spec
1995
if file_list is not None:
1996
if len(file_list) == 0:
1997
raise BzrCommandError("No files specified")
2001
tree, file_list = tree_files(file_list)
2002
if revision is None:
2003
# FIXME should be tree.last_revision
2004
rev_id = tree.last_revision()
2005
elif len(revision) != 1:
2006
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2008
rev_id = revision[0].in_history(tree.branch).rev_id
2009
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2011
tree.revert(file_list,
2012
tree.branch.repository.revision_tree(rev_id),
2018
class cmd_assert_fail(Command):
2019
"""Test reporting of assertion failures"""
2022
assert False, "always fails"
2025
class cmd_help(Command):
2026
"""Show help on a command or other topic.
2028
For a list of all available commands, say 'bzr help commands'."""
2029
takes_options = [Option('long', 'show help on all commands')]
2030
takes_args = ['topic?']
2031
aliases = ['?', '--help', '-?', '-h']
2034
def run(self, topic=None, long=False):
2036
if topic is None and long:
2041
class cmd_shell_complete(Command):
2042
"""Show appropriate completions for context.
2044
For a list of all available commands, say 'bzr shell-complete'."""
2045
takes_args = ['context?']
2050
def run(self, context=None):
2051
import shellcomplete
2052
shellcomplete.shellcomplete(context)
2055
class cmd_fetch(Command):
2056
"""Copy in history from another branch but don't merge it.
2058
This is an internal method used for pull and merge."""
2060
takes_args = ['from_branch', 'to_branch']
2061
def run(self, from_branch, to_branch):
2062
from bzrlib.fetch import Fetcher
2063
from bzrlib.branch import Branch
2064
from_b = Branch.open(from_branch)
2065
to_b = Branch.open(to_branch)
2066
Fetcher(to_b, from_b)
2069
class cmd_missing(Command):
2070
"""Show unmerged/unpulled revisions between two branches.
2072
OTHER_BRANCH may be local or remote."""
2073
takes_args = ['other_branch?']
2074
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2076
'Display changes in the local branch only'),
2077
Option('theirs-only',
2078
'Display changes in the remote branch only'),
2087
def run(self, other_branch=None, reverse=False, mine_only=False,
2088
theirs_only=False, log_format=None, long=False, short=False, line=False,
2089
show_ids=False, verbose=False):
2090
from bzrlib.missing import find_unmerged, iter_log_data
2091
from bzrlib.log import log_formatter
2092
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2093
parent = local_branch.get_parent()
2094
if other_branch is None:
2095
other_branch = parent
2096
if other_branch is None:
2097
raise BzrCommandError("No missing location known or specified.")
2098
print "Using last location: " + local_branch.get_parent()
2099
remote_branch = bzrlib.branch.Branch.open(other_branch)
2100
local_branch.lock_write()
2101
if remote_branch.base == local_branch.base:
2102
remote_branch = local_branch
2104
remote_branch.lock_read()
2106
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2107
if (log_format == None):
2108
default = bzrlib.config.BranchConfig(local_branch).log_format()
2109
log_format = get_log_format(long=long, short=short, line=line, default=default)
2110
lf = log_formatter(log_format, sys.stdout,
2112
show_timezone='original')
2113
if reverse is False:
2114
local_extra.reverse()
2115
remote_extra.reverse()
2116
if local_extra and not theirs_only:
2117
print "You have %d extra revision(s):" % len(local_extra)
2118
for data in iter_log_data(local_extra, local_branch.repository,
2121
printed_local = True
2123
printed_local = False
2124
if remote_extra and not mine_only:
2125
if printed_local is True:
2127
print "You are missing %d revision(s):" % len(remote_extra)
2128
for data in iter_log_data(remote_extra, remote_branch.repository,
2131
if not remote_extra and not local_extra:
2133
print "Branches are up to date."
2136
if parent is None and other_branch is not None:
2137
local_branch.set_parent(other_branch)
2140
local_branch.unlock()
2142
remote_branch.unlock()
2145
class cmd_plugins(Command):
2150
import bzrlib.plugin
2151
from inspect import getdoc
2152
for name, plugin in bzrlib.plugin.all_plugins().items():
2153
if hasattr(plugin, '__path__'):
2154
print plugin.__path__[0]
2155
elif hasattr(plugin, '__file__'):
2156
print plugin.__file__
2162
print '\t', d.split('\n')[0]
2165
class cmd_testament(Command):
2166
"""Show testament (signing-form) of a revision."""
2167
takes_options = ['revision', 'long']
2168
takes_args = ['branch?']
2170
def run(self, branch=u'.', revision=None, long=False):
2171
from bzrlib.testament import Testament
2172
b = WorkingTree.open_containing(branch)[0].branch
2175
if revision is None:
2176
rev_id = b.last_revision()
2178
rev_id = revision[0].in_history(b).rev_id
2179
t = Testament.from_revision(b.repository, rev_id)
2181
sys.stdout.writelines(t.as_text_lines())
2183
sys.stdout.write(t.as_short_text())
2188
class cmd_annotate(Command):
2189
"""Show the origin of each line in a file.
2191
This prints out the given file with an annotation on the left side
2192
indicating which revision, author and date introduced the change.
2194
If the origin is the same for a run of consecutive lines, it is
2195
shown only at the top, unless the --all option is given.
2197
# TODO: annotate directories; showing when each file was last changed
2198
# TODO: annotate a previous version of a file
2199
# TODO: if the working copy is modified, show annotations on that
2200
# with new uncommitted lines marked
2201
aliases = ['blame', 'praise']
2202
takes_args = ['filename']
2203
takes_options = [Option('all', help='show annotations on all lines'),
2204
Option('long', help='show date in annotations'),
2208
def run(self, filename, all=False, long=False):
2209
from bzrlib.annotate import annotate_file
2210
tree, relpath = WorkingTree.open_containing(filename)
2211
branch = tree.branch
2214
file_id = tree.inventory.path2id(relpath)
2215
tree = branch.repository.revision_tree(branch.last_revision())
2216
file_version = tree.inventory[file_id].revision
2217
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2222
class cmd_re_sign(Command):
2223
"""Create a digital signature for an existing revision."""
2224
# TODO be able to replace existing ones.
2226
hidden = True # is this right ?
2227
takes_args = ['revision_id*']
2228
takes_options = ['revision']
2230
def run(self, revision_id_list=None, revision=None):
2231
import bzrlib.config as config
2232
import bzrlib.gpg as gpg
2233
if revision_id_list is not None and revision is not None:
2234
raise BzrCommandError('You can only supply one of revision_id or --revision')
2235
if revision_id_list is None and revision is None:
2236
raise BzrCommandError('You must supply either --revision or a revision_id')
2237
b = WorkingTree.open_containing(u'.')[0].branch
2238
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2239
if revision_id_list is not None:
2240
for revision_id in revision_id_list:
2241
b.repository.sign_revision(revision_id, gpg_strategy)
2242
elif revision is not None:
2243
if len(revision) == 1:
2244
revno, rev_id = revision[0].in_history(b)
2245
b.repository.sign_revision(rev_id, gpg_strategy)
2246
elif len(revision) == 2:
2247
# are they both on rh- if so we can walk between them
2248
# might be nice to have a range helper for arbitrary
2249
# revision paths. hmm.
2250
from_revno, from_revid = revision[0].in_history(b)
2251
to_revno, to_revid = revision[1].in_history(b)
2252
if to_revid is None:
2253
to_revno = b.revno()
2254
if from_revno is None or to_revno is None:
2255
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2256
for revno in range(from_revno, to_revno + 1):
2257
b.repository.sign_revision(b.get_rev_id(revno),
2260
raise BzrCommandError('Please supply either one revision, or a range.')
2263
class cmd_bind(Command):
2264
"""Bind the current branch to a master branch.
2266
After binding, commits must succeed on the master branch
2267
before they are executed on the local one.
2270
takes_args = ['location']
2273
def run(self, location=None):
2274
b, relpath = Branch.open_containing(u'.')
2275
b_other = Branch.open(location)
2278
except DivergedBranches:
2279
raise BzrCommandError('These branches have diverged.'
2280
' Try merging, and then bind again.')
2283
class cmd_unbind(Command):
2284
"""Bind the current branch to its parent.
2286
After unbinding, the local branch is considered independent.
2293
b, relpath = Branch.open_containing(u'.')
2295
raise BzrCommandError('Local branch is not bound')
2298
class cmd_uncommit(bzrlib.commands.Command):
2299
"""Remove the last committed revision.
2301
By supplying the --all flag, it will not only remove the entry
2302
from revision_history, but also remove all of the entries in the
2305
--verbose will print out what is being removed.
2306
--dry-run will go through all the motions, but not actually
2309
In the future, uncommit will create a changeset, which can then
2313
# TODO: jam 20060108 Add an option to allow uncommit to remove
2314
# unreferenced information in 'branch-as-repostory' branches.
2315
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2316
# information in shared branches as well.
2317
takes_options = ['verbose', 'revision',
2318
Option('dry-run', help='Don\'t actually make changes'),
2319
Option('force', help='Say yes to all questions.')]
2320
takes_args = ['location?']
2323
def run(self, location=None,
2324
dry_run=False, verbose=False,
2325
revision=None, force=False):
2326
from bzrlib.branch import Branch
2327
from bzrlib.log import log_formatter
2329
from bzrlib.uncommit import uncommit
2331
if location is None:
2333
control, relpath = bzrdir.BzrDir.open_containing(location)
2335
tree = control.open_workingtree()
2337
except (errors.NoWorkingTree, errors.NotLocalUrl):
2339
b = control.open_branch()
2341
if revision is None:
2343
rev_id = b.last_revision()
2345
revno, rev_id = revision[0].in_history(b)
2347
print 'No revisions to uncommit.'
2349
for r in range(revno, b.revno()+1):
2350
rev_id = b.get_rev_id(r)
2351
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2352
lf.show(r, b.repository.get_revision(rev_id), None)
2355
print 'Dry-run, pretending to remove the above revisions.'
2357
val = raw_input('Press <enter> to continue')
2359
print 'The above revision(s) will be removed.'
2361
val = raw_input('Are you sure [y/N]? ')
2362
if val.lower() not in ('y', 'yes'):
2366
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2370
class cmd_break_lock(Command):
2371
"""Break a dead lock on a repository, branch or working directory.
2373
CAUTION: Locks should only be broken when you are sure that the process
2374
holding the lock has been stopped.
2379
takes_args = ['location']
2380
takes_options = [Option('show',
2381
help="just show information on the lock, " \
2384
def run(self, location, show=False):
2385
raise NotImplementedError("sorry, break-lock is not complete yet; "
2386
"you can remove the 'held' directory manually to break the lock")
2389
# command-line interpretation helper for merge-related commands
2390
def merge(other_revision, base_revision,
2391
check_clean=True, ignore_zero=False,
2392
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2393
file_list=None, show_base=False, reprocess=False,
2394
pb=DummyProgress()):
2395
"""Merge changes into a tree.
2398
list(path, revno) Base for three-way merge.
2399
If [None, None] then a base will be automatically determined.
2401
list(path, revno) Other revision for three-way merge.
2403
Directory to merge changes into; '.' by default.
2405
If true, this_dir must have no uncommitted changes before the
2407
ignore_zero - If true, suppress the "zero conflicts" message when
2408
there are no conflicts; should be set when doing something we expect
2409
to complete perfectly.
2410
file_list - If supplied, merge only changes to selected files.
2412
All available ancestors of other_revision and base_revision are
2413
automatically pulled into the branch.
2415
The revno may be -1 to indicate the last revision on the branch, which is
2418
This function is intended for use from the command line; programmatic
2419
clients might prefer to call merge.merge_inner(), which has less magic
2422
from bzrlib.merge import Merger
2423
if this_dir is None:
2425
this_tree = WorkingTree.open_containing(this_dir)[0]
2426
if show_base and not merge_type is Merge3Merger:
2427
raise BzrCommandError("Show-base is not supported for this merge"
2428
" type. %s" % merge_type)
2429
if reprocess and not merge_type is Merge3Merger:
2430
raise BzrCommandError("Reprocess is not supported for this merge"
2431
" type. %s" % merge_type)
2432
if reprocess and show_base:
2433
raise BzrCommandError("Cannot reprocess and show base.")
2435
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2436
merger.pp = ProgressPhase("Merge phase", 5, pb)
2437
merger.pp.next_phase()
2438
merger.check_basis(check_clean)
2439
merger.set_other(other_revision)
2440
merger.pp.next_phase()
2441
merger.set_base(base_revision)
2442
if merger.base_rev_id == merger.other_rev_id:
2443
note('Nothing to do.')
2445
merger.backup_files = backup_files
2446
merger.merge_type = merge_type
2447
merger.set_interesting_files(file_list)
2448
merger.show_base = show_base
2449
merger.reprocess = reprocess
2450
conflicts = merger.do_merge()
2451
if file_list is None:
2452
merger.set_pending()
2458
# these get imported and then picked up by the scan for cmd_*
2459
# TODO: Some more consistent way to split command definitions across files;
2460
# we do need to load at least some information about them to know of
2461
# aliases. ideally we would avoid loading the implementation until the
2462
# details were needed.
2463
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2464
from bzrlib.sign_my_commits import cmd_sign_my_commits
2465
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2466
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
