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 in 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', 'short']
187
aliases = ['st', 'stat']
189
encoding_type = 'replace'
192
def run(self, show_ids=False, file_list=None, revision=None, short=False):
193
from bzrlib.status import show_tree_status
195
tree, file_list = tree_files(file_list)
197
show_tree_status(tree, show_ids=show_ids,
198
specific_files=file_list, revision=revision,
203
class cmd_cat_revision(Command):
204
"""Write out metadata for a revision.
206
The revision to print can either be specified by a specific
207
revision identifier, or you can use --revision.
211
takes_args = ['revision_id?']
212
takes_options = ['revision']
213
# cat-revision is more for frontends so should be exact
217
def run(self, revision_id=None, revision=None):
219
if revision_id is not None and revision is not None:
220
raise errors.BzrCommandError('You can only supply one of'
221
' revision_id or --revision')
222
if revision_id is None and revision is None:
223
raise errors.BzrCommandError('You must supply either'
224
' --revision or a revision_id')
225
b = WorkingTree.open_containing(u'.')[0].branch
227
# TODO: jam 20060112 should cat-revision always output utf-8?
228
if revision_id is not None:
229
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
230
elif revision is not None:
233
raise errors.BzrCommandError('You cannot specify a NULL'
235
revno, rev_id = rev.in_history(b)
236
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
239
class cmd_remove_tree(Command):
240
"""Remove the working tree from a given branch/checkout.
242
Since a lightweight checkout is little more than a working tree
243
this will refuse to run against one.
246
takes_args = ['location?']
248
def run(self, location='.'):
249
d = bzrdir.BzrDir.open(location)
252
working = d.open_workingtree()
253
except errors.NoWorkingTree:
254
raise errors.BzrCommandError("No working tree to remove")
255
except errors.NotLocalUrl:
256
raise errors.BzrCommandError("You cannot remove the working tree of a "
259
working_path = working.bzrdir.root_transport.base
260
branch_path = working.branch.bzrdir.root_transport.base
261
if working_path != branch_path:
262
raise errors.BzrCommandError("You cannot remove the working tree from "
263
"a lightweight checkout")
265
d.destroy_workingtree()
268
class cmd_revno(Command):
269
"""Show current revision number.
271
This is equal to the number of revisions on this branch.
274
takes_args = ['location?']
277
def run(self, location=u'.'):
278
self.outf.write(str(Branch.open_containing(location)[0].revno()))
279
self.outf.write('\n')
282
class cmd_revision_info(Command):
283
"""Show revision number and revision id for a given revision identifier.
286
takes_args = ['revision_info*']
287
takes_options = ['revision']
290
def run(self, revision=None, revision_info_list=[]):
293
if revision is not None:
294
revs.extend(revision)
295
if revision_info_list is not None:
296
for rev in revision_info_list:
297
revs.append(RevisionSpec.from_string(rev))
299
raise errors.BzrCommandError('You must supply a revision identifier')
301
b = WorkingTree.open_containing(u'.')[0].branch
304
revinfo = rev.in_history(b)
305
if revinfo.revno is None:
306
print ' %s' % revinfo.rev_id
308
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
311
class cmd_add(Command):
312
"""Add specified files or directories.
314
In non-recursive mode, all the named items are added, regardless
315
of whether they were previously ignored. A warning is given if
316
any of the named files are already versioned.
318
In recursive mode (the default), files are treated the same way
319
but the behaviour for directories is different. Directories that
320
are already versioned do not give a warning. All directories,
321
whether already versioned or not, are searched for files or
322
subdirectories that are neither versioned or ignored, and these
323
are added. This search proceeds recursively into versioned
324
directories. If no names are given '.' is assumed.
326
Therefore simply saying 'bzr add' will version all files that
327
are currently unknown.
329
Adding a file whose parent directory is not versioned will
330
implicitly add the parent, and so on up to the root. This means
331
you should never need to explicitly add a directory, they'll just
332
get added when you add a file in the directory.
334
--dry-run will show which files would be added, but not actually
337
--file-ids-from will try to use the file ids from the supplied path.
338
It looks up ids trying to find a matching parent directory with the
339
same filename, and then by pure path.
341
takes_args = ['file*']
342
takes_options = ['no-recurse', 'dry-run', 'verbose',
343
Option('file-ids-from', type=unicode,
344
help='Lookup file ids from here')]
345
encoding_type = 'replace'
347
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
352
if file_ids_from is not None:
354
base_tree, base_path = WorkingTree.open_containing(
356
except errors.NoWorkingTree:
357
base_branch, base_path = Branch.open_containing(
359
base_tree = base_branch.basis_tree()
361
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
362
to_file=self.outf, should_print=(not is_quiet()))
364
action = bzrlib.add.AddAction(to_file=self.outf,
365
should_print=(not is_quiet()))
368
base_tree.lock_read()
370
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
371
action=action, save=not dry_run)
373
if base_tree is not None:
377
for glob in sorted(ignored.keys()):
378
for path in ignored[glob]:
379
self.outf.write("ignored %s matching \"%s\"\n"
383
for glob, paths in ignored.items():
384
match_len += len(paths)
385
self.outf.write("ignored %d file(s).\n" % match_len)
386
self.outf.write("If you wish to add some of these files,"
387
" please add them by name.\n")
390
class cmd_mkdir(Command):
391
"""Create a new versioned directory.
393
This is equivalent to creating the directory and then adding it.
396
takes_args = ['dir+']
397
encoding_type = 'replace'
399
def run(self, dir_list):
402
wt, dd = WorkingTree.open_containing(d)
404
self.outf.write('added %s\n' % d)
407
class cmd_relpath(Command):
408
"""Show path of a file relative to root"""
410
takes_args = ['filename']
414
def run(self, filename):
415
# TODO: jam 20050106 Can relpath return a munged path if
416
# sys.stdout encoding cannot represent it?
417
tree, relpath = WorkingTree.open_containing(filename)
418
self.outf.write(relpath)
419
self.outf.write('\n')
422
class cmd_inventory(Command):
423
"""Show inventory of the current working copy or a revision.
425
It is possible to limit the output to a particular entry
426
type using the --kind option. For example: --kind file.
428
It is also possible to restrict the list of files to a specific
429
set. For example: bzr inventory --show-ids this/file
436
takes_options = ['revision', 'show-ids', 'kind']
438
takes_args = ['file*']
441
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
442
if kind and kind not in ['file', 'directory', 'symlink']:
443
raise errors.BzrCommandError('invalid kind specified')
445
work_tree, file_list = tree_files(file_list)
446
work_tree.lock_read()
448
if revision is not None:
449
if len(revision) > 1:
450
raise errors.BzrCommandError(
451
'bzr inventory --revision takes exactly one revision'
453
revision_id = revision[0].in_history(work_tree.branch).rev_id
454
tree = work_tree.branch.repository.revision_tree(revision_id)
456
extra_trees = [work_tree]
462
if file_list is not None:
463
file_ids = tree.paths2ids(file_list, trees=extra_trees,
464
require_versioned=True)
465
# find_ids_across_trees may include some paths that don't
467
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
468
for file_id in file_ids if file_id in tree)
470
entries = tree.inventory.entries()
473
if tree is not work_tree:
476
for path, entry in entries:
477
if kind and kind != entry.kind:
480
self.outf.write('%-50s %s\n' % (path, entry.file_id))
482
self.outf.write(path)
483
self.outf.write('\n')
486
class cmd_mv(Command):
487
"""Move or rename a file.
490
bzr mv OLDNAME NEWNAME
491
bzr mv SOURCE... DESTINATION
493
If the last argument is a versioned directory, all the other names
494
are moved into it. Otherwise, there must be exactly two arguments
495
and the file is changed to a new name.
497
If OLDNAME does not exist on the filesystem but is versioned and
498
NEWNAME does exist on the filesystem but is not versioned, mv
499
assumes that the file has been manually moved and only updates
500
its internal inventory to reflect that change.
501
The same is valid when moving many SOURCE files to a DESTINATION.
503
Files cannot be moved between branches.
506
takes_args = ['names*']
507
takes_options = [Option("after", help="move only the bzr identifier"
508
" of the file (file has already been moved). Use this flag if"
509
" bzr is not able to detect this itself.")]
510
aliases = ['move', 'rename']
511
encoding_type = 'replace'
513
def run(self, names_list, after=False):
514
if names_list is None:
517
if len(names_list) < 2:
518
raise errors.BzrCommandError("missing file argument")
519
tree, rel_names = tree_files(names_list)
521
if os.path.isdir(names_list[-1]):
522
# move into existing directory
523
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
524
self.outf.write("%s => %s\n" % pair)
526
if len(names_list) != 2:
527
raise errors.BzrCommandError('to mv multiple files the'
528
' destination must be a versioned'
530
tree.rename_one(rel_names[0], rel_names[1], after=after)
531
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
534
class cmd_pull(Command):
535
"""Turn this branch into a mirror of another branch.
537
This command only works on branches that have not diverged. Branches are
538
considered diverged if the destination branch's most recent commit is one
539
that has not been merged (directly or indirectly) into the parent.
541
If branches have diverged, you can use 'bzr merge' to integrate the changes
542
from one into the other. Once one branch has merged, the other should
543
be able to pull it again.
545
If you want to forget your local changes and just update your branch to
546
match the remote one, use pull --overwrite.
548
If there is no default location set, the first pull will set it. After
549
that, you can omit the location to use the default. To change the
550
default, use --remember. The value will only be saved if the remote
551
location can be accessed.
554
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
556
help='branch to pull into, '
557
'rather than the one containing the working directory',
562
takes_args = ['location?']
563
encoding_type = 'replace'
565
def run(self, location=None, remember=False, overwrite=False,
566
revision=None, verbose=False,
568
from bzrlib.tag import _merge_tags_if_possible
569
# FIXME: too much stuff is in the command class
571
if directory is None:
574
tree_to = WorkingTree.open_containing(directory)[0]
575
branch_to = tree_to.branch
576
except errors.NoWorkingTree:
578
branch_to = Branch.open_containing(directory)[0]
581
if location is not None:
583
mergeable = bundle.read_mergeable_from_url(
585
except errors.NotABundle:
586
pass # Continue on considering this url a Branch
588
stored_loc = branch_to.get_parent()
590
if stored_loc is None:
591
raise errors.BzrCommandError("No pull location known or"
594
display_url = urlutils.unescape_for_display(stored_loc,
596
self.outf.write("Using saved location: %s\n" % display_url)
597
location = stored_loc
599
if mergeable is not None:
600
if revision is not None:
601
raise errors.BzrCommandError(
602
'Cannot use -r with merge directives or bundles')
603
rev_id = mergeable.get_target_revision(
604
branch_to.repository)
605
branch_from = branch_to
607
branch_from = Branch.open(location)
609
if branch_to.get_parent() is None or remember:
610
branch_to.set_parent(branch_from.base)
612
if revision is not None:
613
if len(revision) == 1:
614
rev_id = revision[0].in_history(branch_from).rev_id
616
raise errors.BzrCommandError(
617
'bzr pull --revision takes one value.')
619
old_rh = branch_to.revision_history()
620
if tree_to is not None:
621
result = tree_to.pull(branch_from, overwrite, rev_id,
622
delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
624
result = branch_to.pull(branch_from, overwrite, rev_id)
626
result.report(self.outf)
628
from bzrlib.log import show_changed_revisions
629
new_rh = branch_to.revision_history()
630
show_changed_revisions(branch_to, old_rh, new_rh,
634
class cmd_push(Command):
635
"""Update a mirror of this branch.
637
The target branch will not have its working tree populated because this
638
is both expensive, and is not supported on remote file systems.
640
Some smart servers or protocols *may* put the working tree in place in
643
This command only works on branches that have not diverged. Branches are
644
considered diverged if the destination branch's most recent commit is one
645
that has not been merged (directly or indirectly) by the source branch.
647
If branches have diverged, you can use 'bzr push --overwrite' to replace
648
the other branch completely, discarding its unmerged changes.
650
If you want to ensure you have the different changes in the other branch,
651
do a merge (see bzr help merge) from the other branch, and commit that.
652
After that you will be able to do a push without '--overwrite'.
654
If there is no default push location set, the first push will set it.
655
After that, you can omit the location to use the default. To change the
656
default, use --remember. The value will only be saved if the remote
657
location can be accessed.
660
takes_options = ['remember', 'overwrite', 'verbose',
661
Option('create-prefix',
662
help='Create the path leading up to the branch '
663
'if it does not already exist'),
665
help='branch to push from, '
666
'rather than the one containing the working directory',
670
Option('use-existing-dir',
671
help='By default push will fail if the target'
672
' directory exists, but does not already'
673
' have a control directory. This flag will'
674
' allow push to proceed.'),
676
takes_args = ['location?']
677
encoding_type = 'replace'
679
def run(self, location=None, remember=False, overwrite=False,
680
create_prefix=False, verbose=False,
681
use_existing_dir=False,
683
# FIXME: Way too big! Put this into a function called from the
685
if directory is None:
687
br_from = Branch.open_containing(directory)[0]
688
stored_loc = br_from.get_push_location()
690
if stored_loc is None:
691
raise errors.BzrCommandError("No push location known or specified.")
693
display_url = urlutils.unescape_for_display(stored_loc,
695
self.outf.write("Using saved location: %s\n" % display_url)
696
location = stored_loc
698
to_transport = transport.get_transport(location)
699
location_url = to_transport.base
701
br_to = repository_to = dir_to = None
703
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
704
except errors.NotBranchError:
705
pass # Didn't find anything
707
# If we can open a branch, use its direct repository, otherwise see
708
# if there is a repository without a branch.
710
br_to = dir_to.open_branch()
711
except errors.NotBranchError:
712
# Didn't find a branch, can we find a repository?
714
repository_to = dir_to.find_repository()
715
except errors.NoRepositoryPresent:
718
# Found a branch, so we must have found a repository
719
repository_to = br_to.repository
723
# The destination doesn't exist; create it.
724
# XXX: Refactor the create_prefix/no_create_prefix code into a
725
# common helper function
727
to_transport.mkdir('.')
728
except errors.FileExists:
729
if not use_existing_dir:
730
raise errors.BzrCommandError("Target directory %s"
731
" already exists, but does not have a valid .bzr"
732
" directory. Supply --use-existing-dir to push"
733
" there anyway." % location)
734
except errors.NoSuchFile:
735
if not create_prefix:
736
raise errors.BzrCommandError("Parent directory of %s"
738
"\nYou may supply --create-prefix to create all"
739
" leading parent directories."
742
cur_transport = to_transport
743
needed = [cur_transport]
744
# Recurse upwards until we can create a directory successfully
746
new_transport = cur_transport.clone('..')
747
if new_transport.base == cur_transport.base:
748
raise errors.BzrCommandError("Failed to create path"
752
new_transport.mkdir('.')
753
except errors.NoSuchFile:
754
needed.append(new_transport)
755
cur_transport = new_transport
759
# Now we only need to create child directories
761
cur_transport = needed.pop()
762
cur_transport.mkdir('.')
764
# Now the target directory exists, but doesn't have a .bzr
765
# directory. So we need to create it, along with any work to create
766
# all of the dependent branches, etc.
767
dir_to = br_from.bzrdir.clone(location_url,
768
revision_id=br_from.last_revision())
769
br_to = dir_to.open_branch()
770
# TODO: Some more useful message about what was copied
771
note('Created new branch.')
772
# We successfully created the target, remember it
773
if br_from.get_push_location() is None or remember:
774
br_from.set_push_location(br_to.base)
775
elif repository_to is None:
776
# we have a bzrdir but no branch or repository
777
# XXX: Figure out what to do other than complain.
778
raise errors.BzrCommandError("At %s you have a valid .bzr control"
779
" directory, but not a branch or repository. This is an"
780
" unsupported configuration. Please move the target directory"
781
" out of the way and try again."
784
# We have a repository but no branch, copy the revisions, and then
786
last_revision_id = br_from.last_revision()
787
repository_to.fetch(br_from.repository,
788
revision_id=last_revision_id)
789
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
790
note('Created new branch.')
791
if br_from.get_push_location() is None or remember:
792
br_from.set_push_location(br_to.base)
793
else: # We have a valid to branch
794
# We were able to connect to the remote location, so remember it
795
# we don't need to successfully push because of possible divergence.
796
if br_from.get_push_location() is None or remember:
797
br_from.set_push_location(br_to.base)
798
old_rh = br_to.revision_history()
801
tree_to = dir_to.open_workingtree()
802
except errors.NotLocalUrl:
803
warning('This transport does not update the working '
804
'tree of: %s' % (br_to.base,))
805
push_result = br_from.push(br_to, overwrite)
806
except errors.NoWorkingTree:
807
push_result = br_from.push(br_to, overwrite)
811
push_result = br_from.push(tree_to.branch, overwrite)
815
except errors.DivergedBranches:
816
raise errors.BzrCommandError('These branches have diverged.'
817
' Try using "merge" and then "push".')
818
if push_result is not None:
819
push_result.report(self.outf)
821
new_rh = br_to.revision_history()
824
from bzrlib.log import show_changed_revisions
825
show_changed_revisions(br_to, old_rh, new_rh,
828
# we probably did a clone rather than a push, so a message was
833
class cmd_branch(Command):
834
"""Create a new copy of a branch.
836
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
837
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
839
To retrieve the branch as of a particular revision, supply the --revision
840
parameter, as in "branch foo/bar -r 5".
842
--basis is to speed up branching from remote branches. When specified, it
843
copies all the file-contents, inventory and revision data from the basis
844
branch before copying anything from the remote branch.
846
takes_args = ['from_location', 'to_location?']
847
takes_options = ['revision', 'basis']
848
aliases = ['get', 'clone']
850
def run(self, from_location, to_location=None, revision=None, basis=None):
851
from bzrlib.tag import _merge_tags_if_possible
854
elif len(revision) > 1:
855
raise errors.BzrCommandError(
856
'bzr branch --revision takes exactly 1 revision value')
858
br_from = Branch.open(from_location)
861
if basis is not None:
862
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
865
if len(revision) == 1 and revision[0] is not None:
866
revision_id = revision[0].in_history(br_from)[1]
868
# FIXME - wt.last_revision, fallback to branch, fall back to
869
# None or perhaps NULL_REVISION to mean copy nothing
871
revision_id = br_from.last_revision()
872
if to_location is None:
873
to_location = os.path.basename(from_location.rstrip("/\\"))
876
name = os.path.basename(to_location) + '\n'
878
to_transport = transport.get_transport(to_location)
880
to_transport.mkdir('.')
881
except errors.FileExists:
882
raise errors.BzrCommandError('Target directory "%s" already'
883
' exists.' % to_location)
884
except errors.NoSuchFile:
885
raise errors.BzrCommandError('Parent of "%s" does not exist.'
888
# preserve whatever source format we have.
889
dir = br_from.bzrdir.sprout(to_transport.base,
890
revision_id, basis_dir)
891
branch = dir.open_branch()
892
except errors.NoSuchRevision:
893
to_transport.delete_tree('.')
894
msg = "The branch %s has no revision %s." % (from_location, revision[0])
895
raise errors.BzrCommandError(msg)
896
except errors.UnlistableBranch:
897
osutils.rmtree(to_location)
898
msg = "The branch %s cannot be used as a --basis" % (basis,)
899
raise errors.BzrCommandError(msg)
901
branch.control_files.put_utf8('branch-name', name)
902
_merge_tags_if_possible(br_from, branch)
903
note('Branched %d revision(s).' % branch.revno())
908
class cmd_checkout(Command):
909
"""Create a new checkout of an existing branch.
911
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
912
the branch found in '.'. This is useful if you have removed the working tree
913
or if it was never created - i.e. if you pushed the branch to its current
916
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
917
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
919
To retrieve the branch as of a particular revision, supply the --revision
920
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
921
out of date [so you cannot commit] but it may be useful (i.e. to examine old
924
--basis is to speed up checking out from remote branches. When specified, it
925
uses the inventory and file contents from the basis branch in preference to the
926
branch being checked out.
928
See "help checkouts" for more information on checkouts.
930
takes_args = ['branch_location?', 'to_location?']
931
takes_options = ['revision', # , 'basis']
932
Option('lightweight',
933
help="perform a lightweight checkout. Lightweight "
934
"checkouts depend on access to the branch for "
935
"every operation. Normal checkouts can perform "
936
"common operations like diff and status without "
937
"such access, and also support local commits."
942
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
946
elif len(revision) > 1:
947
raise errors.BzrCommandError(
948
'bzr checkout --revision takes exactly 1 revision value')
949
if branch_location is None:
950
branch_location = osutils.getcwd()
951
to_location = branch_location
952
source = Branch.open(branch_location)
953
if len(revision) == 1 and revision[0] is not None:
954
revision_id = revision[0].in_history(source)[1]
957
if to_location is None:
958
to_location = os.path.basename(branch_location.rstrip("/\\"))
959
# if the source and to_location are the same,
960
# and there is no working tree,
961
# then reconstitute a branch
962
if (osutils.abspath(to_location) ==
963
osutils.abspath(branch_location)):
965
source.bzrdir.open_workingtree()
966
except errors.NoWorkingTree:
967
source.bzrdir.create_workingtree()
970
os.mkdir(to_location)
972
if e.errno == errno.EEXIST:
973
raise errors.BzrCommandError('Target directory "%s" already'
974
' exists.' % to_location)
975
if e.errno == errno.ENOENT:
976
raise errors.BzrCommandError('Parent of "%s" does not exist.'
980
source.create_checkout(to_location, revision_id, lightweight)
983
class cmd_renames(Command):
984
"""Show list of renamed files.
986
# TODO: Option to show renames between two historical versions.
988
# TODO: Only show renames under dir, rather than in the whole branch.
989
takes_args = ['dir?']
992
def run(self, dir=u'.'):
993
tree = WorkingTree.open_containing(dir)[0]
996
new_inv = tree.inventory
997
old_tree = tree.basis_tree()
1000
old_inv = old_tree.inventory
1001
renames = list(_mod_tree.find_renames(old_inv, new_inv))
1003
for old_name, new_name in renames:
1004
self.outf.write("%s => %s\n" % (old_name, new_name))
1011
class cmd_update(Command):
1012
"""Update a tree to have the latest code committed to its branch.
1014
This will perform a merge into the working tree, and may generate
1015
conflicts. If you have any local changes, you will still
1016
need to commit them after the update for the update to be complete.
1018
If you want to discard your local changes, you can just do a
1019
'bzr revert' instead of 'bzr commit' after the update.
1021
takes_args = ['dir?']
1024
def run(self, dir='.'):
1025
tree = WorkingTree.open_containing(dir)[0]
1026
master = tree.branch.get_master_branch()
1027
if master is not None:
1030
tree.lock_tree_write()
1032
existing_pending_merges = tree.get_parent_ids()[1:]
1033
last_rev = tree.last_revision()
1034
if last_rev == tree.branch.last_revision():
1035
# may be up to date, check master too.
1036
master = tree.branch.get_master_branch()
1037
if master is None or last_rev == master.last_revision():
1038
revno = tree.branch.revision_id_to_revno(last_rev)
1039
note("Tree is up to date at revision %d." % (revno,))
1041
conflicts = tree.update()
1042
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1043
note('Updated to revision %d.' % (revno,))
1044
if tree.get_parent_ids()[1:] != existing_pending_merges:
1045
note('Your local commits will now show as pending merges with '
1046
"'bzr status', and can be committed with 'bzr commit'.")
1055
class cmd_info(Command):
1056
"""Show information about a working tree, branch or repository.
1058
This command will show all known locations and formats associated to the
1059
tree, branch or repository. Statistical information is included with
1062
Branches and working trees will also report any missing revisions.
1064
takes_args = ['location?']
1065
takes_options = ['verbose']
1068
def run(self, location=None, verbose=False):
1069
from bzrlib.info import show_bzrdir_info
1070
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1074
class cmd_remove(Command):
1075
"""Make a file unversioned.
1077
This makes bzr stop tracking changes to a versioned file. It does
1078
not delete the working copy.
1080
You can specify one or more files, and/or --new. If you specify --new,
1081
only 'added' files will be removed. If you specify both, then new files
1082
in the specified directories will be removed. If the directories are
1083
also new, they will also be removed.
1085
takes_args = ['file*']
1086
takes_options = ['verbose', Option('new', help='remove newly-added files')]
1088
encoding_type = 'replace'
1090
def run(self, file_list, verbose=False, new=False):
1091
tree, file_list = tree_files(file_list)
1093
if file_list is None:
1094
raise errors.BzrCommandError('Specify one or more files to'
1095
' remove, or use --new.')
1097
added = tree.changes_from(tree.basis_tree(),
1098
specific_files=file_list).added
1099
file_list = sorted([f[0] for f in added], reverse=True)
1100
if len(file_list) == 0:
1101
raise errors.BzrCommandError('No matching files.')
1102
tree.remove(file_list, verbose=verbose, to_file=self.outf)
1105
class cmd_file_id(Command):
1106
"""Print file_id of a particular file or directory.
1108
The file_id is assigned when the file is first added and remains the
1109
same through all revisions where the file exists, even when it is
1114
takes_args = ['filename']
1117
def run(self, filename):
1118
tree, relpath = WorkingTree.open_containing(filename)
1119
i = tree.path2id(relpath)
1121
raise errors.NotVersionedError(filename)
1123
self.outf.write(i + '\n')
1126
class cmd_file_path(Command):
1127
"""Print path of file_ids to a file or directory.
1129
This prints one line for each directory down to the target,
1130
starting at the branch root.
1134
takes_args = ['filename']
1137
def run(self, filename):
1138
tree, relpath = WorkingTree.open_containing(filename)
1139
fid = tree.path2id(relpath)
1141
raise errors.NotVersionedError(filename)
1142
segments = osutils.splitpath(relpath)
1143
for pos in range(1, len(segments) + 1):
1144
path = osutils.joinpath(segments[:pos])
1145
self.outf.write("%s\n" % tree.path2id(path))
1148
class cmd_reconcile(Command):
1149
"""Reconcile bzr metadata in a branch.
1151
This can correct data mismatches that may have been caused by
1152
previous ghost operations or bzr upgrades. You should only
1153
need to run this command if 'bzr check' or a bzr developer
1154
advises you to run it.
1156
If a second branch is provided, cross-branch reconciliation is
1157
also attempted, which will check that data like the tree root
1158
id which was not present in very early bzr versions is represented
1159
correctly in both branches.
1161
At the same time it is run it may recompress data resulting in
1162
a potential saving in disk space or performance gain.
1164
The branch *MUST* be on a listable system such as local disk or sftp.
1166
takes_args = ['branch?']
1168
def run(self, branch="."):
1169
from bzrlib.reconcile import reconcile
1170
dir = bzrdir.BzrDir.open(branch)
1174
class cmd_revision_history(Command):
1175
"""Display the list of revision ids on a branch."""
1176
takes_args = ['location?']
1181
def run(self, location="."):
1182
branch = Branch.open_containing(location)[0]
1183
for revid in branch.revision_history():
1184
self.outf.write(revid)
1185
self.outf.write('\n')
1188
class cmd_ancestry(Command):
1189
"""List all revisions merged into this branch."""
1190
takes_args = ['location?']
1195
def run(self, location="."):
1197
wt = WorkingTree.open_containing(location)[0]
1198
except errors.NoWorkingTree:
1199
b = Branch.open(location)
1200
last_revision = b.last_revision()
1203
last_revision = wt.last_revision()
1205
revision_ids = b.repository.get_ancestry(last_revision)
1206
assert revision_ids[0] is None
1208
for revision_id in revision_ids:
1209
self.outf.write(revision_id + '\n')
1212
class cmd_init(Command):
1213
"""Make a directory into a versioned branch.
1215
Use this to create an empty branch, or before importing an
1218
If there is a repository in a parent directory of the location, then
1219
the history of the branch will be stored in the repository. Otherwise
1220
init creates a standalone branch which carries its own history in
1223
If there is already a branch at the location but it has no working tree,
1224
the tree can be populated with 'bzr checkout'.
1226
Recipe for importing a tree of files:
1231
bzr commit -m 'imported project'
1233
takes_args = ['location?']
1235
RegistryOption('format',
1236
help='Specify a format for this branch. '
1237
'See "help formats".',
1238
registry=bzrdir.format_registry,
1239
converter=bzrdir.format_registry.make_bzrdir,
1240
value_switches=True,
1241
title="Branch Format",
1243
Option('append-revisions-only',
1244
help='Never change revnos or the existing log.'
1245
' Append revisions to it only.')
1247
def run(self, location=None, format=None, append_revisions_only=False):
1249
format = bzrdir.format_registry.make_bzrdir('default')
1250
if location is None:
1253
to_transport = transport.get_transport(location)
1255
# The path has to exist to initialize a
1256
# branch inside of it.
1257
# Just using os.mkdir, since I don't
1258
# believe that we want to create a bunch of
1259
# locations if the user supplies an extended path
1260
# TODO: create-prefix
1262
to_transport.mkdir('.')
1263
except errors.FileExists:
1267
existing_bzrdir = bzrdir.BzrDir.open(location)
1268
except errors.NotBranchError:
1269
# really a NotBzrDir error...
1270
branch = bzrdir.BzrDir.create_branch_convenience(to_transport.base,
1273
from bzrlib.transport.local import LocalTransport
1274
if existing_bzrdir.has_branch():
1275
if (isinstance(to_transport, LocalTransport)
1276
and not existing_bzrdir.has_workingtree()):
1277
raise errors.BranchExistsWithoutWorkingTree(location)
1278
raise errors.AlreadyBranchError(location)
1280
branch = existing_bzrdir.create_branch()
1281
existing_bzrdir.create_workingtree()
1282
if append_revisions_only:
1284
branch.set_append_revisions_only(True)
1285
except errors.UpgradeRequired:
1286
raise errors.BzrCommandError('This branch format cannot be set'
1287
' to append-revisions-only. Try --experimental-branch6')
1290
class cmd_init_repository(Command):
1291
"""Create a shared repository to hold branches.
1293
New branches created under the repository directory will store their revisions
1294
in the repository, not in the branch directory, if the branch format supports
1300
bzr checkout --lightweight repo/trunk trunk-checkout
1304
takes_args = ["location"]
1305
takes_options = [RegistryOption('format',
1306
help='Specify a format for this repository. See'
1307
' "bzr help formats" for details',
1308
registry=bzrdir.format_registry,
1309
converter=bzrdir.format_registry.make_bzrdir,
1310
value_switches=True, title='Repository format'),
1312
help='Allows branches in repository to have'
1314
aliases = ["init-repo"]
1315
def run(self, location, format=None, trees=False):
1317
format = bzrdir.format_registry.make_bzrdir('default')
1319
if location is None:
1322
to_transport = transport.get_transport(location)
1324
to_transport.mkdir('.')
1325
except errors.FileExists:
1328
newdir = format.initialize_on_transport(to_transport)
1329
repo = newdir.create_repository(shared=True)
1330
repo.set_make_working_trees(trees)
1333
class cmd_diff(Command):
1334
"""Show differences in the working tree or between revisions.
1336
If files are listed, only the changes in those files are listed.
1337
Otherwise, all changes for the tree are listed.
1339
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1340
produces patches suitable for "patch -p1".
1344
Shows the difference in the working tree versus the last commit
1346
Difference between the working tree and revision 1
1348
Difference between revision 2 and revision 1
1349
bzr diff --prefix old/:new/
1350
Same as 'bzr diff' but prefix paths with old/ and new/
1351
bzr diff bzr.mine bzr.dev
1352
Show the differences between the two working trees
1354
Show just the differences for 'foo.c'
1356
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1357
# or a graphical diff.
1359
# TODO: Python difflib is not exactly the same as unidiff; should
1360
# either fix it up or prefer to use an external diff.
1362
# TODO: Selected-file diff is inefficient and doesn't show you
1365
# TODO: This probably handles non-Unix newlines poorly.
1367
takes_args = ['file*']
1368
takes_options = ['revision', 'diff-options',
1369
Option('prefix', type=str,
1371
help='Set prefixes to added to old and new filenames, as '
1372
'two values separated by a colon. (eg "old/:new/")'),
1374
aliases = ['di', 'dif']
1375
encoding_type = 'exact'
1378
def run(self, revision=None, file_list=None, diff_options=None,
1380
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1382
if (prefix is None) or (prefix == '0'):
1390
old_label, new_label = prefix.split(":")
1392
raise errors.BzrCommandError(
1393
'--prefix expects two values separated by a colon'
1394
' (eg "old/:new/")')
1396
if revision and len(revision) > 2:
1397
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1398
' one or two revision specifiers')
1401
tree1, file_list = internal_tree_files(file_list)
1405
except errors.FileInWrongBranch:
1406
if len(file_list) != 2:
1407
raise errors.BzrCommandError("Files are in different branches")
1409
tree1, file1 = WorkingTree.open_containing(file_list[0])
1410
tree2, file2 = WorkingTree.open_containing(file_list[1])
1411
if file1 != "" or file2 != "":
1412
# FIXME diff those two files. rbc 20051123
1413
raise errors.BzrCommandError("Files are in different branches")
1415
except errors.NotBranchError:
1416
if (revision is not None and len(revision) == 2
1417
and not revision[0].needs_branch()
1418
and not revision[1].needs_branch()):
1419
# If both revision specs include a branch, we can
1420
# diff them without needing a local working tree
1421
tree1, tree2 = None, None
1425
if tree2 is not None:
1426
if revision is not None:
1427
# FIXME: but there should be a clean way to diff between
1428
# non-default versions of two trees, it's not hard to do
1430
raise errors.BzrCommandError(
1431
"Sorry, diffing arbitrary revisions across branches "
1432
"is not implemented yet")
1433
return show_diff_trees(tree1, tree2, sys.stdout,
1434
specific_files=file_list,
1435
external_diff_options=diff_options,
1436
old_label=old_label, new_label=new_label)
1438
return diff_cmd_helper(tree1, file_list, diff_options,
1439
revision_specs=revision,
1440
old_label=old_label, new_label=new_label)
1443
class cmd_deleted(Command):
1444
"""List files deleted in the working tree.
1446
# TODO: Show files deleted since a previous revision, or
1447
# between two revisions.
1448
# TODO: Much more efficient way to do this: read in new
1449
# directories with readdir, rather than stating each one. Same
1450
# level of effort but possibly much less IO. (Or possibly not,
1451
# if the directories are very large...)
1452
takes_options = ['show-ids']
1455
def run(self, show_ids=False):
1456
tree = WorkingTree.open_containing(u'.')[0]
1459
old = tree.basis_tree()
1462
for path, ie in old.inventory.iter_entries():
1463
if not tree.has_id(ie.file_id):
1464
self.outf.write(path)
1466
self.outf.write(' ')
1467
self.outf.write(ie.file_id)
1468
self.outf.write('\n')
1475
class cmd_modified(Command):
1476
"""List files modified in working tree.
1478
See also: "bzr status".
1485
tree = WorkingTree.open_containing(u'.')[0]
1486
td = tree.changes_from(tree.basis_tree())
1487
for path, id, kind, text_modified, meta_modified in td.modified:
1488
self.outf.write(path + '\n')
1491
class cmd_added(Command):
1492
"""List files added in working tree.
1494
See also: "bzr status".
1501
wt = WorkingTree.open_containing(u'.')[0]
1504
basis = wt.basis_tree()
1507
basis_inv = basis.inventory
1510
if file_id in basis_inv:
1512
if inv.is_root(file_id) and len(basis_inv) == 0:
1514
path = inv.id2path(file_id)
1515
if not os.access(osutils.abspath(path), os.F_OK):
1517
self.outf.write(path + '\n')
1524
class cmd_root(Command):
1525
"""Show the tree root directory.
1527
The root is the nearest enclosing directory with a .bzr control
1529
takes_args = ['filename?']
1531
def run(self, filename=None):
1532
"""Print the branch root."""
1533
tree = WorkingTree.open_containing(filename)[0]
1534
self.outf.write(tree.basedir + '\n')
1537
class cmd_log(Command):
1538
"""Show log of a branch, file, or directory.
1540
By default show the log of the branch containing the working directory.
1542
To request a range of logs, you can use the command -r begin..end
1543
-r revision requests a specific revision, -r ..end or -r begin.. are
1549
bzr log -r -10.. http://server/branch
1552
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1554
takes_args = ['location?']
1555
takes_options = [Option('forward',
1556
help='show from oldest to newest'),
1560
help='show files changed in each revision'),
1561
'show-ids', 'revision',
1565
help='show revisions whose message matches this regexp',
1568
encoding_type = 'replace'
1571
def run(self, location=None, timezone='original',
1578
from bzrlib.log import show_log
1579
assert message is None or isinstance(message, basestring), \
1580
"invalid message argument %r" % message
1581
direction = (forward and 'forward') or 'reverse'
1586
# find the file id to log:
1588
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1592
tree = b.basis_tree()
1593
file_id = tree.path2id(fp)
1595
raise errors.BzrCommandError(
1596
"Path does not have any revision history: %s" %
1600
# FIXME ? log the current subdir only RBC 20060203
1601
if revision is not None \
1602
and len(revision) > 0 and revision[0].get_branch():
1603
location = revision[0].get_branch()
1606
dir, relpath = bzrdir.BzrDir.open_containing(location)
1607
b = dir.open_branch()
1611
if revision is None:
1614
elif len(revision) == 1:
1615
rev1 = rev2 = revision[0].in_history(b).revno
1616
elif len(revision) == 2:
1617
if revision[1].get_branch() != revision[0].get_branch():
1618
# b is taken from revision[0].get_branch(), and
1619
# show_log will use its revision_history. Having
1620
# different branches will lead to weird behaviors.
1621
raise errors.BzrCommandError(
1622
"Log doesn't accept two revisions in different"
1624
if revision[0].spec is None:
1625
# missing begin-range means first revision
1628
rev1 = revision[0].in_history(b).revno
1630
if revision[1].spec is None:
1631
# missing end-range means last known revision
1634
rev2 = revision[1].in_history(b).revno
1636
raise errors.BzrCommandError(
1637
'bzr log --revision takes one or two values.')
1639
# By this point, the revision numbers are converted to the +ve
1640
# form if they were supplied in the -ve form, so we can do
1641
# this comparison in relative safety
1643
(rev2, rev1) = (rev1, rev2)
1645
if log_format is None:
1646
log_format = log.log_formatter_registry.get_default(b)
1648
lf = log_format(show_ids=show_ids, to_file=self.outf,
1649
show_timezone=timezone)
1655
direction=direction,
1656
start_revision=rev1,
1663
def get_log_format(long=False, short=False, line=False, default='long'):
1664
log_format = default
1668
log_format = 'short'
1674
class cmd_touching_revisions(Command):
1675
"""Return revision-ids which affected a particular file.
1677
A more user-friendly interface is "bzr log FILE".
1681
takes_args = ["filename"]
1684
def run(self, filename):
1685
tree, relpath = WorkingTree.open_containing(filename)
1687
file_id = tree.path2id(relpath)
1688
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1689
self.outf.write("%6d %s\n" % (revno, what))
1692
class cmd_ls(Command):
1693
"""List files in a tree.
1696
takes_args = ['path?']
1697
# TODO: Take a revision or remote path and list that tree instead.
1698
takes_options = ['verbose', 'revision',
1699
Option('non-recursive',
1700
help='don\'t recurse into sub-directories'),
1702
help='Print all paths from the root of the branch.'),
1703
Option('unknown', help='Print unknown files'),
1704
Option('versioned', help='Print versioned files'),
1705
Option('ignored', help='Print ignored files'),
1707
Option('null', help='Null separate the files'),
1711
def run(self, revision=None, verbose=False,
1712
non_recursive=False, from_root=False,
1713
unknown=False, versioned=False, ignored=False,
1714
null=False, kind=None, show_ids=False, path=None):
1716
if kind and kind not in ('file', 'directory', 'symlink'):
1717
raise errors.BzrCommandError('invalid kind specified')
1719
if verbose and null:
1720
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1721
all = not (unknown or versioned or ignored)
1723
selection = {'I':ignored, '?':unknown, 'V':versioned}
1730
raise errors.BzrCommandError('cannot specify both --from-root'
1734
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1740
if revision is not None:
1741
tree = branch.repository.revision_tree(
1742
revision[0].in_history(branch).rev_id)
1744
tree = branch.basis_tree()
1748
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1749
if fp.startswith(relpath):
1750
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1751
if non_recursive and '/' in fp:
1753
if not all and not selection[fc]:
1755
if kind is not None and fkind != kind:
1758
kindch = entry.kind_character()
1759
outstring = '%-8s %s%s' % (fc, fp, kindch)
1760
if show_ids and fid is not None:
1761
outstring = "%-50s %s" % (outstring, fid)
1762
self.outf.write(outstring + '\n')
1764
self.outf.write(fp + '\0')
1767
self.outf.write(fid)
1768
self.outf.write('\0')
1776
self.outf.write('%-50s %s\n' % (fp, my_id))
1778
self.outf.write(fp + '\n')
1783
class cmd_unknowns(Command):
1784
"""List unknown files.
1786
See also: "bzr ls --unknown".
1793
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1794
self.outf.write(osutils.quotefn(f) + '\n')
1797
class cmd_ignore(Command):
1798
"""Ignore specified files or patterns.
1800
To remove patterns from the ignore list, edit the .bzrignore file.
1802
Trailing slashes on patterns are ignored.
1803
If the pattern contains a slash or is a regular expression, it is compared
1804
to the whole path from the branch root. Otherwise, it is compared to only
1805
the last component of the path. To match a file only in the root
1806
directory, prepend './'.
1808
Ignore patterns specifying absolute paths are not allowed.
1810
Ignore patterns may include globbing wildcards such as:
1811
? - Matches any single character except '/'
1812
* - Matches 0 or more characters except '/'
1813
/**/ - Matches 0 or more directories in a path
1814
[a-z] - Matches a single character from within a group of characters
1816
Ignore patterns may also be Python regular expressions.
1817
Regular expression ignore patterns are identified by a 'RE:' prefix
1818
followed by the regular expression. Regular expression ignore patterns
1819
may not include named or numbered groups.
1821
Note: ignore patterns containing shell wildcards must be quoted from
1825
bzr ignore ./Makefile
1826
bzr ignore '*.class'
1827
bzr ignore 'lib/**/*.o'
1828
bzr ignore 'RE:lib/.*\.o'
1830
takes_args = ['name_pattern*']
1832
Option('old-default-rules',
1833
help='Out the ignore rules bzr < 0.9 always used.')
1836
def run(self, name_pattern_list=None, old_default_rules=None):
1837
from bzrlib.atomicfile import AtomicFile
1838
if old_default_rules is not None:
1839
# dump the rules and exit
1840
for pattern in ignores.OLD_DEFAULTS:
1843
if not name_pattern_list:
1844
raise errors.BzrCommandError("ignore requires at least one "
1845
"NAME_PATTERN or --old-default-rules")
1846
name_pattern_list = [globbing.normalize_pattern(p)
1847
for p in name_pattern_list]
1848
for name_pattern in name_pattern_list:
1849
if (name_pattern[0] == '/' or
1850
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1851
raise errors.BzrCommandError(
1852
"NAME_PATTERN should not be an absolute path")
1853
tree, relpath = WorkingTree.open_containing(u'.')
1854
ifn = tree.abspath('.bzrignore')
1855
if os.path.exists(ifn):
1858
igns = f.read().decode('utf-8')
1864
# TODO: If the file already uses crlf-style termination, maybe
1865
# we should use that for the newly added lines?
1867
if igns and igns[-1] != '\n':
1869
for name_pattern in name_pattern_list:
1870
igns += name_pattern + '\n'
1872
f = AtomicFile(ifn, 'wb')
1874
f.write(igns.encode('utf-8'))
1879
if not tree.path2id('.bzrignore'):
1880
tree.add(['.bzrignore'])
1883
class cmd_ignored(Command):
1884
"""List ignored files and the patterns that matched them.
1886
See also: bzr ignore"""
1889
tree = WorkingTree.open_containing(u'.')[0]
1892
for path, file_class, kind, file_id, entry in tree.list_files():
1893
if file_class != 'I':
1895
## XXX: Slightly inefficient since this was already calculated
1896
pat = tree.is_ignored(path)
1897
print '%-50s %s' % (path, pat)
1902
class cmd_lookup_revision(Command):
1903
"""Lookup the revision-id from a revision-number
1906
bzr lookup-revision 33
1909
takes_args = ['revno']
1912
def run(self, revno):
1916
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1918
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1921
class cmd_export(Command):
1922
"""Export past revision to destination directory.
1924
If no revision is specified this exports the last committed revision.
1926
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1927
given, try to find the format with the extension. If no extension
1928
is found exports to a directory (equivalent to --format=dir).
1930
Root may be the top directory for tar, tgz and tbz2 formats. If none
1931
is given, the top directory will be the root name of the file.
1933
If branch is omitted then the branch containing the CWD will be used.
1935
Note: export of tree with non-ascii filenames to zip is not supported.
1937
Supported formats Autodetected by extension
1938
----------------- -------------------------
1941
tbz2 .tar.bz2, .tbz2
1945
takes_args = ['dest', 'branch?']
1946
takes_options = ['revision', 'format', 'root']
1947
def run(self, dest, branch=None, revision=None, format=None, root=None):
1948
from bzrlib.export import export
1951
tree = WorkingTree.open_containing(u'.')[0]
1954
b = Branch.open(branch)
1956
if revision is None:
1957
# should be tree.last_revision FIXME
1958
rev_id = b.last_revision()
1960
if len(revision) != 1:
1961
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1962
rev_id = revision[0].in_history(b).rev_id
1963
t = b.repository.revision_tree(rev_id)
1965
export(t, dest, format, root)
1966
except errors.NoSuchExportFormat, e:
1967
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1970
class cmd_cat(Command):
1971
"""Write a file's text from a previous revision."""
1973
takes_options = ['revision', 'name-from-revision']
1974
takes_args = ['filename']
1975
encoding_type = 'exact'
1978
def run(self, filename, revision=None, name_from_revision=False):
1979
if revision is not None and len(revision) != 1:
1980
raise errors.BzrCommandError("bzr cat --revision takes exactly"
1985
tree, b, relpath = \
1986
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
1987
except errors.NotBranchError:
1990
if revision is not None and revision[0].get_branch() is not None:
1991
b = Branch.open(revision[0].get_branch())
1993
tree = b.basis_tree()
1994
if revision is None:
1995
revision_id = b.last_revision()
1997
revision_id = revision[0].in_history(b).rev_id
1999
cur_file_id = tree.path2id(relpath)
2000
rev_tree = b.repository.revision_tree(revision_id)
2001
old_file_id = rev_tree.path2id(relpath)
2003
if name_from_revision:
2004
if old_file_id is None:
2005
raise errors.BzrCommandError("%r is not present in revision %s"
2006
% (filename, revision_id))
2008
rev_tree.print_file(old_file_id)
2009
elif cur_file_id is not None:
2010
rev_tree.print_file(cur_file_id)
2011
elif old_file_id is not None:
2012
rev_tree.print_file(old_file_id)
2014
raise errors.BzrCommandError("%r is not present in revision %s" %
2015
(filename, revision_id))
2018
class cmd_local_time_offset(Command):
2019
"""Show the offset in seconds from GMT to local time."""
2023
print osutils.local_time_offset()
2027
class cmd_commit(Command):
2028
"""Commit changes into a new revision.
2030
If no arguments are given, the entire tree is committed.
2032
If selected files are specified, only changes to those files are
2033
committed. If a directory is specified then the directory and everything
2034
within it is committed.
2036
A selected-file commit may fail in some cases where the committed
2037
tree would be invalid, such as trying to commit a file in a
2038
newly-added directory that is not itself committed.
2040
# TODO: Run hooks on tree to-be-committed, and after commit.
2042
# TODO: Strict commit that fails if there are deleted files.
2043
# (what does "deleted files" mean ??)
2045
# TODO: Give better message for -s, --summary, used by tla people
2047
# XXX: verbose currently does nothing
2049
takes_args = ['selected*']
2050
takes_options = ['message', 'verbose',
2052
help='commit even if nothing has changed'),
2053
Option('file', type=str,
2056
help='file containing commit message'),
2058
help="refuse to commit if there are unknown "
2059
"files in the working tree."),
2061
help="perform a local only commit in a bound "
2062
"branch. Such commits are not pushed to "
2063
"the master branch until a normal commit "
2067
aliases = ['ci', 'checkin']
2069
def run(self, message=None, file=None, verbose=True, selected_list=None,
2070
unchanged=False, strict=False, local=False):
2071
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
2072
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
2074
from bzrlib.msgeditor import edit_commit_message, \
2075
make_commit_message_template
2077
# TODO: Need a blackbox test for invoking the external editor; may be
2078
# slightly problematic to run this cross-platform.
2080
# TODO: do more checks that the commit will succeed before
2081
# spending the user's valuable time typing a commit message.
2082
tree, selected_list = tree_files(selected_list)
2083
if selected_list == ['']:
2084
# workaround - commit of root of tree should be exactly the same
2085
# as just default commit in that tree, and succeed even though
2086
# selected-file merge commit is not done yet
2089
if local and not tree.branch.get_bound_location():
2090
raise errors.LocalRequiresBoundBranch()
2092
def get_message(commit_obj):
2093
"""Callback to get commit message"""
2094
my_message = message
2095
if my_message is None and not file:
2096
template = make_commit_message_template(tree, selected_list)
2097
my_message = edit_commit_message(template)
2098
if my_message is None:
2099
raise errors.BzrCommandError("please specify a commit"
2100
" message with either --message or --file")
2101
elif my_message and file:
2102
raise errors.BzrCommandError(
2103
"please specify either --message or --file")
2105
my_message = codecs.open(file, 'rt',
2106
bzrlib.user_encoding).read()
2107
if my_message == "":
2108
raise errors.BzrCommandError("empty commit message specified")
2112
reporter = ReportCommitToLog()
2114
reporter = NullCommitReporter()
2117
tree.commit(message_callback=get_message,
2118
specific_files=selected_list,
2119
allow_pointless=unchanged, strict=strict, local=local,
2121
except PointlessCommit:
2122
# FIXME: This should really happen before the file is read in;
2123
# perhaps prepare the commit; get the message; then actually commit
2124
raise errors.BzrCommandError("no changes to commit."
2125
" use --unchanged to commit anyhow")
2126
except ConflictsInTree:
2127
raise errors.BzrCommandError('Conflicts detected in working '
2128
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2130
except StrictCommitFailed:
2131
raise errors.BzrCommandError("Commit refused because there are"
2132
" unknown files in the working tree.")
2133
except errors.BoundBranchOutOfDate, e:
2134
raise errors.BzrCommandError(str(e) + "\n"
2135
'To commit to master branch, run update and then commit.\n'
2136
'You can also pass --local to commit to continue working '
2140
class cmd_check(Command):
2141
"""Validate consistency of branch history.
2143
This command checks various invariants about the branch storage to
2144
detect data corruption or bzr bugs.
2146
takes_args = ['branch?']
2147
takes_options = ['verbose']
2149
def run(self, branch=None, verbose=False):
2150
from bzrlib.check import check
2152
tree = WorkingTree.open_containing()[0]
2153
branch = tree.branch
2155
branch = Branch.open(branch)
2156
check(branch, verbose)
2159
class cmd_upgrade(Command):
2160
"""Upgrade branch storage to current format.
2162
The check command or bzr developers may sometimes advise you to run
2163
this command. When the default format has changed you may also be warned
2164
during other operations to upgrade.
2166
takes_args = ['url?']
2168
RegistryOption('format',
2169
help='Upgrade to a specific format. See "bzr help'
2170
' formats" for details',
2171
registry=bzrdir.format_registry,
2172
converter=bzrdir.format_registry.make_bzrdir,
2173
value_switches=True, title='Branch format'),
2176
def run(self, url='.', format=None):
2177
from bzrlib.upgrade import upgrade
2179
format = bzrdir.format_registry.make_bzrdir('default')
2180
upgrade(url, format)
2183
class cmd_whoami(Command):
2184
"""Show or set bzr user id.
2188
bzr whoami 'Frank Chu <fchu@example.com>'
2190
takes_options = [ Option('email',
2191
help='display email address only'),
2193
help='set identity for the current branch instead of '
2196
takes_args = ['name?']
2197
encoding_type = 'replace'
2200
def run(self, email=False, branch=False, name=None):
2202
# use branch if we're inside one; otherwise global config
2204
c = Branch.open_containing('.')[0].get_config()
2205
except errors.NotBranchError:
2206
c = config.GlobalConfig()
2208
self.outf.write(c.user_email() + '\n')
2210
self.outf.write(c.username() + '\n')
2213
# display a warning if an email address isn't included in the given name.
2215
config.extract_email_address(name)
2216
except errors.NoEmailInUsername, e:
2217
warning('"%s" does not seem to contain an email address. '
2218
'This is allowed, but not recommended.', name)
2220
# use global config unless --branch given
2222
c = Branch.open_containing('.')[0].get_config()
2224
c = config.GlobalConfig()
2225
c.set_user_option('email', name)
2228
class cmd_nick(Command):
2229
"""Print or set the branch nickname.
2231
If unset, the tree root directory name is used as the nickname
2232
To print the current nickname, execute with no argument.
2234
takes_args = ['nickname?']
2235
def run(self, nickname=None):
2236
branch = Branch.open_containing(u'.')[0]
2237
if nickname is None:
2238
self.printme(branch)
2240
branch.nick = nickname
2243
def printme(self, branch):
2247
class cmd_selftest(Command):
2248
"""Run internal test suite.
2250
This creates temporary test directories in the working directory, but not
2251
existing data is affected. These directories are deleted if the tests
2252
pass, or left behind to help in debugging if they fail and --keep-output
2255
If arguments are given, they are regular expressions that say which tests
2256
should run. Tests matching any expression are run, and other tests are
2259
Alternatively if --first is given, matching tests are run first and then
2260
all other tests are run. This is useful if you have been working in a
2261
particular area, but want to make sure nothing else was broken.
2263
If the global option '--no-plugins' is given, plugins are not loaded
2264
before running the selftests. This has two effects: features provided or
2265
modified by plugins will not be tested, and tests provided by plugins will
2270
run only tests relating to 'ignore'
2271
bzr --no-plugins selftest -v
2272
disable plugins and list tests as they're run
2274
For each test, that needs actual disk access, bzr create their own
2275
subdirectory in the temporary testing directory (testXXXX.tmp).
2276
By default the name of such subdirectory is based on the name of the test.
2277
If option '--numbered-dirs' is given, bzr will use sequent numbers
2278
of running tests to create such subdirectories. This is default behavior
2279
on Windows because of path length limitation.
2281
# TODO: --list should give a list of all available tests
2283
# NB: this is used from the class without creating an instance, which is
2284
# why it does not have a self parameter.
2285
def get_transport_type(typestring):
2286
"""Parse and return a transport specifier."""
2287
if typestring == "sftp":
2288
from bzrlib.transport.sftp import SFTPAbsoluteServer
2289
return SFTPAbsoluteServer
2290
if typestring == "memory":
2291
from bzrlib.transport.memory import MemoryServer
2293
if typestring == "fakenfs":
2294
from bzrlib.transport.fakenfs import FakeNFSServer
2295
return FakeNFSServer
2296
msg = "No known transport type %s. Supported types are: sftp\n" %\
2298
raise errors.BzrCommandError(msg)
2301
takes_args = ['testspecs*']
2302
takes_options = ['verbose',
2303
Option('one', help='stop when one test fails'),
2304
Option('keep-output',
2305
help='keep output directories when tests fail'),
2307
help='Use a different transport by default '
2308
'throughout the test suite.',
2309
type=get_transport_type),
2310
Option('benchmark', help='run the bzr bencharks.'),
2311
Option('lsprof-timed',
2312
help='generate lsprof output for benchmarked'
2313
' sections of code.'),
2314
Option('cache-dir', type=str,
2315
help='a directory to cache intermediate'
2316
' benchmark steps'),
2317
Option('clean-output',
2318
help='clean temporary tests directories'
2319
' without running tests'),
2321
help='run all tests, but run specified tests first',
2323
Option('numbered-dirs',
2324
help='use numbered dirs for TestCaseInTempDir'),
2326
encoding_type = 'replace'
2328
def run(self, testspecs_list=None, verbose=None, one=False,
2329
keep_output=False, transport=None, benchmark=None,
2330
lsprof_timed=None, cache_dir=None, clean_output=False,
2331
first=False, numbered_dirs=None):
2333
from bzrlib.tests import selftest
2334
import bzrlib.benchmarks as benchmarks
2335
from bzrlib.benchmarks import tree_creator
2338
from bzrlib.tests import clean_selftest_output
2339
clean_selftest_output()
2342
if numbered_dirs is None and sys.platform == 'win32':
2343
numbered_dirs = True
2345
if cache_dir is not None:
2346
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2347
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2348
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2350
if testspecs_list is not None:
2351
pattern = '|'.join(testspecs_list)
2355
test_suite_factory = benchmarks.test_suite
2358
# TODO: should possibly lock the history file...
2359
benchfile = open(".perf_history", "at", buffering=1)
2361
test_suite_factory = None
2366
result = selftest(verbose=verbose,
2368
stop_on_failure=one,
2369
keep_output=keep_output,
2370
transport=transport,
2371
test_suite_factory=test_suite_factory,
2372
lsprof_timed=lsprof_timed,
2373
bench_history=benchfile,
2374
matching_tests_first=first,
2375
numbered_dirs=numbered_dirs,
2378
if benchfile is not None:
2381
info('tests passed')
2383
info('tests failed')
2384
return int(not result)
2387
class cmd_version(Command):
2388
"""Show version of bzr."""
2392
from bzrlib.version import show_version
2396
class cmd_rocks(Command):
2397
"""Statement of optimism."""
2403
print "It sure does!"
2406
class cmd_find_merge_base(Command):
2407
"""Find and print a base revision for merging two branches."""
2408
# TODO: Options to specify revisions on either side, as if
2409
# merging only part of the history.
2410
takes_args = ['branch', 'other']
2414
def run(self, branch, other):
2415
from bzrlib.revision import MultipleRevisionSources
2417
branch1 = Branch.open_containing(branch)[0]
2418
branch2 = Branch.open_containing(other)[0]
2420
last1 = branch1.last_revision()
2421
last2 = branch2.last_revision()
2423
source = MultipleRevisionSources(branch1.repository,
2426
base_rev_id = common_ancestor(last1, last2, source)
2428
print 'merge base is revision %s' % base_rev_id
2431
class cmd_merge(Command):
2432
"""Perform a three-way merge.
2434
The branch is the branch you will merge from. By default, it will merge
2435
the latest revision. If you specify a revision, that revision will be
2436
merged. If you specify two revisions, the first will be used as a BASE,
2437
and the second one as OTHER. Revision numbers are always relative to the
2440
By default, bzr will try to merge in all new work from the other
2441
branch, automatically determining an appropriate base. If this
2442
fails, you may need to give an explicit base.
2444
Merge will do its best to combine the changes in two branches, but there
2445
are some kinds of problems only a human can fix. When it encounters those,
2446
it will mark a conflict. A conflict means that you need to fix something,
2447
before you should commit.
2449
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2451
If there is no default branch set, the first merge will set it. After
2452
that, you can omit the branch to use the default. To change the
2453
default, use --remember. The value will only be saved if the remote
2454
location can be accessed.
2456
The results of the merge are placed into the destination working
2457
directory, where they can be reviewed (with bzr diff), tested, and then
2458
committed to record the result of the merge.
2462
To merge the latest revision from bzr.dev
2463
bzr merge ../bzr.dev
2465
To merge changes up to and including revision 82 from bzr.dev
2466
bzr merge -r 82 ../bzr.dev
2468
To merge the changes introduced by 82, without previous changes:
2469
bzr merge -r 81..82 ../bzr.dev
2471
merge refuses to run if there are any uncommitted changes, unless
2474
The following merge types are available:
2476
takes_args = ['branch?']
2477
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2478
Option('show-base', help="Show base revision text in "
2480
Option('uncommitted', help='Apply uncommitted changes'
2481
' from a working copy, instead of branch changes'),
2482
Option('pull', help='If the destination is already'
2483
' completely merged into the source, pull from the'
2484
' source rather than merging. When this happens,'
2485
' you do not need to commit the result.'),
2487
help='Branch to merge into, '
2488
'rather than the one containing the working directory',
2494
def run(self, branch=None, revision=None, force=False, merge_type=None,
2495
show_base=False, reprocess=False, remember=False,
2496
uncommitted=False, pull=False,
2499
from bzrlib.tag import _merge_tags_if_possible
2500
if merge_type is None:
2501
merge_type = _mod_merge.Merge3Merger
2503
if directory is None: directory = u'.'
2504
# XXX: jam 20070225 WorkingTree should be locked before you extract its
2505
# inventory. Because merge is a mutating operation, it really
2506
# should be a lock_write() for the whole cmd_merge operation.
2507
# However, cmd_merge open's its own tree in _merge_helper, which
2508
# means if we lock here, the later lock_write() will always block.
2509
# Either the merge helper code should be updated to take a tree,
2510
# (What about tree.merge_from_branch?)
2511
tree = WorkingTree.open_containing(directory)[0]
2512
change_reporter = delta._ChangeReporter(
2513
unversioned_filter=tree.is_ignored)
2515
if branch is not None:
2517
mergeable = bundle.read_mergeable_from_url(
2519
except errors.NotABundle:
2521
pass # Continue on considering this url a Branch
2523
if revision is not None:
2524
raise errors.BzrCommandError(
2525
'Cannot use -r with merge directives or bundles')
2526
other_rev_id = mergeable.get_target_revision(
2527
tree.branch.repository)
2528
revision = [RevisionSpec.from_string(
2529
'revid:' + other_rev_id)]
2531
if revision is None \
2532
or len(revision) < 1 or revision[0].needs_branch():
2533
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2535
if revision is None or len(revision) < 1:
2538
other = [branch, None]
2541
other = [branch, -1]
2542
other_branch, path = Branch.open_containing(branch)
2545
raise errors.BzrCommandError('Cannot use --uncommitted and'
2546
' --revision at the same time.')
2547
branch = revision[0].get_branch() or branch
2548
if len(revision) == 1:
2550
if other_rev_id is not None:
2555
other_branch, path = Branch.open_containing(branch)
2556
revno = revision[0].in_history(other_branch).revno
2557
other = [branch, revno]
2559
assert len(revision) == 2
2560
if None in revision:
2561
raise errors.BzrCommandError(
2562
"Merge doesn't permit empty revision specifier.")
2563
base_branch, path = Branch.open_containing(branch)
2564
branch1 = revision[1].get_branch() or branch
2565
other_branch, path1 = Branch.open_containing(branch1)
2566
if revision[0].get_branch() is not None:
2567
# then path was obtained from it, and is None.
2570
base = [branch, revision[0].in_history(base_branch).revno]
2571
other = [branch1, revision[1].in_history(other_branch).revno]
2573
if tree.branch.get_parent() is None or remember:
2574
tree.branch.set_parent(other_branch.base)
2576
# pull tags now... it's a bit inconsistent to do it ahead of copying
2577
# the history but that's done inside the merge code
2578
if other_branch is not None:
2579
_merge_tags_if_possible(other_branch, tree.branch)
2582
interesting_files = [path]
2584
interesting_files = None
2585
pb = ui.ui_factory.nested_progress_bar()
2588
conflict_count = _merge_helper(
2589
other, base, other_rev_id=other_rev_id,
2590
check_clean=(not force),
2591
merge_type=merge_type,
2592
reprocess=reprocess,
2593
show_base=show_base,
2596
pb=pb, file_list=interesting_files,
2597
change_reporter=change_reporter)
2600
if conflict_count != 0:
2604
except errors.AmbiguousBase, e:
2605
m = ("sorry, bzr can't determine the right merge base yet\n"
2606
"candidates are:\n "
2607
+ "\n ".join(e.bases)
2609
"please specify an explicit base with -r,\n"
2610
"and (if you want) report this to the bzr developers\n")
2613
# TODO: move up to common parent; this isn't merge-specific anymore.
2614
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2615
"""Use tree.branch's parent if none was supplied.
2617
Report if the remembered location was used.
2619
if supplied_location is not None:
2620
return supplied_location
2621
stored_location = tree.branch.get_parent()
2622
mutter("%s", stored_location)
2623
if stored_location is None:
2624
raise errors.BzrCommandError("No location specified or remembered")
2625
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2626
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2627
return stored_location
2630
class cmd_remerge(Command):
2633
Use this if you want to try a different merge technique while resolving
2634
conflicts. Some merge techniques are better than others, and remerge
2635
lets you try different ones on different files.
2637
The options for remerge have the same meaning and defaults as the ones for
2638
merge. The difference is that remerge can (only) be run when there is a
2639
pending merge, and it lets you specify particular files.
2642
$ bzr remerge --show-base
2643
Re-do the merge of all conflicted files, and show the base text in
2644
conflict regions, in addition to the usual THIS and OTHER texts.
2646
$ bzr remerge --merge-type weave --reprocess foobar
2647
Re-do the merge of "foobar", using the weave merge algorithm, with
2648
additional processing to reduce the size of conflict regions.
2650
The following merge types are available:"""
2651
takes_args = ['file*']
2652
takes_options = ['merge-type', 'reprocess',
2653
Option('show-base', help="Show base revision text in "
2656
def run(self, file_list=None, merge_type=None, show_base=False,
2658
if merge_type is None:
2659
merge_type = _mod_merge.Merge3Merger
2660
tree, file_list = tree_files(file_list)
2663
parents = tree.get_parent_ids()
2664
if len(parents) != 2:
2665
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2666
" merges. Not cherrypicking or"
2668
repository = tree.branch.repository
2669
base_revision = common_ancestor(parents[0],
2670
parents[1], repository)
2671
base_tree = repository.revision_tree(base_revision)
2672
other_tree = repository.revision_tree(parents[1])
2673
interesting_ids = None
2675
conflicts = tree.conflicts()
2676
if file_list is not None:
2677
interesting_ids = set()
2678
for filename in file_list:
2679
file_id = tree.path2id(filename)
2681
raise errors.NotVersionedError(filename)
2682
interesting_ids.add(file_id)
2683
if tree.kind(file_id) != "directory":
2686
for name, ie in tree.inventory.iter_entries(file_id):
2687
interesting_ids.add(ie.file_id)
2688
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2690
# Remerge only supports resolving contents conflicts
2691
allowed_conflicts = ('text conflict', 'contents conflict')
2692
restore_files = [c.path for c in conflicts
2693
if c.typestring in allowed_conflicts]
2694
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2695
tree.set_conflicts(ConflictList(new_conflicts))
2696
if file_list is not None:
2697
restore_files = file_list
2698
for filename in restore_files:
2700
restore(tree.abspath(filename))
2701
except errors.NotConflicted:
2703
conflicts = _mod_merge.merge_inner(
2704
tree.branch, other_tree, base_tree,
2706
interesting_ids=interesting_ids,
2707
other_rev_id=parents[1],
2708
merge_type=merge_type,
2709
show_base=show_base,
2710
reprocess=reprocess)
2719
class cmd_revert(Command):
2720
"""Revert files to a previous revision.
2722
Giving a list of files will revert only those files. Otherwise, all files
2723
will be reverted. If the revision is not specified with '--revision', the
2724
last committed revision is used.
2726
To remove only some changes, without reverting to a prior version, use
2727
merge instead. For example, "merge . --r-2..-3" will remove the changes
2728
introduced by -2, without affecting the changes introduced by -1. Or
2729
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2731
By default, any files that have been manually changed will be backed up
2732
first. (Files changed only by merge are not backed up.) Backup files have
2733
'.~#~' appended to their name, where # is a number.
2735
When you provide files, you can use their current pathname or the pathname
2736
from the target revision. So you can use revert to "undelete" a file by
2737
name. If you name a directory, all the contents of that directory will be
2740
takes_options = ['revision', 'no-backup']
2741
takes_args = ['file*']
2742
aliases = ['merge-revert']
2744
def run(self, revision=None, no_backup=False, file_list=None):
2745
if file_list is not None:
2746
if len(file_list) == 0:
2747
raise errors.BzrCommandError("No files specified")
2751
tree, file_list = tree_files(file_list)
2752
if revision is None:
2753
# FIXME should be tree.last_revision
2754
rev_id = tree.last_revision()
2755
elif len(revision) != 1:
2756
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2758
rev_id = revision[0].in_history(tree.branch).rev_id
2759
pb = ui.ui_factory.nested_progress_bar()
2761
tree.revert(file_list,
2762
tree.branch.repository.revision_tree(rev_id),
2763
not no_backup, pb, report_changes=True)
2768
class cmd_assert_fail(Command):
2769
"""Test reporting of assertion failures"""
2770
# intended just for use in testing
2775
raise AssertionError("always fails")
2778
class cmd_help(Command):
2779
"""Show help on a command or other topic.
2781
For a list of all available commands, say 'bzr help commands'.
2783
takes_options = [Option('long', 'show help on all commands')]
2784
takes_args = ['topic?']
2785
aliases = ['?', '--help', '-?', '-h']
2788
def run(self, topic=None, long=False):
2790
if topic is None and long:
2792
bzrlib.help.help(topic)
2795
class cmd_shell_complete(Command):
2796
"""Show appropriate completions for context.
2798
For a list of all available commands, say 'bzr shell-complete'.
2800
takes_args = ['context?']
2805
def run(self, context=None):
2806
import shellcomplete
2807
shellcomplete.shellcomplete(context)
2810
class cmd_fetch(Command):
2811
"""Copy in history from another branch but don't merge it.
2813
This is an internal method used for pull and merge.
2816
takes_args = ['from_branch', 'to_branch']
2817
def run(self, from_branch, to_branch):
2818
from bzrlib.fetch import Fetcher
2819
from_b = Branch.open(from_branch)
2820
to_b = Branch.open(to_branch)
2821
Fetcher(to_b, from_b)
2824
class cmd_missing(Command):
2825
"""Show unmerged/unpulled revisions between two branches.
2827
OTHER_BRANCH may be local or remote.
2829
takes_args = ['other_branch?']
2830
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2832
'Display changes in the local branch only'),
2833
Option('theirs-only',
2834
'Display changes in the remote branch only'),
2839
encoding_type = 'replace'
2842
def run(self, other_branch=None, reverse=False, mine_only=False,
2843
theirs_only=False, log_format=None, long=False, short=False, line=False,
2844
show_ids=False, verbose=False):
2845
from bzrlib.missing import find_unmerged, iter_log_data
2846
from bzrlib.log import log_formatter
2847
local_branch = Branch.open_containing(u".")[0]
2848
parent = local_branch.get_parent()
2849
if other_branch is None:
2850
other_branch = parent
2851
if other_branch is None:
2852
raise errors.BzrCommandError("No peer location known or specified.")
2853
display_url = urlutils.unescape_for_display(parent,
2855
print "Using last location: " + display_url
2857
remote_branch = Branch.open(other_branch)
2858
if remote_branch.base == local_branch.base:
2859
remote_branch = local_branch
2860
local_branch.lock_read()
2862
remote_branch.lock_read()
2864
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2865
if (log_format is None):
2866
log_format = log.log_formatter_registry.get_default(
2868
lf = log_format(to_file=self.outf,
2870
show_timezone='original')
2871
if reverse is False:
2872
local_extra.reverse()
2873
remote_extra.reverse()
2874
if local_extra and not theirs_only:
2875
print "You have %d extra revision(s):" % len(local_extra)
2876
for data in iter_log_data(local_extra, local_branch.repository,
2879
printed_local = True
2881
printed_local = False
2882
if remote_extra and not mine_only:
2883
if printed_local is True:
2885
print "You are missing %d revision(s):" % len(remote_extra)
2886
for data in iter_log_data(remote_extra, remote_branch.repository,
2889
if not remote_extra and not local_extra:
2891
print "Branches are up to date."
2895
remote_branch.unlock()
2897
local_branch.unlock()
2898
if not status_code and parent is None and other_branch is not None:
2899
local_branch.lock_write()
2901
# handle race conditions - a parent might be set while we run.
2902
if local_branch.get_parent() is None:
2903
local_branch.set_parent(remote_branch.base)
2905
local_branch.unlock()
2909
class cmd_plugins(Command):
2914
import bzrlib.plugin
2915
from inspect import getdoc
2916
for name, plugin in bzrlib.plugin.all_plugins().items():
2917
if getattr(plugin, '__path__', None) is not None:
2918
print plugin.__path__[0]
2919
elif getattr(plugin, '__file__', None) is not None:
2920
print plugin.__file__
2926
print '\t', d.split('\n')[0]
2929
class cmd_testament(Command):
2930
"""Show testament (signing-form) of a revision."""
2931
takes_options = ['revision',
2932
Option('long', help='Produce long-format testament'),
2933
Option('strict', help='Produce a strict-format'
2935
takes_args = ['branch?']
2937
def run(self, branch=u'.', revision=None, long=False, strict=False):
2938
from bzrlib.testament import Testament, StrictTestament
2940
testament_class = StrictTestament
2942
testament_class = Testament
2943
b = WorkingTree.open_containing(branch)[0].branch
2946
if revision is None:
2947
rev_id = b.last_revision()
2949
rev_id = revision[0].in_history(b).rev_id
2950
t = testament_class.from_revision(b.repository, rev_id)
2952
sys.stdout.writelines(t.as_text_lines())
2954
sys.stdout.write(t.as_short_text())
2959
class cmd_annotate(Command):
2960
"""Show the origin of each line in a file.
2962
This prints out the given file with an annotation on the left side
2963
indicating which revision, author and date introduced the change.
2965
If the origin is the same for a run of consecutive lines, it is
2966
shown only at the top, unless the --all option is given.
2968
# TODO: annotate directories; showing when each file was last changed
2969
# TODO: if the working copy is modified, show annotations on that
2970
# with new uncommitted lines marked
2971
aliases = ['ann', 'blame', 'praise']
2972
takes_args = ['filename']
2973
takes_options = [Option('all', help='show annotations on all lines'),
2974
Option('long', help='show date in annotations'),
2980
def run(self, filename, all=False, long=False, revision=None,
2982
from bzrlib.annotate import annotate_file
2983
tree, relpath = WorkingTree.open_containing(filename)
2984
branch = tree.branch
2987
if revision is None:
2988
revision_id = branch.last_revision()
2989
elif len(revision) != 1:
2990
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2992
revision_id = revision[0].in_history(branch).rev_id
2993
file_id = tree.path2id(relpath)
2994
tree = branch.repository.revision_tree(revision_id)
2995
file_version = tree.inventory[file_id].revision
2996
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
3002
class cmd_re_sign(Command):
3003
"""Create a digital signature for an existing revision."""
3004
# TODO be able to replace existing ones.
3006
hidden = True # is this right ?
3007
takes_args = ['revision_id*']
3008
takes_options = ['revision']
3010
def run(self, revision_id_list=None, revision=None):
3011
import bzrlib.gpg as gpg
3012
if revision_id_list is not None and revision is not None:
3013
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3014
if revision_id_list is None and revision is None:
3015
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3016
b = WorkingTree.open_containing(u'.')[0].branch
3017
gpg_strategy = gpg.GPGStrategy(b.get_config())
3018
if revision_id_list is not None:
3019
for revision_id in revision_id_list:
3020
b.repository.sign_revision(revision_id, gpg_strategy)
3021
elif revision is not None:
3022
if len(revision) == 1:
3023
revno, rev_id = revision[0].in_history(b)
3024
b.repository.sign_revision(rev_id, gpg_strategy)
3025
elif len(revision) == 2:
3026
# are they both on rh- if so we can walk between them
3027
# might be nice to have a range helper for arbitrary
3028
# revision paths. hmm.
3029
from_revno, from_revid = revision[0].in_history(b)
3030
to_revno, to_revid = revision[1].in_history(b)
3031
if to_revid is None:
3032
to_revno = b.revno()
3033
if from_revno is None or to_revno is None:
3034
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3035
for revno in range(from_revno, to_revno + 1):
3036
b.repository.sign_revision(b.get_rev_id(revno),
3039
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3042
class cmd_bind(Command):
3043
"""Convert the current branch into a checkout of the supplied branch.
3045
Once converted into a checkout, commits must succeed on the master branch
3046
before they will be applied to the local branch.
3048
See "help checkouts" for more information on checkouts.
3051
takes_args = ['location?']
3054
def run(self, location=None):
3055
b, relpath = Branch.open_containing(u'.')
3056
if location is None:
3058
location = b.get_old_bound_location()
3059
except errors.UpgradeRequired:
3060
raise errors.BzrCommandError('No location supplied. '
3061
'This format does not remember old locations.')
3063
if location is None:
3064
raise errors.BzrCommandError('No location supplied and no '
3065
'previous location known')
3066
b_other = Branch.open(location)
3069
except errors.DivergedBranches:
3070
raise errors.BzrCommandError('These branches have diverged.'
3071
' Try merging, and then bind again.')
3074
class cmd_unbind(Command):
3075
"""Convert the current checkout into a regular branch.
3077
After unbinding, the local branch is considered independent and subsequent
3078
commits will be local only.
3080
See "help checkouts" for more information on checkouts.
3087
b, relpath = Branch.open_containing(u'.')
3089
raise errors.BzrCommandError('Local branch is not bound')
3092
class cmd_uncommit(Command):
3093
"""Remove the last committed revision.
3095
--verbose will print out what is being removed.
3096
--dry-run will go through all the motions, but not actually
3099
In the future, uncommit will create a revision bundle, which can then
3103
# TODO: jam 20060108 Add an option to allow uncommit to remove
3104
# unreferenced information in 'branch-as-repository' branches.
3105
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3106
# information in shared branches as well.
3107
takes_options = ['verbose', 'revision',
3108
Option('dry-run', help='Don\'t actually make changes'),
3109
Option('force', help='Say yes to all questions.')]
3110
takes_args = ['location?']
3113
def run(self, location=None,
3114
dry_run=False, verbose=False,
3115
revision=None, force=False):
3116
from bzrlib.log import log_formatter, show_log
3118
from bzrlib.uncommit import uncommit
3120
if location is None:
3122
control, relpath = bzrdir.BzrDir.open_containing(location)
3124
tree = control.open_workingtree()
3126
except (errors.NoWorkingTree, errors.NotLocalUrl):
3128
b = control.open_branch()
3131
if revision is None:
3134
# 'bzr uncommit -r 10' actually means uncommit
3135
# so that the final tree is at revno 10.
3136
# but bzrlib.uncommit.uncommit() actually uncommits
3137
# the revisions that are supplied.
3138
# So we need to offset it by one
3139
revno = revision[0].in_history(b).revno+1
3141
if revno <= b.revno():
3142
rev_id = b.get_rev_id(revno)
3144
self.outf.write('No revisions to uncommit.\n')
3147
lf = log_formatter('short',
3149
show_timezone='original')
3154
direction='forward',
3155
start_revision=revno,
3156
end_revision=b.revno())
3159
print 'Dry-run, pretending to remove the above revisions.'
3161
val = raw_input('Press <enter> to continue')
3163
print 'The above revision(s) will be removed.'
3165
val = raw_input('Are you sure [y/N]? ')
3166
if val.lower() not in ('y', 'yes'):
3170
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3174
class cmd_break_lock(Command):
3175
"""Break a dead lock on a repository, branch or working directory.
3177
CAUTION: Locks should only be broken when you are sure that the process
3178
holding the lock has been stopped.
3180
You can get information on what locks are open via the 'bzr info' command.
3185
takes_args = ['location?']
3187
def run(self, location=None, show=False):
3188
if location is None:
3190
control, relpath = bzrdir.BzrDir.open_containing(location)
3192
control.break_lock()
3193
except NotImplementedError:
3197
class cmd_wait_until_signalled(Command):
3198
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3200
This just prints a line to signal when it is ready, then blocks on stdin.
3206
sys.stdout.write("running\n")
3208
sys.stdin.readline()
3211
class cmd_serve(Command):
3212
"""Run the bzr server."""
3214
aliases = ['server']
3218
help='serve on stdin/out for use from inetd or sshd'),
3220
help='listen for connections on nominated port of the form '
3221
'[hostname:]portnumber. Passing 0 as the port number will '
3222
'result in a dynamically allocated port. Default port is '
3226
help='serve contents of directory',
3228
Option('allow-writes',
3229
help='By default the server is a readonly server. Supplying '
3230
'--allow-writes enables write access to the contents of '
3231
'the served directory and below. '
3235
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3236
from bzrlib.transport import smart
3237
from bzrlib.transport import get_transport
3238
if directory is None:
3239
directory = os.getcwd()
3240
url = urlutils.local_path_to_url(directory)
3241
if not allow_writes:
3242
url = 'readonly+' + url
3243
t = get_transport(url)
3245
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
3248
port = smart.BZR_DEFAULT_PORT
3252
host, port = port.split(':')
3256
server = smart.SmartTCPServer(t, host=host, port=port)
3257
print 'listening on port: ', server.port
3261
class cmd_join(Command):
3262
"""Combine a subtree into its containing tree.
3264
This is marked as a merge of the subtree into the containing tree, and all
3265
history is preserved.
3268
takes_args = ['tree']
3269
takes_options = [Option('reference', 'join by reference')]
3271
def run(self, tree, reference=False):
3272
sub_tree = WorkingTree.open(tree)
3273
parent_dir = osutils.dirname(sub_tree.basedir)
3274
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3275
repo = containing_tree.branch.repository
3276
if not repo.supports_rich_root():
3277
raise errors.BzrCommandError(
3278
"Can't join trees because %s doesn't support rich root data.\n"
3279
"You can use bzr upgrade on the repository."
3283
containing_tree.add_reference(sub_tree)
3284
except errors.BadReferenceTarget, e:
3285
# XXX: Would be better to just raise a nicely printable
3286
# exception from the real origin. Also below. mbp 20070306
3287
raise errors.BzrCommandError("Cannot join %s. %s" %
3291
containing_tree.subsume(sub_tree)
3292
except errors.BadSubsumeSource, e:
3293
raise errors.BzrCommandError("Cannot join %s. %s" %
3297
class cmd_split(Command):
3298
"""Split a tree into two trees.
3301
takes_args = ['tree']
3303
def run(self, tree):
3304
containing_tree, subdir = WorkingTree.open_containing(tree)
3305
sub_id = containing_tree.path2id(subdir)
3307
raise errors.NotVersionedError(subdir)
3309
containing_tree.extract(sub_id)
3310
except errors.RootNotRich:
3311
raise errors.UpgradeRequired(containing_tree.branch.base)
3315
class cmd_merge_directive(Command):
3316
"""Generate a merge directive for auto-merge tools.
3318
A directive requests a merge to be performed, and also provides all the
3319
information necessary to do so. This means it must either include a
3320
revision bundle, or the location of a branch containing the desired
3323
A submit branch (the location to merge into) must be supplied the first
3324
time the command is issued. After it has been supplied once, it will
3325
be remembered as the default.
3327
A public branch is optional if a revision bundle is supplied, but required
3328
if --diff or --plain is specified. It will be remembered as the default
3329
after the first use.
3332
takes_args = ['submit_branch?', 'public_branch?']
3335
RegistryOption.from_kwargs('patch-type',
3336
'The type of patch to include in the directive',
3337
title='Patch type', value_switches=True, enum_switch=False,
3338
bundle='Bazaar revision bundle (default)',
3339
diff='Normal unified diff',
3340
plain='No patch, just directive'),
3341
Option('sign', help='GPG-sign the directive'), 'revision',
3342
Option('mail-to', type=str,
3343
help='Instead of printing the directive, email to this address'),
3344
Option('message', type=str, short_name='m',
3345
help='Message to use when committing this merge')
3348
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3349
sign=False, revision=None, mail_to=None, message=None):
3350
if patch_type == 'plain':
3352
branch = Branch.open('.')
3353
stored_submit_branch = branch.get_submit_branch()
3354
if submit_branch is None:
3355
submit_branch = stored_submit_branch
3357
if stored_submit_branch is None:
3358
branch.set_submit_branch(submit_branch)
3359
if submit_branch is None:
3360
submit_branch = branch.get_parent()
3361
if submit_branch is None:
3362
raise errors.BzrCommandError('No submit branch specified or known')
3364
stored_public_branch = branch.get_public_branch()
3365
if public_branch is None:
3366
public_branch = stored_public_branch
3367
elif stored_public_branch is None:
3368
branch.set_public_branch(public_branch)
3369
if patch_type != "bundle" and public_branch is None:
3370
raise errors.BzrCommandError('No public branch specified or'
3372
if revision is not None:
3373
if len(revision) != 1:
3374
raise errors.BzrCommandError('bzr merge-directive takes '
3375
'exactly one revision identifier')
3377
revision_id = revision[0].in_history(branch).rev_id
3379
revision_id = branch.last_revision()
3380
directive = merge_directive.MergeDirective.from_objects(
3381
branch.repository, revision_id, time.time(),
3382
osutils.local_time_offset(), submit_branch,
3383
public_branch=public_branch, patch_type=patch_type,
3387
self.outf.write(directive.to_signed(branch))
3389
self.outf.writelines(directive.to_lines())
3391
message = directive.to_email(mail_to, branch, sign)
3393
server = branch.get_config().get_user_option('smtp_server')
3395
server = 'localhost'
3397
s.sendmail(message['From'], message['To'], message.as_string())
3400
class cmd_tag(Command):
3401
"""Create a tag naming a revision.
3403
Tags give human-meaningful names to revisions. Commands that take a -r
3404
(--revision) option can be given -rtag:X, where X is any previously
3407
Tags are stored in the branch. Tags are copied from one branch to another
3408
along when you branch, push, pull or merge.
3410
It is an error to give a tag name that already exists unless you pass
3411
--force, in which case the tag is moved to point to the new revision.
3414
takes_args = ['tag_name']
3417
help='Delete this tag rather than placing it.',
3420
help='Branch in which to place the tag.',
3425
help='Replace existing tags',
3430
def run(self, tag_name,
3436
branch, relpath = Branch.open_containing(directory)
3440
branch.tags.delete_tag(tag_name)
3441
self.outf.write('Deleted tag %s.\n' % tag_name)
3444
if len(revision) != 1:
3445
raise errors.BzrCommandError(
3446
"Tags can only be placed on a single revision, "
3448
revision_id = revision[0].in_history(branch).rev_id
3450
revision_id = branch.last_revision()
3451
if (not force) and branch.tags.has_tag(tag_name):
3452
raise errors.TagAlreadyExists(tag_name)
3453
branch.tags.set_tag(tag_name, revision_id)
3454
self.outf.write('Created tag %s.\n' % tag_name)
3459
class cmd_tags(Command):
3462
This tag shows a table of tag names and the revisions they reference.
3467
help='Branch whose tags should be displayed',
3477
branch, relpath = Branch.open_containing(directory)
3478
for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
3479
self.outf.write('%-20s %s\n' % (tag_name, target))
3482
# command-line interpretation helper for merge-related commands
3483
def _merge_helper(other_revision, base_revision,
3484
check_clean=True, ignore_zero=False,
3485
this_dir=None, backup_files=False,
3487
file_list=None, show_base=False, reprocess=False,
3490
change_reporter=None,
3492
"""Merge changes into a tree.
3495
list(path, revno) Base for three-way merge.
3496
If [None, None] then a base will be automatically determined.
3498
list(path, revno) Other revision for three-way merge.
3500
Directory to merge changes into; '.' by default.
3502
If true, this_dir must have no uncommitted changes before the
3504
ignore_zero - If true, suppress the "zero conflicts" message when
3505
there are no conflicts; should be set when doing something we expect
3506
to complete perfectly.
3507
file_list - If supplied, merge only changes to selected files.
3509
All available ancestors of other_revision and base_revision are
3510
automatically pulled into the branch.
3512
The revno may be -1 to indicate the last revision on the branch, which is
3515
This function is intended for use from the command line; programmatic
3516
clients might prefer to call merge.merge_inner(), which has less magic
3519
# Loading it late, so that we don't always have to import bzrlib.merge
3520
if merge_type is None:
3521
merge_type = _mod_merge.Merge3Merger
3522
if this_dir is None:
3524
this_tree = WorkingTree.open_containing(this_dir)[0]
3525
if show_base and not merge_type is _mod_merge.Merge3Merger:
3526
raise errors.BzrCommandError("Show-base is not supported for this merge"
3527
" type. %s" % merge_type)
3528
if reprocess and not merge_type.supports_reprocess:
3529
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3530
" type %s." % merge_type)
3531
if reprocess and show_base:
3532
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3533
# TODO: jam 20070226 We should really lock these trees earlier. However, we
3534
# only want to take out a lock_tree_write() if we don't have to pull
3535
# any ancestry. But merge might fetch ancestry in the middle, in
3536
# which case we would need a lock_write().
3537
# Because we cannot upgrade locks, for now we live with the fact that
3538
# the tree will be locked multiple times during a merge. (Maybe
3539
# read-only some of the time, but it means things will get read
3542
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3543
pb=pb, change_reporter=change_reporter)
3544
merger.pp = ProgressPhase("Merge phase", 5, pb)
3545
merger.pp.next_phase()
3546
merger.check_basis(check_clean)
3547
if other_rev_id is not None:
3548
merger.set_other_revision(other_rev_id, this_tree.branch)
3550
merger.set_other(other_revision)
3551
merger.pp.next_phase()
3552
merger.set_base(base_revision)
3553
if merger.base_rev_id == merger.other_rev_id:
3554
note('Nothing to do.')
3556
if file_list is None:
3557
if pull and merger.base_rev_id == merger.this_rev_id:
3558
# FIXME: deduplicate with pull
3559
result = merger.this_tree.pull(merger.this_branch,
3560
False, merger.other_rev_id)
3561
if result.old_revid == result.new_revid:
3562
note('No revisions to pull.')
3564
note('Now on revision %d.' % result.new_revno)
3566
merger.backup_files = backup_files
3567
merger.merge_type = merge_type
3568
merger.set_interesting_files(file_list)
3569
merger.show_base = show_base
3570
merger.reprocess = reprocess
3571
conflicts = merger.do_merge()
3572
if file_list is None:
3573
merger.set_pending()
3580
merge = _merge_helper
3583
# these get imported and then picked up by the scan for cmd_*
3584
# TODO: Some more consistent way to split command definitions across files;
3585
# we do need to load at least some information about them to know of
3586
# aliases. ideally we would avoid loading the implementation until the
3587
# details were needed.
3588
from bzrlib.cmd_version_info import cmd_version_info
3589
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3590
from bzrlib.bundle.commands import cmd_bundle_revisions
3591
from bzrlib.sign_my_commits import cmd_sign_my_commits
3592
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3593
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
