13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""builtin bzr commands"""
19
from __future__ import absolute_import
25
from bzrlib import lazy_import
26
lazy_import.lazy_import(globals(), """
33
27
from bzrlib import (
40
config as _mod_config,
50
revision as _mod_revision,
59
from bzrlib.branch import Branch
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
60
44
from bzrlib.conflicts import ConflictList
61
from bzrlib.transport import memory
62
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
63
from bzrlib.smtp_connection import SMTPConnection
45
from bzrlib.commands import Command, display_command
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
47
NotBranchError, DivergedBranches, NotConflicted,
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
54
from bzrlib.revisionspec import RevisionSpec
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
64
57
from bzrlib.workingtree import WorkingTree
65
from bzrlib.i18n import gettext, ngettext
68
from bzrlib.commands import (
70
builtin_command_registry,
73
from bzrlib.option import (
80
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
86
def _get_branch_location(control_dir, possible_transports=None):
87
"""Return location of branch for this control dir."""
89
target = control_dir.get_branch_reference()
90
except errors.NotBranchError:
91
return control_dir.root_transport.base
92
if target is not None:
94
this_branch = control_dir.open_branch(
95
possible_transports=possible_transports)
96
# This may be a heavy checkout, where we want the master branch
97
master_location = this_branch.get_bound_location()
98
if master_location is not None:
99
return master_location
100
# If not, use a local sibling
101
return this_branch.base
104
def _is_colocated(control_dir, possible_transports=None):
105
"""Check if the branch in control_dir is colocated.
107
:param control_dir: Control directory
108
:return: Tuple with boolean indicating whether the branch is colocated
109
and the full URL to the actual branch
111
# This path is meant to be relative to the existing branch
112
this_url = _get_branch_location(control_dir,
113
possible_transports=possible_transports)
114
# Perhaps the target control dir supports colocated branches?
116
root = controldir.ControlDir.open(this_url,
117
possible_transports=possible_transports)
118
except errors.NotBranchError:
119
return (False, this_url)
122
wt = control_dir.open_workingtree()
123
except (errors.NoWorkingTree, errors.NotLocalUrl):
124
return (False, this_url)
127
root._format.colocated_branches and
128
control_dir.control_url == root.control_url,
132
def lookup_new_sibling_branch(control_dir, location, possible_transports=None):
133
"""Lookup the location for a new sibling branch.
135
:param control_dir: Control directory to find sibling branches from
136
:param location: Name of the new branch
137
:return: Full location to the new branch
139
location = directory_service.directories.dereference(location)
140
if '/' not in location and '\\' not in location:
141
(colocated, this_url) = _is_colocated(control_dir, possible_transports)
144
return urlutils.join_segment_parameters(this_url,
145
{"branch": urlutils.escape(location)})
147
return urlutils.join(this_url, '..', urlutils.escape(location))
151
def open_sibling_branch(control_dir, location, possible_transports=None):
152
"""Open a branch, possibly a sibling of another.
154
:param control_dir: Control directory relative to which to lookup the
156
:param location: Location to look up
157
:return: branch to open
160
# Perhaps it's a colocated branch?
161
return control_dir.open_branch(location,
162
possible_transports=possible_transports)
163
except (errors.NotBranchError, errors.NoColocatedBranchSupport):
164
this_url = _get_branch_location(control_dir)
167
this_url, '..', urlutils.escape(location)))
170
def open_nearby_branch(near=None, location=None, possible_transports=None):
171
"""Open a nearby branch.
173
:param near: Optional location of container from which to open branch
174
:param location: Location of the branch
175
:return: Branch instance
181
return Branch.open(location,
182
possible_transports=possible_transports)
183
except errors.NotBranchError:
185
cdir = controldir.ControlDir.open(near,
186
possible_transports=possible_transports)
187
return open_sibling_branch(cdir, location,
188
possible_transports=possible_transports)
191
def iter_sibling_branches(control_dir, possible_transports=None):
192
"""Iterate over the siblings of a branch.
194
:param control_dir: Control directory for which to look up the siblings
195
:return: Iterator over tuples with branch name and branch object
199
reference = control_dir.get_branch_reference()
200
except errors.NotBranchError:
201
# There is no active branch, just return the colocated branches.
202
for name, branch in control_dir.get_branches().iteritems():
205
if reference is not None:
206
ref_branch = Branch.open(reference,
207
possible_transports=possible_transports)
210
if ref_branch is None or ref_branch.name:
211
if ref_branch is not None:
212
control_dir = ref_branch.bzrdir
213
for name, branch in control_dir.get_branches().iteritems():
216
repo = ref_branch.bzrdir.find_repository()
217
for branch in repo.find_branches(using=True):
218
name = urlutils.relative_url(repo.user_url,
219
branch.user_url).rstrip("/")
223
def tree_files_for_add(file_list):
225
Return a tree and list of absolute paths from a file list.
227
Similar to tree_files, but add handles files a bit differently, so it a
228
custom implementation. In particular, MutableTreeTree.smart_add expects
229
absolute paths, which it immediately converts to relative paths.
231
# FIXME Would be nice to just return the relative paths like
232
# internal_tree_files does, but there are a large number of unit tests
233
# that assume the current interface to mutabletree.smart_add
235
tree, relpath = WorkingTree.open_containing(file_list[0])
236
if tree.supports_views():
237
view_files = tree.views.lookup_view()
239
for filename in file_list:
240
if not osutils.is_inside_any(view_files, filename):
241
raise errors.FileOutsideView(filename, view_files)
242
file_list = file_list[:]
243
file_list[0] = tree.abspath(relpath)
245
tree = WorkingTree.open_containing(u'.')[0]
246
if tree.supports_views():
247
view_files = tree.views.lookup_view()
249
file_list = view_files
250
view_str = views.view_display_str(view_files)
251
note(gettext("Ignoring files outside view. View is %s") % view_str)
252
return tree, file_list
255
def _get_one_revision(command_name, revisions):
256
if revisions is None:
258
if len(revisions) != 1:
259
raise errors.BzrCommandError(gettext(
260
'bzr %s --revision takes exactly one revision identifier') % (
265
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
266
"""Get a revision tree. Not suitable for commands that change the tree.
268
Specifically, the basis tree in dirstate trees is coupled to the dirstate
269
and doing a commit/uncommit/pull will at best fail due to changing the
272
If tree is passed in, it should be already locked, for lifetime management
273
of the trees internal cached state.
277
if revisions is None:
279
rev_tree = tree.basis_tree()
281
rev_tree = branch.basis_tree()
283
revision = _get_one_revision(command_name, revisions)
284
rev_tree = revision.as_tree(branch)
288
def _get_view_info_for_change_reporter(tree):
289
"""Get the view information from a tree for change reporting."""
292
current_view = tree.views.get_view_info()[0]
293
if current_view is not None:
294
view_info = (current_view, tree.views.lookup_view())
295
except errors.ViewsNotSupported:
300
def _open_directory_or_containing_tree_or_branch(filename, directory):
301
"""Open the tree or branch containing the specified file, unless
302
the --directory option is used to specify a different branch."""
303
if directory is not None:
304
return (None, Branch.open(directory), filename)
305
return controldir.ControlDir.open_containing_tree_or_branch(filename)
60
def tree_files(file_list, default_branch=u'.'):
62
return internal_tree_files(file_list, default_branch)
63
except FileInWrongBranch, e:
64
raise BzrCommandError("%s is not in the same branch as %s" %
65
(e.path, file_list[0]))
68
# XXX: Bad function name; should possibly also be a class method of
69
# WorkingTree rather than a function.
70
def internal_tree_files(file_list, default_branch=u'.'):
71
"""Convert command-line paths to a WorkingTree and relative paths.
73
This is typically used for command-line processors that take one or
74
more filenames, and infer the workingtree that contains them.
76
The filenames given are not required to exist.
78
:param file_list: Filenames to convert.
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
82
:return: workingtree, [relative_paths]
84
if file_list is None or len(file_list) == 0:
85
return WorkingTree.open_containing(default_branch)[0], file_list
86
tree = WorkingTree.open_containing(file_list[0])[0]
88
for filename in file_list:
90
new_list.append(tree.relpath(filename))
91
except errors.PathNotChild:
92
raise FileInWrongBranch(tree.branch, filename)
96
def get_format_type(typestring):
97
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
100
if typestring == "default":
101
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
110
if typestring == "experimental-knit2":
111
format = bzrdir.BzrDirMetaFormat1()
112
format.repository_format = repository.RepositoryFormatKnit2()
114
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
115
"metaweave and weave" % typestring
116
raise BzrCommandError(msg)
308
119
# TODO: Make sure no commands unconditionally use the working directory as a
333
144
Text has changed since the previous revision.
336
File kind has been changed (e.g. from file to directory).
339
147
Not versioned and not matching an ignore pattern.
341
Additionally for directories, symlinks and files with a changed
342
executable bit, Bazaar indicates their type using a trailing
343
character: '/', '@' or '*' respectively. These decorations can be
344
disabled using the '--no-classify' option.
346
To see ignored files use 'bzr ignored'. For details on the
149
To see ignored files use 'bzr ignored'. For details in the
347
150
changes to file texts, use 'bzr diff'.
349
Note that --short or -S gives status flags for each item, similar
350
to Subversion's status command. To get output similar to svn -q,
353
152
If no arguments are specified, the status of the entire working
354
153
directory is shown. Otherwise, only the status of the specified
355
154
files or directories is reported. If a directory is given, status
356
155
is reported for everything inside that directory.
358
Before merges are committed, the pending merge tip revisions are
359
shown. To see all pending merge revisions, use the -v option.
360
To skip the display of pending merge information altogether, use
361
the no-pending option or specify a file/directory.
363
To compare the working directory to a specific revision, pass a
364
single revision to the revision argument.
366
To see which files have changed in a specific revision, or between
367
two revisions, pass a revision range to the revision argument.
368
This will produce the same results as calling 'bzr diff --summarize'.
157
If a revision argument is given, the status is calculated against
158
that revision, or between two revisions if two are provided.
371
# TODO: --no-recurse/-N, --recurse options
161
# TODO: --no-recurse, --recurse options
373
163
takes_args = ['file*']
374
takes_options = ['show-ids', 'revision', 'change', 'verbose',
375
Option('short', help='Use short status indicators.',
377
Option('versioned', help='Only show versioned files.',
379
Option('no-pending', help='Don\'t show pending merges.',
381
Option('no-classify',
382
help='Do not mark object type using indicator.',
164
takes_options = ['show-ids', 'revision']
385
165
aliases = ['st', 'stat']
387
167
encoding_type = 'replace'
388
_see_also = ['diff', 'revert', 'status-flags']
391
def run(self, show_ids=False, file_list=None, revision=None, short=False,
392
versioned=False, no_pending=False, verbose=False,
170
def run(self, show_ids=False, file_list=None, revision=None):
394
171
from bzrlib.status import show_tree_status
396
if revision and len(revision) > 2:
397
raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
398
' one or two revision specifiers'))
400
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
401
# Avoid asking for specific files when that is not needed.
402
if relfile_list == ['']:
404
# Don't disable pending merges for full trees other than '.'.
405
if file_list == ['.']:
407
# A specific path within a tree was given.
408
elif relfile_list is not None:
173
tree, file_list = tree_files(file_list)
410
175
show_tree_status(tree, show_ids=show_ids,
411
specific_files=relfile_list, revision=revision,
412
to_file=self.outf, short=short, versioned=versioned,
413
show_pending=(not no_pending), verbose=verbose,
414
classify=not no_classify)
176
specific_files=file_list, revision=revision,
417
180
class cmd_cat_revision(Command):
418
__doc__ = """Write out metadata for a revision.
181
"""Write out metadata for a revision.
420
183
The revision to print can either be specified by a specific
421
184
revision identifier, or you can use --revision.
425
188
takes_args = ['revision_id?']
426
takes_options = ['directory', 'revision']
189
takes_options = ['revision']
427
190
# cat-revision is more for frontends so should be exact
428
191
encoding = 'strict'
430
def print_revision(self, revisions, revid):
431
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
432
record = stream.next()
433
if record.storage_kind == 'absent':
434
raise errors.NoSuchRevision(revisions, revid)
435
revtext = record.get_bytes_as('fulltext')
436
self.outf.write(revtext.decode('utf-8'))
439
def run(self, revision_id=None, revision=None, directory=u'.'):
194
def run(self, revision_id=None, revision=None):
440
196
if revision_id is not None and revision is not None:
441
raise errors.BzrCommandError(gettext('You can only supply one of'
442
' revision_id or --revision'))
197
raise BzrCommandError('You can only supply one of revision_id or --revision')
443
198
if revision_id is None and revision is None:
444
raise errors.BzrCommandError(gettext('You must supply either'
445
' --revision or a revision_id'))
447
b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]
449
revisions = b.repository.revisions
450
if revisions is None:
451
raise errors.BzrCommandError(gettext('Repository %r does not support '
452
'access to raw revision texts'))
454
b.repository.lock_read()
456
# TODO: jam 20060112 should cat-revision always output utf-8?
457
if revision_id is not None:
458
revision_id = osutils.safe_revision_id(revision_id, warn=False)
460
self.print_revision(revisions, revision_id)
461
except errors.NoSuchRevision:
462
msg = gettext("The repository {0} contains no revision {1}.").format(
463
b.repository.base, revision_id)
464
raise errors.BzrCommandError(msg)
465
elif revision is not None:
468
raise errors.BzrCommandError(
469
gettext('You cannot specify a NULL revision.'))
470
rev_id = rev.as_revision_id(b)
471
self.print_revision(revisions, rev_id)
473
b.repository.unlock()
476
class cmd_dump_btree(Command):
477
__doc__ = """Dump the contents of a btree index file to stdout.
479
PATH is a btree index file, it can be any URL. This includes things like
480
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
482
By default, the tuples stored in the index file will be displayed. With
483
--raw, we will uncompress the pages, but otherwise display the raw bytes
487
# TODO: Do we want to dump the internal nodes as well?
488
# TODO: It would be nice to be able to dump the un-parsed information,
489
# rather than only going through iter_all_entries. However, this is
490
# good enough for a start
492
encoding_type = 'exact'
493
takes_args = ['path']
494
takes_options = [Option('raw', help='Write the uncompressed bytes out,'
495
' rather than the parsed tuples.'),
498
def run(self, path, raw=False):
499
dirname, basename = osutils.split(path)
500
t = transport.get_transport(dirname)
502
self._dump_raw_bytes(t, basename)
504
self._dump_entries(t, basename)
506
def _get_index_and_bytes(self, trans, basename):
507
"""Create a BTreeGraphIndex and raw bytes."""
508
bt = btree_index.BTreeGraphIndex(trans, basename, None)
509
bytes = trans.get_bytes(basename)
510
bt._file = cStringIO.StringIO(bytes)
511
bt._size = len(bytes)
514
def _dump_raw_bytes(self, trans, basename):
517
# We need to parse at least the root node.
518
# This is because the first page of every row starts with an
519
# uncompressed header.
520
bt, bytes = self._get_index_and_bytes(trans, basename)
521
for page_idx, page_start in enumerate(xrange(0, len(bytes),
522
btree_index._PAGE_SIZE)):
523
page_end = min(page_start + btree_index._PAGE_SIZE, len(bytes))
524
page_bytes = bytes[page_start:page_end]
526
self.outf.write('Root node:\n')
527
header_end, data = bt._parse_header_from_bytes(page_bytes)
528
self.outf.write(page_bytes[:header_end])
530
self.outf.write('\nPage %d\n' % (page_idx,))
531
if len(page_bytes) == 0:
532
self.outf.write('(empty)\n');
534
decomp_bytes = zlib.decompress(page_bytes)
535
self.outf.write(decomp_bytes)
536
self.outf.write('\n')
538
def _dump_entries(self, trans, basename):
540
st = trans.stat(basename)
541
except errors.TransportNotPossible:
542
# We can't stat, so we'll fake it because we have to do the 'get()'
544
bt, _ = self._get_index_and_bytes(trans, basename)
546
bt = btree_index.BTreeGraphIndex(trans, basename, st.st_size)
547
for node in bt.iter_all_entries():
548
# Node is made up of:
549
# (index, key, value, [references])
553
refs_as_tuples = None
555
refs_as_tuples = static_tuple.as_tuples(refs)
556
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
557
self.outf.write('%s\n' % (as_tuple,))
560
class cmd_remove_tree(Command):
561
__doc__ = """Remove the working tree from a given branch/checkout.
563
Since a lightweight checkout is little more than a working tree
564
this will refuse to run against one.
566
To re-create the working tree, use "bzr checkout".
568
_see_also = ['checkout', 'working-trees']
569
takes_args = ['location*']
572
help='Remove the working tree even if it has '
573
'uncommitted or shelved changes.'),
576
def run(self, location_list, force=False):
577
if not location_list:
580
for location in location_list:
581
d = controldir.ControlDir.open(location)
584
working = d.open_workingtree()
585
except errors.NoWorkingTree:
586
raise errors.BzrCommandError(gettext("No working tree to remove"))
587
except errors.NotLocalUrl:
588
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
589
" of a remote path"))
591
if (working.has_changes()):
592
raise errors.UncommittedChanges(working)
593
if working.get_shelf_manager().last_shelf() is not None:
594
raise errors.ShelvedChanges(working)
596
if working.user_url != working.branch.user_url:
597
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
598
" from a lightweight checkout"))
600
d.destroy_workingtree()
603
class cmd_repair_workingtree(Command):
604
__doc__ = """Reset the working tree state file.
606
This is not meant to be used normally, but more as a way to recover from
607
filesystem corruption, etc. This rebuilds the working inventory back to a
608
'known good' state. Any new modifications (adding a file, renaming, etc)
609
will be lost, though modified files will still be detected as such.
611
Most users will want something more like "bzr revert" or "bzr update"
612
unless the state file has become corrupted.
614
By default this attempts to recover the current state by looking at the
615
headers of the state file. If the state file is too corrupted to even do
616
that, you can supply --revision to force the state of the tree.
619
takes_options = ['revision', 'directory',
621
help='Reset the tree even if it doesn\'t appear to be'
626
def run(self, revision=None, directory='.', force=False):
627
tree, _ = WorkingTree.open_containing(directory)
628
self.add_cleanup(tree.lock_tree_write().unlock)
632
except errors.BzrError:
633
pass # There seems to be a real error here, so we'll reset
636
raise errors.BzrCommandError(gettext(
637
'The tree does not appear to be corrupt. You probably'
638
' want "bzr revert" instead. Use "--force" if you are'
639
' sure you want to reset the working tree.'))
643
revision_ids = [r.as_revision_id(tree.branch) for r in revision]
645
tree.reset_state(revision_ids)
646
except errors.BzrError, e:
647
if revision_ids is None:
648
extra = (gettext(', the header appears corrupt, try passing -r -1'
649
' to set the state to the last commit'))
652
raise errors.BzrCommandError(gettext('failed to reset the tree state{0}').format(extra))
199
raise BzrCommandError('You must supply either --revision or a revision_id')
200
b = WorkingTree.open_containing(u'.')[0].branch
202
# TODO: jam 20060112 should cat-revision always output utf-8?
203
if revision_id is not None:
204
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
205
elif revision is not None:
208
raise BzrCommandError('You cannot specify a NULL revision.')
209
revno, rev_id = rev.in_history(b)
210
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
655
213
class cmd_revno(Command):
656
__doc__ = """Show current revision number.
214
"""Show current revision number.
658
216
This is equal to the number of revisions on this branch.
662
219
takes_args = ['location?']
664
Option('tree', help='Show revno of working tree.'),
669
def run(self, tree=False, location=u'.', revision=None):
670
if revision is not None and tree:
671
raise errors.BzrCommandError(gettext("--tree and --revision can "
672
"not be used together"))
676
wt = WorkingTree.open_containing(location)[0]
677
self.add_cleanup(wt.lock_read().unlock)
678
except (errors.NoWorkingTree, errors.NotLocalUrl):
679
raise errors.NoWorkingTree(location)
681
revid = wt.last_revision()
683
b = Branch.open_containing(location)[0]
684
self.add_cleanup(b.lock_read().unlock)
686
if len(revision) != 1:
687
raise errors.BzrCommandError(gettext(
688
"Tags can only be placed on a single revision, "
690
revid = revision[0].as_revision_id(b)
692
revid = b.last_revision()
694
revno_t = b.revision_id_to_dotted_revno(revid)
695
except errors.NoSuchRevision:
697
revno = ".".join(str(n) for n in revno_t)
699
self.outf.write(revno + '\n')
222
def run(self, location=u'.'):
223
self.outf.write(str(Branch.open_containing(location)[0].revno()))
224
self.outf.write('\n')
702
227
class cmd_revision_info(Command):
703
__doc__ = """Show revision number and revision id for a given revision identifier.
228
"""Show revision number and revision id for a given revision identifier.
706
231
takes_args = ['revision_info*']
709
custom_help('directory',
710
help='Branch to examine, '
711
'rather than the one containing the working directory.'),
712
Option('tree', help='Show revno of working tree.'),
232
takes_options = ['revision']
716
def run(self, revision=None, directory=u'.', tree=False,
717
revision_info_list=[]):
235
def run(self, revision=None, revision_info_list=[]):
720
wt = WorkingTree.open_containing(directory)[0]
722
self.add_cleanup(wt.lock_read().unlock)
723
except (errors.NoWorkingTree, errors.NotLocalUrl):
725
b = Branch.open_containing(directory)[0]
726
self.add_cleanup(b.lock_read().unlock)
728
238
if revision is not None:
729
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
239
revs.extend(revision)
730
240
if revision_info_list is not None:
731
for rev_str in revision_info_list:
732
rev_spec = RevisionSpec.from_string(rev_str)
733
revision_ids.append(rev_spec.as_revision_id(b))
734
# No arguments supplied, default to the last revision
735
if len(revision_ids) == 0:
738
raise errors.NoWorkingTree(directory)
739
revision_ids.append(wt.last_revision())
241
for rev in revision_info_list:
242
revs.append(RevisionSpec.from_string(rev))
244
raise BzrCommandError('You must supply a revision identifier')
246
b = WorkingTree.open_containing(u'.')[0].branch
249
revinfo = rev.in_history(b)
250
if revinfo.revno is None:
251
print ' %s' % revinfo.rev_id
741
revision_ids.append(b.last_revision())
745
for revision_id in revision_ids:
747
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
748
revno = '.'.join(str(i) for i in dotted_revno)
749
except errors.NoSuchRevision:
751
maxlen = max(maxlen, len(revno))
752
revinfos.append([revno, revision_id])
756
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
253
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
759
256
class cmd_add(Command):
760
__doc__ = """Add specified files or directories.
257
"""Add specified files or directories.
762
259
In non-recursive mode, all the named items are added, regardless
763
260
of whether they were previously ignored. A warning is given if
975
393
class cmd_mv(Command):
976
__doc__ = """Move or rename a file.
394
"""Move or rename a file.
979
397
bzr mv OLDNAME NEWNAME
981
398
bzr mv SOURCE... DESTINATION
983
400
If the last argument is a versioned directory, all the other names
984
401
are moved into it. Otherwise, there must be exactly two arguments
985
and the file is changed to a new name.
987
If OLDNAME does not exist on the filesystem but is versioned and
988
NEWNAME does exist on the filesystem but is not versioned, mv
989
assumes that the file has been manually moved and only updates
990
its internal inventory to reflect that change.
991
The same is valid when moving many SOURCE files to a DESTINATION.
402
and the file is changed to a new name, which must not already exist.
993
404
Files cannot be moved between branches.
996
407
takes_args = ['names*']
997
takes_options = [Option("after", help="Move only the bzr identifier"
998
" of the file, because the file has already been moved."),
999
Option('auto', help='Automatically guess renames.'),
1000
Option('dry-run', help='Avoid making changes when guessing renames.'),
1002
408
aliases = ['move', 'rename']
1003
409
encoding_type = 'replace'
1005
def run(self, names_list, after=False, auto=False, dry_run=False):
1007
return self.run_auto(names_list, after, dry_run)
1009
raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
411
def run(self, names_list):
1010
412
if names_list is None:
1012
415
if len(names_list) < 2:
1013
raise errors.BzrCommandError(gettext("missing file argument"))
1014
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
1015
for file_name in rel_names[0:-1]:
1017
raise errors.BzrCommandError(gettext("can not move root of branch"))
1018
self.add_cleanup(tree.lock_tree_write().unlock)
1019
self._run(tree, names_list, rel_names, after)
1021
def run_auto(self, names_list, after, dry_run):
1022
if names_list is not None and len(names_list) > 1:
1023
raise errors.BzrCommandError(gettext('Only one path may be specified to'
1026
raise errors.BzrCommandError(gettext('--after cannot be specified with'
1028
work_tree, file_list = WorkingTree.open_containing_paths(
1029
names_list, default_directory='.')
1030
self.add_cleanup(work_tree.lock_tree_write().unlock)
1031
rename_map.RenameMap.guess_renames(work_tree, dry_run)
1033
def _run(self, tree, names_list, rel_names, after):
1034
into_existing = osutils.isdir(names_list[-1])
1035
if into_existing and len(names_list) == 2:
1037
# a. case-insensitive filesystem and change case of dir
1038
# b. move directory after the fact (if the source used to be
1039
# a directory, but now doesn't exist in the working tree
1040
# and the target is an existing directory, just rename it)
1041
if (not tree.case_sensitive
1042
and rel_names[0].lower() == rel_names[1].lower()):
1043
into_existing = False
1045
# 'fix' the case of a potential 'from'
1046
from_id = tree.path2id(
1047
tree.get_canonical_inventory_path(rel_names[0]))
1048
if (not osutils.lexists(names_list[0]) and
1049
from_id and tree.stored_kind(from_id) == "directory"):
1050
into_existing = False
416
raise BzrCommandError("missing file argument")
417
tree, rel_names = tree_files(names_list)
419
if os.path.isdir(names_list[-1]):
1053
420
# move into existing directory
1054
# All entries reference existing inventory items, so fix them up
1055
# for cicp file-systems.
1056
rel_names = tree.get_canonical_inventory_paths(rel_names)
1057
for src, dest in tree.move(rel_names[:-1], rel_names[-1], after=after):
1059
self.outf.write("%s => %s\n" % (src, dest))
421
for pair in tree.move(rel_names[:-1], rel_names[-1]):
422
self.outf.write("%s => %s\n" % pair)
1061
424
if len(names_list) != 2:
1062
raise errors.BzrCommandError(gettext('to mv multiple files the'
1063
' destination must be a versioned'
1066
# for cicp file-systems: the src references an existing inventory
1068
src = tree.get_canonical_inventory_path(rel_names[0])
1069
# Find the canonical version of the destination: In all cases, the
1070
# parent of the target must be in the inventory, so we fetch the
1071
# canonical version from there (we do not always *use* the
1072
# canonicalized tail portion - we may be attempting to rename the
1074
canon_dest = tree.get_canonical_inventory_path(rel_names[1])
1075
dest_parent = osutils.dirname(canon_dest)
1076
spec_tail = osutils.basename(rel_names[1])
1077
# For a CICP file-system, we need to avoid creating 2 inventory
1078
# entries that differ only by case. So regardless of the case
1079
# we *want* to use (ie, specified by the user or the file-system),
1080
# we must always choose to use the case of any existing inventory
1081
# items. The only exception to this is when we are attempting a
1082
# case-only rename (ie, canonical versions of src and dest are
1084
dest_id = tree.path2id(canon_dest)
1085
if dest_id is None or tree.path2id(src) == dest_id:
1086
# No existing item we care about, so work out what case we
1087
# are actually going to use.
1089
# If 'after' is specified, the tail must refer to a file on disk.
1091
dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
1093
# pathjoin with an empty tail adds a slash, which breaks
1095
dest_parent_fq = tree.basedir
1097
dest_tail = osutils.canonical_relpath(
1099
osutils.pathjoin(dest_parent_fq, spec_tail))
1101
# not 'after', so case as specified is used
1102
dest_tail = spec_tail
1104
# Use the existing item so 'mv' fails with AlreadyVersioned.
1105
dest_tail = os.path.basename(canon_dest)
1106
dest = osutils.pathjoin(dest_parent, dest_tail)
1107
mutter("attempting to move %s => %s", src, dest)
1108
tree.rename_one(src, dest, after=after)
1110
self.outf.write("%s => %s\n" % (src, dest))
425
raise BzrCommandError('to mv multiple files the destination '
426
'must be a versioned directory')
427
tree.rename_one(rel_names[0], rel_names[1])
428
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
1113
431
class cmd_pull(Command):
1114
__doc__ = """Turn this branch into a mirror of another branch.
432
"""Turn this branch into a mirror of another branch.
1116
By default, this command only works on branches that have not diverged.
1117
Branches are considered diverged if the destination branch's most recent
1118
commit is one that has not been merged (directly or indirectly) into the
434
This command only works on branches that have not diverged. Branches are
435
considered diverged if the destination branch's most recent commit is one
436
that has not been merged (directly or indirectly) into the parent.
1121
438
If branches have diverged, you can use 'bzr merge' to integrate the changes
1122
439
from one into the other. Once one branch has merged, the other should
1123
440
be able to pull it again.
1125
If you want to replace your local changes and just want your branch to
1126
match the remote one, use pull --overwrite. This will work even if the two
1127
branches have diverged.
1129
If there is no default location set, the first pull will set it (use
1130
--no-remember to avoid setting it). After that, you can omit the
1131
location to use the default. To change the default, use --remember. The
1132
value will only be saved if the remote location can be accessed.
1134
The --verbose option will display the revisions pulled using the log_format
1135
configuration option. You can use a different format by overriding it with
1136
-Olog_format=<other_format>.
1138
Note: The location can be specified either in the form of a branch,
1139
or in the form of a path to a file containing a merge directive generated
442
If you want to forget your local changes and just update your branch to
443
match the remote one, use pull --overwrite.
445
If there is no default location set, the first pull will set it. After
446
that, you can omit the location to use the default. To change the
447
default, use --remember. The value will only be saved if the remote
448
location can be accessed.
1143
_see_also = ['push', 'update', 'status-flags', 'send']
1144
takes_options = ['remember', 'overwrite', 'revision',
1145
custom_help('verbose',
1146
help='Show logs of pulled revisions.'),
1147
custom_help('directory',
1148
help='Branch to pull into, '
1149
'rather than the one containing the working directory.'),
1151
help="Perform a local pull in a bound "
1152
"branch. Local pulls are not applied to "
1153
"the master branch."
1156
help="Show base revision text in conflicts."),
1157
Option('overwrite-tags',
1158
help="Overwrite tags only."),
451
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
1160
452
takes_args = ['location?']
1161
453
encoding_type = 'replace'
1163
def run(self, location=None, remember=None, overwrite=False,
1164
revision=None, verbose=False,
1165
directory=None, local=False,
1166
show_base=False, overwrite_tags=False):
1169
overwrite = ["history", "tags"]
1170
elif overwrite_tags:
1171
overwrite = ["tags"]
455
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
1174
456
# FIXME: too much stuff is in the command class
1177
if directory is None:
1180
tree_to = WorkingTree.open_containing(directory)[0]
458
tree_to = WorkingTree.open_containing(u'.')[0]
1181
459
branch_to = tree_to.branch
1182
self.add_cleanup(tree_to.lock_write().unlock)
1183
except errors.NoWorkingTree:
460
except NoWorkingTree:
1185
branch_to = Branch.open_containing(directory)[0]
1186
self.add_cleanup(branch_to.lock_write().unlock)
1188
if tree_to is None and show_base:
1189
raise errors.BzrCommandError(gettext("Need working tree for --show-base."))
1191
if local and not branch_to.get_bound_location():
1192
raise errors.LocalRequiresBoundBranch()
1194
possible_transports = []
462
branch_to = Branch.open_containing(u'.')[0]
1195
465
if location is not None:
1197
mergeable = bundle.read_mergeable_from_url(location,
1198
possible_transports=possible_transports)
1199
except errors.NotABundle:
467
reader = bundle.read_bundle_from_url(location)
469
pass # Continue on considering this url a Branch
1202
471
stored_loc = branch_to.get_parent()
1203
472
if location is None:
1204
473
if stored_loc is None:
1205
raise errors.BzrCommandError(gettext("No pull location known or"
474
raise BzrCommandError("No pull location known or specified.")
1208
476
display_url = urlutils.unescape_for_display(stored_loc,
1209
477
self.outf.encoding)
1211
self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
478
self.outf.write("Using saved location: %s\n" % display_url)
1212
479
location = stored_loc
1214
revision = _get_one_revision('pull', revision)
1215
if mergeable is not None:
1216
if revision is not None:
1217
raise errors.BzrCommandError(gettext(
1218
'Cannot use -r with merge directives or bundles'))
1219
mergeable.install_revisions(branch_to.repository)
1220
base_revision_id, revision_id, verified = \
1221
mergeable.get_merge_request(branch_to.repository)
482
if reader is not None:
483
install_bundle(branch_to.repository, reader)
1222
484
branch_from = branch_to
1224
branch_from = Branch.open(location,
1225
possible_transports=possible_transports)
1226
self.add_cleanup(branch_from.lock_read().unlock)
1227
# Remembers if asked explicitly or no previous location is set
1229
or (remember is None and branch_to.get_parent() is None)):
1230
# FIXME: This shouldn't be done before the pull
1231
# succeeds... -- vila 2012-01-02
486
branch_from = Branch.open(location)
488
if branch_to.get_parent() is None or remember:
1232
489
branch_to.set_parent(branch_from.base)
1234
if revision is not None:
1235
revision_id = revision.as_revision_id(branch_from)
493
if reader is not None:
494
rev_id = reader.target
495
elif len(revision) == 1:
496
rev_id = revision[0].in_history(branch_from).rev_id
498
raise BzrCommandError('bzr pull --revision takes one value.')
500
old_rh = branch_to.revision_history()
1237
501
if tree_to is not None:
1238
view_info = _get_view_info_for_change_reporter(tree_to)
1239
change_reporter = delta._ChangeReporter(
1240
unversioned_filter=tree_to.is_ignored,
1241
view_info=view_info)
1242
result = tree_to.pull(
1243
branch_from, overwrite, revision_id, change_reporter,
1244
local=local, show_base=show_base)
502
count = tree_to.pull(branch_from, overwrite, rev_id)
1246
result = branch_to.pull(
1247
branch_from, overwrite, revision_id, local=local)
504
count = branch_to.pull(branch_from, overwrite, rev_id)
505
note('%d revision(s) pulled.' % (count,))
1249
result.report(self.outf)
1250
if verbose and result.old_revid != result.new_revid:
1251
log.show_branch_change(
1252
branch_to, self.outf, result.old_revno,
1254
if getattr(result, 'tag_conflicts', None):
508
new_rh = branch_to.revision_history()
511
from bzrlib.log import show_changed_revisions
512
show_changed_revisions(branch_to, old_rh, new_rh,
1260
516
class cmd_push(Command):
1261
__doc__ = """Update a mirror of this branch.
517
"""Update a mirror of this branch.
1263
519
The target branch will not have its working tree populated because this
1264
520
is both expensive, and is not supported on remote file systems.
1266
522
Some smart servers or protocols *may* put the working tree in place in
1273
529
If branches have diverged, you can use 'bzr push --overwrite' to replace
1274
530
the other branch completely, discarding its unmerged changes.
1276
532
If you want to ensure you have the different changes in the other branch,
1277
533
do a merge (see bzr help merge) from the other branch, and commit that.
1278
534
After that you will be able to do a push without '--overwrite'.
1280
If there is no default push location set, the first push will set it (use
1281
--no-remember to avoid setting it). After that, you can omit the
1282
location to use the default. To change the default, use --remember. The
1283
value will only be saved if the remote location can be accessed.
1285
The --verbose option will display the revisions pushed using the log_format
1286
configuration option. You can use a different format by overriding it with
1287
-Olog_format=<other_format>.
536
If there is no default push location set, the first push will set it.
537
After that, you can omit the location to use the default. To change the
538
default, use --remember. The value will only be saved if the remote
539
location can be accessed.
1290
_see_also = ['pull', 'update', 'working-trees']
1291
takes_options = ['remember', 'overwrite', 'verbose', 'revision',
1292
Option('create-prefix',
1293
help='Create the path leading up to the branch '
1294
'if it does not already exist.'),
1295
custom_help('directory',
1296
help='Branch to push from, '
1297
'rather than the one containing the working directory.'),
1298
Option('use-existing-dir',
1299
help='By default push will fail if the target'
1300
' directory exists, but does not already'
1301
' have a control directory. This flag will'
1302
' allow push to proceed.'),
1304
help='Create a stacked branch that references the public location '
1305
'of the parent branch.'),
1306
Option('stacked-on',
1307
help='Create a stacked branch that refers to another branch '
1308
'for the commit history. Only the work not present in the '
1309
'referenced branch is included in the branch created.',
1312
help='Refuse to push if there are uncommitted changes in'
1313
' the working tree, --no-strict disables the check.'),
1315
help="Don't populate the working tree, even for protocols"
1316
" that support it."),
1317
Option('overwrite-tags',
1318
help="Overwrite tags only."),
542
takes_options = ['remember', 'overwrite', 'verbose',
543
Option('create-prefix',
544
help='Create the path leading up to the branch '
545
'if it does not already exist')]
1320
546
takes_args = ['location?']
1321
547
encoding_type = 'replace'
1323
def run(self, location=None, remember=None, overwrite=False,
1324
create_prefix=False, verbose=False, revision=None,
1325
use_existing_dir=False, directory=None, stacked_on=None,
1326
stacked=False, strict=None, no_tree=False,
1327
overwrite_tags=False):
1328
from bzrlib.push import _show_push_branch
1331
overwrite = ["history", "tags"]
1332
elif overwrite_tags:
1333
overwrite = ["tags"]
1337
if directory is None:
1339
# Get the source branch
1341
_unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1342
# Get the tip's revision_id
1343
revision = _get_one_revision('push', revision)
1344
if revision is not None:
1345
revision_id = revision.in_history(br_from).rev_id
1348
if tree is not None and revision_id is None:
1349
tree.check_changed_or_out_of_date(
1350
strict, 'push_strict',
1351
more_error='Use --no-strict to force the push.',
1352
more_warning='Uncommitted changes will not be pushed.')
1353
# Get the stacked_on branch, if any
1354
if stacked_on is not None:
1355
stacked_on = urlutils.normalize_url(stacked_on)
1357
parent_url = br_from.get_parent()
1359
parent = Branch.open(parent_url)
1360
stacked_on = parent.get_public_branch()
1362
# I considered excluding non-http url's here, thus forcing
1363
# 'public' branches only, but that only works for some
1364
# users, so it's best to just depend on the user spotting an
1365
# error by the feedback given to them. RBC 20080227.
1366
stacked_on = parent_url
1368
raise errors.BzrCommandError(gettext(
1369
"Could not determine branch to refer to."))
1371
# Get the destination location
549
def run(self, location=None, remember=False, overwrite=False,
550
create_prefix=False, verbose=False):
551
# FIXME: Way too big! Put this into a function called from the
554
br_from = Branch.open_containing('.')[0]
555
stored_loc = br_from.get_push_location()
1372
556
if location is None:
1373
stored_loc = br_from.get_push_location()
1374
557
if stored_loc is None:
1375
parent_loc = br_from.get_parent()
1377
raise errors.BzrCommandError(gettext(
1378
"No push location known or specified. To push to the "
1379
"parent branch (at %s), use 'bzr push :parent'." %
1380
urlutils.unescape_for_display(parent_loc,
1381
self.outf.encoding)))
1383
raise errors.BzrCommandError(gettext(
1384
"No push location known or specified."))
558
raise BzrCommandError("No push location known or specified.")
1386
560
display_url = urlutils.unescape_for_display(stored_loc,
1387
561
self.outf.encoding)
1388
note(gettext("Using saved push location: %s") % display_url)
562
self.outf.write("Using saved location: %s\n" % display_url)
1389
563
location = stored_loc
1391
_show_push_branch(br_from, revision_id, location, self.outf,
1392
verbose=verbose, overwrite=overwrite, remember=remember,
1393
stacked_on=stacked_on, create_prefix=create_prefix,
1394
use_existing_dir=use_existing_dir, no_tree=no_tree)
565
to_transport = transport.get_transport(location)
566
location_url = to_transport.base
570
dir_to = bzrdir.BzrDir.open(location_url)
571
br_to = dir_to.open_branch()
572
except NotBranchError:
574
to_transport = to_transport.clone('..')
575
if not create_prefix:
577
relurl = to_transport.relpath(location_url)
578
mutter('creating directory %s => %s', location_url, relurl)
579
to_transport.mkdir(relurl)
581
raise BzrCommandError("Parent directory of %s "
582
"does not exist." % location)
584
current = to_transport.base
585
needed = [(to_transport, to_transport.relpath(location_url))]
588
to_transport, relpath = needed[-1]
589
to_transport.mkdir(relpath)
592
new_transport = to_transport.clone('..')
593
needed.append((new_transport,
594
new_transport.relpath(to_transport.base)))
595
if new_transport.base == to_transport.base:
596
raise BzrCommandError("Could not create "
598
dir_to = br_from.bzrdir.clone(location_url,
599
revision_id=br_from.last_revision())
600
br_to = dir_to.open_branch()
601
count = len(br_to.revision_history())
602
# We successfully created the target, remember it
603
if br_from.get_push_location() is None or remember:
604
br_from.set_push_location(br_to.base)
606
# We were able to connect to the remote location, so remember it
607
# we don't need to successfully push because of possible divergence.
608
if br_from.get_push_location() is None or remember:
609
br_from.set_push_location(br_to.base)
610
old_rh = br_to.revision_history()
613
tree_to = dir_to.open_workingtree()
614
except errors.NotLocalUrl:
615
warning('This transport does not update the working '
616
'tree of: %s' % (br_to.base,))
617
count = br_to.pull(br_from, overwrite)
618
except NoWorkingTree:
619
count = br_to.pull(br_from, overwrite)
621
count = tree_to.pull(br_from, overwrite)
622
except DivergedBranches:
623
raise BzrCommandError("These branches have diverged."
624
" Try a merge then push with overwrite.")
625
note('%d revision(s) pushed.' % (count,))
628
new_rh = br_to.revision_history()
631
from bzrlib.log import show_changed_revisions
632
show_changed_revisions(br_to, old_rh, new_rh,
1397
636
class cmd_branch(Command):
1398
__doc__ = """Create a new branch that is a copy of an existing branch.
637
"""Create a new copy of a branch.
1400
639
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1401
640
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1402
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
1403
is derived from the FROM_LOCATION by stripping a leading scheme or drive
1404
identifier, if any. For example, "branch lp:foo-bar" will attempt to
1407
642
To retrieve the branch as of a particular revision, supply the --revision
1408
643
parameter, as in "branch foo/bar -r 5".
1410
The synonyms 'clone' and 'get' for this command are deprecated.
645
--basis is to speed up branching from remote branches. When specified, it
646
copies all the file-contents, inventory and revision data from the basis
647
branch before copying anything from the remote branch.
1413
_see_also = ['checkout']
1414
649
takes_args = ['from_location', 'to_location?']
1415
takes_options = ['revision',
1416
Option('hardlink', help='Hard-link working tree files where possible.'),
1417
Option('files-from', type=str,
1418
help="Get file contents from this tree."),
1420
help="Create a branch without a working-tree."),
1422
help="Switch the checkout in the current directory "
1423
"to the new branch."),
1425
help='Create a stacked branch referring to the source branch. '
1426
'The new branch will depend on the availability of the source '
1427
'branch for all operations.'),
1428
Option('standalone',
1429
help='Do not use a shared repository, even if available.'),
1430
Option('use-existing-dir',
1431
help='By default branch will fail if the target'
1432
' directory exists, but does not already'
1433
' have a control directory. This flag will'
1434
' allow branch to proceed.'),
1436
help="Bind new branch to from location."),
650
takes_options = ['revision', 'basis']
1438
651
aliases = ['get', 'clone']
1440
def run(self, from_location, to_location=None, revision=None,
1441
hardlink=False, stacked=False, standalone=False, no_tree=False,
1442
use_existing_dir=False, switch=False, bind=False,
1444
from bzrlib import switch as _mod_switch
1445
from bzrlib.tag import _merge_tags_if_possible
1446
if self.invoked_as in ['get', 'clone']:
1447
ui.ui_factory.show_user_warning(
1448
'deprecated_command',
1449
deprecated_name=self.invoked_as,
1450
recommended_name='branch',
1451
deprecated_in_version='2.4')
1452
accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
1454
if not (hardlink or files_from):
1455
# accelerator_tree is usually slower because you have to read N
1456
# files (no readahead, lots of seeks, etc), but allow the user to
1457
# explicitly request it
1458
accelerator_tree = None
1459
if files_from is not None and files_from != from_location:
1460
accelerator_tree = WorkingTree.open(files_from)
1461
revision = _get_one_revision('branch', revision)
1462
self.add_cleanup(br_from.lock_read().unlock)
1463
if revision is not None:
1464
revision_id = revision.as_revision_id(br_from)
1466
# FIXME - wt.last_revision, fallback to branch, fall back to
1467
# None or perhaps NULL_REVISION to mean copy nothing
1469
revision_id = br_from.last_revision()
1470
if to_location is None:
1471
to_location = getattr(br_from, "name", None)
1473
to_location = urlutils.derive_to_location(from_location)
1474
to_transport = transport.get_transport(to_location)
1476
to_transport.mkdir('.')
1477
except errors.FileExists:
653
def run(self, from_location, to_location=None, revision=None, basis=None):
656
elif len(revision) > 1:
657
raise BzrCommandError(
658
'bzr branch --revision takes exactly 1 revision value')
660
br_from = Branch.open(from_location)
662
if e.errno == errno.ENOENT:
663
raise BzrCommandError('Source location "%s" does not'
664
' exist.' % to_location)
669
if basis is not None:
670
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
673
if len(revision) == 1 and revision[0] is not None:
674
revision_id = revision[0].in_history(br_from)[1]
676
# FIXME - wt.last_revision, fallback to branch, fall back to
677
# None or perhaps NULL_REVISION to mean copy nothing
679
revision_id = br_from.last_revision()
680
if to_location is None:
681
to_location = os.path.basename(from_location.rstrip("/\\"))
684
name = os.path.basename(to_location) + '\n'
686
to_transport = transport.get_transport(to_location)
1479
to_dir = controldir.ControlDir.open_from_transport(
1481
except errors.NotBranchError:
1482
if not use_existing_dir:
1483
raise errors.BzrCommandError(gettext('Target directory "%s" '
1484
'already exists.') % to_location)
1489
to_dir.open_branch()
1490
except errors.NotBranchError:
1493
raise errors.AlreadyBranchError(to_location)
1494
except errors.NoSuchFile:
1495
raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
688
to_transport.mkdir('.')
689
except errors.FileExists:
690
raise BzrCommandError('Target directory "%s" already'
691
' exists.' % to_location)
692
except errors.NoSuchFile:
693
raise BzrCommandError('Parent of "%s" does not exist.' %
1501
696
# preserve whatever source format we have.
1502
to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1503
possible_transports=[to_transport],
1504
accelerator_tree=accelerator_tree,
1505
hardlink=hardlink, stacked=stacked,
1506
force_new_repo=standalone,
1507
create_tree_if_local=not no_tree,
1508
source_branch=br_from)
1509
branch = to_dir.open_branch(
1510
possible_transports=[
1511
br_from.bzrdir.root_transport, to_transport])
697
dir = br_from.bzrdir.sprout(to_transport.base,
698
revision_id, basis_dir)
699
branch = dir.open_branch()
1512
700
except errors.NoSuchRevision:
1513
701
to_transport.delete_tree('.')
1514
msg = gettext("The branch {0} has no revision {1}.").format(
1515
from_location, revision)
1516
raise errors.BzrCommandError(msg)
1519
to_repo = to_dir.open_repository()
1520
except errors.NoRepositoryPresent:
1521
to_repo = to_dir.create_repository()
1522
to_repo.fetch(br_from.repository, revision_id=revision_id)
1523
branch = br_from.sprout(to_dir, revision_id=revision_id)
1524
_merge_tags_if_possible(br_from, branch)
1525
# If the source branch is stacked, the new branch may
1526
# be stacked whether we asked for that explicitly or not.
1527
# We therefore need a try/except here and not just 'if stacked:'
1529
note(gettext('Created new stacked branch referring to %s.') %
1530
branch.get_stacked_on_url())
1531
except (errors.NotStacked, errors.UnstackableBranchFormat,
1532
errors.UnstackableRepositoryFormat), e:
1533
note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1535
# Bind to the parent
1536
parent_branch = Branch.open(from_location)
1537
branch.bind(parent_branch)
1538
note(gettext('New branch bound to %s') % from_location)
1540
# Switch to the new branch
1541
wt, _ = WorkingTree.open_containing('.')
1542
_mod_switch.switch(wt.bzrdir, branch)
1543
note(gettext('Switched to branch: %s'),
1544
urlutils.unescape_for_display(branch.base, 'utf-8'))
1547
class cmd_branches(Command):
1548
__doc__ = """List the branches available at the current location.
1550
This command will print the names of all the branches at the current
1554
takes_args = ['location?']
1556
Option('recursive', short_name='R',
1557
help='Recursively scan for branches rather than '
1558
'just looking in the specified location.')]
1560
def run(self, location=".", recursive=False):
1562
t = transport.get_transport(location)
1563
if not t.listable():
1564
raise errors.BzrCommandError(
1565
"Can't scan this type of location.")
1566
for b in controldir.ControlDir.find_branches(t):
1567
self.outf.write("%s\n" % urlutils.unescape_for_display(
1568
urlutils.relative_url(t.base, b.base),
1569
self.outf.encoding).rstrip("/"))
1571
dir = controldir.ControlDir.open_containing(location)[0]
1573
active_branch = dir.open_branch(name="")
1574
except errors.NotBranchError:
1575
active_branch = None
1577
for name, branch in iter_sibling_branches(dir):
1580
active = (active_branch is not None and
1581
active_branch.base == branch.base)
1582
names[name] = active
1583
# Only mention the current branch explicitly if it's not
1584
# one of the colocated branches
1585
if not any(names.values()) and active_branch is not None:
1586
self.outf.write("* %s\n" % gettext("(default)"))
1587
for name in sorted(names.keys()):
1588
active = names[name]
1593
self.outf.write("%s %s\n" % (
1594
prefix, name.encode(self.outf.encoding)))
702
msg = "The branch %s has no revision %s." % (from_location, revision[0])
703
raise BzrCommandError(msg)
704
except errors.UnlistableBranch:
705
osutils.rmtree(to_location)
706
msg = "The branch %s cannot be used as a --basis" % (basis,)
707
raise BzrCommandError(msg)
709
branch.control_files.put_utf8('branch-name', name)
710
note('Branched %d revision(s).' % branch.revno())
1597
715
class cmd_checkout(Command):
1598
__doc__ = """Create a new checkout of an existing branch.
716
"""Create a new checkout of an existing branch.
1600
718
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1601
719
the branch found in '.'. This is useful if you have removed the working tree
1602
720
or if it was never created - i.e. if you pushed the branch to its current
1603
721
location using SFTP.
1605
723
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
1606
724
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
1607
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
1608
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
1609
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
1612
726
To retrieve the branch as of a particular revision, supply the --revision
1613
727
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
1614
728
out of date [so you cannot commit] but it may be useful (i.e. to examine old
731
--basis is to speed up checking out from remote branches. When specified, it
732
uses the inventory and file contents from the basis branch in preference to the
733
branch being checked out.
1618
_see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1619
735
takes_args = ['branch_location?', 'to_location?']
1620
takes_options = ['revision',
736
takes_options = ['revision', # , 'basis']
1621
737
Option('lightweight',
1622
help="Perform a lightweight checkout. Lightweight "
738
help="perform a lightweight checkout. Lightweight "
1623
739
"checkouts depend on access to the branch for "
1624
"every operation. Normal checkouts can perform "
740
"every operation. Normal checkouts can perform "
1625
741
"common operations like diff and status without "
1626
742
"such access, and also support local commits."
1628
Option('files-from', type=str,
1629
help="Get file contents from this tree."),
1631
help='Hard-link working tree files where possible.'
1634
745
aliases = ['co']
1636
def run(self, branch_location=None, to_location=None, revision=None,
1637
lightweight=False, files_from=None, hardlink=False):
747
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
751
elif len(revision) > 1:
752
raise BzrCommandError(
753
'bzr checkout --revision takes exactly 1 revision value')
1638
754
if branch_location is None:
1639
755
branch_location = osutils.getcwd()
1640
756
to_location = branch_location
1641
accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1643
if not (hardlink or files_from):
1644
# accelerator_tree is usually slower because you have to read N
1645
# files (no readahead, lots of seeks, etc), but allow the user to
1646
# explicitly request it
1647
accelerator_tree = None
1648
revision = _get_one_revision('checkout', revision)
1649
if files_from is not None and files_from != branch_location:
1650
accelerator_tree = WorkingTree.open(files_from)
1651
if revision is not None:
1652
revision_id = revision.as_revision_id(source)
757
source = Branch.open(branch_location)
758
if len(revision) == 1 and revision[0] is not None:
759
revision_id = revision[0].in_history(source)[1]
1654
761
revision_id = None
1655
762
if to_location is None:
1656
to_location = urlutils.derive_to_location(branch_location)
1657
# if the source and to_location are the same,
763
to_location = os.path.basename(branch_location.rstrip("/\\"))
764
# if the source and to_location are the same,
1658
765
# and there is no working tree,
1659
766
# then reconstitute a branch
1660
767
if (osutils.abspath(to_location) ==
1663
770
source.bzrdir.open_workingtree()
1664
771
except errors.NoWorkingTree:
1665
source.bzrdir.create_workingtree(revision_id)
772
source.bzrdir.create_workingtree()
1667
source.create_checkout(to_location, revision_id, lightweight,
1668
accelerator_tree, hardlink)
775
os.mkdir(to_location)
777
if e.errno == errno.EEXIST:
778
raise BzrCommandError('Target directory "%s" already'
779
' exists.' % to_location)
780
if e.errno == errno.ENOENT:
781
raise BzrCommandError('Parent of "%s" does not exist.' %
785
old_format = bzrdir.BzrDirFormat.get_default_format()
786
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
788
source.create_checkout(to_location, revision_id, lightweight)
790
bzrdir.BzrDirFormat.set_default_format(old_format)
1671
793
class cmd_renames(Command):
1672
__doc__ = """Show list of renamed files.
794
"""Show list of renamed files.
1674
796
# TODO: Option to show renames between two historical versions.
1676
798
# TODO: Only show renames under dir, rather than in the whole branch.
1677
_see_also = ['status']
1678
799
takes_args = ['dir?']
1680
801
@display_command
1681
802
def run(self, dir=u'.'):
803
from bzrlib.tree import find_renames
1682
804
tree = WorkingTree.open_containing(dir)[0]
1683
self.add_cleanup(tree.lock_read().unlock)
1684
old_tree = tree.basis_tree()
1685
self.add_cleanup(old_tree.lock_read().unlock)
1687
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1688
for f, paths, c, v, p, n, k, e in iterator:
1689
if paths[0] == paths[1]:
1693
renames.append(paths)
805
old_inv = tree.basis_tree().inventory
806
new_inv = tree.read_working_inventory()
807
renames = list(find_renames(old_inv, new_inv))
1695
809
for old_name, new_name in renames:
1696
810
self.outf.write("%s => %s\n" % (old_name, new_name))
1699
813
class cmd_update(Command):
1700
__doc__ = """Update a working tree to a new revision.
1702
This will perform a merge of the destination revision (the tip of the
1703
branch, or the specified revision) into the working tree, and then make
1704
that revision the basis revision for the working tree.
1706
You can use this to visit an older revision, or to update a working tree
1707
that is out of date from its branch.
1709
If there are any uncommitted changes in the tree, they will be carried
1710
across and remain as uncommitted changes after the update. To discard
1711
these changes, use 'bzr revert'. The uncommitted changes may conflict
1712
with the changes brought in by the change in basis revision.
1714
If the tree's branch is bound to a master branch, bzr will also update
1715
the branch from the master.
1717
You cannot update just a single file or directory, because each Bazaar
1718
working tree has just a single basis revision. If you want to restore a
1719
file that has been removed locally, use 'bzr revert' instead of 'bzr
1720
update'. If you want to restore a file to its state in a previous
1721
revision, use 'bzr revert' with a '-r' option, or use 'bzr cat' to write
1722
out the old content of that file to a new location.
1724
The 'dir' argument, if given, must be the location of the root of a
1725
working tree to update. By default, the working tree that contains the
1726
current working directory is used.
814
"""Update a tree to have the latest code committed to its branch.
816
This will perform a merge into the working tree, and may generate
817
conflicts. If you have any local changes, you will still
818
need to commit them after the update for the update to be complete.
820
If you want to discard your local changes, you can just do a
821
'bzr revert' instead of 'bzr commit' after the update.
1729
_see_also = ['pull', 'working-trees', 'status-flags']
1730
823
takes_args = ['dir?']
1731
takes_options = ['revision',
1733
help="Show base revision text in conflicts."),
1735
824
aliases = ['up']
1737
def run(self, dir=None, revision=None, show_base=None):
1738
if revision is not None and len(revision) != 1:
1739
raise errors.BzrCommandError(gettext(
1740
"bzr update --revision takes exactly one revision"))
1742
tree = WorkingTree.open_containing('.')[0]
1744
tree, relpath = WorkingTree.open_containing(dir)
1747
raise errors.BzrCommandError(gettext(
1748
"bzr update can only update a whole tree, "
1749
"not a file or subdirectory"))
1750
branch = tree.branch
1751
possible_transports = []
1752
master = branch.get_master_branch(
1753
possible_transports=possible_transports)
1754
if master is not None:
1755
branch_location = master.base
1758
branch_location = tree.branch.base
1759
tree.lock_tree_write()
1760
self.add_cleanup(tree.unlock)
1761
# get rid of the final '/' and be ready for display
1762
branch_location = urlutils.unescape_for_display(
1763
branch_location.rstrip('/'),
1765
existing_pending_merges = tree.get_parent_ids()[1:]
1769
# may need to fetch data into a heavyweight checkout
1770
# XXX: this may take some time, maybe we should display a
1772
old_tip = branch.update(possible_transports)
1773
if revision is not None:
1774
revision_id = revision[0].as_revision_id(branch)
1776
revision_id = branch.last_revision()
1777
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1778
revno = branch.revision_id_to_dotted_revno(revision_id)
1779
note(gettext("Tree is up to date at revision {0} of branch {1}"
1780
).format('.'.join(map(str, revno)), branch_location))
1782
view_info = _get_view_info_for_change_reporter(tree)
1783
change_reporter = delta._ChangeReporter(
1784
unversioned_filter=tree.is_ignored,
1785
view_info=view_info)
826
def run(self, dir='.'):
827
tree = WorkingTree.open_containing(dir)[0]
1787
conflicts = tree.update(
1789
possible_transports=possible_transports,
1790
revision=revision_id,
1792
show_base=show_base)
1793
except errors.NoSuchRevision, e:
1794
raise errors.BzrCommandError(gettext(
1795
"branch has no revision %s\n"
1796
"bzr update --revision only works"
1797
" for a revision in the branch history")
1799
revno = tree.branch.revision_id_to_dotted_revno(
1800
_mod_revision.ensure_null(tree.last_revision()))
1801
note(gettext('Updated to revision {0} of branch {1}').format(
1802
'.'.join(map(str, revno)), branch_location))
1803
parent_ids = tree.get_parent_ids()
1804
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1805
note(gettext('Your local commits will now show as pending merges with '
1806
"'bzr status', and can be committed with 'bzr commit'."))
830
existing_pending_merges = tree.get_parent_ids()[1:]
831
last_rev = tree.last_revision()
832
if last_rev == tree.branch.last_revision():
833
# may be up to date, check master too.
834
master = tree.branch.get_master_branch()
835
if master is None or last_rev == master.last_revision():
836
revno = tree.branch.revision_id_to_revno(last_rev)
837
note("Tree is up to date at revision %d." % (revno,))
839
conflicts = tree.update()
840
revno = tree.branch.revision_id_to_revno(tree.last_revision())
841
note('Updated to revision %d.' % (revno,))
842
if tree.get_parent_ids()[1:] != existing_pending_merges:
843
note('Your local commits will now show as pending merges with '
844
"'bzr status', and can be committed with 'bzr commit'.")
1813
853
class cmd_info(Command):
1814
__doc__ = """Show information about a working tree, branch or repository.
854
"""Show information about a working tree, branch or repository.
1816
856
This command will show all known locations and formats associated to the
1817
tree, branch or repository.
1819
In verbose mode, statistical information is included with each report.
1820
To see extended statistic information, use a verbosity level of 2 or
1821
higher by specifying the verbose option multiple times, e.g. -vv.
857
tree, branch or repository. Statistical information is included with
1823
860
Branches and working trees will also report any missing revisions.
1827
Display information on the format and related locations:
1831
Display the above together with extended format information and
1832
basic statistics (like the number of files in the working tree and
1833
number of revisions in the branch and repository):
1837
Display the above together with number of committers to the branch:
1841
_see_also = ['revno', 'working-trees', 'repositories']
1842
862
takes_args = ['location?']
1843
863
takes_options = ['verbose']
1844
encoding_type = 'replace'
1846
865
@display_command
1847
866
def run(self, location=None, verbose=False):
1849
noise_level = get_verbosity_level()
1852
867
from bzrlib.info import show_bzrdir_info
1853
show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1854
verbose=noise_level, outfile=self.outf)
868
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1857
872
class cmd_remove(Command):
1858
__doc__ = """Remove files or directories.
1860
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1861
delete them if they can easily be recovered using revert otherwise they
1862
will be backed up (adding an extension of the form .~#~). If no options or
1863
parameters are given Bazaar will scan for files that are being tracked by
1864
Bazaar but missing in your tree and stop tracking them for you.
873
"""Make a file unversioned.
875
This makes bzr stop tracking changes to a versioned file. It does
876
not delete the working copy.
878
You can specify one or more files, and/or --new. If you specify --new,
879
only 'added' files will be removed. If you specify both, then new files
880
in the specified directories will be removed. If the directories are
881
also new, they will also be removed.
1866
883
takes_args = ['file*']
1867
takes_options = ['verbose',
1868
Option('new', help='Only remove files that have never been committed.'),
1869
RegistryOption.from_kwargs('file-deletion-strategy',
1870
'The file deletion mode to be used.',
1871
title='Deletion Strategy', value_switches=True, enum_switch=False,
1872
safe='Backup changed files (default).',
1873
keep='Delete from bzr but leave the working copy.',
1874
no_backup='Don\'t backup changed files.',
1875
force='Delete all the specified files, even if they can not be '
1876
'recovered and even if they are non-empty directories. '
1877
'(deprecated, use no-backup)')]
1878
aliases = ['rm', 'del']
884
takes_options = ['verbose', Option('new', help='remove newly-added files')]
1879
886
encoding_type = 'replace'
1881
def run(self, file_list, verbose=False, new=False,
1882
file_deletion_strategy='safe'):
1883
if file_deletion_strategy == 'force':
1884
note(gettext("(The --force option is deprecated, rather use --no-backup "
1886
file_deletion_strategy = 'no-backup'
1888
tree, file_list = WorkingTree.open_containing_paths(file_list)
1890
if file_list is not None:
1891
file_list = [f for f in file_list]
1893
self.add_cleanup(tree.lock_write().unlock)
1894
# Heuristics should probably all move into tree.remove_smart or
888
def run(self, file_list, verbose=False, new=False):
889
tree, file_list = tree_files(file_list)
891
if file_list is None:
892
raise BzrCommandError('Specify one or more files to remove, or'
1897
895
added = tree.changes_from(tree.basis_tree(),
1898
896
specific_files=file_list).added
1899
897
file_list = sorted([f[0] for f in added], reverse=True)
1900
898
if len(file_list) == 0:
1901
raise errors.BzrCommandError(gettext('No matching files.'))
1902
elif file_list is None:
1903
# missing files show up in iter_changes(basis) as
1904
# versioned-with-no-kind.
1906
for change in tree.iter_changes(tree.basis_tree()):
1907
# Find paths in the working tree that have no kind:
1908
if change[1][1] is not None and change[6][1] is None:
1909
missing.append(change[1][1])
1910
file_list = sorted(missing, reverse=True)
1911
file_deletion_strategy = 'keep'
1912
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1913
keep_files=file_deletion_strategy=='keep',
1914
force=(file_deletion_strategy=='no-backup'))
899
raise BzrCommandError('No matching files.')
900
tree.remove(file_list, verbose=verbose, to_file=self.outf)
1917
903
class cmd_file_id(Command):
1918
__doc__ = """Print file_id of a particular file or directory.
904
"""Print file_id of a particular file or directory.
1920
906
The file_id is assigned when the file is first added and remains the
1921
907
same through all revisions where the file exists, even when it is
2475
1283
self.outf.write(tree.basedir + '\n')
2478
def _parse_limit(limitstring):
2480
return int(limitstring)
2482
msg = gettext("The limit argument must be an integer.")
2483
raise errors.BzrCommandError(msg)
2486
def _parse_levels(s):
2490
msg = gettext("The levels argument must be an integer.")
2491
raise errors.BzrCommandError(msg)
2494
1286
class cmd_log(Command):
2495
__doc__ = """Show historical log for a branch or subset of a branch.
2497
log is bzr's default tool for exploring the history of a branch.
2498
The branch to use is taken from the first parameter. If no parameters
2499
are given, the branch containing the working directory is logged.
2500
Here are some simple examples::
2502
bzr log log the current branch
2503
bzr log foo.py log a file in its branch
2504
bzr log http://server/branch log a branch on a server
2506
The filtering, ordering and information shown for each revision can
2507
be controlled as explained below. By default, all revisions are
2508
shown sorted (topologically) so that newer revisions appear before
2509
older ones and descendants always appear before ancestors. If displayed,
2510
merged revisions are shown indented under the revision in which they
2515
The log format controls how information about each revision is
2516
displayed. The standard log formats are called ``long``, ``short``
2517
and ``line``. The default is long. See ``bzr help log-formats``
2518
for more details on log formats.
2520
The following options can be used to control what information is
2523
-l N display a maximum of N revisions
2524
-n N display N levels of revisions (0 for all, 1 for collapsed)
2525
-v display a status summary (delta) for each revision
2526
-p display a diff (patch) for each revision
2527
--show-ids display revision-ids (and file-ids), not just revnos
2529
Note that the default number of levels to display is a function of the
2530
log format. If the -n option is not used, the standard log formats show
2531
just the top level (mainline).
2533
Status summaries are shown using status flags like A, M, etc. To see
2534
the changes explained using words like ``added`` and ``modified``
2535
instead, use the -vv option.
2539
To display revisions from oldest to newest, use the --forward option.
2540
In most cases, using this option will have little impact on the total
2541
time taken to produce a log, though --forward does not incrementally
2542
display revisions like --reverse does when it can.
2544
:Revision filtering:
2546
The -r option can be used to specify what revision or range of revisions
2547
to filter against. The various forms are shown below::
2549
-rX display revision X
2550
-rX.. display revision X and later
2551
-r..Y display up to and including revision Y
2552
-rX..Y display from X to Y inclusive
2554
See ``bzr help revisionspec`` for details on how to specify X and Y.
2555
Some common examples are given below::
2557
-r-1 show just the tip
2558
-r-10.. show the last 10 mainline revisions
2559
-rsubmit:.. show what's new on this branch
2560
-rancestor:path.. show changes since the common ancestor of this
2561
branch and the one at location path
2562
-rdate:yesterday.. show changes since yesterday
2564
When logging a range of revisions using -rX..Y, log starts at
2565
revision Y and searches back in history through the primary
2566
("left-hand") parents until it finds X. When logging just the
2567
top level (using -n1), an error is reported if X is not found
2568
along the way. If multi-level logging is used (-n0), X may be
2569
a nested merge revision and the log will be truncated accordingly.
2573
If parameters are given and the first one is not a branch, the log
2574
will be filtered to show only those revisions that changed the
2575
nominated files or directories.
2577
Filenames are interpreted within their historical context. To log a
2578
deleted file, specify a revision range so that the file existed at
2579
the end or start of the range.
2581
Historical context is also important when interpreting pathnames of
2582
renamed files/directories. Consider the following example:
2584
* revision 1: add tutorial.txt
2585
* revision 2: modify tutorial.txt
2586
* revision 3: rename tutorial.txt to guide.txt; add tutorial.txt
2590
* ``bzr log guide.txt`` will log the file added in revision 1
2592
* ``bzr log tutorial.txt`` will log the new file added in revision 3
2594
* ``bzr log -r2 -p tutorial.txt`` will show the changes made to
2595
the original file in revision 2.
2597
* ``bzr log -r2 -p guide.txt`` will display an error message as there
2598
was no file called guide.txt in revision 2.
2600
Renames are always followed by log. By design, there is no need to
2601
explicitly ask for this (and no way to stop logging a file back
2602
until it was last renamed).
2606
The --match option can be used for finding revisions that match a
2607
regular expression in a commit message, committer, author or bug.
2608
Specifying the option several times will match any of the supplied
2609
expressions. --match-author, --match-bugs, --match-committer and
2610
--match-message can be used to only match a specific field.
2614
GUI tools and IDEs are often better at exploring history than command
2615
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2616
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2617
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2618
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2620
You may find it useful to add the aliases below to ``bazaar.conf``::
2624
top = log -l10 --line
2627
``bzr tip`` will then show the latest revision while ``bzr top``
2628
will show the last 10 mainline revisions. To see the details of a
2629
particular revision X, ``bzr show -rX``.
2631
If you are interested in looking deeper into a particular merge X,
2632
use ``bzr log -n0 -rX``.
2634
``bzr log -v`` on a branch with lots of history is currently
2635
very slow. A fix for this issue is currently under development.
2636
With or without that fix, it is recommended that a revision range
2637
be given when using the -v option.
2639
bzr has a generic full-text matching plugin, bzr-search, that can be
2640
used to find revisions matching user names, commit messages, etc.
2641
Among other features, this plugin can find all revisions containing
2642
a list of words but not others.
2644
When exploring non-mainline history on large projects with deep
2645
history, the performance of log can be greatly improved by installing
2646
the historycache plugin. This plugin buffers historical information
2647
trading disk space for faster speed.
1287
"""Show log of a branch, file, or directory.
1289
By default show the log of the branch containing the working directory.
1291
To request a range of logs, you can use the command -r begin..end
1292
-r revision requests a specific revision, -r ..end or -r begin.. are
1298
bzr log -r -10.. http://server/branch
2649
takes_args = ['file*']
2650
_see_also = ['log-formats', 'revisionspec']
2653
help='Show from oldest to newest.'),
2655
custom_help('verbose',
2656
help='Show files changed in each revision.'),
2660
type=bzrlib.option._parse_revision_str,
2662
help='Show just the specified revision.'
2663
' See also "help revisionspec".'),
2665
RegistryOption('authors',
2666
'What names to list as authors - first, all or committer.',
2668
lazy_registry=('bzrlib.log', 'author_list_registry'),
2672
help='Number of levels to display - 0 for all, 1 for flat.',
2674
type=_parse_levels),
2676
help='Show revisions whose message matches this '
2677
'regular expression.',
2682
help='Limit the output to the first N revisions.',
2687
help='Show changes made in each revision as a patch.'),
2688
Option('include-merged',
2689
help='Show merged revisions like --levels 0 does.'),
2690
Option('include-merges', hidden=True,
2691
help='Historical alias for --include-merged.'),
2692
Option('omit-merges',
2693
help='Do not report commits with more than one parent.'),
2694
Option('exclude-common-ancestry',
2695
help='Display only the revisions that are not part'
2696
' of both ancestries (require -rX..Y).'
2698
Option('signatures',
2699
help='Show digital signature validity.'),
2702
help='Show revisions whose properties match this '
2705
ListOption('match-message',
2706
help='Show revisions whose message matches this '
2709
ListOption('match-committer',
2710
help='Show revisions whose committer matches this '
2713
ListOption('match-author',
2714
help='Show revisions whose authors match this '
2717
ListOption('match-bugs',
2718
help='Show revisions whose bugs match this '
1301
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1303
takes_args = ['location?']
1304
takes_options = [Option('forward',
1305
help='show from oldest to newest'),
1308
help='show files changed in each revision'),
1309
'show-ids', 'revision',
1313
help='show revisions whose message matches this regexp',
2722
1317
encoding_type = 'replace'
2724
1319
@display_command
2725
def run(self, file_list=None, timezone='original',
1320
def run(self, location=None, timezone='original',
2727
1322
show_ids=False,
2731
1325
log_format=None,
2736
include_merged=None,
2738
exclude_common_ancestry=False,
2742
match_committer=None,
2746
include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2748
from bzrlib.log import (
2750
make_log_request_dict,
2751
_get_info_for_log_files,
1330
from bzrlib.log import log_formatter, show_log
1331
assert message is None or isinstance(message, basestring), \
1332
"invalid message argument %r" % message
2753
1333
direction = (forward and 'forward') or 'reverse'
2754
if symbol_versioning.deprecated_passed(include_merges):
2755
ui.ui_factory.show_user_warning(
2756
'deprecated_command_option',
2757
deprecated_name='--include-merges',
2758
recommended_name='--include-merged',
2759
deprecated_in_version='2.5',
2760
command=self.invoked_as)
2761
if include_merged is None:
2762
include_merged = include_merges
2764
raise errors.BzrCommandError(gettext(
2765
'{0} and {1} are mutually exclusive').format(
2766
'--include-merges', '--include-merged'))
2767
if include_merged is None:
2768
include_merged = False
2769
if (exclude_common_ancestry
2770
and (revision is None or len(revision) != 2)):
2771
raise errors.BzrCommandError(gettext(
2772
'--exclude-common-ancestry requires -r with two revisions'))
2777
raise errors.BzrCommandError(gettext(
2778
'{0} and {1} are mutually exclusive').format(
2779
'--levels', '--include-merged'))
2781
if change is not None:
2783
raise errors.RangeInChangeOption()
2784
if revision is not None:
2785
raise errors.BzrCommandError(gettext(
2786
'{0} and {1} are mutually exclusive').format(
2787
'--revision', '--change'))
2792
filter_by_dir = False
2794
# find the file ids to log and check for directory filtering
2795
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2796
revision, file_list, self.add_cleanup)
2797
for relpath, file_id, kind in file_info_list:
2799
raise errors.BzrCommandError(gettext(
2800
"Path unknown at end or start of revision range: %s") %
2802
# If the relpath is the top of the tree, we log everything
2807
file_ids.append(file_id)
2808
filter_by_dir = filter_by_dir or (
2809
kind in ['directory', 'tree-reference'])
1338
# find the file id to log:
1340
dir, fp = bzrdir.BzrDir.open_containing(location)
1341
b = dir.open_branch()
1345
inv = dir.open_workingtree().inventory
1346
except (errors.NotBranchError, errors.NotLocalUrl):
1347
# either no tree, or is remote.
1348
inv = b.basis_tree().inventory
1349
file_id = inv.path2id(fp)
2812
# FIXME ? log the current subdir only RBC 20060203
1352
# FIXME ? log the current subdir only RBC 20060203
2813
1353
if revision is not None \
2814
1354
and len(revision) > 0 and revision[0].get_branch():
2815
1355
location = revision[0].get_branch()
2818
dir, relpath = controldir.ControlDir.open_containing(location)
1358
dir, relpath = bzrdir.BzrDir.open_containing(location)
2819
1359
b = dir.open_branch()
2820
self.add_cleanup(b.lock_read().unlock)
2821
rev1, rev2 = _get_revision_range(revision, b, self.name())
2823
if b.get_config_stack().get('validate_signatures_in_log'):
2827
if not gpg.GPGStrategy.verify_signatures_available():
2828
raise errors.GpgmeNotInstalled(None)
2830
# Decide on the type of delta & diff filtering to use
2831
# TODO: add an --all-files option to make this configurable & consistent
2839
diff_type = 'partial'
2843
# Build the log formatter
2844
if log_format is None:
2845
log_format = log.log_formatter_registry.get_default(b)
2846
# Make a non-encoding output to include the diffs - bug 328007
2847
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2848
lf = log_format(show_ids=show_ids, to_file=self.outf,
2849
to_exact_file=unencoded_output,
2850
show_timezone=timezone,
2851
delta_format=get_verbosity_level(),
2853
show_advice=levels is None,
2854
author_list_handler=authors)
2856
# Choose the algorithm for doing the logging. It's annoying
2857
# having multiple code paths like this but necessary until
2858
# the underlying repository format is faster at generating
2859
# deltas or can provide everything we need from the indices.
2860
# The default algorithm - match-using-deltas - works for
2861
# multiple files and directories and is faster for small
2862
# amounts of history (200 revisions say). However, it's too
2863
# slow for logging a single file in a repository with deep
2864
# history, i.e. > 10K revisions. In the spirit of "do no
2865
# evil when adding features", we continue to use the
2866
# original algorithm - per-file-graph - for the "single
2867
# file that isn't a directory without showing a delta" case.
2868
partial_history = revision and b.repository._format.supports_chks
2869
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2870
or delta_type or partial_history)
2874
match_dict[''] = match
2876
match_dict['message'] = match_message
2878
match_dict['committer'] = match_committer
2880
match_dict['author'] = match_author
2882
match_dict['bugs'] = match_bugs
2884
# Build the LogRequest and execute it
2885
if len(file_ids) == 0:
2887
rqst = make_log_request_dict(
2888
direction=direction, specific_fileids=file_ids,
2889
start_revision=rev1, end_revision=rev2, limit=limit,
2890
message_search=message, delta_type=delta_type,
2891
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2892
exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
2893
signature=signatures, omit_merges=omit_merges,
2895
Logger(b, rqst).show(lf)
2898
def _get_revision_range(revisionspec_list, branch, command_name):
2899
"""Take the input of a revision option and turn it into a revision range.
2901
It returns RevisionInfo objects which can be used to obtain the rev_id's
2902
of the desired revisions. It does some user input validations.
2904
if revisionspec_list is None:
2907
elif len(revisionspec_list) == 1:
2908
rev1 = rev2 = revisionspec_list[0].in_history(branch)
2909
elif len(revisionspec_list) == 2:
2910
start_spec = revisionspec_list[0]
2911
end_spec = revisionspec_list[1]
2912
if end_spec.get_branch() != start_spec.get_branch():
2913
# b is taken from revision[0].get_branch(), and
2914
# show_log will use its revision_history. Having
2915
# different branches will lead to weird behaviors.
2916
raise errors.BzrCommandError(gettext(
2917
"bzr %s doesn't accept two revisions in different"
2918
" branches.") % command_name)
2919
if start_spec.spec is None:
2920
# Avoid loading all the history.
2921
rev1 = RevisionInfo(branch, None, None)
2923
rev1 = start_spec.in_history(branch)
2924
# Avoid loading all of history when we know a missing
2925
# end of range means the last revision ...
2926
if end_spec.spec is None:
2927
last_revno, last_revision_id = branch.last_revision_info()
2928
rev2 = RevisionInfo(branch, last_revno, last_revision_id)
2930
rev2 = end_spec.in_history(branch)
2932
raise errors.BzrCommandError(gettext(
2933
'bzr %s --revision takes one or two values.') % command_name)
2937
def _revision_range_to_revid_range(revision_range):
2940
if revision_range[0] is not None:
2941
rev_id1 = revision_range[0].rev_id
2942
if revision_range[1] is not None:
2943
rev_id2 = revision_range[1].rev_id
2944
return rev_id1, rev_id2
1361
if revision is None:
1364
elif len(revision) == 1:
1365
rev1 = rev2 = revision[0].in_history(b).revno
1366
elif len(revision) == 2:
1367
if revision[1].get_branch() != revision[0].get_branch():
1368
# b is taken from revision[0].get_branch(), and
1369
# show_log will use its revision_history. Having
1370
# different branches will lead to weird behaviors.
1371
raise BzrCommandError(
1372
"Log doesn't accept two revisions in different branches.")
1373
if revision[0].spec is None:
1374
# missing begin-range means first revision
1377
rev1 = revision[0].in_history(b).revno
1379
if revision[1].spec is None:
1380
# missing end-range means last known revision
1383
rev2 = revision[1].in_history(b).revno
1385
raise BzrCommandError('bzr log --revision takes one or two values.')
1387
# By this point, the revision numbers are converted to the +ve
1388
# form if they were supplied in the -ve form, so we can do
1389
# this comparison in relative safety
1391
(rev2, rev1) = (rev1, rev2)
1393
if (log_format is None):
1394
default = b.get_config().log_format()
1395
log_format = get_log_format(long=long, short=short, line=line,
1397
lf = log_formatter(log_format,
1400
show_timezone=timezone)
1406
direction=direction,
1407
start_revision=rev1,
2946
1412
def get_log_format(long=False, short=False, line=False, default='long'):
2947
1413
log_format = default
2966
1432
@display_command
2967
1433
def run(self, filename):
2968
1434
tree, relpath = WorkingTree.open_containing(filename)
2969
file_id = tree.path2id(relpath)
2970
1435
b = tree.branch
2971
self.add_cleanup(b.lock_read().unlock)
2972
touching_revs = log.find_touching_revisions(b, file_id)
2973
for revno, revision_id, what in touching_revs:
1436
inv = tree.read_working_inventory()
1437
file_id = inv.path2id(relpath)
1438
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
2974
1439
self.outf.write("%6d %s\n" % (revno, what))
2977
1442
class cmd_ls(Command):
2978
__doc__ = """List files in a tree.
1443
"""List files in a tree.
1445
# TODO: Take a revision or remote path and list that tree instead.
1447
takes_options = ['verbose', 'revision',
1448
Option('non-recursive',
1449
help='don\'t recurse into sub-directories'),
1451
help='Print all paths from the root of the branch.'),
1452
Option('unknown', help='Print unknown files'),
1453
Option('versioned', help='Print versioned files'),
1454
Option('ignored', help='Print ignored files'),
2981
_see_also = ['status', 'cat']
2982
takes_args = ['path?']
2986
Option('recursive', short_name='R',
2987
help='Recurse into subdirectories.'),
2989
help='Print paths relative to the root of the branch.'),
2990
Option('unknown', short_name='u',
2991
help='Print unknown files.'),
2992
Option('versioned', help='Print versioned files.',
2994
Option('ignored', short_name='i',
2995
help='Print ignored files.'),
2996
Option('kind', short_name='k',
2997
help='List entries of a particular kind: file, directory, symlink.',
1456
Option('null', help='Null separate the files'),
3003
1458
@display_command
3004
def run(self, revision=None, verbose=False,
3005
recursive=False, from_root=False,
1459
def run(self, revision=None, verbose=False,
1460
non_recursive=False, from_root=False,
3006
1461
unknown=False, versioned=False, ignored=False,
3007
null=False, kind=None, show_ids=False, path=None, directory=None):
3009
if kind and kind not in ('file', 'directory', 'symlink'):
3010
raise errors.BzrCommandError(gettext('invalid kind specified'))
3012
1464
if verbose and null:
3013
raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
1465
raise BzrCommandError('Cannot set both --verbose and --null')
3014
1466
all = not (unknown or versioned or ignored)
3016
1468
selection = {'I':ignored, '?':unknown, 'V':versioned}
3022
raise errors.BzrCommandError(gettext('cannot specify both --from-root'
3025
tree, branch, relpath = \
3026
_open_directory_or_containing_tree_or_branch(fs_path, directory)
3028
# Calculate the prefix to use
1470
tree, relpath = WorkingTree.open_containing(u'.')
3032
prefix = relpath + '/'
3033
elif fs_path != '.' and not fs_path.endswith('/'):
3034
prefix = fs_path + '/'
3036
if revision is not None or tree is None:
3037
tree = _get_one_revision_tree('ls', revision, branch=branch)
3040
if isinstance(tree, WorkingTree) and tree.supports_views():
3041
view_files = tree.views.lookup_view()
3044
view_str = views.view_display_str(view_files)
3045
note(gettext("Ignoring files outside view. View is %s") % view_str)
3047
self.add_cleanup(tree.lock_read().unlock)
3048
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
3049
from_dir=relpath, recursive=recursive):
3050
# Apply additional masking
3051
if not all and not selection[fc]:
3053
if kind is not None and fkind != kind:
3058
fullpath = osutils.pathjoin(relpath, fp)
3061
views.check_path_in_view(tree, fullpath)
3062
except errors.FileOutsideView:
3067
fp = osutils.pathjoin(prefix, fp)
3068
kindch = entry.kind_character()
3069
outstring = fp + kindch
3070
ui.ui_factory.clear_term()
3072
outstring = '%-8s %s' % (fc, outstring)
3073
if show_ids and fid is not None:
3074
outstring = "%-50s %s" % (outstring, fid)
3075
self.outf.write(outstring + '\n')
3077
self.outf.write(fp + '\0')
3080
self.outf.write(fid)
3081
self.outf.write('\0')
3089
self.outf.write('%-50s %s\n' % (outstring, my_id))
1475
if revision is not None:
1476
tree = tree.branch.repository.revision_tree(
1477
revision[0].in_history(tree.branch).rev_id)
1479
for fp, fc, kind, fid, entry in tree.list_files():
1480
if fp.startswith(relpath):
1481
fp = fp[len(relpath):]
1482
if non_recursive and '/' in fp:
1484
if not all and not selection[fc]:
1487
kindch = entry.kind_character()
1488
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1490
self.outf.write(fp + '\0')
3091
self.outf.write(outstring + '\n')
1493
self.outf.write(fp + '\n')
3094
1496
class cmd_unknowns(Command):
3095
__doc__ = """List unknown files.
3100
takes_options = ['directory']
1497
"""List unknown files."""
3102
1498
@display_command
3103
def run(self, directory=u'.'):
3104
for f in WorkingTree.open_containing(directory)[0].unknowns():
1500
for f in WorkingTree.open_containing(u'.')[0].unknowns():
3105
1501
self.outf.write(osutils.quotefn(f) + '\n')
3108
1504
class cmd_ignore(Command):
3109
__doc__ = """Ignore specified files or patterns.
3111
See ``bzr help patterns`` for details on the syntax of patterns.
3113
If a .bzrignore file does not exist, the ignore command
3114
will create one and add the specified files or patterns to the newly
3115
created file. The ignore command will also automatically add the
3116
.bzrignore file to be versioned. Creating a .bzrignore file without
3117
the use of the ignore command will require an explicit add command.
1505
"""Ignore a command or pattern.
3119
1507
To remove patterns from the ignore list, edit the .bzrignore file.
3120
After adding, editing or deleting that file either indirectly by
3121
using this command or directly by using an editor, be sure to commit
3124
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
3125
the global ignore file can be found in the application data directory as
3126
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
3127
Global ignores are not touched by this command. The global ignore file
3128
can be edited directly using an editor.
3130
Patterns prefixed with '!' are exceptions to ignore patterns and take
3131
precedence over regular ignores. Such exceptions are used to specify
3132
files that should be versioned which would otherwise be ignored.
3134
Patterns prefixed with '!!' act as regular ignore patterns, but have
3135
precedence over the '!' exception patterns.
3139
* Ignore patterns containing shell wildcards must be quoted from
3142
* Ignore patterns starting with "#" act as comments in the ignore file.
3143
To ignore patterns that begin with that character, use the "RE:" prefix.
3146
Ignore the top level Makefile::
3148
bzr ignore ./Makefile
3150
Ignore .class files in all directories...::
3152
bzr ignore "*.class"
3154
...but do not ignore "special.class"::
3156
bzr ignore "!special.class"
3158
Ignore files whose name begins with the "#" character::
3162
Ignore .o files under the lib directory::
3164
bzr ignore "lib/**/*.o"
3166
Ignore .o files under the lib directory::
3168
bzr ignore "RE:lib/.*\.o"
3170
Ignore everything but the "debian" toplevel directory::
3172
bzr ignore "RE:(?!debian/).*"
3174
Ignore everything except the "local" toplevel directory,
3175
but always ignore autosave files ending in ~, even under local/::
3178
bzr ignore "!./local"
1509
If the pattern contains a slash, it is compared to the whole path
1510
from the branch root. Otherwise, it is compared to only the last
1511
component of the path. To match a file only in the root directory,
1514
Ignore patterns are case-insensitive on case-insensitive systems.
1516
Note: wildcards must be quoted from the shell on Unix.
1519
bzr ignore ./Makefile
1520
bzr ignore '*.class'
3182
_see_also = ['status', 'ignored', 'patterns']
3183
takes_args = ['name_pattern*']
3184
takes_options = ['directory',
3185
Option('default-rules',
3186
help='Display the default ignore rules that bzr uses.')
3189
def run(self, name_pattern_list=None, default_rules=None,
3191
from bzrlib import ignores
3192
if default_rules is not None:
3193
# dump the default rules and exit
3194
for pattern in ignores.USER_DEFAULTS:
3195
self.outf.write("%s\n" % pattern)
1522
# TODO: Complain if the filename is absolute
1523
takes_args = ['name_pattern?']
1525
Option('old-default-rules',
1526
help='Out the ignore rules bzr < 0.9 always used.')
1529
def run(self, name_pattern=None, old_default_rules=None):
1530
from bzrlib.atomicfile import AtomicFile
1531
if old_default_rules is not None:
1532
# dump the rules and exit
1533
for pattern in ignores.OLD_DEFAULTS:
3197
if not name_pattern_list:
3198
raise errors.BzrCommandError(gettext("ignore requires at least one "
3199
"NAME_PATTERN or --default-rules."))
3200
name_pattern_list = [globbing.normalize_pattern(p)
3201
for p in name_pattern_list]
3203
bad_patterns_count = 0
3204
for p in name_pattern_list:
3205
if not globbing.Globster.is_pattern_valid(p):
3206
bad_patterns_count += 1
3207
bad_patterns += ('\n %s' % p)
3209
msg = (ngettext('Invalid ignore pattern found. %s',
3210
'Invalid ignore patterns found. %s',
3211
bad_patterns_count) % bad_patterns)
3212
ui.ui_factory.show_error(msg)
3213
raise errors.InvalidPattern('')
3214
for name_pattern in name_pattern_list:
3215
if (name_pattern[0] == '/' or
3216
(len(name_pattern) > 1 and name_pattern[1] == ':')):
3217
raise errors.BzrCommandError(gettext(
3218
"NAME_PATTERN should not be an absolute path"))
3219
tree, relpath = WorkingTree.open_containing(directory)
3220
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
3221
ignored = globbing.Globster(name_pattern_list)
3223
self.add_cleanup(tree.lock_read().unlock)
3224
for entry in tree.list_files():
3228
if ignored.match(filename):
3229
matches.append(filename)
3230
if len(matches) > 0:
3231
self.outf.write(gettext("Warning: the following files are version "
3232
"controlled and match your ignore pattern:\n%s"
3233
"\nThese files will continue to be version controlled"
3234
" unless you 'bzr remove' them.\n") % ("\n".join(matches),))
1536
if name_pattern is None:
1537
raise BzrCommandError("ignore requires a NAME_PATTERN")
1538
tree, relpath = WorkingTree.open_containing(u'.')
1539
ifn = tree.abspath('.bzrignore')
1540
if os.path.exists(ifn):
1543
igns = f.read().decode('utf-8')
1549
# TODO: If the file already uses crlf-style termination, maybe
1550
# we should use that for the newly added lines?
1552
if igns and igns[-1] != '\n':
1554
igns += name_pattern + '\n'
1556
f = AtomicFile(ifn, 'wt')
1558
f.write(igns.encode('utf-8'))
1563
inv = tree.inventory
1564
if inv.path2id('.bzrignore'):
1565
mutter('.bzrignore is already versioned')
1567
mutter('need to make new .bzrignore file versioned')
1568
tree.add(['.bzrignore'])
3237
1571
class cmd_ignored(Command):
3238
__doc__ = """List ignored files and the patterns that matched them.
3240
List all the ignored files and the ignore pattern that caused the file to
3243
Alternatively, to list just the files::
3248
encoding_type = 'replace'
3249
_see_also = ['ignore', 'ls']
3250
takes_options = ['directory']
1572
"""List ignored files and the patterns that matched them.
1574
See also: bzr ignore"""
3252
1575
@display_command
3253
def run(self, directory=u'.'):
3254
tree = WorkingTree.open_containing(directory)[0]
3255
self.add_cleanup(tree.lock_read().unlock)
1577
tree = WorkingTree.open_containing(u'.')[0]
3256
1578
for path, file_class, kind, file_id, entry in tree.list_files():
3257
1579
if file_class != 'I':
3259
1581
## XXX: Slightly inefficient since this was already calculated
3260
1582
pat = tree.is_ignored(path)
3261
self.outf.write('%-50s %s\n' % (path, pat))
1583
print '%-50s %s' % (path, pat)
3264
1586
class cmd_lookup_revision(Command):
3265
__doc__ = """Lookup the revision-id from a revision-number
1587
"""Lookup the revision-id from a revision-number
3268
1590
bzr lookup-revision 33
3271
1593
takes_args = ['revno']
3272
takes_options = ['directory']
3274
1595
@display_command
3275
def run(self, revno, directory=u'.'):
1596
def run(self, revno):
3277
1598
revno = int(revno)
3278
1599
except ValueError:
3279
raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
3281
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
3282
self.outf.write("%s\n" % revid)
1600
raise BzrCommandError("not a valid revision-number: %r" % revno)
1602
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
3285
1605
class cmd_export(Command):
3286
__doc__ = """Export current or past revision to a destination directory or archive.
1606
"""Export past revision to destination directory.
3288
1608
If no revision is specified this exports the last committed revision.
3291
1611
given, try to find the format with the extension. If no extension
3292
1612
is found exports to a directory (equivalent to --format=dir).
3294
If root is supplied, it will be used as the root directory inside
3295
container formats (tar, zip, etc). If it is not supplied it will default
3296
to the exported filename. The root option has no effect for 'dir' format.
3298
If branch is omitted then the branch containing the current working
3299
directory will be used.
3301
Note: Export of tree with non-ASCII filenames to zip is not supported.
3303
================= =========================
3304
Supported formats Autodetected by extension
3305
================= =========================
1614
Root may be the top directory for tar, tgz and tbz2 formats. If none
1615
is given, the top directory will be the root name of the file.
1617
Note: export of tree with non-ascii filenames to zip is not supported.
1619
Supported formats Autodetected by extension
1620
----------------- -------------------------
3308
1623
tbz2 .tar.bz2, .tbz2
3309
1624
tgz .tar.gz, .tgz
3311
================= =========================
3314
takes_args = ['dest', 'branch_or_subdir?']
3315
takes_options = ['directory',
3317
help="Type of file to export to.",
3320
Option('filters', help='Apply content filters to export the '
3321
'convenient form.'),
3324
help="Name of the root directory inside the exported file."),
3325
Option('per-file-timestamps',
3326
help='Set modification time of files to that of the last '
3327
'revision in which it was changed.'),
3328
Option('uncommitted',
3329
help='Export the working tree contents rather than that of the '
3332
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
3333
root=None, filters=False, per_file_timestamps=False, uncommitted=False,
1627
takes_args = ['dest']
1628
takes_options = ['revision', 'format', 'root']
1629
def run(self, dest, revision=None, format=None, root=None):
3335
1630
from bzrlib.export import export
3337
if branch_or_subdir is None:
3338
branch_or_subdir = directory
3340
(tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
3342
if tree is not None:
3343
self.add_cleanup(tree.lock_read().unlock)
3347
raise errors.BzrCommandError(
3348
gettext("--uncommitted requires a working tree"))
1631
tree = WorkingTree.open_containing(u'.')[0]
1633
if revision is None:
1634
# should be tree.last_revision FIXME
1635
rev_id = b.last_revision()
3351
export_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
1637
if len(revision) != 1:
1638
raise BzrError('bzr export --revision takes exactly 1 argument')
1639
rev_id = revision[0].in_history(b).rev_id
1640
t = b.repository.revision_tree(rev_id)
3353
export(export_tree, dest, format, root, subdir, filtered=filters,
3354
per_file_timestamps=per_file_timestamps)
1642
export(t, dest, format, root)
3355
1643
except errors.NoSuchExportFormat, e:
3356
raise errors.BzrCommandError(
3357
gettext('Unsupported export format: %s') % e.format)
1644
raise BzrCommandError('Unsupported export format: %s' % e.format)
3360
1647
class cmd_cat(Command):
3361
__doc__ = """Write the contents of a file as of a given revision to standard output.
3363
If no revision is nominated, the last revision is used.
3365
Note: Take care to redirect standard output when using this command on a
3370
takes_options = ['directory',
3371
Option('name-from-revision', help='The path name in the old tree.'),
3372
Option('filters', help='Apply content filters to display the '
3373
'convenience form.'),
1648
"""Write a file's text from a previous revision."""
1650
takes_options = ['revision']
3376
1651
takes_args = ['filename']
3377
encoding_type = 'exact'
3379
1653
@display_command
3380
def run(self, filename, revision=None, name_from_revision=False,
3381
filters=False, directory=None):
1654
def run(self, filename, revision=None):
3382
1655
if revision is not None and len(revision) != 1:
3383
raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
3384
" one revision specifier"))
3385
tree, branch, relpath = \
3386
_open_directory_or_containing_tree_or_branch(filename, directory)
3387
self.add_cleanup(branch.lock_read().unlock)
3388
return self._run(tree, branch, relpath, filename, revision,
3389
name_from_revision, filters)
1656
raise BzrCommandError("bzr cat --revision takes exactly one number")
1659
tree, relpath = WorkingTree.open_containing(filename)
1661
except NotBranchError:
3391
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
3393
1664
if tree is None:
3394
tree = b.basis_tree()
3395
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
3396
self.add_cleanup(rev_tree.lock_read().unlock)
3398
old_file_id = rev_tree.path2id(relpath)
3400
# TODO: Split out this code to something that generically finds the
3401
# best id for a path across one or more trees; it's like
3402
# find_ids_across_trees but restricted to find just one. -- mbp
3404
if name_from_revision:
3405
# Try in revision if requested
3406
if old_file_id is None:
3407
raise errors.BzrCommandError(gettext(
3408
"{0!r} is not present in revision {1}").format(
3409
filename, rev_tree.get_revision_id()))
3411
actual_file_id = old_file_id
3413
cur_file_id = tree.path2id(relpath)
3414
if cur_file_id is not None and rev_tree.has_id(cur_file_id):
3415
actual_file_id = cur_file_id
3416
elif old_file_id is not None:
3417
actual_file_id = old_file_id
3419
raise errors.BzrCommandError(gettext(
3420
"{0!r} is not present in revision {1}").format(
3421
filename, rev_tree.get_revision_id()))
3423
from bzrlib.filter_tree import ContentFilterTree
3424
filter_tree = ContentFilterTree(rev_tree,
3425
rev_tree._content_filter_stack)
3426
content = filter_tree.get_file_text(actual_file_id)
3428
content = rev_tree.get_file_text(actual_file_id)
3430
self.outf.write(content)
1665
b, relpath = Branch.open_containing(filename)
1666
if revision is not None and revision[0].get_branch() is not None:
1667
b = Branch.open(revision[0].get_branch())
1668
if revision is None:
1669
revision_id = b.last_revision()
1671
revision_id = revision[0].in_history(b).rev_id
1672
b.print_file(relpath, revision_id)
3433
1675
class cmd_local_time_offset(Command):
3434
__doc__ = """Show the offset in seconds from GMT to local time."""
1676
"""Show the offset in seconds from GMT to local time."""
3436
1678
@display_command
3438
self.outf.write("%s\n" % osutils.local_time_offset())
1680
print osutils.local_time_offset()
3442
1684
class cmd_commit(Command):
3443
__doc__ = """Commit changes into a new revision.
3445
An explanatory message needs to be given for each commit. This is
3446
often done by using the --message option (getting the message from the
3447
command line) or by using the --file option (getting the message from
3448
a file). If neither of these options is given, an editor is opened for
3449
the user to enter the message. To see the changed files in the
3450
boilerplate text loaded into the editor, use the --show-diff option.
3452
By default, the entire tree is committed and the person doing the
3453
commit is assumed to be the author. These defaults can be overridden
3458
If selected files are specified, only changes to those files are
3459
committed. If a directory is specified then the directory and
3460
everything within it is committed.
3462
When excludes are given, they take precedence over selected files.
3463
For example, to commit only changes within foo, but not changes
3466
bzr commit foo -x foo/bar
3468
A selective commit after a merge is not yet supported.
3472
If the author of the change is not the same person as the committer,
3473
you can specify the author's name using the --author option. The
3474
name should be in the same format as a committer-id, e.g.
3475
"John Doe <jdoe@example.com>". If there is more than one author of
3476
the change you can specify the option multiple times, once for each
3481
A common mistake is to forget to add a new file or directory before
3482
running the commit command. The --strict option checks for unknown
3483
files and aborts the commit if any are found. More advanced pre-commit
3484
checks can be implemented by defining hooks. See ``bzr help hooks``
3489
If you accidentially commit the wrong changes or make a spelling
3490
mistake in the commit message say, you can use the uncommit command
3491
to undo it. See ``bzr help uncommit`` for details.
3493
Hooks can also be configured to run after a commit. This allows you
3494
to trigger updates to external systems like bug trackers. The --fixes
3495
option can be used to record the association between a revision and
3496
one or more bugs. See ``bzr help bugs`` for details.
1685
"""Commit changes into a new revision.
1687
If no arguments are given, the entire tree is committed.
1689
If selected files are specified, only changes to those files are
1690
committed. If a directory is specified then the directory and everything
1691
within it is committed.
1693
A selected-file commit may fail in some cases where the committed
1694
tree would be invalid, such as trying to commit a file in a
1695
newly-added directory that is not itself committed.
3499
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
1697
# TODO: Run hooks on tree to-be-committed, and after commit.
1699
# TODO: Strict commit that fails if there are deleted files.
1700
# (what does "deleted files" mean ??)
1702
# TODO: Give better message for -s, --summary, used by tla people
1704
# XXX: verbose currently does nothing
3500
1706
takes_args = ['selected*']
3502
ListOption('exclude', type=str, short_name='x',
3503
help="Do not consider changes made to a given path."),
3504
Option('message', type=unicode,
3506
help="Description of the new revision."),
3509
help='Commit even if nothing has changed.'),
3510
Option('file', type=str,
3513
help='Take commit message from this file.'),
3515
help="Refuse to commit if there are unknown "
3516
"files in the working tree."),
3517
Option('commit-time', type=str,
3518
help="Manually set a commit time using commit date "
3519
"format, e.g. '2009-10-10 08:00:00 +0100'."),
3520
ListOption('fixes', type=str,
3521
help="Mark a bug as being fixed by this revision "
3522
"(see \"bzr help bugs\")."),
3523
ListOption('author', type=unicode,
3524
help="Set the author's name, if it's different "
3525
"from the committer."),
3527
help="Perform a local commit in a bound "
3528
"branch. Local commits are not pushed to "
3529
"the master branch until a normal commit "
3532
Option('show-diff', short_name='p',
3533
help='When no message is supplied, show the diff along'
3534
' with the status summary in the message editor.'),
3536
help='When committing to a foreign version control '
3537
'system do not push data that can not be natively '
1707
takes_options = ['message', 'verbose',
1709
help='commit even if nothing has changed'),
1710
Option('file', type=str,
1712
help='file containing commit message'),
1714
help="refuse to commit if there are unknown "
1715
"files in the working tree."),
1717
help="perform a local only commit in a bound "
1718
"branch. Such commits are not pushed to "
1719
"the master branch until a normal commit "
3540
1723
aliases = ['ci', 'checkin']
3542
def _iter_bug_fix_urls(self, fixes, branch):
3543
default_bugtracker = None
3544
# Configure the properties for bug fixing attributes.
3545
for fixed_bug in fixes:
3546
tokens = fixed_bug.split(':')
3547
if len(tokens) == 1:
3548
if default_bugtracker is None:
3549
branch_config = branch.get_config_stack()
3550
default_bugtracker = branch_config.get(
3552
if default_bugtracker is None:
3553
raise errors.BzrCommandError(gettext(
3554
"No tracker specified for bug %s. Use the form "
3555
"'tracker:id' or specify a default bug tracker "
3556
"using the `bugtracker` option.\nSee "
3557
"\"bzr help bugs\" for more information on this "
3558
"feature. Commit refused.") % fixed_bug)
3559
tag = default_bugtracker
3561
elif len(tokens) != 2:
3562
raise errors.BzrCommandError(gettext(
3563
"Invalid bug %s. Must be in the form of 'tracker:id'. "
3564
"See \"bzr help bugs\" for more information on this "
3565
"feature.\nCommit refused.") % fixed_bug)
3567
tag, bug_id = tokens
3569
yield bugtracker.get_bug_url(tag, branch, bug_id)
3570
except errors.UnknownBugTrackerAbbreviation:
3571
raise errors.BzrCommandError(gettext(
3572
'Unrecognized bug %s. Commit refused.') % fixed_bug)
3573
except errors.MalformedBugIdentifier, e:
3574
raise errors.BzrCommandError(gettext(
3575
"%s\nCommit refused.") % (str(e),))
3577
def run(self, message=None, file=None, verbose=False, selected_list=None,
3578
unchanged=False, strict=False, local=False, fixes=None,
3579
author=None, show_diff=False, exclude=None, commit_time=None,
3581
from bzrlib.errors import (
3586
from bzrlib.msgeditor import (
3587
edit_commit_message_encoded,
3588
generate_commit_message_template,
3589
make_commit_message_template_encoded,
3593
commit_stamp = offset = None
3594
if commit_time is not None:
3596
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3597
except ValueError, e:
3598
raise errors.BzrCommandError(gettext(
3599
"Could not parse --commit-time: " + str(e)))
3603
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
1725
def run(self, message=None, file=None, verbose=True, selected_list=None,
1726
unchanged=False, strict=False, local=False):
1727
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1728
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1730
from bzrlib.msgeditor import edit_commit_message, \
1731
make_commit_message_template
1732
from tempfile import TemporaryFile
1734
# TODO: Need a blackbox test for invoking the external editor; may be
1735
# slightly problematic to run this cross-platform.
1737
# TODO: do more checks that the commit will succeed before
1738
# spending the user's valuable time typing a commit message.
1740
# TODO: if the commit *does* happen to fail, then save the commit
1741
# message to a temporary file where it can be recovered
1742
tree, selected_list = tree_files(selected_list)
3604
1743
if selected_list == ['']:
3605
1744
# workaround - commit of root of tree should be exactly the same
3606
1745
# as just default commit in that tree, and succeed even though
3607
1746
# selected-file merge commit is not done yet
3608
1747
selected_list = []
3612
bug_property = bugtracker.encode_fixes_bug_urls(
3613
self._iter_bug_fix_urls(fixes, tree.branch))
3615
properties['bugs'] = bug_property
3617
1749
if local and not tree.branch.get_bound_location():
3618
1750
raise errors.LocalRequiresBoundBranch()
3620
if message is not None:
3622
file_exists = osutils.lexists(message)
3623
except UnicodeError:
3624
# The commit message contains unicode characters that can't be
3625
# represented in the filesystem encoding, so that can't be a
3630
'The commit message is a file name: "%(f)s".\n'
3631
'(use --file "%(f)s" to take commit message from that file)'
3633
ui.ui_factory.show_warning(warning_msg)
3635
message = message.replace('\r\n', '\n')
3636
message = message.replace('\r', '\n')
3638
raise errors.BzrCommandError(gettext(
3639
"please specify either --message or --file"))
3641
def get_message(commit_obj):
3642
"""Callback to get commit message"""
3646
my_message = f.read().decode(osutils.get_user_encoding())
3649
elif message is not None:
3650
my_message = message
3652
# No message supplied: make one up.
3653
# text is the status of the tree
3654
text = make_commit_message_template_encoded(tree,
3655
selected_list, diff=show_diff,
3656
output_encoding=osutils.get_user_encoding())
3657
# start_message is the template generated from hooks
3658
# XXX: Warning - looks like hooks return unicode,
3659
# make_commit_message_template_encoded returns user encoding.
3660
# We probably want to be using edit_commit_message instead to
3662
my_message = set_commit_message(commit_obj)
3663
if my_message is None:
3664
start_message = generate_commit_message_template(commit_obj)
3665
my_message = edit_commit_message_encoded(text,
3666
start_message=start_message)
3667
if my_message is None:
3668
raise errors.BzrCommandError(gettext("please specify a commit"
3669
" message with either --message or --file"))
3670
if my_message == "":
3671
raise errors.BzrCommandError(gettext("Empty commit message specified."
3672
" Please specify a commit message with either"
3673
" --message or --file or leave a blank message"
3674
" with --message \"\"."))
3677
# The API permits a commit with a filter of [] to mean 'select nothing'
3678
# but the command line should not do that.
3679
if not selected_list:
3680
selected_list = None
1751
if message is None and not file:
1752
template = make_commit_message_template(tree, selected_list)
1753
message = edit_commit_message(template)
1755
raise BzrCommandError("please specify a commit message"
1756
" with either --message or --file")
1757
elif message and file:
1758
raise BzrCommandError("please specify either --message or --file")
1761
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1764
raise BzrCommandError("empty commit message specified")
1767
reporter = ReportCommitToLog()
1769
reporter = NullCommitReporter()
3682
tree.commit(message_callback=get_message,
3683
specific_files=selected_list,
1772
tree.commit(message, specific_files=selected_list,
3684
1773
allow_pointless=unchanged, strict=strict, local=local,
3685
reporter=None, verbose=verbose, revprops=properties,
3686
authors=author, timestamp=commit_stamp,
3688
exclude=tree.safe_relpath_files(exclude),
3690
1775
except PointlessCommit:
3691
raise errors.BzrCommandError(gettext("No changes to commit."
3692
" Please 'bzr add' the files you want to commit, or use"
3693
" --unchanged to force an empty commit."))
1776
# FIXME: This should really happen before the file is read in;
1777
# perhaps prepare the commit; get the message; then actually commit
1778
raise BzrCommandError("no changes to commit."
1779
" use --unchanged to commit anyhow")
3694
1780
except ConflictsInTree:
3695
raise errors.BzrCommandError(gettext('Conflicts detected in working '
3696
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
1781
raise BzrCommandError("Conflicts detected in working tree. "
1782
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
3698
1783
except StrictCommitFailed:
3699
raise errors.BzrCommandError(gettext("Commit refused because there are"
3700
" unknown files in the working tree."))
1784
raise BzrCommandError("Commit refused because there are unknown "
1785
"files in the working tree.")
3701
1786
except errors.BoundBranchOutOfDate, e:
3702
e.extra_help = (gettext("\n"
1787
raise BzrCommandError(str(e) + "\n"
3703
1788
'To commit to master branch, run update and then commit.\n'
3704
1789
'You can also pass --local to commit to continue working '
3709
1792
class cmd_check(Command):
3710
__doc__ = """Validate working tree structure, branch consistency and repository history.
3712
This command checks various invariants about branch and repository storage
3713
to detect data corruption or bzr bugs.
3715
The working tree and branch checks will only give output if a problem is
3716
detected. The output fields of the repository check are:
3719
This is just the number of revisions checked. It doesn't
3723
This is just the number of versionedfiles checked. It
3724
doesn't indicate a problem.
3726
unreferenced ancestors
3727
Texts that are ancestors of other texts, but
3728
are not properly referenced by the revision ancestry. This is a
3729
subtle problem that Bazaar can work around.
3732
This is the total number of unique file contents
3733
seen in the checked revisions. It does not indicate a problem.
3736
This is the total number of repeated texts seen
3737
in the checked revisions. Texts can be repeated when their file
3738
entries are modified, but the file contents are not. It does not
3741
If no restrictions are specified, all Bazaar data that is found at the given
3742
location will be checked.
3746
Check the tree and branch at 'foo'::
3748
bzr check --tree --branch foo
3750
Check only the repository at 'bar'::
3752
bzr check --repo bar
3754
Check everything at 'baz'::
1793
"""Validate consistency of branch history.
1795
This command checks various invariants about the branch storage to
1796
detect data corruption or bzr bugs.
3759
_see_also = ['reconcile']
3760
takes_args = ['path?']
3761
takes_options = ['verbose',
3762
Option('branch', help="Check the branch related to the"
3763
" current directory."),
3764
Option('repo', help="Check the repository related to the"
3765
" current directory."),
3766
Option('tree', help="Check the working tree related to"
3767
" the current directory.")]
3769
def run(self, path=None, verbose=False, branch=False, repo=False,
3771
from bzrlib.check import check_dwim
3774
if not branch and not repo and not tree:
3775
branch = repo = tree = True
3776
check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
1798
takes_args = ['branch?']
1799
takes_options = ['verbose']
1801
def run(self, branch=None, verbose=False):
1802
from bzrlib.check import check
1804
tree = WorkingTree.open_containing()[0]
1805
branch = tree.branch
1807
branch = Branch.open(branch)
1808
check(branch, verbose)
1811
class cmd_scan_cache(Command):
1814
from bzrlib.hashcache import HashCache
1820
print '%6d stats' % c.stat_count
1821
print '%6d in hashcache' % len(c._cache)
1822
print '%6d files removed from cache' % c.removed_count
1823
print '%6d hashes updated' % c.update_count
1824
print '%6d files changed too recently to cache' % c.danger_count
3779
1830
class cmd_upgrade(Command):
3780
__doc__ = """Upgrade a repository, branch or working tree to a newer format.
3782
When the default format has changed after a major new release of
3783
Bazaar, you may be informed during certain operations that you
3784
should upgrade. Upgrading to a newer format may improve performance
3785
or make new features available. It may however limit interoperability
3786
with older repositories or with older versions of Bazaar.
3788
If you wish to upgrade to a particular format rather than the
3789
current default, that can be specified using the --format option.
3790
As a consequence, you can use the upgrade command this way to
3791
"downgrade" to an earlier format, though some conversions are
3792
a one way process (e.g. changing from the 1.x default to the
3793
2.x default) so downgrading is not always possible.
3795
A backup.bzr.~#~ directory is created at the start of the conversion
3796
process (where # is a number). By default, this is left there on
3797
completion. If the conversion fails, delete the new .bzr directory
3798
and rename this one back in its place. Use the --clean option to ask
3799
for the backup.bzr directory to be removed on successful conversion.
3800
Alternatively, you can delete it by hand if everything looks good
3803
If the location given is a shared repository, dependent branches
3804
are also converted provided the repository converts successfully.
3805
If the conversion of a branch fails, remaining branches are still
3808
For more information on upgrades, see the Bazaar Upgrade Guide,
3809
http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
1831
"""Upgrade branch storage to current format.
1833
The check command or bzr developers may sometimes advise you to run
1834
this command. When the default format has changed you may also be warned
1835
during other operations to upgrade.
3812
_see_also = ['check', 'reconcile', 'formats']
3813
1837
takes_args = ['url?']
3814
1838
takes_options = [
3815
RegistryOption('format',
3816
help='Upgrade to a specific format. See "bzr help'
3817
' formats" for details.',
3818
lazy_registry=('bzrlib.controldir', 'format_registry'),
3819
converter=lambda name: controldir.format_registry.make_bzrdir(name),
3820
value_switches=True, title='Branch format'),
3822
help='Remove the backup.bzr directory if successful.'),
3824
help="Show what would be done, but don't actually do anything."),
3827
def run(self, url='.', format=None, clean=False, dry_run=False):
1840
help='Upgrade to a specific format. Current formats'
1841
' are: default, knit, metaweave and weave.'
1842
' Default is knit; metaweave and weave are'
1844
type=get_format_type),
1848
def run(self, url='.', format=None):
3828
1849
from bzrlib.upgrade import upgrade
3829
exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3831
if len(exceptions) == 1:
3832
# Compatibility with historical behavior
1851
format = get_format_type('default')
1852
upgrade(url, format)
3838
1855
class cmd_whoami(Command):
3839
__doc__ = """Show or set bzr user id.
3842
Show the email of the current user::
3846
Set the current user::
3848
bzr whoami "Frank Chu <fchu@example.com>"
1856
"""Show or set bzr user id.
1860
bzr whoami 'Frank Chu <fchu@example.com>'
3850
takes_options = [ 'directory',
3852
help='Display email address only.'),
1862
takes_options = [ Option('email',
1863
help='display email address only'),
3853
1864
Option('branch',
3854
help='Set identity for the current branch instead of '
1865
help='set identity for the current branch instead of '
3857
1868
takes_args = ['name?']
3858
1869
encoding_type = 'replace'
3860
1871
@display_command
3861
def run(self, email=False, branch=False, name=None, directory=None):
1872
def run(self, email=False, branch=False, name=None):
3862
1873
if name is None:
3863
if directory is None:
3864
# use branch if we're inside one; otherwise global config
3866
c = Branch.open_containing(u'.')[0].get_config_stack()
3867
except errors.NotBranchError:
3868
c = _mod_config.GlobalStack()
3870
c = Branch.open(directory).get_config_stack()
3871
identity = c.get('email')
1874
# use branch if we're inside one; otherwise global config
1876
c = Branch.open_containing('.')[0].get_config()
1877
except NotBranchError:
1878
c = config.GlobalConfig()
3873
self.outf.write(_mod_config.extract_email_address(identity)
1880
self.outf.write(c.user_email() + '\n')
3876
self.outf.write(identity + '\n')
1882
self.outf.write(c.username() + '\n')
3880
raise errors.BzrCommandError(gettext("--email can only be used to display existing "
3883
1885
# display a warning if an email address isn't included in the given name.
3885
_mod_config.extract_email_address(name)
3886
except errors.NoEmailInUsername, e:
1887
config.extract_email_address(name)
3887
1889
warning('"%s" does not seem to contain an email address. '
3888
1890
'This is allowed, but not recommended.', name)
3890
1892
# use global config unless --branch given
3892
if directory is None:
3893
c = Branch.open_containing(u'.')[0].get_config_stack()
3895
b = Branch.open(directory)
3896
self.add_cleanup(b.lock_write().unlock)
3897
c = b.get_config_stack()
1894
c = Branch.open_containing('.')[0].get_config()
3899
c = _mod_config.GlobalStack()
3900
c.set('email', name)
1896
c = config.GlobalConfig()
1897
c.set_user_option('email', name)
3903
1900
class cmd_nick(Command):
3904
__doc__ = """Print or set the branch nickname.
3906
If unset, the colocated branch name is used for colocated branches, and
3907
the branch directory name is used for other branches. To print the
3908
current nickname, execute with no argument.
3910
Bound branches use the nickname of its master branch unless it is set
1901
"""Print or set the branch nickname.
1903
If unset, the tree root directory name is used as the nickname
1904
To print the current nickname, execute with no argument.
3914
_see_also = ['info']
3915
1906
takes_args = ['nickname?']
3916
takes_options = ['directory']
3917
def run(self, nickname=None, directory=u'.'):
3918
branch = Branch.open_containing(directory)[0]
1907
def run(self, nickname=None):
1908
branch = Branch.open_containing(u'.')[0]
3919
1909
if nickname is None:
3920
1910
self.printme(branch)
3924
1914
@display_command
3925
1915
def printme(self, branch):
3926
self.outf.write('%s\n' % branch.nick)
3929
class cmd_alias(Command):
3930
__doc__ = """Set/unset and display aliases.
3933
Show the current aliases::
3937
Show the alias specified for 'll'::
3941
Set an alias for 'll'::
3943
bzr alias ll="log --line -r-10..-1"
3945
To remove an alias for 'll'::
3947
bzr alias --remove ll
3950
takes_args = ['name?']
3952
Option('remove', help='Remove the alias.'),
3955
def run(self, name=None, remove=False):
3957
self.remove_alias(name)
3959
self.print_aliases()
3961
equal_pos = name.find('=')
3963
self.print_alias(name)
3965
self.set_alias(name[:equal_pos], name[equal_pos+1:])
3967
def remove_alias(self, alias_name):
3968
if alias_name is None:
3969
raise errors.BzrCommandError(gettext(
3970
'bzr alias --remove expects an alias to remove.'))
3971
# If alias is not found, print something like:
3972
# unalias: foo: not found
3973
c = _mod_config.GlobalConfig()
3974
c.unset_alias(alias_name)
3977
def print_aliases(self):
3978
"""Print out the defined aliases in a similar format to bash."""
3979
aliases = _mod_config.GlobalConfig().get_aliases()
3980
for key, value in sorted(aliases.iteritems()):
3981
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3984
def print_alias(self, alias_name):
3985
from bzrlib.commands import get_alias
3986
alias = get_alias(alias_name)
3988
self.outf.write("bzr alias: %s: not found\n" % alias_name)
3991
'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
3993
def set_alias(self, alias_name, alias_command):
3994
"""Save the alias in the global config."""
3995
c = _mod_config.GlobalConfig()
3996
c.set_alias(alias_name, alias_command)
3999
1919
class cmd_selftest(Command):
4000
__doc__ = """Run internal test suite.
4002
If arguments are given, they are regular expressions that say which tests
4003
should run. Tests matching any expression are run, and other tests are
4006
Alternatively if --first is given, matching tests are run first and then
4007
all other tests are run. This is useful if you have been working in a
4008
particular area, but want to make sure nothing else was broken.
4010
If --exclude is given, tests that match that regular expression are
4011
excluded, regardless of whether they match --first or not.
4013
To help catch accidential dependencies between tests, the --randomize
4014
option is useful. In most cases, the argument used is the word 'now'.
4015
Note that the seed used for the random number generator is displayed
4016
when this option is used. The seed can be explicitly passed as the
4017
argument to this option if required. This enables reproduction of the
4018
actual ordering used if and when an order sensitive problem is encountered.
4020
If --list-only is given, the tests that would be run are listed. This is
4021
useful when combined with --first, --exclude and/or --randomize to
4022
understand their impact. The test harness reports "Listed nn tests in ..."
4023
instead of "Ran nn tests in ..." when list mode is enabled.
1920
"""Run internal test suite.
1922
This creates temporary test directories in the working directory,
1923
but not existing data is affected. These directories are deleted
1924
if the tests pass, or left behind to help in debugging if they
1925
fail and --keep-output is specified.
1927
If arguments are given, they are regular expressions that say
1928
which tests should run.
4025
1930
If the global option '--no-plugins' is given, plugins are not loaded
4026
1931
before running the selftests. This has two effects: features provided or
4027
1932
modified by plugins will not be tested, and tests provided by plugins will
4030
Tests that need working space on disk use a common temporary directory,
4031
typically inside $TMPDIR or /tmp.
4033
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
4034
into a pdb postmortem session.
4036
The --coverage=DIRNAME global option produces a report with covered code
4040
Run only tests relating to 'ignore'::
4044
Disable plugins and list tests as they're run::
4046
bzr --no-plugins selftest -v
1937
bzr --no-plugins selftest -v
1939
# TODO: --list should give a list of all available tests
4048
1941
# NB: this is used from the class without creating an instance, which is
4049
1942
# why it does not have a self parameter.
4050
1943
def get_transport_type(typestring):
4051
1944
"""Parse and return a transport specifier."""
4052
1945
if typestring == "sftp":
4053
from bzrlib.tests import stub_sftp
4054
return stub_sftp.SFTPAbsoluteServer
4055
elif typestring == "memory":
4056
from bzrlib.tests import test_server
4057
return memory.MemoryServer
4058
elif typestring == "fakenfs":
4059
from bzrlib.tests import test_server
4060
return test_server.FakeNFSServer
1946
from bzrlib.transport.sftp import SFTPAbsoluteServer
1947
return SFTPAbsoluteServer
1948
if typestring == "memory":
1949
from bzrlib.transport.memory import MemoryServer
1951
if typestring == "fakenfs":
1952
from bzrlib.transport.fakenfs import FakeNFSServer
1953
return FakeNFSServer
4061
1954
msg = "No known transport type %s. Supported types are: sftp\n" %\
4063
raise errors.BzrCommandError(msg)
1956
raise BzrCommandError(msg)
4066
1959
takes_args = ['testspecs*']
4067
1960
takes_options = ['verbose',
4069
help='Stop when one test fails.',
1961
Option('one', help='stop when one test fails'),
1962
Option('keep-output',
1963
help='keep output directories when tests fail'),
4073
1965
help='Use a different transport by default '
4074
1966
'throughout the test suite.',
4075
1967
type=get_transport_type),
4077
help='Run the benchmarks rather than selftests.',
1968
Option('benchmark', help='run the bzr bencharks.'),
4079
1969
Option('lsprof-timed',
4080
help='Generate lsprof output for benchmarked'
1970
help='generate lsprof output for benchmarked'
4081
1971
' sections of code.'),
4082
Option('lsprof-tests',
4083
help='Generate lsprof output for each test.'),
4085
help='Run all tests, but run specified tests first.',
4089
help='List the tests instead of running them.'),
4090
RegistryOption('parallel',
4091
help="Run the test suite in parallel.",
4092
lazy_registry=('bzrlib.tests', 'parallel_registry'),
4093
value_switches=False,
4095
Option('randomize', type=str, argname="SEED",
4096
help='Randomize the order of tests using the given'
4097
' seed or "now" for the current time.'),
4098
ListOption('exclude', type=str, argname="PATTERN",
4100
help='Exclude tests that match this regular'
4103
help='Output test progress via subunit.'),
4104
Option('strict', help='Fail on missing dependencies or '
4106
Option('load-list', type=str, argname='TESTLISTFILE',
4107
help='Load a test id list from a text file.'),
4108
ListOption('debugflag', type=str, short_name='E',
4109
help='Turn on a selftest debug flag.'),
4110
ListOption('starting-with', type=str, argname='TESTID',
4111
param_name='starting_with', short_name='s',
4113
'Load only the tests starting with TESTID.'),
4115
help="By default we disable fsync and fdatasync"
4116
" while running the test suite.")
1972
Option('cache-dir', type=str,
1973
help='a directory to cache intermediate'
1974
' benchmark steps'),
4118
encoding_type = 'replace'
4121
Command.__init__(self)
4122
self.additional_selftest_args = {}
4124
def run(self, testspecs_list=None, verbose=False, one=False,
4125
transport=None, benchmark=None,
4127
first=False, list_only=False,
4128
randomize=None, exclude=None, strict=False,
4129
load_list=None, debugflag=None, starting_with=None, subunit=False,
4130
parallel=None, lsprof_tests=False,
4133
# During selftest, disallow proxying, as it can cause severe
4134
# performance penalties and is only needed for thread
4135
# safety. The selftest command is assumed to not use threads
4136
# too heavily. The call should be as early as possible, as
4137
# error reporting for past duplicate imports won't have useful
4139
lazy_import.disallow_proxying()
4141
from bzrlib import tests
4143
if testspecs_list is not None:
4144
pattern = '|'.join(testspecs_list)
1977
def run(self, testspecs_list=None, verbose=None, one=False,
1978
keep_output=False, transport=None, benchmark=None,
1979
lsprof_timed=None, cache_dir=None):
1981
from bzrlib.tests import selftest
1982
import bzrlib.benchmarks as benchmarks
1983
from bzrlib.benchmarks import tree_creator
1985
if cache_dir is not None:
1986
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
1987
# we don't want progress meters from the tests to go to the
1988
# real output; and we don't want log messages cluttering up
1990
save_ui = ui.ui_factory
1991
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1992
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1994
info('running tests...')
1996
ui.ui_factory = ui.SilentUIFactory()
1997
if testspecs_list is not None:
1998
pattern = '|'.join(testspecs_list)
2002
test_suite_factory = benchmarks.test_suite
2005
benchfile = open(".perf_history", "at")
2007
test_suite_factory = None
4149
from bzrlib.tests import SubUnitBzrRunner
4151
raise errors.BzrCommandError(gettext("subunit not available. subunit "
4152
"needs to be installed to use --subunit."))
4153
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
4154
# On Windows, disable automatic conversion of '\n' to '\r\n' in
4155
# stdout, which would corrupt the subunit stream.
4156
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
4157
# following code can be deleted when it's sufficiently deployed
4158
# -- vila/mgz 20100514
4159
if (sys.platform == "win32"
4160
and getattr(sys.stdout, 'fileno', None) is not None):
4162
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
4164
self.additional_selftest_args.setdefault(
4165
'suite_decorators', []).append(parallel)
4167
raise errors.BzrCommandError(gettext(
4168
"--benchmark is no longer supported from bzr 2.2; "
4169
"use bzr-usertest instead"))
4170
test_suite_factory = None
4172
exclude_pattern = None
4174
exclude_pattern = '(' + '|'.join(exclude) + ')'
4176
self._disable_fsync()
4177
selftest_kwargs = {"verbose": verbose,
4179
"stop_on_failure": one,
4180
"transport": transport,
4181
"test_suite_factory": test_suite_factory,
4182
"lsprof_timed": lsprof_timed,
4183
"lsprof_tests": lsprof_tests,
4184
"matching_tests_first": first,
4185
"list_only": list_only,
4186
"random_seed": randomize,
4187
"exclude_pattern": exclude_pattern,
4189
"load_list": load_list,
4190
"debug_flags": debugflag,
4191
"starting_with": starting_with
4193
selftest_kwargs.update(self.additional_selftest_args)
4195
# Make deprecation warnings visible, unless -Werror is set
4196
cleanup = symbol_versioning.activate_deprecation_warnings(
4199
result = tests.selftest(**selftest_kwargs)
2012
result = selftest(verbose=verbose,
2014
stop_on_failure=one,
2015
keep_output=keep_output,
2016
transport=transport,
2017
test_suite_factory=test_suite_factory,
2018
lsprof_timed=lsprof_timed,
2019
bench_history=benchfile)
2021
if benchfile is not None:
2024
info('tests passed')
2026
info('tests failed')
2027
return int(not result)
4202
return int(not result)
4204
def _disable_fsync(self):
4205
"""Change the 'os' functionality to not synchronize."""
4206
self._orig_fsync = getattr(os, 'fsync', None)
4207
if self._orig_fsync is not None:
4208
os.fsync = lambda filedes: None
4209
self._orig_fdatasync = getattr(os, 'fdatasync', None)
4210
if self._orig_fdatasync is not None:
4211
os.fdatasync = lambda filedes: None
2029
ui.ui_factory = save_ui
4214
2032
class cmd_version(Command):
4215
__doc__ = """Show version of bzr."""
4217
encoding_type = 'replace'
4219
Option("short", help="Print just the version number."),
2033
"""Show version of bzr."""
4222
2035
@display_command
4223
def run(self, short=False):
4224
2037
from bzrlib.version import show_version
4226
self.outf.write(bzrlib.version_string + '\n')
4228
show_version(to_file=self.outf)
4231
2041
class cmd_rocks(Command):
4232
__doc__ = """Statement of optimism."""
2042
"""Statement of optimism."""
4236
2046
@display_command
4238
self.outf.write(gettext("It sure does!\n"))
2048
print "it sure does!"
4241
2051
class cmd_find_merge_base(Command):
4242
__doc__ = """Find and print a base revision for merging two branches."""
2052
"""Find and print a base revision for merging two branches."""
4243
2053
# TODO: Options to specify revisions on either side, as if
4244
2054
# merging only part of the history.
4245
2055
takes_args = ['branch', 'other']
4248
2058
@display_command
4249
2059
def run(self, branch, other):
4250
from bzrlib.revision import ensure_null
2060
from bzrlib.revision import common_ancestor, MultipleRevisionSources
4252
2062
branch1 = Branch.open_containing(branch)[0]
4253
2063
branch2 = Branch.open_containing(other)[0]
4254
self.add_cleanup(branch1.lock_read().unlock)
4255
self.add_cleanup(branch2.lock_read().unlock)
4256
last1 = ensure_null(branch1.last_revision())
4257
last2 = ensure_null(branch2.last_revision())
4259
graph = branch1.repository.get_graph(branch2.repository)
4260
base_rev_id = graph.find_unique_lca(last1, last2)
4262
self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
2065
history_1 = branch1.revision_history()
2066
history_2 = branch2.revision_history()
2068
last1 = branch1.last_revision()
2069
last2 = branch2.last_revision()
2071
source = MultipleRevisionSources(branch1.repository,
2074
base_rev_id = common_ancestor(last1, last2, source)
2076
print 'merge base is revision %s' % base_rev_id
4265
2079
class cmd_merge(Command):
4266
__doc__ = """Perform a three-way merge.
4268
The source of the merge can be specified either in the form of a branch,
4269
or in the form of a path to a file containing a merge directive generated
4270
with bzr send. If neither is specified, the default is the upstream branch
4271
or the branch most recently merged using --remember. The source of the
4272
merge may also be specified in the form of a path to a file in another
4273
branch: in this case, only the modifications to that file are merged into
4274
the current working tree.
4276
When merging from a branch, by default bzr will try to merge in all new
4277
work from the other branch, automatically determining an appropriate base
4278
revision. If this fails, you may need to give an explicit base.
4280
To pick a different ending revision, pass "--revision OTHER". bzr will
4281
try to merge in all new work up to and including revision OTHER.
4283
If you specify two values, "--revision BASE..OTHER", only revisions BASE
4284
through OTHER, excluding BASE but including OTHER, will be merged. If this
4285
causes some revisions to be skipped, i.e. if the destination branch does
4286
not already contain revision BASE, such a merge is commonly referred to as
4287
a "cherrypick". Unlike a normal merge, Bazaar does not currently track
4288
cherrypicks. The changes look like a normal commit, and the history of the
4289
changes from the other branch is not stored in the commit.
4291
Revision numbers are always relative to the source branch.
2080
"""Perform a three-way merge.
2082
The branch is the branch you will merge from. By default, it will merge
2083
the latest revision. If you specify a revision, that revision will be
2084
merged. If you specify two revisions, the first will be used as a BASE,
2085
and the second one as OTHER. Revision numbers are always relative to the
2088
By default, bzr will try to merge in all new work from the other
2089
branch, automatically determining an appropriate base. If this
2090
fails, you may need to give an explicit base.
4293
2092
Merge will do its best to combine the changes in two branches, but there
4294
2093
are some kinds of problems only a human can fix. When it encounters those,
4295
2094
it will mark a conflict. A conflict means that you need to fix something,
4296
before you can commit.
2095
before you should commit.
4298
2097
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
4300
If there is no default branch set, the first merge will set it (use
4301
--no-remember to avoid setting it). After that, you can omit the branch
4302
to use the default. To change the default, use --remember. The value will
4303
only be saved if the remote location can be accessed.
4305
The results of the merge are placed into the destination working
4306
directory, where they can be reviewed (with bzr diff), tested, and then
4307
committed to record the result of the merge.
2099
If there is no default branch set, the first merge will set it. After
2100
that, you can omit the branch to use the default. To change the
2101
default, use --remember. The value will only be saved if the remote
2102
location can be accessed.
2106
To merge the latest revision from bzr.dev
2107
bzr merge ../bzr.dev
2109
To merge changes up to and including revision 82 from bzr.dev
2110
bzr merge -r 82 ../bzr.dev
2112
To merge the changes introduced by 82, without previous changes:
2113
bzr merge -r 81..82 ../bzr.dev
4309
2115
merge refuses to run if there are any uncommitted changes, unless
4310
--force is given. If --force is given, then the changes from the source
4311
will be merged with the current working tree, including any uncommitted
4312
changes in the tree. The --force option can also be used to create a
4313
merge revision which has more than two parents.
4315
If one would like to merge changes from the working tree of the other
4316
branch without merging any committed revisions, the --uncommitted option
4319
To select only some changes to merge, use "merge -i", which will prompt
4320
you to apply each diff hunk and file change, similar to "shelve".
4323
To merge all new revisions from bzr.dev::
4325
bzr merge ../bzr.dev
4327
To merge changes up to and including revision 82 from bzr.dev::
4329
bzr merge -r 82 ../bzr.dev
4331
To merge the changes introduced by 82, without previous changes::
4333
bzr merge -r 81..82 ../bzr.dev
4335
To apply a merge directive contained in /tmp/merge::
4337
bzr merge /tmp/merge
4339
To create a merge revision with three parents from two branches
4340
feature1a and feature1b:
4342
bzr merge ../feature1a
4343
bzr merge ../feature1b --force
4344
bzr commit -m 'revision with three parents'
2118
The following merge types are available:
4347
encoding_type = 'exact'
4348
_see_also = ['update', 'remerge', 'status-flags', 'send']
4349
takes_args = ['location?']
4354
help='Merge even if the destination tree has uncommitted changes.'),
4358
Option('show-base', help="Show base revision text in "
4360
Option('uncommitted', help='Apply uncommitted changes'
4361
' from a working copy, instead of branch changes.'),
4362
Option('pull', help='If the destination is already'
4363
' completely merged into the source, pull from the'
4364
' source rather than merging. When this happens,'
4365
' you do not need to commit the result.'),
4366
custom_help('directory',
4367
help='Branch to merge into, '
4368
'rather than the one containing the working directory.'),
4369
Option('preview', help='Instead of merging, show a diff of the'
4371
Option('interactive', help='Select changes interactively.',
4375
def run(self, location=None, revision=None, force=False,
4376
merge_type=None, show_base=False, reprocess=None, remember=None,
4377
uncommitted=False, pull=False,
2120
takes_args = ['branch?']
2121
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2122
Option('show-base', help="Show base revision text in "
2124
Option('uncommitted', help='Apply uncommitted changes'
2125
' from a working copy, instead of branch changes')]
2128
from merge import merge_type_help
2129
from inspect import getdoc
2130
return getdoc(self) + '\n' + merge_type_help()
2132
def run(self, branch=None, revision=None, force=False, merge_type=None,
2133
show_base=False, reprocess=False, remember=False,
4382
2135
if merge_type is None:
4383
merge_type = _mod_merge.Merge3Merger
4385
if directory is None: directory = u'.'
4386
possible_transports = []
4388
allow_pending = True
4389
verified = 'inapplicable'
4391
tree = WorkingTree.open_containing(directory)[0]
4392
if tree.branch.revno() == 0:
4393
raise errors.BzrCommandError(gettext('Merging into empty branches not currently supported, '
4394
'https://bugs.launchpad.net/bzr/+bug/308562'))
4397
basis_tree = tree.revision_tree(tree.last_revision())
4398
except errors.NoSuchRevision:
4399
basis_tree = tree.basis_tree()
4401
# die as quickly as possible if there are uncommitted changes
4403
if tree.has_changes():
4404
raise errors.UncommittedChanges(tree)
4406
view_info = _get_view_info_for_change_reporter(tree)
4407
change_reporter = delta._ChangeReporter(
4408
unversioned_filter=tree.is_ignored, view_info=view_info)
2136
merge_type = Merge3Merger
2138
tree = WorkingTree.open_containing(u'.')[0]
2140
if branch is not None:
2142
reader = bundle.read_bundle_from_url(branch)
2144
pass # Continue on considering this url a Branch
2146
conflicts = merge_bundle(reader, tree, not force, merge_type,
2147
reprocess, show_base)
2153
if revision is None \
2154
or len(revision) < 1 or revision[0].needs_branch():
2155
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2157
if revision is None or len(revision) < 1:
2160
other = [branch, None]
2163
other = [branch, -1]
2164
other_branch, path = Branch.open_containing(branch)
2167
raise BzrCommandError('Cannot use --uncommitted and --revision'
2168
' at the same time.')
2169
branch = revision[0].get_branch() or branch
2170
if len(revision) == 1:
2172
other_branch, path = Branch.open_containing(branch)
2173
revno = revision[0].in_history(other_branch).revno
2174
other = [branch, revno]
2176
assert len(revision) == 2
2177
if None in revision:
2178
raise BzrCommandError(
2179
"Merge doesn't permit empty revision specifier.")
2180
base_branch, path = Branch.open_containing(branch)
2181
branch1 = revision[1].get_branch() or branch
2182
other_branch, path1 = Branch.open_containing(branch1)
2183
if revision[0].get_branch() is not None:
2184
# then path was obtained from it, and is None.
2187
base = [branch, revision[0].in_history(base_branch).revno]
2188
other = [branch1, revision[1].in_history(other_branch).revno]
2190
if tree.branch.get_parent() is None or remember:
2191
tree.branch.set_parent(other_branch.base)
2194
interesting_files = [path]
2196
interesting_files = None
4409
2197
pb = ui.ui_factory.nested_progress_bar()
4410
self.add_cleanup(pb.finished)
4411
self.add_cleanup(tree.lock_write().unlock)
4412
if location is not None:
4414
mergeable = bundle.read_mergeable_from_url(location,
4415
possible_transports=possible_transports)
4416
except errors.NotABundle:
2200
conflict_count = merge(other, base, check_clean=(not force),
2201
merge_type=merge_type,
2202
reprocess=reprocess,
2203
show_base=show_base,
2204
pb=pb, file_list=interesting_files)
2207
if conflict_count != 0:
4420
raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
4421
' with bundles or merge directives.'))
4423
if revision is not None:
4424
raise errors.BzrCommandError(gettext(
4425
'Cannot use -r with merge directives or bundles'))
4426
merger, verified = _mod_merge.Merger.from_mergeable(tree,
4429
if merger is None and uncommitted:
4430
if revision is not None and len(revision) > 0:
4431
raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
4432
' --revision at the same time.'))
4433
merger = self.get_merger_from_uncommitted(tree, location, None)
4434
allow_pending = False
4437
merger, allow_pending = self._get_merger_from_branch(tree,
4438
location, revision, remember, possible_transports, None)
4440
merger.merge_type = merge_type
4441
merger.reprocess = reprocess
4442
merger.show_base = show_base
4443
self.sanity_check_merger(merger)
4444
if (merger.base_rev_id == merger.other_rev_id and
4445
merger.other_rev_id is not None):
4446
# check if location is a nonexistent file (and not a branch) to
4447
# disambiguate the 'Nothing to do'
4448
if merger.interesting_files:
4449
if not merger.other_tree.has_filename(
4450
merger.interesting_files[0]):
4451
note(gettext("merger: ") + str(merger))
4452
raise errors.PathsDoNotExist([location])
4453
note(gettext('Nothing to do.'))
4455
if pull and not preview:
4456
if merger.interesting_files is not None:
4457
raise errors.BzrCommandError(gettext('Cannot pull individual files'))
4458
if (merger.base_rev_id == tree.last_revision()):
4459
result = tree.pull(merger.other_branch, False,
4460
merger.other_rev_id)
4461
result.report(self.outf)
4463
if merger.this_basis is None:
4464
raise errors.BzrCommandError(gettext(
4465
"This branch has no commits."
4466
" (perhaps you would prefer 'bzr pull')"))
4468
return self._do_preview(merger)
4470
return self._do_interactive(merger)
4472
return self._do_merge(merger, change_reporter, allow_pending,
4475
def _get_preview(self, merger):
4476
tree_merger = merger.make_merger()
4477
tt = tree_merger.make_preview_transform()
4478
self.add_cleanup(tt.finalize)
4479
result_tree = tt.get_preview_tree()
4482
def _do_preview(self, merger):
4483
from bzrlib.diff import show_diff_trees
4484
result_tree = self._get_preview(merger)
4485
path_encoding = osutils.get_diff_header_encoding()
4486
show_diff_trees(merger.this_tree, result_tree, self.outf,
4487
old_label='', new_label='',
4488
path_encoding=path_encoding)
4490
def _do_merge(self, merger, change_reporter, allow_pending, verified):
4491
merger.change_reporter = change_reporter
4492
conflict_count = merger.do_merge()
4494
merger.set_pending()
4495
if verified == 'failed':
4496
warning('Preview patch does not match changes')
4497
if conflict_count != 0:
4502
def _do_interactive(self, merger):
4503
"""Perform an interactive merge.
4505
This works by generating a preview tree of the merge, then using
4506
Shelver to selectively remove the differences between the working tree
4507
and the preview tree.
4509
from bzrlib import shelf_ui
4510
result_tree = self._get_preview(merger)
4511
writer = bzrlib.option.diff_writer_registry.get()
4512
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
4513
reporter=shelf_ui.ApplyReporter(),
4514
diff_writer=writer(sys.stdout))
4520
def sanity_check_merger(self, merger):
4521
if (merger.show_base and
4522
not merger.merge_type is _mod_merge.Merge3Merger):
4523
raise errors.BzrCommandError(gettext("Show-base is not supported for this"
4524
" merge type. %s") % merger.merge_type)
4525
if merger.reprocess is None:
4526
if merger.show_base:
4527
merger.reprocess = False
4529
# Use reprocess if the merger supports it
4530
merger.reprocess = merger.merge_type.supports_reprocess
4531
if merger.reprocess and not merger.merge_type.supports_reprocess:
4532
raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
4533
" for merge type %s.") %
4535
if merger.reprocess and merger.show_base:
4536
raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
4539
def _get_merger_from_branch(self, tree, location, revision, remember,
4540
possible_transports, pb):
4541
"""Produce a merger from a location, assuming it refers to a branch."""
4542
from bzrlib.tag import _merge_tags_if_possible
4543
# find the branch locations
4544
other_loc, user_location = self._select_branch_location(tree, location,
4546
if revision is not None and len(revision) == 2:
4547
base_loc, _unused = self._select_branch_location(tree,
4548
location, revision, 0)
4550
base_loc = other_loc
4552
other_branch, other_path = Branch.open_containing(other_loc,
4553
possible_transports)
4554
if base_loc == other_loc:
4555
base_branch = other_branch
4557
base_branch, base_path = Branch.open_containing(base_loc,
4558
possible_transports)
4559
# Find the revision ids
4560
other_revision_id = None
4561
base_revision_id = None
4562
if revision is not None:
4563
if len(revision) >= 1:
4564
other_revision_id = revision[-1].as_revision_id(other_branch)
4565
if len(revision) == 2:
4566
base_revision_id = revision[0].as_revision_id(base_branch)
4567
if other_revision_id is None:
4568
other_revision_id = _mod_revision.ensure_null(
4569
other_branch.last_revision())
4570
# Remember where we merge from. We need to remember if:
4571
# - user specify a location (and we don't merge from the parent
4573
# - user ask to remember or there is no previous location set to merge
4574
# from and user didn't ask to *not* remember
4575
if (user_location is not None
4577
or (remember is None
4578
and tree.branch.get_submit_branch() is None)))):
4579
tree.branch.set_submit_branch(other_branch.base)
4580
# Merge tags (but don't set them in the master branch yet, the user
4581
# might revert this merge). Commit will propagate them.
4582
_merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
4583
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4584
other_revision_id, base_revision_id, other_branch, base_branch)
4585
if other_path != '':
4586
allow_pending = False
4587
merger.interesting_files = [other_path]
4589
allow_pending = True
4590
return merger, allow_pending
4592
def get_merger_from_uncommitted(self, tree, location, pb):
4593
"""Get a merger for uncommitted changes.
4595
:param tree: The tree the merger should apply to.
4596
:param location: The location containing uncommitted changes.
4597
:param pb: The progress bar to use for showing progress.
4599
location = self._select_branch_location(tree, location)[0]
4600
other_tree, other_path = WorkingTree.open_containing(location)
4601
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree, pb)
4602
if other_path != '':
4603
merger.interesting_files = [other_path]
4606
def _select_branch_location(self, tree, user_location, revision=None,
4608
"""Select a branch location, according to possible inputs.
4610
If provided, branches from ``revision`` are preferred. (Both
4611
``revision`` and ``index`` must be supplied.)
4613
Otherwise, the ``location`` parameter is used. If it is None, then the
4614
``submit`` or ``parent`` location is used, and a note is printed.
4616
:param tree: The working tree to select a branch for merging into
4617
:param location: The location entered by the user
4618
:param revision: The revision parameter to the command
4619
:param index: The index to use for the revision parameter. Negative
4620
indices are permitted.
4621
:return: (selected_location, user_location). The default location
4622
will be the user-entered location.
4624
if (revision is not None and index is not None
4625
and revision[index] is not None):
4626
branch = revision[index].get_branch()
4627
if branch is not None:
4628
return branch, branch
4629
if user_location is None:
4630
location = self._get_remembered(tree, 'Merging from')
4632
location = user_location
4633
return location, user_location
4635
def _get_remembered(self, tree, verb_string):
2211
except errors.AmbiguousBase, e:
2212
m = ("sorry, bzr can't determine the right merge base yet\n"
2213
"candidates are:\n "
2214
+ "\n ".join(e.bases)
2216
"please specify an explicit base with -r,\n"
2217
"and (if you want) report this to the bzr developers\n")
2220
# TODO: move up to common parent; this isn't merge-specific anymore.
2221
def _get_remembered_parent(self, tree, supplied_location, verb_string):
4636
2222
"""Use tree.branch's parent if none was supplied.
4638
2224
Report if the remembered location was used.
4640
stored_location = tree.branch.get_submit_branch()
4641
stored_location_type = "submit"
4642
if stored_location is None:
4643
stored_location = tree.branch.get_parent()
4644
stored_location_type = "parent"
2226
if supplied_location is not None:
2227
return supplied_location
2228
stored_location = tree.branch.get_parent()
4645
2229
mutter("%s", stored_location)
4646
2230
if stored_location is None:
4647
raise errors.BzrCommandError(gettext("No location specified or remembered"))
4648
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4649
note(gettext("{0} remembered {1} location {2}").format(verb_string,
4650
stored_location_type, display_url))
2231
raise BzrCommandError("No location specified or remembered")
2232
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2233
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
4651
2234
return stored_location
4654
2237
class cmd_remerge(Command):
4655
__doc__ = """Redo a merge.
4657
2240
Use this if you want to try a different merge technique while resolving
4658
conflicts. Some merge techniques are better than others, and remerge
2241
conflicts. Some merge techniques are better than others, and remerge
4659
2242
lets you try different ones on different files.
4661
2244
The options for remerge have the same meaning and defaults as the ones for
4662
2245
merge. The difference is that remerge can (only) be run when there is a
4663
2246
pending merge, and it lets you specify particular files.
2249
$ bzr remerge --show-base
4666
2250
Re-do the merge of all conflicted files, and show the base text in
4667
conflict regions, in addition to the usual THIS and OTHER texts::
4669
bzr remerge --show-base
2251
conflict regions, in addition to the usual THIS and OTHER texts.
2253
$ bzr remerge --merge-type weave --reprocess foobar
4671
2254
Re-do the merge of "foobar", using the weave merge algorithm, with
4672
additional processing to reduce the size of conflict regions::
4674
bzr remerge --merge-type weave --reprocess foobar
2255
additional processing to reduce the size of conflict regions.
2257
The following merge types are available:"""
4676
2258
takes_args = ['file*']
4681
help="Show base revision text in conflicts."),
2259
takes_options = ['merge-type', 'reprocess',
2260
Option('show-base', help="Show base revision text in "
2264
from merge import merge_type_help
2265
from inspect import getdoc
2266
return getdoc(self) + '\n' + merge_type_help()
4684
2268
def run(self, file_list=None, merge_type=None, show_base=False,
4685
2269
reprocess=False):
4686
from bzrlib.conflicts import restore
2270
from bzrlib.merge import merge_inner, transform_tree
4687
2271
if merge_type is None:
4688
merge_type = _mod_merge.Merge3Merger
4689
tree, file_list = WorkingTree.open_containing_paths(file_list)
4690
self.add_cleanup(tree.lock_write().unlock)
4691
parents = tree.get_parent_ids()
4692
if len(parents) != 2:
4693
raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4694
" merges. Not cherrypicking or"
4696
repository = tree.branch.repository
4697
interesting_ids = None
4699
conflicts = tree.conflicts()
4700
if file_list is not None:
4701
interesting_ids = set()
4702
for filename in file_list:
4703
file_id = tree.path2id(filename)
4705
raise errors.NotVersionedError(filename)
4706
interesting_ids.add(file_id)
4707
if tree.kind(file_id) != "directory":
4710
# FIXME: Support nested trees
4711
for name, ie in tree.root_inventory.iter_entries(file_id):
4712
interesting_ids.add(ie.file_id)
4713
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4715
# Remerge only supports resolving contents conflicts
4716
allowed_conflicts = ('text conflict', 'contents conflict')
4717
restore_files = [c.path for c in conflicts
4718
if c.typestring in allowed_conflicts]
4719
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4720
tree.set_conflicts(ConflictList(new_conflicts))
4721
if file_list is not None:
4722
restore_files = file_list
4723
for filename in restore_files:
4725
restore(tree.abspath(filename))
4726
except errors.NotConflicted:
4728
# Disable pending merges, because the file texts we are remerging
4729
# have not had those merges performed. If we use the wrong parents
4730
# list, we imply that the working tree text has seen and rejected
4731
# all the changes from the other tree, when in fact those changes
4732
# have not yet been seen.
4733
tree.set_parent_ids(parents[:1])
2272
merge_type = Merge3Merger
2273
tree, file_list = tree_files(file_list)
4735
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4736
merger.interesting_ids = interesting_ids
4737
merger.merge_type = merge_type
4738
merger.show_base = show_base
4739
merger.reprocess = reprocess
4740
conflicts = merger.do_merge()
2276
parents = tree.get_parent_ids()
2277
if len(parents) != 2:
2278
raise BzrCommandError("Sorry, remerge only works after normal"
2279
" merges. Not cherrypicking or"
2281
repository = tree.branch.repository
2282
base_revision = common_ancestor(parents[0],
2283
parents[1], repository)
2284
base_tree = repository.revision_tree(base_revision)
2285
other_tree = repository.revision_tree(parents[1])
2286
interesting_ids = None
2288
conflicts = tree.conflicts()
2289
if file_list is not None:
2290
interesting_ids = set()
2291
for filename in file_list:
2292
file_id = tree.path2id(filename)
2294
raise NotVersionedError(filename)
2295
interesting_ids.add(file_id)
2296
if tree.kind(file_id) != "directory":
2299
for name, ie in tree.inventory.iter_entries(file_id):
2300
interesting_ids.add(ie.file_id)
2301
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2302
transform_tree(tree, tree.basis_tree(), interesting_ids)
2303
tree.set_conflicts(ConflictList(new_conflicts))
2304
if file_list is None:
2305
restore_files = list(tree.iter_conflicts())
2307
restore_files = file_list
2308
for filename in restore_files:
2310
restore(tree.abspath(filename))
2311
except NotConflicted:
2313
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2315
interesting_ids=interesting_ids,
2316
other_rev_id=parents[1],
2317
merge_type=merge_type,
2318
show_base=show_base,
2319
reprocess=reprocess)
4742
tree.set_parent_ids(parents)
4743
2322
if conflicts > 0:
4749
2327
class cmd_revert(Command):
4751
Set files in the working tree back to the contents of a previous revision.
4753
Giving a list of files will revert only those files. Otherwise, all files
4754
will be reverted. If the revision is not specified with '--revision', the
4755
working tree basis revision is used. A revert operation affects only the
4756
working tree, not any revision history like the branch and repository or
4757
the working tree basis revision.
4759
To remove only some changes, without reverting to a prior version, use
4760
merge instead. For example, "merge . -r -2..-3" (don't forget the ".")
4761
will remove the changes introduced by the second last commit (-2), without
4762
affecting the changes introduced by the last commit (-1). To remove
4763
certain changes on a hunk-by-hunk basis, see the shelve command.
4764
To update the branch to a specific revision or the latest revision and
4765
update the working tree accordingly while preserving local changes, see the
4768
Uncommitted changes to files that are reverted will be discarded.
4769
Howver, by default, any files that have been manually changed will be
4770
backed up first. (Files changed only by merge are not backed up.) Backup
4771
files have '.~#~' appended to their name, where # is a number.
4773
When you provide files, you can use their current pathname or the pathname
4774
from the target revision. So you can use revert to "undelete" a file by
4775
name. If you name a directory, all the contents of that directory will be
4778
If you have newly added files since the target revision, they will be
4779
removed. If the files to be removed have been changed, backups will be
4780
created as above. Directories containing unknown files will not be
4783
The working tree contains a list of revisions that have been merged but
4784
not yet committed. These revisions will be included as additional parents
4785
of the next commit. Normally, using revert clears that list as well as
4786
reverting the files. If any files are specified, revert leaves the list
4787
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4788
.`` in the tree root to revert all files but keep the recorded merges,
4789
and ``bzr revert --forget-merges`` to clear the pending merge list without
4790
reverting any files.
4792
Using "bzr revert --forget-merges", it is possible to apply all of the
4793
changes from a branch in a single revision. To do this, perform the merge
4794
as desired. Then doing revert with the "--forget-merges" option will keep
4795
the content of the tree as it was, but it will clear the list of pending
4796
merges. The next commit will then contain all of the changes that are
4797
present in the other branch, but without any other parent revisions.
4798
Because this technique forgets where these changes originated, it may
4799
cause additional conflicts on later merges involving the same source and
2328
"""Reverse all changes since the last commit.
2330
Only versioned files are affected. Specify filenames to revert only
2331
those files. By default, any files that are changed will be backed up
2332
first. Backup files have a '~' appended to their name.
4803
_see_also = ['cat', 'export', 'merge', 'shelve']
4806
Option('no-backup', "Do not save backups of reverted files."),
4807
Option('forget-merges',
4808
'Remove pending merge marker, without changing any files.'),
2334
takes_options = ['revision', 'no-backup']
4810
2335
takes_args = ['file*']
4812
def run(self, revision=None, no_backup=False, file_list=None,
4813
forget_merges=None):
4814
tree, file_list = WorkingTree.open_containing_paths(file_list)
4815
self.add_cleanup(tree.lock_tree_write().unlock)
4817
tree.set_parent_ids(tree.get_parent_ids()[:1])
4819
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4822
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4823
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4824
tree.revert(file_list, rev_tree, not no_backup, None,
4825
report_changes=True)
2336
aliases = ['merge-revert']
2338
def run(self, revision=None, no_backup=False, file_list=None):
2339
from bzrlib.commands import parse_spec
2340
if file_list is not None:
2341
if len(file_list) == 0:
2342
raise BzrCommandError("No files specified")
2346
tree, file_list = tree_files(file_list)
2347
if revision is None:
2348
# FIXME should be tree.last_revision
2349
rev_id = tree.last_revision()
2350
elif len(revision) != 1:
2351
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2353
rev_id = revision[0].in_history(tree.branch).rev_id
2354
pb = ui.ui_factory.nested_progress_bar()
2356
tree.revert(file_list,
2357
tree.branch.repository.revision_tree(rev_id),
4828
2363
class cmd_assert_fail(Command):
4829
__doc__ = """Test reporting of assertion failures"""
4830
# intended just for use in testing
2364
"""Test reporting of assertion failures"""
4835
raise AssertionError("always fails")
2367
assert False, "always fails"
4838
2370
class cmd_help(Command):
4839
__doc__ = """Show help on a command or other topic.
2371
"""Show help on a command or other topic.
4842
_see_also = ['topics']
4844
Option('long', 'Show help on all commands.'),
2373
For a list of all available commands, say 'bzr help commands'."""
2374
takes_options = [Option('long', 'show help on all commands')]
4846
2375
takes_args = ['topic?']
4847
2376
aliases = ['?', '--help', '-?', '-h']
4849
2378
@display_command
4850
2379
def run(self, topic=None, long=False):
4852
2381
if topic is None and long:
4853
2382
topic = "commands"
4854
bzrlib.help.help(topic)
4857
2386
class cmd_shell_complete(Command):
4858
__doc__ = """Show appropriate completions for context.
2387
"""Show appropriate completions for context.
4860
For a list of all available commands, say 'bzr shell-complete'.
2389
For a list of all available commands, say 'bzr shell-complete'."""
4862
2390
takes_args = ['context?']
4863
2391
aliases = ['s-c']
4866
2394
@display_command
4867
2395
def run(self, context=None):
4868
from bzrlib import shellcomplete
2396
import shellcomplete
4869
2397
shellcomplete.shellcomplete(context)
2400
class cmd_fetch(Command):
2401
"""Copy in history from another branch but don't merge it.
2403
This is an internal method used for pull and merge."""
2405
takes_args = ['from_branch', 'to_branch']
2406
def run(self, from_branch, to_branch):
2407
from bzrlib.fetch import Fetcher
2408
from_b = Branch.open(from_branch)
2409
to_b = Branch.open(to_branch)
2410
Fetcher(to_b, from_b)
4872
2413
class cmd_missing(Command):
4873
__doc__ = """Show unmerged/unpulled revisions between two branches.
4875
OTHER_BRANCH may be local or remote.
4877
To filter on a range of revisions, you can use the command -r begin..end
4878
-r revision requests a specific revision, -r ..end or -r begin.. are
4882
1 - some missing revisions
4883
0 - no missing revisions
4887
Determine the missing revisions between this and the branch at the
4888
remembered pull location::
4892
Determine the missing revisions between this and another branch::
4894
bzr missing http://server/branch
4896
Determine the missing revisions up to a specific revision on the other
4899
bzr missing -r ..-10
4901
Determine the missing revisions up to a specific revision on this
4904
bzr missing --my-revision ..-10
4907
_see_also = ['merge', 'pull']
2414
"""Show unmerged/unpulled revisions between two branches.
2416
OTHER_BRANCH may be local or remote."""
4908
2417
takes_args = ['other_branch?']
4911
Option('reverse', 'Reverse the order of revisions.'),
4913
'Display changes in the local branch only.'),
4914
Option('this' , 'Same as --mine-only.'),
4915
Option('theirs-only',
4916
'Display changes in the remote branch only.'),
4917
Option('other', 'Same as --theirs-only.'),
4921
custom_help('revision',
4922
help='Filter on other branch revisions (inclusive). '
4923
'See "help revisionspec" for details.'),
4924
Option('my-revision',
4925
type=_parse_revision_str,
4926
help='Filter on local branch revisions (inclusive). '
4927
'See "help revisionspec" for details.'),
4928
Option('include-merged',
4929
'Show all revisions in addition to the mainline ones.'),
4930
Option('include-merges', hidden=True,
4931
help='Historical alias for --include-merged.'),
2418
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2420
'Display changes in the local branch only'),
2421
Option('theirs-only',
2422
'Display changes in the remote branch only'),
4933
2430
encoding_type = 'replace'
4935
2432
@display_command
4936
2433
def run(self, other_branch=None, reverse=False, mine_only=False,
4938
log_format=None, long=False, short=False, line=False,
4939
show_ids=False, verbose=False, this=False, other=False,
4940
include_merged=None, revision=None, my_revision=None,
4942
include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4943
from bzrlib.missing import find_unmerged, iter_log_revisions
4948
if symbol_versioning.deprecated_passed(include_merges):
4949
ui.ui_factory.show_user_warning(
4950
'deprecated_command_option',
4951
deprecated_name='--include-merges',
4952
recommended_name='--include-merged',
4953
deprecated_in_version='2.5',
4954
command=self.invoked_as)
4955
if include_merged is None:
4956
include_merged = include_merges
4958
raise errors.BzrCommandError(gettext(
4959
'{0} and {1} are mutually exclusive').format(
4960
'--include-merges', '--include-merged'))
4961
if include_merged is None:
4962
include_merged = False
4967
# TODO: We should probably check that we don't have mine-only and
4968
# theirs-only set, but it gets complicated because we also have
4969
# this and other which could be used.
4976
local_branch = Branch.open_containing(directory)[0]
4977
self.add_cleanup(local_branch.lock_read().unlock)
2434
theirs_only=False, log_format=None, long=False, short=False, line=False,
2435
show_ids=False, verbose=False):
2436
from bzrlib.missing import find_unmerged, iter_log_data
2437
from bzrlib.log import log_formatter
2438
local_branch = Branch.open_containing(u".")[0]
4979
2439
parent = local_branch.get_parent()
4980
2440
if other_branch is None:
4981
2441
other_branch = parent
4982
2442
if other_branch is None:
4983
raise errors.BzrCommandError(gettext("No peer location known"
4985
display_url = urlutils.unescape_for_display(parent,
4987
message(gettext("Using saved parent location: {0}\n").format(
2443
raise BzrCommandError("No peer location known or specified.")
2444
print "Using last location: " + local_branch.get_parent()
4990
2445
remote_branch = Branch.open(other_branch)
4991
2446
if remote_branch.base == local_branch.base:
4992
2447
remote_branch = local_branch
4994
self.add_cleanup(remote_branch.lock_read().unlock)
4996
local_revid_range = _revision_range_to_revid_range(
4997
_get_revision_range(my_revision, local_branch,
5000
remote_revid_range = _revision_range_to_revid_range(
5001
_get_revision_range(revision,
5002
remote_branch, self.name()))
5004
local_extra, remote_extra = find_unmerged(
5005
local_branch, remote_branch, restrict,
5006
backward=not reverse,
5007
include_merged=include_merged,
5008
local_revid_range=local_revid_range,
5009
remote_revid_range=remote_revid_range)
5011
if log_format is None:
5012
registry = log.log_formatter_registry
5013
log_format = registry.get_default(local_branch)
5014
lf = log_format(to_file=self.outf,
5016
show_timezone='original')
5019
if local_extra and not theirs_only:
5020
message(ngettext("You have %d extra revision:\n",
5021
"You have %d extra revisions:\n",
5025
if local_branch.supports_tags():
5026
rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
5027
for revision in iter_log_revisions(local_extra,
5028
local_branch.repository,
5031
lf.log_revision(revision)
5032
printed_local = True
5035
printed_local = False
5037
if remote_extra and not mine_only:
5038
if printed_local is True:
5040
message(ngettext("You are missing %d revision:\n",
5041
"You are missing %d revisions:\n",
5042
len(remote_extra)) %
5044
if remote_branch.supports_tags():
5045
rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
5046
for revision in iter_log_revisions(remote_extra,
5047
remote_branch.repository,
5050
lf.log_revision(revision)
5053
if mine_only and not local_extra:
5054
# We checked local, and found nothing extra
5055
message(gettext('This branch has no new revisions.\n'))
5056
elif theirs_only and not remote_extra:
5057
# We checked remote, and found nothing extra
5058
message(gettext('Other branch has no new revisions.\n'))
5059
elif not (mine_only or theirs_only or local_extra or
5061
# We checked both branches, and neither one had extra
5063
message(gettext("Branches are up to date.\n"))
2448
local_branch.lock_read()
2450
remote_branch.lock_read()
2452
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2453
if (log_format is None):
2454
default = local_branch.get_config().log_format()
2455
log_format = get_log_format(long=long, short=short,
2456
line=line, default=default)
2457
lf = log_formatter(log_format,
2460
show_timezone='original')
2461
if reverse is False:
2462
local_extra.reverse()
2463
remote_extra.reverse()
2464
if local_extra and not theirs_only:
2465
print "You have %d extra revision(s):" % len(local_extra)
2466
for data in iter_log_data(local_extra, local_branch.repository,
2469
printed_local = True
2471
printed_local = False
2472
if remote_extra and not mine_only:
2473
if printed_local is True:
2475
print "You are missing %d revision(s):" % len(remote_extra)
2476
for data in iter_log_data(remote_extra, remote_branch.repository,
2479
if not remote_extra and not local_extra:
2481
print "Branches are up to date."
2485
remote_branch.unlock()
2487
local_branch.unlock()
5065
2488
if not status_code and parent is None and other_branch is not None:
5066
self.add_cleanup(local_branch.lock_write().unlock)
5067
# handle race conditions - a parent might be set while we run.
5068
if local_branch.get_parent() is None:
5069
local_branch.set_parent(remote_branch.base)
2489
local_branch.lock_write()
2491
# handle race conditions - a parent might be set while we run.
2492
if local_branch.get_parent() is None:
2493
local_branch.set_parent(remote_branch.base)
2495
local_branch.unlock()
5070
2496
return status_code
5073
class cmd_pack(Command):
5074
__doc__ = """Compress the data within a repository.
5076
This operation compresses the data within a bazaar repository. As
5077
bazaar supports automatic packing of repository, this operation is
5078
normally not required to be done manually.
5080
During the pack operation, bazaar takes a backup of existing repository
5081
data, i.e. pack files. This backup is eventually removed by bazaar
5082
automatically when it is safe to do so. To save disk space by removing
5083
the backed up pack files, the --clean-obsolete-packs option may be
5086
Warning: If you use --clean-obsolete-packs and your machine crashes
5087
during or immediately after repacking, you may be left with a state
5088
where the deletion has been written to disk but the new packs have not
5089
been. In this case the repository may be unusable.
5092
_see_also = ['repositories']
5093
takes_args = ['branch_or_repo?']
5095
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
5098
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
5099
dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
5101
branch = dir.open_branch()
5102
repository = branch.repository
5103
except errors.NotBranchError:
5104
repository = dir.open_repository()
5105
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
5108
2499
class cmd_plugins(Command):
5109
__doc__ = """List the installed plugins.
5111
This command displays the list of installed plugins including
5112
version of plugin and a short description of each.
5114
--verbose shows the path where each plugin is located.
5116
A plugin is an external component for Bazaar that extends the
5117
revision control system, by adding or replacing code in Bazaar.
5118
Plugins can do a variety of things, including overriding commands,
5119
adding new commands, providing additional network transports and
5120
customizing log output.
5122
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
5123
for further information on plugins including where to find them and how to
5124
install them. Instructions are also provided there on how to write new
5125
plugins using the Python programming language.
5127
takes_options = ['verbose']
5129
2502
@display_command
5130
def run(self, verbose=False):
5131
from bzrlib import plugin
5132
# Don't give writelines a generator as some codecs don't like that
5133
self.outf.writelines(
5134
list(plugin.describe_plugins(show_paths=verbose)))
2504
import bzrlib.plugin
2505
from inspect import getdoc
2506
for name, plugin in bzrlib.plugin.all_plugins().items():
2507
if getattr(plugin, '__path__', None) is not None:
2508
print plugin.__path__[0]
2509
elif getattr(plugin, '__file__', None) is not None:
2510
print plugin.__file__
2516
print '\t', d.split('\n')[0]
5137
2519
class cmd_testament(Command):
5138
__doc__ = """Show testament (signing-form) of a revision."""
5141
Option('long', help='Produce long-format testament.'),
5143
help='Produce a strict-format testament.')]
2520
"""Show testament (signing-form) of a revision."""
2521
takes_options = ['revision',
2522
Option('long', help='Produce long-format testament'),
2523
Option('strict', help='Produce a strict-format'
5144
2525
takes_args = ['branch?']
5145
2526
@display_command
5146
2527
def run(self, branch=u'.', revision=None, long=False, strict=False):
5515
2784
class cmd_serve(Command):
5516
__doc__ = """Run the bzr server."""
5518
aliases = ['server']
2785
"""Run the bzr server.
5520
2787
takes_options = [
5522
help='Serve on stdin/out for use from inetd or sshd.'),
5523
RegistryOption('protocol',
5524
help="Protocol to serve.",
5525
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
5526
value_switches=True),
5528
help='Listen for connections on nominated address.', type=str),
2789
help='serve on stdin/out for use from inetd or sshd'),
5530
help='Listen for connections on nominated port. Passing 0 as '
5531
'the port number will result in a dynamically allocated '
5532
'port. The default port depends on the protocol.',
5534
custom_help('directory',
5535
help='Serve contents of this directory.'),
5536
Option('allow-writes',
5537
help='By default the server is a readonly server. Supplying '
5538
'--allow-writes enables write access to the contents of '
5539
'the served directory and below. Note that ``bzr serve`` '
5540
'does not perform authentication, so unless some form of '
5541
'external authentication is arranged supplying this '
5542
'option leads to global uncontrolled write access to your '
5545
Option('client-timeout', type=float,
5546
help='Override the default idle client timeout (5min).'),
2791
help='listen for connections on nominated port of the form '
2792
'[hostname:]portnumber. Passing 0 as the port number will '
2793
'result in a dynamically allocated port.',
2796
help='serve contents of directory',
5549
def run(self, listen=None, port=None, inet=False, directory=None,
5550
allow_writes=False, protocol=None, client_timeout=None):
5551
from bzrlib import transport
2800
def run(self, port=None, inet=False, directory=None):
2801
from bzrlib.transport import smart
2802
from bzrlib.transport import get_transport
5552
2803
if directory is None:
5553
2804
directory = os.getcwd()
5554
if protocol is None:
5555
protocol = transport.transport_server_registry.get()
5556
url = transport.location_to_url(directory)
5557
if not allow_writes:
5558
url = 'readonly+' + url
5559
t = transport.get_transport_from_url(url)
5560
protocol(t, listen, port, inet, client_timeout)
5563
class cmd_join(Command):
5564
__doc__ = """Combine a tree into its containing tree.
5566
This command requires the target tree to be in a rich-root format.
5568
The TREE argument should be an independent tree, inside another tree, but
5569
not part of it. (Such trees can be produced by "bzr split", but also by
5570
running "bzr branch" with the target inside a tree.)
5572
The result is a combined tree, with the subtree no longer an independent
5573
part. This is marked as a merge of the subtree into the containing tree,
5574
and all history is preserved.
5577
_see_also = ['split']
5578
takes_args = ['tree']
5580
Option('reference', help='Join by reference.', hidden=True),
5583
def run(self, tree, reference=False):
5584
sub_tree = WorkingTree.open(tree)
5585
parent_dir = osutils.dirname(sub_tree.basedir)
5586
containing_tree = WorkingTree.open_containing(parent_dir)[0]
5587
repo = containing_tree.branch.repository
5588
if not repo.supports_rich_root():
5589
raise errors.BzrCommandError(gettext(
5590
"Can't join trees because %s doesn't support rich root data.\n"
5591
"You can use bzr upgrade on the repository.")
5595
containing_tree.add_reference(sub_tree)
5596
except errors.BadReferenceTarget, e:
5597
# XXX: Would be better to just raise a nicely printable
5598
# exception from the real origin. Also below. mbp 20070306
5599
raise errors.BzrCommandError(
5600
gettext("Cannot join {0}. {1}").format(tree, e.reason))
5603
containing_tree.subsume(sub_tree)
5604
except errors.BadSubsumeSource, e:
5605
raise errors.BzrCommandError(
5606
gettext("Cannot join {0}. {1}").format(tree, e.reason))
5609
class cmd_split(Command):
5610
__doc__ = """Split a subdirectory of a tree into a separate tree.
5612
This command will produce a target tree in a format that supports
5613
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5614
converted into earlier formats like 'dirstate-tags'.
5616
The TREE argument should be a subdirectory of a working tree. That
5617
subdirectory will be converted into an independent tree, with its own
5618
branch. Commits in the top-level tree will not apply to the new subtree.
5621
_see_also = ['join']
5622
takes_args = ['tree']
5624
def run(self, tree):
5625
containing_tree, subdir = WorkingTree.open_containing(tree)
5626
sub_id = containing_tree.path2id(subdir)
5628
raise errors.NotVersionedError(subdir)
5630
containing_tree.extract(sub_id)
5631
except errors.RootNotRich:
5632
raise errors.RichRootUpgradeRequired(containing_tree.branch.base)
5635
class cmd_merge_directive(Command):
5636
__doc__ = """Generate a merge directive for auto-merge tools.
5638
A directive requests a merge to be performed, and also provides all the
5639
information necessary to do so. This means it must either include a
5640
revision bundle, or the location of a branch containing the desired
5643
A submit branch (the location to merge into) must be supplied the first
5644
time the command is issued. After it has been supplied once, it will
5645
be remembered as the default.
5647
A public branch is optional if a revision bundle is supplied, but required
5648
if --diff or --plain is specified. It will be remembered as the default
5649
after the first use.
5652
takes_args = ['submit_branch?', 'public_branch?']
5656
_see_also = ['send']
5660
RegistryOption.from_kwargs('patch-type',
5661
'The type of patch to include in the directive.',
5663
value_switches=True,
5665
bundle='Bazaar revision bundle (default).',
5666
diff='Normal unified diff.',
5667
plain='No patch, just directive.'),
5668
Option('sign', help='GPG-sign the directive.'), 'revision',
5669
Option('mail-to', type=str,
5670
help='Instead of printing the directive, email to this address.'),
5671
Option('message', type=str, short_name='m',
5672
help='Message to use when committing this merge.')
5675
encoding_type = 'exact'
5677
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5678
sign=False, revision=None, mail_to=None, message=None,
5680
from bzrlib.revision import ensure_null, NULL_REVISION
5681
include_patch, include_bundle = {
5682
'plain': (False, False),
5683
'diff': (True, False),
5684
'bundle': (True, True),
5686
branch = Branch.open(directory)
5687
stored_submit_branch = branch.get_submit_branch()
5688
if submit_branch is None:
5689
submit_branch = stored_submit_branch
5691
if stored_submit_branch is None:
5692
branch.set_submit_branch(submit_branch)
5693
if submit_branch is None:
5694
submit_branch = branch.get_parent()
5695
if submit_branch is None:
5696
raise errors.BzrCommandError(gettext('No submit branch specified or known'))
5698
stored_public_branch = branch.get_public_branch()
5699
if public_branch is None:
5700
public_branch = stored_public_branch
5701
elif stored_public_branch is None:
5702
# FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5703
branch.set_public_branch(public_branch)
5704
if not include_bundle and public_branch is None:
5705
raise errors.BzrCommandError(gettext('No public branch specified or'
5707
base_revision_id = None
5708
if revision is not None:
5709
if len(revision) > 2:
5710
raise errors.BzrCommandError(gettext('bzr merge-directive takes '
5711
'at most two one revision identifiers'))
5712
revision_id = revision[-1].as_revision_id(branch)
5713
if len(revision) == 2:
5714
base_revision_id = revision[0].as_revision_id(branch)
5716
revision_id = branch.last_revision()
5717
revision_id = ensure_null(revision_id)
5718
if revision_id == NULL_REVISION:
5719
raise errors.BzrCommandError(gettext('No revisions to bundle.'))
5720
directive = merge_directive.MergeDirective2.from_objects(
5721
branch.repository, revision_id, time.time(),
5722
osutils.local_time_offset(), submit_branch,
5723
public_branch=public_branch, include_patch=include_patch,
5724
include_bundle=include_bundle, message=message,
5725
base_revision_id=base_revision_id)
5728
self.outf.write(directive.to_signed(branch))
5730
self.outf.writelines(directive.to_lines())
5732
message = directive.to_email(mail_to, branch, sign)
5733
s = SMTPConnection(branch.get_config_stack())
5734
s.send_email(message)
5737
class cmd_send(Command):
5738
__doc__ = """Mail or create a merge-directive for submitting changes.
5740
A merge directive provides many things needed for requesting merges:
5742
* A machine-readable description of the merge to perform
5744
* An optional patch that is a preview of the changes requested
5746
* An optional bundle of revision data, so that the changes can be applied
5747
directly from the merge directive, without retrieving data from a
5750
`bzr send` creates a compact data set that, when applied using bzr
5751
merge, has the same effect as merging from the source branch.
5753
By default the merge directive is self-contained and can be applied to any
5754
branch containing submit_branch in its ancestory without needing access to
5757
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5758
revisions, but only a structured request to merge from the
5759
public_location. In that case the public_branch is needed and it must be
5760
up-to-date and accessible to the recipient. The public_branch is always
5761
included if known, so that people can check it later.
5763
The submit branch defaults to the parent of the source branch, but can be
5764
overridden. Both submit branch and public branch will be remembered in
5765
branch.conf the first time they are used for a particular branch. The
5766
source branch defaults to that containing the working directory, but can
5767
be changed using --from.
5769
Both the submit branch and the public branch follow the usual behavior with
5770
respect to --remember: If there is no default location set, the first send
5771
will set it (use --no-remember to avoid setting it). After that, you can
5772
omit the location to use the default. To change the default, use
5773
--remember. The value will only be saved if the location can be accessed.
5775
In order to calculate those changes, bzr must analyse the submit branch.
5776
Therefore it is most efficient for the submit branch to be a local mirror.
5777
If a public location is known for the submit_branch, that location is used
5778
in the merge directive.
5780
The default behaviour is to send the merge directive by mail, unless -o is
5781
given, in which case it is sent to a file.
5783
Mail is sent using your preferred mail program. This should be transparent
5784
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5785
If the preferred client can't be found (or used), your editor will be used.
5787
To use a specific mail program, set the mail_client configuration option.
5788
(For Thunderbird 1.5, this works around some bugs.) Supported values for
5789
specific clients are "claws", "evolution", "kmail", "mail.app" (MacOS X's
5790
Mail.app), "mutt", and "thunderbird"; generic options are "default",
5791
"editor", "emacsclient", "mapi", and "xdg-email". Plugins may also add
5794
If mail is being sent, a to address is required. This can be supplied
5795
either on the commandline, by setting the submit_to configuration
5796
option in the branch itself or the child_submit_to configuration option
5797
in the submit branch.
5799
Two formats are currently supported: "4" uses revision bundle format 4 and
5800
merge directive format 2. It is significantly faster and smaller than
5801
older formats. It is compatible with Bazaar 0.19 and later. It is the
5802
default. "0.9" uses revision bundle format 0.9 and merge directive
5803
format 1. It is compatible with Bazaar 0.12 - 0.18.
5805
The merge directives created by bzr send may be applied using bzr merge or
5806
bzr pull by specifying a file containing a merge directive as the location.
5808
bzr send makes extensive use of public locations to map local locations into
5809
URLs that can be used by other people. See `bzr help configuration` to
5810
set them, and use `bzr info` to display them.
5813
encoding_type = 'exact'
5815
_see_also = ['merge', 'pull']
5817
takes_args = ['submit_branch?', 'public_branch?']
5821
help='Do not include a bundle in the merge directive.'),
5822
Option('no-patch', help='Do not include a preview patch in the merge'
5825
help='Remember submit and public branch.'),
5827
help='Branch to generate the submission from, '
5828
'rather than the one containing the working directory.',
5831
Option('output', short_name='o',
5832
help='Write merge directive to this file or directory; '
5833
'use - for stdout.',
5836
help='Refuse to send if there are uncommitted changes in'
5837
' the working tree, --no-strict disables the check.'),
5838
Option('mail-to', help='Mail the request to this address.',
5842
Option('body', help='Body for the email.', type=unicode),
5843
RegistryOption('format',
5844
help='Use the specified output format.',
5845
lazy_registry=('bzrlib.send', 'format_registry')),
5848
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5849
no_patch=False, revision=None, remember=None, output=None,
5850
format=None, mail_to=None, message=None, body=None,
5851
strict=None, **kwargs):
5852
from bzrlib.send import send
5853
return send(submit_branch, revision, public_branch, remember,
5854
format, no_bundle, no_patch, output,
5855
kwargs.get('from', '.'), mail_to, message, body,
5860
class cmd_bundle_revisions(cmd_send):
5861
__doc__ = """Create a merge-directive for submitting changes.
5863
A merge directive provides many things needed for requesting merges:
5865
* A machine-readable description of the merge to perform
5867
* An optional patch that is a preview of the changes requested
5869
* An optional bundle of revision data, so that the changes can be applied
5870
directly from the merge directive, without retrieving data from a
5873
If --no-bundle is specified, then public_branch is needed (and must be
5874
up-to-date), so that the receiver can perform the merge using the
5875
public_branch. The public_branch is always included if known, so that
5876
people can check it later.
5878
The submit branch defaults to the parent, but can be overridden. Both
5879
submit branch and public branch will be remembered if supplied.
5881
If a public_branch is known for the submit_branch, that public submit
5882
branch is used in the merge instructions. This means that a local mirror
5883
can be used as your actual submit branch, once you have set public_branch
5886
Two formats are currently supported: "4" uses revision bundle format 4 and
5887
merge directive format 2. It is significantly faster and smaller than
5888
older formats. It is compatible with Bazaar 0.19 and later. It is the
5889
default. "0.9" uses revision bundle format 0.9 and merge directive
5890
format 1. It is compatible with Bazaar 0.12 - 0.18.
5895
help='Do not include a bundle in the merge directive.'),
5896
Option('no-patch', help='Do not include a preview patch in the merge'
5899
help='Remember submit and public branch.'),
5901
help='Branch to generate the submission from, '
5902
'rather than the one containing the working directory.',
5905
Option('output', short_name='o', help='Write directive to this file.',
5908
help='Refuse to bundle revisions if there are uncommitted'
5909
' changes in the working tree, --no-strict disables the check.'),
5911
RegistryOption('format',
5912
help='Use the specified output format.',
5913
lazy_registry=('bzrlib.send', 'format_registry')),
5915
aliases = ['bundle']
5917
_see_also = ['send', 'merge']
5921
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5922
no_patch=False, revision=None, remember=False, output=None,
5923
format=None, strict=None, **kwargs):
5926
from bzrlib.send import send
5927
return send(submit_branch, revision, public_branch, remember,
5928
format, no_bundle, no_patch, output,
5929
kwargs.get('from', '.'), None, None, None,
5930
self.outf, strict=strict)
5933
class cmd_tag(Command):
5934
__doc__ = """Create, remove or modify a tag naming a revision.
5936
Tags give human-meaningful names to revisions. Commands that take a -r
5937
(--revision) option can be given -rtag:X, where X is any previously
5940
Tags are stored in the branch. Tags are copied from one branch to another
5941
along when you branch, push, pull or merge.
5943
It is an error to give a tag name that already exists unless you pass
5944
--force, in which case the tag is moved to point to the new revision.
5946
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5947
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5949
If no tag name is specified it will be determined through the
5950
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5951
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5955
_see_also = ['commit', 'tags']
5956
takes_args = ['tag_name?']
5959
help='Delete this tag rather than placing it.',
5961
custom_help('directory',
5962
help='Branch in which to place the tag.'),
5964
help='Replace existing tags.',
5969
def run(self, tag_name=None,
5975
branch, relpath = Branch.open_containing(directory)
5976
self.add_cleanup(branch.lock_write().unlock)
5978
if tag_name is None:
5979
raise errors.BzrCommandError(gettext("No tag specified to delete."))
5980
branch.tags.delete_tag(tag_name)
5981
note(gettext('Deleted tag %s.') % tag_name)
5984
if len(revision) != 1:
5985
raise errors.BzrCommandError(gettext(
5986
"Tags can only be placed on a single revision, "
5988
revision_id = revision[0].as_revision_id(branch)
5990
revision_id = branch.last_revision()
5991
if tag_name is None:
5992
tag_name = branch.automatic_tag_name(revision_id)
5993
if tag_name is None:
5994
raise errors.BzrCommandError(gettext(
5995
"Please specify a tag name."))
5997
existing_target = branch.tags.lookup_tag(tag_name)
5998
except errors.NoSuchTag:
5999
existing_target = None
6000
if not force and existing_target not in (None, revision_id):
6001
raise errors.TagAlreadyExists(tag_name)
6002
if existing_target == revision_id:
6003
note(gettext('Tag %s already exists for that revision.') % tag_name)
6005
branch.tags.set_tag(tag_name, revision_id)
6006
if existing_target is None:
6007
note(gettext('Created tag %s.') % tag_name)
6009
note(gettext('Updated tag %s.') % tag_name)
6012
class cmd_tags(Command):
6013
__doc__ = """List tags.
6015
This command shows a table of tag names and the revisions they reference.
6020
custom_help('directory',
6021
help='Branch whose tags should be displayed.'),
6022
RegistryOption('sort',
6023
'Sort tags by different criteria.', title='Sorting',
6024
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
6031
def run(self, directory='.', sort=None, show_ids=False, revision=None):
6032
from bzrlib.tag import tag_sort_methods
6033
branch, relpath = Branch.open_containing(directory)
6035
tags = branch.tags.get_tag_dict().items()
6039
self.add_cleanup(branch.lock_read().unlock)
6041
# Restrict to the specified range
6042
tags = self._tags_for_range(branch, revision)
6044
sort = tag_sort_methods.get()
6047
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
6048
for index, (tag, revid) in enumerate(tags):
6050
revno = branch.revision_id_to_dotted_revno(revid)
6051
if isinstance(revno, tuple):
6052
revno = '.'.join(map(str, revno))
6053
except (errors.NoSuchRevision,
6054
errors.GhostRevisionsHaveNoRevno,
6055
errors.UnsupportedOperation):
6056
# Bad tag data/merges can lead to tagged revisions
6057
# which are not in this branch. Fail gracefully ...
6059
tags[index] = (tag, revno)
6061
for tag, revspec in tags:
6062
self.outf.write('%-20s %s\n' % (tag, revspec))
6064
def _tags_for_range(self, branch, revision):
6066
rev1, rev2 = _get_revision_range(revision, branch, self.name())
6067
revid1, revid2 = rev1.rev_id, rev2.rev_id
6068
# _get_revision_range will always set revid2 if it's not specified.
6069
# If revid1 is None, it means we want to start from the branch
6070
# origin which is always a valid ancestor. If revid1 == revid2, the
6071
# ancestry check is useless.
6072
if revid1 and revid1 != revid2:
6073
# FIXME: We really want to use the same graph than
6074
# branch.iter_merge_sorted_revisions below, but this is not
6075
# easily available -- vila 2011-09-23
6076
if branch.repository.get_graph().is_ancestor(revid2, revid1):
6077
# We don't want to output anything in this case...
6079
# only show revisions between revid1 and revid2 (inclusive)
6080
tagged_revids = branch.tags.get_reverse_tag_dict()
6082
for r in branch.iter_merge_sorted_revisions(
6083
start_revision_id=revid2, stop_revision_id=revid1,
6084
stop_rule='include'):
6085
revid_tags = tagged_revids.get(r[0], None)
6087
found.extend([(tag, r[0]) for tag in revid_tags])
6091
class cmd_reconfigure(Command):
6092
__doc__ = """Reconfigure the type of a bzr directory.
6094
A target configuration must be specified.
6096
For checkouts, the bind-to location will be auto-detected if not specified.
6097
The order of preference is
6098
1. For a lightweight checkout, the current bound location.
6099
2. For branches that used to be checkouts, the previously-bound location.
6100
3. The push location.
6101
4. The parent location.
6102
If none of these is available, --bind-to must be specified.
6105
_see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
6106
takes_args = ['location?']
6108
RegistryOption.from_kwargs(
6111
help='The relation between branch and tree.',
6112
value_switches=True, enum_switch=False,
6113
branch='Reconfigure to be an unbound branch with no working tree.',
6114
tree='Reconfigure to be an unbound branch with a working tree.',
6115
checkout='Reconfigure to be a bound branch with a working tree.',
6116
lightweight_checkout='Reconfigure to be a lightweight'
6117
' checkout (with no local history).',
6119
RegistryOption.from_kwargs(
6121
title='Repository type',
6122
help='Location fo the repository.',
6123
value_switches=True, enum_switch=False,
6124
standalone='Reconfigure to be a standalone branch '
6125
'(i.e. stop using shared repository).',
6126
use_shared='Reconfigure to use a shared repository.',
6128
RegistryOption.from_kwargs(
6130
title='Trees in Repository',
6131
help='Whether new branches in the repository have trees.',
6132
value_switches=True, enum_switch=False,
6133
with_trees='Reconfigure repository to create '
6134
'working trees on branches by default.',
6135
with_no_trees='Reconfigure repository to not create '
6136
'working trees on branches by default.'
6138
Option('bind-to', help='Branch to bind checkout to.', type=str),
6140
help='Perform reconfiguration even if local changes'
6142
Option('stacked-on',
6143
help='Reconfigure a branch to be stacked on another branch.',
6147
help='Reconfigure a branch to be unstacked. This '
6148
'may require copying substantial data into it.',
6152
def run(self, location=None, bind_to=None, force=False,
6153
tree_type=None, repository_type=None, repository_trees=None,
6154
stacked_on=None, unstacked=None):
6155
directory = controldir.ControlDir.open(location)
6156
if stacked_on and unstacked:
6157
raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
6158
elif stacked_on is not None:
6159
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
6161
reconfigure.ReconfigureUnstacked().apply(directory)
6162
# At the moment you can use --stacked-on and a different
6163
# reconfiguration shape at the same time; there seems no good reason
6165
if (tree_type is None and
6166
repository_type is None and
6167
repository_trees is None):
6168
if stacked_on or unstacked:
6171
raise errors.BzrCommandError(gettext('No target configuration '
6173
reconfiguration = None
6174
if tree_type == 'branch':
6175
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
6176
elif tree_type == 'tree':
6177
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
6178
elif tree_type == 'checkout':
6179
reconfiguration = reconfigure.Reconfigure.to_checkout(
6181
elif tree_type == 'lightweight-checkout':
6182
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
6185
reconfiguration.apply(force)
6186
reconfiguration = None
6187
if repository_type == 'use-shared':
6188
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
6189
elif repository_type == 'standalone':
6190
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
6192
reconfiguration.apply(force)
6193
reconfiguration = None
6194
if repository_trees == 'with-trees':
6195
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
6197
elif repository_trees == 'with-no-trees':
6198
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
6201
reconfiguration.apply(force)
6202
reconfiguration = None
6205
class cmd_switch(Command):
6206
__doc__ = """Set the branch of a checkout and update.
6208
For lightweight checkouts, this changes the branch being referenced.
6209
For heavyweight checkouts, this checks that there are no local commits
6210
versus the current bound branch, then it makes the local branch a mirror
6211
of the new location and binds to it.
6213
In both cases, the working tree is updated and uncommitted changes
6214
are merged. The user can commit or revert these as they desire.
6216
Pending merges need to be committed or reverted before using switch.
6218
The path to the branch to switch to can be specified relative to the parent
6219
directory of the current branch. For example, if you are currently in a
6220
checkout of /path/to/branch, specifying 'newbranch' will find a branch at
6223
Bound branches use the nickname of its master branch unless it is set
6224
locally, in which case switching will update the local nickname to be
6228
takes_args = ['to_location?']
6229
takes_options = ['directory',
6231
help='Switch even if local commits will be lost.'),
6233
Option('create-branch', short_name='b',
6234
help='Create the target branch from this one before'
6235
' switching to it.'),
6238
def run(self, to_location=None, force=False, create_branch=False,
6239
revision=None, directory=u'.'):
6240
from bzrlib import switch
6241
tree_location = directory
6242
revision = _get_one_revision('switch', revision)
6243
possible_transports = []
6244
control_dir = controldir.ControlDir.open_containing(tree_location,
6245
possible_transports=possible_transports)[0]
6246
if to_location is None:
6247
if revision is None:
6248
raise errors.BzrCommandError(gettext('You must supply either a'
6249
' revision or a location'))
6250
to_location = tree_location
6252
branch = control_dir.open_branch(
6253
possible_transports=possible_transports)
6254
had_explicit_nick = branch.get_config().has_explicit_nickname()
6255
except errors.NotBranchError:
6257
had_explicit_nick = False
6260
raise errors.BzrCommandError(
6261
gettext('cannot create branch without source branch'))
6262
to_location = lookup_new_sibling_branch(control_dir, to_location,
6263
possible_transports=possible_transports)
6264
to_branch = branch.bzrdir.sprout(to_location,
6265
possible_transports=possible_transports,
6266
source_branch=branch).open_branch()
6269
to_branch = Branch.open(to_location,
6270
possible_transports=possible_transports)
6271
except errors.NotBranchError:
6272
to_branch = open_sibling_branch(control_dir, to_location,
6273
possible_transports=possible_transports)
6274
if revision is not None:
6275
revision = revision.as_revision_id(to_branch)
6276
switch.switch(control_dir, to_branch, force, revision_id=revision)
6277
if had_explicit_nick:
6278
branch = control_dir.open_branch() #get the new branch!
6279
branch.nick = to_branch.nick
6280
note(gettext('Switched to branch: %s'),
6281
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
6285
class cmd_view(Command):
6286
__doc__ = """Manage filtered views.
6288
Views provide a mask over the tree so that users can focus on
6289
a subset of a tree when doing their work. After creating a view,
6290
commands that support a list of files - status, diff, commit, etc -
6291
effectively have that list of files implicitly given each time.
6292
An explicit list of files can still be given but those files
6293
must be within the current view.
6295
In most cases, a view has a short life-span: it is created to make
6296
a selected change and is deleted once that change is committed.
6297
At other times, you may wish to create one or more named views
6298
and switch between them.
6300
To disable the current view without deleting it, you can switch to
6301
the pseudo view called ``off``. This can be useful when you need
6302
to see the whole tree for an operation or two (e.g. merge) but
6303
want to switch back to your view after that.
6306
To define the current view::
6308
bzr view file1 dir1 ...
6310
To list the current view::
6314
To delete the current view::
6318
To disable the current view without deleting it::
6320
bzr view --switch off
6322
To define a named view and switch to it::
6324
bzr view --name view-name file1 dir1 ...
6326
To list a named view::
6328
bzr view --name view-name
6330
To delete a named view::
6332
bzr view --name view-name --delete
6334
To switch to a named view::
6336
bzr view --switch view-name
6338
To list all views defined::
6342
To delete all views::
6344
bzr view --delete --all
6348
takes_args = ['file*']
6351
help='Apply list or delete action to all views.',
6354
help='Delete the view.',
6357
help='Name of the view to define, list or delete.',
6361
help='Name of the view to switch to.',
6366
def run(self, file_list,
6372
tree, file_list = WorkingTree.open_containing_paths(file_list,
6374
current_view, view_dict = tree.views.get_view_info()
6379
raise errors.BzrCommandError(gettext(
6380
"Both --delete and a file list specified"))
6382
raise errors.BzrCommandError(gettext(
6383
"Both --delete and --switch specified"))
6385
tree.views.set_view_info(None, {})
6386
self.outf.write(gettext("Deleted all views.\n"))
6388
raise errors.BzrCommandError(gettext("No current view to delete"))
6390
tree.views.delete_view(name)
6391
self.outf.write(gettext("Deleted '%s' view.\n") % name)
6394
raise errors.BzrCommandError(gettext(
6395
"Both --switch and a file list specified"))
6397
raise errors.BzrCommandError(gettext(
6398
"Both --switch and --all specified"))
6399
elif switch == 'off':
6400
if current_view is None:
6401
raise errors.BzrCommandError(gettext("No current view to disable"))
6402
tree.views.set_view_info(None, view_dict)
6403
self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
6405
tree.views.set_view_info(switch, view_dict)
6406
view_str = views.view_display_str(tree.views.lookup_view())
6407
self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
6410
self.outf.write(gettext('Views defined:\n'))
6411
for view in sorted(view_dict):
6412
if view == current_view:
6416
view_str = views.view_display_str(view_dict[view])
6417
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
6419
self.outf.write(gettext('No views defined.\n'))
6422
# No name given and no current view set
6425
raise errors.BzrCommandError(gettext(
6426
"Cannot change the 'off' pseudo view"))
6427
tree.views.set_view(name, sorted(file_list))
6428
view_str = views.view_display_str(tree.views.lookup_view())
6429
self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
6433
# No name given and no current view set
6434
self.outf.write(gettext('No current view.\n'))
6436
view_str = views.view_display_str(tree.views.lookup_view(name))
6437
self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
6440
class cmd_hooks(Command):
6441
__doc__ = """Show hooks."""
6446
for hook_key in sorted(hooks.known_hooks.keys()):
6447
some_hooks = hooks.known_hooks_key_to_object(hook_key)
6448
self.outf.write("%s:\n" % type(some_hooks).__name__)
6449
for hook_name, hook_point in sorted(some_hooks.items()):
6450
self.outf.write(" %s:\n" % (hook_name,))
6451
found_hooks = list(hook_point)
6453
for hook in found_hooks:
6454
self.outf.write(" %s\n" %
6455
(some_hooks.get_hook_name(hook),))
6457
self.outf.write(gettext(" <no hooks installed>\n"))
6460
class cmd_remove_branch(Command):
6461
__doc__ = """Remove a branch.
6463
This will remove the branch from the specified location but
6464
will keep any working tree or repository in place.
6468
Remove the branch at repo/trunk::
6470
bzr remove-branch repo/trunk
6474
takes_args = ["location?"]
6476
takes_options = ['directory',
6477
Option('force', help='Remove branch even if it is the active branch.')]
6479
aliases = ["rmbranch"]
6481
def run(self, directory=None, location=None, force=False):
6482
br = open_nearby_branch(near=directory, location=location)
6483
if not force and br.bzrdir.has_workingtree():
6485
active_branch = br.bzrdir.open_branch(name="")
6486
except errors.NotBranchError:
6487
active_branch = None
6488
if (active_branch is not None and
6489
br.control_url == active_branch.control_url):
6490
raise errors.BzrCommandError(
6491
gettext("Branch is active. Use --force to remove it."))
6492
br.bzrdir.destroy_branch(br.name)
6495
class cmd_shelve(Command):
6496
__doc__ = """Temporarily set aside some changes from the current tree.
6498
Shelve allows you to temporarily put changes you've made "on the shelf",
6499
ie. out of the way, until a later time when you can bring them back from
6500
the shelf with the 'unshelve' command. The changes are stored alongside
6501
your working tree, and so they aren't propagated along with your branch nor
6502
will they survive its deletion.
6504
If shelve --list is specified, previously-shelved changes are listed.
6506
Shelve is intended to help separate several sets of changes that have
6507
been inappropriately mingled. If you just want to get rid of all changes
6508
and you don't need to restore them later, use revert. If you want to
6509
shelve all text changes at once, use shelve --all.
6511
If filenames are specified, only the changes to those files will be
6512
shelved. Other files will be left untouched.
6514
If a revision is specified, changes since that revision will be shelved.
6516
You can put multiple items on the shelf, and by default, 'unshelve' will
6517
restore the most recently shelved changes.
6519
For complicated changes, it is possible to edit the changes in a separate
6520
editor program to decide what the file remaining in the working copy
6521
should look like. To do this, add the configuration option
6523
change_editor = PROGRAM @new_path @old_path
6525
where @new_path is replaced with the path of the new version of the
6526
file and @old_path is replaced with the path of the old version of
6527
the file. The PROGRAM should save the new file with the desired
6528
contents of the file in the working tree.
6532
takes_args = ['file*']
6537
Option('all', help='Shelve all changes.'),
6539
RegistryOption('writer', 'Method to use for writing diffs.',
6540
bzrlib.option.diff_writer_registry,
6541
value_switches=True, enum_switch=False),
6543
Option('list', help='List shelved changes.'),
6545
help='Destroy removed changes instead of shelving them.'),
6547
_see_also = ['unshelve', 'configuration']
6549
def run(self, revision=None, all=False, file_list=None, message=None,
6550
writer=None, list=False, destroy=False, directory=None):
6552
return self.run_for_list(directory=directory)
6553
from bzrlib.shelf_ui import Shelver
6555
writer = bzrlib.option.diff_writer_registry.get()
6557
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6558
file_list, message, destroy=destroy, directory=directory)
6563
except errors.UserAbort:
6566
def run_for_list(self, directory=None):
6567
if directory is None:
6569
tree = WorkingTree.open_containing(directory)[0]
6570
self.add_cleanup(tree.lock_read().unlock)
6571
manager = tree.get_shelf_manager()
6572
shelves = manager.active_shelves()
6573
if len(shelves) == 0:
6574
note(gettext('No shelved changes.'))
6576
for shelf_id in reversed(shelves):
6577
message = manager.get_metadata(shelf_id).get('message')
6579
message = '<no message>'
6580
self.outf.write('%3d: %s\n' % (shelf_id, message))
6584
class cmd_unshelve(Command):
6585
__doc__ = """Restore shelved changes.
6587
By default, the most recently shelved changes are restored. However if you
6588
specify a shelf by id those changes will be restored instead. This works
6589
best when the changes don't depend on each other.
6592
takes_args = ['shelf_id?']
6595
RegistryOption.from_kwargs(
6596
'action', help="The action to perform.",
6597
enum_switch=False, value_switches=True,
6598
apply="Apply changes and remove from the shelf.",
6599
dry_run="Show changes, but do not apply or remove them.",
6600
preview="Instead of unshelving the changes, show the diff that "
6601
"would result from unshelving.",
6602
delete_only="Delete changes without applying them.",
6603
keep="Apply changes but don't delete them.",
6606
_see_also = ['shelve']
6608
def run(self, shelf_id=None, action='apply', directory=u'.'):
6609
from bzrlib.shelf_ui import Unshelver
6610
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
6614
unshelver.tree.unlock()
6617
class cmd_clean_tree(Command):
6618
__doc__ = """Remove unwanted files from working tree.
6620
By default, only unknown files, not ignored files, are deleted. Versioned
6621
files are never deleted.
6623
Another class is 'detritus', which includes files emitted by bzr during
6624
normal operations and selftests. (The value of these files decreases with
6627
If no options are specified, unknown files are deleted. Otherwise, option
6628
flags are respected, and may be combined.
6630
To check what clean-tree will do, use --dry-run.
6632
takes_options = ['directory',
6633
Option('ignored', help='Delete all ignored files.'),
6634
Option('detritus', help='Delete conflict files, merge and revert'
6635
' backups, and failed selftest dirs.'),
6637
help='Delete files unknown to bzr (default).'),
6638
Option('dry-run', help='Show files to delete instead of'
6640
Option('force', help='Do not prompt before deleting.')]
6641
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6642
force=False, directory=u'.'):
6643
from bzrlib.clean_tree import clean_tree
6644
if not (unknown or ignored or detritus):
6648
clean_tree(directory, unknown=unknown, ignored=ignored,
6649
detritus=detritus, dry_run=dry_run, no_prompt=force)
6652
class cmd_reference(Command):
6653
__doc__ = """list, view and set branch locations for nested trees.
6655
If no arguments are provided, lists the branch locations for nested trees.
6656
If one argument is provided, display the branch location for that tree.
6657
If two arguments are provided, set the branch location for that tree.
6662
takes_args = ['path?', 'location?']
6664
def run(self, path=None, location=None):
6666
if path is not None:
6668
tree, branch, relpath =(
6669
controldir.ControlDir.open_containing_tree_or_branch(branchdir))
6670
if path is not None:
6673
tree = branch.basis_tree()
6675
info = branch._get_all_reference_info().iteritems()
6676
self._display_reference_info(tree, branch, info)
6678
file_id = tree.path2id(path)
6680
raise errors.NotVersionedError(path)
6681
if location is None:
6682
info = [(file_id, branch.get_reference_info(file_id))]
6683
self._display_reference_info(tree, branch, info)
6685
branch.set_reference_info(file_id, path, location)
6687
def _display_reference_info(self, tree, branch, info):
6689
for file_id, (path, location) in info:
6691
path = tree.id2path(file_id)
6692
except errors.NoSuchId:
6694
ref_list.append((path, location))
6695
for path, location in sorted(ref_list):
6696
self.outf.write('%s %s\n' % (path, location))
6699
class cmd_export_pot(Command):
6700
__doc__ = """Export command helps and error messages in po format."""
6703
takes_options = [Option('plugin',
6704
help='Export help text from named command '\
6705
'(defaults to all built in commands).',
6707
Option('include-duplicates',
6708
help='Output multiple copies of the same msgid '
6709
'string if it appears more than once.'),
6712
def run(self, plugin=None, include_duplicates=False):
6713
from bzrlib.export_pot import export_pot
6714
export_pot(self.outf, plugin, include_duplicates)
6717
def _register_lazy_builtins():
6718
# register lazy builtins from other modules; called at startup and should
6719
# be only called once.
6720
for (name, aliases, module_name) in [
6721
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6722
('cmd_config', [], 'bzrlib.config'),
6723
('cmd_dpush', [], 'bzrlib.foreign'),
6724
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6725
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6726
('cmd_conflicts', [], 'bzrlib.conflicts'),
6727
('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6728
('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
6729
('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6731
builtin_command_registry.register_lazy(name, aliases, module_name)
2805
t = get_transport(directory)
2807
server = smart.SmartStreamServer(sys.stdin, sys.stdout, t)
2808
elif port is not None:
2810
host, port = port.split(':')
2813
server = smart.SmartTCPServer(t, host=host, port=int(port))
2814
print 'listening on port: ', server.port
2817
raise BzrCommandError("bzr serve requires one of --inet or --port")
2821
# command-line interpretation helper for merge-related commands
2822
def merge(other_revision, base_revision,
2823
check_clean=True, ignore_zero=False,
2824
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2825
file_list=None, show_base=False, reprocess=False,
2826
pb=DummyProgress()):
2827
"""Merge changes into a tree.
2830
list(path, revno) Base for three-way merge.
2831
If [None, None] then a base will be automatically determined.
2833
list(path, revno) Other revision for three-way merge.
2835
Directory to merge changes into; '.' by default.
2837
If true, this_dir must have no uncommitted changes before the
2839
ignore_zero - If true, suppress the "zero conflicts" message when
2840
there are no conflicts; should be set when doing something we expect
2841
to complete perfectly.
2842
file_list - If supplied, merge only changes to selected files.
2844
All available ancestors of other_revision and base_revision are
2845
automatically pulled into the branch.
2847
The revno may be -1 to indicate the last revision on the branch, which is
2850
This function is intended for use from the command line; programmatic
2851
clients might prefer to call merge.merge_inner(), which has less magic
2854
from bzrlib.merge import Merger
2855
if this_dir is None:
2857
this_tree = WorkingTree.open_containing(this_dir)[0]
2858
if show_base and not merge_type is Merge3Merger:
2859
raise BzrCommandError("Show-base is not supported for this merge"
2860
" type. %s" % merge_type)
2861
if reprocess and not merge_type.supports_reprocess:
2862
raise BzrCommandError("Conflict reduction is not supported for merge"
2863
" type %s." % merge_type)
2864
if reprocess and show_base:
2865
raise BzrCommandError("Cannot do conflict reduction and show base.")
2867
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2868
merger.pp = ProgressPhase("Merge phase", 5, pb)
2869
merger.pp.next_phase()
2870
merger.check_basis(check_clean)
2871
merger.set_other(other_revision)
2872
merger.pp.next_phase()
2873
merger.set_base(base_revision)
2874
if merger.base_rev_id == merger.other_rev_id:
2875
note('Nothing to do.')
2877
merger.backup_files = backup_files
2878
merger.merge_type = merge_type
2879
merger.set_interesting_files(file_list)
2880
merger.show_base = show_base
2881
merger.reprocess = reprocess
2882
conflicts = merger.do_merge()
2883
if file_list is None:
2884
merger.set_pending()
2890
# these get imported and then picked up by the scan for cmd_*
2891
# TODO: Some more consistent way to split command definitions across files;
2892
# we do need to load at least some information about them to know of
2893
# aliases. ideally we would avoid loading the implementation until the
2894
# details were needed.
2895
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2896
from bzrlib.bundle.commands import cmd_bundle_revisions
2897
from bzrlib.sign_my_commits import cmd_sign_my_commits
2898
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2899
cmd_weave_plan_merge, cmd_weave_merge_text