1
# Copyright (C) 2004, 2005, 2006, 2007 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"""
20
from StringIO import StringIO
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
53
from bzrlib.branch import Branch
54
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
55
from bzrlib.conflicts import ConflictList
56
from bzrlib.revision import common_ancestor
57
from bzrlib.revisionspec import RevisionSpec
58
from bzrlib.workingtree import WorkingTree
61
from bzrlib.commands import Command, display_command
62
from bzrlib.option import Option, RegistryOption
63
from bzrlib.progress import DummyProgress, ProgressPhase
64
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
67
def tree_files(file_list, default_branch=u'.'):
69
return internal_tree_files(file_list, default_branch)
70
except errors.FileInWrongBranch, e:
71
raise errors.BzrCommandError("%s is not in the same branch as %s" %
72
(e.path, file_list[0]))
75
# XXX: Bad function name; should possibly also be a class method of
76
# WorkingTree rather than a function.
77
def internal_tree_files(file_list, default_branch=u'.'):
78
"""Convert command-line paths to a WorkingTree and relative paths.
80
This is typically used for command-line processors that take one or
81
more filenames, and infer the workingtree that contains them.
83
The filenames given are not required to exist.
85
:param file_list: Filenames to convert.
87
:param default_branch: Fallback tree path to use if file_list is empty or
90
:return: workingtree, [relative_paths]
92
if file_list is None or len(file_list) == 0:
93
return WorkingTree.open_containing(default_branch)[0], file_list
94
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
96
for filename in file_list:
98
new_list.append(tree.relpath(osutils.dereference_path(filename)))
99
except errors.PathNotChild:
100
raise errors.FileInWrongBranch(tree.branch, filename)
101
return tree, new_list
104
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
105
def get_format_type(typestring):
106
"""Parse and return a format specifier."""
107
# Have to use BzrDirMetaFormat1 directly, so that
108
# RepositoryFormat.set_default_format works
109
if typestring == "default":
110
return bzrdir.BzrDirMetaFormat1()
112
return bzrdir.format_registry.make_bzrdir(typestring)
114
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
115
raise errors.BzrCommandError(msg)
118
# TODO: Make sure no commands unconditionally use the working directory as a
119
# branch. If a filename argument is used, the first of them should be used to
120
# specify the branch. (Perhaps this can be factored out into some kind of
121
# Argument class, representing a file in a branch, where the first occurrence
124
class cmd_status(Command):
125
"""Display status summary.
127
This reports on versioned and unknown files, reporting them
128
grouped by state. Possible states are:
131
Versioned in the working copy but not in the previous revision.
134
Versioned in the previous revision but removed or deleted
138
Path of this file changed from the previous revision;
139
the text may also have changed. This includes files whose
140
parent directory was renamed.
143
Text has changed since the previous revision.
146
File kind has been changed (e.g. from file to directory).
149
Not versioned and not matching an ignore pattern.
151
To see ignored files use 'bzr ignored'. For details on the
152
changes to file texts, use 'bzr diff'.
154
--short gives a status flags for each item, similar to the SVN's status
157
Column 1: versioning / renames
163
P Entry for a pending merge (not a file)
172
* The execute bit was changed
174
If no arguments are specified, the status of the entire working
175
directory is shown. Otherwise, only the status of the specified
176
files or directories is reported. If a directory is given, status
177
is reported for everything inside that directory.
179
If a revision argument is given, the status is calculated against
180
that revision, or between two revisions if two are provided.
183
# TODO: --no-recurse, --recurse options
185
takes_args = ['file*']
186
takes_options = ['show-ids', 'revision',
187
Option('short', help='Give short SVN-style status lines'),
188
Option('versioned', help='Only show versioned files')]
189
aliases = ['st', 'stat']
191
encoding_type = 'replace'
194
def run(self, show_ids=False, file_list=None, revision=None, short=False,
196
from bzrlib.status import show_tree_status
198
tree, file_list = tree_files(file_list)
200
show_tree_status(tree, show_ids=show_ids,
201
specific_files=file_list, revision=revision,
202
to_file=self.outf, short=short, versioned=versioned)
205
class cmd_cat_revision(Command):
206
"""Write out metadata for a revision.
208
The revision to print can either be specified by a specific
209
revision identifier, or you can use --revision.
213
takes_args = ['revision_id?']
214
takes_options = ['revision']
215
# cat-revision is more for frontends so should be exact
219
def run(self, revision_id=None, revision=None):
221
if revision_id is not None and revision is not None:
222
raise errors.BzrCommandError('You can only supply one of'
223
' revision_id or --revision')
224
if revision_id is None and revision is None:
225
raise errors.BzrCommandError('You must supply either'
226
' --revision or a revision_id')
227
b = WorkingTree.open_containing(u'.')[0].branch
229
# TODO: jam 20060112 should cat-revision always output utf-8?
230
if revision_id is not None:
231
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
232
elif revision is not None:
235
raise errors.BzrCommandError('You cannot specify a NULL'
237
revno, rev_id = rev.in_history(b)
238
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
241
class cmd_remove_tree(Command):
242
"""Remove the working tree from a given branch/checkout.
244
Since a lightweight checkout is little more than a working tree
245
this will refuse to run against one.
248
takes_args = ['location?']
250
def run(self, location='.'):
251
d = bzrdir.BzrDir.open(location)
254
working = d.open_workingtree()
255
except errors.NoWorkingTree:
256
raise errors.BzrCommandError("No working tree to remove")
257
except errors.NotLocalUrl:
258
raise errors.BzrCommandError("You cannot remove the working tree of a "
261
working_path = working.bzrdir.root_transport.base
262
branch_path = working.branch.bzrdir.root_transport.base
263
if working_path != branch_path:
264
raise errors.BzrCommandError("You cannot remove the working tree from "
265
"a lightweight checkout")
267
d.destroy_workingtree()
270
class cmd_revno(Command):
271
"""Show current revision number.
273
This is equal to the number of revisions on this branch.
276
takes_args = ['location?']
279
def run(self, location=u'.'):
280
self.outf.write(str(Branch.open_containing(location)[0].revno()))
281
self.outf.write('\n')
284
class cmd_revision_info(Command):
285
"""Show revision number and revision id for a given revision identifier.
288
takes_args = ['revision_info*']
289
takes_options = ['revision']
292
def run(self, revision=None, revision_info_list=[]):
295
if revision is not None:
296
revs.extend(revision)
297
if revision_info_list is not None:
298
for rev in revision_info_list:
299
revs.append(RevisionSpec.from_string(rev))
301
raise errors.BzrCommandError('You must supply a revision identifier')
303
b = WorkingTree.open_containing(u'.')[0].branch
306
revinfo = rev.in_history(b)
307
if revinfo.revno is None:
308
print ' %s' % revinfo.rev_id
310
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
313
class cmd_add(Command):
314
"""Add specified files or directories.
316
In non-recursive mode, all the named items are added, regardless
317
of whether they were previously ignored. A warning is given if
318
any of the named files are already versioned.
320
In recursive mode (the default), files are treated the same way
321
but the behaviour for directories is different. Directories that
322
are already versioned do not give a warning. All directories,
323
whether already versioned or not, are searched for files or
324
subdirectories that are neither versioned or ignored, and these
325
are added. This search proceeds recursively into versioned
326
directories. If no names are given '.' is assumed.
328
Therefore simply saying 'bzr add' will version all files that
329
are currently unknown.
331
Adding a file whose parent directory is not versioned will
332
implicitly add the parent, and so on up to the root. This means
333
you should never need to explicitly add a directory, they'll just
334
get added when you add a file in the directory.
336
--dry-run will show which files would be added, but not actually
339
--file-ids-from will try to use the file ids from the supplied path.
340
It looks up ids trying to find a matching parent directory with the
341
same filename, and then by pure path.
343
takes_args = ['file*']
344
takes_options = ['no-recurse', 'dry-run', 'verbose',
345
Option('file-ids-from', type=unicode,
346
help='Lookup file ids from here')]
347
encoding_type = 'replace'
349
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
354
if file_ids_from is not None:
356
base_tree, base_path = WorkingTree.open_containing(
358
except errors.NoWorkingTree:
359
base_branch, base_path = Branch.open_containing(
361
base_tree = base_branch.basis_tree()
363
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
364
to_file=self.outf, should_print=(not is_quiet()))
366
action = bzrlib.add.AddAction(to_file=self.outf,
367
should_print=(not is_quiet()))
370
base_tree.lock_read()
372
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
373
action=action, save=not dry_run)
375
if base_tree is not None:
379
for glob in sorted(ignored.keys()):
380
for path in ignored[glob]:
381
self.outf.write("ignored %s matching \"%s\"\n"
385
for glob, paths in ignored.items():
386
match_len += len(paths)
387
self.outf.write("ignored %d file(s).\n" % match_len)
388
self.outf.write("If you wish to add some of these files,"
389
" please add them by name.\n")
392
class cmd_mkdir(Command):
393
"""Create a new versioned directory.
395
This is equivalent to creating the directory and then adding it.
398
takes_args = ['dir+']
399
encoding_type = 'replace'
401
def run(self, dir_list):
404
wt, dd = WorkingTree.open_containing(d)
406
self.outf.write('added %s\n' % d)
409
class cmd_relpath(Command):
410
"""Show path of a file relative to root"""
412
takes_args = ['filename']
416
def run(self, filename):
417
# TODO: jam 20050106 Can relpath return a munged path if
418
# sys.stdout encoding cannot represent it?
419
tree, relpath = WorkingTree.open_containing(filename)
420
self.outf.write(relpath)
421
self.outf.write('\n')
424
class cmd_inventory(Command):
425
"""Show inventory of the current working copy or a revision.
427
It is possible to limit the output to a particular entry
428
type using the --kind option. For example: --kind file.
430
It is also possible to restrict the list of files to a specific
431
set. For example: bzr inventory --show-ids this/file
438
takes_options = ['revision', 'show-ids', 'kind']
440
takes_args = ['file*']
443
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
444
if kind and kind not in ['file', 'directory', 'symlink']:
445
raise errors.BzrCommandError('invalid kind specified')
447
work_tree, file_list = tree_files(file_list)
448
work_tree.lock_read()
450
if revision is not None:
451
if len(revision) > 1:
452
raise errors.BzrCommandError(
453
'bzr inventory --revision takes exactly one revision'
455
revision_id = revision[0].in_history(work_tree.branch).rev_id
456
tree = work_tree.branch.repository.revision_tree(revision_id)
458
extra_trees = [work_tree]
464
if file_list is not None:
465
file_ids = tree.paths2ids(file_list, trees=extra_trees,
466
require_versioned=True)
467
# find_ids_across_trees may include some paths that don't
469
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
470
for file_id in file_ids if file_id in tree)
472
entries = tree.inventory.entries()
475
if tree is not work_tree:
478
for path, entry in entries:
479
if kind and kind != entry.kind:
482
self.outf.write('%-50s %s\n' % (path, entry.file_id))
484
self.outf.write(path)
485
self.outf.write('\n')
488
class cmd_mv(Command):
489
"""Move or rename a file.
492
bzr mv OLDNAME NEWNAME
493
bzr mv SOURCE... DESTINATION
495
If the last argument is a versioned directory, all the other names
496
are moved into it. Otherwise, there must be exactly two arguments
497
and the file is changed to a new name.
499
If OLDNAME does not exist on the filesystem but is versioned and
500
NEWNAME does exist on the filesystem but is not versioned, mv
501
assumes that the file has been manually moved and only updates
502
its internal inventory to reflect that change.
503
The same is valid when moving many SOURCE files to a DESTINATION.
505
Files cannot be moved between branches.
508
takes_args = ['names*']
509
takes_options = [Option("after", help="move only the bzr identifier"
510
" of the file (file has already been moved). Use this flag if"
511
" bzr is not able to detect this itself.")]
512
aliases = ['move', 'rename']
513
encoding_type = 'replace'
515
def run(self, names_list, after=False):
516
if names_list is None:
519
if len(names_list) < 2:
520
raise errors.BzrCommandError("missing file argument")
521
tree, rel_names = tree_files(names_list)
523
if os.path.isdir(names_list[-1]):
524
# move into existing directory
525
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
526
self.outf.write("%s => %s\n" % pair)
528
if len(names_list) != 2:
529
raise errors.BzrCommandError('to mv multiple files the'
530
' destination must be a versioned'
532
tree.rename_one(rel_names[0], rel_names[1], after=after)
533
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
536
class cmd_pull(Command):
537
"""Turn this branch into a mirror of another branch.
539
This command only works on branches that have not diverged. Branches are
540
considered diverged if the destination branch's most recent commit is one
541
that has not been merged (directly or indirectly) into the parent.
543
If branches have diverged, you can use 'bzr merge' to integrate the changes
544
from one into the other. Once one branch has merged, the other should
545
be able to pull it again.
547
If you want to forget your local changes and just update your branch to
548
match the remote one, use pull --overwrite.
550
If there is no default location set, the first pull will set it. After
551
that, you can omit the location to use the default. To change the
552
default, use --remember. The value will only be saved if the remote
553
location can be accessed.
556
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
558
help='branch to pull into, '
559
'rather than the one containing the working directory',
564
takes_args = ['location?']
565
encoding_type = 'replace'
567
def run(self, location=None, remember=False, overwrite=False,
568
revision=None, verbose=False,
570
from bzrlib.tag import _merge_tags_if_possible
571
# FIXME: too much stuff is in the command class
572
if directory is None:
575
tree_to = WorkingTree.open_containing(directory)[0]
576
branch_to = tree_to.branch
577
except errors.NoWorkingTree:
579
branch_to = Branch.open_containing(directory)[0]
582
if location is not None:
584
reader = bundle.read_bundle_from_url(location)
585
except errors.NotABundle:
586
pass # Continue on considering this url a Branch
588
stored_loc = branch_to.get_parent()
590
if stored_loc is None:
591
raise errors.BzrCommandError("No pull location known or"
594
display_url = urlutils.unescape_for_display(stored_loc,
596
self.outf.write("Using saved location: %s\n" % display_url)
597
location = stored_loc
599
if reader is not None:
600
install_bundle(branch_to.repository, reader)
601
branch_from = branch_to
603
branch_from = Branch.open(location)
605
if branch_to.get_parent() is None or remember:
606
branch_to.set_parent(branch_from.base)
610
if reader is not None:
611
rev_id = reader.target
612
elif len(revision) == 1:
613
rev_id = revision[0].in_history(branch_from).rev_id
615
raise errors.BzrCommandError('bzr pull --revision takes one value.')
617
old_rh = branch_to.revision_history()
618
if tree_to is not None:
619
result = tree_to.pull(branch_from, overwrite, rev_id,
620
delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
622
result = branch_to.pull(branch_from, overwrite, rev_id)
624
result.report(self.outf)
626
from bzrlib.log import show_changed_revisions
627
new_rh = branch_to.revision_history()
628
show_changed_revisions(branch_to, old_rh, new_rh, to_file=self.outf)
631
class cmd_push(Command):
632
"""Update a mirror of this branch.
634
The target branch will not have its working tree populated because this
635
is both expensive, and is not supported on remote file systems.
637
Some smart servers or protocols *may* put the working tree in place in
640
This command only works on branches that have not diverged. Branches are
641
considered diverged if the destination branch's most recent commit is one
642
that has not been merged (directly or indirectly) by the source branch.
644
If branches have diverged, you can use 'bzr push --overwrite' to replace
645
the other branch completely, discarding its unmerged changes.
647
If you want to ensure you have the different changes in the other branch,
648
do a merge (see bzr help merge) from the other branch, and commit that.
649
After that you will be able to do a push without '--overwrite'.
651
If there is no default push location set, the first push will set it.
652
After that, you can omit the location to use the default. To change the
653
default, use --remember. The value will only be saved if the remote
654
location can be accessed.
657
takes_options = ['remember', 'overwrite', 'verbose',
658
Option('create-prefix',
659
help='Create the path leading up to the branch '
660
'if it does not already exist'),
662
help='branch to push from, '
663
'rather than the one containing the working directory',
667
Option('use-existing-dir',
668
help='By default push will fail if the target'
669
' directory exists, but does not already'
670
' have a control directory. This flag will'
671
' allow push to proceed.'),
673
takes_args = ['location?']
674
encoding_type = 'replace'
676
def run(self, location=None, remember=False, overwrite=False,
677
create_prefix=False, verbose=False,
678
use_existing_dir=False,
680
# FIXME: Way too big! Put this into a function called from the
682
if directory is None:
684
br_from = Branch.open_containing(directory)[0]
685
stored_loc = br_from.get_push_location()
687
if stored_loc is None:
688
raise errors.BzrCommandError("No push location known or specified.")
690
display_url = urlutils.unescape_for_display(stored_loc,
692
self.outf.write("Using saved location: %s\n" % display_url)
693
location = stored_loc
695
to_transport = transport.get_transport(location)
696
location_url = to_transport.base
698
br_to = repository_to = dir_to = None
700
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
701
except errors.NotBranchError:
702
pass # Didn't find anything
704
# If we can open a branch, use its direct repository, otherwise see
705
# if there is a repository without a branch.
707
br_to = dir_to.open_branch()
708
except errors.NotBranchError:
709
# Didn't find a branch, can we find a repository?
711
repository_to = dir_to.find_repository()
712
except errors.NoRepositoryPresent:
715
# Found a branch, so we must have found a repository
716
repository_to = br_to.repository
720
# The destination doesn't exist; create it.
721
# XXX: Refactor the create_prefix/no_create_prefix code into a
722
# common helper function
724
to_transport.mkdir('.')
725
except errors.FileExists:
726
if not use_existing_dir:
727
raise errors.BzrCommandError("Target directory %s"
728
" already exists, but does not have a valid .bzr"
729
" directory. Supply --use-existing-dir to push"
730
" there anyway." % location)
731
except errors.NoSuchFile:
732
if not create_prefix:
733
raise errors.BzrCommandError("Parent directory of %s"
735
"\nYou may supply --create-prefix to create all"
736
" leading parent directories."
739
cur_transport = to_transport
740
needed = [cur_transport]
741
# Recurse upwards until we can create a directory successfully
743
new_transport = cur_transport.clone('..')
744
if new_transport.base == cur_transport.base:
745
raise errors.BzrCommandError("Failed to create path"
749
new_transport.mkdir('.')
750
except errors.NoSuchFile:
751
needed.append(new_transport)
752
cur_transport = new_transport
756
# Now we only need to create child directories
758
cur_transport = needed.pop()
759
cur_transport.mkdir('.')
761
# Now the target directory exists, but doesn't have a .bzr
762
# directory. So we need to create it, along with any work to create
763
# all of the dependent branches, etc.
764
dir_to = br_from.bzrdir.clone(location_url,
765
revision_id=br_from.last_revision())
766
br_to = dir_to.open_branch()
767
# TODO: Some more useful message about what was copied
768
note('Created new branch.')
769
# We successfully created the target, remember it
770
if br_from.get_push_location() is None or remember:
771
br_from.set_push_location(br_to.base)
772
elif repository_to is None:
773
# we have a bzrdir but no branch or repository
774
# XXX: Figure out what to do other than complain.
775
raise errors.BzrCommandError("At %s you have a valid .bzr control"
776
" directory, but not a branch or repository. This is an"
777
" unsupported configuration. Please move the target directory"
778
" out of the way and try again."
781
# We have a repository but no branch, copy the revisions, and then
783
last_revision_id = br_from.last_revision()
784
repository_to.fetch(br_from.repository,
785
revision_id=last_revision_id)
786
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
787
note('Created new branch.')
788
if br_from.get_push_location() is None or remember:
789
br_from.set_push_location(br_to.base)
790
else: # We have a valid to branch
791
# We were able to connect to the remote location, so remember it
792
# we don't need to successfully push because of possible divergence.
793
if br_from.get_push_location() is None or remember:
794
br_from.set_push_location(br_to.base)
795
old_rh = br_to.revision_history()
798
tree_to = dir_to.open_workingtree()
799
except errors.NotLocalUrl:
800
warning('This transport does not update the working '
801
'tree of: %s' % (br_to.base,))
802
push_result = br_from.push(br_to, overwrite)
803
except errors.NoWorkingTree:
804
push_result = br_from.push(br_to, overwrite)
808
push_result = br_from.push(tree_to.branch, overwrite)
812
except errors.DivergedBranches:
813
raise errors.BzrCommandError('These branches have diverged.'
814
' Try using "merge" and then "push".')
815
if push_result is not None:
816
push_result.report(self.outf)
818
new_rh = br_to.revision_history()
821
from bzrlib.log import show_changed_revisions
822
show_changed_revisions(br_to, old_rh, new_rh,
825
# we probably did a clone rather than a push, so a message was
830
class cmd_branch(Command):
831
"""Create a new copy of a branch.
833
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
834
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
836
To retrieve the branch as of a particular revision, supply the --revision
837
parameter, as in "branch foo/bar -r 5".
839
--basis is to speed up branching from remote branches. When specified, it
840
copies all the file-contents, inventory and revision data from the basis
841
branch before copying anything from the remote branch.
843
takes_args = ['from_location', 'to_location?']
844
takes_options = ['revision', 'basis']
845
aliases = ['get', 'clone']
847
def run(self, from_location, to_location=None, revision=None, basis=None):
848
from bzrlib.tag import _merge_tags_if_possible
851
elif len(revision) > 1:
852
raise errors.BzrCommandError(
853
'bzr branch --revision takes exactly 1 revision value')
855
br_from = Branch.open(from_location)
858
if basis is not None:
859
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
862
if len(revision) == 1 and revision[0] is not None:
863
revision_id = revision[0].in_history(br_from)[1]
865
# FIXME - wt.last_revision, fallback to branch, fall back to
866
# None or perhaps NULL_REVISION to mean copy nothing
868
revision_id = br_from.last_revision()
869
if to_location is None:
870
to_location = os.path.basename(from_location.rstrip("/\\"))
873
name = os.path.basename(to_location) + '\n'
875
to_transport = transport.get_transport(to_location)
877
to_transport.mkdir('.')
878
except errors.FileExists:
879
raise errors.BzrCommandError('Target directory "%s" already'
880
' exists.' % to_location)
881
except errors.NoSuchFile:
882
raise errors.BzrCommandError('Parent of "%s" does not exist.'
885
# preserve whatever source format we have.
886
dir = br_from.bzrdir.sprout(to_transport.base,
887
revision_id, basis_dir)
888
branch = dir.open_branch()
889
except errors.NoSuchRevision:
890
to_transport.delete_tree('.')
891
msg = "The branch %s has no revision %s." % (from_location, revision[0])
892
raise errors.BzrCommandError(msg)
893
except errors.UnlistableBranch:
894
osutils.rmtree(to_location)
895
msg = "The branch %s cannot be used as a --basis" % (basis,)
896
raise errors.BzrCommandError(msg)
898
branch.control_files.put_utf8('branch-name', name)
899
_merge_tags_if_possible(br_from, branch)
900
note('Branched %d revision(s).' % branch.revno())
905
class cmd_checkout(Command):
906
"""Create a new checkout of an existing branch.
908
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
909
the branch found in '.'. This is useful if you have removed the working tree
910
or if it was never created - i.e. if you pushed the branch to its current
913
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
914
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
916
To retrieve the branch as of a particular revision, supply the --revision
917
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
918
out of date [so you cannot commit] but it may be useful (i.e. to examine old
921
See "help checkouts" for more information on checkouts.
923
takes_args = ['branch_location?', 'to_location?']
924
takes_options = ['revision', # , 'basis']
925
Option('lightweight',
926
help="perform a lightweight checkout. Lightweight "
927
"checkouts depend on access to the branch for "
928
"every operation. Normal checkouts can perform "
929
"common operations like diff and status without "
930
"such access, and also support local commits."
935
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
939
elif len(revision) > 1:
940
raise errors.BzrCommandError(
941
'bzr checkout --revision takes exactly 1 revision value')
942
if branch_location is None:
943
branch_location = osutils.getcwd()
944
to_location = branch_location
945
source = Branch.open(branch_location)
946
if len(revision) == 1 and revision[0] is not None:
947
revision_id = revision[0].in_history(source)[1]
950
if to_location is None:
951
to_location = os.path.basename(branch_location.rstrip("/\\"))
952
# if the source and to_location are the same,
953
# and there is no working tree,
954
# then reconstitute a branch
955
if (osutils.abspath(to_location) ==
956
osutils.abspath(branch_location)):
958
source.bzrdir.open_workingtree()
959
except errors.NoWorkingTree:
960
source.bzrdir.create_workingtree()
963
os.mkdir(to_location)
965
if e.errno == errno.EEXIST:
966
raise errors.BzrCommandError('Target directory "%s" already'
967
' exists.' % to_location)
968
if e.errno == errno.ENOENT:
969
raise errors.BzrCommandError('Parent of "%s" does not exist.'
973
source.create_checkout(to_location, revision_id, lightweight)
976
class cmd_renames(Command):
977
"""Show list of renamed files.
979
# TODO: Option to show renames between two historical versions.
981
# TODO: Only show renames under dir, rather than in the whole branch.
982
takes_args = ['dir?']
985
def run(self, dir=u'.'):
986
tree = WorkingTree.open_containing(dir)[0]
989
new_inv = tree.inventory
990
old_tree = tree.basis_tree()
993
old_inv = old_tree.inventory
994
renames = list(_mod_tree.find_renames(old_inv, new_inv))
996
for old_name, new_name in renames:
997
self.outf.write("%s => %s\n" % (old_name, new_name))
1004
class cmd_update(Command):
1005
"""Update a tree to have the latest code committed to its branch.
1007
This will perform a merge into the working tree, and may generate
1008
conflicts. If you have any local changes, you will still
1009
need to commit them after the update for the update to be complete.
1011
If you want to discard your local changes, you can just do a
1012
'bzr revert' instead of 'bzr commit' after the update.
1014
takes_args = ['dir?']
1017
def run(self, dir='.'):
1018
tree = WorkingTree.open_containing(dir)[0]
1019
master = tree.branch.get_master_branch()
1020
if master is not None:
1023
tree.lock_tree_write()
1025
existing_pending_merges = tree.get_parent_ids()[1:]
1026
last_rev = tree.last_revision()
1027
if last_rev == tree.branch.last_revision():
1028
# may be up to date, check master too.
1029
master = tree.branch.get_master_branch()
1030
if master is None or last_rev == master.last_revision():
1031
revno = tree.branch.revision_id_to_revno(last_rev)
1032
note("Tree is up to date at revision %d." % (revno,))
1034
conflicts = tree.update()
1035
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1036
note('Updated to revision %d.' % (revno,))
1037
if tree.get_parent_ids()[1:] != existing_pending_merges:
1038
note('Your local commits will now show as pending merges with '
1039
"'bzr status', and can be committed with 'bzr commit'.")
1048
class cmd_info(Command):
1049
"""Show information about a working tree, branch or repository.
1051
This command will show all known locations and formats associated to the
1052
tree, branch or repository. Statistical information is included with
1055
Branches and working trees will also report any missing revisions.
1057
takes_args = ['location?']
1058
takes_options = ['verbose']
1061
def run(self, location=None, verbose=False):
1062
from bzrlib.info import show_bzrdir_info
1063
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1067
class cmd_remove(Command):
1068
"""Remove files or directories..
1070
This makes bzr stop tracking changes to the specified files and
1071
delete them if they can easily be recovered using revert.
1073
You can specify one or more files, and/or --new. If you specify --new,
1074
only 'added' files will be removed. If you specify both, then new files
1075
in the specified directories will be removed. If the directories are
1076
also new, they will also be removed.
1078
takes_args = ['file*']
1079
takes_options = ['verbose',
1080
Option('new', help='remove newly-added files'),
1081
Option('keep', help="never delete files"),
1082
Option('force', help="always delete files, even if they can not be "
1083
"recovered and even if they are non-empty directories")]
1085
encoding_type = 'replace'
1087
def run(self, file_list, verbose=False, new=False, keep=False,
1089
tree, file_list = tree_files(file_list)
1091
if file_list is not None:
1092
file_list = [f for f in file_list if f != '']
1094
raise errors.BzrCommandError('Specify one or more files to'
1095
' remove, or use --new.')
1098
added = tree.changes_from(tree.basis_tree(),
1099
specific_files=file_list).added
1100
file_list = sorted([f[0] for f in added], reverse=True)
1101
if len(file_list) == 0:
1102
raise errors.BzrCommandError('No matching files.')
1103
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1104
keep_files=keep, force=force)
1107
class cmd_file_id(Command):
1108
"""Print file_id of a particular file or directory.
1110
The file_id is assigned when the file is first added and remains the
1111
same through all revisions where the file exists, even when it is
1116
takes_args = ['filename']
1119
def run(self, filename):
1120
tree, relpath = WorkingTree.open_containing(filename)
1121
i = tree.path2id(relpath)
1123
raise errors.NotVersionedError(filename)
1125
self.outf.write(i + '\n')
1128
class cmd_file_path(Command):
1129
"""Print path of file_ids to a file or directory.
1131
This prints one line for each directory down to the target,
1132
starting at the branch root.
1136
takes_args = ['filename']
1139
def run(self, filename):
1140
tree, relpath = WorkingTree.open_containing(filename)
1141
fid = tree.path2id(relpath)
1143
raise errors.NotVersionedError(filename)
1144
segments = osutils.splitpath(relpath)
1145
for pos in range(1, len(segments) + 1):
1146
path = osutils.joinpath(segments[:pos])
1147
self.outf.write("%s\n" % tree.path2id(path))
1150
class cmd_reconcile(Command):
1151
"""Reconcile bzr metadata in a branch.
1153
This can correct data mismatches that may have been caused by
1154
previous ghost operations or bzr upgrades. You should only
1155
need to run this command if 'bzr check' or a bzr developer
1156
advises you to run it.
1158
If a second branch is provided, cross-branch reconciliation is
1159
also attempted, which will check that data like the tree root
1160
id which was not present in very early bzr versions is represented
1161
correctly in both branches.
1163
At the same time it is run it may recompress data resulting in
1164
a potential saving in disk space or performance gain.
1166
The branch *MUST* be on a listable system such as local disk or sftp.
1168
takes_args = ['branch?']
1170
def run(self, branch="."):
1171
from bzrlib.reconcile import reconcile
1172
dir = bzrdir.BzrDir.open(branch)
1176
class cmd_revision_history(Command):
1177
"""Display the list of revision ids on a branch."""
1178
takes_args = ['location?']
1183
def run(self, location="."):
1184
branch = Branch.open_containing(location)[0]
1185
for revid in branch.revision_history():
1186
self.outf.write(revid)
1187
self.outf.write('\n')
1190
class cmd_ancestry(Command):
1191
"""List all revisions merged into this branch."""
1192
takes_args = ['location?']
1197
def run(self, location="."):
1199
wt = WorkingTree.open_containing(location)[0]
1200
except errors.NoWorkingTree:
1201
b = Branch.open(location)
1202
last_revision = b.last_revision()
1205
last_revision = wt.last_revision()
1207
revision_ids = b.repository.get_ancestry(last_revision)
1208
assert revision_ids[0] is None
1210
for revision_id in revision_ids:
1211
self.outf.write(revision_id + '\n')
1214
class cmd_init(Command):
1215
"""Make a directory into a versioned branch.
1217
Use this to create an empty branch, or before importing an
1220
If there is a repository in a parent directory of the location, then
1221
the history of the branch will be stored in the repository. Otherwise
1222
init creates a standalone branch which carries its own history
1223
in the .bzr directory.
1225
If there is already a branch at the location but it has no working tree,
1226
the tree can be populated with 'bzr checkout'.
1228
Recipe for importing a tree of files:
1233
bzr commit -m 'imported project'
1235
takes_args = ['location?']
1237
RegistryOption('format',
1238
help='Specify a format for this branch. '
1239
'See "help formats".',
1240
registry=bzrdir.format_registry,
1241
converter=bzrdir.format_registry.make_bzrdir,
1242
value_switches=True,
1243
title="Branch Format",
1245
Option('append-revisions-only',
1246
help='Never change revnos or the existing log.'
1247
' Append revisions to it only.')
1249
def run(self, location=None, format=None, append_revisions_only=False):
1251
format = bzrdir.format_registry.make_bzrdir('default')
1252
if location is None:
1255
to_transport = transport.get_transport(location)
1257
# The path has to exist to initialize a
1258
# branch inside of it.
1259
# Just using os.mkdir, since I don't
1260
# believe that we want to create a bunch of
1261
# locations if the user supplies an extended path
1262
# TODO: create-prefix
1264
to_transport.mkdir('.')
1265
except errors.FileExists:
1269
existing_bzrdir = bzrdir.BzrDir.open(location)
1270
except errors.NotBranchError:
1271
# really a NotBzrDir error...
1272
branch = bzrdir.BzrDir.create_branch_convenience(to_transport.base,
1275
from bzrlib.transport.local import LocalTransport
1276
if existing_bzrdir.has_branch():
1277
if (isinstance(to_transport, LocalTransport)
1278
and not existing_bzrdir.has_workingtree()):
1279
raise errors.BranchExistsWithoutWorkingTree(location)
1280
raise errors.AlreadyBranchError(location)
1282
branch = existing_bzrdir.create_branch()
1283
existing_bzrdir.create_workingtree()
1284
if append_revisions_only:
1286
branch.set_append_revisions_only(True)
1287
except errors.UpgradeRequired:
1288
raise errors.BzrCommandError('This branch format cannot be set'
1289
' to append-revisions-only. Try --experimental-branch6')
1292
class cmd_init_repository(Command):
1293
"""Create a shared repository to hold branches.
1295
New branches created under the repository directory will store their revisions
1296
in the repository, not in the branch directory.
1299
bzr init-repo --no-trees repo
1301
bzr checkout --lightweight repo/trunk trunk-checkout
1306
takes_args = ["location"]
1307
takes_options = [RegistryOption('format',
1308
help='Specify a format for this repository. See'
1309
' "bzr help formats" for details',
1310
registry=bzrdir.format_registry,
1311
converter=bzrdir.format_registry.make_bzrdir,
1312
value_switches=True, title='Repository format'),
1314
help='Branches in the repository will default to'
1315
' not having a working tree'),
1317
aliases = ["init-repo"]
1319
def run(self, location, format=None, no_trees=False):
1321
format = bzrdir.format_registry.make_bzrdir('default')
1323
if location is None:
1326
to_transport = transport.get_transport(location)
1328
to_transport.mkdir('.')
1329
except errors.FileExists:
1332
newdir = format.initialize_on_transport(to_transport)
1333
repo = newdir.create_repository(shared=True)
1334
repo.set_make_working_trees(not no_trees)
1337
class cmd_diff(Command):
1338
"""Show differences in the working tree or between revisions.
1340
If files are listed, only the changes in those files are listed.
1341
Otherwise, all changes for the tree are listed.
1343
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1344
produces patches suitable for "patch -p1".
1348
Shows the difference in the working tree versus the last commit
1350
Difference between the working tree and revision 1
1352
Difference between revision 2 and revision 1
1353
bzr diff --prefix old/:new/
1354
Same as 'bzr diff' but prefix paths with old/ and new/
1355
bzr diff bzr.mine bzr.dev
1356
Show the differences between the two working trees
1358
Show just the differences for 'foo.c'
1360
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1361
# or a graphical diff.
1363
# TODO: Python difflib is not exactly the same as unidiff; should
1364
# either fix it up or prefer to use an external diff.
1366
# TODO: Selected-file diff is inefficient and doesn't show you
1369
# TODO: This probably handles non-Unix newlines poorly.
1371
takes_args = ['file*']
1372
takes_options = ['revision', 'diff-options',
1373
Option('prefix', type=str,
1375
help='Set prefixes to added to old and new filenames, as '
1376
'two values separated by a colon. (eg "old/:new/")'),
1378
aliases = ['di', 'dif']
1379
encoding_type = 'exact'
1382
def run(self, revision=None, file_list=None, diff_options=None,
1384
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1386
if (prefix is None) or (prefix == '0'):
1394
old_label, new_label = prefix.split(":")
1396
raise errors.BzrCommandError(
1397
'--prefix expects two values separated by a colon'
1398
' (eg "old/:new/")')
1400
if revision and len(revision) > 2:
1401
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1402
' one or two revision specifiers')
1405
tree1, file_list = internal_tree_files(file_list)
1409
except errors.FileInWrongBranch:
1410
if len(file_list) != 2:
1411
raise errors.BzrCommandError("Files are in different branches")
1413
tree1, file1 = WorkingTree.open_containing(file_list[0])
1414
tree2, file2 = WorkingTree.open_containing(file_list[1])
1415
if file1 != "" or file2 != "":
1416
# FIXME diff those two files. rbc 20051123
1417
raise errors.BzrCommandError("Files are in different branches")
1419
except errors.NotBranchError:
1420
if (revision is not None and len(revision) == 2
1421
and not revision[0].needs_branch()
1422
and not revision[1].needs_branch()):
1423
# If both revision specs include a branch, we can
1424
# diff them without needing a local working tree
1425
tree1, tree2 = None, None
1429
if tree2 is not None:
1430
if revision is not None:
1431
# FIXME: but there should be a clean way to diff between
1432
# non-default versions of two trees, it's not hard to do
1434
raise errors.BzrCommandError(
1435
"Sorry, diffing arbitrary revisions across branches "
1436
"is not implemented yet")
1437
return show_diff_trees(tree1, tree2, sys.stdout,
1438
specific_files=file_list,
1439
external_diff_options=diff_options,
1440
old_label=old_label, new_label=new_label)
1442
return diff_cmd_helper(tree1, file_list, diff_options,
1443
revision_specs=revision,
1444
old_label=old_label, new_label=new_label)
1447
class cmd_deleted(Command):
1448
"""List files deleted in the working tree.
1450
# TODO: Show files deleted since a previous revision, or
1451
# between two revisions.
1452
# TODO: Much more efficient way to do this: read in new
1453
# directories with readdir, rather than stating each one. Same
1454
# level of effort but possibly much less IO. (Or possibly not,
1455
# if the directories are very large...)
1456
takes_options = ['show-ids']
1459
def run(self, show_ids=False):
1460
tree = WorkingTree.open_containing(u'.')[0]
1463
old = tree.basis_tree()
1466
for path, ie in old.inventory.iter_entries():
1467
if not tree.has_id(ie.file_id):
1468
self.outf.write(path)
1470
self.outf.write(' ')
1471
self.outf.write(ie.file_id)
1472
self.outf.write('\n')
1479
class cmd_modified(Command):
1480
"""List files modified in working tree.
1482
See also: "bzr status".
1489
tree = WorkingTree.open_containing(u'.')[0]
1490
td = tree.changes_from(tree.basis_tree())
1491
for path, id, kind, text_modified, meta_modified in td.modified:
1492
self.outf.write(path + '\n')
1495
class cmd_added(Command):
1496
"""List files added in working tree.
1498
See also: "bzr status".
1505
wt = WorkingTree.open_containing(u'.')[0]
1508
basis = wt.basis_tree()
1511
basis_inv = basis.inventory
1514
if file_id in basis_inv:
1516
if inv.is_root(file_id) and len(basis_inv) == 0:
1518
path = inv.id2path(file_id)
1519
if not os.access(osutils.abspath(path), os.F_OK):
1521
self.outf.write(path + '\n')
1528
class cmd_root(Command):
1529
"""Show the tree root directory.
1531
The root is the nearest enclosing directory with a .bzr control
1533
takes_args = ['filename?']
1535
def run(self, filename=None):
1536
"""Print the branch root."""
1537
tree = WorkingTree.open_containing(filename)[0]
1538
self.outf.write(tree.basedir + '\n')
1541
class cmd_log(Command):
1542
"""Show log of a branch, file, or directory.
1544
By default show the log of the branch containing the working directory.
1546
To request a range of logs, you can use the command -r begin..end
1547
-r revision requests a specific revision, -r ..end or -r begin.. are
1553
bzr log -r -10.. http://server/branch
1556
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1558
takes_args = ['location?']
1559
takes_options = [Option('forward',
1560
help='show from oldest to newest'),
1564
help='show files changed in each revision'),
1565
'show-ids', 'revision',
1569
help='show revisions whose message matches this regexp',
1572
encoding_type = 'replace'
1575
def run(self, location=None, timezone='original',
1582
from bzrlib.log import show_log
1583
assert message is None or isinstance(message, basestring), \
1584
"invalid message argument %r" % message
1585
direction = (forward and 'forward') or 'reverse'
1590
# find the file id to log:
1592
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1596
tree = b.basis_tree()
1597
file_id = tree.path2id(fp)
1599
raise errors.BzrCommandError(
1600
"Path does not have any revision history: %s" %
1604
# FIXME ? log the current subdir only RBC 20060203
1605
if revision is not None \
1606
and len(revision) > 0 and revision[0].get_branch():
1607
location = revision[0].get_branch()
1610
dir, relpath = bzrdir.BzrDir.open_containing(location)
1611
b = dir.open_branch()
1615
if revision is None:
1618
elif len(revision) == 1:
1619
rev1 = rev2 = revision[0].in_history(b).revno
1620
elif len(revision) == 2:
1621
if revision[1].get_branch() != revision[0].get_branch():
1622
# b is taken from revision[0].get_branch(), and
1623
# show_log will use its revision_history. Having
1624
# different branches will lead to weird behaviors.
1625
raise errors.BzrCommandError(
1626
"Log doesn't accept two revisions in different"
1628
if revision[0].spec is None:
1629
# missing begin-range means first revision
1632
rev1 = revision[0].in_history(b).revno
1634
if revision[1].spec is None:
1635
# missing end-range means last known revision
1638
rev2 = revision[1].in_history(b).revno
1640
raise errors.BzrCommandError(
1641
'bzr log --revision takes one or two values.')
1643
# By this point, the revision numbers are converted to the +ve
1644
# form if they were supplied in the -ve form, so we can do
1645
# this comparison in relative safety
1647
(rev2, rev1) = (rev1, rev2)
1649
if log_format is None:
1650
log_format = log.log_formatter_registry.get_default(b)
1652
lf = log_format(show_ids=show_ids, to_file=self.outf,
1653
show_timezone=timezone)
1659
direction=direction,
1660
start_revision=rev1,
1667
def get_log_format(long=False, short=False, line=False, default='long'):
1668
log_format = default
1672
log_format = 'short'
1678
class cmd_touching_revisions(Command):
1679
"""Return revision-ids which affected a particular file.
1681
A more user-friendly interface is "bzr log FILE".
1685
takes_args = ["filename"]
1688
def run(self, filename):
1689
tree, relpath = WorkingTree.open_containing(filename)
1691
file_id = tree.path2id(relpath)
1692
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1693
self.outf.write("%6d %s\n" % (revno, what))
1696
class cmd_ls(Command):
1697
"""List files in a tree.
1700
takes_args = ['path?']
1701
# TODO: Take a revision or remote path and list that tree instead.
1702
takes_options = ['verbose', 'revision',
1703
Option('non-recursive',
1704
help='don\'t recurse into sub-directories'),
1706
help='Print all paths from the root of the branch.'),
1707
Option('unknown', help='Print unknown files'),
1708
Option('versioned', help='Print versioned files'),
1709
Option('ignored', help='Print ignored files'),
1711
Option('null', help='Null separate the files'),
1715
def run(self, revision=None, verbose=False,
1716
non_recursive=False, from_root=False,
1717
unknown=False, versioned=False, ignored=False,
1718
null=False, kind=None, show_ids=False, path=None):
1720
if kind and kind not in ('file', 'directory', 'symlink'):
1721
raise errors.BzrCommandError('invalid kind specified')
1723
if verbose and null:
1724
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1725
all = not (unknown or versioned or ignored)
1727
selection = {'I':ignored, '?':unknown, 'V':versioned}
1734
raise errors.BzrCommandError('cannot specify both --from-root'
1738
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1744
if revision is not None:
1745
tree = branch.repository.revision_tree(
1746
revision[0].in_history(branch).rev_id)
1748
tree = branch.basis_tree()
1752
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1753
if fp.startswith(relpath):
1754
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1755
if non_recursive and '/' in fp:
1757
if not all and not selection[fc]:
1759
if kind is not None and fkind != kind:
1762
kindch = entry.kind_character()
1763
outstring = '%-8s %s%s' % (fc, fp, kindch)
1764
if show_ids and fid is not None:
1765
outstring = "%-50s %s" % (outstring, fid)
1766
self.outf.write(outstring + '\n')
1768
self.outf.write(fp + '\0')
1771
self.outf.write(fid)
1772
self.outf.write('\0')
1780
self.outf.write('%-50s %s\n' % (fp, my_id))
1782
self.outf.write(fp + '\n')
1787
class cmd_unknowns(Command):
1788
"""List unknown files.
1790
See also: "bzr ls --unknown".
1797
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1798
self.outf.write(osutils.quotefn(f) + '\n')
1801
class cmd_ignore(Command):
1802
"""Ignore specified files or patterns.
1804
To remove patterns from the ignore list, edit the .bzrignore file.
1806
Trailing slashes on patterns are ignored.
1807
If the pattern contains a slash or is a regular expression, it is compared
1808
to the whole path from the branch root. Otherwise, it is compared to only
1809
the last component of the path. To match a file only in the root
1810
directory, prepend './'.
1812
Ignore patterns specifying absolute paths are not allowed.
1814
Ignore patterns may include globbing wildcards such as:
1815
? - Matches any single character except '/'
1816
* - Matches 0 or more characters except '/'
1817
/**/ - Matches 0 or more directories in a path
1818
[a-z] - Matches a single character from within a group of characters
1820
Ignore patterns may also be Python regular expressions.
1821
Regular expression ignore patterns are identified by a 'RE:' prefix
1822
followed by the regular expression. Regular expression ignore patterns
1823
may not include named or numbered groups.
1825
Note: ignore patterns containing shell wildcards must be quoted from
1829
bzr ignore ./Makefile
1830
bzr ignore '*.class'
1831
bzr ignore 'lib/**/*.o'
1832
bzr ignore 'RE:lib/.*\.o'
1834
takes_args = ['name_pattern*']
1836
Option('old-default-rules',
1837
help='Out the ignore rules bzr < 0.9 always used.')
1840
def run(self, name_pattern_list=None, old_default_rules=None):
1841
from bzrlib.atomicfile import AtomicFile
1842
if old_default_rules is not None:
1843
# dump the rules and exit
1844
for pattern in ignores.OLD_DEFAULTS:
1847
if not name_pattern_list:
1848
raise errors.BzrCommandError("ignore requires at least one "
1849
"NAME_PATTERN or --old-default-rules")
1850
name_pattern_list = [globbing.normalize_pattern(p)
1851
for p in name_pattern_list]
1852
for name_pattern in name_pattern_list:
1853
if (name_pattern[0] == '/' or
1854
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1855
raise errors.BzrCommandError(
1856
"NAME_PATTERN should not be an absolute path")
1857
tree, relpath = WorkingTree.open_containing(u'.')
1858
ifn = tree.abspath('.bzrignore')
1859
if os.path.exists(ifn):
1862
igns = f.read().decode('utf-8')
1868
# TODO: If the file already uses crlf-style termination, maybe
1869
# we should use that for the newly added lines?
1871
if igns and igns[-1] != '\n':
1873
for name_pattern in name_pattern_list:
1874
igns += name_pattern + '\n'
1876
f = AtomicFile(ifn, 'wb')
1878
f.write(igns.encode('utf-8'))
1883
if not tree.path2id('.bzrignore'):
1884
tree.add(['.bzrignore'])
1887
class cmd_ignored(Command):
1888
"""List ignored files and the patterns that matched them.
1890
See also: bzr ignore"""
1893
tree = WorkingTree.open_containing(u'.')[0]
1896
for path, file_class, kind, file_id, entry in tree.list_files():
1897
if file_class != 'I':
1899
## XXX: Slightly inefficient since this was already calculated
1900
pat = tree.is_ignored(path)
1901
print '%-50s %s' % (path, pat)
1906
class cmd_lookup_revision(Command):
1907
"""Lookup the revision-id from a revision-number
1910
bzr lookup-revision 33
1913
takes_args = ['revno']
1916
def run(self, revno):
1920
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1922
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1925
class cmd_export(Command):
1926
"""Export current or past revision to a destination directory or archive.
1928
If no revision is specified this exports the last committed revision.
1930
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1931
given, try to find the format with the extension. If no extension
1932
is found exports to a directory (equivalent to --format=dir).
1934
Root may be the top directory for tar, tgz and tbz2 formats. If none
1935
is given, the top directory will be the root name of the file.
1937
If branch is omitted then the branch containing the current working
1938
directory will be used.
1940
Note: export of tree with non-ascii filenames to zip is not supported.
1942
Supported formats Autodetected by extension
1943
----------------- -------------------------
1946
tbz2 .tar.bz2, .tbz2
1950
takes_args = ['dest', 'branch?']
1951
takes_options = ['revision', 'format', 'root']
1952
def run(self, dest, branch=None, revision=None, format=None, root=None):
1953
from bzrlib.export import export
1956
tree = WorkingTree.open_containing(u'.')[0]
1959
b = Branch.open(branch)
1961
if revision is None:
1962
# should be tree.last_revision FIXME
1963
rev_id = b.last_revision()
1965
if len(revision) != 1:
1966
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1967
rev_id = revision[0].in_history(b).rev_id
1968
t = b.repository.revision_tree(rev_id)
1970
export(t, dest, format, root)
1971
except errors.NoSuchExportFormat, e:
1972
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1975
class cmd_cat(Command):
1976
"""Write the contents of a file as of a given revision to standard output.
1978
If no revision is nominated, the last revision is used.
1980
Note: Take care to redirect standard output when using this command on a
1984
takes_options = ['revision', 'name-from-revision']
1985
takes_args = ['filename']
1986
encoding_type = 'exact'
1989
def run(self, filename, revision=None, name_from_revision=False):
1990
if revision is not None and len(revision) != 1:
1991
raise errors.BzrCommandError("bzr cat --revision takes exactly"
1996
tree, b, relpath = \
1997
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
1998
except errors.NotBranchError:
2001
if revision is not None and revision[0].get_branch() is not None:
2002
b = Branch.open(revision[0].get_branch())
2004
tree = b.basis_tree()
2005
if revision is None:
2006
revision_id = b.last_revision()
2008
revision_id = revision[0].in_history(b).rev_id
2010
cur_file_id = tree.path2id(relpath)
2011
rev_tree = b.repository.revision_tree(revision_id)
2012
old_file_id = rev_tree.path2id(relpath)
2014
if name_from_revision:
2015
if old_file_id is None:
2016
raise errors.BzrCommandError("%r is not present in revision %s"
2017
% (filename, revision_id))
2019
rev_tree.print_file(old_file_id)
2020
elif cur_file_id is not None:
2021
rev_tree.print_file(cur_file_id)
2022
elif old_file_id is not None:
2023
rev_tree.print_file(old_file_id)
2025
raise errors.BzrCommandError("%r is not present in revision %s" %
2026
(filename, revision_id))
2029
class cmd_local_time_offset(Command):
2030
"""Show the offset in seconds from GMT to local time."""
2034
print osutils.local_time_offset()
2038
class cmd_commit(Command):
2039
"""Commit changes into a new revision.
2041
If no arguments are given, the entire tree is committed.
2043
If selected files are specified, only changes to those files are
2044
committed. If a directory is specified then the directory and everything
2045
within it is committed.
2047
A selected-file commit may fail in some cases where the committed
2048
tree would be invalid, such as trying to commit a file in a
2049
newly-added directory that is not itself committed.
2051
# TODO: Run hooks on tree to-be-committed, and after commit.
2053
# TODO: Strict commit that fails if there are deleted files.
2054
# (what does "deleted files" mean ??)
2056
# TODO: Give better message for -s, --summary, used by tla people
2058
# XXX: verbose currently does nothing
2060
takes_args = ['selected*']
2061
takes_options = ['message', 'verbose',
2063
help='commit even if nothing has changed'),
2064
Option('file', type=str,
2067
help='file containing commit message'),
2069
help="refuse to commit if there are unknown "
2070
"files in the working tree."),
2072
help="perform a local only commit in a bound "
2073
"branch. Such commits are not pushed to "
2074
"the master branch until a normal commit "
2078
aliases = ['ci', 'checkin']
2080
def run(self, message=None, file=None, verbose=True, selected_list=None,
2081
unchanged=False, strict=False, local=False):
2082
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
2083
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
2085
from bzrlib.msgeditor import edit_commit_message, \
2086
make_commit_message_template
2088
# TODO: Need a blackbox test for invoking the external editor; may be
2089
# slightly problematic to run this cross-platform.
2091
# TODO: do more checks that the commit will succeed before
2092
# spending the user's valuable time typing a commit message.
2093
tree, selected_list = tree_files(selected_list)
2094
if selected_list == ['']:
2095
# workaround - commit of root of tree should be exactly the same
2096
# as just default commit in that tree, and succeed even though
2097
# selected-file merge commit is not done yet
2100
if local and not tree.branch.get_bound_location():
2101
raise errors.LocalRequiresBoundBranch()
2103
def get_message(commit_obj):
2104
"""Callback to get commit message"""
2105
my_message = message
2106
if my_message is None and not file:
2107
template = make_commit_message_template(tree, selected_list)
2108
my_message = edit_commit_message(template)
2109
if my_message is None:
2110
raise errors.BzrCommandError("please specify a commit"
2111
" message with either --message or --file")
2112
elif my_message and file:
2113
raise errors.BzrCommandError(
2114
"please specify either --message or --file")
2116
my_message = codecs.open(file, 'rt',
2117
bzrlib.user_encoding).read()
2118
if my_message == "":
2119
raise errors.BzrCommandError("empty commit message specified")
2123
reporter = ReportCommitToLog()
2125
reporter = NullCommitReporter()
2128
tree.commit(message_callback=get_message,
2129
specific_files=selected_list,
2130
allow_pointless=unchanged, strict=strict, local=local,
2132
except PointlessCommit:
2133
# FIXME: This should really happen before the file is read in;
2134
# perhaps prepare the commit; get the message; then actually commit
2135
raise errors.BzrCommandError("no changes to commit."
2136
" use --unchanged to commit anyhow")
2137
except ConflictsInTree:
2138
raise errors.BzrCommandError('Conflicts detected in working '
2139
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2141
except StrictCommitFailed:
2142
raise errors.BzrCommandError("Commit refused because there are"
2143
" unknown files in the working tree.")
2144
except errors.BoundBranchOutOfDate, e:
2145
raise errors.BzrCommandError(str(e) + "\n"
2146
'To commit to master branch, run update and then commit.\n'
2147
'You can also pass --local to commit to continue working '
2151
class cmd_check(Command):
2152
"""Validate consistency of branch history.
2154
This command checks various invariants about the branch storage to
2155
detect data corruption or bzr bugs.
2157
takes_args = ['branch?']
2158
takes_options = ['verbose']
2160
def run(self, branch=None, verbose=False):
2161
from bzrlib.check import check
2163
tree = WorkingTree.open_containing()[0]
2164
branch = tree.branch
2166
branch = Branch.open(branch)
2167
check(branch, verbose)
2170
class cmd_upgrade(Command):
2171
"""Upgrade branch storage to current format.
2173
The check command or bzr developers may sometimes advise you to run
2174
this command. When the default format has changed you may also be warned
2175
during other operations to upgrade.
2177
takes_args = ['url?']
2179
RegistryOption('format',
2180
help='Upgrade to a specific format. See "bzr help'
2181
' formats" for details',
2182
registry=bzrdir.format_registry,
2183
converter=bzrdir.format_registry.make_bzrdir,
2184
value_switches=True, title='Branch format'),
2187
def run(self, url='.', format=None):
2188
from bzrlib.upgrade import upgrade
2190
format = bzrdir.format_registry.make_bzrdir('default')
2191
upgrade(url, format)
2194
class cmd_whoami(Command):
2195
"""Show or set bzr user id.
2199
bzr whoami 'Frank Chu <fchu@example.com>'
2201
takes_options = [ Option('email',
2202
help='display email address only'),
2204
help='set identity for the current branch instead of '
2207
takes_args = ['name?']
2208
encoding_type = 'replace'
2211
def run(self, email=False, branch=False, name=None):
2213
# use branch if we're inside one; otherwise global config
2215
c = Branch.open_containing('.')[0].get_config()
2216
except errors.NotBranchError:
2217
c = config.GlobalConfig()
2219
self.outf.write(c.user_email() + '\n')
2221
self.outf.write(c.username() + '\n')
2224
# display a warning if an email address isn't included in the given name.
2226
config.extract_email_address(name)
2227
except errors.NoEmailInUsername, e:
2228
warning('"%s" does not seem to contain an email address. '
2229
'This is allowed, but not recommended.', name)
2231
# use global config unless --branch given
2233
c = Branch.open_containing('.')[0].get_config()
2235
c = config.GlobalConfig()
2236
c.set_user_option('email', name)
2239
class cmd_nick(Command):
2240
"""Print or set the branch nickname.
2242
If unset, the tree root directory name is used as the nickname
2243
To print the current nickname, execute with no argument.
2245
takes_args = ['nickname?']
2246
def run(self, nickname=None):
2247
branch = Branch.open_containing(u'.')[0]
2248
if nickname is None:
2249
self.printme(branch)
2251
branch.nick = nickname
2254
def printme(self, branch):
2258
class cmd_selftest(Command):
2259
"""Run internal test suite.
2261
This creates temporary test directories in the working directory, but not
2262
existing data is affected. These directories are deleted if the tests
2263
pass, or left behind to help in debugging if they fail and --keep-output
2266
If arguments are given, they are regular expressions that say which tests
2267
should run. Tests matching any expression are run, and other tests are
2270
Alternatively if --first is given, matching tests are run first and then
2271
all other tests are run. This is useful if you have been working in a
2272
particular area, but want to make sure nothing else was broken.
2274
If the global option '--no-plugins' is given, plugins are not loaded
2275
before running the selftests. This has two effects: features provided or
2276
modified by plugins will not be tested, and tests provided by plugins will
2281
run only tests relating to 'ignore'
2282
bzr --no-plugins selftest -v
2283
disable plugins and list tests as they're run
2285
For each test, that needs actual disk access, bzr create their own
2286
subdirectory in the temporary testing directory (testXXXX.tmp).
2287
By default the name of such subdirectory is based on the name of the test.
2288
If option '--numbered-dirs' is given, bzr will use sequent numbers
2289
of running tests to create such subdirectories. This is default behavior
2290
on Windows because of path length limitation.
2292
# TODO: --list should give a list of all available tests
2294
# NB: this is used from the class without creating an instance, which is
2295
# why it does not have a self parameter.
2296
def get_transport_type(typestring):
2297
"""Parse and return a transport specifier."""
2298
if typestring == "sftp":
2299
from bzrlib.transport.sftp import SFTPAbsoluteServer
2300
return SFTPAbsoluteServer
2301
if typestring == "memory":
2302
from bzrlib.transport.memory import MemoryServer
2304
if typestring == "fakenfs":
2305
from bzrlib.transport.fakenfs import FakeNFSServer
2306
return FakeNFSServer
2307
msg = "No known transport type %s. Supported types are: sftp\n" %\
2309
raise errors.BzrCommandError(msg)
2312
takes_args = ['testspecs*']
2313
takes_options = ['verbose',
2314
Option('one', help='stop when one test fails'),
2315
Option('keep-output',
2316
help='keep output directories when tests fail'),
2318
help='Use a different transport by default '
2319
'throughout the test suite.',
2320
type=get_transport_type),
2321
Option('benchmark', help='run the bzr benchmarks.'),
2322
Option('lsprof-timed',
2323
help='generate lsprof output for benchmarked'
2324
' sections of code.'),
2325
Option('cache-dir', type=str,
2326
help='a directory to cache intermediate'
2327
' benchmark steps'),
2328
Option('clean-output',
2329
help='clean temporary tests directories'
2330
' without running tests'),
2332
help='run all tests, but run specified tests first'
2334
Option('numbered-dirs',
2335
help='use numbered dirs for TestCaseInTempDir'),
2337
encoding_type = 'replace'
2339
def run(self, testspecs_list=None, verbose=None, one=False,
2340
keep_output=False, transport=None, benchmark=None,
2341
lsprof_timed=None, cache_dir=None, clean_output=False,
2342
first=False, numbered_dirs=None):
2344
from bzrlib.tests import selftest
2345
import bzrlib.benchmarks as benchmarks
2346
from bzrlib.benchmarks import tree_creator
2349
from bzrlib.tests import clean_selftest_output
2350
clean_selftest_output()
2353
if numbered_dirs is None and sys.platform == 'win32':
2354
numbered_dirs = True
2356
if cache_dir is not None:
2357
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2358
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2359
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2361
if testspecs_list is not None:
2362
pattern = '|'.join(testspecs_list)
2366
test_suite_factory = benchmarks.test_suite
2369
# TODO: should possibly lock the history file...
2370
benchfile = open(".perf_history", "at", buffering=1)
2372
test_suite_factory = None
2377
result = selftest(verbose=verbose,
2379
stop_on_failure=one,
2380
keep_output=keep_output,
2381
transport=transport,
2382
test_suite_factory=test_suite_factory,
2383
lsprof_timed=lsprof_timed,
2384
bench_history=benchfile,
2385
matching_tests_first=first,
2386
numbered_dirs=numbered_dirs,
2389
if benchfile is not None:
2392
info('tests passed')
2394
info('tests failed')
2395
return int(not result)
2398
class cmd_version(Command):
2399
"""Show version of bzr."""
2403
from bzrlib.version import show_version
2407
class cmd_rocks(Command):
2408
"""Statement of optimism."""
2414
print "It sure does!"
2417
class cmd_find_merge_base(Command):
2418
"""Find and print a base revision for merging two branches."""
2419
# TODO: Options to specify revisions on either side, as if
2420
# merging only part of the history.
2421
takes_args = ['branch', 'other']
2425
def run(self, branch, other):
2426
from bzrlib.revision import MultipleRevisionSources
2428
branch1 = Branch.open_containing(branch)[0]
2429
branch2 = Branch.open_containing(other)[0]
2431
last1 = branch1.last_revision()
2432
last2 = branch2.last_revision()
2434
source = MultipleRevisionSources(branch1.repository,
2437
base_rev_id = common_ancestor(last1, last2, source)
2439
print 'merge base is revision %s' % base_rev_id
2442
class cmd_merge(Command):
2443
"""Perform a three-way merge.
2445
The branch is the branch you will merge from. By default, it will merge
2446
the latest revision. If you specify a revision, that revision will be
2447
merged. If you specify two revisions, the first will be used as a BASE,
2448
and the second one as OTHER. Revision numbers are always relative to the
2451
By default, bzr will try to merge in all new work from the other
2452
branch, automatically determining an appropriate base. If this
2453
fails, you may need to give an explicit base.
2455
Merge will do its best to combine the changes in two branches, but there
2456
are some kinds of problems only a human can fix. When it encounters those,
2457
it will mark a conflict. A conflict means that you need to fix something,
2458
before you should commit.
2460
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2462
If there is no default branch set, the first merge will set it. After
2463
that, you can omit the branch to use the default. To change the
2464
default, use --remember. The value will only be saved if the remote
2465
location can be accessed.
2467
The results of the merge are placed into the destination working
2468
directory, where they can be reviewed (with bzr diff), tested, and then
2469
committed to record the result of the merge.
2473
To merge the latest revision from bzr.dev
2474
bzr merge ../bzr.dev
2476
To merge changes up to and including revision 82 from bzr.dev
2477
bzr merge -r 82 ../bzr.dev
2479
To merge the changes introduced by 82, without previous changes:
2480
bzr merge -r 81..82 ../bzr.dev
2482
merge refuses to run if there are any uncommitted changes, unless
2485
takes_args = ['branch?']
2486
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2487
Option('show-base', help="Show base revision text in "
2489
Option('uncommitted', help='Apply uncommitted changes'
2490
' from a working copy, instead of branch changes'),
2491
Option('pull', help='If the destination is already'
2492
' completely merged into the source, pull from the'
2493
' source rather than merging. When this happens,'
2494
' you do not need to commit the result.'),
2496
help='Branch to merge into, '
2497
'rather than the one containing the working directory',
2503
def run(self, branch=None, revision=None, force=False, merge_type=None,
2504
show_base=False, reprocess=False, remember=False,
2505
uncommitted=False, pull=False,
2508
from bzrlib.tag import _merge_tags_if_possible
2509
if merge_type is None:
2510
merge_type = _mod_merge.Merge3Merger
2512
if directory is None: directory = u'.'
2513
# XXX: jam 20070225 WorkingTree should be locked before you extract its
2514
# inventory. Because merge is a mutating operation, it really
2515
# should be a lock_write() for the whole cmd_merge operation.
2516
# However, cmd_merge open's its own tree in _merge_helper, which
2517
# means if we lock here, the later lock_write() will always block.
2518
# Either the merge helper code should be updated to take a tree,
2519
# (What about tree.merge_from_branch?)
2520
tree = WorkingTree.open_containing(directory)[0]
2521
change_reporter = delta._ChangeReporter(
2522
unversioned_filter=tree.is_ignored)
2524
if branch is not None:
2526
reader = bundle.read_bundle_from_url(branch)
2527
except errors.NotABundle:
2528
pass # Continue on considering this url a Branch
2530
conflicts = merge_bundle(reader, tree, not force, merge_type,
2531
reprocess, show_base, change_reporter)
2537
if revision is None \
2538
or len(revision) < 1 or revision[0].needs_branch():
2539
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2541
if revision is None or len(revision) < 1:
2544
other = [branch, None]
2547
other = [branch, -1]
2548
other_branch, path = Branch.open_containing(branch)
2551
raise errors.BzrCommandError('Cannot use --uncommitted and'
2552
' --revision at the same time.')
2553
branch = revision[0].get_branch() or branch
2554
if len(revision) == 1:
2556
other_branch, path = Branch.open_containing(branch)
2557
revno = revision[0].in_history(other_branch).revno
2558
other = [branch, revno]
2560
assert len(revision) == 2
2561
if None in revision:
2562
raise errors.BzrCommandError(
2563
"Merge doesn't permit empty revision specifier.")
2564
base_branch, path = Branch.open_containing(branch)
2565
branch1 = revision[1].get_branch() or branch
2566
other_branch, path1 = Branch.open_containing(branch1)
2567
if revision[0].get_branch() is not None:
2568
# then path was obtained from it, and is None.
2571
base = [branch, revision[0].in_history(base_branch).revno]
2572
other = [branch1, revision[1].in_history(other_branch).revno]
2574
if tree.branch.get_parent() is None or remember:
2575
tree.branch.set_parent(other_branch.base)
2577
# pull tags now... it's a bit inconsistent to do it ahead of copying
2578
# the history but that's done inside the merge code
2579
_merge_tags_if_possible(other_branch, tree.branch)
2582
interesting_files = [path]
2584
interesting_files = None
2585
pb = ui.ui_factory.nested_progress_bar()
2588
conflict_count = _merge_helper(
2589
other, base, check_clean=(not force),
2590
merge_type=merge_type,
2591
reprocess=reprocess,
2592
show_base=show_base,
2595
pb=pb, file_list=interesting_files,
2596
change_reporter=change_reporter)
2599
if conflict_count != 0:
2603
except errors.AmbiguousBase, e:
2604
m = ("sorry, bzr can't determine the right merge base yet\n"
2605
"candidates are:\n "
2606
+ "\n ".join(e.bases)
2608
"please specify an explicit base with -r,\n"
2609
"and (if you want) report this to the bzr developers\n")
2612
# TODO: move up to common parent; this isn't merge-specific anymore.
2613
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2614
"""Use tree.branch's parent if none was supplied.
2616
Report if the remembered location was used.
2618
if supplied_location is not None:
2619
return supplied_location
2620
stored_location = tree.branch.get_parent()
2621
mutter("%s", stored_location)
2622
if stored_location is None:
2623
raise errors.BzrCommandError("No location specified or remembered")
2624
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2625
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2626
return stored_location
2629
class cmd_remerge(Command):
2632
Use this if you want to try a different merge technique while resolving
2633
conflicts. Some merge techniques are better than others, and remerge
2634
lets you try different ones on different files.
2636
The options for remerge have the same meaning and defaults as the ones for
2637
merge. The difference is that remerge can (only) be run when there is a
2638
pending merge, and it lets you specify particular files.
2641
$ bzr remerge --show-base
2642
Re-do the merge of all conflicted files, and show the base text in
2643
conflict regions, in addition to the usual THIS and OTHER texts.
2645
$ bzr remerge --merge-type weave --reprocess foobar
2646
Re-do the merge of "foobar", using the weave merge algorithm, with
2647
additional processing to reduce the size of conflict regions.
2649
takes_args = ['file*']
2650
takes_options = ['merge-type', 'reprocess',
2651
Option('show-base', help="Show base revision text in "
2654
def run(self, file_list=None, merge_type=None, show_base=False,
2656
if merge_type is None:
2657
merge_type = _mod_merge.Merge3Merger
2658
tree, file_list = tree_files(file_list)
2661
parents = tree.get_parent_ids()
2662
if len(parents) != 2:
2663
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2664
" merges. Not cherrypicking or"
2666
repository = tree.branch.repository
2667
base_revision = common_ancestor(parents[0],
2668
parents[1], repository)
2669
base_tree = repository.revision_tree(base_revision)
2670
other_tree = repository.revision_tree(parents[1])
2671
interesting_ids = None
2673
conflicts = tree.conflicts()
2674
if file_list is not None:
2675
interesting_ids = set()
2676
for filename in file_list:
2677
file_id = tree.path2id(filename)
2679
raise errors.NotVersionedError(filename)
2680
interesting_ids.add(file_id)
2681
if tree.kind(file_id) != "directory":
2684
for name, ie in tree.inventory.iter_entries(file_id):
2685
interesting_ids.add(ie.file_id)
2686
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2688
# Remerge only supports resolving contents conflicts
2689
allowed_conflicts = ('text conflict', 'contents conflict')
2690
restore_files = [c.path for c in conflicts
2691
if c.typestring in allowed_conflicts]
2692
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2693
tree.set_conflicts(ConflictList(new_conflicts))
2694
if file_list is not None:
2695
restore_files = file_list
2696
for filename in restore_files:
2698
restore(tree.abspath(filename))
2699
except errors.NotConflicted:
2701
conflicts = _mod_merge.merge_inner(
2702
tree.branch, other_tree, base_tree,
2704
interesting_ids=interesting_ids,
2705
other_rev_id=parents[1],
2706
merge_type=merge_type,
2707
show_base=show_base,
2708
reprocess=reprocess)
2717
class cmd_revert(Command):
2718
"""Revert files to a previous revision.
2720
Giving a list of files will revert only those files. Otherwise, all files
2721
will be reverted. If the revision is not specified with '--revision', the
2722
last committed revision is used.
2724
To remove only some changes, without reverting to a prior version, use
2725
merge instead. For example, "merge . --r-2..-3" will remove the changes
2726
introduced by -2, without affecting the changes introduced by -1. Or
2727
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2729
By default, any files that have been manually changed will be backed up
2730
first. (Files changed only by merge are not backed up.) Backup files have
2731
'.~#~' appended to their name, where # is a number.
2733
When you provide files, you can use their current pathname or the pathname
2734
from the target revision. So you can use revert to "undelete" a file by
2735
name. If you name a directory, all the contents of that directory will be
2738
takes_options = ['revision', 'no-backup']
2739
takes_args = ['file*']
2741
def run(self, revision=None, no_backup=False, file_list=None):
2742
if file_list is not None:
2743
if len(file_list) == 0:
2744
raise errors.BzrCommandError("No files specified")
2748
tree, file_list = tree_files(file_list)
2749
if revision is None:
2750
# FIXME should be tree.last_revision
2751
rev_id = tree.last_revision()
2752
elif len(revision) != 1:
2753
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2755
rev_id = revision[0].in_history(tree.branch).rev_id
2756
pb = ui.ui_factory.nested_progress_bar()
2758
tree.revert(file_list,
2759
tree.branch.repository.revision_tree(rev_id),
2760
not no_backup, pb, report_changes=True)
2765
class cmd_assert_fail(Command):
2766
"""Test reporting of assertion failures"""
2767
# intended just for use in testing
2772
raise AssertionError("always fails")
2775
class cmd_help(Command):
2776
"""Show help on a command or other topic.
2778
For a list of all available commands, say 'bzr help commands'.
2780
takes_options = [Option('long', 'show help on all commands')]
2781
takes_args = ['topic?']
2782
aliases = ['?', '--help', '-?', '-h']
2785
def run(self, topic=None, long=False):
2787
if topic is None and long:
2789
bzrlib.help.help(topic)
2792
class cmd_shell_complete(Command):
2793
"""Show appropriate completions for context.
2795
For a list of all available commands, say 'bzr shell-complete'.
2797
takes_args = ['context?']
2802
def run(self, context=None):
2803
import shellcomplete
2804
shellcomplete.shellcomplete(context)
2807
class cmd_fetch(Command):
2808
"""Copy in history from another branch but don't merge it.
2810
This is an internal method used for pull and merge.
2813
takes_args = ['from_branch', 'to_branch']
2814
def run(self, from_branch, to_branch):
2815
from bzrlib.fetch import Fetcher
2816
from_b = Branch.open(from_branch)
2817
to_b = Branch.open(to_branch)
2818
Fetcher(to_b, from_b)
2821
class cmd_missing(Command):
2822
"""Show unmerged/unpulled revisions between two branches.
2824
OTHER_BRANCH may be local or remote.
2826
takes_args = ['other_branch?']
2827
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2829
'Display changes in the local branch only'),
2830
Option('theirs-only',
2831
'Display changes in the remote branch only'),
2836
encoding_type = 'replace'
2839
def run(self, other_branch=None, reverse=False, mine_only=False,
2840
theirs_only=False, log_format=None, long=False, short=False, line=False,
2841
show_ids=False, verbose=False):
2842
from bzrlib.missing import find_unmerged, iter_log_data
2843
from bzrlib.log import log_formatter
2844
local_branch = Branch.open_containing(u".")[0]
2845
parent = local_branch.get_parent()
2846
if other_branch is None:
2847
other_branch = parent
2848
if other_branch is None:
2849
raise errors.BzrCommandError("No peer location known or specified.")
2850
display_url = urlutils.unescape_for_display(parent,
2852
print "Using last location: " + display_url
2854
remote_branch = Branch.open(other_branch)
2855
if remote_branch.base == local_branch.base:
2856
remote_branch = local_branch
2857
local_branch.lock_read()
2859
remote_branch.lock_read()
2861
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2862
if (log_format is None):
2863
log_format = log.log_formatter_registry.get_default(
2865
lf = log_format(to_file=self.outf,
2867
show_timezone='original')
2868
if reverse is False:
2869
local_extra.reverse()
2870
remote_extra.reverse()
2871
if local_extra and not theirs_only:
2872
print "You have %d extra revision(s):" % len(local_extra)
2873
for data in iter_log_data(local_extra, local_branch.repository,
2876
printed_local = True
2878
printed_local = False
2879
if remote_extra and not mine_only:
2880
if printed_local is True:
2882
print "You are missing %d revision(s):" % len(remote_extra)
2883
for data in iter_log_data(remote_extra, remote_branch.repository,
2886
if not remote_extra and not local_extra:
2888
print "Branches are up to date."
2892
remote_branch.unlock()
2894
local_branch.unlock()
2895
if not status_code and parent is None and other_branch is not None:
2896
local_branch.lock_write()
2898
# handle race conditions - a parent might be set while we run.
2899
if local_branch.get_parent() is None:
2900
local_branch.set_parent(remote_branch.base)
2902
local_branch.unlock()
2906
class cmd_plugins(Command):
2911
import bzrlib.plugin
2912
from inspect import getdoc
2913
for name, plugin in bzrlib.plugin.all_plugins().items():
2914
if getattr(plugin, '__path__', None) is not None:
2915
print plugin.__path__[0]
2916
elif getattr(plugin, '__file__', None) is not None:
2917
print plugin.__file__
2923
print '\t', d.split('\n')[0]
2926
class cmd_testament(Command):
2927
"""Show testament (signing-form) of a revision."""
2928
takes_options = ['revision',
2929
Option('long', help='Produce long-format testament'),
2930
Option('strict', help='Produce a strict-format'
2932
takes_args = ['branch?']
2934
def run(self, branch=u'.', revision=None, long=False, strict=False):
2935
from bzrlib.testament import Testament, StrictTestament
2937
testament_class = StrictTestament
2939
testament_class = Testament
2940
b = WorkingTree.open_containing(branch)[0].branch
2943
if revision is None:
2944
rev_id = b.last_revision()
2946
rev_id = revision[0].in_history(b).rev_id
2947
t = testament_class.from_revision(b.repository, rev_id)
2949
sys.stdout.writelines(t.as_text_lines())
2951
sys.stdout.write(t.as_short_text())
2956
class cmd_annotate(Command):
2957
"""Show the origin of each line in a file.
2959
This prints out the given file with an annotation on the left side
2960
indicating which revision, author and date introduced the change.
2962
If the origin is the same for a run of consecutive lines, it is
2963
shown only at the top, unless the --all option is given.
2965
# TODO: annotate directories; showing when each file was last changed
2966
# TODO: if the working copy is modified, show annotations on that
2967
# with new uncommitted lines marked
2968
aliases = ['ann', 'blame', 'praise']
2969
takes_args = ['filename']
2970
takes_options = [Option('all', help='show annotations on all lines'),
2971
Option('long', help='show date in annotations'),
2977
def run(self, filename, all=False, long=False, revision=None,
2979
from bzrlib.annotate import annotate_file
2980
tree, relpath = WorkingTree.open_containing(filename)
2981
branch = tree.branch
2984
if revision is None:
2985
revision_id = branch.last_revision()
2986
elif len(revision) != 1:
2987
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2989
revision_id = revision[0].in_history(branch).rev_id
2990
file_id = tree.path2id(relpath)
2991
tree = branch.repository.revision_tree(revision_id)
2992
file_version = tree.inventory[file_id].revision
2993
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
2999
class cmd_re_sign(Command):
3000
"""Create a digital signature for an existing revision."""
3001
# TODO be able to replace existing ones.
3003
hidden = True # is this right ?
3004
takes_args = ['revision_id*']
3005
takes_options = ['revision']
3007
def run(self, revision_id_list=None, revision=None):
3008
import bzrlib.gpg as gpg
3009
if revision_id_list is not None and revision is not None:
3010
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3011
if revision_id_list is None and revision is None:
3012
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3013
b = WorkingTree.open_containing(u'.')[0].branch
3014
gpg_strategy = gpg.GPGStrategy(b.get_config())
3015
if revision_id_list is not None:
3016
for revision_id in revision_id_list:
3017
b.repository.sign_revision(revision_id, gpg_strategy)
3018
elif revision is not None:
3019
if len(revision) == 1:
3020
revno, rev_id = revision[0].in_history(b)
3021
b.repository.sign_revision(rev_id, gpg_strategy)
3022
elif len(revision) == 2:
3023
# are they both on rh- if so we can walk between them
3024
# might be nice to have a range helper for arbitrary
3025
# revision paths. hmm.
3026
from_revno, from_revid = revision[0].in_history(b)
3027
to_revno, to_revid = revision[1].in_history(b)
3028
if to_revid is None:
3029
to_revno = b.revno()
3030
if from_revno is None or to_revno is None:
3031
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3032
for revno in range(from_revno, to_revno + 1):
3033
b.repository.sign_revision(b.get_rev_id(revno),
3036
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3039
class cmd_bind(Command):
3040
"""Convert the current branch into a checkout of the supplied branch.
3042
Once converted into a checkout, commits must succeed on the master branch
3043
before they will be applied to the local branch.
3045
See "help checkouts" for more information on checkouts.
3048
takes_args = ['location?']
3051
def run(self, location=None):
3052
b, relpath = Branch.open_containing(u'.')
3053
if location is None:
3055
location = b.get_old_bound_location()
3056
except errors.UpgradeRequired:
3057
raise errors.BzrCommandError('No location supplied. '
3058
'This format does not remember old locations.')
3060
if location is None:
3061
raise errors.BzrCommandError('No location supplied and no '
3062
'previous location known')
3063
b_other = Branch.open(location)
3066
except errors.DivergedBranches:
3067
raise errors.BzrCommandError('These branches have diverged.'
3068
' Try merging, and then bind again.')
3071
class cmd_unbind(Command):
3072
"""Convert the current checkout into a regular branch.
3074
After unbinding, the local branch is considered independent and subsequent
3075
commits will be local only.
3077
See "help checkouts" for more information on checkouts.
3084
b, relpath = Branch.open_containing(u'.')
3086
raise errors.BzrCommandError('Local branch is not bound')
3089
class cmd_uncommit(Command):
3090
"""Remove the last committed revision.
3092
--verbose will print out what is being removed.
3093
--dry-run will go through all the motions, but not actually
3096
In the future, uncommit will create a revision bundle, which can then
3100
# TODO: jam 20060108 Add an option to allow uncommit to remove
3101
# unreferenced information in 'branch-as-repository' branches.
3102
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3103
# information in shared branches as well.
3104
takes_options = ['verbose', 'revision',
3105
Option('dry-run', help='Don\'t actually make changes'),
3106
Option('force', help='Say yes to all questions.')]
3107
takes_args = ['location?']
3110
def run(self, location=None,
3111
dry_run=False, verbose=False,
3112
revision=None, force=False):
3113
from bzrlib.log import log_formatter, show_log
3115
from bzrlib.uncommit import uncommit
3117
if location is None:
3119
control, relpath = bzrdir.BzrDir.open_containing(location)
3121
tree = control.open_workingtree()
3123
except (errors.NoWorkingTree, errors.NotLocalUrl):
3125
b = control.open_branch()
3128
if revision is None:
3131
# 'bzr uncommit -r 10' actually means uncommit
3132
# so that the final tree is at revno 10.
3133
# but bzrlib.uncommit.uncommit() actually uncommits
3134
# the revisions that are supplied.
3135
# So we need to offset it by one
3136
revno = revision[0].in_history(b).revno+1
3138
if revno <= b.revno():
3139
rev_id = b.get_rev_id(revno)
3141
self.outf.write('No revisions to uncommit.\n')
3144
lf = log_formatter('short',
3146
show_timezone='original')
3151
direction='forward',
3152
start_revision=revno,
3153
end_revision=b.revno())
3156
print 'Dry-run, pretending to remove the above revisions.'
3158
val = raw_input('Press <enter> to continue')
3160
print 'The above revision(s) will be removed.'
3162
val = raw_input('Are you sure [y/N]? ')
3163
if val.lower() not in ('y', 'yes'):
3167
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3171
class cmd_break_lock(Command):
3172
"""Break a dead lock on a repository, branch or working directory.
3174
CAUTION: Locks should only be broken when you are sure that the process
3175
holding the lock has been stopped.
3177
You can get information on what locks are open via the 'bzr info' command.
3182
takes_args = ['location?']
3184
def run(self, location=None, show=False):
3185
if location is None:
3187
control, relpath = bzrdir.BzrDir.open_containing(location)
3189
control.break_lock()
3190
except NotImplementedError:
3194
class cmd_wait_until_signalled(Command):
3195
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3197
This just prints a line to signal when it is ready, then blocks on stdin.
3203
sys.stdout.write("running\n")
3205
sys.stdin.readline()
3208
class cmd_serve(Command):
3209
"""Run the bzr server."""
3211
aliases = ['server']
3215
help='serve on stdin/out for use from inetd or sshd'),
3217
help='listen for connections on nominated port of the form '
3218
'[hostname:]portnumber. Passing 0 as the port number will '
3219
'result in a dynamically allocated port. Default port is '
3223
help='serve contents of directory',
3225
Option('allow-writes',
3226
help='By default the server is a readonly server. Supplying '
3227
'--allow-writes enables write access to the contents of '
3228
'the served directory and below. '
3232
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3233
from bzrlib.transport import smart
3234
from bzrlib.transport import get_transport
3235
if directory is None:
3236
directory = os.getcwd()
3237
url = urlutils.local_path_to_url(directory)
3238
if not allow_writes:
3239
url = 'readonly+' + url
3240
t = get_transport(url)
3242
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
3245
port = smart.BZR_DEFAULT_PORT
3249
host, port = port.split(':')
3253
server = smart.SmartTCPServer(t, host=host, port=port)
3254
print 'listening on port: ', server.port
3258
class cmd_join(Command):
3259
"""Combine a subtree into its containing tree.
3261
This command is for experimental use only. It requires the target tree
3262
to be in dirstate-with-subtree format, which cannot be converted into
3265
The TREE argument should be an independent tree, inside another tree, but
3266
not part of it. (Such trees can be produced by "bzr split", but also by
3267
running "bzr branch" with the target inside a tree.)
3269
The result is a combined tree, with the subtree no longer an independant
3270
part. This is marked as a merge of the subtree into the containing tree,
3271
and all history is preserved.
3273
If --reference is specified, the subtree retains its independence. It can
3274
be branched by itself, and can be part of multiple projects at the same
3275
time. But operations performed in the containing tree, such as commit
3276
and merge, will recurse into the subtree.
3279
takes_args = ['tree']
3280
takes_options = [Option('reference', 'join by reference')]
3283
def run(self, tree, reference=False):
3284
sub_tree = WorkingTree.open(tree)
3285
parent_dir = osutils.dirname(sub_tree.basedir)
3286
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3287
repo = containing_tree.branch.repository
3288
if not repo.supports_rich_root():
3289
raise errors.BzrCommandError(
3290
"Can't join trees because %s doesn't support rich root data.\n"
3291
"You can use bzr upgrade on the repository."
3295
containing_tree.add_reference(sub_tree)
3296
except errors.BadReferenceTarget, e:
3297
# XXX: Would be better to just raise a nicely printable
3298
# exception from the real origin. Also below. mbp 20070306
3299
raise errors.BzrCommandError("Cannot join %s. %s" %
3303
containing_tree.subsume(sub_tree)
3304
except errors.BadSubsumeSource, e:
3305
raise errors.BzrCommandError("Cannot join %s. %s" %
3309
class cmd_split(Command):
3310
"""Split a tree into two trees.
3312
This command is for experimental use only. It requires the target tree
3313
to be in dirstate-with-subtree format, which cannot be converted into
3316
The TREE argument should be a subdirectory of a working tree. That
3317
subdirectory will be converted into an independent tree, with its own
3318
branch. Commits in the top-level tree will not apply to the new subtree.
3319
If you want that behavior, do "bzr join --reference TREE".
3321
To undo this operation, do "bzr join TREE".
3324
takes_args = ['tree']
3328
def run(self, tree):
3329
containing_tree, subdir = WorkingTree.open_containing(tree)
3330
sub_id = containing_tree.path2id(subdir)
3332
raise errors.NotVersionedError(subdir)
3334
containing_tree.extract(sub_id)
3335
except errors.RootNotRich:
3336
raise errors.UpgradeRequired(containing_tree.branch.base)
3340
class cmd_merge_directive(Command):
3341
"""Generate a merge directive for auto-merge tools.
3343
A directive requests a merge to be performed, and also provides all the
3344
information necessary to do so. This means it must either include a
3345
revision bundle, or the location of a branch containing the desired
3348
A submit branch (the location to merge into) must be supplied the first
3349
time the command is issued. After it has been supplied once, it will
3350
be remembered as the default.
3352
A public branch is optional if a revision bundle is supplied, but required
3353
if --diff or --plain is specified. It will be remembered as the default
3354
after the first use.
3357
takes_args = ['submit_branch?', 'public_branch?']
3360
RegistryOption.from_kwargs('patch-type',
3361
'The type of patch to include in the directive',
3362
title='Patch type', value_switches=True, enum_switch=False,
3363
bundle='Bazaar revision bundle (default)',
3364
diff='Normal unified diff',
3365
plain='No patch, just directive'),
3366
Option('sign', help='GPG-sign the directive'), 'revision',
3367
Option('mail-to', type=str,
3368
help='Instead of printing the directive, email to this address'),
3369
Option('message', type=str, short_name='m',
3370
help='Message to use when committing this merge')
3373
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3374
sign=False, revision=None, mail_to=None, message=None):
3375
if patch_type == 'plain':
3377
branch = Branch.open('.')
3378
stored_submit_branch = branch.get_submit_branch()
3379
if submit_branch is None:
3380
submit_branch = stored_submit_branch
3382
if stored_submit_branch is None:
3383
branch.set_submit_branch(submit_branch)
3384
if submit_branch is None:
3385
submit_branch = branch.get_parent()
3386
if submit_branch is None:
3387
raise errors.BzrCommandError('No submit branch specified or known')
3389
stored_public_branch = branch.get_public_branch()
3390
if public_branch is None:
3391
public_branch = stored_public_branch
3392
elif stored_public_branch is None:
3393
branch.set_public_branch(public_branch)
3394
if patch_type != "bundle" and public_branch is None:
3395
raise errors.BzrCommandError('No public branch specified or'
3397
if revision is not None:
3398
if len(revision) != 1:
3399
raise errors.BzrCommandError('bzr merge-directive takes '
3400
'exactly one revision identifier')
3402
revision_id = revision[0].in_history(branch).rev_id
3404
revision_id = branch.last_revision()
3405
directive = merge_directive.MergeDirective.from_objects(
3406
branch.repository, revision_id, time.time(),
3407
osutils.local_time_offset(), submit_branch,
3408
public_branch=public_branch, patch_type=patch_type,
3412
self.outf.write(directive.to_signed(branch))
3414
self.outf.writelines(directive.to_lines())
3416
message = directive.to_email(mail_to, branch, sign)
3418
server = branch.get_config().get_user_option('smtp_server')
3420
server = 'localhost'
3422
s.sendmail(message['From'], message['To'], message.as_string())
3425
class cmd_tag(Command):
3426
"""Create a tag naming a revision.
3428
Tags give human-meaningful names to revisions. Commands that take a -r
3429
(--revision) option can be given -rtag:X, where X is any previously
3432
Tags are stored in the branch. Tags are copied from one branch to another
3433
along when you branch, push, pull or merge.
3435
It is an error to give a tag name that already exists unless you pass
3436
--force, in which case the tag is moved to point to the new revision.
3439
takes_args = ['tag_name']
3442
help='Delete this tag rather than placing it.',
3445
help='Branch in which to place the tag.',
3450
help='Replace existing tags',
3455
def run(self, tag_name,
3461
branch, relpath = Branch.open_containing(directory)
3465
branch.tags.delete_tag(tag_name)
3466
self.outf.write('Deleted tag %s.\n' % tag_name)
3469
if len(revision) != 1:
3470
raise errors.BzrCommandError(
3471
"Tags can only be placed on a single revision, "
3473
revision_id = revision[0].in_history(branch).rev_id
3475
revision_id = branch.last_revision()
3476
if (not force) and branch.tags.has_tag(tag_name):
3477
raise errors.TagAlreadyExists(tag_name)
3478
branch.tags.set_tag(tag_name, revision_id)
3479
self.outf.write('Created tag %s.\n' % tag_name)
3484
class cmd_tags(Command):
3487
This tag shows a table of tag names and the revisions they reference.
3492
help='Branch whose tags should be displayed',
3502
branch, relpath = Branch.open_containing(directory)
3503
for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
3504
self.outf.write('%-20s %s\n' % (tag_name, target))
3507
# command-line interpretation helper for merge-related commands
3508
def _merge_helper(other_revision, base_revision,
3509
check_clean=True, ignore_zero=False,
3510
this_dir=None, backup_files=False,
3512
file_list=None, show_base=False, reprocess=False,
3515
change_reporter=None):
3516
"""Merge changes into a tree.
3519
list(path, revno) Base for three-way merge.
3520
If [None, None] then a base will be automatically determined.
3522
list(path, revno) Other revision for three-way merge.
3524
Directory to merge changes into; '.' by default.
3526
If true, this_dir must have no uncommitted changes before the
3528
ignore_zero - If true, suppress the "zero conflicts" message when
3529
there are no conflicts; should be set when doing something we expect
3530
to complete perfectly.
3531
file_list - If supplied, merge only changes to selected files.
3533
All available ancestors of other_revision and base_revision are
3534
automatically pulled into the branch.
3536
The revno may be -1 to indicate the last revision on the branch, which is
3539
This function is intended for use from the command line; programmatic
3540
clients might prefer to call merge.merge_inner(), which has less magic
3543
# Loading it late, so that we don't always have to import bzrlib.merge
3544
if merge_type is None:
3545
merge_type = _mod_merge.Merge3Merger
3546
if this_dir is None:
3548
this_tree = WorkingTree.open_containing(this_dir)[0]
3549
if show_base and not merge_type is _mod_merge.Merge3Merger:
3550
raise errors.BzrCommandError("Show-base is not supported for this merge"
3551
" type. %s" % merge_type)
3552
if reprocess and not merge_type.supports_reprocess:
3553
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3554
" type %s." % merge_type)
3555
if reprocess and show_base:
3556
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3557
# TODO: jam 20070226 We should really lock these trees earlier. However, we
3558
# only want to take out a lock_tree_write() if we don't have to pull
3559
# any ancestry. But merge might fetch ancestry in the middle, in
3560
# which case we would need a lock_write().
3561
# Because we cannot upgrade locks, for now we live with the fact that
3562
# the tree will be locked multiple times during a merge. (Maybe
3563
# read-only some of the time, but it means things will get read
3566
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3567
pb=pb, change_reporter=change_reporter)
3568
merger.pp = ProgressPhase("Merge phase", 5, pb)
3569
merger.pp.next_phase()
3570
merger.check_basis(check_clean)
3571
merger.set_other(other_revision)
3572
merger.pp.next_phase()
3573
merger.set_base(base_revision)
3574
if merger.base_rev_id == merger.other_rev_id:
3575
note('Nothing to do.')
3577
if file_list is None:
3578
if pull and merger.base_rev_id == merger.this_rev_id:
3579
# FIXME: deduplicate with pull
3580
result = merger.this_tree.pull(merger.this_branch,
3581
False, merger.other_rev_id)
3582
if result.old_revid == result.new_revid:
3583
note('No revisions to pull.')
3585
note('Now on revision %d.' % result.new_revno)
3587
merger.backup_files = backup_files
3588
merger.merge_type = merge_type
3589
merger.set_interesting_files(file_list)
3590
merger.show_base = show_base
3591
merger.reprocess = reprocess
3592
conflicts = merger.do_merge()
3593
if file_list is None:
3594
merger.set_pending()
3601
merge = _merge_helper
3604
# these get imported and then picked up by the scan for cmd_*
3605
# TODO: Some more consistent way to split command definitions across files;
3606
# we do need to load at least some information about them to know of
3607
# aliases. ideally we would avoid loading the implementation until the
3608
# details were needed.
3609
from bzrlib.cmd_version_info import cmd_version_info
3610
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3611
from bzrlib.bundle.commands import cmd_bundle_revisions
3612
from bzrlib.sign_my_commits import cmd_sign_my_commits
3613
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3614
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
