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
revision_id = osutils.safe_revision_id(revision_id, warn=False)
222
if revision_id is not None and revision is not None:
223
raise errors.BzrCommandError('You can only supply one of'
224
' revision_id or --revision')
225
if revision_id is None and revision is None:
226
raise errors.BzrCommandError('You must supply either'
227
' --revision or a revision_id')
228
b = WorkingTree.open_containing(u'.')[0].branch
230
# TODO: jam 20060112 should cat-revision always output utf-8?
231
if revision_id is not None:
232
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
233
elif revision is not None:
236
raise errors.BzrCommandError('You cannot specify a NULL'
238
revno, rev_id = rev.in_history(b)
239
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
242
class cmd_remove_tree(Command):
243
"""Remove the working tree from a given branch/checkout.
245
Since a lightweight checkout is little more than a working tree
246
this will refuse to run against one.
249
takes_args = ['location?']
251
def run(self, location='.'):
252
d = bzrdir.BzrDir.open(location)
255
working = d.open_workingtree()
256
except errors.NoWorkingTree:
257
raise errors.BzrCommandError("No working tree to remove")
258
except errors.NotLocalUrl:
259
raise errors.BzrCommandError("You cannot remove the working tree of a "
262
working_path = working.bzrdir.root_transport.base
263
branch_path = working.branch.bzrdir.root_transport.base
264
if working_path != branch_path:
265
raise errors.BzrCommandError("You cannot remove the working tree from "
266
"a lightweight checkout")
268
d.destroy_workingtree()
271
class cmd_revno(Command):
272
"""Show current revision number.
274
This is equal to the number of revisions on this branch.
277
takes_args = ['location?']
280
def run(self, location=u'.'):
281
self.outf.write(str(Branch.open_containing(location)[0].revno()))
282
self.outf.write('\n')
285
class cmd_revision_info(Command):
286
"""Show revision number and revision id for a given revision identifier.
289
takes_args = ['revision_info*']
290
takes_options = ['revision']
293
def run(self, revision=None, revision_info_list=[]):
296
if revision is not None:
297
revs.extend(revision)
298
if revision_info_list is not None:
299
for rev in revision_info_list:
300
revs.append(RevisionSpec.from_string(rev))
302
raise errors.BzrCommandError('You must supply a revision identifier')
304
b = WorkingTree.open_containing(u'.')[0].branch
307
revinfo = rev.in_history(b)
308
if revinfo.revno is None:
309
print ' %s' % revinfo.rev_id
311
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
314
class cmd_add(Command):
315
"""Add specified files or directories.
317
In non-recursive mode, all the named items are added, regardless
318
of whether they were previously ignored. A warning is given if
319
any of the named files are already versioned.
321
In recursive mode (the default), files are treated the same way
322
but the behaviour for directories is different. Directories that
323
are already versioned do not give a warning. All directories,
324
whether already versioned or not, are searched for files or
325
subdirectories that are neither versioned or ignored, and these
326
are added. This search proceeds recursively into versioned
327
directories. If no names are given '.' is assumed.
329
Therefore simply saying 'bzr add' will version all files that
330
are currently unknown.
332
Adding a file whose parent directory is not versioned will
333
implicitly add the parent, and so on up to the root. This means
334
you should never need to explicitly add a directory, they'll just
335
get added when you add a file in the directory.
337
--dry-run will show which files would be added, but not actually
340
--file-ids-from will try to use the file ids from the supplied path.
341
It looks up ids trying to find a matching parent directory with the
342
same filename, and then by pure path.
344
takes_args = ['file*']
345
takes_options = ['no-recurse', 'dry-run', 'verbose',
346
Option('file-ids-from', type=unicode,
347
help='Lookup file ids from here')]
348
encoding_type = 'replace'
350
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
355
if file_ids_from is not None:
357
base_tree, base_path = WorkingTree.open_containing(
359
except errors.NoWorkingTree:
360
base_branch, base_path = Branch.open_containing(
362
base_tree = base_branch.basis_tree()
364
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
365
to_file=self.outf, should_print=(not is_quiet()))
367
action = bzrlib.add.AddAction(to_file=self.outf,
368
should_print=(not is_quiet()))
371
base_tree.lock_read()
373
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
374
action=action, save=not dry_run)
376
if base_tree is not None:
380
for glob in sorted(ignored.keys()):
381
for path in ignored[glob]:
382
self.outf.write("ignored %s matching \"%s\"\n"
386
for glob, paths in ignored.items():
387
match_len += len(paths)
388
self.outf.write("ignored %d file(s).\n" % match_len)
389
self.outf.write("If you wish to add some of these files,"
390
" please add them by name.\n")
393
class cmd_mkdir(Command):
394
"""Create a new versioned directory.
396
This is equivalent to creating the directory and then adding it.
399
takes_args = ['dir+']
400
encoding_type = 'replace'
402
def run(self, dir_list):
405
wt, dd = WorkingTree.open_containing(d)
407
self.outf.write('added %s\n' % d)
410
class cmd_relpath(Command):
411
"""Show path of a file relative to root"""
413
takes_args = ['filename']
417
def run(self, filename):
418
# TODO: jam 20050106 Can relpath return a munged path if
419
# sys.stdout encoding cannot represent it?
420
tree, relpath = WorkingTree.open_containing(filename)
421
self.outf.write(relpath)
422
self.outf.write('\n')
425
class cmd_inventory(Command):
426
"""Show inventory of the current working copy or a revision.
428
It is possible to limit the output to a particular entry
429
type using the --kind option. For example: --kind file.
431
It is also possible to restrict the list of files to a specific
432
set. For example: bzr inventory --show-ids this/file
439
takes_options = ['revision', 'show-ids', 'kind']
441
takes_args = ['file*']
444
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
445
if kind and kind not in ['file', 'directory', 'symlink']:
446
raise errors.BzrCommandError('invalid kind specified')
448
work_tree, file_list = tree_files(file_list)
449
work_tree.lock_read()
451
if revision is not None:
452
if len(revision) > 1:
453
raise errors.BzrCommandError(
454
'bzr inventory --revision takes exactly one revision'
456
revision_id = revision[0].in_history(work_tree.branch).rev_id
457
tree = work_tree.branch.repository.revision_tree(revision_id)
459
extra_trees = [work_tree]
465
if file_list is not None:
466
file_ids = tree.paths2ids(file_list, trees=extra_trees,
467
require_versioned=True)
468
# find_ids_across_trees may include some paths that don't
470
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
471
for file_id in file_ids if file_id in tree)
473
entries = tree.inventory.entries()
476
if tree is not work_tree:
479
for path, entry in entries:
480
if kind and kind != entry.kind:
483
self.outf.write('%-50s %s\n' % (path, entry.file_id))
485
self.outf.write(path)
486
self.outf.write('\n')
489
class cmd_mv(Command):
490
"""Move or rename a file.
493
bzr mv OLDNAME NEWNAME
494
bzr mv SOURCE... DESTINATION
496
If the last argument is a versioned directory, all the other names
497
are moved into it. Otherwise, there must be exactly two arguments
498
and the file is changed to a new name.
500
If OLDNAME does not exist on the filesystem but is versioned and
501
NEWNAME does exist on the filesystem but is not versioned, mv
502
assumes that the file has been manually moved and only updates
503
its internal inventory to reflect that change.
504
The same is valid when moving many SOURCE files to a DESTINATION.
506
Files cannot be moved between branches.
509
takes_args = ['names*']
510
takes_options = [Option("after", help="move only the bzr identifier"
511
" of the file (file has already been moved). Use this flag if"
512
" bzr is not able to detect this itself.")]
513
aliases = ['move', 'rename']
514
encoding_type = 'replace'
516
def run(self, names_list, after=False):
517
if names_list is None:
520
if len(names_list) < 2:
521
raise errors.BzrCommandError("missing file argument")
522
tree, rel_names = tree_files(names_list)
524
if os.path.isdir(names_list[-1]):
525
# move into existing directory
526
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
527
self.outf.write("%s => %s\n" % pair)
529
if len(names_list) != 2:
530
raise errors.BzrCommandError('to mv multiple files the'
531
' destination must be a versioned'
533
tree.rename_one(rel_names[0], rel_names[1], after=after)
534
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
537
class cmd_pull(Command):
538
"""Turn this branch into a mirror of another branch.
540
This command only works on branches that have not diverged. Branches are
541
considered diverged if the destination branch's most recent commit is one
542
that has not been merged (directly or indirectly) into the parent.
544
If branches have diverged, you can use 'bzr merge' to integrate the changes
545
from one into the other. Once one branch has merged, the other should
546
be able to pull it again.
548
If you want to forget your local changes and just update your branch to
549
match the remote one, use pull --overwrite.
551
If there is no default location set, the first pull will set it. After
552
that, you can omit the location to use the default. To change the
553
default, use --remember. The value will only be saved if the remote
554
location can be accessed.
557
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
559
help='branch to pull into, '
560
'rather than the one containing the working directory',
565
takes_args = ['location?']
566
encoding_type = 'replace'
568
def run(self, location=None, remember=False, overwrite=False,
569
revision=None, verbose=False,
571
from bzrlib.tag import _merge_tags_if_possible
572
# FIXME: too much stuff is in the command class
575
if directory is None:
578
tree_to = WorkingTree.open_containing(directory)[0]
579
branch_to = tree_to.branch
580
except errors.NoWorkingTree:
582
branch_to = Branch.open_containing(directory)[0]
585
if location is not None:
587
mergeable = bundle.read_mergeable_from_url(
589
except errors.NotABundle:
590
pass # Continue on considering this url a Branch
592
stored_loc = branch_to.get_parent()
594
if stored_loc is None:
595
raise errors.BzrCommandError("No pull location known or"
598
display_url = urlutils.unescape_for_display(stored_loc,
600
self.outf.write("Using saved location: %s\n" % display_url)
601
location = stored_loc
603
if mergeable is not None:
604
if revision is not None:
605
raise errors.BzrCommandError(
606
'Cannot use -r with merge directives or bundles')
607
revision_id = mergeable.install_revisions(branch_to.repository)
608
branch_from = branch_to
610
branch_from = Branch.open(location)
612
if branch_to.get_parent() is None or remember:
613
branch_to.set_parent(branch_from.base)
615
if revision is not None:
616
if len(revision) == 1:
617
revision_id = revision[0].in_history(branch_from).rev_id
619
raise errors.BzrCommandError(
620
'bzr pull --revision takes one value.')
622
old_rh = branch_to.revision_history()
623
if tree_to is not None:
624
result = tree_to.pull(branch_from, overwrite, revision_id,
625
delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
627
result = branch_to.pull(branch_from, overwrite, revision_id)
629
result.report(self.outf)
631
from bzrlib.log import show_changed_revisions
632
new_rh = branch_to.revision_history()
633
show_changed_revisions(branch_to, old_rh, new_rh,
637
class cmd_push(Command):
638
"""Update a mirror of this branch.
640
The target branch will not have its working tree populated because this
641
is both expensive, and is not supported on remote file systems.
643
Some smart servers or protocols *may* put the working tree in place in
646
This command only works on branches that have not diverged. Branches are
647
considered diverged if the destination branch's most recent commit is one
648
that has not been merged (directly or indirectly) by the source branch.
650
If branches have diverged, you can use 'bzr push --overwrite' to replace
651
the other branch completely, discarding its unmerged changes.
653
If you want to ensure you have the different changes in the other branch,
654
do a merge (see bzr help merge) from the other branch, and commit that.
655
After that you will be able to do a push without '--overwrite'.
657
If there is no default push location set, the first push will set it.
658
After that, you can omit the location to use the default. To change the
659
default, use --remember. The value will only be saved if the remote
660
location can be accessed.
663
takes_options = ['remember', 'overwrite', 'verbose',
664
Option('create-prefix',
665
help='Create the path leading up to the branch '
666
'if it does not already exist'),
668
help='branch to push from, '
669
'rather than the one containing the working directory',
673
Option('use-existing-dir',
674
help='By default push will fail if the target'
675
' directory exists, but does not already'
676
' have a control directory. This flag will'
677
' allow push to proceed.'),
679
takes_args = ['location?']
680
encoding_type = 'replace'
682
def run(self, location=None, remember=False, overwrite=False,
683
create_prefix=False, verbose=False,
684
use_existing_dir=False,
686
# FIXME: Way too big! Put this into a function called from the
688
if directory is None:
690
br_from = Branch.open_containing(directory)[0]
691
stored_loc = br_from.get_push_location()
693
if stored_loc is None:
694
raise errors.BzrCommandError("No push location known or specified.")
696
display_url = urlutils.unescape_for_display(stored_loc,
698
self.outf.write("Using saved location: %s\n" % display_url)
699
location = stored_loc
701
to_transport = transport.get_transport(location)
702
location_url = to_transport.base
704
br_to = repository_to = dir_to = None
706
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
707
except errors.NotBranchError:
708
pass # Didn't find anything
710
# If we can open a branch, use its direct repository, otherwise see
711
# if there is a repository without a branch.
713
br_to = dir_to.open_branch()
714
except errors.NotBranchError:
715
# Didn't find a branch, can we find a repository?
717
repository_to = dir_to.find_repository()
718
except errors.NoRepositoryPresent:
721
# Found a branch, so we must have found a repository
722
repository_to = br_to.repository
726
# The destination doesn't exist; create it.
727
# XXX: Refactor the create_prefix/no_create_prefix code into a
728
# common helper function
730
to_transport.mkdir('.')
731
except errors.FileExists:
732
if not use_existing_dir:
733
raise errors.BzrCommandError("Target directory %s"
734
" already exists, but does not have a valid .bzr"
735
" directory. Supply --use-existing-dir to push"
736
" there anyway." % location)
737
except errors.NoSuchFile:
738
if not create_prefix:
739
raise errors.BzrCommandError("Parent directory of %s"
741
"\nYou may supply --create-prefix to create all"
742
" leading parent directories."
745
cur_transport = to_transport
746
needed = [cur_transport]
747
# Recurse upwards until we can create a directory successfully
749
new_transport = cur_transport.clone('..')
750
if new_transport.base == cur_transport.base:
751
raise errors.BzrCommandError("Failed to create path"
755
new_transport.mkdir('.')
756
except errors.NoSuchFile:
757
needed.append(new_transport)
758
cur_transport = new_transport
762
# Now we only need to create child directories
764
cur_transport = needed.pop()
765
cur_transport.mkdir('.')
767
# Now the target directory exists, but doesn't have a .bzr
768
# directory. So we need to create it, along with any work to create
769
# all of the dependent branches, etc.
770
dir_to = br_from.bzrdir.clone(location_url,
771
revision_id=br_from.last_revision())
772
br_to = dir_to.open_branch()
773
# TODO: Some more useful message about what was copied
774
note('Created new branch.')
775
# We successfully created the target, remember it
776
if br_from.get_push_location() is None or remember:
777
br_from.set_push_location(br_to.base)
778
elif repository_to is None:
779
# we have a bzrdir but no branch or repository
780
# XXX: Figure out what to do other than complain.
781
raise errors.BzrCommandError("At %s you have a valid .bzr control"
782
" directory, but not a branch or repository. This is an"
783
" unsupported configuration. Please move the target directory"
784
" out of the way and try again."
787
# We have a repository but no branch, copy the revisions, and then
789
last_revision_id = br_from.last_revision()
790
repository_to.fetch(br_from.repository,
791
revision_id=last_revision_id)
792
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
793
note('Created new branch.')
794
if br_from.get_push_location() is None or remember:
795
br_from.set_push_location(br_to.base)
796
else: # We have a valid to branch
797
# We were able to connect to the remote location, so remember it
798
# we don't need to successfully push because of possible divergence.
799
if br_from.get_push_location() is None or remember:
800
br_from.set_push_location(br_to.base)
801
old_rh = br_to.revision_history()
804
tree_to = dir_to.open_workingtree()
805
except errors.NotLocalUrl:
806
warning('This transport does not update the working '
807
'tree of: %s' % (br_to.base,))
808
push_result = br_from.push(br_to, overwrite)
809
except errors.NoWorkingTree:
810
push_result = br_from.push(br_to, overwrite)
814
push_result = br_from.push(tree_to.branch, overwrite)
818
except errors.DivergedBranches:
819
raise errors.BzrCommandError('These branches have diverged.'
820
' Try using "merge" and then "push".')
821
if push_result is not None:
822
push_result.report(self.outf)
824
new_rh = br_to.revision_history()
827
from bzrlib.log import show_changed_revisions
828
show_changed_revisions(br_to, old_rh, new_rh,
831
# we probably did a clone rather than a push, so a message was
836
class cmd_branch(Command):
837
"""Create a new copy of a branch.
839
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
840
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
842
To retrieve the branch as of a particular revision, supply the --revision
843
parameter, as in "branch foo/bar -r 5".
845
takes_args = ['from_location', 'to_location?']
846
takes_options = ['revision']
847
aliases = ['get', 'clone']
849
def run(self, from_location, to_location=None, revision=None):
850
from bzrlib.tag import _merge_tags_if_possible
853
elif len(revision) > 1:
854
raise errors.BzrCommandError(
855
'bzr branch --revision takes exactly 1 revision value')
857
br_from = Branch.open(from_location)
860
if len(revision) == 1 and revision[0] is not None:
861
revision_id = revision[0].in_history(br_from)[1]
863
# FIXME - wt.last_revision, fallback to branch, fall back to
864
# None or perhaps NULL_REVISION to mean copy nothing
866
revision_id = br_from.last_revision()
867
if to_location is None:
868
to_location = os.path.basename(from_location.rstrip("/\\"))
871
name = os.path.basename(to_location) + '\n'
873
to_transport = transport.get_transport(to_location)
875
to_transport.mkdir('.')
876
except errors.FileExists:
877
raise errors.BzrCommandError('Target directory "%s" already'
878
' exists.' % to_location)
879
except errors.NoSuchFile:
880
raise errors.BzrCommandError('Parent of "%s" does not exist.'
883
# preserve whatever source format we have.
884
dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
885
branch = dir.open_branch()
886
except errors.NoSuchRevision:
887
to_transport.delete_tree('.')
888
msg = "The branch %s has no revision %s." % (from_location, revision[0])
889
raise errors.BzrCommandError(msg)
891
branch.control_files.put_utf8('branch-name', name)
892
_merge_tags_if_possible(br_from, branch)
893
note('Branched %d revision(s).' % branch.revno())
898
class cmd_checkout(Command):
899
"""Create a new checkout of an existing branch.
901
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
902
the branch found in '.'. This is useful if you have removed the working tree
903
or if it was never created - i.e. if you pushed the branch to its current
906
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
907
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
909
To retrieve the branch as of a particular revision, supply the --revision
910
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
911
out of date [so you cannot commit] but it may be useful (i.e. to examine old
914
See "help checkouts" for more information on checkouts.
916
takes_args = ['branch_location?', 'to_location?']
917
takes_options = ['revision',
918
Option('lightweight',
919
help="perform a lightweight checkout. Lightweight "
920
"checkouts depend on access to the branch for "
921
"every operation. Normal checkouts can perform "
922
"common operations like diff and status without "
923
"such access, and also support local commits."
928
def run(self, branch_location=None, to_location=None, revision=None,
932
elif len(revision) > 1:
933
raise errors.BzrCommandError(
934
'bzr checkout --revision takes exactly 1 revision value')
935
if branch_location is None:
936
branch_location = osutils.getcwd()
937
to_location = branch_location
938
source = Branch.open(branch_location)
939
if len(revision) == 1 and revision[0] is not None:
940
revision_id = revision[0].in_history(source)[1]
943
if to_location is None:
944
to_location = os.path.basename(branch_location.rstrip("/\\"))
945
# if the source and to_location are the same,
946
# and there is no working tree,
947
# then reconstitute a branch
948
if (osutils.abspath(to_location) ==
949
osutils.abspath(branch_location)):
951
source.bzrdir.open_workingtree()
952
except errors.NoWorkingTree:
953
source.bzrdir.create_workingtree()
956
os.mkdir(to_location)
958
if e.errno == errno.EEXIST:
959
raise errors.BzrCommandError('Target directory "%s" already'
960
' exists.' % to_location)
961
if e.errno == errno.ENOENT:
962
raise errors.BzrCommandError('Parent of "%s" does not exist.'
966
source.create_checkout(to_location, revision_id, lightweight)
969
class cmd_renames(Command):
970
"""Show list of renamed files.
972
# TODO: Option to show renames between two historical versions.
974
# TODO: Only show renames under dir, rather than in the whole branch.
975
takes_args = ['dir?']
978
def run(self, dir=u'.'):
979
tree = WorkingTree.open_containing(dir)[0]
982
new_inv = tree.inventory
983
old_tree = tree.basis_tree()
986
old_inv = old_tree.inventory
987
renames = list(_mod_tree.find_renames(old_inv, new_inv))
989
for old_name, new_name in renames:
990
self.outf.write("%s => %s\n" % (old_name, new_name))
997
class cmd_update(Command):
998
"""Update a tree to have the latest code committed to its branch.
1000
This will perform a merge into the working tree, and may generate
1001
conflicts. If you have any local changes, you will still
1002
need to commit them after the update for the update to be complete.
1004
If you want to discard your local changes, you can just do a
1005
'bzr revert' instead of 'bzr commit' after the update.
1007
takes_args = ['dir?']
1010
def run(self, dir='.'):
1011
tree = WorkingTree.open_containing(dir)[0]
1012
master = tree.branch.get_master_branch()
1013
if master is not None:
1016
tree.lock_tree_write()
1018
existing_pending_merges = tree.get_parent_ids()[1:]
1019
last_rev = tree.last_revision()
1020
if last_rev == tree.branch.last_revision():
1021
# may be up to date, check master too.
1022
master = tree.branch.get_master_branch()
1023
if master is None or last_rev == master.last_revision():
1024
revno = tree.branch.revision_id_to_revno(last_rev)
1025
note("Tree is up to date at revision %d." % (revno,))
1027
conflicts = tree.update()
1028
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1029
note('Updated to revision %d.' % (revno,))
1030
if tree.get_parent_ids()[1:] != existing_pending_merges:
1031
note('Your local commits will now show as pending merges with '
1032
"'bzr status', and can be committed with 'bzr commit'.")
1041
class cmd_info(Command):
1042
"""Show information about a working tree, branch or repository.
1044
This command will show all known locations and formats associated to the
1045
tree, branch or repository. Statistical information is included with
1048
Branches and working trees will also report any missing revisions.
1050
takes_args = ['location?']
1051
takes_options = ['verbose']
1054
def run(self, location=None, verbose=False):
1055
from bzrlib.info import show_bzrdir_info
1056
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1060
class cmd_remove(Command):
1061
"""Make a file unversioned.
1063
This makes bzr stop tracking changes to a versioned file. It does
1064
not delete the working copy.
1066
You can specify one or more files, and/or --new. If you specify --new,
1067
only 'added' files will be removed. If you specify both, then new files
1068
in the specified directories will be removed. If the directories are
1069
also new, they will also be removed.
1071
takes_args = ['file*']
1072
takes_options = ['verbose', Option('new', help='remove newly-added files')]
1074
encoding_type = 'replace'
1076
def run(self, file_list, verbose=False, new=False):
1077
tree, file_list = tree_files(file_list)
1079
if file_list is None:
1080
raise errors.BzrCommandError('Specify one or more files to'
1081
' remove, or use --new.')
1083
added = tree.changes_from(tree.basis_tree(),
1084
specific_files=file_list).added
1085
file_list = sorted([f[0] for f in added], reverse=True)
1086
if len(file_list) == 0:
1087
raise errors.BzrCommandError('No matching files.')
1088
tree.remove(file_list, verbose=verbose, to_file=self.outf)
1091
class cmd_file_id(Command):
1092
"""Print file_id of a particular file or directory.
1094
The file_id is assigned when the file is first added and remains the
1095
same through all revisions where the file exists, even when it is
1100
takes_args = ['filename']
1103
def run(self, filename):
1104
tree, relpath = WorkingTree.open_containing(filename)
1105
i = tree.path2id(relpath)
1107
raise errors.NotVersionedError(filename)
1109
self.outf.write(i + '\n')
1112
class cmd_file_path(Command):
1113
"""Print path of file_ids to a file or directory.
1115
This prints one line for each directory down to the target,
1116
starting at the branch root.
1120
takes_args = ['filename']
1123
def run(self, filename):
1124
tree, relpath = WorkingTree.open_containing(filename)
1125
fid = tree.path2id(relpath)
1127
raise errors.NotVersionedError(filename)
1128
segments = osutils.splitpath(relpath)
1129
for pos in range(1, len(segments) + 1):
1130
path = osutils.joinpath(segments[:pos])
1131
self.outf.write("%s\n" % tree.path2id(path))
1134
class cmd_reconcile(Command):
1135
"""Reconcile bzr metadata in a branch.
1137
This can correct data mismatches that may have been caused by
1138
previous ghost operations or bzr upgrades. You should only
1139
need to run this command if 'bzr check' or a bzr developer
1140
advises you to run it.
1142
If a second branch is provided, cross-branch reconciliation is
1143
also attempted, which will check that data like the tree root
1144
id which was not present in very early bzr versions is represented
1145
correctly in both branches.
1147
At the same time it is run it may recompress data resulting in
1148
a potential saving in disk space or performance gain.
1150
The branch *MUST* be on a listable system such as local disk or sftp.
1152
takes_args = ['branch?']
1154
def run(self, branch="."):
1155
from bzrlib.reconcile import reconcile
1156
dir = bzrdir.BzrDir.open(branch)
1160
class cmd_revision_history(Command):
1161
"""Display the list of revision ids on a branch."""
1162
takes_args = ['location?']
1167
def run(self, location="."):
1168
branch = Branch.open_containing(location)[0]
1169
for revid in branch.revision_history():
1170
self.outf.write(revid)
1171
self.outf.write('\n')
1174
class cmd_ancestry(Command):
1175
"""List all revisions merged into this branch."""
1176
takes_args = ['location?']
1181
def run(self, location="."):
1183
wt = WorkingTree.open_containing(location)[0]
1184
except errors.NoWorkingTree:
1185
b = Branch.open(location)
1186
last_revision = b.last_revision()
1189
last_revision = wt.last_revision()
1191
revision_ids = b.repository.get_ancestry(last_revision)
1192
assert revision_ids[0] is None
1194
for revision_id in revision_ids:
1195
self.outf.write(revision_id + '\n')
1198
class cmd_init(Command):
1199
"""Make a directory into a versioned branch.
1201
Use this to create an empty branch, or before importing an
1204
If there is a repository in a parent directory of the location, then
1205
the history of the branch will be stored in the repository. Otherwise
1206
init creates a standalone branch which carries its own history
1207
in the .bzr directory.
1209
If there is already a branch at the location but it has no working tree,
1210
the tree can be populated with 'bzr checkout'.
1212
Recipe for importing a tree of files:
1217
bzr commit -m 'imported project'
1219
takes_args = ['location?']
1221
RegistryOption('format',
1222
help='Specify a format for this branch. '
1223
'See "help formats".',
1224
registry=bzrdir.format_registry,
1225
converter=bzrdir.format_registry.make_bzrdir,
1226
value_switches=True,
1227
title="Branch Format",
1229
Option('append-revisions-only',
1230
help='Never change revnos or the existing log.'
1231
' Append revisions to it only.')
1233
def run(self, location=None, format=None, append_revisions_only=False):
1235
format = bzrdir.format_registry.make_bzrdir('default')
1236
if location is None:
1239
to_transport = transport.get_transport(location)
1241
# The path has to exist to initialize a
1242
# branch inside of it.
1243
# Just using os.mkdir, since I don't
1244
# believe that we want to create a bunch of
1245
# locations if the user supplies an extended path
1246
# TODO: create-prefix
1248
to_transport.mkdir('.')
1249
except errors.FileExists:
1253
existing_bzrdir = bzrdir.BzrDir.open(location)
1254
except errors.NotBranchError:
1255
# really a NotBzrDir error...
1256
branch = bzrdir.BzrDir.create_branch_convenience(to_transport.base,
1259
from bzrlib.transport.local import LocalTransport
1260
if existing_bzrdir.has_branch():
1261
if (isinstance(to_transport, LocalTransport)
1262
and not existing_bzrdir.has_workingtree()):
1263
raise errors.BranchExistsWithoutWorkingTree(location)
1264
raise errors.AlreadyBranchError(location)
1266
branch = existing_bzrdir.create_branch()
1267
existing_bzrdir.create_workingtree()
1268
if append_revisions_only:
1270
branch.set_append_revisions_only(True)
1271
except errors.UpgradeRequired:
1272
raise errors.BzrCommandError('This branch format cannot be set'
1273
' to append-revisions-only. Try --experimental-branch6')
1276
class cmd_init_repository(Command):
1277
"""Create a shared repository to hold branches.
1279
New branches created under the repository directory will store their revisions
1280
in the repository, not in the branch directory.
1283
bzr init-repo --no-trees repo
1285
bzr checkout --lightweight repo/trunk trunk-checkout
1290
takes_args = ["location"]
1291
takes_options = [RegistryOption('format',
1292
help='Specify a format for this repository. See'
1293
' "bzr help formats" for details',
1294
registry=bzrdir.format_registry,
1295
converter=bzrdir.format_registry.make_bzrdir,
1296
value_switches=True, title='Repository format'),
1298
help='Branches in the repository will default to'
1299
' not having a working tree'),
1301
aliases = ["init-repo"]
1303
def run(self, location, format=None, no_trees=False):
1305
format = bzrdir.format_registry.make_bzrdir('default')
1307
if location is None:
1310
to_transport = transport.get_transport(location)
1312
to_transport.mkdir('.')
1313
except errors.FileExists:
1316
newdir = format.initialize_on_transport(to_transport)
1317
repo = newdir.create_repository(shared=True)
1318
repo.set_make_working_trees(not no_trees)
1321
class cmd_diff(Command):
1322
"""Show differences in the working tree or between revisions.
1324
If files are listed, only the changes in those files are listed.
1325
Otherwise, all changes for the tree are listed.
1327
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1328
produces patches suitable for "patch -p1".
1332
Shows the difference in the working tree versus the last commit
1334
Difference between the working tree and revision 1
1336
Difference between revision 2 and revision 1
1337
bzr diff --prefix old/:new/
1338
Same as 'bzr diff' but prefix paths with old/ and new/
1339
bzr diff bzr.mine bzr.dev
1340
Show the differences between the two working trees
1342
Show just the differences for 'foo.c'
1344
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1345
# or a graphical diff.
1347
# TODO: Python difflib is not exactly the same as unidiff; should
1348
# either fix it up or prefer to use an external diff.
1350
# TODO: Selected-file diff is inefficient and doesn't show you
1353
# TODO: This probably handles non-Unix newlines poorly.
1355
takes_args = ['file*']
1356
takes_options = ['revision', 'diff-options',
1357
Option('prefix', type=str,
1359
help='Set prefixes to added to old and new filenames, as '
1360
'two values separated by a colon. (eg "old/:new/")'),
1362
aliases = ['di', 'dif']
1363
encoding_type = 'exact'
1366
def run(self, revision=None, file_list=None, diff_options=None,
1368
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1370
if (prefix is None) or (prefix == '0'):
1378
old_label, new_label = prefix.split(":")
1380
raise errors.BzrCommandError(
1381
'--prefix expects two values separated by a colon'
1382
' (eg "old/:new/")')
1384
if revision and len(revision) > 2:
1385
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1386
' one or two revision specifiers')
1389
tree1, file_list = internal_tree_files(file_list)
1393
except errors.FileInWrongBranch:
1394
if len(file_list) != 2:
1395
raise errors.BzrCommandError("Files are in different branches")
1397
tree1, file1 = WorkingTree.open_containing(file_list[0])
1398
tree2, file2 = WorkingTree.open_containing(file_list[1])
1399
if file1 != "" or file2 != "":
1400
# FIXME diff those two files. rbc 20051123
1401
raise errors.BzrCommandError("Files are in different branches")
1403
except errors.NotBranchError:
1404
if (revision is not None and len(revision) == 2
1405
and not revision[0].needs_branch()
1406
and not revision[1].needs_branch()):
1407
# If both revision specs include a branch, we can
1408
# diff them without needing a local working tree
1409
tree1, tree2 = None, None
1413
if tree2 is not None:
1414
if revision is not None:
1415
# FIXME: but there should be a clean way to diff between
1416
# non-default versions of two trees, it's not hard to do
1418
raise errors.BzrCommandError(
1419
"Sorry, diffing arbitrary revisions across branches "
1420
"is not implemented yet")
1421
return show_diff_trees(tree1, tree2, sys.stdout,
1422
specific_files=file_list,
1423
external_diff_options=diff_options,
1424
old_label=old_label, new_label=new_label)
1426
return diff_cmd_helper(tree1, file_list, diff_options,
1427
revision_specs=revision,
1428
old_label=old_label, new_label=new_label)
1431
class cmd_deleted(Command):
1432
"""List files deleted in the working tree.
1434
# TODO: Show files deleted since a previous revision, or
1435
# between two revisions.
1436
# TODO: Much more efficient way to do this: read in new
1437
# directories with readdir, rather than stating each one. Same
1438
# level of effort but possibly much less IO. (Or possibly not,
1439
# if the directories are very large...)
1440
takes_options = ['show-ids']
1443
def run(self, show_ids=False):
1444
tree = WorkingTree.open_containing(u'.')[0]
1447
old = tree.basis_tree()
1450
for path, ie in old.inventory.iter_entries():
1451
if not tree.has_id(ie.file_id):
1452
self.outf.write(path)
1454
self.outf.write(' ')
1455
self.outf.write(ie.file_id)
1456
self.outf.write('\n')
1463
class cmd_modified(Command):
1464
"""List files modified in working tree.
1466
See also: "bzr status".
1473
tree = WorkingTree.open_containing(u'.')[0]
1474
td = tree.changes_from(tree.basis_tree())
1475
for path, id, kind, text_modified, meta_modified in td.modified:
1476
self.outf.write(path + '\n')
1479
class cmd_added(Command):
1480
"""List files added in working tree.
1482
See also: "bzr status".
1489
wt = WorkingTree.open_containing(u'.')[0]
1492
basis = wt.basis_tree()
1495
basis_inv = basis.inventory
1498
if file_id in basis_inv:
1500
if inv.is_root(file_id) and len(basis_inv) == 0:
1502
path = inv.id2path(file_id)
1503
if not os.access(osutils.abspath(path), os.F_OK):
1505
self.outf.write(path + '\n')
1512
class cmd_root(Command):
1513
"""Show the tree root directory.
1515
The root is the nearest enclosing directory with a .bzr control
1517
takes_args = ['filename?']
1519
def run(self, filename=None):
1520
"""Print the branch root."""
1521
tree = WorkingTree.open_containing(filename)[0]
1522
self.outf.write(tree.basedir + '\n')
1525
class cmd_log(Command):
1526
"""Show log of a branch, file, or directory.
1528
By default show the log of the branch containing the working directory.
1530
To request a range of logs, you can use the command -r begin..end
1531
-r revision requests a specific revision, -r ..end or -r begin.. are
1537
bzr log -r -10.. http://server/branch
1540
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1542
takes_args = ['location?']
1543
takes_options = [Option('forward',
1544
help='show from oldest to newest'),
1548
help='show files changed in each revision'),
1549
'show-ids', 'revision',
1553
help='show revisions whose message matches this regexp',
1556
encoding_type = 'replace'
1559
def run(self, location=None, timezone='original',
1566
from bzrlib.log import show_log
1567
assert message is None or isinstance(message, basestring), \
1568
"invalid message argument %r" % message
1569
direction = (forward and 'forward') or 'reverse'
1574
# find the file id to log:
1576
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1580
tree = b.basis_tree()
1581
file_id = tree.path2id(fp)
1583
raise errors.BzrCommandError(
1584
"Path does not have any revision history: %s" %
1588
# FIXME ? log the current subdir only RBC 20060203
1589
if revision is not None \
1590
and len(revision) > 0 and revision[0].get_branch():
1591
location = revision[0].get_branch()
1594
dir, relpath = bzrdir.BzrDir.open_containing(location)
1595
b = dir.open_branch()
1599
if revision is None:
1602
elif len(revision) == 1:
1603
rev1 = rev2 = revision[0].in_history(b).revno
1604
elif len(revision) == 2:
1605
if revision[1].get_branch() != revision[0].get_branch():
1606
# b is taken from revision[0].get_branch(), and
1607
# show_log will use its revision_history. Having
1608
# different branches will lead to weird behaviors.
1609
raise errors.BzrCommandError(
1610
"Log doesn't accept two revisions in different"
1612
if revision[0].spec is None:
1613
# missing begin-range means first revision
1616
rev1 = revision[0].in_history(b).revno
1618
if revision[1].spec is None:
1619
# missing end-range means last known revision
1622
rev2 = revision[1].in_history(b).revno
1624
raise errors.BzrCommandError(
1625
'bzr log --revision takes one or two values.')
1627
# By this point, the revision numbers are converted to the +ve
1628
# form if they were supplied in the -ve form, so we can do
1629
# this comparison in relative safety
1631
(rev2, rev1) = (rev1, rev2)
1633
if log_format is None:
1634
log_format = log.log_formatter_registry.get_default(b)
1636
lf = log_format(show_ids=show_ids, to_file=self.outf,
1637
show_timezone=timezone)
1643
direction=direction,
1644
start_revision=rev1,
1651
def get_log_format(long=False, short=False, line=False, default='long'):
1652
log_format = default
1656
log_format = 'short'
1662
class cmd_touching_revisions(Command):
1663
"""Return revision-ids which affected a particular file.
1665
A more user-friendly interface is "bzr log FILE".
1669
takes_args = ["filename"]
1672
def run(self, filename):
1673
tree, relpath = WorkingTree.open_containing(filename)
1675
file_id = tree.path2id(relpath)
1676
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1677
self.outf.write("%6d %s\n" % (revno, what))
1680
class cmd_ls(Command):
1681
"""List files in a tree.
1684
takes_args = ['path?']
1685
# TODO: Take a revision or remote path and list that tree instead.
1686
takes_options = ['verbose', 'revision',
1687
Option('non-recursive',
1688
help='don\'t recurse into sub-directories'),
1690
help='Print all paths from the root of the branch.'),
1691
Option('unknown', help='Print unknown files'),
1692
Option('versioned', help='Print versioned files'),
1693
Option('ignored', help='Print ignored files'),
1695
Option('null', help='Null separate the files'),
1699
def run(self, revision=None, verbose=False,
1700
non_recursive=False, from_root=False,
1701
unknown=False, versioned=False, ignored=False,
1702
null=False, kind=None, show_ids=False, path=None):
1704
if kind and kind not in ('file', 'directory', 'symlink'):
1705
raise errors.BzrCommandError('invalid kind specified')
1707
if verbose and null:
1708
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1709
all = not (unknown or versioned or ignored)
1711
selection = {'I':ignored, '?':unknown, 'V':versioned}
1718
raise errors.BzrCommandError('cannot specify both --from-root'
1722
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1728
if revision is not None:
1729
tree = branch.repository.revision_tree(
1730
revision[0].in_history(branch).rev_id)
1732
tree = branch.basis_tree()
1736
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1737
if fp.startswith(relpath):
1738
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1739
if non_recursive and '/' in fp:
1741
if not all and not selection[fc]:
1743
if kind is not None and fkind != kind:
1746
kindch = entry.kind_character()
1747
outstring = '%-8s %s%s' % (fc, fp, kindch)
1748
if show_ids and fid is not None:
1749
outstring = "%-50s %s" % (outstring, fid)
1750
self.outf.write(outstring + '\n')
1752
self.outf.write(fp + '\0')
1755
self.outf.write(fid)
1756
self.outf.write('\0')
1764
self.outf.write('%-50s %s\n' % (fp, my_id))
1766
self.outf.write(fp + '\n')
1771
class cmd_unknowns(Command):
1772
"""List unknown files.
1774
See also: "bzr ls --unknown".
1781
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1782
self.outf.write(osutils.quotefn(f) + '\n')
1785
class cmd_ignore(Command):
1786
"""Ignore specified files or patterns.
1788
To remove patterns from the ignore list, edit the .bzrignore file.
1790
Trailing slashes on patterns are ignored.
1791
If the pattern contains a slash or is a regular expression, it is compared
1792
to the whole path from the branch root. Otherwise, it is compared to only
1793
the last component of the path. To match a file only in the root
1794
directory, prepend './'.
1796
Ignore patterns specifying absolute paths are not allowed.
1798
Ignore patterns may include globbing wildcards such as:
1799
? - Matches any single character except '/'
1800
* - Matches 0 or more characters except '/'
1801
/**/ - Matches 0 or more directories in a path
1802
[a-z] - Matches a single character from within a group of characters
1804
Ignore patterns may also be Python regular expressions.
1805
Regular expression ignore patterns are identified by a 'RE:' prefix
1806
followed by the regular expression. Regular expression ignore patterns
1807
may not include named or numbered groups.
1809
Note: ignore patterns containing shell wildcards must be quoted from
1813
bzr ignore ./Makefile
1814
bzr ignore '*.class'
1815
bzr ignore 'lib/**/*.o'
1816
bzr ignore 'RE:lib/.*\.o'
1818
takes_args = ['name_pattern*']
1820
Option('old-default-rules',
1821
help='Out the ignore rules bzr < 0.9 always used.')
1824
def run(self, name_pattern_list=None, old_default_rules=None):
1825
from bzrlib.atomicfile import AtomicFile
1826
if old_default_rules is not None:
1827
# dump the rules and exit
1828
for pattern in ignores.OLD_DEFAULTS:
1831
if not name_pattern_list:
1832
raise errors.BzrCommandError("ignore requires at least one "
1833
"NAME_PATTERN or --old-default-rules")
1834
name_pattern_list = [globbing.normalize_pattern(p)
1835
for p in name_pattern_list]
1836
for name_pattern in name_pattern_list:
1837
if (name_pattern[0] == '/' or
1838
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1839
raise errors.BzrCommandError(
1840
"NAME_PATTERN should not be an absolute path")
1841
tree, relpath = WorkingTree.open_containing(u'.')
1842
ifn = tree.abspath('.bzrignore')
1843
if os.path.exists(ifn):
1846
igns = f.read().decode('utf-8')
1852
# TODO: If the file already uses crlf-style termination, maybe
1853
# we should use that for the newly added lines?
1855
if igns and igns[-1] != '\n':
1857
for name_pattern in name_pattern_list:
1858
igns += name_pattern + '\n'
1860
f = AtomicFile(ifn, 'wb')
1862
f.write(igns.encode('utf-8'))
1867
if not tree.path2id('.bzrignore'):
1868
tree.add(['.bzrignore'])
1871
class cmd_ignored(Command):
1872
"""List ignored files and the patterns that matched them.
1874
See also: bzr ignore"""
1877
tree = WorkingTree.open_containing(u'.')[0]
1880
for path, file_class, kind, file_id, entry in tree.list_files():
1881
if file_class != 'I':
1883
## XXX: Slightly inefficient since this was already calculated
1884
pat = tree.is_ignored(path)
1885
print '%-50s %s' % (path, pat)
1890
class cmd_lookup_revision(Command):
1891
"""Lookup the revision-id from a revision-number
1894
bzr lookup-revision 33
1897
takes_args = ['revno']
1900
def run(self, revno):
1904
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1906
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1909
class cmd_export(Command):
1910
"""Export current or past revision to a destination directory or archive.
1912
If no revision is specified this exports the last committed revision.
1914
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1915
given, try to find the format with the extension. If no extension
1916
is found exports to a directory (equivalent to --format=dir).
1918
Root may be the top directory for tar, tgz and tbz2 formats. If none
1919
is given, the top directory will be the root name of the file.
1921
If branch is omitted then the branch containing the current working
1922
directory will be used.
1924
Note: export of tree with non-ascii filenames to zip is not supported.
1926
Supported formats Autodetected by extension
1927
----------------- -------------------------
1930
tbz2 .tar.bz2, .tbz2
1934
takes_args = ['dest', 'branch?']
1935
takes_options = ['revision', 'format', 'root']
1936
def run(self, dest, branch=None, revision=None, format=None, root=None):
1937
from bzrlib.export import export
1940
tree = WorkingTree.open_containing(u'.')[0]
1943
b = Branch.open(branch)
1945
if revision is None:
1946
# should be tree.last_revision FIXME
1947
rev_id = b.last_revision()
1949
if len(revision) != 1:
1950
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1951
rev_id = revision[0].in_history(b).rev_id
1952
t = b.repository.revision_tree(rev_id)
1954
export(t, dest, format, root)
1955
except errors.NoSuchExportFormat, e:
1956
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1959
class cmd_cat(Command):
1960
"""Write the contents of a file as of a given revision to standard output.
1962
If no revision is nominated, the last revision is used.
1964
Note: Take care to redirect standard output when using this command on a
1968
takes_options = ['revision', 'name-from-revision']
1969
takes_args = ['filename']
1970
encoding_type = 'exact'
1973
def run(self, filename, revision=None, name_from_revision=False):
1974
if revision is not None and len(revision) != 1:
1975
raise errors.BzrCommandError("bzr cat --revision takes exactly"
1980
tree, b, relpath = \
1981
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
1982
except errors.NotBranchError:
1985
if revision is not None and revision[0].get_branch() is not None:
1986
b = Branch.open(revision[0].get_branch())
1988
tree = b.basis_tree()
1989
if revision is None:
1990
revision_id = b.last_revision()
1992
revision_id = revision[0].in_history(b).rev_id
1994
cur_file_id = tree.path2id(relpath)
1995
rev_tree = b.repository.revision_tree(revision_id)
1996
old_file_id = rev_tree.path2id(relpath)
1998
if name_from_revision:
1999
if old_file_id is None:
2000
raise errors.BzrCommandError("%r is not present in revision %s"
2001
% (filename, revision_id))
2003
rev_tree.print_file(old_file_id)
2004
elif cur_file_id is not None:
2005
rev_tree.print_file(cur_file_id)
2006
elif old_file_id is not None:
2007
rev_tree.print_file(old_file_id)
2009
raise errors.BzrCommandError("%r is not present in revision %s" %
2010
(filename, revision_id))
2013
class cmd_local_time_offset(Command):
2014
"""Show the offset in seconds from GMT to local time."""
2018
print osutils.local_time_offset()
2022
class cmd_commit(Command):
2023
"""Commit changes into a new revision.
2025
If no arguments are given, the entire tree is committed.
2027
If selected files are specified, only changes to those files are
2028
committed. If a directory is specified then the directory and everything
2029
within it is committed.
2031
A selected-file commit may fail in some cases where the committed
2032
tree would be invalid, such as trying to commit a file in a
2033
newly-added directory that is not itself committed.
2035
# TODO: Run hooks on tree to-be-committed, and after commit.
2037
# TODO: Strict commit that fails if there are deleted files.
2038
# (what does "deleted files" mean ??)
2040
# TODO: Give better message for -s, --summary, used by tla people
2042
# XXX: verbose currently does nothing
2044
takes_args = ['selected*']
2045
takes_options = ['message', 'verbose',
2047
help='commit even if nothing has changed'),
2048
Option('file', type=str,
2051
help='file containing commit message'),
2053
help="refuse to commit if there are unknown "
2054
"files in the working tree."),
2056
help="perform a local only commit in a bound "
2057
"branch. Such commits are not pushed to "
2058
"the master branch until a normal commit "
2062
aliases = ['ci', 'checkin']
2064
def run(self, message=None, file=None, verbose=True, selected_list=None,
2065
unchanged=False, strict=False, local=False):
2066
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
2067
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
2069
from bzrlib.msgeditor import edit_commit_message, \
2070
make_commit_message_template
2072
# TODO: Need a blackbox test for invoking the external editor; may be
2073
# slightly problematic to run this cross-platform.
2075
# TODO: do more checks that the commit will succeed before
2076
# spending the user's valuable time typing a commit message.
2077
tree, selected_list = tree_files(selected_list)
2078
if selected_list == ['']:
2079
# workaround - commit of root of tree should be exactly the same
2080
# as just default commit in that tree, and succeed even though
2081
# selected-file merge commit is not done yet
2084
if local and not tree.branch.get_bound_location():
2085
raise errors.LocalRequiresBoundBranch()
2087
def get_message(commit_obj):
2088
"""Callback to get commit message"""
2089
my_message = message
2090
if my_message is None and not file:
2091
template = make_commit_message_template(tree, selected_list)
2092
my_message = edit_commit_message(template)
2093
if my_message is None:
2094
raise errors.BzrCommandError("please specify a commit"
2095
" message with either --message or --file")
2096
elif my_message and file:
2097
raise errors.BzrCommandError(
2098
"please specify either --message or --file")
2100
my_message = codecs.open(file, 'rt',
2101
bzrlib.user_encoding).read()
2102
if my_message == "":
2103
raise errors.BzrCommandError("empty commit message specified")
2107
reporter = ReportCommitToLog()
2109
reporter = NullCommitReporter()
2112
tree.commit(message_callback=get_message,
2113
specific_files=selected_list,
2114
allow_pointless=unchanged, strict=strict, local=local,
2116
except PointlessCommit:
2117
# FIXME: This should really happen before the file is read in;
2118
# perhaps prepare the commit; get the message; then actually commit
2119
raise errors.BzrCommandError("no changes to commit."
2120
" use --unchanged to commit anyhow")
2121
except ConflictsInTree:
2122
raise errors.BzrCommandError('Conflicts detected in working '
2123
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2125
except StrictCommitFailed:
2126
raise errors.BzrCommandError("Commit refused because there are"
2127
" unknown files in the working tree.")
2128
except errors.BoundBranchOutOfDate, e:
2129
raise errors.BzrCommandError(str(e) + "\n"
2130
'To commit to master branch, run update and then commit.\n'
2131
'You can also pass --local to commit to continue working '
2135
class cmd_check(Command):
2136
"""Validate consistency of branch history.
2138
This command checks various invariants about the branch storage to
2139
detect data corruption or bzr bugs.
2141
takes_args = ['branch?']
2142
takes_options = ['verbose']
2144
def run(self, branch=None, verbose=False):
2145
from bzrlib.check import check
2147
tree = WorkingTree.open_containing()[0]
2148
branch = tree.branch
2150
branch = Branch.open(branch)
2151
check(branch, verbose)
2154
class cmd_upgrade(Command):
2155
"""Upgrade branch storage to current format.
2157
The check command or bzr developers may sometimes advise you to run
2158
this command. When the default format has changed you may also be warned
2159
during other operations to upgrade.
2161
takes_args = ['url?']
2163
RegistryOption('format',
2164
help='Upgrade to a specific format. See "bzr help'
2165
' formats" for details',
2166
registry=bzrdir.format_registry,
2167
converter=bzrdir.format_registry.make_bzrdir,
2168
value_switches=True, title='Branch format'),
2171
def run(self, url='.', format=None):
2172
from bzrlib.upgrade import upgrade
2174
format = bzrdir.format_registry.make_bzrdir('default')
2175
upgrade(url, format)
2178
class cmd_whoami(Command):
2179
"""Show or set bzr user id.
2183
bzr whoami 'Frank Chu <fchu@example.com>'
2185
takes_options = [ Option('email',
2186
help='display email address only'),
2188
help='set identity for the current branch instead of '
2191
takes_args = ['name?']
2192
encoding_type = 'replace'
2195
def run(self, email=False, branch=False, name=None):
2197
# use branch if we're inside one; otherwise global config
2199
c = Branch.open_containing('.')[0].get_config()
2200
except errors.NotBranchError:
2201
c = config.GlobalConfig()
2203
self.outf.write(c.user_email() + '\n')
2205
self.outf.write(c.username() + '\n')
2208
# display a warning if an email address isn't included in the given name.
2210
config.extract_email_address(name)
2211
except errors.NoEmailInUsername, e:
2212
warning('"%s" does not seem to contain an email address. '
2213
'This is allowed, but not recommended.', name)
2215
# use global config unless --branch given
2217
c = Branch.open_containing('.')[0].get_config()
2219
c = config.GlobalConfig()
2220
c.set_user_option('email', name)
2223
class cmd_nick(Command):
2224
"""Print or set the branch nickname.
2226
If unset, the tree root directory name is used as the nickname
2227
To print the current nickname, execute with no argument.
2229
takes_args = ['nickname?']
2230
def run(self, nickname=None):
2231
branch = Branch.open_containing(u'.')[0]
2232
if nickname is None:
2233
self.printme(branch)
2235
branch.nick = nickname
2238
def printme(self, branch):
2242
class cmd_selftest(Command):
2243
"""Run internal test suite.
2245
This creates temporary test directories in the working directory, but not
2246
existing data is affected. These directories are deleted if the tests
2247
pass, or left behind to help in debugging if they fail and --keep-output
2250
If arguments are given, they are regular expressions that say which tests
2251
should run. Tests matching any expression are run, and other tests are
2254
Alternatively if --first is given, matching tests are run first and then
2255
all other tests are run. This is useful if you have been working in a
2256
particular area, but want to make sure nothing else was broken.
2258
If the global option '--no-plugins' is given, plugins are not loaded
2259
before running the selftests. This has two effects: features provided or
2260
modified by plugins will not be tested, and tests provided by plugins will
2265
run only tests relating to 'ignore'
2266
bzr --no-plugins selftest -v
2267
disable plugins and list tests as they're run
2269
For each test, that needs actual disk access, bzr create their own
2270
subdirectory in the temporary testing directory (testXXXX.tmp).
2271
By default the name of such subdirectory is based on the name of the test.
2272
If option '--numbered-dirs' is given, bzr will use sequent numbers
2273
of running tests to create such subdirectories. This is default behavior
2274
on Windows because of path length limitation.
2276
# TODO: --list should give a list of all available tests
2278
# NB: this is used from the class without creating an instance, which is
2279
# why it does not have a self parameter.
2280
def get_transport_type(typestring):
2281
"""Parse and return a transport specifier."""
2282
if typestring == "sftp":
2283
from bzrlib.transport.sftp import SFTPAbsoluteServer
2284
return SFTPAbsoluteServer
2285
if typestring == "memory":
2286
from bzrlib.transport.memory import MemoryServer
2288
if typestring == "fakenfs":
2289
from bzrlib.transport.fakenfs import FakeNFSServer
2290
return FakeNFSServer
2291
msg = "No known transport type %s. Supported types are: sftp\n" %\
2293
raise errors.BzrCommandError(msg)
2296
takes_args = ['testspecs*']
2297
takes_options = ['verbose',
2298
Option('one', help='stop when one test fails'),
2299
Option('keep-output',
2300
help='keep output directories when tests fail'),
2302
help='Use a different transport by default '
2303
'throughout the test suite.',
2304
type=get_transport_type),
2305
Option('benchmark', help='run the bzr benchmarks.'),
2306
Option('lsprof-timed',
2307
help='generate lsprof output for benchmarked'
2308
' sections of code.'),
2309
Option('cache-dir', type=str,
2310
help='a directory to cache intermediate'
2311
' benchmark steps'),
2312
Option('clean-output',
2313
help='clean temporary tests directories'
2314
' without running tests'),
2316
help='run all tests, but run specified tests first'
2318
Option('numbered-dirs',
2319
help='use numbered dirs for TestCaseInTempDir'),
2321
encoding_type = 'replace'
2323
def run(self, testspecs_list=None, verbose=None, one=False,
2324
keep_output=False, transport=None, benchmark=None,
2325
lsprof_timed=None, cache_dir=None, clean_output=False,
2326
first=False, numbered_dirs=None):
2328
from bzrlib.tests import selftest
2329
import bzrlib.benchmarks as benchmarks
2330
from bzrlib.benchmarks import tree_creator
2333
from bzrlib.tests import clean_selftest_output
2334
clean_selftest_output()
2337
if numbered_dirs is None and sys.platform == 'win32':
2338
numbered_dirs = True
2340
if cache_dir is not None:
2341
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2342
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2343
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2345
if testspecs_list is not None:
2346
pattern = '|'.join(testspecs_list)
2350
test_suite_factory = benchmarks.test_suite
2353
# TODO: should possibly lock the history file...
2354
benchfile = open(".perf_history", "at", buffering=1)
2356
test_suite_factory = None
2361
result = selftest(verbose=verbose,
2363
stop_on_failure=one,
2364
keep_output=keep_output,
2365
transport=transport,
2366
test_suite_factory=test_suite_factory,
2367
lsprof_timed=lsprof_timed,
2368
bench_history=benchfile,
2369
matching_tests_first=first,
2370
numbered_dirs=numbered_dirs,
2373
if benchfile is not None:
2376
info('tests passed')
2378
info('tests failed')
2379
return int(not result)
2382
class cmd_version(Command):
2383
"""Show version of bzr."""
2387
from bzrlib.version import show_version
2391
class cmd_rocks(Command):
2392
"""Statement of optimism."""
2398
print "It sure does!"
2401
class cmd_find_merge_base(Command):
2402
"""Find and print a base revision for merging two branches."""
2403
# TODO: Options to specify revisions on either side, as if
2404
# merging only part of the history.
2405
takes_args = ['branch', 'other']
2409
def run(self, branch, other):
2410
from bzrlib.revision import MultipleRevisionSources
2412
branch1 = Branch.open_containing(branch)[0]
2413
branch2 = Branch.open_containing(other)[0]
2415
last1 = branch1.last_revision()
2416
last2 = branch2.last_revision()
2418
source = MultipleRevisionSources(branch1.repository,
2421
base_rev_id = common_ancestor(last1, last2, source)
2423
print 'merge base is revision %s' % base_rev_id
2426
class cmd_merge(Command):
2427
"""Perform a three-way merge.
2429
The branch is the branch you will merge from. By default, it will merge
2430
the latest revision. If you specify a revision, that revision will be
2431
merged. If you specify two revisions, the first will be used as a BASE,
2432
and the second one as OTHER. Revision numbers are always relative to the
2435
By default, bzr will try to merge in all new work from the other
2436
branch, automatically determining an appropriate base. If this
2437
fails, you may need to give an explicit base.
2439
Merge will do its best to combine the changes in two branches, but there
2440
are some kinds of problems only a human can fix. When it encounters those,
2441
it will mark a conflict. A conflict means that you need to fix something,
2442
before you should commit.
2444
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2446
If there is no default branch set, the first merge will set it. After
2447
that, you can omit the branch to use the default. To change the
2448
default, use --remember. The value will only be saved if the remote
2449
location can be accessed.
2451
The results of the merge are placed into the destination working
2452
directory, where they can be reviewed (with bzr diff), tested, and then
2453
committed to record the result of the merge.
2457
To merge the latest revision from bzr.dev
2458
bzr merge ../bzr.dev
2460
To merge changes up to and including revision 82 from bzr.dev
2461
bzr merge -r 82 ../bzr.dev
2463
To merge the changes introduced by 82, without previous changes:
2464
bzr merge -r 81..82 ../bzr.dev
2466
merge refuses to run if there are any uncommitted changes, unless
2469
takes_args = ['branch?']
2470
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2471
Option('show-base', help="Show base revision text in "
2473
Option('uncommitted', help='Apply uncommitted changes'
2474
' from a working copy, instead of branch changes'),
2475
Option('pull', help='If the destination is already'
2476
' completely merged into the source, pull from the'
2477
' source rather than merging. When this happens,'
2478
' you do not need to commit the result.'),
2480
help='Branch to merge into, '
2481
'rather than the one containing the working directory',
2487
def run(self, branch=None, revision=None, force=False, merge_type=None,
2488
show_base=False, reprocess=False, remember=False,
2489
uncommitted=False, pull=False,
2492
from bzrlib.tag import _merge_tags_if_possible
2493
other_revision_id = None
2494
if merge_type is None:
2495
merge_type = _mod_merge.Merge3Merger
2497
if directory is None: directory = u'.'
2498
# XXX: jam 20070225 WorkingTree should be locked before you extract its
2499
# inventory. Because merge is a mutating operation, it really
2500
# should be a lock_write() for the whole cmd_merge operation.
2501
# However, cmd_merge open's its own tree in _merge_helper, which
2502
# means if we lock here, the later lock_write() will always block.
2503
# Either the merge helper code should be updated to take a tree,
2504
# (What about tree.merge_from_branch?)
2505
tree = WorkingTree.open_containing(directory)[0]
2506
change_reporter = delta._ChangeReporter(
2507
unversioned_filter=tree.is_ignored)
2509
if branch is not None:
2511
mergeable = bundle.read_mergeable_from_url(
2513
except errors.NotABundle:
2514
pass # Continue on considering this url a Branch
2516
if revision is not None:
2517
raise errors.BzrCommandError(
2518
'Cannot use -r with merge directives or bundles')
2519
other_revision_id = mergeable.install_revisions(
2520
tree.branch.repository)
2521
revision = [RevisionSpec.from_string(
2522
'revid:' + other_revision_id)]
2524
if revision is None \
2525
or len(revision) < 1 or revision[0].needs_branch():
2526
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2528
if revision is None or len(revision) < 1:
2531
other = [branch, None]
2534
other = [branch, -1]
2535
other_branch, path = Branch.open_containing(branch)
2538
raise errors.BzrCommandError('Cannot use --uncommitted and'
2539
' --revision at the same time.')
2540
branch = revision[0].get_branch() or branch
2541
if len(revision) == 1:
2543
if other_revision_id is not None:
2548
other_branch, path = Branch.open_containing(branch)
2549
revno = revision[0].in_history(other_branch).revno
2550
other = [branch, revno]
2552
assert len(revision) == 2
2553
if None in revision:
2554
raise errors.BzrCommandError(
2555
"Merge doesn't permit empty revision specifier.")
2556
base_branch, path = Branch.open_containing(branch)
2557
branch1 = revision[1].get_branch() or branch
2558
other_branch, path1 = Branch.open_containing(branch1)
2559
if revision[0].get_branch() is not None:
2560
# then path was obtained from it, and is None.
2563
base = [branch, revision[0].in_history(base_branch).revno]
2564
other = [branch1, revision[1].in_history(other_branch).revno]
2566
if ((tree.branch.get_parent() is None or remember) and
2567
other_branch is not None):
2568
tree.branch.set_parent(other_branch.base)
2570
# pull tags now... it's a bit inconsistent to do it ahead of copying
2571
# the history but that's done inside the merge code
2572
if other_branch is not None:
2573
_merge_tags_if_possible(other_branch, tree.branch)
2576
interesting_files = [path]
2578
interesting_files = None
2579
pb = ui.ui_factory.nested_progress_bar()
2582
conflict_count = _merge_helper(
2583
other, base, other_rev_id=other_revision_id,
2584
check_clean=(not force),
2585
merge_type=merge_type,
2586
reprocess=reprocess,
2587
show_base=show_base,
2590
pb=pb, file_list=interesting_files,
2591
change_reporter=change_reporter)
2594
if conflict_count != 0:
2598
except errors.AmbiguousBase, e:
2599
m = ("sorry, bzr can't determine the right merge base yet\n"
2600
"candidates are:\n "
2601
+ "\n ".join(e.bases)
2603
"please specify an explicit base with -r,\n"
2604
"and (if you want) report this to the bzr developers\n")
2607
# TODO: move up to common parent; this isn't merge-specific anymore.
2608
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2609
"""Use tree.branch's parent if none was supplied.
2611
Report if the remembered location was used.
2613
if supplied_location is not None:
2614
return supplied_location
2615
stored_location = tree.branch.get_parent()
2616
mutter("%s", stored_location)
2617
if stored_location is None:
2618
raise errors.BzrCommandError("No location specified or remembered")
2619
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2620
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2621
return stored_location
2624
class cmd_remerge(Command):
2627
Use this if you want to try a different merge technique while resolving
2628
conflicts. Some merge techniques are better than others, and remerge
2629
lets you try different ones on different files.
2631
The options for remerge have the same meaning and defaults as the ones for
2632
merge. The difference is that remerge can (only) be run when there is a
2633
pending merge, and it lets you specify particular files.
2636
$ bzr remerge --show-base
2637
Re-do the merge of all conflicted files, and show the base text in
2638
conflict regions, in addition to the usual THIS and OTHER texts.
2640
$ bzr remerge --merge-type weave --reprocess foobar
2641
Re-do the merge of "foobar", using the weave merge algorithm, with
2642
additional processing to reduce the size of conflict regions.
2644
takes_args = ['file*']
2645
takes_options = ['merge-type', 'reprocess',
2646
Option('show-base', help="Show base revision text in "
2649
def run(self, file_list=None, merge_type=None, show_base=False,
2651
if merge_type is None:
2652
merge_type = _mod_merge.Merge3Merger
2653
tree, file_list = tree_files(file_list)
2656
parents = tree.get_parent_ids()
2657
if len(parents) != 2:
2658
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2659
" merges. Not cherrypicking or"
2661
repository = tree.branch.repository
2662
base_revision = common_ancestor(parents[0],
2663
parents[1], repository)
2664
base_tree = repository.revision_tree(base_revision)
2665
other_tree = repository.revision_tree(parents[1])
2666
interesting_ids = None
2668
conflicts = tree.conflicts()
2669
if file_list is not None:
2670
interesting_ids = set()
2671
for filename in file_list:
2672
file_id = tree.path2id(filename)
2674
raise errors.NotVersionedError(filename)
2675
interesting_ids.add(file_id)
2676
if tree.kind(file_id) != "directory":
2679
for name, ie in tree.inventory.iter_entries(file_id):
2680
interesting_ids.add(ie.file_id)
2681
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2683
# Remerge only supports resolving contents conflicts
2684
allowed_conflicts = ('text conflict', 'contents conflict')
2685
restore_files = [c.path for c in conflicts
2686
if c.typestring in allowed_conflicts]
2687
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2688
tree.set_conflicts(ConflictList(new_conflicts))
2689
if file_list is not None:
2690
restore_files = file_list
2691
for filename in restore_files:
2693
restore(tree.abspath(filename))
2694
except errors.NotConflicted:
2696
conflicts = _mod_merge.merge_inner(
2697
tree.branch, other_tree, base_tree,
2699
interesting_ids=interesting_ids,
2700
other_rev_id=parents[1],
2701
merge_type=merge_type,
2702
show_base=show_base,
2703
reprocess=reprocess)
2712
class cmd_revert(Command):
2713
"""Revert files to a previous revision.
2715
Giving a list of files will revert only those files. Otherwise, all files
2716
will be reverted. If the revision is not specified with '--revision', the
2717
last committed revision is used.
2719
To remove only some changes, without reverting to a prior version, use
2720
merge instead. For example, "merge . --r-2..-3" will remove the changes
2721
introduced by -2, without affecting the changes introduced by -1. Or
2722
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2724
By default, any files that have been manually changed will be backed up
2725
first. (Files changed only by merge are not backed up.) Backup files have
2726
'.~#~' appended to their name, where # is a number.
2728
When you provide files, you can use their current pathname or the pathname
2729
from the target revision. So you can use revert to "undelete" a file by
2730
name. If you name a directory, all the contents of that directory will be
2733
takes_options = ['revision', 'no-backup']
2734
takes_args = ['file*']
2736
def run(self, revision=None, no_backup=False, file_list=None):
2737
if file_list is not None:
2738
if len(file_list) == 0:
2739
raise errors.BzrCommandError("No files specified")
2743
tree, file_list = tree_files(file_list)
2744
if revision is None:
2745
# FIXME should be tree.last_revision
2746
rev_id = tree.last_revision()
2747
elif len(revision) != 1:
2748
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2750
rev_id = revision[0].in_history(tree.branch).rev_id
2751
pb = ui.ui_factory.nested_progress_bar()
2753
tree.revert(file_list,
2754
tree.branch.repository.revision_tree(rev_id),
2755
not no_backup, pb, report_changes=True)
2760
class cmd_assert_fail(Command):
2761
"""Test reporting of assertion failures"""
2762
# intended just for use in testing
2767
raise AssertionError("always fails")
2770
class cmd_help(Command):
2771
"""Show help on a command or other topic.
2773
For a list of all available commands, say 'bzr help commands'.
2775
takes_options = [Option('long', 'show help on all commands')]
2776
takes_args = ['topic?']
2777
aliases = ['?', '--help', '-?', '-h']
2780
def run(self, topic=None, long=False):
2782
if topic is None and long:
2784
bzrlib.help.help(topic)
2787
class cmd_shell_complete(Command):
2788
"""Show appropriate completions for context.
2790
For a list of all available commands, say 'bzr shell-complete'.
2792
takes_args = ['context?']
2797
def run(self, context=None):
2798
import shellcomplete
2799
shellcomplete.shellcomplete(context)
2802
class cmd_fetch(Command):
2803
"""Copy in history from another branch but don't merge it.
2805
This is an internal method used for pull and merge.
2808
takes_args = ['from_branch', 'to_branch']
2809
def run(self, from_branch, to_branch):
2810
from bzrlib.fetch import Fetcher
2811
from_b = Branch.open(from_branch)
2812
to_b = Branch.open(to_branch)
2813
Fetcher(to_b, from_b)
2816
class cmd_missing(Command):
2817
"""Show unmerged/unpulled revisions between two branches.
2819
OTHER_BRANCH may be local or remote.
2821
takes_args = ['other_branch?']
2822
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2824
'Display changes in the local branch only'),
2825
Option('theirs-only',
2826
'Display changes in the remote branch only'),
2831
encoding_type = 'replace'
2834
def run(self, other_branch=None, reverse=False, mine_only=False,
2835
theirs_only=False, log_format=None, long=False, short=False, line=False,
2836
show_ids=False, verbose=False):
2837
from bzrlib.missing import find_unmerged, iter_log_data
2838
from bzrlib.log import log_formatter
2839
local_branch = Branch.open_containing(u".")[0]
2840
parent = local_branch.get_parent()
2841
if other_branch is None:
2842
other_branch = parent
2843
if other_branch is None:
2844
raise errors.BzrCommandError("No peer location known or specified.")
2845
display_url = urlutils.unescape_for_display(parent,
2847
print "Using last location: " + display_url
2849
remote_branch = Branch.open(other_branch)
2850
if remote_branch.base == local_branch.base:
2851
remote_branch = local_branch
2852
local_branch.lock_read()
2854
remote_branch.lock_read()
2856
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2857
if (log_format is None):
2858
log_format = log.log_formatter_registry.get_default(
2860
lf = log_format(to_file=self.outf,
2862
show_timezone='original')
2863
if reverse is False:
2864
local_extra.reverse()
2865
remote_extra.reverse()
2866
if local_extra and not theirs_only:
2867
print "You have %d extra revision(s):" % len(local_extra)
2868
for data in iter_log_data(local_extra, local_branch.repository,
2871
printed_local = True
2873
printed_local = False
2874
if remote_extra and not mine_only:
2875
if printed_local is True:
2877
print "You are missing %d revision(s):" % len(remote_extra)
2878
for data in iter_log_data(remote_extra, remote_branch.repository,
2881
if not remote_extra and not local_extra:
2883
print "Branches are up to date."
2887
remote_branch.unlock()
2889
local_branch.unlock()
2890
if not status_code and parent is None and other_branch is not None:
2891
local_branch.lock_write()
2893
# handle race conditions - a parent might be set while we run.
2894
if local_branch.get_parent() is None:
2895
local_branch.set_parent(remote_branch.base)
2897
local_branch.unlock()
2901
class cmd_plugins(Command):
2906
import bzrlib.plugin
2907
from inspect import getdoc
2908
for name, plugin in bzrlib.plugin.all_plugins().items():
2909
if getattr(plugin, '__path__', None) is not None:
2910
print plugin.__path__[0]
2911
elif getattr(plugin, '__file__', None) is not None:
2912
print plugin.__file__
2918
print '\t', d.split('\n')[0]
2921
class cmd_testament(Command):
2922
"""Show testament (signing-form) of a revision."""
2923
takes_options = ['revision',
2924
Option('long', help='Produce long-format testament'),
2925
Option('strict', help='Produce a strict-format'
2927
takes_args = ['branch?']
2929
def run(self, branch=u'.', revision=None, long=False, strict=False):
2930
from bzrlib.testament import Testament, StrictTestament
2932
testament_class = StrictTestament
2934
testament_class = Testament
2935
b = WorkingTree.open_containing(branch)[0].branch
2938
if revision is None:
2939
rev_id = b.last_revision()
2941
rev_id = revision[0].in_history(b).rev_id
2942
t = testament_class.from_revision(b.repository, rev_id)
2944
sys.stdout.writelines(t.as_text_lines())
2946
sys.stdout.write(t.as_short_text())
2951
class cmd_annotate(Command):
2952
"""Show the origin of each line in a file.
2954
This prints out the given file with an annotation on the left side
2955
indicating which revision, author and date introduced the change.
2957
If the origin is the same for a run of consecutive lines, it is
2958
shown only at the top, unless the --all option is given.
2960
# TODO: annotate directories; showing when each file was last changed
2961
# TODO: if the working copy is modified, show annotations on that
2962
# with new uncommitted lines marked
2963
aliases = ['ann', 'blame', 'praise']
2964
takes_args = ['filename']
2965
takes_options = [Option('all', help='show annotations on all lines'),
2966
Option('long', help='show date in annotations'),
2972
def run(self, filename, all=False, long=False, revision=None,
2974
from bzrlib.annotate import annotate_file
2975
tree, relpath = WorkingTree.open_containing(filename)
2976
branch = tree.branch
2979
if revision is None:
2980
revision_id = branch.last_revision()
2981
elif len(revision) != 1:
2982
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2984
revision_id = revision[0].in_history(branch).rev_id
2985
file_id = tree.path2id(relpath)
2986
tree = branch.repository.revision_tree(revision_id)
2987
file_version = tree.inventory[file_id].revision
2988
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
2994
class cmd_re_sign(Command):
2995
"""Create a digital signature for an existing revision."""
2996
# TODO be able to replace existing ones.
2998
hidden = True # is this right ?
2999
takes_args = ['revision_id*']
3000
takes_options = ['revision']
3002
def run(self, revision_id_list=None, revision=None):
3003
import bzrlib.gpg as gpg
3004
if revision_id_list is not None and revision is not None:
3005
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3006
if revision_id_list is None and revision is None:
3007
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3008
b = WorkingTree.open_containing(u'.')[0].branch
3009
gpg_strategy = gpg.GPGStrategy(b.get_config())
3010
if revision_id_list is not None:
3011
for revision_id in revision_id_list:
3012
b.repository.sign_revision(revision_id, gpg_strategy)
3013
elif revision is not None:
3014
if len(revision) == 1:
3015
revno, rev_id = revision[0].in_history(b)
3016
b.repository.sign_revision(rev_id, gpg_strategy)
3017
elif len(revision) == 2:
3018
# are they both on rh- if so we can walk between them
3019
# might be nice to have a range helper for arbitrary
3020
# revision paths. hmm.
3021
from_revno, from_revid = revision[0].in_history(b)
3022
to_revno, to_revid = revision[1].in_history(b)
3023
if to_revid is None:
3024
to_revno = b.revno()
3025
if from_revno is None or to_revno is None:
3026
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3027
for revno in range(from_revno, to_revno + 1):
3028
b.repository.sign_revision(b.get_rev_id(revno),
3031
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3034
class cmd_bind(Command):
3035
"""Convert the current branch into a checkout of the supplied branch.
3037
Once converted into a checkout, commits must succeed on the master branch
3038
before they will be applied to the local branch.
3040
See "help checkouts" for more information on checkouts.
3043
takes_args = ['location?']
3046
def run(self, location=None):
3047
b, relpath = Branch.open_containing(u'.')
3048
if location is None:
3050
location = b.get_old_bound_location()
3051
except errors.UpgradeRequired:
3052
raise errors.BzrCommandError('No location supplied. '
3053
'This format does not remember old locations.')
3055
if location is None:
3056
raise errors.BzrCommandError('No location supplied and no '
3057
'previous location known')
3058
b_other = Branch.open(location)
3061
except errors.DivergedBranches:
3062
raise errors.BzrCommandError('These branches have diverged.'
3063
' Try merging, and then bind again.')
3066
class cmd_unbind(Command):
3067
"""Convert the current checkout into a regular branch.
3069
After unbinding, the local branch is considered independent and subsequent
3070
commits will be local only.
3072
See "help checkouts" for more information on checkouts.
3079
b, relpath = Branch.open_containing(u'.')
3081
raise errors.BzrCommandError('Local branch is not bound')
3084
class cmd_uncommit(Command):
3085
"""Remove the last committed revision.
3087
--verbose will print out what is being removed.
3088
--dry-run will go through all the motions, but not actually
3091
In the future, uncommit will create a revision bundle, which can then
3095
# TODO: jam 20060108 Add an option to allow uncommit to remove
3096
# unreferenced information in 'branch-as-repository' branches.
3097
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3098
# information in shared branches as well.
3099
takes_options = ['verbose', 'revision',
3100
Option('dry-run', help='Don\'t actually make changes'),
3101
Option('force', help='Say yes to all questions.')]
3102
takes_args = ['location?']
3105
def run(self, location=None,
3106
dry_run=False, verbose=False,
3107
revision=None, force=False):
3108
from bzrlib.log import log_formatter, show_log
3110
from bzrlib.uncommit import uncommit
3112
if location is None:
3114
control, relpath = bzrdir.BzrDir.open_containing(location)
3116
tree = control.open_workingtree()
3118
except (errors.NoWorkingTree, errors.NotLocalUrl):
3120
b = control.open_branch()
3123
if revision is None:
3126
# 'bzr uncommit -r 10' actually means uncommit
3127
# so that the final tree is at revno 10.
3128
# but bzrlib.uncommit.uncommit() actually uncommits
3129
# the revisions that are supplied.
3130
# So we need to offset it by one
3131
revno = revision[0].in_history(b).revno+1
3133
if revno <= b.revno():
3134
rev_id = b.get_rev_id(revno)
3136
self.outf.write('No revisions to uncommit.\n')
3139
lf = log_formatter('short',
3141
show_timezone='original')
3146
direction='forward',
3147
start_revision=revno,
3148
end_revision=b.revno())
3151
print 'Dry-run, pretending to remove the above revisions.'
3153
val = raw_input('Press <enter> to continue')
3155
print 'The above revision(s) will be removed.'
3157
val = raw_input('Are you sure [y/N]? ')
3158
if val.lower() not in ('y', 'yes'):
3162
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3166
class cmd_break_lock(Command):
3167
"""Break a dead lock on a repository, branch or working directory.
3169
CAUTION: Locks should only be broken when you are sure that the process
3170
holding the lock has been stopped.
3172
You can get information on what locks are open via the 'bzr info' command.
3177
takes_args = ['location?']
3179
def run(self, location=None, show=False):
3180
if location is None:
3182
control, relpath = bzrdir.BzrDir.open_containing(location)
3184
control.break_lock()
3185
except NotImplementedError:
3189
class cmd_wait_until_signalled(Command):
3190
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3192
This just prints a line to signal when it is ready, then blocks on stdin.
3198
sys.stdout.write("running\n")
3200
sys.stdin.readline()
3203
class cmd_serve(Command):
3204
"""Run the bzr server."""
3206
aliases = ['server']
3210
help='serve on stdin/out for use from inetd or sshd'),
3212
help='listen for connections on nominated port of the form '
3213
'[hostname:]portnumber. Passing 0 as the port number will '
3214
'result in a dynamically allocated port. Default port is '
3218
help='serve contents of directory',
3220
Option('allow-writes',
3221
help='By default the server is a readonly server. Supplying '
3222
'--allow-writes enables write access to the contents of '
3223
'the served directory and below. '
3227
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3228
from bzrlib.smart import server, medium
3229
from bzrlib.transport import get_transport
3230
from bzrlib.transport.remote import BZR_DEFAULT_PORT
3231
if directory is None:
3232
directory = os.getcwd()
3233
url = urlutils.local_path_to_url(directory)
3234
if not allow_writes:
3235
url = 'readonly+' + url
3236
t = get_transport(url)
3238
smart_server = medium.SmartServerPipeStreamMedium(
3239
sys.stdin, sys.stdout, t)
3242
port = BZR_DEFAULT_PORT
3246
host, port = port.split(':')
3250
smart_server = server.SmartTCPServer(t, host=host, port=port)
3251
print 'listening on port: ', smart_server.port
3253
smart_server.serve()
3255
class cmd_join(Command):
3256
"""Combine a subtree into its containing tree.
3258
This command is for experimental use only. It requires the target tree
3259
to be in dirstate-with-subtree format, which cannot be converted into
3262
The TREE argument should be an independent tree, inside another tree, but
3263
not part of it. (Such trees can be produced by "bzr split", but also by
3264
running "bzr branch" with the target inside a tree.)
3266
The result is a combined tree, with the subtree no longer an independant
3267
part. This is marked as a merge of the subtree into the containing tree,
3268
and all history is preserved.
3270
If --reference is specified, the subtree retains its independence. It can
3271
be branched by itself, and can be part of multiple projects at the same
3272
time. But operations performed in the containing tree, such as commit
3273
and merge, will recurse into the subtree.
3276
takes_args = ['tree']
3277
takes_options = [Option('reference', 'join by reference')]
3280
def run(self, tree, reference=False):
3281
sub_tree = WorkingTree.open(tree)
3282
parent_dir = osutils.dirname(sub_tree.basedir)
3283
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3284
repo = containing_tree.branch.repository
3285
if not repo.supports_rich_root():
3286
raise errors.BzrCommandError(
3287
"Can't join trees because %s doesn't support rich root data.\n"
3288
"You can use bzr upgrade on the repository."
3292
containing_tree.add_reference(sub_tree)
3293
except errors.BadReferenceTarget, e:
3294
# XXX: Would be better to just raise a nicely printable
3295
# exception from the real origin. Also below. mbp 20070306
3296
raise errors.BzrCommandError("Cannot join %s. %s" %
3300
containing_tree.subsume(sub_tree)
3301
except errors.BadSubsumeSource, e:
3302
raise errors.BzrCommandError("Cannot join %s. %s" %
3306
class cmd_split(Command):
3307
"""Split a tree into two trees.
3309
This command is for experimental use only. It requires the target tree
3310
to be in dirstate-with-subtree format, which cannot be converted into
3313
The TREE argument should be a subdirectory of a working tree. That
3314
subdirectory will be converted into an independent tree, with its own
3315
branch. Commits in the top-level tree will not apply to the new subtree.
3316
If you want that behavior, do "bzr join --reference TREE".
3318
To undo this operation, do "bzr join TREE".
3321
takes_args = ['tree']
3325
def run(self, tree):
3326
containing_tree, subdir = WorkingTree.open_containing(tree)
3327
sub_id = containing_tree.path2id(subdir)
3329
raise errors.NotVersionedError(subdir)
3331
containing_tree.extract(sub_id)
3332
except errors.RootNotRich:
3333
raise errors.UpgradeRequired(containing_tree.branch.base)
3337
class cmd_merge_directive(Command):
3338
"""Generate a merge directive for auto-merge tools.
3340
A directive requests a merge to be performed, and also provides all the
3341
information necessary to do so. This means it must either include a
3342
revision bundle, or the location of a branch containing the desired
3345
A submit branch (the location to merge into) must be supplied the first
3346
time the command is issued. After it has been supplied once, it will
3347
be remembered as the default.
3349
A public branch is optional if a revision bundle is supplied, but required
3350
if --diff or --plain is specified. It will be remembered as the default
3351
after the first use.
3354
takes_args = ['submit_branch?', 'public_branch?']
3357
RegistryOption.from_kwargs('patch-type',
3358
'The type of patch to include in the directive',
3359
title='Patch type', value_switches=True, enum_switch=False,
3360
bundle='Bazaar revision bundle (default)',
3361
diff='Normal unified diff',
3362
plain='No patch, just directive'),
3363
Option('sign', help='GPG-sign the directive'), 'revision',
3364
Option('mail-to', type=str,
3365
help='Instead of printing the directive, email to this address'),
3366
Option('message', type=str, short_name='m',
3367
help='Message to use when committing this merge')
3370
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3371
sign=False, revision=None, mail_to=None, message=None):
3372
if patch_type == 'plain':
3374
branch = Branch.open('.')
3375
stored_submit_branch = branch.get_submit_branch()
3376
if submit_branch is None:
3377
submit_branch = stored_submit_branch
3379
if stored_submit_branch is None:
3380
branch.set_submit_branch(submit_branch)
3381
if submit_branch is None:
3382
submit_branch = branch.get_parent()
3383
if submit_branch is None:
3384
raise errors.BzrCommandError('No submit branch specified or known')
3386
stored_public_branch = branch.get_public_branch()
3387
if public_branch is None:
3388
public_branch = stored_public_branch
3389
elif stored_public_branch is None:
3390
branch.set_public_branch(public_branch)
3391
if patch_type != "bundle" and public_branch is None:
3392
raise errors.BzrCommandError('No public branch specified or'
3394
if revision is not None:
3395
if len(revision) != 1:
3396
raise errors.BzrCommandError('bzr merge-directive takes '
3397
'exactly one revision identifier')
3399
revision_id = revision[0].in_history(branch).rev_id
3401
revision_id = branch.last_revision()
3402
directive = merge_directive.MergeDirective.from_objects(
3403
branch.repository, revision_id, time.time(),
3404
osutils.local_time_offset(), submit_branch,
3405
public_branch=public_branch, patch_type=patch_type,
3409
self.outf.write(directive.to_signed(branch))
3411
self.outf.writelines(directive.to_lines())
3413
message = directive.to_email(mail_to, branch, sign)
3415
server = branch.get_config().get_user_option('smtp_server')
3417
server = 'localhost'
3419
s.sendmail(message['From'], message['To'], message.as_string())
3422
class cmd_tag(Command):
3423
"""Create a tag naming a revision.
3425
Tags give human-meaningful names to revisions. Commands that take a -r
3426
(--revision) option can be given -rtag:X, where X is any previously
3429
Tags are stored in the branch. Tags are copied from one branch to another
3430
along when you branch, push, pull or merge.
3432
It is an error to give a tag name that already exists unless you pass
3433
--force, in which case the tag is moved to point to the new revision.
3436
takes_args = ['tag_name']
3439
help='Delete this tag rather than placing it.',
3442
help='Branch in which to place the tag.',
3447
help='Replace existing tags',
3452
def run(self, tag_name,
3458
branch, relpath = Branch.open_containing(directory)
3462
branch.tags.delete_tag(tag_name)
3463
self.outf.write('Deleted tag %s.\n' % tag_name)
3466
if len(revision) != 1:
3467
raise errors.BzrCommandError(
3468
"Tags can only be placed on a single revision, "
3470
revision_id = revision[0].in_history(branch).rev_id
3472
revision_id = branch.last_revision()
3473
if (not force) and branch.tags.has_tag(tag_name):
3474
raise errors.TagAlreadyExists(tag_name)
3475
branch.tags.set_tag(tag_name, revision_id)
3476
self.outf.write('Created tag %s.\n' % tag_name)
3481
class cmd_tags(Command):
3484
This tag shows a table of tag names and the revisions they reference.
3489
help='Branch whose tags should be displayed',
3499
branch, relpath = Branch.open_containing(directory)
3500
for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
3501
self.outf.write('%-20s %s\n' % (tag_name, target))
3504
# command-line interpretation helper for merge-related commands
3505
def _merge_helper(other_revision, base_revision,
3506
check_clean=True, ignore_zero=False,
3507
this_dir=None, backup_files=False,
3509
file_list=None, show_base=False, reprocess=False,
3512
change_reporter=None,
3514
"""Merge changes into a tree.
3517
list(path, revno) Base for three-way merge.
3518
If [None, None] then a base will be automatically determined.
3520
list(path, revno) Other revision for three-way merge.
3522
Directory to merge changes into; '.' by default.
3524
If true, this_dir must have no uncommitted changes before the
3526
ignore_zero - If true, suppress the "zero conflicts" message when
3527
there are no conflicts; should be set when doing something we expect
3528
to complete perfectly.
3529
file_list - If supplied, merge only changes to selected files.
3531
All available ancestors of other_revision and base_revision are
3532
automatically pulled into the branch.
3534
The revno may be -1 to indicate the last revision on the branch, which is
3537
This function is intended for use from the command line; programmatic
3538
clients might prefer to call merge.merge_inner(), which has less magic
3541
# Loading it late, so that we don't always have to import bzrlib.merge
3542
if merge_type is None:
3543
merge_type = _mod_merge.Merge3Merger
3544
if this_dir is None:
3546
this_tree = WorkingTree.open_containing(this_dir)[0]
3547
if show_base and not merge_type is _mod_merge.Merge3Merger:
3548
raise errors.BzrCommandError("Show-base is not supported for this merge"
3549
" type. %s" % merge_type)
3550
if reprocess and not merge_type.supports_reprocess:
3551
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3552
" type %s." % merge_type)
3553
if reprocess and show_base:
3554
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3555
# TODO: jam 20070226 We should really lock these trees earlier. However, we
3556
# only want to take out a lock_tree_write() if we don't have to pull
3557
# any ancestry. But merge might fetch ancestry in the middle, in
3558
# which case we would need a lock_write().
3559
# Because we cannot upgrade locks, for now we live with the fact that
3560
# the tree will be locked multiple times during a merge. (Maybe
3561
# read-only some of the time, but it means things will get read
3564
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3565
pb=pb, change_reporter=change_reporter)
3566
merger.pp = ProgressPhase("Merge phase", 5, pb)
3567
merger.pp.next_phase()
3568
merger.check_basis(check_clean)
3569
if other_rev_id is not None:
3570
merger.set_other_revision(other_rev_id, this_tree.branch)
3572
merger.set_other(other_revision)
3573
merger.pp.next_phase()
3574
merger.set_base(base_revision)
3575
if merger.base_rev_id == merger.other_rev_id:
3576
note('Nothing to do.')
3578
if file_list is None:
3579
if pull and merger.base_rev_id == merger.this_rev_id:
3580
# FIXME: deduplicate with pull
3581
result = merger.this_tree.pull(merger.this_branch,
3582
False, merger.other_rev_id)
3583
if result.old_revid == result.new_revid:
3584
note('No revisions to pull.')
3586
note('Now on revision %d.' % result.new_revno)
3588
merger.backup_files = backup_files
3589
merger.merge_type = merge_type
3590
merger.set_interesting_files(file_list)
3591
merger.show_base = show_base
3592
merger.reprocess = reprocess
3593
conflicts = merger.do_merge()
3594
if file_list is None:
3595
merger.set_pending()
3602
merge = _merge_helper
3605
# these get imported and then picked up by the scan for cmd_*
3606
# TODO: Some more consistent way to split command definitions across files;
3607
# we do need to load at least some information about them to know of
3608
# aliases. ideally we would avoid loading the implementation until the
3609
# details were needed.
3610
from bzrlib.cmd_version_info import cmd_version_info
3611
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3612
from bzrlib.bundle.commands import cmd_bundle_revisions
3613
from bzrlib.sign_my_commits import cmd_sign_my_commits
3614
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3615
cmd_weave_plan_merge, cmd_weave_merge_text