28
29
from bzrlib import (
35
config as _mod_config,
40
39
merge as _mod_merge,
45
43
revision as _mod_revision,
54
50
from bzrlib.branch import Branch
55
51
from bzrlib.conflicts import ConflictList
56
from bzrlib.transport import memory
57
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
52
from bzrlib.revisionspec import RevisionSpec
58
53
from bzrlib.smtp_connection import SMTPConnection
59
54
from bzrlib.workingtree import WorkingTree
62
from bzrlib.commands import (
64
builtin_command_registry,
67
from bzrlib.option import (
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
77
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
def tree_files(file_list, default_branch=u'.', canonicalize=True,
80
return internal_tree_files(file_list, default_branch, canonicalize,
84
def tree_files_for_add(file_list):
86
Return a tree and list of absolute paths from a file list.
88
Similar to tree_files, but add handles files a bit differently, so it a
89
custom implementation. In particular, MutableTreeTree.smart_add expects
90
absolute paths, which it immediately converts to relative paths.
92
# FIXME Would be nice to just return the relative paths like
93
# internal_tree_files does, but there are a large number of unit tests
94
# that assume the current interface to mutabletree.smart_add
96
tree, relpath = WorkingTree.open_containing(file_list[0])
97
if tree.supports_views():
98
view_files = tree.views.lookup_view()
100
for filename in file_list:
101
if not osutils.is_inside_any(view_files, filename):
102
raise errors.FileOutsideView(filename, view_files)
103
file_list = file_list[:]
104
file_list[0] = tree.abspath(relpath)
106
tree = WorkingTree.open_containing(u'.')[0]
107
if tree.supports_views():
108
view_files = tree.views.lookup_view()
110
file_list = view_files
111
view_str = views.view_display_str(view_files)
112
note("Ignoring files outside view. View is %s" % view_str)
113
return tree, file_list
116
def _get_one_revision(command_name, revisions):
117
if revisions is None:
119
if len(revisions) != 1:
120
raise errors.BzrCommandError(
121
'bzr %s --revision takes exactly one revision identifier' % (
126
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
127
"""Get a revision tree. Not suitable for commands that change the tree.
129
Specifically, the basis tree in dirstate trees is coupled to the dirstate
130
and doing a commit/uncommit/pull will at best fail due to changing the
133
If tree is passed in, it should be already locked, for lifetime management
134
of the trees internal cached state.
138
if revisions is None:
140
rev_tree = tree.basis_tree()
142
rev_tree = branch.basis_tree()
144
revision = _get_one_revision(command_name, revisions)
145
rev_tree = revision.as_tree(branch)
57
from bzrlib.commands import Command, display_command
58
from bzrlib.option import ListOption, Option, RegistryOption, custom_help
59
from bzrlib.trace import mutter, note, warning, is_quiet, info
62
def tree_files(file_list, default_branch=u'.'):
64
return internal_tree_files(file_list, default_branch)
65
except errors.FileInWrongBranch, e:
66
raise errors.BzrCommandError("%s is not in the same branch as %s" %
67
(e.path, file_list[0]))
149
70
# XXX: Bad function name; should possibly also be a class method of
150
71
# WorkingTree rather than a function.
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
152
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
72
def internal_tree_files(file_list, default_branch=u'.'):
154
73
"""Convert command-line paths to a WorkingTree and relative paths.
156
Deprecated: use WorkingTree.open_containing_paths instead.
158
75
This is typically used for command-line processors that take one or
159
76
more filenames, and infer the workingtree that contains them.
161
78
The filenames given are not required to exist.
163
:param file_list: Filenames to convert.
80
:param file_list: Filenames to convert.
165
82
:param default_branch: Fallback tree path to use if file_list is empty or
168
:param apply_view: if True and a view is set, apply it or check that
169
specified files are within it
171
85
:return: workingtree, [relative_paths]
173
return WorkingTree.open_containing_paths(
174
file_list, default_directory='.',
179
def _get_view_info_for_change_reporter(tree):
180
"""Get the view information from a tree for change reporting."""
87
if file_list is None or len(file_list) == 0:
88
return WorkingTree.open_containing(default_branch)[0], file_list
89
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
91
for filename in file_list:
93
new_list.append(tree.relpath(osutils.dereference_path(filename)))
94
except errors.PathNotChild:
95
raise errors.FileInWrongBranch(tree.branch, filename)
99
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
100
def get_format_type(typestring):
101
"""Parse and return a format specifier."""
102
# Have to use BzrDirMetaFormat1 directly, so that
103
# RepositoryFormat.set_default_format works
104
if typestring == "default":
105
return bzrdir.BzrDirMetaFormat1()
183
current_view = tree.views.get_view_info()[0]
184
if current_view is not None:
185
view_info = (current_view, tree.views.lookup_view())
186
except errors.ViewsNotSupported:
191
def _open_directory_or_containing_tree_or_branch(filename, directory):
192
"""Open the tree or branch containing the specified file, unless
193
the --directory option is used to specify a different branch."""
194
if directory is not None:
195
return (None, Branch.open(directory), filename)
196
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
107
return bzrdir.format_registry.make_bzrdir(typestring)
109
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
110
raise errors.BzrCommandError(msg)
199
113
# TODO: Make sure no commands unconditionally use the working directory as a
230
144
Not versioned and not matching an ignore pattern.
232
Additionally for directories, symlinks and files with an executable
233
bit, Bazaar indicates their type using a trailing character: '/', '@'
236
146
To see ignored files use 'bzr ignored'. For details on the
237
147
changes to file texts, use 'bzr diff'.
239
149
Note that --short or -S gives status flags for each item, similar
240
150
to Subversion's status command. To get output similar to svn -q,
243
153
If no arguments are specified, the status of the entire working
244
154
directory is shown. Otherwise, only the status of the specified
245
155
files or directories is reported. If a directory is given, status
246
156
is reported for everything inside that directory.
248
Before merges are committed, the pending merge tip revisions are
249
shown. To see all pending merge revisions, use the -v option.
250
To skip the display of pending merge information altogether, use
251
the no-pending option or specify a file/directory.
253
To compare the working directory to a specific revision, pass a
254
single revision to the revision argument.
256
To see which files have changed in a specific revision, or between
257
two revisions, pass a revision range to the revision argument.
258
This will produce the same results as calling 'bzr diff --summarize'.
158
If a revision argument is given, the status is calculated against
159
that revision, or between two revisions if two are provided.
261
162
# TODO: --no-recurse, --recurse options
263
164
takes_args = ['file*']
264
takes_options = ['show-ids', 'revision', 'change', 'verbose',
165
takes_options = ['show-ids', 'revision', 'change',
265
166
Option('short', help='Use short status indicators.',
267
168
Option('versioned', help='Only show versioned files.',
269
Option('no-pending', help='Don\'t show pending merges.',
272
171
aliases = ['st', 'stat']
274
173
encoding_type = 'replace'
275
174
_see_also = ['diff', 'revert', 'status-flags']
278
177
def run(self, show_ids=False, file_list=None, revision=None, short=False,
279
versioned=False, no_pending=False, verbose=False):
280
179
from bzrlib.status import show_tree_status
282
181
if revision and len(revision) > 2:
283
182
raise errors.BzrCommandError('bzr status --revision takes exactly'
284
183
' one or two revision specifiers')
286
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
287
# Avoid asking for specific files when that is not needed.
288
if relfile_list == ['']:
290
# Don't disable pending merges for full trees other than '.'.
291
if file_list == ['.']:
293
# A specific path within a tree was given.
294
elif relfile_list is not None:
185
tree, file_list = tree_files(file_list)
296
187
show_tree_status(tree, show_ids=show_ids,
297
specific_files=relfile_list, revision=revision,
298
to_file=self.outf, short=short, versioned=versioned,
299
show_pending=(not no_pending), verbose=verbose)
188
specific_files=file_list, revision=revision,
189
to_file=self.outf, short=short, versioned=versioned)
302
192
class cmd_cat_revision(Command):
303
__doc__ = """Write out metadata for a revision.
193
"""Write out metadata for a revision.
305
195
The revision to print can either be specified by a specific
306
196
revision identifier, or you can use --revision.
310
200
takes_args = ['revision_id?']
311
takes_options = ['directory', 'revision']
201
takes_options = ['revision']
312
202
# cat-revision is more for frontends so should be exact
313
203
encoding = 'strict'
315
def print_revision(self, revisions, revid):
316
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
317
record = stream.next()
318
if record.storage_kind == 'absent':
319
raise errors.NoSuchRevision(revisions, revid)
320
revtext = record.get_bytes_as('fulltext')
321
self.outf.write(revtext.decode('utf-8'))
324
def run(self, revision_id=None, revision=None, directory=u'.'):
206
def run(self, revision_id=None, revision=None):
325
207
if revision_id is not None and revision is not None:
326
208
raise errors.BzrCommandError('You can only supply one of'
327
209
' revision_id or --revision')
328
210
if revision_id is None and revision is None:
329
211
raise errors.BzrCommandError('You must supply either'
330
212
' --revision or a revision_id')
332
b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
334
revisions = b.repository.revisions
335
if revisions is None:
336
raise errors.BzrCommandError('Repository %r does not support '
337
'access to raw revision texts')
339
b.repository.lock_read()
341
# TODO: jam 20060112 should cat-revision always output utf-8?
342
if revision_id is not None:
343
revision_id = osutils.safe_revision_id(revision_id, warn=False)
345
self.print_revision(revisions, revision_id)
346
except errors.NoSuchRevision:
347
msg = "The repository %s contains no revision %s." % (
348
b.repository.base, revision_id)
349
raise errors.BzrCommandError(msg)
350
elif revision is not None:
353
raise errors.BzrCommandError(
354
'You cannot specify a NULL revision.')
355
rev_id = rev.as_revision_id(b)
356
self.print_revision(revisions, rev_id)
358
b.repository.unlock()
361
class cmd_dump_btree(Command):
362
__doc__ = """Dump the contents of a btree index file to stdout.
364
PATH is a btree index file, it can be any URL. This includes things like
365
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
367
By default, the tuples stored in the index file will be displayed. With
368
--raw, we will uncompress the pages, but otherwise display the raw bytes
372
# TODO: Do we want to dump the internal nodes as well?
373
# TODO: It would be nice to be able to dump the un-parsed information,
374
# rather than only going through iter_all_entries. However, this is
375
# good enough for a start
377
encoding_type = 'exact'
378
takes_args = ['path']
379
takes_options = [Option('raw', help='Write the uncompressed bytes out,'
380
' rather than the parsed tuples.'),
383
def run(self, path, raw=False):
384
dirname, basename = osutils.split(path)
385
t = transport.get_transport(dirname)
387
self._dump_raw_bytes(t, basename)
389
self._dump_entries(t, basename)
391
def _get_index_and_bytes(self, trans, basename):
392
"""Create a BTreeGraphIndex and raw bytes."""
393
bt = btree_index.BTreeGraphIndex(trans, basename, None)
394
bytes = trans.get_bytes(basename)
395
bt._file = cStringIO.StringIO(bytes)
396
bt._size = len(bytes)
399
def _dump_raw_bytes(self, trans, basename):
402
# We need to parse at least the root node.
403
# This is because the first page of every row starts with an
404
# uncompressed header.
405
bt, bytes = self._get_index_and_bytes(trans, basename)
406
for page_idx, page_start in enumerate(xrange(0, len(bytes),
407
btree_index._PAGE_SIZE)):
408
page_end = min(page_start + btree_index._PAGE_SIZE, len(bytes))
409
page_bytes = bytes[page_start:page_end]
411
self.outf.write('Root node:\n')
412
header_end, data = bt._parse_header_from_bytes(page_bytes)
413
self.outf.write(page_bytes[:header_end])
415
self.outf.write('\nPage %d\n' % (page_idx,))
416
if len(page_bytes) == 0:
417
self.outf.write('(empty)\n');
419
decomp_bytes = zlib.decompress(page_bytes)
420
self.outf.write(decomp_bytes)
421
self.outf.write('\n')
423
def _dump_entries(self, trans, basename):
425
st = trans.stat(basename)
426
except errors.TransportNotPossible:
427
# We can't stat, so we'll fake it because we have to do the 'get()'
429
bt, _ = self._get_index_and_bytes(trans, basename)
431
bt = btree_index.BTreeGraphIndex(trans, basename, st.st_size)
432
for node in bt.iter_all_entries():
433
# Node is made up of:
434
# (index, key, value, [references])
438
refs_as_tuples = None
440
refs_as_tuples = static_tuple.as_tuples(refs)
441
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
442
self.outf.write('%s\n' % (as_tuple,))
213
b = WorkingTree.open_containing(u'.')[0].branch
215
# TODO: jam 20060112 should cat-revision always output utf-8?
216
if revision_id is not None:
217
revision_id = osutils.safe_revision_id(revision_id, warn=False)
218
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
219
elif revision is not None:
222
raise errors.BzrCommandError('You cannot specify a NULL'
224
revno, rev_id = rev.in_history(b)
225
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
445
228
class cmd_remove_tree(Command):
446
__doc__ = """Remove the working tree from a given branch/checkout.
229
"""Remove the working tree from a given branch/checkout.
448
231
Since a lightweight checkout is little more than a working tree
449
232
this will refuse to run against one.
451
234
To re-create the working tree, use "bzr checkout".
453
236
_see_also = ['checkout', 'working-trees']
454
takes_args = ['location*']
457
help='Remove the working tree even if it has '
458
'uncommitted or shelved changes.'),
461
def run(self, location_list, force=False):
462
if not location_list:
465
for location in location_list:
466
d = bzrdir.BzrDir.open(location)
469
working = d.open_workingtree()
470
except errors.NoWorkingTree:
471
raise errors.BzrCommandError("No working tree to remove")
472
except errors.NotLocalUrl:
473
raise errors.BzrCommandError("You cannot remove the working tree"
476
if (working.has_changes()):
477
raise errors.UncommittedChanges(working)
478
if working.get_shelf_manager().last_shelf() is not None:
479
raise errors.ShelvedChanges(working)
481
if working.user_url != working.branch.user_url:
482
raise errors.BzrCommandError("You cannot remove the working tree"
483
" from a lightweight checkout")
485
d.destroy_workingtree()
488
class cmd_repair_workingtree(Command):
489
__doc__ = """Reset the working tree state file.
491
This is not meant to be used normally, but more as a way to recover from
492
filesystem corruption, etc. This rebuilds the working inventory back to a
493
'known good' state. Any new modifications (adding a file, renaming, etc)
494
will be lost, though modified files will still be detected as such.
496
Most users will want something more like "bzr revert" or "bzr update"
497
unless the state file has become corrupted.
499
By default this attempts to recover the current state by looking at the
500
headers of the state file. If the state file is too corrupted to even do
501
that, you can supply --revision to force the state of the tree.
504
takes_options = ['revision', 'directory',
506
help='Reset the tree even if it doesn\'t appear to be'
511
def run(self, revision=None, directory='.', force=False):
512
tree, _ = WorkingTree.open_containing(directory)
513
self.add_cleanup(tree.lock_tree_write().unlock)
517
except errors.BzrError:
518
pass # There seems to be a real error here, so we'll reset
521
raise errors.BzrCommandError(
522
'The tree does not appear to be corrupt. You probably'
523
' want "bzr revert" instead. Use "--force" if you are'
524
' sure you want to reset the working tree.')
528
revision_ids = [r.as_revision_id(tree.branch) for r in revision]
238
takes_args = ['location?']
240
def run(self, location='.'):
241
d = bzrdir.BzrDir.open(location)
530
tree.reset_state(revision_ids)
531
except errors.BzrError, e:
532
if revision_ids is None:
533
extra = (', the header appears corrupt, try passing -r -1'
534
' to set the state to the last commit')
537
raise errors.BzrCommandError('failed to reset the tree state'
244
working = d.open_workingtree()
245
except errors.NoWorkingTree:
246
raise errors.BzrCommandError("No working tree to remove")
247
except errors.NotLocalUrl:
248
raise errors.BzrCommandError("You cannot remove the working tree of a "
251
working_path = working.bzrdir.root_transport.base
252
branch_path = working.branch.bzrdir.root_transport.base
253
if working_path != branch_path:
254
raise errors.BzrCommandError("You cannot remove the working tree from "
255
"a lightweight checkout")
257
d.destroy_workingtree()
541
260
class cmd_revno(Command):
542
__doc__ = """Show current revision number.
261
"""Show current revision number.
544
263
This is equal to the number of revisions on this branch.
547
266
_see_also = ['info']
548
267
takes_args = ['location?']
550
Option('tree', help='Show revno of working tree'),
554
def run(self, tree=False, location=u'.'):
557
wt = WorkingTree.open_containing(location)[0]
558
self.add_cleanup(wt.lock_read().unlock)
559
except (errors.NoWorkingTree, errors.NotLocalUrl):
560
raise errors.NoWorkingTree(location)
561
revid = wt.last_revision()
563
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
564
except errors.NoSuchRevision:
566
revno = ".".join(str(n) for n in revno_t)
568
b = Branch.open_containing(location)[0]
569
self.add_cleanup(b.lock_read().unlock)
572
self.outf.write(str(revno) + '\n')
270
def run(self, location=u'.'):
271
self.outf.write(str(Branch.open_containing(location)[0].revno()))
272
self.outf.write('\n')
575
275
class cmd_revision_info(Command):
576
__doc__ = """Show revision number and revision id for a given revision identifier.
276
"""Show revision number and revision id for a given revision identifier.
579
279
takes_args = ['revision_info*']
582
custom_help('directory',
583
help='Branch to examine, '
584
'rather than the one containing the working directory.'),
585
Option('tree', help='Show revno of working tree'),
280
takes_options = ['revision']
589
def run(self, revision=None, directory=u'.', tree=False,
590
revision_info_list=[]):
283
def run(self, revision=None, revision_info_list=[]):
593
wt = WorkingTree.open_containing(directory)[0]
595
self.add_cleanup(wt.lock_read().unlock)
596
except (errors.NoWorkingTree, errors.NotLocalUrl):
598
b = Branch.open_containing(directory)[0]
599
self.add_cleanup(b.lock_read().unlock)
601
286
if revision is not None:
602
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
287
revs.extend(revision)
603
288
if revision_info_list is not None:
604
for rev_str in revision_info_list:
605
rev_spec = RevisionSpec.from_string(rev_str)
606
revision_ids.append(rev_spec.as_revision_id(b))
607
# No arguments supplied, default to the last revision
608
if len(revision_ids) == 0:
611
raise errors.NoWorkingTree(directory)
612
revision_ids.append(wt.last_revision())
289
for rev in revision_info_list:
290
revs.append(RevisionSpec.from_string(rev))
292
b = Branch.open_containing(u'.')[0]
295
revs.append(RevisionSpec.from_string('-1'))
298
revinfo = rev.in_history(b)
299
if revinfo.revno is None:
300
dotted_map = b.get_revision_id_to_revno_map()
301
revno = '.'.join(str(i) for i in dotted_map[revinfo.rev_id])
302
print '%s %s' % (revno, revinfo.rev_id)
614
revision_ids.append(b.last_revision())
618
for revision_id in revision_ids:
620
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
621
revno = '.'.join(str(i) for i in dotted_revno)
622
except errors.NoSuchRevision:
624
maxlen = max(maxlen, len(revno))
625
revinfos.append([revno, revision_id])
629
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
304
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
632
307
class cmd_add(Command):
633
__doc__ = """Add specified files or directories.
308
"""Add specified files or directories.
635
310
In non-recursive mode, all the named items are added, regardless
636
311
of whether they were previously ignored. A warning is given if
834
523
takes_args = ['names*']
835
524
takes_options = [Option("after", help="Move only the bzr identifier"
836
525
" of the file, because the file has already been moved."),
837
Option('auto', help='Automatically guess renames.'),
838
Option('dry-run', help='Avoid making changes when guessing renames.'),
840
527
aliases = ['move', 'rename']
841
528
encoding_type = 'replace'
843
def run(self, names_list, after=False, auto=False, dry_run=False):
845
return self.run_auto(names_list, after, dry_run)
847
raise errors.BzrCommandError('--dry-run requires --auto.')
530
def run(self, names_list, after=False):
848
531
if names_list is None:
850
534
if len(names_list) < 2:
851
535
raise errors.BzrCommandError("missing file argument")
852
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
853
self.add_cleanup(tree.lock_tree_write().unlock)
854
self._run(tree, names_list, rel_names, after)
856
def run_auto(self, names_list, after, dry_run):
857
if names_list is not None and len(names_list) > 1:
858
raise errors.BzrCommandError('Only one path may be specified to'
861
raise errors.BzrCommandError('--after cannot be specified with'
863
work_tree, file_list = WorkingTree.open_containing_paths(
864
names_list, default_directory='.')
865
self.add_cleanup(work_tree.lock_tree_write().unlock)
866
rename_map.RenameMap.guess_renames(work_tree, dry_run)
868
def _run(self, tree, names_list, rel_names, after):
869
into_existing = osutils.isdir(names_list[-1])
870
if into_existing and len(names_list) == 2:
872
# a. case-insensitive filesystem and change case of dir
873
# b. move directory after the fact (if the source used to be
874
# a directory, but now doesn't exist in the working tree
875
# and the target is an existing directory, just rename it)
876
if (not tree.case_sensitive
877
and rel_names[0].lower() == rel_names[1].lower()):
878
into_existing = False
881
# 'fix' the case of a potential 'from'
882
from_id = tree.path2id(
883
tree.get_canonical_inventory_path(rel_names[0]))
884
if (not osutils.lexists(names_list[0]) and
885
from_id and inv.get_file_kind(from_id) == "directory"):
886
into_existing = False
536
tree, rel_names = tree_files(names_list)
538
if os.path.isdir(names_list[-1]):
889
539
# move into existing directory
890
# All entries reference existing inventory items, so fix them up
891
# for cicp file-systems.
892
rel_names = tree.get_canonical_inventory_paths(rel_names)
893
for src, dest in tree.move(rel_names[:-1], rel_names[-1], after=after):
895
self.outf.write("%s => %s\n" % (src, dest))
540
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
541
self.outf.write("%s => %s\n" % pair)
897
543
if len(names_list) != 2:
898
544
raise errors.BzrCommandError('to mv multiple files the'
899
545
' destination must be a versioned'
902
# for cicp file-systems: the src references an existing inventory
904
src = tree.get_canonical_inventory_path(rel_names[0])
905
# Find the canonical version of the destination: In all cases, the
906
# parent of the target must be in the inventory, so we fetch the
907
# canonical version from there (we do not always *use* the
908
# canonicalized tail portion - we may be attempting to rename the
910
canon_dest = tree.get_canonical_inventory_path(rel_names[1])
911
dest_parent = osutils.dirname(canon_dest)
912
spec_tail = osutils.basename(rel_names[1])
913
# For a CICP file-system, we need to avoid creating 2 inventory
914
# entries that differ only by case. So regardless of the case
915
# we *want* to use (ie, specified by the user or the file-system),
916
# we must always choose to use the case of any existing inventory
917
# items. The only exception to this is when we are attempting a
918
# case-only rename (ie, canonical versions of src and dest are
920
dest_id = tree.path2id(canon_dest)
921
if dest_id is None or tree.path2id(src) == dest_id:
922
# No existing item we care about, so work out what case we
923
# are actually going to use.
925
# If 'after' is specified, the tail must refer to a file on disk.
927
dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
929
# pathjoin with an empty tail adds a slash, which breaks
931
dest_parent_fq = tree.basedir
933
dest_tail = osutils.canonical_relpath(
935
osutils.pathjoin(dest_parent_fq, spec_tail))
937
# not 'after', so case as specified is used
938
dest_tail = spec_tail
940
# Use the existing item so 'mv' fails with AlreadyVersioned.
941
dest_tail = os.path.basename(canon_dest)
942
dest = osutils.pathjoin(dest_parent, dest_tail)
943
mutter("attempting to move %s => %s", src, dest)
944
tree.rename_one(src, dest, after=after)
946
self.outf.write("%s => %s\n" % (src, dest))
547
tree.rename_one(rel_names[0], rel_names[1], after=after)
548
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
949
551
class cmd_pull(Command):
950
__doc__ = """Turn this branch into a mirror of another branch.
552
"""Turn this branch into a mirror of another branch.
952
By default, this command only works on branches that have not diverged.
953
Branches are considered diverged if the destination branch's most recent
954
commit is one that has not been merged (directly or indirectly) into the
554
This command only works on branches that have not diverged. Branches are
555
considered diverged if the destination branch's most recent commit is one
556
that has not been merged (directly or indirectly) into the parent.
957
558
If branches have diverged, you can use 'bzr merge' to integrate the changes
958
559
from one into the other. Once one branch has merged, the other should
959
560
be able to pull it again.
961
If you want to replace your local changes and just want your branch to
962
match the remote one, use pull --overwrite. This will work even if the two
963
branches have diverged.
562
If you want to forget your local changes and just update your branch to
563
match the remote one, use pull --overwrite.
965
565
If there is no default location set, the first pull will set it. After
966
566
that, you can omit the location to use the default. To change the
967
567
default, use --remember. The value will only be saved if the remote
968
568
location can be accessed.
970
Note: The location can be specified either in the form of a branch,
971
or in the form of a path to a file containing a merge directive generated
975
_see_also = ['push', 'update', 'status-flags', 'send']
571
_see_also = ['push', 'update', 'status-flags']
976
572
takes_options = ['remember', 'overwrite', 'revision',
977
573
custom_help('verbose',
978
574
help='Show logs of pulled revisions.'),
979
custom_help('directory',
980
576
help='Branch to pull into, '
981
'rather than the one containing the working directory.'),
983
help="Perform a local pull in a bound "
984
"branch. Local pulls are not applied to "
577
'rather than the one containing the working directory.',
988
help="Show base revision text in conflicts.")
990
582
takes_args = ['location?']
991
583
encoding_type = 'replace'
993
585
def run(self, location=None, remember=False, overwrite=False,
994
586
revision=None, verbose=False,
995
directory=None, local=False,
997
588
# FIXME: too much stuff is in the command class
998
589
revision_id = None
1107
683
_see_also = ['pull', 'update', 'working-trees']
1108
takes_options = ['remember', 'overwrite', 'verbose', 'revision',
684
takes_options = ['remember', 'overwrite', 'verbose',
1109
685
Option('create-prefix',
1110
686
help='Create the path leading up to the branch '
1111
687
'if it does not already exist.'),
1112
custom_help('directory',
1113
689
help='Branch to push from, '
1114
'rather than the one containing the working directory.'),
690
'rather than the one containing the working directory.',
1115
694
Option('use-existing-dir',
1116
695
help='By default push will fail if the target'
1117
696
' directory exists, but does not already'
1118
697
' have a control directory. This flag will'
1119
698
' allow push to proceed.'),
1121
help='Create a stacked branch that references the public location '
1122
'of the parent branch.'),
1123
Option('stacked-on',
1124
help='Create a stacked branch that refers to another branch '
1125
'for the commit history. Only the work not present in the '
1126
'referenced branch is included in the branch created.',
1129
help='Refuse to push if there are uncommitted changes in'
1130
' the working tree, --no-strict disables the check.'),
1132
help="Don't populate the working tree, even for protocols"
1133
" that support it."),
1135
700
takes_args = ['location?']
1136
701
encoding_type = 'replace'
1138
703
def run(self, location=None, remember=False, overwrite=False,
1139
create_prefix=False, verbose=False, revision=None,
1140
use_existing_dir=False, directory=None, stacked_on=None,
1141
stacked=False, strict=None, no_tree=False):
1142
from bzrlib.push import _show_push_branch
704
create_prefix=False, verbose=False,
705
use_existing_dir=False,
707
# FIXME: Way too big! Put this into a function called from the
1144
709
if directory is None:
1146
# Get the source branch
1148
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1149
# Get the tip's revision_id
1150
revision = _get_one_revision('push', revision)
1151
if revision is not None:
1152
revision_id = revision.in_history(br_from).rev_id
1155
if tree is not None and revision_id is None:
1156
tree.check_changed_or_out_of_date(
1157
strict, 'push_strict',
1158
more_error='Use --no-strict to force the push.',
1159
more_warning='Uncommitted changes will not be pushed.')
1160
# Get the stacked_on branch, if any
1161
if stacked_on is not None:
1162
stacked_on = urlutils.normalize_url(stacked_on)
1164
parent_url = br_from.get_parent()
1166
parent = Branch.open(parent_url)
1167
stacked_on = parent.get_public_branch()
1169
# I considered excluding non-http url's here, thus forcing
1170
# 'public' branches only, but that only works for some
1171
# users, so it's best to just depend on the user spotting an
1172
# error by the feedback given to them. RBC 20080227.
1173
stacked_on = parent_url
1175
raise errors.BzrCommandError(
1176
"Could not determine branch to refer to.")
1178
# Get the destination location
711
br_from = Branch.open_containing(directory)[0]
712
stored_loc = br_from.get_push_location()
1179
713
if location is None:
1180
stored_loc = br_from.get_push_location()
1181
714
if stored_loc is None:
1182
raise errors.BzrCommandError(
1183
"No push location known or specified.")
715
raise errors.BzrCommandError("No push location known or specified.")
1185
717
display_url = urlutils.unescape_for_display(stored_loc,
1186
718
self.outf.encoding)
1187
self.outf.write("Using saved push location: %s\n" % display_url)
719
self.outf.write("Using saved location: %s\n" % display_url)
1188
720
location = stored_loc
1190
_show_push_branch(br_from, revision_id, location, self.outf,
1191
verbose=verbose, overwrite=overwrite, remember=remember,
1192
stacked_on=stacked_on, create_prefix=create_prefix,
1193
use_existing_dir=use_existing_dir, no_tree=no_tree)
722
to_transport = transport.get_transport(location)
724
br_to = repository_to = dir_to = None
726
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
727
except errors.NotBranchError:
728
pass # Didn't find anything
730
# If we can open a branch, use its direct repository, otherwise see
731
# if there is a repository without a branch.
733
br_to = dir_to.open_branch()
734
except errors.NotBranchError:
735
# Didn't find a branch, can we find a repository?
737
repository_to = dir_to.find_repository()
738
except errors.NoRepositoryPresent:
741
# Found a branch, so we must have found a repository
742
repository_to = br_to.repository
747
# The destination doesn't exist; create it.
748
# XXX: Refactor the create_prefix/no_create_prefix code into a
749
# common helper function
751
def make_directory(transport):
755
def redirected(redirected_transport, e, redirection_notice):
756
return transport.get_transport(e.get_target_url())
759
to_transport = transport.do_catching_redirections(
760
make_directory, to_transport, redirected)
761
except errors.FileExists:
762
if not use_existing_dir:
763
raise errors.BzrCommandError("Target directory %s"
764
" already exists, but does not have a valid .bzr"
765
" directory. Supply --use-existing-dir to push"
766
" there anyway." % location)
767
except errors.NoSuchFile:
768
if not create_prefix:
769
raise errors.BzrCommandError("Parent directory of %s"
771
"\nYou may supply --create-prefix to create all"
772
" leading parent directories."
774
_create_prefix(to_transport)
775
except errors.TooManyRedirections:
776
raise errors.BzrCommandError("Too many redirections trying "
777
"to make %s." % location)
779
# Now the target directory exists, but doesn't have a .bzr
780
# directory. So we need to create it, along with any work to create
781
# all of the dependent branches, etc.
782
dir_to = br_from.bzrdir.clone_on_transport(to_transport,
783
revision_id=br_from.last_revision())
784
br_to = dir_to.open_branch()
785
# TODO: Some more useful message about what was copied
786
note('Created new branch.')
787
# We successfully created the target, remember it
788
if br_from.get_push_location() is None or remember:
789
br_from.set_push_location(br_to.base)
790
elif repository_to is None:
791
# we have a bzrdir but no branch or repository
792
# XXX: Figure out what to do other than complain.
793
raise errors.BzrCommandError("At %s you have a valid .bzr control"
794
" directory, but not a branch or repository. This is an"
795
" unsupported configuration. Please move the target directory"
796
" out of the way and try again."
799
# We have a repository but no branch, copy the revisions, and then
801
last_revision_id = br_from.last_revision()
802
repository_to.fetch(br_from.repository,
803
revision_id=last_revision_id)
804
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
805
note('Created new branch.')
806
if br_from.get_push_location() is None or remember:
807
br_from.set_push_location(br_to.base)
808
else: # We have a valid to branch
809
# We were able to connect to the remote location, so remember it
810
# we don't need to successfully push because of possible divergence.
811
if br_from.get_push_location() is None or remember:
812
br_from.set_push_location(br_to.base)
814
old_rh = br_to.revision_history()
817
tree_to = dir_to.open_workingtree()
818
except errors.NotLocalUrl:
819
warning("This transport does not update the working "
820
"tree of: %s. See 'bzr help working-trees' for "
821
"more information." % br_to.base)
822
push_result = br_from.push(br_to, overwrite)
823
except errors.NoWorkingTree:
824
push_result = br_from.push(br_to, overwrite)
828
push_result = br_from.push(tree_to.branch, overwrite)
832
except errors.DivergedBranches:
833
raise errors.BzrCommandError('These branches have diverged.'
834
' Try using "merge" and then "push".')
835
if push_result is not None:
836
push_result.report(self.outf)
838
new_rh = br_to.revision_history()
841
from bzrlib.log import show_changed_revisions
842
show_changed_revisions(br_to, old_rh, new_rh,
845
# we probably did a clone rather than a push, so a message was
1196
850
class cmd_branch(Command):
1197
__doc__ = """Create a new branch that is a copy of an existing branch.
851
"""Create a new copy of a branch.
1199
853
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1200
854
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1210
864
_see_also = ['checkout']
1211
865
takes_args = ['from_location', 'to_location?']
1212
takes_options = ['revision',
1213
Option('hardlink', help='Hard-link working tree files where possible.'),
1214
Option('files-from', type=str,
1215
help="Get file contents from this tree."),
1217
help="Create a branch without a working-tree."),
1219
help="Switch the checkout in the current directory "
1220
"to the new branch."),
1222
help='Create a stacked branch referring to the source branch. '
1223
'The new branch will depend on the availability of the source '
1224
'branch for all operations.'),
1225
Option('standalone',
1226
help='Do not use a shared repository, even if available.'),
1227
Option('use-existing-dir',
1228
help='By default branch will fail if the target'
1229
' directory exists, but does not already'
1230
' have a control directory. This flag will'
1231
' allow branch to proceed.'),
1233
help="Bind new branch to from location."),
866
takes_options = ['revision']
1235
867
aliases = ['get', 'clone']
1237
def run(self, from_location, to_location=None, revision=None,
1238
hardlink=False, stacked=False, standalone=False, no_tree=False,
1239
use_existing_dir=False, switch=False, bind=False,
1241
from bzrlib import switch as _mod_switch
869
def run(self, from_location, to_location=None, revision=None):
1242
870
from bzrlib.tag import _merge_tags_if_possible
1243
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1245
if not (hardlink or files_from):
1246
# accelerator_tree is usually slower because you have to read N
1247
# files (no readahead, lots of seeks, etc), but allow the user to
1248
# explicitly request it
1249
accelerator_tree = None
1250
if files_from is not None and files_from != from_location:
1251
accelerator_tree = WorkingTree.open(files_from)
1252
revision = _get_one_revision('branch', revision)
1253
self.add_cleanup(br_from.lock_read().unlock)
1254
if revision is not None:
1255
revision_id = revision.as_revision_id(br_from)
1257
# FIXME - wt.last_revision, fallback to branch, fall back to
1258
# None or perhaps NULL_REVISION to mean copy nothing
1260
revision_id = br_from.last_revision()
1261
if to_location is None:
1262
to_location = urlutils.derive_to_location(from_location)
1263
to_transport = transport.get_transport(to_location)
1265
to_transport.mkdir('.')
1266
except errors.FileExists:
1267
if not use_existing_dir:
1268
raise errors.BzrCommandError('Target directory "%s" '
1269
'already exists.' % to_location)
1272
bzrdir.BzrDir.open_from_transport(to_transport)
1273
except errors.NotBranchError:
1276
raise errors.AlreadyBranchError(to_location)
1277
except errors.NoSuchFile:
1278
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1281
# preserve whatever source format we have.
1282
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1283
possible_transports=[to_transport],
1284
accelerator_tree=accelerator_tree,
1285
hardlink=hardlink, stacked=stacked,
1286
force_new_repo=standalone,
1287
create_tree_if_local=not no_tree,
1288
source_branch=br_from)
1289
branch = dir.open_branch()
1290
except errors.NoSuchRevision:
1291
to_transport.delete_tree('.')
1292
msg = "The branch %s has no revision %s." % (from_location,
1294
raise errors.BzrCommandError(msg)
1295
_merge_tags_if_possible(br_from, branch)
1296
# If the source branch is stacked, the new branch may
1297
# be stacked whether we asked for that explicitly or not.
1298
# We therefore need a try/except here and not just 'if stacked:'
1300
note('Created new stacked branch referring to %s.' %
1301
branch.get_stacked_on_url())
1302
except (errors.NotStacked, errors.UnstackableBranchFormat,
1303
errors.UnstackableRepositoryFormat), e:
873
elif len(revision) > 1:
874
raise errors.BzrCommandError(
875
'bzr branch --revision takes exactly 1 revision value')
877
br_from = Branch.open(from_location)
880
if len(revision) == 1 and revision[0] is not None:
881
revision_id = revision[0].in_history(br_from)[1]
883
# FIXME - wt.last_revision, fallback to branch, fall back to
884
# None or perhaps NULL_REVISION to mean copy nothing
886
revision_id = br_from.last_revision()
887
if to_location is None:
888
to_location = urlutils.derive_to_location(from_location)
891
name = os.path.basename(to_location) + '\n'
893
to_transport = transport.get_transport(to_location)
895
to_transport.mkdir('.')
896
except errors.FileExists:
897
raise errors.BzrCommandError('Target directory "%s" already'
898
' exists.' % to_location)
899
except errors.NoSuchFile:
900
raise errors.BzrCommandError('Parent of "%s" does not exist.'
903
# preserve whatever source format we have.
904
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
905
possible_transports=[to_transport])
906
branch = dir.open_branch()
907
except errors.NoSuchRevision:
908
to_transport.delete_tree('.')
909
msg = "The branch %s has no revision %s." % (from_location, revision[0])
910
raise errors.BzrCommandError(msg)
912
branch.control_files.put_utf8('branch-name', name)
913
_merge_tags_if_possible(br_from, branch)
1304
914
note('Branched %d revision(s).' % branch.revno())
1306
# Bind to the parent
1307
parent_branch = Branch.open(from_location)
1308
branch.bind(parent_branch)
1309
note('New branch bound to %s' % from_location)
1311
# Switch to the new branch
1312
wt, _ = WorkingTree.open_containing('.')
1313
_mod_switch.switch(wt.bzrdir, branch)
1314
note('Switched to branch: %s',
1315
urlutils.unescape_for_display(branch.base, 'utf-8'))
1318
919
class cmd_checkout(Command):
1319
__doc__ = """Create a new checkout of an existing branch.
920
"""Create a new checkout of an existing branch.
1321
922
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1322
923
the branch found in '.'. This is useful if you have removed the working tree
1323
924
or if it was never created - i.e. if you pushed the branch to its current
1324
925
location using SFTP.
1326
927
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
1327
928
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
1328
929
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
1401
993
@display_command
1402
994
def run(self, dir=u'.'):
1403
995
tree = WorkingTree.open_containing(dir)[0]
1404
self.add_cleanup(tree.lock_read().unlock)
1405
new_inv = tree.inventory
1406
old_tree = tree.basis_tree()
1407
self.add_cleanup(old_tree.lock_read().unlock)
1408
old_inv = old_tree.inventory
1410
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1411
for f, paths, c, v, p, n, k, e in iterator:
1412
if paths[0] == paths[1]:
1416
renames.append(paths)
1418
for old_name, new_name in renames:
1419
self.outf.write("%s => %s\n" % (old_name, new_name))
998
new_inv = tree.inventory
999
old_tree = tree.basis_tree()
1000
old_tree.lock_read()
1002
old_inv = old_tree.inventory
1003
renames = list(_mod_tree.find_renames(old_inv, new_inv))
1005
for old_name, new_name in renames:
1006
self.outf.write("%s => %s\n" % (old_name, new_name))
1422
1013
class cmd_update(Command):
1423
__doc__ = """Update a tree to have the latest code committed to its branch.
1014
"""Update a tree to have the latest code committed to its branch.
1425
1016
This will perform a merge into the working tree, and may generate
1426
conflicts. If you have any local changes, you will still
1017
conflicts. If you have any local changes, you will still
1427
1018
need to commit them after the update for the update to be complete.
1429
If you want to discard your local changes, you can just do a
1020
If you want to discard your local changes, you can just do a
1430
1021
'bzr revert' instead of 'bzr commit' after the update.
1432
If you want to restore a file that has been removed locally, use
1433
'bzr revert' instead of 'bzr update'.
1435
If the tree's branch is bound to a master branch, it will also update
1436
the branch from the master.
1439
1024
_see_also = ['pull', 'working-trees', 'status-flags']
1440
1025
takes_args = ['dir?']
1441
takes_options = ['revision',
1443
help="Show base revision text in conflicts."),
1445
1026
aliases = ['up']
1447
def run(self, dir='.', revision=None, show_base=None):
1448
if revision is not None and len(revision) != 1:
1449
raise errors.BzrCommandError(
1450
"bzr update --revision takes exactly one revision")
1028
def run(self, dir='.'):
1451
1029
tree = WorkingTree.open_containing(dir)[0]
1452
branch = tree.branch
1453
1030
possible_transports = []
1454
master = branch.get_master_branch(
1031
master = tree.branch.get_master_branch(
1455
1032
possible_transports=possible_transports)
1456
1033
if master is not None:
1457
branch_location = master.base
1458
1034
tree.lock_write()
1460
branch_location = tree.branch.base
1461
1036
tree.lock_tree_write()
1462
self.add_cleanup(tree.unlock)
1463
# get rid of the final '/' and be ready for display
1464
branch_location = urlutils.unescape_for_display(
1465
branch_location.rstrip('/'),
1467
existing_pending_merges = tree.get_parent_ids()[1:]
1471
# may need to fetch data into a heavyweight checkout
1472
# XXX: this may take some time, maybe we should display a
1474
old_tip = branch.update(possible_transports)
1475
if revision is not None:
1476
revision_id = revision[0].as_revision_id(branch)
1478
revision_id = branch.last_revision()
1479
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1480
revno = branch.revision_id_to_dotted_revno(revision_id)
1481
note("Tree is up to date at revision %s of branch %s" %
1482
('.'.join(map(str, revno)), branch_location))
1484
view_info = _get_view_info_for_change_reporter(tree)
1485
change_reporter = delta._ChangeReporter(
1486
unversioned_filter=tree.is_ignored,
1487
view_info=view_info)
1038
existing_pending_merges = tree.get_parent_ids()[1:]
1039
last_rev = _mod_revision.ensure_null(tree.last_revision())
1040
if last_rev == _mod_revision.ensure_null(
1041
tree.branch.last_revision()):
1042
# may be up to date, check master too.
1043
if master is None or last_rev == _mod_revision.ensure_null(
1044
master.last_revision()):
1045
revno = tree.branch.revision_id_to_revno(last_rev)
1046
note("Tree is up to date at revision %d." % (revno,))
1489
1048
conflicts = tree.update(
1491
possible_transports=possible_transports,
1492
revision=revision_id,
1494
show_base=show_base)
1495
except errors.NoSuchRevision, e:
1496
raise errors.BzrCommandError(
1497
"branch has no revision %s\n"
1498
"bzr update --revision only works"
1499
" for a revision in the branch history"
1501
revno = tree.branch.revision_id_to_dotted_revno(
1502
_mod_revision.ensure_null(tree.last_revision()))
1503
note('Updated to revision %s of branch %s' %
1504
('.'.join(map(str, revno)), branch_location))
1505
parent_ids = tree.get_parent_ids()
1506
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1507
note('Your local commits will now show as pending merges with '
1508
"'bzr status', and can be committed with 'bzr commit'.")
1049
delta._ChangeReporter(unversioned_filter=tree.is_ignored),
1050
possible_transports=possible_transports)
1051
revno = tree.branch.revision_id_to_revno(
1052
_mod_revision.ensure_null(tree.last_revision()))
1053
note('Updated to revision %d.' % (revno,))
1054
if tree.get_parent_ids()[1:] != existing_pending_merges:
1055
note('Your local commits will now show as pending merges with '
1056
"'bzr status', and can be committed with 'bzr commit'.")
1515
1065
class cmd_info(Command):
1516
__doc__ = """Show information about a working tree, branch or repository.
1066
"""Show information about a working tree, branch or repository.
1518
1068
This command will show all known locations and formats associated to the
1519
tree, branch or repository.
1521
In verbose mode, statistical information is included with each report.
1522
To see extended statistic information, use a verbosity level of 2 or
1523
higher by specifying the verbose option multiple times, e.g. -vv.
1069
tree, branch or repository. Statistical information is included with
1525
1072
Branches and working trees will also report any missing revisions.
1529
Display information on the format and related locations:
1533
Display the above together with extended format information and
1534
basic statistics (like the number of files in the working tree and
1535
number of revisions in the branch and repository):
1539
Display the above together with number of committers to the branch:
1543
1074
_see_also = ['revno', 'working-trees', 'repositories']
1544
1075
takes_args = ['location?']
2174
1623
raise errors.BzrCommandError(msg)
2177
def _parse_levels(s):
2181
msg = "The levels argument must be an integer."
2182
raise errors.BzrCommandError(msg)
2185
1626
class cmd_log(Command):
2186
__doc__ = """Show historical log for a branch or subset of a branch.
2188
log is bzr's default tool for exploring the history of a branch.
2189
The branch to use is taken from the first parameter. If no parameters
2190
are given, the branch containing the working directory is logged.
2191
Here are some simple examples::
2193
bzr log log the current branch
2194
bzr log foo.py log a file in its branch
2195
bzr log http://server/branch log a branch on a server
2197
The filtering, ordering and information shown for each revision can
2198
be controlled as explained below. By default, all revisions are
2199
shown sorted (topologically) so that newer revisions appear before
2200
older ones and descendants always appear before ancestors. If displayed,
2201
merged revisions are shown indented under the revision in which they
2206
The log format controls how information about each revision is
2207
displayed. The standard log formats are called ``long``, ``short``
2208
and ``line``. The default is long. See ``bzr help log-formats``
2209
for more details on log formats.
2211
The following options can be used to control what information is
2214
-l N display a maximum of N revisions
2215
-n N display N levels of revisions (0 for all, 1 for collapsed)
2216
-v display a status summary (delta) for each revision
2217
-p display a diff (patch) for each revision
2218
--show-ids display revision-ids (and file-ids), not just revnos
2220
Note that the default number of levels to display is a function of the
2221
log format. If the -n option is not used, the standard log formats show
2222
just the top level (mainline).
2224
Status summaries are shown using status flags like A, M, etc. To see
2225
the changes explained using words like ``added`` and ``modified``
2226
instead, use the -vv option.
2230
To display revisions from oldest to newest, use the --forward option.
2231
In most cases, using this option will have little impact on the total
2232
time taken to produce a log, though --forward does not incrementally
2233
display revisions like --reverse does when it can.
2235
:Revision filtering:
2237
The -r option can be used to specify what revision or range of revisions
2238
to filter against. The various forms are shown below::
2240
-rX display revision X
2241
-rX.. display revision X and later
2242
-r..Y display up to and including revision Y
2243
-rX..Y display from X to Y inclusive
2245
See ``bzr help revisionspec`` for details on how to specify X and Y.
2246
Some common examples are given below::
2248
-r-1 show just the tip
2249
-r-10.. show the last 10 mainline revisions
2250
-rsubmit:.. show what's new on this branch
2251
-rancestor:path.. show changes since the common ancestor of this
2252
branch and the one at location path
2253
-rdate:yesterday.. show changes since yesterday
2255
When logging a range of revisions using -rX..Y, log starts at
2256
revision Y and searches back in history through the primary
2257
("left-hand") parents until it finds X. When logging just the
2258
top level (using -n1), an error is reported if X is not found
2259
along the way. If multi-level logging is used (-n0), X may be
2260
a nested merge revision and the log will be truncated accordingly.
2264
If parameters are given and the first one is not a branch, the log
2265
will be filtered to show only those revisions that changed the
2266
nominated files or directories.
2268
Filenames are interpreted within their historical context. To log a
2269
deleted file, specify a revision range so that the file existed at
2270
the end or start of the range.
2272
Historical context is also important when interpreting pathnames of
2273
renamed files/directories. Consider the following example:
2275
* revision 1: add tutorial.txt
2276
* revision 2: modify tutorial.txt
2277
* revision 3: rename tutorial.txt to guide.txt; add tutorial.txt
2281
* ``bzr log guide.txt`` will log the file added in revision 1
2283
* ``bzr log tutorial.txt`` will log the new file added in revision 3
2285
* ``bzr log -r2 -p tutorial.txt`` will show the changes made to
2286
the original file in revision 2.
2288
* ``bzr log -r2 -p guide.txt`` will display an error message as there
2289
was no file called guide.txt in revision 2.
2291
Renames are always followed by log. By design, there is no need to
2292
explicitly ask for this (and no way to stop logging a file back
2293
until it was last renamed).
2297
The --message option can be used for finding revisions that match a
2298
regular expression in a commit message.
2302
GUI tools and IDEs are often better at exploring history than command
2303
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2304
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2305
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2306
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2308
You may find it useful to add the aliases below to ``bazaar.conf``::
2312
top = log -l10 --line
2315
``bzr tip`` will then show the latest revision while ``bzr top``
2316
will show the last 10 mainline revisions. To see the details of a
2317
particular revision X, ``bzr show -rX``.
2319
If you are interested in looking deeper into a particular merge X,
2320
use ``bzr log -n0 -rX``.
2322
``bzr log -v`` on a branch with lots of history is currently
2323
very slow. A fix for this issue is currently under development.
2324
With or without that fix, it is recommended that a revision range
2325
be given when using the -v option.
2327
bzr has a generic full-text matching plugin, bzr-search, that can be
2328
used to find revisions matching user names, commit messages, etc.
2329
Among other features, this plugin can find all revisions containing
2330
a list of words but not others.
2332
When exploring non-mainline history on large projects with deep
2333
history, the performance of log can be greatly improved by installing
2334
the historycache plugin. This plugin buffers historical information
2335
trading disk space for faster speed.
1627
"""Show log of a branch, file, or directory.
1629
By default show the log of the branch containing the working directory.
1631
To request a range of logs, you can use the command -r begin..end
1632
-r revision requests a specific revision, -r ..end or -r begin.. are
1636
Log the current branch::
1644
Log the last 10 revisions of a branch::
1646
bzr log -r -10.. http://server/branch
2337
takes_args = ['file*']
2338
_see_also = ['log-formats', 'revisionspec']
1649
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1651
takes_args = ['location?']
2339
1652
takes_options = [
2340
1653
Option('forward',
2341
1654
help='Show from oldest to newest.'),
1657
help='Display timezone as local, original, or utc.'),
2343
1658
custom_help('verbose',
2344
1659
help='Show files changed in each revision.'),
2348
type=bzrlib.option._parse_revision_str,
2350
help='Show just the specified revision.'
2351
' See also "help revisionspec".'),
2353
RegistryOption('authors',
2354
'What names to list as authors - first, all or committer.',
2356
lazy_registry=('bzrlib.log', 'author_list_registry'),
2360
help='Number of levels to display - 0 for all, 1 for flat.',
2362
type=_parse_levels),
2363
1663
Option('message',
2364
1664
short_name='m',
2365
1665
help='Show revisions whose message matches this '
2366
1666
'regular expression.',
2368
1668
Option('limit',
2370
1669
help='Limit the output to the first N revisions.',
2372
1671
type=_parse_limit),
2375
help='Show changes made in each revision as a patch.'),
2376
Option('include-merges',
2377
help='Show merged revisions like --levels 0 does.'),
2378
Option('exclude-common-ancestry',
2379
help='Display only the revisions that are not part'
2380
' of both ancestries (require -rX..Y)'
2383
1673
encoding_type = 'replace'
2385
1675
@display_command
2386
def run(self, file_list=None, timezone='original',
1676
def run(self, location=None, timezone='original',
2388
1678
show_ids=False,
2392
1681
log_format=None,
2397
include_merges=False,
2399
exclude_common_ancestry=False,
2401
from bzrlib.log import (
2403
make_log_request_dict,
2404
_get_info_for_log_files,
1684
from bzrlib.log import show_log
1685
assert message is None or isinstance(message, basestring), \
1686
"invalid message argument %r" % message
2406
1687
direction = (forward and 'forward') or 'reverse'
2407
if (exclude_common_ancestry
2408
and (revision is None or len(revision) != 2)):
2409
raise errors.BzrCommandError(
2410
'--exclude-common-ancestry requires -r with two revisions')
2415
raise errors.BzrCommandError(
2416
'--levels and --include-merges are mutually exclusive')
2418
if change is not None:
2420
raise errors.RangeInChangeOption()
2421
if revision is not None:
2422
raise errors.BzrCommandError(
2423
'--revision and --change are mutually exclusive')
2428
filter_by_dir = False
2430
# find the file ids to log and check for directory filtering
2431
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2432
revision, file_list, self.add_cleanup)
2433
for relpath, file_id, kind in file_info_list:
1692
# find the file id to log:
1694
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1698
tree = b.basis_tree()
1699
file_id = tree.path2id(fp)
2434
1700
if file_id is None:
2435
1701
raise errors.BzrCommandError(
2436
"Path unknown at end or start of revision range: %s" %
2438
# If the relpath is the top of the tree, we log everything
2443
file_ids.append(file_id)
2444
filter_by_dir = filter_by_dir or (
2445
kind in ['directory', 'tree-reference'])
1702
"Path does not have any revision history: %s" %
2448
# FIXME ? log the current subdir only RBC 20060203
1706
# FIXME ? log the current subdir only RBC 20060203
2449
1707
if revision is not None \
2450
1708
and len(revision) > 0 and revision[0].get_branch():
2451
1709
location = revision[0].get_branch()
2454
1712
dir, relpath = bzrdir.BzrDir.open_containing(location)
2455
1713
b = dir.open_branch()
2456
self.add_cleanup(b.lock_read().unlock)
2457
rev1, rev2 = _get_revision_range(revision, b, self.name())
2459
# Decide on the type of delta & diff filtering to use
2460
# TODO: add an --all-files option to make this configurable & consistent
2468
diff_type = 'partial'
2472
# Build the log formatter
2473
if log_format is None:
2474
log_format = log.log_formatter_registry.get_default(b)
2475
# Make a non-encoding output to include the diffs - bug 328007
2476
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2477
lf = log_format(show_ids=show_ids, to_file=self.outf,
2478
to_exact_file=unencoded_output,
2479
show_timezone=timezone,
2480
delta_format=get_verbosity_level(),
2482
show_advice=levels is None,
2483
author_list_handler=authors)
2485
# Choose the algorithm for doing the logging. It's annoying
2486
# having multiple code paths like this but necessary until
2487
# the underlying repository format is faster at generating
2488
# deltas or can provide everything we need from the indices.
2489
# The default algorithm - match-using-deltas - works for
2490
# multiple files and directories and is faster for small
2491
# amounts of history (200 revisions say). However, it's too
2492
# slow for logging a single file in a repository with deep
2493
# history, i.e. > 10K revisions. In the spirit of "do no
2494
# evil when adding features", we continue to use the
2495
# original algorithm - per-file-graph - for the "single
2496
# file that isn't a directory without showing a delta" case.
2497
partial_history = revision and b.repository._format.supports_chks
2498
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2499
or delta_type or partial_history)
2501
# Build the LogRequest and execute it
2502
if len(file_ids) == 0:
2504
rqst = make_log_request_dict(
2505
direction=direction, specific_fileids=file_ids,
2506
start_revision=rev1, end_revision=rev2, limit=limit,
2507
message_search=message, delta_type=delta_type,
2508
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2509
exclude_common_ancestry=exclude_common_ancestry,
2511
Logger(b, rqst).show(lf)
2514
def _get_revision_range(revisionspec_list, branch, command_name):
2515
"""Take the input of a revision option and turn it into a revision range.
2517
It returns RevisionInfo objects which can be used to obtain the rev_id's
2518
of the desired revisions. It does some user input validations.
2520
if revisionspec_list is None:
2523
elif len(revisionspec_list) == 1:
2524
rev1 = rev2 = revisionspec_list[0].in_history(branch)
2525
elif len(revisionspec_list) == 2:
2526
start_spec = revisionspec_list[0]
2527
end_spec = revisionspec_list[1]
2528
if end_spec.get_branch() != start_spec.get_branch():
2529
# b is taken from revision[0].get_branch(), and
2530
# show_log will use its revision_history. Having
2531
# different branches will lead to weird behaviors.
2532
raise errors.BzrCommandError(
2533
"bzr %s doesn't accept two revisions in different"
2534
" branches." % command_name)
2535
if start_spec.spec is None:
2536
# Avoid loading all the history.
2537
rev1 = RevisionInfo(branch, None, None)
2539
rev1 = start_spec.in_history(branch)
2540
# Avoid loading all of history when we know a missing
2541
# end of range means the last revision ...
2542
if end_spec.spec is None:
2543
last_revno, last_revision_id = branch.last_revision_info()
2544
rev2 = RevisionInfo(branch, last_revno, last_revision_id)
2546
rev2 = end_spec.in_history(branch)
2548
raise errors.BzrCommandError(
2549
'bzr %s --revision takes one or two values.' % command_name)
2553
def _revision_range_to_revid_range(revision_range):
2556
if revision_range[0] is not None:
2557
rev_id1 = revision_range[0].rev_id
2558
if revision_range[1] is not None:
2559
rev_id2 = revision_range[1].rev_id
2560
return rev_id1, rev_id2
1717
if revision is None:
1720
elif len(revision) == 1:
1721
rev1 = rev2 = revision[0].in_history(b)
1722
elif len(revision) == 2:
1723
if revision[1].get_branch() != revision[0].get_branch():
1724
# b is taken from revision[0].get_branch(), and
1725
# show_log will use its revision_history. Having
1726
# different branches will lead to weird behaviors.
1727
raise errors.BzrCommandError(
1728
"Log doesn't accept two revisions in different"
1730
rev1 = revision[0].in_history(b)
1731
rev2 = revision[1].in_history(b)
1733
raise errors.BzrCommandError(
1734
'bzr log --revision takes one or two values.')
1736
if log_format is None:
1737
log_format = log.log_formatter_registry.get_default(b)
1739
lf = log_format(show_ids=show_ids, to_file=self.outf,
1740
show_timezone=timezone)
1746
direction=direction,
1747
start_revision=rev1,
2562
1755
def get_log_format(long=False, short=False, line=False, default='long'):
2563
1756
log_format = default
2634
1824
if path is None:
2638
1829
raise errors.BzrCommandError('cannot specify both --from-root'
2641
tree, branch, relpath = \
2642
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2644
# Calculate the prefix to use
1833
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2648
prefix = relpath + '/'
2649
elif fs_path != '.' and not fs_path.endswith('/'):
2650
prefix = fs_path + '/'
2652
if revision is not None or tree is None:
2653
tree = _get_one_revision_tree('ls', revision, branch=branch)
2656
if isinstance(tree, WorkingTree) and tree.supports_views():
2657
view_files = tree.views.lookup_view()
2660
view_str = views.view_display_str(view_files)
2661
note("Ignoring files outside view. View is %s" % view_str)
2663
self.add_cleanup(tree.lock_read().unlock)
2664
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2665
from_dir=relpath, recursive=recursive):
2666
# Apply additional masking
2667
if not all and not selection[fc]:
2669
if kind is not None and fkind != kind:
2674
fullpath = osutils.pathjoin(relpath, fp)
2677
views.check_path_in_view(tree, fullpath)
2678
except errors.FileOutsideView:
2683
fp = osutils.pathjoin(prefix, fp)
2684
kindch = entry.kind_character()
2685
outstring = fp + kindch
2686
ui.ui_factory.clear_term()
2688
outstring = '%-8s %s' % (fc, outstring)
2689
if show_ids and fid is not None:
2690
outstring = "%-50s %s" % (outstring, fid)
2691
self.outf.write(outstring + '\n')
2693
self.outf.write(fp + '\0')
2696
self.outf.write(fid)
2697
self.outf.write('\0')
2705
self.outf.write('%-50s %s\n' % (outstring, my_id))
2707
self.outf.write(outstring + '\n')
1839
if revision is not None:
1840
tree = branch.repository.revision_tree(
1841
revision[0].in_history(branch).rev_id)
1843
tree = branch.basis_tree()
1847
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1848
if fp.startswith(relpath):
1849
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1850
if non_recursive and '/' in fp:
1852
if not all and not selection[fc]:
1854
if kind is not None and fkind != kind:
1857
kindch = entry.kind_character()
1858
outstring = '%-8s %s%s' % (fc, fp, kindch)
1859
if show_ids and fid is not None:
1860
outstring = "%-50s %s" % (outstring, fid)
1861
self.outf.write(outstring + '\n')
1863
self.outf.write(fp + '\0')
1866
self.outf.write(fid)
1867
self.outf.write('\0')
1875
self.outf.write('%-50s %s\n' % (fp, my_id))
1877
self.outf.write(fp + '\n')
2710
1882
class cmd_unknowns(Command):
2711
__doc__ = """List unknown files.
1883
"""List unknown files.
2715
1887
_see_also = ['ls']
2716
takes_options = ['directory']
2718
1889
@display_command
2719
def run(self, directory=u'.'):
2720
for f in WorkingTree.open_containing(directory)[0].unknowns():
1891
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2721
1892
self.outf.write(osutils.quotefn(f) + '\n')
2724
1895
class cmd_ignore(Command):
2725
__doc__ = """Ignore specified files or patterns.
2727
See ``bzr help patterns`` for details on the syntax of patterns.
2729
If a .bzrignore file does not exist, the ignore command
2730
will create one and add the specified files or patterns to the newly
2731
created file. The ignore command will also automatically add the
2732
.bzrignore file to be versioned. Creating a .bzrignore file without
2733
the use of the ignore command will require an explicit add command.
1896
"""Ignore specified files or patterns.
2735
1898
To remove patterns from the ignore list, edit the .bzrignore file.
2736
After adding, editing or deleting that file either indirectly by
2737
using this command or directly by using an editor, be sure to commit
2740
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2741
the global ignore file can be found in the application data directory as
2742
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2743
Global ignores are not touched by this command. The global ignore file
2744
can be edited directly using an editor.
2746
Patterns prefixed with '!' are exceptions to ignore patterns and take
2747
precedence over regular ignores. Such exceptions are used to specify
2748
files that should be versioned which would otherwise be ignored.
2750
Patterns prefixed with '!!' act as regular ignore patterns, but have
2751
precedence over the '!' exception patterns.
2755
* Ignore patterns containing shell wildcards must be quoted from
2758
* Ignore patterns starting with "#" act as comments in the ignore file.
2759
To ignore patterns that begin with that character, use the "RE:" prefix.
1900
Trailing slashes on patterns are ignored.
1901
If the pattern contains a slash or is a regular expression, it is compared
1902
to the whole path from the branch root. Otherwise, it is compared to only
1903
the last component of the path. To match a file only in the root
1904
directory, prepend './'.
1906
Ignore patterns specifying absolute paths are not allowed.
1908
Ignore patterns may include globbing wildcards such as::
1910
? - Matches any single character except '/'
1911
* - Matches 0 or more characters except '/'
1912
/**/ - Matches 0 or more directories in a path
1913
[a-z] - Matches a single character from within a group of characters
1915
Ignore patterns may also be Python regular expressions.
1916
Regular expression ignore patterns are identified by a 'RE:' prefix
1917
followed by the regular expression. Regular expression ignore patterns
1918
may not include named or numbered groups.
1920
Note: ignore patterns containing shell wildcards must be quoted from
2762
1924
Ignore the top level Makefile::
2764
1926
bzr ignore ./Makefile
2766
Ignore .class files in all directories...::
1928
Ignore class files in all directories::
2768
1930
bzr ignore "*.class"
2770
...but do not ignore "special.class"::
2772
bzr ignore "!special.class"
2774
Ignore files whose name begins with the "#" character::
2778
1932
Ignore .o files under the lib directory::
2780
1934
bzr ignore "lib/**/*.o"
2782
1936
Ignore .o files under the lib directory::
2784
1938
bzr ignore "RE:lib/.*\.o"
2786
Ignore everything but the "debian" toplevel directory::
2788
bzr ignore "RE:(?!debian/).*"
2790
Ignore everything except the "local" toplevel directory,
2791
but always ignore "*~" autosave files, even under local/::
2794
bzr ignore "!./local"
2798
_see_also = ['status', 'ignored', 'patterns']
1941
_see_also = ['status', 'ignored']
2799
1942
takes_args = ['name_pattern*']
2800
takes_options = ['directory',
2801
Option('default-rules',
2802
help='Display the default ignore rules that bzr uses.')
1944
Option('old-default-rules',
1945
help='Write out the ignore rules bzr < 0.9 always used.')
2805
def run(self, name_pattern_list=None, default_rules=None,
2807
from bzrlib import ignores
2808
if default_rules is not None:
2809
# dump the default rules and exit
2810
for pattern in ignores.USER_DEFAULTS:
2811
self.outf.write("%s\n" % pattern)
1948
def run(self, name_pattern_list=None, old_default_rules=None):
1949
from bzrlib.atomicfile import AtomicFile
1950
if old_default_rules is not None:
1951
# dump the rules and exit
1952
for pattern in ignores.OLD_DEFAULTS:
2813
1955
if not name_pattern_list:
2814
1956
raise errors.BzrCommandError("ignore requires at least one "
2815
"NAME_PATTERN or --default-rules.")
2816
name_pattern_list = [globbing.normalize_pattern(p)
1957
"NAME_PATTERN or --old-default-rules")
1958
name_pattern_list = [globbing.normalize_pattern(p)
2817
1959
for p in name_pattern_list]
2819
for p in name_pattern_list:
2820
if not globbing.Globster.is_pattern_valid(p):
2821
bad_patterns += ('\n %s' % p)
2823
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2824
ui.ui_factory.show_error(msg)
2825
raise errors.InvalidPattern('')
2826
1960
for name_pattern in name_pattern_list:
2827
if (name_pattern[0] == '/' or
1961
if (name_pattern[0] == '/' or
2828
1962
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2829
1963
raise errors.BzrCommandError(
2830
1964
"NAME_PATTERN should not be an absolute path")
2831
tree, relpath = WorkingTree.open_containing(directory)
2832
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
1965
tree, relpath = WorkingTree.open_containing(u'.')
1966
ifn = tree.abspath('.bzrignore')
1967
if os.path.exists(ifn):
1970
igns = f.read().decode('utf-8')
1976
# TODO: If the file already uses crlf-style termination, maybe
1977
# we should use that for the newly added lines?
1979
if igns and igns[-1] != '\n':
1981
for name_pattern in name_pattern_list:
1982
igns += name_pattern + '\n'
1984
f = AtomicFile(ifn, 'wb')
1986
f.write(igns.encode('utf-8'))
1991
if not tree.path2id('.bzrignore'):
1992
tree.add(['.bzrignore'])
2833
1994
ignored = globbing.Globster(name_pattern_list)
2835
self.add_cleanup(tree.lock_read().unlock)
2836
1997
for entry in tree.list_files():
2838
1999
if id is not None:
2839
2000
filename = entry[0]
2840
2001
if ignored.match(filename):
2841
matches.append(filename)
2002
matches.append(filename.encode('utf-8'))
2842
2004
if len(matches) > 0:
2843
self.outf.write("Warning: the following files are version controlled and"
2844
" match your ignore pattern:\n%s"
2845
"\nThese files will continue to be version controlled"
2846
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2005
print "Warning: the following files are version controlled and" \
2006
" match your ignore pattern:\n%s" % ("\n".join(matches),)
2849
2008
class cmd_ignored(Command):
2850
__doc__ = """List ignored files and the patterns that matched them.
2852
List all the ignored files and the ignore pattern that caused the file to
2855
Alternatively, to list just the files::
2009
"""List ignored files and the patterns that matched them.
2860
encoding_type = 'replace'
2861
_see_also = ['ignore', 'ls']
2862
takes_options = ['directory']
2012
_see_also = ['ignore']
2864
2013
@display_command
2865
def run(self, directory=u'.'):
2866
tree = WorkingTree.open_containing(directory)[0]
2867
self.add_cleanup(tree.lock_read().unlock)
2868
for path, file_class, kind, file_id, entry in tree.list_files():
2869
if file_class != 'I':
2871
## XXX: Slightly inefficient since this was already calculated
2872
pat = tree.is_ignored(path)
2873
self.outf.write('%-50s %s\n' % (path, pat))
2015
tree = WorkingTree.open_containing(u'.')[0]
2018
for path, file_class, kind, file_id, entry in tree.list_files():
2019
if file_class != 'I':
2021
## XXX: Slightly inefficient since this was already calculated
2022
pat = tree.is_ignored(path)
2023
print '%-50s %s' % (path, pat)
2876
2028
class cmd_lookup_revision(Command):
2877
__doc__ = """Lookup the revision-id from a revision-number
2029
"""Lookup the revision-id from a revision-number
2880
2032
bzr lookup-revision 33
2883
2035
takes_args = ['revno']
2884
takes_options = ['directory']
2886
2037
@display_command
2887
def run(self, revno, directory=u'.'):
2038
def run(self, revno):
2889
2040
revno = int(revno)
2890
2041
except ValueError:
2891
raise errors.BzrCommandError("not a valid revision-number: %r"
2893
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2894
self.outf.write("%s\n" % revid)
2042
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2044
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2897
2047
class cmd_export(Command):
2898
__doc__ = """Export current or past revision to a destination directory or archive.
2048
"""Export current or past revision to a destination directory or archive.
2900
2050
If no revision is specified this exports the last committed revision.
2923
2073
================= =========================
2925
takes_args = ['dest', 'branch_or_subdir?']
2926
takes_options = ['directory',
2075
takes_args = ['dest', 'branch?']
2927
2077
Option('format',
2928
2078
help="Type of file to export to.",
2931
Option('filters', help='Apply content filters to export the '
2932
'convenient form.'),
2935
2083
help="Name of the root directory inside the exported file."),
2936
Option('per-file-timestamps',
2937
help='Set modification time of files to that of the last '
2938
'revision in which it was changed.'),
2940
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2941
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2085
def run(self, dest, branch=None, revision=None, format=None, root=None):
2942
2086
from bzrlib.export import export
2944
if branch_or_subdir is None:
2945
tree = WorkingTree.open_containing(directory)[0]
2089
tree = WorkingTree.open_containing(u'.')[0]
2946
2090
b = tree.branch
2949
b, subdir = Branch.open_containing(branch_or_subdir)
2952
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2092
b = Branch.open(branch)
2094
if revision is None:
2095
# should be tree.last_revision FIXME
2096
rev_id = b.last_revision()
2098
if len(revision) != 1:
2099
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
2100
rev_id = revision[0].in_history(b).rev_id
2101
t = b.repository.revision_tree(rev_id)
2954
export(rev_tree, dest, format, root, subdir, filtered=filters,
2955
per_file_timestamps=per_file_timestamps)
2103
export(t, dest, format, root)
2956
2104
except errors.NoSuchExportFormat, e:
2957
2105
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2960
2108
class cmd_cat(Command):
2961
__doc__ = """Write the contents of a file as of a given revision to standard output.
2109
"""Write the contents of a file as of a given revision to standard output.
2963
2111
If no revision is nominated, the last revision is used.
2965
2113
Note: Take care to redirect standard output when using this command on a
2969
2117
_see_also = ['ls']
2970
takes_options = ['directory',
2971
2119
Option('name-from-revision', help='The path name in the old tree.'),
2972
Option('filters', help='Apply content filters to display the '
2973
'convenience form.'),
2976
2122
takes_args = ['filename']
2977
2123
encoding_type = 'exact'
2979
2125
@display_command
2980
def run(self, filename, revision=None, name_from_revision=False,
2981
filters=False, directory=None):
2126
def run(self, filename, revision=None, name_from_revision=False):
2982
2127
if revision is not None and len(revision) != 1:
2983
2128
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2984
2129
" one revision specifier")
2985
2130
tree, branch, relpath = \
2986
_open_directory_or_containing_tree_or_branch(filename, directory)
2987
self.add_cleanup(branch.lock_read().unlock)
2988
return self._run(tree, branch, relpath, filename, revision,
2989
name_from_revision, filters)
2131
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2134
return self._run(tree, branch, relpath, filename, revision,
2991
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2139
def _run(self, tree, b, relpath, filename, revision, name_from_revision):
2993
2140
if tree is None:
2994
2141
tree = b.basis_tree()
2995
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2996
self.add_cleanup(rev_tree.lock_read().unlock)
2142
if revision is None:
2143
revision_id = b.last_revision()
2145
revision_id = revision[0].in_history(b).rev_id
2147
cur_file_id = tree.path2id(relpath)
2148
rev_tree = b.repository.revision_tree(revision_id)
2998
2149
old_file_id = rev_tree.path2id(relpath)
3000
2151
if name_from_revision:
3001
# Try in revision if requested
3002
2152
if old_file_id is None:
3003
raise errors.BzrCommandError(
3004
"%r is not present in revision %s" % (
3005
filename, rev_tree.get_revision_id()))
2153
raise errors.BzrCommandError("%r is not present in revision %s"
2154
% (filename, revision_id))
3007
content = rev_tree.get_file_text(old_file_id)
3009
cur_file_id = tree.path2id(relpath)
3011
if cur_file_id is not None:
3012
# Then try with the actual file id
3014
content = rev_tree.get_file_text(cur_file_id)
3016
except errors.NoSuchId:
3017
# The actual file id didn't exist at that time
3019
if not found and old_file_id is not None:
3020
# Finally try with the old file id
3021
content = rev_tree.get_file_text(old_file_id)
3024
# Can't be found anywhere
3025
raise errors.BzrCommandError(
3026
"%r is not present in revision %s" % (
3027
filename, rev_tree.get_revision_id()))
3029
from bzrlib.filters import (
3030
ContentFilterContext,
3031
filtered_output_bytes,
3033
filters = rev_tree._content_filter_stack(relpath)
3034
chunks = content.splitlines(True)
3035
content = filtered_output_bytes(chunks, filters,
3036
ContentFilterContext(relpath, rev_tree))
3038
self.outf.writelines(content)
3041
self.outf.write(content)
2156
rev_tree.print_file(old_file_id)
2157
elif cur_file_id is not None:
2158
rev_tree.print_file(cur_file_id)
2159
elif old_file_id is not None:
2160
rev_tree.print_file(old_file_id)
2162
raise errors.BzrCommandError("%r is not present in revision %s" %
2163
(filename, revision_id))
3044
2166
class cmd_local_time_offset(Command):
3045
__doc__ = """Show the offset in seconds from GMT to local time."""
2167
"""Show the offset in seconds from GMT to local time."""
3047
2169
@display_command
3049
self.outf.write("%s\n" % osutils.local_time_offset())
2171
print osutils.local_time_offset()
3053
2175
class cmd_commit(Command):
3054
__doc__ = """Commit changes into a new revision.
3056
An explanatory message needs to be given for each commit. This is
3057
often done by using the --message option (getting the message from the
3058
command line) or by using the --file option (getting the message from
3059
a file). If neither of these options is given, an editor is opened for
3060
the user to enter the message. To see the changed files in the
3061
boilerplate text loaded into the editor, use the --show-diff option.
3063
By default, the entire tree is committed and the person doing the
3064
commit is assumed to be the author. These defaults can be overridden
3069
If selected files are specified, only changes to those files are
3070
committed. If a directory is specified then the directory and
3071
everything within it is committed.
3073
When excludes are given, they take precedence over selected files.
3074
For example, to commit only changes within foo, but not changes
3077
bzr commit foo -x foo/bar
3079
A selective commit after a merge is not yet supported.
3083
If the author of the change is not the same person as the committer,
3084
you can specify the author's name using the --author option. The
3085
name should be in the same format as a committer-id, e.g.
3086
"John Doe <jdoe@example.com>". If there is more than one author of
3087
the change you can specify the option multiple times, once for each
3092
A common mistake is to forget to add a new file or directory before
3093
running the commit command. The --strict option checks for unknown
3094
files and aborts the commit if any are found. More advanced pre-commit
3095
checks can be implemented by defining hooks. See ``bzr help hooks``
3100
If you accidentially commit the wrong changes or make a spelling
3101
mistake in the commit message say, you can use the uncommit command
3102
to undo it. See ``bzr help uncommit`` for details.
3104
Hooks can also be configured to run after a commit. This allows you
3105
to trigger updates to external systems like bug trackers. The --fixes
3106
option can be used to record the association between a revision and
3107
one or more bugs. See ``bzr help bugs`` for details.
3109
A selective commit may fail in some cases where the committed
3110
tree would be invalid. Consider::
3115
bzr commit foo -m "committing foo"
3116
bzr mv foo/bar foo/baz
3119
bzr commit foo/bar -m "committing bar but not baz"
3121
In the example above, the last commit will fail by design. This gives
3122
the user the opportunity to decide whether they want to commit the
3123
rename at the same time, separately first, or not at all. (As a general
3124
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2176
"""Commit changes into a new revision.
2178
If no arguments are given, the entire tree is committed.
2180
If selected files are specified, only changes to those files are
2181
committed. If a directory is specified then the directory and everything
2182
within it is committed.
2184
If author of the change is not the same person as the committer, you can
2185
specify the author's name using the --author option. The name should be
2186
in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
2188
A selected-file commit may fail in some cases where the committed
2189
tree would be invalid. Consider::
2194
bzr commit foo -m "committing foo"
2195
bzr mv foo/bar foo/baz
2198
bzr commit foo/bar -m "committing bar but not baz"
2200
In the example above, the last commit will fail by design. This gives
2201
the user the opportunity to decide whether they want to commit the
2202
rename at the same time, separately first, or not at all. (As a general
2203
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2205
Note: A selected-file commit after a merge is not yet supported.
3126
2207
# TODO: Run hooks on tree to-be-committed, and after commit.
3312
2345
raise errors.BzrCommandError("Commit refused because there are"
3313
2346
" unknown files in the working tree.")
3314
2347
except errors.BoundBranchOutOfDate, e:
3315
e.extra_help = ("\n"
3316
'To commit to master branch, run update and then commit.\n'
3317
'You can also pass --local to commit to continue working '
2348
raise errors.BzrCommandError(str(e) + "\n"
2349
'To commit to master branch, run update and then commit.\n'
2350
'You can also pass --local to commit to continue working '
3322
2354
class cmd_check(Command):
3323
__doc__ = """Validate working tree structure, branch consistency and repository history.
3325
This command checks various invariants about branch and repository storage
3326
to detect data corruption or bzr bugs.
3328
The working tree and branch checks will only give output if a problem is
3329
detected. The output fields of the repository check are:
3332
This is just the number of revisions checked. It doesn't
3336
This is just the number of versionedfiles checked. It
3337
doesn't indicate a problem.
3339
unreferenced ancestors
3340
Texts that are ancestors of other texts, but
3341
are not properly referenced by the revision ancestry. This is a
3342
subtle problem that Bazaar can work around.
3345
This is the total number of unique file contents
3346
seen in the checked revisions. It does not indicate a problem.
3349
This is the total number of repeated texts seen
3350
in the checked revisions. Texts can be repeated when their file
3351
entries are modified, but the file contents are not. It does not
3354
If no restrictions are specified, all Bazaar data that is found at the given
3355
location will be checked.
3359
Check the tree and branch at 'foo'::
3361
bzr check --tree --branch foo
3363
Check only the repository at 'bar'::
3365
bzr check --repo bar
3367
Check everything at 'baz'::
2355
"""Validate consistency of branch history.
2357
This command checks various invariants about the branch storage to
2358
detect data corruption or bzr bugs.
2362
revisions: This is just the number of revisions checked. It doesn't
2364
versionedfiles: This is just the number of versionedfiles checked. It
2365
doesn't indicate a problem.
2366
unreferenced ancestors: Texts that are ancestors of other texts, but
2367
are not properly referenced by the revision ancestry. This is a
2368
subtle problem that Bazaar can work around.
2369
unique file texts: This is the total number of unique file contents
2370
seen in the checked revisions. It does not indicate a problem.
2371
repeated file texts: This is the total number of repeated texts seen
2372
in the checked revisions. Texts can be repeated when their file
2373
entries are modified, but the file contents are not. It does not
3372
2377
_see_also = ['reconcile']
3373
takes_args = ['path?']
3374
takes_options = ['verbose',
3375
Option('branch', help="Check the branch related to the"
3376
" current directory."),
3377
Option('repo', help="Check the repository related to the"
3378
" current directory."),
3379
Option('tree', help="Check the working tree related to"
3380
" the current directory.")]
2378
takes_args = ['branch?']
2379
takes_options = ['verbose']
3382
def run(self, path=None, verbose=False, branch=False, repo=False,
3384
from bzrlib.check import check_dwim
3387
if not branch and not repo and not tree:
3388
branch = repo = tree = True
3389
check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
2381
def run(self, branch=None, verbose=False):
2382
from bzrlib.check import check
2384
branch_obj = Branch.open_containing('.')[0]
2386
branch_obj = Branch.open(branch)
2387
check(branch_obj, verbose)
2388
# bit hacky, check the tree parent is accurate
2391
tree = WorkingTree.open_containing('.')[0]
2393
tree = WorkingTree.open(branch)
2394
except (errors.NoWorkingTree, errors.NotLocalUrl):
2397
# This is a primitive 'check' for tree state. Currently this is not
2398
# integrated into the main check logic as yet.
2401
tree_basis = tree.basis_tree()
2402
tree_basis.lock_read()
2404
repo_basis = tree.branch.repository.revision_tree(
2405
tree.last_revision())
2406
if len(list(repo_basis._iter_changes(tree_basis))):
2407
raise errors.BzrCheckError(
2408
"Mismatched basis inventory content.")
3392
2416
class cmd_upgrade(Command):
3393
__doc__ = """Upgrade a repository, branch or working tree to a newer format.
3395
When the default format has changed after a major new release of
3396
Bazaar, you may be informed during certain operations that you
3397
should upgrade. Upgrading to a newer format may improve performance
3398
or make new features available. It may however limit interoperability
3399
with older repositories or with older versions of Bazaar.
3401
If you wish to upgrade to a particular format rather than the
3402
current default, that can be specified using the --format option.
3403
As a consequence, you can use the upgrade command this way to
3404
"downgrade" to an earlier format, though some conversions are
3405
a one way process (e.g. changing from the 1.x default to the
3406
2.x default) so downgrading is not always possible.
3408
A backup.bzr.~#~ directory is created at the start of the conversion
3409
process (where # is a number). By default, this is left there on
3410
completion. If the conversion fails, delete the new .bzr directory
3411
and rename this one back in its place. Use the --clean option to ask
3412
for the backup.bzr directory to be removed on successful conversion.
3413
Alternatively, you can delete it by hand if everything looks good
3416
If the location given is a shared repository, dependent branches
3417
are also converted provided the repository converts successfully.
3418
If the conversion of a branch fails, remaining branches are still
3421
For more information on upgrades, see the Bazaar Upgrade Guide,
3422
http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
2417
"""Upgrade branch storage to current format.
2419
The check command or bzr developers may sometimes advise you to run
2420
this command. When the default format has changed you may also be warned
2421
during other operations to upgrade.
3425
_see_also = ['check', 'reconcile', 'formats']
2424
_see_also = ['check']
3426
2425
takes_args = ['url?']
3427
2426
takes_options = [
3428
RegistryOption('format',
3429
help='Upgrade to a specific format. See "bzr help'
3430
' formats" for details.',
3431
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3432
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3433
value_switches=True, title='Branch format'),
3435
help='Remove the backup.bzr directory if successful.'),
3437
help="Show what would be done, but don't actually do anything."),
2427
RegistryOption('format',
2428
help='Upgrade to a specific format. See "bzr help'
2429
' formats" for details.',
2430
registry=bzrdir.format_registry,
2431
converter=bzrdir.format_registry.make_bzrdir,
2432
value_switches=True, title='Branch format'),
3440
def run(self, url='.', format=None, clean=False, dry_run=False):
2435
def run(self, url='.', format=None):
3441
2436
from bzrlib.upgrade import upgrade
3442
exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3444
if len(exceptions) == 1:
3445
# Compatibility with historical behavior
2438
format = bzrdir.format_registry.make_bzrdir('default')
2439
upgrade(url, format)
3451
2442
class cmd_whoami(Command):
3452
__doc__ = """Show or set bzr user id.
2443
"""Show or set bzr user id.
3455
2446
Show the email of the current user::
3707
2602
short_name='x',
3708
2603
help='Exclude tests that match this regular'
3709
2604
' expression.'),
3711
help='Output test progress via subunit.'),
3712
2605
Option('strict', help='Fail on missing dependencies or '
3713
2606
'known failures.'),
3714
Option('load-list', type=str, argname='TESTLISTFILE',
3715
help='Load a test id list from a text file.'),
3716
ListOption('debugflag', type=str, short_name='E',
3717
help='Turn on a selftest debug flag.'),
3718
ListOption('starting-with', type=str, argname='TESTID',
3719
param_name='starting_with', short_name='s',
3721
'Load only the tests starting with TESTID.'),
2607
Option('coverage', type=str, argname="DIRECTORY",
2608
help='Generate line coverage report in this '
3723
2611
encoding_type = 'replace'
3726
Command.__init__(self)
3727
self.additional_selftest_args = {}
3729
2613
def run(self, testspecs_list=None, verbose=False, one=False,
3730
2614
transport=None, benchmark=None,
2615
lsprof_timed=None, cache_dir=None,
3732
2616
first=False, list_only=False,
3733
randomize=None, exclude=None, strict=False,
3734
load_list=None, debugflag=None, starting_with=None, subunit=False,
3735
parallel=None, lsprof_tests=False):
3736
from bzrlib import tests
2617
randomize=None, exclude=None, strict=False, coverage=None):
2619
from bzrlib.tests import selftest
2620
import bzrlib.benchmarks as benchmarks
2621
from bzrlib.benchmarks import tree_creator
2623
if cache_dir is not None:
2624
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2626
print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
2627
print ' %s (%s python%s)' % (
2629
bzrlib.version_string,
2630
'.'.join(map(str, sys.version_info)),
3738
2633
if testspecs_list is not None:
3739
2634
pattern = '|'.join(testspecs_list)
3744
from bzrlib.tests import SubUnitBzrRunner
3746
raise errors.BzrCommandError("subunit not available. subunit "
3747
"needs to be installed to use --subunit.")
3748
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3749
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3750
# stdout, which would corrupt the subunit stream.
3751
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3752
# following code can be deleted when it's sufficiently deployed
3753
# -- vila/mgz 20100514
3754
if (sys.platform == "win32"
3755
and getattr(sys.stdout, 'fileno', None) is not None):
3757
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3759
self.additional_selftest_args.setdefault(
3760
'suite_decorators', []).append(parallel)
3762
raise errors.BzrCommandError(
3763
"--benchmark is no longer supported from bzr 2.2; "
3764
"use bzr-usertest instead")
3765
test_suite_factory = None
3766
selftest_kwargs = {"verbose": verbose,
3768
"stop_on_failure": one,
3769
"transport": transport,
3770
"test_suite_factory": test_suite_factory,
3771
"lsprof_timed": lsprof_timed,
3772
"lsprof_tests": lsprof_tests,
3773
"matching_tests_first": first,
3774
"list_only": list_only,
3775
"random_seed": randomize,
3776
"exclude_pattern": exclude,
3778
"load_list": load_list,
3779
"debug_flags": debugflag,
3780
"starting_with": starting_with
3782
selftest_kwargs.update(self.additional_selftest_args)
3784
# Make deprecation warnings visible, unless -Werror is set
3785
cleanup = symbol_versioning.activate_deprecation_warnings(
2638
test_suite_factory = benchmarks.test_suite
2639
# Unless user explicitly asks for quiet, be verbose in benchmarks
2640
verbose = not is_quiet()
2641
# TODO: should possibly lock the history file...
2642
benchfile = open(".perf_history", "at", buffering=1)
2644
test_suite_factory = None
3788
result = tests.selftest(**selftest_kwargs)
2647
result = selftest(verbose=verbose,
2649
stop_on_failure=one,
2650
transport=transport,
2651
test_suite_factory=test_suite_factory,
2652
lsprof_timed=lsprof_timed,
2653
bench_history=benchfile,
2654
matching_tests_first=first,
2655
list_only=list_only,
2656
random_seed=randomize,
2657
exclude_pattern=exclude,
2659
coverage_dir=coverage,
2662
if benchfile is not None:
2665
info('tests passed')
2667
info('tests failed')
3791
2668
return int(not result)
3794
2671
class cmd_version(Command):
3795
__doc__ = """Show version of bzr."""
2672
"""Show version of bzr."""
3797
2674
encoding_type = 'replace'
3799
Option("short", help="Print just the version number."),
3802
2676
@display_command
3803
def run(self, short=False):
3804
2678
from bzrlib.version import show_version
3806
self.outf.write(bzrlib.version_string + '\n')
3808
show_version(to_file=self.outf)
2679
show_version(to_file=self.outf)
3811
2682
class cmd_rocks(Command):
3812
__doc__ = """Statement of optimism."""
2683
"""Statement of optimism."""
3816
2687
@display_command
3818
self.outf.write("It sure does!\n")
2689
print "It sure does!"
3821
2692
class cmd_find_merge_base(Command):
3822
__doc__ = """Find and print a base revision for merging two branches."""
2693
"""Find and print a base revision for merging two branches."""
3823
2694
# TODO: Options to specify revisions on either side, as if
3824
2695
# merging only part of the history.
3825
2696
takes_args = ['branch', 'other']
3828
2699
@display_command
3829
2700
def run(self, branch, other):
3830
2701
from bzrlib.revision import ensure_null
3832
2703
branch1 = Branch.open_containing(branch)[0]
3833
2704
branch2 = Branch.open_containing(other)[0]
3834
self.add_cleanup(branch1.lock_read().unlock)
3835
self.add_cleanup(branch2.lock_read().unlock)
3836
last1 = ensure_null(branch1.last_revision())
3837
last2 = ensure_null(branch2.last_revision())
3839
graph = branch1.repository.get_graph(branch2.repository)
3840
base_rev_id = graph.find_unique_lca(last1, last2)
3842
self.outf.write('merge base is revision %s\n' % base_rev_id)
2709
last1 = ensure_null(branch1.last_revision())
2710
last2 = ensure_null(branch2.last_revision())
2712
graph = branch1.repository.get_graph(branch2.repository)
2713
base_rev_id = graph.find_unique_lca(last1, last2)
2715
print 'merge base is revision %s' % base_rev_id
3845
2722
class cmd_merge(Command):
3846
__doc__ = """Perform a three-way merge.
3848
The source of the merge can be specified either in the form of a branch,
3849
or in the form of a path to a file containing a merge directive generated
3850
with bzr send. If neither is specified, the default is the upstream branch
3851
or the branch most recently merged using --remember.
3853
When merging from a branch, by default bzr will try to merge in all new
3854
work from the other branch, automatically determining an appropriate base
3855
revision. If this fails, you may need to give an explicit base.
3857
To pick a different ending revision, pass "--revision OTHER". bzr will
3858
try to merge in all new work up to and including revision OTHER.
3860
If you specify two values, "--revision BASE..OTHER", only revisions BASE
3861
through OTHER, excluding BASE but including OTHER, will be merged. If this
3862
causes some revisions to be skipped, i.e. if the destination branch does
3863
not already contain revision BASE, such a merge is commonly referred to as
3866
Revision numbers are always relative to the source branch.
2723
"""Perform a three-way merge.
2725
The branch is the branch you will merge from. By default, it will merge
2726
the latest revision. If you specify a revision, that revision will be
2727
merged. If you specify two revisions, the first will be used as a BASE,
2728
and the second one as OTHER. Revision numbers are always relative to the
2731
By default, bzr will try to merge in all new work from the other
2732
branch, automatically determining an appropriate base. If this
2733
fails, you may need to give an explicit base.
3868
2735
Merge will do its best to combine the changes in two branches, but there
3869
2736
are some kinds of problems only a human can fix. When it encounters those,
3870
2737
it will mark a conflict. A conflict means that you need to fix something,
3961
2809
allow_pending = True
3962
2810
verified = 'inapplicable'
3963
2811
tree = WorkingTree.open_containing(directory)[0]
3966
basis_tree = tree.revision_tree(tree.last_revision())
3967
except errors.NoSuchRevision:
3968
basis_tree = tree.basis_tree()
3970
# die as quickly as possible if there are uncommitted changes
3972
if tree.has_changes():
3973
raise errors.UncommittedChanges(tree)
3975
view_info = _get_view_info_for_change_reporter(tree)
3976
2812
change_reporter = delta._ChangeReporter(
3977
unversioned_filter=tree.is_ignored, view_info=view_info)
3978
pb = ui.ui_factory.nested_progress_bar()
3979
self.add_cleanup(pb.finished)
3980
self.add_cleanup(tree.lock_write().unlock)
3981
if location is not None:
3983
mergeable = bundle.read_mergeable_from_url(location,
3984
possible_transports=possible_transports)
3985
except errors.NotABundle:
2813
unversioned_filter=tree.is_ignored)
2816
pb = ui.ui_factory.nested_progress_bar()
2817
cleanups.append(pb.finished)
2819
cleanups.append(tree.unlock)
2820
if location is not None:
2821
mergeable, other_transport = _get_mergeable_helper(location)
2824
raise errors.BzrCommandError('Cannot use --uncommitted'
2825
' with bundles or merge directives.')
2827
if revision is not None:
2828
raise errors.BzrCommandError(
2829
'Cannot use -r with merge directives or bundles')
2830
merger, verified = _mod_merge.Merger.from_mergeable(tree,
2832
possible_transports.append(other_transport)
2834
if merger is None and uncommitted:
2835
if revision is not None and len(revision) > 0:
2836
raise errors.BzrCommandError('Cannot use --uncommitted and'
2837
' --revision at the same time.')
2838
location = self._select_branch_location(tree, location)[0]
2839
other_tree, other_path = WorkingTree.open_containing(location)
2840
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
2842
allow_pending = False
2843
if other_path != '':
2844
merger.interesting_files = [other_path]
2847
merger, allow_pending = self._get_merger_from_branch(tree,
2848
location, revision, remember, possible_transports, pb)
2850
merger.merge_type = merge_type
2851
merger.reprocess = reprocess
2852
merger.show_base = show_base
2853
merger.change_reporter = change_reporter
2854
self.sanity_check_merger(merger)
2855
if (merger.base_rev_id == merger.other_rev_id and
2856
merger.other_rev_id != None):
2857
note('Nothing to do.')
2860
if merger.interesting_files is not None:
2861
raise errors.BzrCommandError('Cannot pull individual files')
2862
if (merger.base_rev_id == tree.last_revision()):
2863
result = tree.pull(merger.other_branch, False,
2864
merger.other_rev_id)
2865
result.report(self.outf)
2867
merger.check_basis(not force)
2868
conflict_count = merger.do_merge()
2870
merger.set_pending()
2871
if verified == 'failed':
2872
warning('Preview patch does not match changes')
2873
if conflict_count != 0:
3989
raise errors.BzrCommandError('Cannot use --uncommitted'
3990
' with bundles or merge directives.')
3992
if revision is not None:
3993
raise errors.BzrCommandError(
3994
'Cannot use -r with merge directives or bundles')
3995
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3998
if merger is None and uncommitted:
3999
if revision is not None and len(revision) > 0:
4000
raise errors.BzrCommandError('Cannot use --uncommitted and'
4001
' --revision at the same time.')
4002
merger = self.get_merger_from_uncommitted(tree, location, None)
4003
allow_pending = False
4006
merger, allow_pending = self._get_merger_from_branch(tree,
4007
location, revision, remember, possible_transports, None)
4009
merger.merge_type = merge_type
4010
merger.reprocess = reprocess
4011
merger.show_base = show_base
4012
self.sanity_check_merger(merger)
4013
if (merger.base_rev_id == merger.other_rev_id and
4014
merger.other_rev_id is not None):
4015
note('Nothing to do.')
4018
if merger.interesting_files is not None:
4019
raise errors.BzrCommandError('Cannot pull individual files')
4020
if (merger.base_rev_id == tree.last_revision()):
4021
result = tree.pull(merger.other_branch, False,
4022
merger.other_rev_id)
4023
result.report(self.outf)
4025
if merger.this_basis is None:
4026
raise errors.BzrCommandError(
4027
"This branch has no commits."
4028
" (perhaps you would prefer 'bzr pull')")
4030
return self._do_preview(merger)
4032
return self._do_interactive(merger)
4034
return self._do_merge(merger, change_reporter, allow_pending,
4037
def _get_preview(self, merger):
4038
tree_merger = merger.make_merger()
4039
tt = tree_merger.make_preview_transform()
4040
self.add_cleanup(tt.finalize)
4041
result_tree = tt.get_preview_tree()
4044
def _do_preview(self, merger):
4045
from bzrlib.diff import show_diff_trees
4046
result_tree = self._get_preview(merger)
4047
path_encoding = osutils.get_diff_header_encoding()
4048
show_diff_trees(merger.this_tree, result_tree, self.outf,
4049
old_label='', new_label='',
4050
path_encoding=path_encoding)
4052
def _do_merge(self, merger, change_reporter, allow_pending, verified):
4053
merger.change_reporter = change_reporter
4054
conflict_count = merger.do_merge()
4056
merger.set_pending()
4057
if verified == 'failed':
4058
warning('Preview patch does not match changes')
4059
if conflict_count != 0:
4064
def _do_interactive(self, merger):
4065
"""Perform an interactive merge.
4067
This works by generating a preview tree of the merge, then using
4068
Shelver to selectively remove the differences between the working tree
4069
and the preview tree.
4071
from bzrlib import shelf_ui
4072
result_tree = self._get_preview(merger)
4073
writer = bzrlib.option.diff_writer_registry.get()
4074
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
4075
reporter=shelf_ui.ApplyReporter(),
4076
diff_writer=writer(sys.stdout))
2878
for cleanup in reversed(cleanups):
4082
2881
def sanity_check_merger(self, merger):
4083
2882
if (merger.show_base and
4084
2883
not merger.merge_type is _mod_merge.Merge3Merger):
4085
2884
raise errors.BzrCommandError("Show-base is not supported for this"
4086
2885
" merge type. %s" % merger.merge_type)
4087
if merger.reprocess is None:
4088
if merger.show_base:
4089
merger.reprocess = False
4091
# Use reprocess if the merger supports it
4092
merger.reprocess = merger.merge_type.supports_reprocess
4093
2886
if merger.reprocess and not merger.merge_type.supports_reprocess:
4094
2887
raise errors.BzrCommandError("Conflict reduction is not supported"
4095
2888
" for merge type %s." %
4240
3020
def run(self, file_list=None, merge_type=None, show_base=False,
4241
3021
reprocess=False):
4242
from bzrlib.conflicts import restore
4243
3022
if merge_type is None:
4244
3023
merge_type = _mod_merge.Merge3Merger
4245
tree, file_list = WorkingTree.open_containing_paths(file_list)
4246
self.add_cleanup(tree.lock_write().unlock)
4247
parents = tree.get_parent_ids()
4248
if len(parents) != 2:
4249
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4250
" merges. Not cherrypicking or"
4252
repository = tree.branch.repository
4253
interesting_ids = None
4255
conflicts = tree.conflicts()
4256
if file_list is not None:
4257
interesting_ids = set()
4258
for filename in file_list:
4259
file_id = tree.path2id(filename)
4261
raise errors.NotVersionedError(filename)
4262
interesting_ids.add(file_id)
4263
if tree.kind(file_id) != "directory":
4266
for name, ie in tree.inventory.iter_entries(file_id):
4267
interesting_ids.add(ie.file_id)
4268
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4270
# Remerge only supports resolving contents conflicts
4271
allowed_conflicts = ('text conflict', 'contents conflict')
4272
restore_files = [c.path for c in conflicts
4273
if c.typestring in allowed_conflicts]
4274
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4275
tree.set_conflicts(ConflictList(new_conflicts))
4276
if file_list is not None:
4277
restore_files = file_list
4278
for filename in restore_files:
3024
tree, file_list = tree_files(file_list)
3027
parents = tree.get_parent_ids()
3028
if len(parents) != 2:
3029
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3030
" merges. Not cherrypicking or"
3032
repository = tree.branch.repository
3033
graph = repository.get_graph()
3034
base_revision = graph.find_unique_lca(parents[0], parents[1])
3035
base_tree = repository.revision_tree(base_revision)
3036
other_tree = repository.revision_tree(parents[1])
3037
interesting_ids = None
3039
conflicts = tree.conflicts()
3040
if file_list is not None:
3041
interesting_ids = set()
3042
for filename in file_list:
3043
file_id = tree.path2id(filename)
3045
raise errors.NotVersionedError(filename)
3046
interesting_ids.add(file_id)
3047
if tree.kind(file_id) != "directory":
3050
for name, ie in tree.inventory.iter_entries(file_id):
3051
interesting_ids.add(ie.file_id)
3052
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3054
# Remerge only supports resolving contents conflicts
3055
allowed_conflicts = ('text conflict', 'contents conflict')
3056
restore_files = [c.path for c in conflicts
3057
if c.typestring in allowed_conflicts]
3058
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3059
tree.set_conflicts(ConflictList(new_conflicts))
3060
if file_list is not None:
3061
restore_files = file_list
3062
for filename in restore_files:
3064
restore(tree.abspath(filename))
3065
except errors.NotConflicted:
3067
# Disable pending merges, because the file texts we are remerging
3068
# have not had those merges performed. If we use the wrong parents
3069
# list, we imply that the working tree text has seen and rejected
3070
# all the changes from the other tree, when in fact those changes
3071
# have not yet been seen.
3072
tree.set_parent_ids(parents[:1])
4280
restore(tree.abspath(filename))
4281
except errors.NotConflicted:
4283
# Disable pending merges, because the file texts we are remerging
4284
# have not had those merges performed. If we use the wrong parents
4285
# list, we imply that the working tree text has seen and rejected
4286
# all the changes from the other tree, when in fact those changes
4287
# have not yet been seen.
4288
tree.set_parent_ids(parents[:1])
4290
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4291
merger.interesting_ids = interesting_ids
4292
merger.merge_type = merge_type
4293
merger.show_base = show_base
4294
merger.reprocess = reprocess
4295
conflicts = merger.do_merge()
3074
conflicts = _mod_merge.merge_inner(
3075
tree.branch, other_tree, base_tree,
3077
interesting_ids=interesting_ids,
3078
other_rev_id=parents[1],
3079
merge_type=merge_type,
3080
show_base=show_base,
3081
reprocess=reprocess)
3083
tree.set_parent_ids(parents)
4297
tree.set_parent_ids(parents)
4298
3086
if conflicts > 0:
4514
3257
" or specified.")
4515
3258
display_url = urlutils.unescape_for_display(parent,
4516
3259
self.outf.encoding)
4517
message("Using saved parent location: "
4518
+ display_url + "\n")
3260
self.outf.write("Using last location: " + display_url + "\n")
4520
3262
remote_branch = Branch.open(other_branch)
4521
3263
if remote_branch.base == local_branch.base:
4522
3264
remote_branch = local_branch
4524
self.add_cleanup(remote_branch.lock_read().unlock)
4526
local_revid_range = _revision_range_to_revid_range(
4527
_get_revision_range(my_revision, local_branch,
4530
remote_revid_range = _revision_range_to_revid_range(
4531
_get_revision_range(revision,
4532
remote_branch, self.name()))
4534
local_extra, remote_extra = find_unmerged(
4535
local_branch, remote_branch, restrict,
4536
backward=not reverse,
4537
include_merges=include_merges,
4538
local_revid_range=local_revid_range,
4539
remote_revid_range=remote_revid_range)
4541
if log_format is None:
4542
registry = log.log_formatter_registry
4543
log_format = registry.get_default(local_branch)
4544
lf = log_format(to_file=self.outf,
4546
show_timezone='original')
4549
if local_extra and not theirs_only:
4550
message("You have %d extra revision(s):\n" %
4552
for revision in iter_log_revisions(local_extra,
4553
local_branch.repository,
4555
lf.log_revision(revision)
4556
printed_local = True
4559
printed_local = False
4561
if remote_extra and not mine_only:
4562
if printed_local is True:
4564
message("You are missing %d revision(s):\n" %
4566
for revision in iter_log_revisions(remote_extra,
4567
remote_branch.repository,
4569
lf.log_revision(revision)
4572
if mine_only and not local_extra:
4573
# We checked local, and found nothing extra
4574
message('This branch is up to date.\n')
4575
elif theirs_only and not remote_extra:
4576
# We checked remote, and found nothing extra
4577
message('Other branch is up to date.\n')
4578
elif not (mine_only or theirs_only or local_extra or
4580
# We checked both branches, and neither one had extra
4582
message("Branches are up to date.\n")
3265
local_branch.lock_read()
3267
remote_branch.lock_read()
3269
local_extra, remote_extra = find_unmerged(local_branch,
3271
if log_format is None:
3272
registry = log.log_formatter_registry
3273
log_format = registry.get_default(local_branch)
3274
lf = log_format(to_file=self.outf,
3276
show_timezone='original')
3277
if reverse is False:
3278
local_extra.reverse()
3279
remote_extra.reverse()
3280
if local_extra and not theirs_only:
3281
self.outf.write("You have %d extra revision(s):\n" %
3283
for revision in iter_log_revisions(local_extra,
3284
local_branch.repository,
3286
lf.log_revision(revision)
3287
printed_local = True
3289
printed_local = False
3290
if remote_extra and not mine_only:
3291
if printed_local is True:
3292
self.outf.write("\n\n\n")
3293
self.outf.write("You are missing %d revision(s):\n" %
3295
for revision in iter_log_revisions(remote_extra,
3296
remote_branch.repository,
3298
lf.log_revision(revision)
3299
if not remote_extra and not local_extra:
3301
self.outf.write("Branches are up to date.\n")
3305
remote_branch.unlock()
3307
local_branch.unlock()
4584
3308
if not status_code and parent is None and other_branch is not None:
4585
self.add_cleanup(local_branch.lock_write().unlock)
4586
# handle race conditions - a parent might be set while we run.
4587
if local_branch.get_parent() is None:
4588
local_branch.set_parent(remote_branch.base)
3309
local_branch.lock_write()
3311
# handle race conditions - a parent might be set while we run.
3312
if local_branch.get_parent() is None:
3313
local_branch.set_parent(remote_branch.base)
3315
local_branch.unlock()
4589
3316
return status_code
4592
3319
class cmd_pack(Command):
4593
__doc__ = """Compress the data within a repository.
4595
This operation compresses the data within a bazaar repository. As
4596
bazaar supports automatic packing of repository, this operation is
4597
normally not required to be done manually.
4599
During the pack operation, bazaar takes a backup of existing repository
4600
data, i.e. pack files. This backup is eventually removed by bazaar
4601
automatically when it is safe to do so. To save disk space by removing
4602
the backed up pack files, the --clean-obsolete-packs option may be
4605
Warning: If you use --clean-obsolete-packs and your machine crashes
4606
during or immediately after repacking, you may be left with a state
4607
where the deletion has been written to disk but the new packs have not
4608
been. In this case the repository may be unusable.
3320
"""Compress the data within a repository."""
4611
3322
_see_also = ['repositories']
4612
3323
takes_args = ['branch_or_repo?']
4614
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4617
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
3325
def run(self, branch_or_repo='.'):
4618
3326
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4620
3328
branch = dir.open_branch()
4621
3329
repository = branch.repository
4622
3330
except errors.NotBranchError:
4623
3331
repository = dir.open_repository()
4624
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4627
3335
class cmd_plugins(Command):
4628
__doc__ = """List the installed plugins.
4630
This command displays the list of installed plugins including
4631
version of plugin and a short description of each.
4633
--verbose shows the path where each plugin is located.
3336
"""List the installed plugins.
3338
This command displays the list of installed plugins including the
3339
path where each one is located and a short description of each.
4635
3341
A plugin is an external component for Bazaar that extends the
4636
3342
revision control system, by adding or replacing code in Bazaar.
5027
3696
class cmd_serve(Command):
5028
__doc__ = """Run the bzr server."""
3697
"""Run the bzr server."""
5030
3699
aliases = ['server']
5032
3701
takes_options = [
5034
3703
help='Serve on stdin/out for use from inetd or sshd.'),
5035
RegistryOption('protocol',
5036
help="Protocol to serve.",
5037
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
5038
value_switches=True),
5040
3705
help='Listen for connections on nominated port of the form '
5041
3706
'[hostname:]portnumber. Passing 0 as the port number will '
5042
'result in a dynamically allocated port. The default port '
5043
'depends on the protocol.',
3707
'result in a dynamically allocated port. The default port is '
5045
custom_help('directory',
5046
help='Serve contents of this directory.'),
3711
help='Serve contents of this directory.',
5047
3713
Option('allow-writes',
5048
3714
help='By default the server is a readonly server. Supplying '
5049
3715
'--allow-writes enables write access to the contents of '
5050
'the served directory and below. Note that ``bzr serve`` '
5051
'does not perform authentication, so unless some form of '
5052
'external authentication is arranged supplying this '
5053
'option leads to global uncontrolled write access to your '
3716
'the served directory and below.'
5058
def get_host_and_port(self, port):
5059
"""Return the host and port to run the smart server on.
5061
If 'port' is None, None will be returned for the host and port.
5063
If 'port' has a colon in it, the string before the colon will be
5064
interpreted as the host.
5066
:param port: A string of the port to run the server on.
5067
:return: A tuple of (host, port), where 'host' is a host name or IP,
5068
and port is an integer TCP/IP port.
5071
if port is not None:
5073
host, port = port.split(':')
5077
def run(self, port=None, inet=False, directory=None, allow_writes=False,
5079
from bzrlib import transport
3720
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3721
from bzrlib.smart import medium, server
3722
from bzrlib.transport import get_transport
3723
from bzrlib.transport.chroot import ChrootServer
5080
3724
if directory is None:
5081
3725
directory = os.getcwd()
5082
if protocol is None:
5083
protocol = transport.transport_server_registry.get()
5084
host, port = self.get_host_and_port(port)
5085
3726
url = urlutils.local_path_to_url(directory)
5086
3727
if not allow_writes:
5087
3728
url = 'readonly+' + url
5088
t = transport.get_transport(url)
5089
protocol(t, host, port, inet)
3729
chroot_server = ChrootServer(get_transport(url))
3730
chroot_server.setUp()
3731
t = get_transport(chroot_server.get_url())
3733
smart_server = medium.SmartServerPipeStreamMedium(
3734
sys.stdin, sys.stdout, t)
3736
host = medium.BZR_DEFAULT_INTERFACE
3738
port = medium.BZR_DEFAULT_PORT
3741
host, port = port.split(':')
3743
smart_server = server.SmartTCPServer(t, host=host, port=port)
3744
print 'listening on port: ', smart_server.port
3746
# for the duration of this server, no UI output is permitted.
3747
# note that this may cause problems with blackbox tests. This should
3748
# be changed with care though, as we dont want to use bandwidth sending
3749
# progress over stderr to smart server clients!
3750
old_factory = ui.ui_factory
3752
ui.ui_factory = ui.SilentUIFactory()
3753
smart_server.serve()
3755
ui.ui_factory = old_factory
5092
3758
class cmd_join(Command):
5093
__doc__ = """Combine a tree into its containing tree.
5095
This command requires the target tree to be in a rich-root format.
3759
"""Combine a subtree into its containing tree.
3761
This command is for experimental use only. It requires the target tree
3762
to be in dirstate-with-subtree format, which cannot be converted into
5097
3765
The TREE argument should be an independent tree, inside another tree, but
5098
3766
not part of it. (Such trees can be produced by "bzr split", but also by
5099
3767
running "bzr branch" with the target inside a tree.)
5101
The result is a combined tree, with the subtree no longer an independent
3769
The result is a combined tree, with the subtree no longer an independant
5102
3770
part. This is marked as a merge of the subtree into the containing tree,
5103
3771
and all history is preserved.
3773
If --reference is specified, the subtree retains its independence. It can
3774
be branched by itself, and can be part of multiple projects at the same
3775
time. But operations performed in the containing tree, such as commit
3776
and merge, will recurse into the subtree.
5106
3779
_see_also = ['split']
5107
3780
takes_args = ['tree']
5108
3781
takes_options = [
5109
Option('reference', help='Join by reference.', hidden=True),
3782
Option('reference', help='Join by reference.'),
5112
3786
def run(self, tree, reference=False):
5113
3787
sub_tree = WorkingTree.open(tree)
5350
4003
'rather than the one containing the working directory.',
5351
4004
short_name='f',
5353
Option('output', short_name='o',
5354
help='Write merge directive to this file or directory; '
5355
'use - for stdout.',
4006
Option('output', short_name='o', help='Write directive to this file.',
5358
help='Refuse to send if there are uncommitted changes in'
5359
' the working tree, --no-strict disables the check.'),
5360
4008
Option('mail-to', help='Mail the request to this address.',
5364
Option('body', help='Body for the email.', type=unicode),
5365
RegistryOption('format',
5366
help='Use the specified output format.',
5367
lazy_registry=('bzrlib.send', 'format_registry')),
4012
RegistryOption.from_kwargs('format',
4013
'Use the specified output format.',
4014
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4015
'0.9': 'Bundle format 0.9, Merge Directive 1',})
5370
4018
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5371
4019
no_patch=False, revision=None, remember=False, output=None,
5372
format=None, mail_to=None, message=None, body=None,
5373
strict=None, **kwargs):
5374
from bzrlib.send import send
5375
return send(submit_branch, revision, public_branch, remember,
5376
format, no_bundle, no_patch, output,
5377
kwargs.get('from', '.'), mail_to, message, body,
4020
format='4', mail_to=None, message=None, **kwargs):
4021
return self._run(submit_branch, revision, public_branch, remember,
4022
format, no_bundle, no_patch, output,
4023
kwargs.get('from', '.'), mail_to, message)
4025
def _run(self, submit_branch, revision, public_branch, remember, format,
4026
no_bundle, no_patch, output, from_, mail_to, message):
4027
from bzrlib.revision import NULL_REVISION
4029
outfile = StringIO()
4033
outfile = open(output, 'wb')
4035
branch = Branch.open_containing(from_)[0]
4036
# we may need to write data into branch's repository to calculate
4040
config = branch.get_config()
4042
mail_to = config.get_user_option('submit_to')
4043
mail_client = config.get_mail_client()
4044
if remember and submit_branch is None:
4045
raise errors.BzrCommandError(
4046
'--remember requires a branch to be specified.')
4047
stored_submit_branch = branch.get_submit_branch()
4048
remembered_submit_branch = False
4049
if submit_branch is None:
4050
submit_branch = stored_submit_branch
4051
remembered_submit_branch = True
4053
if stored_submit_branch is None or remember:
4054
branch.set_submit_branch(submit_branch)
4055
if submit_branch is None:
4056
submit_branch = branch.get_parent()
4057
remembered_submit_branch = True
4058
if submit_branch is None:
4059
raise errors.BzrCommandError('No submit branch known or'
4061
if remembered_submit_branch:
4062
note('Using saved location: %s', submit_branch)
4064
stored_public_branch = branch.get_public_branch()
4065
if public_branch is None:
4066
public_branch = stored_public_branch
4067
elif stored_public_branch is None or remember:
4068
branch.set_public_branch(public_branch)
4069
if no_bundle and public_branch is None:
4070
raise errors.BzrCommandError('No public branch specified or'
4072
base_revision_id = None
4074
if revision is not None:
4075
if len(revision) > 2:
4076
raise errors.BzrCommandError('bzr send takes '
4077
'at most two one revision identifiers')
4078
revision_id = revision[-1].in_history(branch).rev_id
4079
if len(revision) == 2:
4080
base_revision_id = revision[0].in_history(branch).rev_id
4081
if revision_id is None:
4082
revision_id = branch.last_revision()
4083
if revision_id == NULL_REVISION:
4084
raise errors.BzrCommandError('No revisions to submit.')
4086
directive = merge_directive.MergeDirective2.from_objects(
4087
branch.repository, revision_id, time.time(),
4088
osutils.local_time_offset(), submit_branch,
4089
public_branch=public_branch, include_patch=not no_patch,
4090
include_bundle=not no_bundle, message=message,
4091
base_revision_id=base_revision_id)
4092
elif format == '0.9':
4095
patch_type = 'bundle'
4097
raise errors.BzrCommandError('Format 0.9 does not'
4098
' permit bundle with no patch')
4104
directive = merge_directive.MergeDirective.from_objects(
4105
branch.repository, revision_id, time.time(),
4106
osutils.local_time_offset(), submit_branch,
4107
public_branch=public_branch, patch_type=patch_type,
4110
outfile.writelines(directive.to_lines())
4112
subject = '[MERGE] '
4113
if message is not None:
4116
revision = branch.repository.get_revision(revision_id)
4117
subject += revision.get_summary()
4118
mail_client.compose_merge_request(mail_to, subject,
5382
4126
class cmd_bundle_revisions(cmd_send):
5383
__doc__ = """Create a merge-directive for submitting changes.
4128
"""Create a merge-directive for submiting changes.
5385
4130
A merge directive provides many things needed for requesting merges:
5462
4203
Tags are stored in the branch. Tags are copied from one branch to another
5463
4204
along when you branch, push, pull or merge.
5465
It is an error to give a tag name that already exists unless you pass
4206
It is an error to give a tag name that already exists unless you pass
5466
4207
--force, in which case the tag is moved to point to the new revision.
5468
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5469
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5471
If no tag name is specified it will be determined through the
5472
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5473
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5477
4210
_see_also = ['commit', 'tags']
5478
takes_args = ['tag_name?']
4211
takes_args = ['tag_name']
5479
4212
takes_options = [
5480
4213
Option('delete',
5481
4214
help='Delete this tag rather than placing it.',
5483
custom_help('directory',
5484
help='Branch in which to place the tag.'),
4217
help='Branch in which to place the tag.',
5485
4221
Option('force',
5486
4222
help='Replace existing tags.',
5491
def run(self, tag_name=None,
4227
def run(self, tag_name,
5497
4233
branch, relpath = Branch.open_containing(directory)
5498
self.add_cleanup(branch.lock_write().unlock)
5500
if tag_name is None:
5501
raise errors.BzrCommandError("No tag specified to delete.")
5502
branch.tags.delete_tag(tag_name)
5503
note('Deleted tag %s.' % tag_name)
5506
if len(revision) != 1:
5507
raise errors.BzrCommandError(
5508
"Tags can only be placed on a single revision, "
5510
revision_id = revision[0].as_revision_id(branch)
4237
branch.tags.delete_tag(tag_name)
4238
self.outf.write('Deleted tag %s.\n' % tag_name)
5512
revision_id = branch.last_revision()
5513
if tag_name is None:
5514
tag_name = branch.automatic_tag_name(revision_id)
5515
if tag_name is None:
5516
raise errors.BzrCommandError(
5517
"Please specify a tag name.")
5518
if (not force) and branch.tags.has_tag(tag_name):
5519
raise errors.TagAlreadyExists(tag_name)
5520
branch.tags.set_tag(tag_name, revision_id)
5521
note('Created tag %s.' % tag_name)
4241
if len(revision) != 1:
4242
raise errors.BzrCommandError(
4243
"Tags can only be placed on a single revision, "
4245
revision_id = revision[0].in_history(branch).rev_id
4247
revision_id = branch.last_revision()
4248
if (not force) and branch.tags.has_tag(tag_name):
4249
raise errors.TagAlreadyExists(tag_name)
4250
branch.tags.set_tag(tag_name, revision_id)
4251
self.outf.write('Created tag %s.\n' % tag_name)
5524
4256
class cmd_tags(Command):
5525
__doc__ = """List tags.
5527
4259
This command shows a table of tag names and the revisions they reference.
5530
4262
_see_also = ['tag']
5531
4263
takes_options = [
5532
custom_help('directory',
5533
help='Branch whose tags should be displayed.'),
5534
RegistryOption('sort',
4265
help='Branch whose tags should be displayed.',
4269
RegistryOption.from_kwargs('sort',
5535
4270
'Sort tags by different criteria.', title='Sorting',
5536
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
4271
alpha='Sort tags lexicographically (default).',
4272
time='Sort tags chronologically.',
5542
4277
@display_command
5543
def run(self, directory='.', sort=None, show_ids=False, revision=None):
5544
from bzrlib.tag import tag_sort_methods
5545
4283
branch, relpath = Branch.open_containing(directory)
5547
4284
tags = branch.tags.get_tag_dict().items()
5551
self.add_cleanup(branch.lock_read().unlock)
5553
graph = branch.repository.get_graph()
5554
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5555
revid1, revid2 = rev1.rev_id, rev2.rev_id
5556
# only show revisions between revid1 and revid2 (inclusive)
5557
tags = [(tag, revid) for tag, revid in tags if
5558
graph.is_between(revid, revid1, revid2)]
5560
sort = tag_sort_methods.get()
4287
elif sort == 'time':
4289
for tag, revid in tags:
4291
revobj = branch.repository.get_revision(revid)
4292
except errors.NoSuchRevision:
4293
timestamp = sys.maxint # place them at the end
4295
timestamp = revobj.timestamp
4296
timestamps[revid] = timestamp
4297
tags.sort(key=lambda x: timestamps[x[1]])
5562
4298
if not show_ids:
5563
4299
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5564
for index, (tag, revid) in enumerate(tags):
5566
revno = branch.revision_id_to_dotted_revno(revid)
5567
if isinstance(revno, tuple):
5568
revno = '.'.join(map(str, revno))
5569
except errors.NoSuchRevision:
5570
# Bad tag data/merges can lead to tagged revisions
5571
# which are not in this branch. Fail gracefully ...
5573
tags[index] = (tag, revno)
4300
revno_map = branch.get_revision_id_to_revno_map()
4301
tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
4302
for tag, revid in tags ]
5575
4303
for tag, revspec in tags:
5576
4304
self.outf.write('%-20s %s\n' % (tag, revspec))
5579
4307
class cmd_reconfigure(Command):
5580
__doc__ = """Reconfigure the type of a bzr directory.
4308
"""Reconfigure the type of a bzr directory.
5582
4310
A target configuration must be specified.
5590
4318
If none of these is available, --bind-to must be specified.
5593
_see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
5594
4321
takes_args = ['location?']
5596
RegistryOption.from_kwargs(
5598
title='Target type',
5599
help='The type to reconfigure the directory to.',
5600
value_switches=True, enum_switch=False,
5601
branch='Reconfigure to be an unbound branch with no working tree.',
5602
tree='Reconfigure to be an unbound branch with a working tree.',
5603
checkout='Reconfigure to be a bound branch with a working tree.',
5604
lightweight_checkout='Reconfigure to be a lightweight'
5605
' checkout (with no local history).',
5606
standalone='Reconfigure to be a standalone branch '
5607
'(i.e. stop using shared repository).',
5608
use_shared='Reconfigure to use a shared repository.',
5609
with_trees='Reconfigure repository to create '
5610
'working trees on branches by default.',
5611
with_no_trees='Reconfigure repository to not create '
5612
'working trees on branches by default.'
5614
Option('bind-to', help='Branch to bind checkout to.', type=str),
5616
help='Perform reconfiguration even if local changes'
5618
Option('stacked-on',
5619
help='Reconfigure a branch to be stacked on another branch.',
5623
help='Reconfigure a branch to be unstacked. This '
5624
'may require copying substantial data into it.',
4322
takes_options = [RegistryOption.from_kwargs('target_type',
4323
title='Target type',
4324
help='The type to reconfigure the directory to.',
4325
value_switches=True, enum_switch=False,
4326
branch='Reconfigure to a branch.',
4327
tree='Reconfigure to a tree.',
4328
checkout='Reconfigure to a checkout.',
4329
lightweight_checkout='Reconfigure to a lightweight'
4331
Option('bind-to', help='Branch to bind checkout to.',
4334
help='Perform reconfiguration even if local changes'
5628
def run(self, location=None, target_type=None, bind_to=None, force=False,
4338
def run(self, location=None, target_type=None, bind_to=None, force=False):
5631
4339
directory = bzrdir.BzrDir.open(location)
5632
if stacked_on and unstacked:
5633
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
5634
elif stacked_on is not None:
5635
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5637
reconfigure.ReconfigureUnstacked().apply(directory)
5638
# At the moment you can use --stacked-on and a different
5639
# reconfiguration shape at the same time; there seems no good reason
5641
4340
if target_type is None:
5642
if stacked_on or unstacked:
5645
raise errors.BzrCommandError('No target configuration '
4341
raise errors.BzrCommandError('No target configuration specified')
5647
4342
elif target_type == 'branch':
5648
4343
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5649
4344
elif target_type == 'tree':
5650
4345
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5651
4346
elif target_type == 'checkout':
5652
reconfiguration = reconfigure.Reconfigure.to_checkout(
4347
reconfiguration = reconfigure.Reconfigure.to_checkout(directory,
5654
4349
elif target_type == 'lightweight-checkout':
5655
4350
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5656
4351
directory, bind_to)
5657
elif target_type == 'use-shared':
5658
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5659
elif target_type == 'standalone':
5660
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5661
elif target_type == 'with-trees':
5662
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5664
elif target_type == 'with-no-trees':
5665
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5667
4352
reconfiguration.apply(force)
5670
4355
class cmd_switch(Command):
5671
__doc__ = """Set the branch of a checkout and update.
4356
"""Set the branch of a checkout and update.
5673
4358
For lightweight checkouts, this changes the branch being referenced.
5674
4359
For heavyweight checkouts, this checks that there are no local commits
5675
4360
versus the current bound branch, then it makes the local branch a mirror
5676
4361
of the new location and binds to it.
5678
4363
In both cases, the working tree is updated and uncommitted changes
5679
4364
are merged. The user can commit or revert these as they desire.
5681
4366
Pending merges need to be committed or reverted before using switch.
5683
The path to the branch to switch to can be specified relative to the parent
5684
directory of the current branch. For example, if you are currently in a
5685
checkout of /path/to/branch, specifying 'newbranch' will find a branch at
5688
Bound branches use the nickname of its master branch unless it is set
5689
locally, in which case switching will update the local nickname to be
5693
takes_args = ['to_location?']
5694
takes_options = ['directory',
5696
help='Switch even if local commits will be lost.'),
5698
Option('create-branch', short_name='b',
5699
help='Create the target branch from this one before'
5700
' switching to it.'),
4369
takes_args = ['to_location']
4370
takes_options = [Option('force',
4371
help='Switch even if local commits will be lost.')
5703
def run(self, to_location=None, force=False, create_branch=False,
5704
revision=None, directory=u'.'):
4374
def run(self, to_location, force=False):
5705
4375
from bzrlib import switch
5706
tree_location = directory
5707
revision = _get_one_revision('switch', revision)
4376
to_branch = Branch.open(to_location)
5708
4378
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5709
if to_location is None:
5710
if revision is None:
5711
raise errors.BzrCommandError('You must supply either a'
5712
' revision or a location')
5713
to_location = tree_location
5715
branch = control_dir.open_branch()
5716
had_explicit_nick = branch.get_config().has_explicit_nickname()
5717
except errors.NotBranchError:
5719
had_explicit_nick = False
5722
raise errors.BzrCommandError('cannot create branch without'
5724
to_location = directory_service.directories.dereference(
5726
if '/' not in to_location and '\\' not in to_location:
5727
# This path is meant to be relative to the existing branch
5728
this_url = self._get_branch_location(control_dir)
5729
to_location = urlutils.join(this_url, '..', to_location)
5730
to_branch = branch.bzrdir.sprout(to_location,
5731
possible_transports=[branch.bzrdir.root_transport],
5732
source_branch=branch).open_branch()
5735
to_branch = Branch.open(to_location)
5736
except errors.NotBranchError:
5737
this_url = self._get_branch_location(control_dir)
5738
to_branch = Branch.open(
5739
urlutils.join(this_url, '..', to_location))
5740
if revision is not None:
5741
revision = revision.as_revision_id(to_branch)
5742
switch.switch(control_dir, to_branch, force, revision_id=revision)
5743
if had_explicit_nick:
5744
branch = control_dir.open_branch() #get the new branch!
5745
branch.nick = to_branch.nick
4379
switch.switch(control_dir, to_branch, force)
5746
4380
note('Switched to branch: %s',
5747
4381
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5749
def _get_branch_location(self, control_dir):
5750
"""Return location of branch for this control dir."""
5752
this_branch = control_dir.open_branch()
5753
# This may be a heavy checkout, where we want the master branch
5754
master_location = this_branch.get_bound_location()
5755
if master_location is not None:
5756
return master_location
5757
# If not, use a local sibling
5758
return this_branch.base
5759
except errors.NotBranchError:
5760
format = control_dir.find_branch_format()
5761
if getattr(format, 'get_reference', None) is not None:
5762
return format.get_reference(control_dir)
5764
return control_dir.root_transport.base
5767
class cmd_view(Command):
5768
__doc__ = """Manage filtered views.
5770
Views provide a mask over the tree so that users can focus on
5771
a subset of a tree when doing their work. After creating a view,
5772
commands that support a list of files - status, diff, commit, etc -
5773
effectively have that list of files implicitly given each time.
5774
An explicit list of files can still be given but those files
5775
must be within the current view.
5777
In most cases, a view has a short life-span: it is created to make
5778
a selected change and is deleted once that change is committed.
5779
At other times, you may wish to create one or more named views
5780
and switch between them.
5782
To disable the current view without deleting it, you can switch to
5783
the pseudo view called ``off``. This can be useful when you need
5784
to see the whole tree for an operation or two (e.g. merge) but
5785
want to switch back to your view after that.
5788
To define the current view::
5790
bzr view file1 dir1 ...
5792
To list the current view::
5796
To delete the current view::
5800
To disable the current view without deleting it::
5802
bzr view --switch off
5804
To define a named view and switch to it::
5806
bzr view --name view-name file1 dir1 ...
5808
To list a named view::
5810
bzr view --name view-name
5812
To delete a named view::
5814
bzr view --name view-name --delete
5816
To switch to a named view::
5818
bzr view --switch view-name
5820
To list all views defined::
5824
To delete all views::
5826
bzr view --delete --all
5830
takes_args = ['file*']
5833
help='Apply list or delete action to all views.',
5836
help='Delete the view.',
5839
help='Name of the view to define, list or delete.',
5843
help='Name of the view to switch to.',
5848
def run(self, file_list,
5854
tree, file_list = WorkingTree.open_containing_paths(file_list,
5856
current_view, view_dict = tree.views.get_view_info()
5861
raise errors.BzrCommandError(
5862
"Both --delete and a file list specified")
5864
raise errors.BzrCommandError(
5865
"Both --delete and --switch specified")
5867
tree.views.set_view_info(None, {})
5868
self.outf.write("Deleted all views.\n")
5870
raise errors.BzrCommandError("No current view to delete")
5872
tree.views.delete_view(name)
5873
self.outf.write("Deleted '%s' view.\n" % name)
5876
raise errors.BzrCommandError(
5877
"Both --switch and a file list specified")
5879
raise errors.BzrCommandError(
5880
"Both --switch and --all specified")
5881
elif switch == 'off':
5882
if current_view is None:
5883
raise errors.BzrCommandError("No current view to disable")
5884
tree.views.set_view_info(None, view_dict)
5885
self.outf.write("Disabled '%s' view.\n" % (current_view))
5887
tree.views.set_view_info(switch, view_dict)
5888
view_str = views.view_display_str(tree.views.lookup_view())
5889
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
5892
self.outf.write('Views defined:\n')
5893
for view in sorted(view_dict):
5894
if view == current_view:
5898
view_str = views.view_display_str(view_dict[view])
5899
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5901
self.outf.write('No views defined.\n')
5904
# No name given and no current view set
5907
raise errors.BzrCommandError(
5908
"Cannot change the 'off' pseudo view")
5909
tree.views.set_view(name, sorted(file_list))
5910
view_str = views.view_display_str(tree.views.lookup_view())
5911
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
5915
# No name given and no current view set
5916
self.outf.write('No current view.\n')
5918
view_str = views.view_display_str(tree.views.lookup_view(name))
5919
self.outf.write("'%s' view is: %s\n" % (name, view_str))
5922
class cmd_hooks(Command):
5923
__doc__ = """Show hooks."""
5928
for hook_key in sorted(hooks.known_hooks.keys()):
5929
some_hooks = hooks.known_hooks_key_to_object(hook_key)
5930
self.outf.write("%s:\n" % type(some_hooks).__name__)
5931
for hook_name, hook_point in sorted(some_hooks.items()):
5932
self.outf.write(" %s:\n" % (hook_name,))
5933
found_hooks = list(hook_point)
5935
for hook in found_hooks:
5936
self.outf.write(" %s\n" %
5937
(some_hooks.get_hook_name(hook),))
5939
self.outf.write(" <no hooks installed>\n")
5942
class cmd_remove_branch(Command):
5943
__doc__ = """Remove a branch.
5945
This will remove the branch from the specified location but
5946
will keep any working tree or repository in place.
5950
Remove the branch at repo/trunk::
5952
bzr remove-branch repo/trunk
5956
takes_args = ["location?"]
5958
aliases = ["rmbranch"]
5960
def run(self, location=None):
5961
if location is None:
5963
branch = Branch.open_containing(location)[0]
5964
branch.bzrdir.destroy_branch()
5967
class cmd_shelve(Command):
5968
__doc__ = """Temporarily set aside some changes from the current tree.
5970
Shelve allows you to temporarily put changes you've made "on the shelf",
5971
ie. out of the way, until a later time when you can bring them back from
5972
the shelf with the 'unshelve' command. The changes are stored alongside
5973
your working tree, and so they aren't propagated along with your branch nor
5974
will they survive its deletion.
5976
If shelve --list is specified, previously-shelved changes are listed.
5978
Shelve is intended to help separate several sets of changes that have
5979
been inappropriately mingled. If you just want to get rid of all changes
5980
and you don't need to restore them later, use revert. If you want to
5981
shelve all text changes at once, use shelve --all.
5983
If filenames are specified, only the changes to those files will be
5984
shelved. Other files will be left untouched.
5986
If a revision is specified, changes since that revision will be shelved.
5988
You can put multiple items on the shelf, and by default, 'unshelve' will
5989
restore the most recently shelved changes.
5991
For complicated changes, it is possible to edit the changes in a separate
5992
editor program to decide what the file remaining in the working copy
5993
should look like. To do this, add the configuration option
5995
change_editor = PROGRAM @new_path @old_path
5997
where @new_path is replaced with the path of the new version of the
5998
file and @old_path is replaced with the path of the old version of
5999
the file. The PROGRAM should save the new file with the desired
6000
contents of the file in the working tree.
6004
takes_args = ['file*']
6009
Option('all', help='Shelve all changes.'),
6011
RegistryOption('writer', 'Method to use for writing diffs.',
6012
bzrlib.option.diff_writer_registry,
6013
value_switches=True, enum_switch=False),
6015
Option('list', help='List shelved changes.'),
6017
help='Destroy removed changes instead of shelving them.'),
6019
_see_also = ['unshelve', 'configuration']
6021
def run(self, revision=None, all=False, file_list=None, message=None,
6022
writer=None, list=False, destroy=False, directory=None):
6024
return self.run_for_list(directory=directory)
6025
from bzrlib.shelf_ui import Shelver
6027
writer = bzrlib.option.diff_writer_registry.get()
6029
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6030
file_list, message, destroy=destroy, directory=directory)
6035
except errors.UserAbort:
6038
def run_for_list(self, directory=None):
6039
if directory is None:
6041
tree = WorkingTree.open_containing(directory)[0]
6042
self.add_cleanup(tree.lock_read().unlock)
6043
manager = tree.get_shelf_manager()
6044
shelves = manager.active_shelves()
6045
if len(shelves) == 0:
6046
note('No shelved changes.')
6048
for shelf_id in reversed(shelves):
6049
message = manager.get_metadata(shelf_id).get('message')
6051
message = '<no message>'
6052
self.outf.write('%3d: %s\n' % (shelf_id, message))
6056
class cmd_unshelve(Command):
6057
__doc__ = """Restore shelved changes.
6059
By default, the most recently shelved changes are restored. However if you
6060
specify a shelf by id those changes will be restored instead. This works
6061
best when the changes don't depend on each other.
6064
takes_args = ['shelf_id?']
6067
RegistryOption.from_kwargs(
6068
'action', help="The action to perform.",
6069
enum_switch=False, value_switches=True,
6070
apply="Apply changes and remove from the shelf.",
6071
dry_run="Show changes, but do not apply or remove them.",
6072
preview="Instead of unshelving the changes, show the diff that "
6073
"would result from unshelving.",
6074
delete_only="Delete changes without applying them.",
6075
keep="Apply changes but don't delete them.",
6078
_see_also = ['shelve']
6080
def run(self, shelf_id=None, action='apply', directory=u'.'):
6081
from bzrlib.shelf_ui import Unshelver
6082
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
6086
unshelver.tree.unlock()
6089
class cmd_clean_tree(Command):
6090
__doc__ = """Remove unwanted files from working tree.
6092
By default, only unknown files, not ignored files, are deleted. Versioned
6093
files are never deleted.
6095
Another class is 'detritus', which includes files emitted by bzr during
6096
normal operations and selftests. (The value of these files decreases with
6099
If no options are specified, unknown files are deleted. Otherwise, option
6100
flags are respected, and may be combined.
6102
To check what clean-tree will do, use --dry-run.
6104
takes_options = ['directory',
6105
Option('ignored', help='Delete all ignored files.'),
6106
Option('detritus', help='Delete conflict files, merge'
6107
' backups, and failed selftest dirs.'),
6109
help='Delete files unknown to bzr (default).'),
6110
Option('dry-run', help='Show files to delete instead of'
6112
Option('force', help='Do not prompt before deleting.')]
6113
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6114
force=False, directory=u'.'):
6115
from bzrlib.clean_tree import clean_tree
6116
if not (unknown or ignored or detritus):
6120
clean_tree(directory, unknown=unknown, ignored=ignored,
6121
detritus=detritus, dry_run=dry_run, no_prompt=force)
6124
class cmd_reference(Command):
6125
__doc__ = """list, view and set branch locations for nested trees.
6127
If no arguments are provided, lists the branch locations for nested trees.
6128
If one argument is provided, display the branch location for that tree.
6129
If two arguments are provided, set the branch location for that tree.
6134
takes_args = ['path?', 'location?']
6136
def run(self, path=None, location=None):
6138
if path is not None:
6140
tree, branch, relpath =(
6141
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
6142
if path is not None:
6145
tree = branch.basis_tree()
6147
info = branch._get_all_reference_info().iteritems()
6148
self._display_reference_info(tree, branch, info)
6150
file_id = tree.path2id(path)
6152
raise errors.NotVersionedError(path)
6153
if location is None:
6154
info = [(file_id, branch.get_reference_info(file_id))]
6155
self._display_reference_info(tree, branch, info)
6157
branch.set_reference_info(file_id, path, location)
6159
def _display_reference_info(self, tree, branch, info):
6161
for file_id, (path, location) in info:
6163
path = tree.id2path(file_id)
6164
except errors.NoSuchId:
6166
ref_list.append((path, location))
6167
for path, location in sorted(ref_list):
6168
self.outf.write('%s %s\n' % (path, location))
6171
def _register_lazy_builtins():
6172
# register lazy builtins from other modules; called at startup and should
6173
# be only called once.
6174
for (name, aliases, module_name) in [
6175
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6176
('cmd_config', [], 'bzrlib.config'),
6177
('cmd_dpush', [], 'bzrlib.foreign'),
6178
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6179
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6180
('cmd_conflicts', [], 'bzrlib.conflicts'),
6181
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6182
('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6184
builtin_command_registry.register_lazy(name, aliases, module_name)
4384
def _create_prefix(cur_transport):
4385
needed = [cur_transport]
4386
# Recurse upwards until we can create a directory successfully
4388
new_transport = cur_transport.clone('..')
4389
if new_transport.base == cur_transport.base:
4390
raise errors.BzrCommandError(
4391
"Failed to create path prefix for %s."
4392
% cur_transport.base)
4394
new_transport.mkdir('.')
4395
except errors.NoSuchFile:
4396
needed.append(new_transport)
4397
cur_transport = new_transport
4400
# Now we only need to create child directories
4402
cur_transport = needed.pop()
4403
cur_transport.ensure_base()
4406
def _get_mergeable_helper(location):
4407
"""Get a merge directive or bundle if 'location' points to one.
4409
Try try to identify a bundle and returns its mergeable form. If it's not,
4410
we return the tried transport anyway so that it can reused to access the
4413
:param location: can point to a bundle or a branch.
4415
:return: mergeable, transport
4418
url = urlutils.normalize_url(location)
4419
url, filename = urlutils.split(url, exclude_trailing_slash=False)
4420
location_transport = transport.get_transport(url)
4423
# There may be redirections but we ignore the intermediate
4424
# and final transports used
4425
read = bundle.read_mergeable_from_transport
4426
mergeable, t = read(location_transport, filename)
4427
except errors.NotABundle:
4428
# Continue on considering this url a Branch but adjust the
4429
# location_transport
4430
location_transport = location_transport.clone(filename)
4431
return mergeable, location_transport
4434
# these get imported and then picked up by the scan for cmd_*
4435
# TODO: Some more consistent way to split command definitions across files;
4436
# we do need to load at least some information about them to know of
4437
# aliases. ideally we would avoid loading the implementation until the
4438
# details were needed.
4439
from bzrlib.cmd_version_info import cmd_version_info
4440
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
4441
from bzrlib.bundle.commands import (
4444
from bzrlib.sign_my_commits import cmd_sign_my_commits
4445
from bzrlib.weave_commands import cmd_versionedfile_list, cmd_weave_join, \
4446
cmd_weave_plan_merge, cmd_weave_merge_text