1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""builtin bzr commands"""
26
from bzrlib.branch import Branch, BranchReferenceFormat
27
from bzrlib import (bundle, branch, bzrdir, errors, osutils, ui, config,
29
from bzrlib.bundle import read_bundle_from_url
30
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
31
from bzrlib.commands import Command, display_command
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
NotBranchError, DivergedBranches, NotConflicted,
34
NoSuchFile, NoWorkingTree, FileInWrongBranch,
35
NotVersionedError, NotABundle)
36
from bzrlib.merge import Merge3Merger
37
from bzrlib.option import Option
38
from bzrlib.progress import DummyProgress, ProgressPhase
39
from bzrlib.revision import common_ancestor
40
from bzrlib.revisionspec import RevisionSpec
41
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
42
from bzrlib.transport.local import LocalTransport
43
import bzrlib.urlutils as urlutils
44
from bzrlib.workingtree import WorkingTree
47
def tree_files(file_list, default_branch=u'.'):
49
return internal_tree_files(file_list, default_branch)
50
except FileInWrongBranch, e:
51
raise BzrCommandError("%s is not in the same branch as %s" %
52
(e.path, file_list[0]))
55
# XXX: Bad function name; should possibly also be a class method of
56
# WorkingTree rather than a function.
57
def internal_tree_files(file_list, default_branch=u'.'):
58
"""Convert command-line paths to a WorkingTree and relative paths.
60
This is typically used for command-line processors that take one or
61
more filenames, and infer the workingtree that contains them.
63
The filenames given are not required to exist.
65
:param file_list: Filenames to convert.
67
:param default_branch: Fallback tree path to use if file_list is empty or None.
69
:return: workingtree, [relative_paths]
71
if file_list is None or len(file_list) == 0:
72
return WorkingTree.open_containing(default_branch)[0], file_list
73
tree = WorkingTree.open_containing(file_list[0])[0]
75
for filename in file_list:
77
new_list.append(tree.relpath(filename))
78
except errors.PathNotChild:
79
raise FileInWrongBranch(tree.branch, filename)
83
def get_format_type(typestring):
84
"""Parse and return a format specifier."""
85
if typestring == "weave":
86
return bzrdir.BzrDirFormat6()
87
if typestring == "default":
88
return bzrdir.BzrDirMetaFormat1()
89
if typestring == "metaweave":
90
format = bzrdir.BzrDirMetaFormat1()
91
format.repository_format = repository.RepositoryFormat7()
93
if typestring == "knit":
94
format = bzrdir.BzrDirMetaFormat1()
95
format.repository_format = repository.RepositoryFormatKnit1()
97
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
98
"metaweave and weave" % typestring
99
raise BzrCommandError(msg)
102
# TODO: Make sure no commands unconditionally use the working directory as a
103
# branch. If a filename argument is used, the first of them should be used to
104
# specify the branch. (Perhaps this can be factored out into some kind of
105
# Argument class, representing a file in a branch, where the first occurrence
108
class cmd_status(Command):
109
"""Display status summary.
111
This reports on versioned and unknown files, reporting them
112
grouped by state. Possible states are:
115
Versioned in the working copy but not in the previous revision.
118
Versioned in the previous revision but removed or deleted
122
Path of this file changed from the previous revision;
123
the text may also have changed. This includes files whose
124
parent directory was renamed.
127
Text has changed since the previous revision.
130
Not versioned and not matching an ignore pattern.
132
To see ignored files use 'bzr ignored'. For details in the
133
changes to file texts, use 'bzr diff'.
135
If no arguments are specified, the status of the entire working
136
directory is shown. Otherwise, only the status of the specified
137
files or directories is reported. If a directory is given, status
138
is reported for everything inside that directory.
140
If a revision argument is given, the status is calculated against
141
that revision, or between two revisions if two are provided.
144
# TODO: --no-recurse, --recurse options
146
takes_args = ['file*']
147
takes_options = ['show-ids', 'revision']
148
aliases = ['st', 'stat']
150
encoding_type = 'replace'
153
def run(self, show_ids=False, file_list=None, revision=None):
154
from bzrlib.status import show_tree_status
156
tree, file_list = tree_files(file_list)
158
show_tree_status(tree, show_ids=show_ids,
159
specific_files=file_list, revision=revision,
163
class cmd_cat_revision(Command):
164
"""Write out metadata for a revision.
166
The revision to print can either be specified by a specific
167
revision identifier, or you can use --revision.
171
takes_args = ['revision_id?']
172
takes_options = ['revision']
173
# cat-revision is more for frontends so should be exact
177
def run(self, revision_id=None, revision=None):
179
if revision_id is not None and revision is not None:
180
raise BzrCommandError('You can only supply one of revision_id or --revision')
181
if revision_id is None and revision is None:
182
raise BzrCommandError('You must supply either --revision or a revision_id')
183
b = WorkingTree.open_containing(u'.')[0].branch
185
# TODO: jam 20060112 should cat-revision always output utf-8?
186
if revision_id is not None:
187
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
188
elif revision is not None:
191
raise BzrCommandError('You cannot specify a NULL revision.')
192
revno, rev_id = rev.in_history(b)
193
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
196
class cmd_revno(Command):
197
"""Show current revision number.
199
This is equal to the number of revisions on this branch.
202
takes_args = ['location?']
205
def run(self, location=u'.'):
206
self.outf.write(str(Branch.open_containing(location)[0].revno()))
207
self.outf.write('\n')
210
class cmd_revision_info(Command):
211
"""Show revision number and revision id for a given revision identifier.
214
takes_args = ['revision_info*']
215
takes_options = ['revision']
218
def run(self, revision=None, revision_info_list=[]):
221
if revision is not None:
222
revs.extend(revision)
223
if revision_info_list is not None:
224
for rev in revision_info_list:
225
revs.append(RevisionSpec(rev))
227
raise BzrCommandError('You must supply a revision identifier')
229
b = WorkingTree.open_containing(u'.')[0].branch
232
revinfo = rev.in_history(b)
233
if revinfo.revno is None:
234
print ' %s' % revinfo.rev_id
236
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
239
class cmd_add(Command):
240
"""Add specified files or directories.
242
In non-recursive mode, all the named items are added, regardless
243
of whether they were previously ignored. A warning is given if
244
any of the named files are already versioned.
246
In recursive mode (the default), files are treated the same way
247
but the behaviour for directories is different. Directories that
248
are already versioned do not give a warning. All directories,
249
whether already versioned or not, are searched for files or
250
subdirectories that are neither versioned or ignored, and these
251
are added. This search proceeds recursively into versioned
252
directories. If no names are given '.' is assumed.
254
Therefore simply saying 'bzr add' will version all files that
255
are currently unknown.
257
Adding a file whose parent directory is not versioned will
258
implicitly add the parent, and so on up to the root. This means
259
you should never need to explicitly add a directory, they'll just
260
get added when you add a file in the directory.
262
--dry-run will show which files would be added, but not actually
265
takes_args = ['file*']
266
takes_options = ['no-recurse', 'dry-run', 'verbose']
267
encoding_type = 'replace'
269
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
272
action = bzrlib.add.AddAction(to_file=self.outf,
273
should_print=(not is_quiet()))
275
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
276
action=action, save=not dry_run)
279
for glob in sorted(ignored.keys()):
280
for path in ignored[glob]:
281
self.outf.write("ignored %s matching \"%s\"\n"
285
for glob, paths in ignored.items():
286
match_len += len(paths)
287
self.outf.write("ignored %d file(s).\n" % match_len)
288
self.outf.write("If you wish to add some of these files,"
289
" please add them by name.\n")
292
class cmd_mkdir(Command):
293
"""Create a new versioned directory.
295
This is equivalent to creating the directory and then adding it.
298
takes_args = ['dir+']
299
encoding_type = 'replace'
301
def run(self, dir_list):
304
wt, dd = WorkingTree.open_containing(d)
306
self.outf.write('added %s\n' % d)
309
class cmd_relpath(Command):
310
"""Show path of a file relative to root"""
312
takes_args = ['filename']
316
def run(self, filename):
317
# TODO: jam 20050106 Can relpath return a munged path if
318
# sys.stdout encoding cannot represent it?
319
tree, relpath = WorkingTree.open_containing(filename)
320
self.outf.write(relpath)
321
self.outf.write('\n')
324
class cmd_inventory(Command):
325
"""Show inventory of the current working copy or a revision.
327
It is possible to limit the output to a particular entry
328
type using the --kind option. For example; --kind file.
331
takes_options = ['revision', 'show-ids', 'kind']
334
def run(self, revision=None, show_ids=False, kind=None):
335
if kind and kind not in ['file', 'directory', 'symlink']:
336
raise BzrCommandError('invalid kind specified')
337
tree = WorkingTree.open_containing(u'.')[0]
339
inv = tree.read_working_inventory()
341
if len(revision) > 1:
342
raise BzrCommandError('bzr inventory --revision takes'
343
' exactly one revision identifier')
344
inv = tree.branch.repository.get_revision_inventory(
345
revision[0].in_history(tree.branch).rev_id)
347
for path, entry in inv.entries():
348
if kind and kind != entry.kind:
351
self.outf.write('%-50s %s\n' % (path, entry.file_id))
353
self.outf.write(path)
354
self.outf.write('\n')
357
class cmd_mv(Command):
358
"""Move or rename a file.
361
bzr mv OLDNAME NEWNAME
362
bzr mv SOURCE... DESTINATION
364
If the last argument is a versioned directory, all the other names
365
are moved into it. Otherwise, there must be exactly two arguments
366
and the file is changed to a new name, which must not already exist.
368
Files cannot be moved between branches.
371
takes_args = ['names*']
372
aliases = ['move', 'rename']
373
encoding_type = 'replace'
375
def run(self, names_list):
376
if len(names_list) < 2:
377
raise BzrCommandError("missing file argument")
378
tree, rel_names = tree_files(names_list)
380
if os.path.isdir(names_list[-1]):
381
# move into existing directory
382
for pair in tree.move(rel_names[:-1], rel_names[-1]):
383
self.outf.write("%s => %s\n" % pair)
385
if len(names_list) != 2:
386
raise BzrCommandError('to mv multiple files the destination '
387
'must be a versioned directory')
388
tree.rename_one(rel_names[0], rel_names[1])
389
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
392
class cmd_pull(Command):
393
"""Turn this branch into a mirror of another branch.
395
This command only works on branches that have not diverged. Branches are
396
considered diverged if the destination branch's most recent commit is one
397
that has not been merged (directly or indirectly) into the parent.
399
If branches have diverged, you can use 'bzr merge' to integrate the changes
400
from one into the other. Once one branch has merged, the other should
401
be able to pull it again.
403
If you want to forget your local changes and just update your branch to
404
match the remote one, use pull --overwrite.
406
If there is no default location set, the first pull will set it. After
407
that, you can omit the location to use the default. To change the
408
default, use --remember. The value will only be saved if the remote
409
location can be accessed.
412
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
413
takes_args = ['location?']
414
encoding_type = 'replace'
416
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
417
# FIXME: too much stuff is in the command class
419
tree_to = WorkingTree.open_containing(u'.')[0]
420
branch_to = tree_to.branch
421
except NoWorkingTree:
423
branch_to = Branch.open_containing(u'.')[0]
426
if location is not None:
428
reader = bundle.read_bundle_from_url(location)
430
pass # Continue on considering this url a Branch
432
stored_loc = branch_to.get_parent()
434
if stored_loc is None:
435
raise BzrCommandError("No pull location known or specified.")
437
display_url = urlutils.unescape_for_display(stored_loc,
439
self.outf.write("Using saved location: %s\n" % display_url)
440
location = stored_loc
443
if reader is not None:
444
install_bundle(branch_to.repository, reader)
445
branch_from = branch_to
447
branch_from = Branch.open(location)
449
if branch_to.get_parent() is None or remember:
450
branch_to.set_parent(branch_from.base)
454
if reader is not None:
455
rev_id = reader.target
456
elif len(revision) == 1:
457
rev_id = revision[0].in_history(branch_from).rev_id
459
raise BzrCommandError('bzr pull --revision takes one value.')
461
old_rh = branch_to.revision_history()
462
if tree_to is not None:
463
count = tree_to.pull(branch_from, overwrite, rev_id)
465
count = branch_to.pull(branch_from, overwrite, rev_id)
466
note('%d revision(s) pulled.' % (count,))
469
new_rh = branch_to.revision_history()
472
from bzrlib.log import show_changed_revisions
473
show_changed_revisions(branch_to, old_rh, new_rh,
477
class cmd_push(Command):
478
"""Update a mirror of this branch.
480
The target branch will not have its working tree populated because this
481
is both expensive, and is not supported on remote file systems.
483
Some smart servers or protocols *may* put the working tree in place in
486
This command only works on branches that have not diverged. Branches are
487
considered diverged if the destination branch's most recent commit is one
488
that has not been merged (directly or indirectly) by the source branch.
490
If branches have diverged, you can use 'bzr push --overwrite' to replace
491
the other branch completely, discarding its unmerged changes.
493
If you want to ensure you have the different changes in the other branch,
494
do a merge (see bzr help merge) from the other branch, and commit that.
495
After that you will be able to do a push without '--overwrite'.
497
If there is no default push location set, the first push will set it.
498
After that, you can omit the location to use the default. To change the
499
default, use --remember. The value will only be saved if the remote
500
location can be accessed.
503
takes_options = ['remember', 'overwrite', 'verbose',
504
Option('create-prefix',
505
help='Create the path leading up to the branch '
506
'if it does not already exist')]
507
takes_args = ['location?']
508
encoding_type = 'replace'
510
def run(self, location=None, remember=False, overwrite=False,
511
create_prefix=False, verbose=False):
512
# FIXME: Way too big! Put this into a function called from the
514
from bzrlib.transport import get_transport
516
br_from = Branch.open_containing('.')[0]
517
stored_loc = br_from.get_push_location()
519
if stored_loc is None:
520
raise BzrCommandError("No push location known or specified.")
522
display_url = urlutils.unescape_for_display(stored_loc,
524
self.outf.write("Using saved location: %s\n" % display_url)
525
location = stored_loc
527
transport = get_transport(location)
528
location_url = transport.base
532
dir_to = bzrdir.BzrDir.open(location_url)
533
br_to = dir_to.open_branch()
534
except NotBranchError:
536
transport = transport.clone('..')
537
if not create_prefix:
539
relurl = transport.relpath(location_url)
540
mutter('creating directory %s => %s', location_url, relurl)
541
transport.mkdir(relurl)
543
raise BzrCommandError("Parent directory of %s "
544
"does not exist." % location)
546
current = transport.base
547
needed = [(transport, transport.relpath(location_url))]
550
transport, relpath = needed[-1]
551
transport.mkdir(relpath)
554
new_transport = transport.clone('..')
555
needed.append((new_transport,
556
new_transport.relpath(transport.base)))
557
if new_transport.base == transport.base:
558
raise BzrCommandError("Could not create "
560
dir_to = br_from.bzrdir.clone(location_url,
561
revision_id=br_from.last_revision())
562
br_to = dir_to.open_branch()
563
count = len(br_to.revision_history())
564
# We successfully created the target, remember it
565
if br_from.get_push_location() is None or remember:
566
br_from.set_push_location(br_to.base)
568
# We were able to connect to the remote location, so remember it
569
# we don't need to successfully push because of possible divergence.
570
if br_from.get_push_location() is None or remember:
571
br_from.set_push_location(br_to.base)
572
old_rh = br_to.revision_history()
575
tree_to = dir_to.open_workingtree()
576
except errors.NotLocalUrl:
577
warning('This transport does not update the working '
578
'tree of: %s' % (br_to.base,))
579
count = br_to.pull(br_from, overwrite)
580
except NoWorkingTree:
581
count = br_to.pull(br_from, overwrite)
583
count = tree_to.pull(br_from, overwrite)
584
except DivergedBranches:
585
raise BzrCommandError("These branches have diverged."
586
" Try a merge then push with overwrite.")
587
note('%d revision(s) pushed.' % (count,))
590
new_rh = br_to.revision_history()
593
from bzrlib.log import show_changed_revisions
594
show_changed_revisions(br_to, old_rh, new_rh,
598
class cmd_branch(Command):
599
"""Create a new copy of a branch.
601
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
602
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
604
To retrieve the branch as of a particular revision, supply the --revision
605
parameter, as in "branch foo/bar -r 5".
607
--basis is to speed up branching from remote branches. When specified, it
608
copies all the file-contents, inventory and revision data from the basis
609
branch before copying anything from the remote branch.
611
takes_args = ['from_location', 'to_location?']
612
takes_options = ['revision', 'basis']
613
aliases = ['get', 'clone']
615
def run(self, from_location, to_location=None, revision=None, basis=None):
616
from bzrlib.transport import get_transport
619
elif len(revision) > 1:
620
raise BzrCommandError(
621
'bzr branch --revision takes exactly 1 revision value')
623
br_from = Branch.open(from_location)
625
if e.errno == errno.ENOENT:
626
raise BzrCommandError('Source location "%s" does not'
627
' exist.' % to_location)
632
if basis is not None:
633
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
636
if len(revision) == 1 and revision[0] is not None:
637
revision_id = revision[0].in_history(br_from)[1]
639
# FIXME - wt.last_revision, fallback to branch, fall back to
640
# None or perhaps NULL_REVISION to mean copy nothing
642
revision_id = br_from.last_revision()
643
if to_location is None:
644
to_location = os.path.basename(from_location.rstrip("/\\"))
647
name = os.path.basename(to_location) + '\n'
649
to_transport = get_transport(to_location)
651
to_transport.mkdir('.')
652
except errors.FileExists:
653
raise BzrCommandError('Target directory "%s" already'
654
' exists.' % to_location)
655
except errors.NoSuchFile:
656
raise BzrCommandError('Parent of "%s" does not exist.' %
659
# preserve whatever source format we have.
660
dir = br_from.bzrdir.sprout(to_transport.base,
661
revision_id, basis_dir)
662
branch = dir.open_branch()
663
except errors.NoSuchRevision:
664
to_transport.delete_tree('.')
665
msg = "The branch %s has no revision %s." % (from_location, revision[0])
666
raise BzrCommandError(msg)
667
except errors.UnlistableBranch:
668
osutils.rmtree(to_location)
669
msg = "The branch %s cannot be used as a --basis" % (basis,)
670
raise BzrCommandError(msg)
672
branch.control_files.put_utf8('branch-name', name)
673
note('Branched %d revision(s).' % branch.revno())
678
class cmd_checkout(Command):
679
"""Create a new checkout of an existing branch.
681
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
682
the branch found in '.'. This is useful if you have removed the working tree
683
or if it was never created - i.e. if you pushed the branch to its current
686
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
687
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
689
To retrieve the branch as of a particular revision, supply the --revision
690
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
691
out of date [so you cannot commit] but it may be useful (i.e. to examine old
694
--basis is to speed up checking out from remote branches. When specified, it
695
uses the inventory and file contents from the basis branch in preference to the
696
branch being checked out.
698
takes_args = ['branch_location?', 'to_location?']
699
takes_options = ['revision', # , 'basis']
700
Option('lightweight',
701
help="perform a lightweight checkout. Lightweight "
702
"checkouts depend on access to the branch for "
703
"every operation. Normal checkouts can perform "
704
"common operations like diff and status without "
705
"such access, and also support local commits."
709
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
713
elif len(revision) > 1:
714
raise BzrCommandError(
715
'bzr checkout --revision takes exactly 1 revision value')
716
if branch_location is None:
717
branch_location = osutils.getcwd()
718
to_location = branch_location
719
source = Branch.open(branch_location)
720
if len(revision) == 1 and revision[0] is not None:
721
revision_id = revision[0].in_history(source)[1]
724
if to_location is None:
725
to_location = os.path.basename(branch_location.rstrip("/\\"))
726
# if the source and to_location are the same,
727
# and there is no working tree,
728
# then reconstitute a branch
729
if (osutils.abspath(to_location) ==
730
osutils.abspath(branch_location)):
732
source.bzrdir.open_workingtree()
733
except errors.NoWorkingTree:
734
source.bzrdir.create_workingtree()
737
os.mkdir(to_location)
739
if e.errno == errno.EEXIST:
740
raise BzrCommandError('Target directory "%s" already'
741
' exists.' % to_location)
742
if e.errno == errno.ENOENT:
743
raise BzrCommandError('Parent of "%s" does not exist.' %
747
old_format = bzrdir.BzrDirFormat.get_default_format()
748
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
751
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
752
branch.BranchReferenceFormat().initialize(checkout, source)
754
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
755
to_location, force_new_tree=False)
756
checkout = checkout_branch.bzrdir
757
checkout_branch.bind(source)
758
if revision_id is not None:
759
rh = checkout_branch.revision_history()
760
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
761
checkout.create_workingtree(revision_id)
763
bzrdir.BzrDirFormat.set_default_format(old_format)
766
class cmd_renames(Command):
767
"""Show list of renamed files.
769
# TODO: Option to show renames between two historical versions.
771
# TODO: Only show renames under dir, rather than in the whole branch.
772
takes_args = ['dir?']
775
def run(self, dir=u'.'):
776
from bzrlib.tree import find_renames
777
tree = WorkingTree.open_containing(dir)[0]
778
old_inv = tree.basis_tree().inventory
779
new_inv = tree.read_working_inventory()
780
renames = list(find_renames(old_inv, new_inv))
782
for old_name, new_name in renames:
783
self.outf.write("%s => %s\n" % (old_name, new_name))
786
class cmd_update(Command):
787
"""Update a tree to have the latest code committed to its branch.
789
This will perform a merge into the working tree, and may generate
790
conflicts. If you have any local changes, you will still
791
need to commit them after the update for the update to be complete.
793
If you want to discard your local changes, you can just do a
794
'bzr revert' instead of 'bzr commit' after the update.
796
takes_args = ['dir?']
798
def run(self, dir='.'):
799
tree = WorkingTree.open_containing(dir)[0]
802
if tree.last_revision() == tree.branch.last_revision():
803
# may be up to date, check master too.
804
master = tree.branch.get_master_branch()
805
if master is None or master.last_revision == tree.last_revision():
806
note("Tree is up to date.")
808
conflicts = tree.update()
809
note('Updated to revision %d.' %
810
(tree.branch.revision_id_to_revno(tree.last_revision()),))
819
class cmd_info(Command):
820
"""Show information about a working tree, branch or repository.
822
This command will show all known locations and formats associated to the
823
tree, branch or repository. Statistical information is included with
826
Branches and working trees will also report any missing revisions.
828
takes_args = ['location?']
829
takes_options = ['verbose']
832
def run(self, location=None, verbose=False):
833
from bzrlib.info import show_bzrdir_info
834
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
838
class cmd_remove(Command):
839
"""Make a file unversioned.
841
This makes bzr stop tracking changes to a versioned file. It does
842
not delete the working copy.
844
You can specify one or more files, and/or --new. If you specify --new,
845
only 'added' files will be removed. If you specify both, then new files
846
in the specified directories will be removed. If the directories are
847
also new, they will also be removed.
849
takes_args = ['file*']
850
takes_options = ['verbose', Option('new', help='remove newly-added files')]
852
encoding_type = 'replace'
854
def run(self, file_list, verbose=False, new=False):
855
tree, file_list = tree_files(file_list)
857
if file_list is None:
858
raise BzrCommandError('Specify one or more files to remove, or'
861
from bzrlib.delta import compare_trees
862
added = [compare_trees(tree.basis_tree(), tree,
863
specific_files=file_list).added]
864
file_list = sorted([f[0] for f in added[0]], reverse=True)
865
if len(file_list) == 0:
866
raise BzrCommandError('No matching files.')
867
tree.remove(file_list, verbose=verbose, to_file=self.outf)
870
class cmd_file_id(Command):
871
"""Print file_id of a particular file or directory.
873
The file_id is assigned when the file is first added and remains the
874
same through all revisions where the file exists, even when it is
879
takes_args = ['filename']
882
def run(self, filename):
883
tree, relpath = WorkingTree.open_containing(filename)
884
i = tree.inventory.path2id(relpath)
886
raise BzrError("%r is not a versioned file" % filename)
888
self.outf.write(i + '\n')
891
class cmd_file_path(Command):
892
"""Print path of file_ids to a file or directory.
894
This prints one line for each directory down to the target,
895
starting at the branch root.
899
takes_args = ['filename']
902
def run(self, filename):
903
tree, relpath = WorkingTree.open_containing(filename)
905
fid = inv.path2id(relpath)
907
raise BzrError("%r is not a versioned file" % filename)
908
for fip in inv.get_idpath(fid):
909
self.outf.write(fip + '\n')
912
class cmd_reconcile(Command):
913
"""Reconcile bzr metadata in a branch.
915
This can correct data mismatches that may have been caused by
916
previous ghost operations or bzr upgrades. You should only
917
need to run this command if 'bzr check' or a bzr developer
918
advises you to run it.
920
If a second branch is provided, cross-branch reconciliation is
921
also attempted, which will check that data like the tree root
922
id which was not present in very early bzr versions is represented
923
correctly in both branches.
925
At the same time it is run it may recompress data resulting in
926
a potential saving in disk space or performance gain.
928
The branch *MUST* be on a listable system such as local disk or sftp.
930
takes_args = ['branch?']
932
def run(self, branch="."):
933
from bzrlib.reconcile import reconcile
934
dir = bzrdir.BzrDir.open(branch)
938
class cmd_revision_history(Command):
939
"""Display the list of revision ids on a branch."""
940
takes_args = ['location?']
945
def run(self, location="."):
946
branch = Branch.open_containing(location)[0]
947
for revid in branch.revision_history():
948
self.outf.write(revid)
949
self.outf.write('\n')
952
class cmd_ancestry(Command):
953
"""List all revisions merged into this branch."""
954
takes_args = ['location?']
959
def run(self, location="."):
961
wt = WorkingTree.open_containing(location)[0]
962
except errors.NoWorkingTree:
963
b = Branch.open(location)
964
last_revision = b.last_revision()
967
last_revision = wt.last_revision()
969
revision_ids = b.repository.get_ancestry(last_revision)
970
assert revision_ids[0] == None
972
for revision_id in revision_ids:
973
self.outf.write(revision_id + '\n')
976
class cmd_init(Command):
977
"""Make a directory into a versioned branch.
979
Use this to create an empty branch, or before importing an
982
If there is a repository in a parent directory of the location, then
983
the history of the branch will be stored in the repository. Otherwise
984
init creates a standalone branch which carries its own history in
987
If there is already a branch at the location but it has no working tree,
988
the tree can be populated with 'bzr checkout'.
990
Recipe for importing a tree of files:
995
bzr commit -m 'imported project'
997
takes_args = ['location?']
1000
help='Specify a format for this branch. Current'
1001
' formats are: default, knit, metaweave and'
1002
' weave. Default is knit; metaweave and'
1003
' weave are deprecated',
1004
type=get_format_type),
1006
def run(self, location=None, format=None):
1008
format = get_format_type('default')
1009
if location is None:
1012
# The path has to exist to initialize a
1013
# branch inside of it.
1014
# Just using os.mkdir, since I don't
1015
# believe that we want to create a bunch of
1016
# locations if the user supplies an extended path
1017
if not os.path.exists(location):
1020
existing_bzrdir = bzrdir.BzrDir.open(location)
1021
except NotBranchError:
1022
# really a NotBzrDir error...
1023
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1025
if existing_bzrdir.has_branch():
1026
if existing_bzrdir.has_workingtree():
1027
raise errors.AlreadyBranchError(location)
1029
raise errors.BranchExistsWithoutWorkingTree(location)
1031
existing_bzrdir.create_branch()
1032
existing_bzrdir.create_workingtree()
1035
class cmd_init_repository(Command):
1036
"""Create a shared repository to hold branches.
1038
New branches created under the repository directory will store their revisions
1039
in the repository, not in the branch directory, if the branch format supports
1045
bzr checkout --lightweight repo/trunk trunk-checkout
1049
takes_args = ["location"]
1050
takes_options = [Option('format',
1051
help='Specify a format for this repository.'
1052
' Current formats are: default, knit,'
1053
' metaweave and weave. Default is knit;'
1054
' metaweave and weave are deprecated',
1055
type=get_format_type),
1057
help='Allows branches in repository to have'
1059
aliases = ["init-repo"]
1060
def run(self, location, format=None, trees=False):
1061
from bzrlib.transport import get_transport
1063
format = get_format_type('default')
1064
transport = get_transport(location)
1065
if not transport.has('.'):
1067
newdir = format.initialize_on_transport(transport)
1068
repo = newdir.create_repository(shared=True)
1069
repo.set_make_working_trees(trees)
1072
class cmd_diff(Command):
1073
"""Show differences in working tree.
1075
If files are listed, only the changes in those files are listed.
1076
Otherwise, all changes for the tree are listed.
1078
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1079
produces patches suitable for "patch -p1".
1085
bzr diff --diff-prefix old/:new/
1086
bzr diff bzr.mine bzr.dev
1089
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1090
# or a graphical diff.
1092
# TODO: Python difflib is not exactly the same as unidiff; should
1093
# either fix it up or prefer to use an external diff.
1095
# TODO: Selected-file diff is inefficient and doesn't show you
1098
# TODO: This probably handles non-Unix newlines poorly.
1100
takes_args = ['file*']
1101
takes_options = ['revision', 'diff-options', 'prefix']
1102
aliases = ['di', 'dif']
1103
encoding_type = 'exact'
1106
def run(self, revision=None, file_list=None, diff_options=None,
1108
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1110
if (prefix is None) or (prefix == '0'):
1118
if not ':' in prefix:
1119
raise BzrError("--diff-prefix expects two values separated by a colon")
1120
old_label, new_label = prefix.split(":")
1123
tree1, file_list = internal_tree_files(file_list)
1127
except FileInWrongBranch:
1128
if len(file_list) != 2:
1129
raise BzrCommandError("Files are in different branches")
1131
tree1, file1 = WorkingTree.open_containing(file_list[0])
1132
tree2, file2 = WorkingTree.open_containing(file_list[1])
1133
if file1 != "" or file2 != "":
1134
# FIXME diff those two files. rbc 20051123
1135
raise BzrCommandError("Files are in different branches")
1137
if revision is not None:
1138
if tree2 is not None:
1139
raise BzrCommandError("Can't specify -r with two branches")
1140
if (len(revision) == 1) or (revision[1].spec is None):
1141
return diff_cmd_helper(tree1, file_list, diff_options,
1143
old_label=old_label, new_label=new_label)
1144
elif len(revision) == 2:
1145
return diff_cmd_helper(tree1, file_list, diff_options,
1146
revision[0], revision[1],
1147
old_label=old_label, new_label=new_label)
1149
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1151
if tree2 is not None:
1152
return show_diff_trees(tree1, tree2, sys.stdout,
1153
specific_files=file_list,
1154
external_diff_options=diff_options,
1155
old_label=old_label, new_label=new_label)
1157
return diff_cmd_helper(tree1, file_list, diff_options,
1158
old_label=old_label, new_label=new_label)
1161
class cmd_deleted(Command):
1162
"""List files deleted in the working tree.
1164
# TODO: Show files deleted since a previous revision, or
1165
# between two revisions.
1166
# TODO: Much more efficient way to do this: read in new
1167
# directories with readdir, rather than stating each one. Same
1168
# level of effort but possibly much less IO. (Or possibly not,
1169
# if the directories are very large...)
1170
takes_options = ['show-ids']
1173
def run(self, show_ids=False):
1174
tree = WorkingTree.open_containing(u'.')[0]
1175
old = tree.basis_tree()
1176
for path, ie in old.inventory.iter_entries():
1177
if not tree.has_id(ie.file_id):
1178
self.outf.write(path)
1180
self.outf.write(' ')
1181
self.outf.write(ie.file_id)
1182
self.outf.write('\n')
1185
class cmd_modified(Command):
1186
"""List files modified in working tree."""
1190
from bzrlib.delta import compare_trees
1192
tree = WorkingTree.open_containing(u'.')[0]
1193
td = compare_trees(tree.basis_tree(), tree)
1195
for path, id, kind, text_modified, meta_modified in td.modified:
1196
self.outf.write(path + '\n')
1199
class cmd_added(Command):
1200
"""List files added in working tree."""
1204
wt = WorkingTree.open_containing(u'.')[0]
1205
basis_inv = wt.basis_tree().inventory
1208
if file_id in basis_inv:
1210
path = inv.id2path(file_id)
1211
if not os.access(osutils.abspath(path), os.F_OK):
1213
self.outf.write(path + '\n')
1216
class cmd_root(Command):
1217
"""Show the tree root directory.
1219
The root is the nearest enclosing directory with a .bzr control
1221
takes_args = ['filename?']
1223
def run(self, filename=None):
1224
"""Print the branch root."""
1225
tree = WorkingTree.open_containing(filename)[0]
1226
self.outf.write(tree.basedir + '\n')
1229
class cmd_log(Command):
1230
"""Show log of a branch, file, or directory.
1232
By default show the log of the branch containing the working directory.
1234
To request a range of logs, you can use the command -r begin..end
1235
-r revision requests a specific revision, -r ..end or -r begin.. are
1241
bzr log -r -10.. http://server/branch
1244
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1246
takes_args = ['location?']
1247
takes_options = [Option('forward',
1248
help='show from oldest to newest'),
1251
help='show files changed in each revision'),
1252
'show-ids', 'revision',
1256
help='show revisions whose message matches this regexp',
1260
encoding_type = 'replace'
1263
def run(self, location=None, timezone='original',
1273
from bzrlib.log import log_formatter, show_log
1274
assert message is None or isinstance(message, basestring), \
1275
"invalid message argument %r" % message
1276
direction = (forward and 'forward') or 'reverse'
1281
# find the file id to log:
1283
dir, fp = bzrdir.BzrDir.open_containing(location)
1284
b = dir.open_branch()
1288
inv = dir.open_workingtree().inventory
1289
except (errors.NotBranchError, errors.NotLocalUrl):
1290
# either no tree, or is remote.
1291
inv = b.basis_tree().inventory
1292
file_id = inv.path2id(fp)
1295
# FIXME ? log the current subdir only RBC 20060203
1296
dir, relpath = bzrdir.BzrDir.open_containing('.')
1297
b = dir.open_branch()
1299
if revision is None:
1302
elif len(revision) == 1:
1303
rev1 = rev2 = revision[0].in_history(b).revno
1304
elif len(revision) == 2:
1305
if revision[0].spec is None:
1306
# missing begin-range means first revision
1309
rev1 = revision[0].in_history(b).revno
1311
if revision[1].spec is None:
1312
# missing end-range means last known revision
1315
rev2 = revision[1].in_history(b).revno
1317
raise BzrCommandError('bzr log --revision takes one or two values.')
1319
# By this point, the revision numbers are converted to the +ve
1320
# form if they were supplied in the -ve form, so we can do
1321
# this comparison in relative safety
1323
(rev2, rev1) = (rev1, rev2)
1325
if (log_format == None):
1326
default = b.get_config().log_format()
1327
log_format = get_log_format(long=long, short=short, line=line,
1329
lf = log_formatter(log_format,
1332
show_timezone=timezone)
1338
direction=direction,
1339
start_revision=rev1,
1344
def get_log_format(long=False, short=False, line=False, default='long'):
1345
log_format = default
1349
log_format = 'short'
1355
class cmd_touching_revisions(Command):
1356
"""Return revision-ids which affected a particular file.
1358
A more user-friendly interface is "bzr log FILE".
1362
takes_args = ["filename"]
1365
def run(self, filename):
1366
tree, relpath = WorkingTree.open_containing(filename)
1368
inv = tree.read_working_inventory()
1369
file_id = inv.path2id(relpath)
1370
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1371
self.outf.write("%6d %s\n" % (revno, what))
1374
class cmd_ls(Command):
1375
"""List files in a tree.
1377
# TODO: Take a revision or remote path and list that tree instead.
1379
takes_options = ['verbose', 'revision',
1380
Option('non-recursive',
1381
help='don\'t recurse into sub-directories'),
1383
help='Print all paths from the root of the branch.'),
1384
Option('unknown', help='Print unknown files'),
1385
Option('versioned', help='Print versioned files'),
1386
Option('ignored', help='Print ignored files'),
1388
Option('null', help='Null separate the files'),
1391
def run(self, revision=None, verbose=False,
1392
non_recursive=False, from_root=False,
1393
unknown=False, versioned=False, ignored=False,
1396
if verbose and null:
1397
raise BzrCommandError('Cannot set both --verbose and --null')
1398
all = not (unknown or versioned or ignored)
1400
selection = {'I':ignored, '?':unknown, 'V':versioned}
1402
tree, relpath = WorkingTree.open_containing(u'.')
1407
if revision is not None:
1408
tree = tree.branch.repository.revision_tree(
1409
revision[0].in_history(tree.branch).rev_id)
1411
for fp, fc, kind, fid, entry in tree.list_files():
1412
if fp.startswith(relpath):
1413
fp = fp[len(relpath):]
1414
if non_recursive and '/' in fp:
1416
if not all and not selection[fc]:
1419
kindch = entry.kind_character()
1420
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1422
self.outf.write(fp + '\0')
1425
self.outf.write(fp + '\n')
1428
class cmd_unknowns(Command):
1429
"""List unknown files."""
1432
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1433
self.outf.write(osutils.quotefn(f) + '\n')
1436
class cmd_ignore(Command):
1437
"""Ignore a command or pattern.
1439
To remove patterns from the ignore list, edit the .bzrignore file.
1441
If the pattern contains a slash, it is compared to the whole path
1442
from the branch root. Otherwise, it is compared to only the last
1443
component of the path. To match a file only in the root directory,
1446
Ignore patterns are case-insensitive on case-insensitive systems.
1448
Note: wildcards must be quoted from the shell on Unix.
1451
bzr ignore ./Makefile
1452
bzr ignore '*.class'
1454
# TODO: Complain if the filename is absolute
1455
takes_args = ['name_pattern']
1457
def run(self, name_pattern):
1458
from bzrlib.atomicfile import AtomicFile
1461
tree, relpath = WorkingTree.open_containing(u'.')
1462
ifn = tree.abspath('.bzrignore')
1464
if os.path.exists(ifn):
1467
igns = f.read().decode('utf-8')
1473
# TODO: If the file already uses crlf-style termination, maybe
1474
# we should use that for the newly added lines?
1476
if igns and igns[-1] != '\n':
1478
igns += name_pattern + '\n'
1480
f = AtomicFile(ifn, 'wt')
1482
f.write(igns.encode('utf-8'))
1487
inv = tree.inventory
1488
if inv.path2id('.bzrignore'):
1489
mutter('.bzrignore is already versioned')
1491
mutter('need to make new .bzrignore file versioned')
1492
tree.add(['.bzrignore'])
1495
class cmd_ignored(Command):
1496
"""List ignored files and the patterns that matched them.
1498
See also: bzr ignore"""
1501
tree = WorkingTree.open_containing(u'.')[0]
1502
for path, file_class, kind, file_id, entry in tree.list_files():
1503
if file_class != 'I':
1505
## XXX: Slightly inefficient since this was already calculated
1506
pat = tree.is_ignored(path)
1507
print '%-50s %s' % (path, pat)
1510
class cmd_lookup_revision(Command):
1511
"""Lookup the revision-id from a revision-number
1514
bzr lookup-revision 33
1517
takes_args = ['revno']
1520
def run(self, revno):
1524
raise BzrCommandError("not a valid revision-number: %r" % revno)
1526
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1529
class cmd_export(Command):
1530
"""Export past revision to destination directory.
1532
If no revision is specified this exports the last committed revision.
1534
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1535
given, try to find the format with the extension. If no extension
1536
is found exports to a directory (equivalent to --format=dir).
1538
Root may be the top directory for tar, tgz and tbz2 formats. If none
1539
is given, the top directory will be the root name of the file.
1541
Note: export of tree with non-ascii filenames to zip is not supported.
1543
Supported formats Autodetected by extension
1544
----------------- -------------------------
1547
tbz2 .tar.bz2, .tbz2
1551
takes_args = ['dest']
1552
takes_options = ['revision', 'format', 'root']
1553
def run(self, dest, revision=None, format=None, root=None):
1555
from bzrlib.export import export
1556
tree = WorkingTree.open_containing(u'.')[0]
1558
if revision is None:
1559
# should be tree.last_revision FIXME
1560
rev_id = b.last_revision()
1562
if len(revision) != 1:
1563
raise BzrError('bzr export --revision takes exactly 1 argument')
1564
rev_id = revision[0].in_history(b).rev_id
1565
t = b.repository.revision_tree(rev_id)
1567
export(t, dest, format, root)
1568
except errors.NoSuchExportFormat, e:
1569
raise BzrCommandError('Unsupported export format: %s' % e.format)
1572
class cmd_cat(Command):
1573
"""Write a file's text from a previous revision."""
1575
takes_options = ['revision']
1576
takes_args = ['filename']
1579
def run(self, filename, revision=None):
1580
if revision is not None and len(revision) != 1:
1581
raise BzrCommandError("bzr cat --revision takes exactly one number")
1584
tree, relpath = WorkingTree.open_containing(filename)
1586
except NotBranchError:
1590
b, relpath = Branch.open_containing(filename)
1591
if revision is None:
1592
revision_id = b.last_revision()
1594
revision_id = revision[0].in_history(b).rev_id
1595
b.print_file(relpath, revision_id)
1598
class cmd_local_time_offset(Command):
1599
"""Show the offset in seconds from GMT to local time."""
1603
print osutils.local_time_offset()
1607
class cmd_commit(Command):
1608
"""Commit changes into a new revision.
1610
If no arguments are given, the entire tree is committed.
1612
If selected files are specified, only changes to those files are
1613
committed. If a directory is specified then the directory and everything
1614
within it is committed.
1616
A selected-file commit may fail in some cases where the committed
1617
tree would be invalid, such as trying to commit a file in a
1618
newly-added directory that is not itself committed.
1620
# TODO: Run hooks on tree to-be-committed, and after commit.
1622
# TODO: Strict commit that fails if there are deleted files.
1623
# (what does "deleted files" mean ??)
1625
# TODO: Give better message for -s, --summary, used by tla people
1627
# XXX: verbose currently does nothing
1629
takes_args = ['selected*']
1630
takes_options = ['message', 'verbose',
1632
help='commit even if nothing has changed'),
1633
Option('file', type=str,
1635
help='file containing commit message'),
1637
help="refuse to commit if there are unknown "
1638
"files in the working tree."),
1640
help="perform a local only commit in a bound "
1641
"branch. Such commits are not pushed to "
1642
"the master branch until a normal commit "
1646
aliases = ['ci', 'checkin']
1648
def run(self, message=None, file=None, verbose=True, selected_list=None,
1649
unchanged=False, strict=False, local=False):
1650
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1651
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1653
from bzrlib.msgeditor import edit_commit_message, \
1654
make_commit_message_template
1655
from tempfile import TemporaryFile
1657
# TODO: Need a blackbox test for invoking the external editor; may be
1658
# slightly problematic to run this cross-platform.
1660
# TODO: do more checks that the commit will succeed before
1661
# spending the user's valuable time typing a commit message.
1663
# TODO: if the commit *does* happen to fail, then save the commit
1664
# message to a temporary file where it can be recovered
1665
tree, selected_list = tree_files(selected_list)
1666
if selected_list == ['']:
1667
# workaround - commit of root of tree should be exactly the same
1668
# as just default commit in that tree, and succeed even though
1669
# selected-file merge commit is not done yet
1672
if local and not tree.branch.get_bound_location():
1673
raise errors.LocalRequiresBoundBranch()
1674
if message is None and not file:
1675
template = make_commit_message_template(tree, selected_list)
1676
message = edit_commit_message(template)
1678
raise BzrCommandError("please specify a commit message"
1679
" with either --message or --file")
1680
elif message and file:
1681
raise BzrCommandError("please specify either --message or --file")
1684
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1687
raise BzrCommandError("empty commit message specified")
1690
reporter = ReportCommitToLog()
1692
reporter = NullCommitReporter()
1695
tree.commit(message, specific_files=selected_list,
1696
allow_pointless=unchanged, strict=strict, local=local,
1698
except PointlessCommit:
1699
# FIXME: This should really happen before the file is read in;
1700
# perhaps prepare the commit; get the message; then actually commit
1701
raise BzrCommandError("no changes to commit."
1702
" use --unchanged to commit anyhow")
1703
except ConflictsInTree:
1704
raise BzrCommandError("Conflicts detected in working tree. "
1705
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1706
except StrictCommitFailed:
1707
raise BzrCommandError("Commit refused because there are unknown "
1708
"files in the working tree.")
1709
except errors.BoundBranchOutOfDate, e:
1710
raise BzrCommandError(str(e)
1711
+ ' Either unbind, update, or'
1712
' pass --local to commit.')
1715
class cmd_check(Command):
1716
"""Validate consistency of branch history.
1718
This command checks various invariants about the branch storage to
1719
detect data corruption or bzr bugs.
1721
takes_args = ['branch?']
1722
takes_options = ['verbose']
1724
def run(self, branch=None, verbose=False):
1725
from bzrlib.check import check
1727
tree = WorkingTree.open_containing()[0]
1728
branch = tree.branch
1730
branch = Branch.open(branch)
1731
check(branch, verbose)
1734
class cmd_scan_cache(Command):
1737
from bzrlib.hashcache import HashCache
1743
print '%6d stats' % c.stat_count
1744
print '%6d in hashcache' % len(c._cache)
1745
print '%6d files removed from cache' % c.removed_count
1746
print '%6d hashes updated' % c.update_count
1747
print '%6d files changed too recently to cache' % c.danger_count
1753
class cmd_upgrade(Command):
1754
"""Upgrade branch storage to current format.
1756
The check command or bzr developers may sometimes advise you to run
1757
this command. When the default format has changed you may also be warned
1758
during other operations to upgrade.
1760
takes_args = ['url?']
1763
help='Upgrade to a specific format. Current formats'
1764
' are: default, knit, metaweave and weave.'
1765
' Default is knit; metaweave and weave are'
1767
type=get_format_type),
1771
def run(self, url='.', format=None):
1772
from bzrlib.upgrade import upgrade
1774
format = get_format_type('default')
1775
upgrade(url, format)
1778
class cmd_whoami(Command):
1779
"""Show bzr user id."""
1780
takes_options = ['email']
1783
def run(self, email=False):
1785
c = WorkingTree.open_containing(u'.')[0].branch.get_config()
1786
except NotBranchError:
1787
c = config.GlobalConfig()
1789
print c.user_email()
1794
class cmd_nick(Command):
1795
"""Print or set the branch nickname.
1797
If unset, the tree root directory name is used as the nickname
1798
To print the current nickname, execute with no argument.
1800
takes_args = ['nickname?']
1801
def run(self, nickname=None):
1802
branch = Branch.open_containing(u'.')[0]
1803
if nickname is None:
1804
self.printme(branch)
1806
branch.nick = nickname
1809
def printme(self, branch):
1813
class cmd_selftest(Command):
1814
"""Run internal test suite.
1816
This creates temporary test directories in the working directory,
1817
but not existing data is affected. These directories are deleted
1818
if the tests pass, or left behind to help in debugging if they
1819
fail and --keep-output is specified.
1821
If arguments are given, they are regular expressions that say
1822
which tests should run.
1824
If the global option '--no-plugins' is given, plugins are not loaded
1825
before running the selftests. This has two effects: features provided or
1826
modified by plugins will not be tested, and tests provided by plugins will
1831
bzr --no-plugins selftest -v
1833
# TODO: --list should give a list of all available tests
1835
# NB: this is used from the class without creating an instance, which is
1836
# why it does not have a self parameter.
1837
def get_transport_type(typestring):
1838
"""Parse and return a transport specifier."""
1839
if typestring == "sftp":
1840
from bzrlib.transport.sftp import SFTPAbsoluteServer
1841
return SFTPAbsoluteServer
1842
if typestring == "memory":
1843
from bzrlib.transport.memory import MemoryServer
1845
if typestring == "fakenfs":
1846
from bzrlib.transport.fakenfs import FakeNFSServer
1847
return FakeNFSServer
1848
msg = "No known transport type %s. Supported types are: sftp\n" %\
1850
raise BzrCommandError(msg)
1853
takes_args = ['testspecs*']
1854
takes_options = ['verbose',
1855
Option('one', help='stop when one test fails'),
1856
Option('keep-output',
1857
help='keep output directories when tests fail'),
1859
help='Use a different transport by default '
1860
'throughout the test suite.',
1861
type=get_transport_type),
1862
Option('benchmark', help='run the bzr bencharks.'),
1863
Option('lsprof-timed',
1864
help='generate lsprof output for benchmarked'
1865
' sections of code.'),
1868
def run(self, testspecs_list=None, verbose=None, one=False,
1869
keep_output=False, transport=None, benchmark=None,
1872
from bzrlib.tests import selftest
1873
import bzrlib.benchmarks as benchmarks
1874
# we don't want progress meters from the tests to go to the
1875
# real output; and we don't want log messages cluttering up
1877
save_ui = ui.ui_factory
1878
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1879
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1881
info('running tests...')
1883
ui.ui_factory = ui.SilentUIFactory()
1884
if testspecs_list is not None:
1885
pattern = '|'.join(testspecs_list)
1889
test_suite_factory = benchmarks.test_suite
1893
test_suite_factory = None
1896
result = selftest(verbose=verbose,
1898
stop_on_failure=one,
1899
keep_output=keep_output,
1900
transport=transport,
1901
test_suite_factory=test_suite_factory,
1902
lsprof_timed=lsprof_timed)
1904
info('tests passed')
1906
info('tests failed')
1907
return int(not result)
1909
ui.ui_factory = save_ui
1912
def _get_bzr_branch():
1913
"""If bzr is run from a branch, return Branch or None"""
1914
from os.path import dirname
1917
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1919
except errors.BzrError:
1925
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1926
# is bzrlib itself in a branch?
1927
branch = _get_bzr_branch()
1929
rh = branch.revision_history()
1931
print " bzr checkout, revision %d" % (revno,)
1932
print " nick: %s" % (branch.nick,)
1934
print " revid: %s" % (rh[-1],)
1935
print "Using python interpreter:", sys.executable
1937
print "Using python standard library:", os.path.dirname(site.__file__)
1938
print "Using bzrlib:",
1939
if len(bzrlib.__path__) > 1:
1940
# print repr, which is a good enough way of making it clear it's
1941
# more than one element (eg ['/foo/bar', '/foo/bzr'])
1942
print repr(bzrlib.__path__)
1944
print bzrlib.__path__[0]
1947
print bzrlib.__copyright__
1948
print "http://bazaar-vcs.org/"
1950
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1951
print "you may use, modify and redistribute it under the terms of the GNU"
1952
print "General Public License version 2 or later."
1955
class cmd_version(Command):
1956
"""Show version of bzr."""
1961
class cmd_rocks(Command):
1962
"""Statement of optimism."""
1966
print "it sure does!"
1969
class cmd_find_merge_base(Command):
1970
"""Find and print a base revision for merging two branches.
1972
# TODO: Options to specify revisions on either side, as if
1973
# merging only part of the history.
1974
takes_args = ['branch', 'other']
1978
def run(self, branch, other):
1979
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1981
branch1 = Branch.open_containing(branch)[0]
1982
branch2 = Branch.open_containing(other)[0]
1984
history_1 = branch1.revision_history()
1985
history_2 = branch2.revision_history()
1987
last1 = branch1.last_revision()
1988
last2 = branch2.last_revision()
1990
source = MultipleRevisionSources(branch1.repository,
1993
base_rev_id = common_ancestor(last1, last2, source)
1995
print 'merge base is revision %s' % base_rev_id
1998
class cmd_merge(Command):
1999
"""Perform a three-way merge.
2001
The branch is the branch you will merge from. By default, it will merge
2002
the latest revision. If you specify a revision, that revision will be
2003
merged. If you specify two revisions, the first will be used as a BASE,
2004
and the second one as OTHER. Revision numbers are always relative to the
2007
By default, bzr will try to merge in all new work from the other
2008
branch, automatically determining an appropriate base. If this
2009
fails, you may need to give an explicit base.
2011
Merge will do its best to combine the changes in two branches, but there
2012
are some kinds of problems only a human can fix. When it encounters those,
2013
it will mark a conflict. A conflict means that you need to fix something,
2014
before you should commit.
2016
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2018
If there is no default branch set, the first merge will set it. After
2019
that, you can omit the branch to use the default. To change the
2020
default, use --remember. The value will only be saved if the remote
2021
location can be accessed.
2025
To merge the latest revision from bzr.dev
2026
bzr merge ../bzr.dev
2028
To merge changes up to and including revision 82 from bzr.dev
2029
bzr merge -r 82 ../bzr.dev
2031
To merge the changes introduced by 82, without previous changes:
2032
bzr merge -r 81..82 ../bzr.dev
2034
merge refuses to run if there are any uncommitted changes, unless
2037
The following merge types are available:
2039
takes_args = ['branch?']
2040
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2041
Option('show-base', help="Show base revision text in "
2045
from merge import merge_type_help
2046
from inspect import getdoc
2047
return getdoc(self) + '\n' + merge_type_help()
2049
def run(self, branch=None, revision=None, force=False, merge_type=None,
2050
show_base=False, reprocess=False, remember=False):
2051
if merge_type is None:
2052
merge_type = Merge3Merger
2054
tree = WorkingTree.open_containing(u'.')[0]
2056
if branch is not None:
2058
reader = bundle.read_bundle_from_url(branch)
2060
pass # Continue on considering this url a Branch
2062
conflicts = merge_bundle(reader, tree, not force, merge_type,
2063
reprocess, show_base)
2069
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2071
if revision is None or len(revision) < 1:
2073
other = [branch, -1]
2074
other_branch, path = Branch.open_containing(branch)
2076
if len(revision) == 1:
2078
other_branch, path = Branch.open_containing(branch)
2079
revno = revision[0].in_history(other_branch).revno
2080
other = [branch, revno]
2082
assert len(revision) == 2
2083
if None in revision:
2084
raise BzrCommandError(
2085
"Merge doesn't permit that revision specifier.")
2086
other_branch, path = Branch.open_containing(branch)
2088
base = [branch, revision[0].in_history(other_branch).revno]
2089
other = [branch, revision[1].in_history(other_branch).revno]
2091
if tree.branch.get_parent() is None or remember:
2092
tree.branch.set_parent(other_branch.base)
2095
interesting_files = [path]
2097
interesting_files = None
2098
pb = ui.ui_factory.nested_progress_bar()
2101
conflict_count = merge(other, base, check_clean=(not force),
2102
merge_type=merge_type,
2103
reprocess=reprocess,
2104
show_base=show_base,
2105
pb=pb, file_list=interesting_files)
2108
if conflict_count != 0:
2112
except errors.AmbiguousBase, e:
2113
m = ("sorry, bzr can't determine the right merge base yet\n"
2114
"candidates are:\n "
2115
+ "\n ".join(e.bases)
2117
"please specify an explicit base with -r,\n"
2118
"and (if you want) report this to the bzr developers\n")
2121
# TODO: move up to common parent; this isn't merge-specific anymore.
2122
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2123
"""Use tree.branch's parent if none was supplied.
2125
Report if the remembered location was used.
2127
if supplied_location is not None:
2128
return supplied_location
2129
stored_location = tree.branch.get_parent()
2130
mutter("%s", stored_location)
2131
if stored_location is None:
2132
raise BzrCommandError("No location specified or remembered")
2133
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2134
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2135
return stored_location
2138
class cmd_remerge(Command):
2141
Use this if you want to try a different merge technique while resolving
2142
conflicts. Some merge techniques are better than others, and remerge
2143
lets you try different ones on different files.
2145
The options for remerge have the same meaning and defaults as the ones for
2146
merge. The difference is that remerge can (only) be run when there is a
2147
pending merge, and it lets you specify particular files.
2150
$ bzr remerge --show-base
2151
Re-do the merge of all conflicted files, and show the base text in
2152
conflict regions, in addition to the usual THIS and OTHER texts.
2154
$ bzr remerge --merge-type weave --reprocess foobar
2155
Re-do the merge of "foobar", using the weave merge algorithm, with
2156
additional processing to reduce the size of conflict regions.
2158
The following merge types are available:"""
2159
takes_args = ['file*']
2160
takes_options = ['merge-type', 'reprocess',
2161
Option('show-base', help="Show base revision text in "
2165
from merge import merge_type_help
2166
from inspect import getdoc
2167
return getdoc(self) + '\n' + merge_type_help()
2169
def run(self, file_list=None, merge_type=None, show_base=False,
2171
from bzrlib.merge import merge_inner, transform_tree
2172
if merge_type is None:
2173
merge_type = Merge3Merger
2174
tree, file_list = tree_files(file_list)
2177
pending_merges = tree.pending_merges()
2178
if len(pending_merges) != 1:
2179
raise BzrCommandError("Sorry, remerge only works after normal"
2180
+ " merges. Not cherrypicking or"
2182
repository = tree.branch.repository
2183
base_revision = common_ancestor(tree.branch.last_revision(),
2184
pending_merges[0], repository)
2185
base_tree = repository.revision_tree(base_revision)
2186
other_tree = repository.revision_tree(pending_merges[0])
2187
interesting_ids = None
2188
if file_list is not None:
2189
interesting_ids = set()
2190
for filename in file_list:
2191
file_id = tree.path2id(filename)
2193
raise NotVersionedError(filename)
2194
interesting_ids.add(file_id)
2195
if tree.kind(file_id) != "directory":
2198
for name, ie in tree.inventory.iter_entries(file_id):
2199
interesting_ids.add(ie.file_id)
2200
transform_tree(tree, tree.basis_tree(), interesting_ids)
2201
if file_list is None:
2202
restore_files = list(tree.iter_conflicts())
2204
restore_files = file_list
2205
for filename in restore_files:
2207
restore(tree.abspath(filename))
2208
except NotConflicted:
2210
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2212
interesting_ids = interesting_ids,
2213
other_rev_id=pending_merges[0],
2214
merge_type=merge_type,
2215
show_base=show_base,
2216
reprocess=reprocess)
2224
class cmd_revert(Command):
2225
"""Reverse all changes since the last commit.
2227
Only versioned files are affected. Specify filenames to revert only
2228
those files. By default, any files that are changed will be backed up
2229
first. Backup files have a '~' appended to their name.
2231
takes_options = ['revision', 'no-backup']
2232
takes_args = ['file*']
2233
aliases = ['merge-revert']
2235
def run(self, revision=None, no_backup=False, file_list=None):
2236
from bzrlib.commands import parse_spec
2237
if file_list is not None:
2238
if len(file_list) == 0:
2239
raise BzrCommandError("No files specified")
2243
tree, file_list = tree_files(file_list)
2244
if revision is None:
2245
# FIXME should be tree.last_revision
2246
rev_id = tree.last_revision()
2247
elif len(revision) != 1:
2248
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2250
rev_id = revision[0].in_history(tree.branch).rev_id
2251
pb = ui.ui_factory.nested_progress_bar()
2253
tree.revert(file_list,
2254
tree.branch.repository.revision_tree(rev_id),
2260
class cmd_assert_fail(Command):
2261
"""Test reporting of assertion failures"""
2264
assert False, "always fails"
2267
class cmd_help(Command):
2268
"""Show help on a command or other topic.
2270
For a list of all available commands, say 'bzr help commands'."""
2271
takes_options = [Option('long', 'show help on all commands')]
2272
takes_args = ['topic?']
2273
aliases = ['?', '--help', '-?', '-h']
2276
def run(self, topic=None, long=False):
2278
if topic is None and long:
2283
class cmd_shell_complete(Command):
2284
"""Show appropriate completions for context.
2286
For a list of all available commands, say 'bzr shell-complete'."""
2287
takes_args = ['context?']
2292
def run(self, context=None):
2293
import shellcomplete
2294
shellcomplete.shellcomplete(context)
2297
class cmd_fetch(Command):
2298
"""Copy in history from another branch but don't merge it.
2300
This is an internal method used for pull and merge."""
2302
takes_args = ['from_branch', 'to_branch']
2303
def run(self, from_branch, to_branch):
2304
from bzrlib.fetch import Fetcher
2305
from_b = Branch.open(from_branch)
2306
to_b = Branch.open(to_branch)
2307
Fetcher(to_b, from_b)
2310
class cmd_missing(Command):
2311
"""Show unmerged/unpulled revisions between two branches.
2313
OTHER_BRANCH may be local or remote."""
2314
takes_args = ['other_branch?']
2315
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2317
'Display changes in the local branch only'),
2318
Option('theirs-only',
2319
'Display changes in the remote branch only'),
2328
def run(self, other_branch=None, reverse=False, mine_only=False,
2329
theirs_only=False, log_format=None, long=False, short=False, line=False,
2330
show_ids=False, verbose=False):
2331
from bzrlib.missing import find_unmerged, iter_log_data
2332
from bzrlib.log import log_formatter
2333
local_branch = Branch.open_containing(u".")[0]
2334
parent = local_branch.get_parent()
2335
if other_branch is None:
2336
other_branch = parent
2337
if other_branch is None:
2338
raise BzrCommandError("No missing location known or specified.")
2339
print "Using last location: " + local_branch.get_parent()
2340
remote_branch = Branch.open(other_branch)
2341
if remote_branch.base == local_branch.base:
2342
remote_branch = local_branch
2343
local_branch.lock_read()
2345
remote_branch.lock_read()
2347
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2348
if (log_format == None):
2349
default = local_branch.get_config().log_format()
2350
log_format = get_log_format(long=long, short=short,
2351
line=line, default=default)
2352
lf = log_formatter(log_format, sys.stdout,
2354
show_timezone='original')
2355
if reverse is False:
2356
local_extra.reverse()
2357
remote_extra.reverse()
2358
if local_extra and not theirs_only:
2359
print "You have %d extra revision(s):" % len(local_extra)
2360
for data in iter_log_data(local_extra, local_branch.repository,
2363
printed_local = True
2365
printed_local = False
2366
if remote_extra and not mine_only:
2367
if printed_local is True:
2369
print "You are missing %d revision(s):" % len(remote_extra)
2370
for data in iter_log_data(remote_extra, remote_branch.repository,
2373
if not remote_extra and not local_extra:
2375
print "Branches are up to date."
2379
remote_branch.unlock()
2381
local_branch.unlock()
2382
if not status_code and parent is None and other_branch is not None:
2383
local_branch.lock_write()
2385
# handle race conditions - a parent might be set while we run.
2386
if local_branch.get_parent() is None:
2387
local_branch.set_parent(remote_branch.base)
2389
local_branch.unlock()
2393
class cmd_plugins(Command):
2398
import bzrlib.plugin
2399
from inspect import getdoc
2400
for name, plugin in bzrlib.plugin.all_plugins().items():
2401
if hasattr(plugin, '__path__'):
2402
print plugin.__path__[0]
2403
elif hasattr(plugin, '__file__'):
2404
print plugin.__file__
2410
print '\t', d.split('\n')[0]
2413
class cmd_testament(Command):
2414
"""Show testament (signing-form) of a revision."""
2415
takes_options = ['revision', 'long',
2416
Option('strict', help='Produce a strict-format'
2418
takes_args = ['branch?']
2420
def run(self, branch=u'.', revision=None, long=False, strict=False):
2421
from bzrlib.testament import Testament, StrictTestament
2423
testament_class = StrictTestament
2425
testament_class = Testament
2426
b = WorkingTree.open_containing(branch)[0].branch
2429
if revision is None:
2430
rev_id = b.last_revision()
2432
rev_id = revision[0].in_history(b).rev_id
2433
t = testament_class.from_revision(b.repository, rev_id)
2435
sys.stdout.writelines(t.as_text_lines())
2437
sys.stdout.write(t.as_short_text())
2442
class cmd_annotate(Command):
2443
"""Show the origin of each line in a file.
2445
This prints out the given file with an annotation on the left side
2446
indicating which revision, author and date introduced the change.
2448
If the origin is the same for a run of consecutive lines, it is
2449
shown only at the top, unless the --all option is given.
2451
# TODO: annotate directories; showing when each file was last changed
2452
# TODO: if the working copy is modified, show annotations on that
2453
# with new uncommitted lines marked
2454
aliases = ['blame', 'praise']
2455
takes_args = ['filename']
2456
takes_options = [Option('all', help='show annotations on all lines'),
2457
Option('long', help='show date in annotations'),
2462
def run(self, filename, all=False, long=False, revision=None):
2463
from bzrlib.annotate import annotate_file
2464
tree, relpath = WorkingTree.open_containing(filename)
2465
branch = tree.branch
2468
if revision is None:
2469
revision_id = branch.last_revision()
2470
elif len(revision) != 1:
2471
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2473
revision_id = revision[0].in_history(branch).rev_id
2474
file_id = tree.inventory.path2id(relpath)
2475
tree = branch.repository.revision_tree(revision_id)
2476
file_version = tree.inventory[file_id].revision
2477
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2482
class cmd_re_sign(Command):
2483
"""Create a digital signature for an existing revision."""
2484
# TODO be able to replace existing ones.
2486
hidden = True # is this right ?
2487
takes_args = ['revision_id*']
2488
takes_options = ['revision']
2490
def run(self, revision_id_list=None, revision=None):
2491
import bzrlib.gpg as gpg
2492
if revision_id_list is not None and revision is not None:
2493
raise BzrCommandError('You can only supply one of revision_id or --revision')
2494
if revision_id_list is None and revision is None:
2495
raise BzrCommandError('You must supply either --revision or a revision_id')
2496
b = WorkingTree.open_containing(u'.')[0].branch
2497
gpg_strategy = gpg.GPGStrategy(b.get_config())
2498
if revision_id_list is not None:
2499
for revision_id in revision_id_list:
2500
b.repository.sign_revision(revision_id, gpg_strategy)
2501
elif revision is not None:
2502
if len(revision) == 1:
2503
revno, rev_id = revision[0].in_history(b)
2504
b.repository.sign_revision(rev_id, gpg_strategy)
2505
elif len(revision) == 2:
2506
# are they both on rh- if so we can walk between them
2507
# might be nice to have a range helper for arbitrary
2508
# revision paths. hmm.
2509
from_revno, from_revid = revision[0].in_history(b)
2510
to_revno, to_revid = revision[1].in_history(b)
2511
if to_revid is None:
2512
to_revno = b.revno()
2513
if from_revno is None or to_revno is None:
2514
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2515
for revno in range(from_revno, to_revno + 1):
2516
b.repository.sign_revision(b.get_rev_id(revno),
2519
raise BzrCommandError('Please supply either one revision, or a range.')
2522
class cmd_bind(Command):
2523
"""Bind the current branch to a master branch.
2525
After binding, commits must succeed on the master branch
2526
before they are executed on the local one.
2529
takes_args = ['location']
2532
def run(self, location=None):
2533
b, relpath = Branch.open_containing(u'.')
2534
b_other = Branch.open(location)
2537
except DivergedBranches:
2538
raise BzrCommandError('These branches have diverged.'
2539
' Try merging, and then bind again.')
2542
class cmd_unbind(Command):
2543
"""Unbind the current branch from its master branch.
2545
After unbinding, the local branch is considered independent.
2546
All subsequent commits will be local.
2553
b, relpath = Branch.open_containing(u'.')
2555
raise BzrCommandError('Local branch is not bound')
2558
class cmd_uncommit(Command):
2559
"""Remove the last committed revision.
2561
--verbose will print out what is being removed.
2562
--dry-run will go through all the motions, but not actually
2565
In the future, uncommit will create a revision bundle, which can then
2569
# TODO: jam 20060108 Add an option to allow uncommit to remove
2570
# unreferenced information in 'branch-as-repository' branches.
2571
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2572
# information in shared branches as well.
2573
takes_options = ['verbose', 'revision',
2574
Option('dry-run', help='Don\'t actually make changes'),
2575
Option('force', help='Say yes to all questions.')]
2576
takes_args = ['location?']
2579
def run(self, location=None,
2580
dry_run=False, verbose=False,
2581
revision=None, force=False):
2582
from bzrlib.log import log_formatter
2584
from bzrlib.uncommit import uncommit
2586
if location is None:
2588
control, relpath = bzrdir.BzrDir.open_containing(location)
2590
tree = control.open_workingtree()
2592
except (errors.NoWorkingTree, errors.NotLocalUrl):
2594
b = control.open_branch()
2596
if revision is None:
2598
rev_id = b.last_revision()
2600
revno, rev_id = revision[0].in_history(b)
2602
print 'No revisions to uncommit.'
2604
for r in range(revno, b.revno()+1):
2605
rev_id = b.get_rev_id(r)
2606
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2607
lf.show(r, b.repository.get_revision(rev_id), None)
2610
print 'Dry-run, pretending to remove the above revisions.'
2612
val = raw_input('Press <enter> to continue')
2614
print 'The above revision(s) will be removed.'
2616
val = raw_input('Are you sure [y/N]? ')
2617
if val.lower() not in ('y', 'yes'):
2621
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2625
class cmd_break_lock(Command):
2626
"""Break a dead lock on a repository, branch or working directory.
2628
CAUTION: Locks should only be broken when you are sure that the process
2629
holding the lock has been stopped.
2631
You can get information on what locks are open via the 'bzr info' command.
2636
takes_args = ['location?']
2638
def run(self, location=None, show=False):
2639
if location is None:
2641
control, relpath = bzrdir.BzrDir.open_containing(location)
2643
control.break_lock()
2644
except NotImplementedError:
2649
# command-line interpretation helper for merge-related commands
2650
def merge(other_revision, base_revision,
2651
check_clean=True, ignore_zero=False,
2652
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2653
file_list=None, show_base=False, reprocess=False,
2654
pb=DummyProgress()):
2655
"""Merge changes into a tree.
2658
list(path, revno) Base for three-way merge.
2659
If [None, None] then a base will be automatically determined.
2661
list(path, revno) Other revision for three-way merge.
2663
Directory to merge changes into; '.' by default.
2665
If true, this_dir must have no uncommitted changes before the
2667
ignore_zero - If true, suppress the "zero conflicts" message when
2668
there are no conflicts; should be set when doing something we expect
2669
to complete perfectly.
2670
file_list - If supplied, merge only changes to selected files.
2672
All available ancestors of other_revision and base_revision are
2673
automatically pulled into the branch.
2675
The revno may be -1 to indicate the last revision on the branch, which is
2678
This function is intended for use from the command line; programmatic
2679
clients might prefer to call merge.merge_inner(), which has less magic
2682
from bzrlib.merge import Merger
2683
if this_dir is None:
2685
this_tree = WorkingTree.open_containing(this_dir)[0]
2686
if show_base and not merge_type is Merge3Merger:
2687
raise BzrCommandError("Show-base is not supported for this merge"
2688
" type. %s" % merge_type)
2689
if reprocess and not merge_type.supports_reprocess:
2690
raise BzrCommandError("Conflict reduction is not supported for merge"
2691
" type %s." % merge_type)
2692
if reprocess and show_base:
2693
raise BzrCommandError("Cannot do conflict reduction and show base.")
2695
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2696
merger.pp = ProgressPhase("Merge phase", 5, pb)
2697
merger.pp.next_phase()
2698
merger.check_basis(check_clean)
2699
merger.set_other(other_revision)
2700
merger.pp.next_phase()
2701
merger.set_base(base_revision)
2702
if merger.base_rev_id == merger.other_rev_id:
2703
note('Nothing to do.')
2705
merger.backup_files = backup_files
2706
merger.merge_type = merge_type
2707
merger.set_interesting_files(file_list)
2708
merger.show_base = show_base
2709
merger.reprocess = reprocess
2710
conflicts = merger.do_merge()
2711
if file_list is None:
2712
merger.set_pending()
2718
# these get imported and then picked up by the scan for cmd_*
2719
# TODO: Some more consistent way to split command definitions across files;
2720
# we do need to load at least some information about them to know of
2721
# aliases. ideally we would avoid loading the implementation until the
2722
# details were needed.
2723
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2724
from bzrlib.bundle.commands import cmd_bundle_revisions
2725
from bzrlib.sign_my_commits import cmd_sign_my_commits
2726
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2727
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
