1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""builtin bzr commands"""
20
from StringIO import StringIO
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
43
revision as _mod_revision,
50
from bzrlib.branch import Branch
51
from bzrlib.conflicts import ConflictList
52
from bzrlib.revisionspec import RevisionSpec
53
from bzrlib.smtp_connection import SMTPConnection
54
from bzrlib.workingtree import WorkingTree
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]))
70
# XXX: Bad function name; should possibly also be a class method of
71
# WorkingTree rather than a function.
72
def internal_tree_files(file_list, default_branch=u'.'):
73
"""Convert command-line paths to a WorkingTree and relative paths.
75
This is typically used for command-line processors that take one or
76
more filenames, and infer the workingtree that contains them.
78
The filenames given are not required to exist.
80
:param file_list: Filenames to convert.
82
:param default_branch: Fallback tree path to use if file_list is empty or
85
:return: workingtree, [relative_paths]
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()
107
return bzrdir.format_registry.make_bzrdir(typestring)
109
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
110
raise errors.BzrCommandError(msg)
113
# TODO: Make sure no commands unconditionally use the working directory as a
114
# branch. If a filename argument is used, the first of them should be used to
115
# specify the branch. (Perhaps this can be factored out into some kind of
116
# Argument class, representing a file in a branch, where the first occurrence
119
class cmd_status(Command):
120
"""Display status summary.
122
This reports on versioned and unknown files, reporting them
123
grouped by state. Possible states are:
126
Versioned in the working copy but not in the previous revision.
129
Versioned in the previous revision but removed or deleted
133
Path of this file changed from the previous revision;
134
the text may also have changed. This includes files whose
135
parent directory was renamed.
138
Text has changed since the previous revision.
141
File kind has been changed (e.g. from file to directory).
144
Not versioned and not matching an ignore pattern.
146
To see ignored files use 'bzr ignored'. For details on the
147
changes to file texts, use 'bzr diff'.
149
Note that --short or -S gives status flags for each item, similar
150
to Subversion's status command. To get output similar to svn -q,
153
If no arguments are specified, the status of the entire working
154
directory is shown. Otherwise, only the status of the specified
155
files or directories is reported. If a directory is given, status
156
is reported for everything inside that directory.
158
If a revision argument is given, the status is calculated against
159
that revision, or between two revisions if two are provided.
162
# TODO: --no-recurse, --recurse options
164
takes_args = ['file*']
165
takes_options = ['show-ids', 'revision', 'change',
166
Option('short', help='Use short status indicators.',
168
Option('versioned', help='Only show versioned files.',
171
aliases = ['st', 'stat']
173
encoding_type = 'replace'
174
_see_also = ['diff', 'revert', 'status-flags']
177
def run(self, show_ids=False, file_list=None, revision=None, short=False,
179
from bzrlib.status import show_tree_status
181
if revision and len(revision) > 2:
182
raise errors.BzrCommandError('bzr status --revision takes exactly'
183
' one or two revision specifiers')
185
tree, file_list = tree_files(file_list)
187
show_tree_status(tree, show_ids=show_ids,
188
specific_files=file_list, revision=revision,
189
to_file=self.outf, short=short, versioned=versioned)
192
class cmd_cat_revision(Command):
193
"""Write out metadata for a revision.
195
The revision to print can either be specified by a specific
196
revision identifier, or you can use --revision.
200
takes_args = ['revision_id?']
201
takes_options = ['revision']
202
# cat-revision is more for frontends so should be exact
206
def run(self, revision_id=None, revision=None):
207
if revision_id is not None and revision is not None:
208
raise errors.BzrCommandError('You can only supply one of'
209
' revision_id or --revision')
210
if revision_id is None and revision is None:
211
raise errors.BzrCommandError('You must supply either'
212
' --revision or a revision_id')
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'))
228
class cmd_remove_tree(Command):
229
"""Remove the working tree from a given branch/checkout.
231
Since a lightweight checkout is little more than a working tree
232
this will refuse to run against one.
234
To re-create the working tree, use "bzr checkout".
236
_see_also = ['checkout', 'working-trees']
238
takes_args = ['location?']
240
def run(self, location='.'):
241
d = bzrdir.BzrDir.open(location)
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()
260
class cmd_revno(Command):
261
"""Show current revision number.
263
This is equal to the number of revisions on this branch.
267
takes_args = ['location?']
270
def run(self, location=u'.'):
271
self.outf.write(str(Branch.open_containing(location)[0].revno()))
272
self.outf.write('\n')
275
class cmd_revision_info(Command):
276
"""Show revision number and revision id for a given revision identifier.
279
takes_args = ['revision_info*']
280
takes_options = ['revision']
283
def run(self, revision=None, revision_info_list=[]):
286
if revision is not None:
287
revs.extend(revision)
288
if revision_info_list is not None:
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)
304
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
307
class cmd_add(Command):
308
"""Add specified files or directories.
310
In non-recursive mode, all the named items are added, regardless
311
of whether they were previously ignored. A warning is given if
312
any of the named files are already versioned.
314
In recursive mode (the default), files are treated the same way
315
but the behaviour for directories is different. Directories that
316
are already versioned do not give a warning. All directories,
317
whether already versioned or not, are searched for files or
318
subdirectories that are neither versioned or ignored, and these
319
are added. This search proceeds recursively into versioned
320
directories. If no names are given '.' is assumed.
322
Therefore simply saying 'bzr add' will version all files that
323
are currently unknown.
325
Adding a file whose parent directory is not versioned will
326
implicitly add the parent, and so on up to the root. This means
327
you should never need to explicitly add a directory, they'll just
328
get added when you add a file in the directory.
330
--dry-run will show which files would be added, but not actually
333
--file-ids-from will try to use the file ids from the supplied path.
334
It looks up ids trying to find a matching parent directory with the
335
same filename, and then by pure path. This option is rarely needed
336
but can be useful when adding the same logical file into two
337
branches that will be merged later (without showing the two different
338
adds as a conflict). It is also useful when merging another project
339
into a subdirectory of this one.
341
takes_args = ['file*']
344
help="Don't recursively add the contents of directories."),
346
help="Show what would be done, but don't actually do anything."),
348
Option('file-ids-from',
350
help='Lookup file ids from this tree.'),
352
encoding_type = 'replace'
353
_see_also = ['remove']
355
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
360
if file_ids_from is not None:
362
base_tree, base_path = WorkingTree.open_containing(
364
except errors.NoWorkingTree:
365
base_branch, base_path = Branch.open_containing(
367
base_tree = base_branch.basis_tree()
369
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
370
to_file=self.outf, should_print=(not is_quiet()))
372
action = bzrlib.add.AddAction(to_file=self.outf,
373
should_print=(not is_quiet()))
376
base_tree.lock_read()
378
file_list = self._maybe_expand_globs(file_list)
380
tree = WorkingTree.open_containing(file_list[0])[0]
382
tree = WorkingTree.open_containing(u'.')[0]
383
added, ignored = tree.smart_add(file_list, not
384
no_recurse, action=action, save=not dry_run)
386
if base_tree is not None:
390
for glob in sorted(ignored.keys()):
391
for path in ignored[glob]:
392
self.outf.write("ignored %s matching \"%s\"\n"
396
for glob, paths in ignored.items():
397
match_len += len(paths)
398
self.outf.write("ignored %d file(s).\n" % match_len)
399
self.outf.write("If you wish to add some of these files,"
400
" please add them by name.\n")
403
class cmd_mkdir(Command):
404
"""Create a new versioned directory.
406
This is equivalent to creating the directory and then adding it.
409
takes_args = ['dir+']
410
encoding_type = 'replace'
412
def run(self, dir_list):
415
wt, dd = WorkingTree.open_containing(d)
417
self.outf.write('added %s\n' % d)
420
class cmd_relpath(Command):
421
"""Show path of a file relative to root"""
423
takes_args = ['filename']
427
def run(self, filename):
428
# TODO: jam 20050106 Can relpath return a munged path if
429
# sys.stdout encoding cannot represent it?
430
tree, relpath = WorkingTree.open_containing(filename)
431
self.outf.write(relpath)
432
self.outf.write('\n')
435
class cmd_inventory(Command):
436
"""Show inventory of the current working copy or a revision.
438
It is possible to limit the output to a particular entry
439
type using the --kind option. For example: --kind file.
441
It is also possible to restrict the list of files to a specific
442
set. For example: bzr inventory --show-ids this/file
451
help='List entries of a particular kind: file, directory, symlink.',
454
takes_args = ['file*']
457
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
458
if kind and kind not in ['file', 'directory', 'symlink']:
459
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
461
work_tree, file_list = tree_files(file_list)
462
work_tree.lock_read()
464
if revision is not None:
465
if len(revision) > 1:
466
raise errors.BzrCommandError(
467
'bzr inventory --revision takes exactly one revision'
469
revision_id = revision[0].in_history(work_tree.branch).rev_id
470
tree = work_tree.branch.repository.revision_tree(revision_id)
472
extra_trees = [work_tree]
478
if file_list is not None:
479
file_ids = tree.paths2ids(file_list, trees=extra_trees,
480
require_versioned=True)
481
# find_ids_across_trees may include some paths that don't
483
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
484
for file_id in file_ids if file_id in tree)
486
entries = tree.inventory.entries()
489
if tree is not work_tree:
492
for path, entry in entries:
493
if kind and kind != entry.kind:
496
self.outf.write('%-50s %s\n' % (path, entry.file_id))
498
self.outf.write(path)
499
self.outf.write('\n')
502
class cmd_mv(Command):
503
"""Move or rename a file.
506
bzr mv OLDNAME NEWNAME
508
bzr mv SOURCE... DESTINATION
510
If the last argument is a versioned directory, all the other names
511
are moved into it. Otherwise, there must be exactly two arguments
512
and the file is changed to a new name.
514
If OLDNAME does not exist on the filesystem but is versioned and
515
NEWNAME does exist on the filesystem but is not versioned, mv
516
assumes that the file has been manually moved and only updates
517
its internal inventory to reflect that change.
518
The same is valid when moving many SOURCE files to a DESTINATION.
520
Files cannot be moved between branches.
523
takes_args = ['names*']
524
takes_options = [Option("after", help="Move only the bzr identifier"
525
" of the file, because the file has already been moved."),
527
aliases = ['move', 'rename']
528
encoding_type = 'replace'
530
def run(self, names_list, after=False):
531
if names_list is None:
534
if len(names_list) < 2:
535
raise errors.BzrCommandError("missing file argument")
536
tree, rel_names = tree_files(names_list)
538
if os.path.isdir(names_list[-1]):
539
# move into existing directory
540
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
541
self.outf.write("%s => %s\n" % pair)
543
if len(names_list) != 2:
544
raise errors.BzrCommandError('to mv multiple files the'
545
' destination must be a versioned'
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]))
551
class cmd_pull(Command):
552
"""Turn this branch into a mirror of another branch.
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.
558
If branches have diverged, you can use 'bzr merge' to integrate the changes
559
from one into the other. Once one branch has merged, the other should
560
be able to pull it again.
562
If you want to forget your local changes and just update your branch to
563
match the remote one, use pull --overwrite.
565
If there is no default location set, the first pull will set it. After
566
that, you can omit the location to use the default. To change the
567
default, use --remember. The value will only be saved if the remote
568
location can be accessed.
571
_see_also = ['push', 'update', 'status-flags']
572
takes_options = ['remember', 'overwrite', 'revision',
573
custom_help('verbose',
574
help='Show logs of pulled revisions.'),
576
help='Branch to pull into, '
577
'rather than the one containing the working directory.',
582
takes_args = ['location?']
583
encoding_type = 'replace'
585
def run(self, location=None, remember=False, overwrite=False,
586
revision=None, verbose=False,
588
# FIXME: too much stuff is in the command class
591
if directory is None:
594
tree_to = WorkingTree.open_containing(directory)[0]
595
branch_to = tree_to.branch
596
except errors.NoWorkingTree:
598
branch_to = Branch.open_containing(directory)[0]
600
possible_transports = []
601
if location is not None:
602
mergeable, location_transport = _get_mergeable_helper(location)
603
possible_transports.append(location_transport)
605
stored_loc = branch_to.get_parent()
607
if stored_loc is None:
608
raise errors.BzrCommandError("No pull location known or"
611
display_url = urlutils.unescape_for_display(stored_loc,
614
self.outf.write("Using saved location: %s\n" % display_url)
615
location = stored_loc
616
location_transport = transport.get_transport(
617
location, possible_transports=possible_transports)
619
if mergeable is not None:
620
if revision is not None:
621
raise errors.BzrCommandError(
622
'Cannot use -r with merge directives or bundles')
623
mergeable.install_revisions(branch_to.repository)
624
base_revision_id, revision_id, verified = \
625
mergeable.get_merge_request(branch_to.repository)
626
branch_from = branch_to
628
branch_from = Branch.open_from_transport(location_transport)
630
if branch_to.get_parent() is None or remember:
631
branch_to.set_parent(branch_from.base)
633
if revision is not None:
634
if len(revision) == 1:
635
revision_id = revision[0].in_history(branch_from).rev_id
637
raise errors.BzrCommandError(
638
'bzr pull --revision takes one value.')
641
old_rh = branch_to.revision_history()
642
if tree_to is not None:
643
change_reporter = delta._ChangeReporter(
644
unversioned_filter=tree_to.is_ignored)
645
result = tree_to.pull(branch_from, overwrite, revision_id,
647
possible_transports=possible_transports)
649
result = branch_to.pull(branch_from, overwrite, revision_id)
651
result.report(self.outf)
653
new_rh = branch_to.revision_history()
654
log.show_changed_revisions(branch_to, old_rh, new_rh,
658
class cmd_push(Command):
659
"""Update a mirror of this branch.
661
The target branch will not have its working tree populated because this
662
is both expensive, and is not supported on remote file systems.
664
Some smart servers or protocols *may* put the working tree in place in
667
This command only works on branches that have not diverged. Branches are
668
considered diverged if the destination branch's most recent commit is one
669
that has not been merged (directly or indirectly) by the source branch.
671
If branches have diverged, you can use 'bzr push --overwrite' to replace
672
the other branch completely, discarding its unmerged changes.
674
If you want to ensure you have the different changes in the other branch,
675
do a merge (see bzr help merge) from the other branch, and commit that.
676
After that you will be able to do a push without '--overwrite'.
678
If there is no default push location set, the first push will set it.
679
After that, you can omit the location to use the default. To change the
680
default, use --remember. The value will only be saved if the remote
681
location can be accessed.
684
_see_also = ['pull', 'update', 'working-trees']
685
takes_options = ['remember', 'overwrite', 'verbose',
686
Option('create-prefix',
687
help='Create the path leading up to the branch '
688
'if it does not already exist.'),
690
help='Branch to push from, '
691
'rather than the one containing the working directory.',
695
Option('use-existing-dir',
696
help='By default push will fail if the target'
697
' directory exists, but does not already'
698
' have a control directory. This flag will'
699
' allow push to proceed.'),
701
takes_args = ['location?']
702
encoding_type = 'replace'
704
def run(self, location=None, remember=False, overwrite=False,
705
create_prefix=False, verbose=False,
706
use_existing_dir=False,
708
# FIXME: Way too big! Put this into a function called from the
710
if directory is None:
712
br_from = Branch.open_containing(directory)[0]
713
stored_loc = br_from.get_push_location()
715
if stored_loc is None:
716
raise errors.BzrCommandError("No push location known or specified.")
718
display_url = urlutils.unescape_for_display(stored_loc,
720
self.outf.write("Using saved location: %s\n" % display_url)
721
location = stored_loc
723
to_transport = transport.get_transport(location)
725
br_to = repository_to = dir_to = None
727
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
728
except errors.NotBranchError:
729
pass # Didn't find anything
731
# If we can open a branch, use its direct repository, otherwise see
732
# if there is a repository without a branch.
734
br_to = dir_to.open_branch()
735
except errors.NotBranchError:
736
# Didn't find a branch, can we find a repository?
738
repository_to = dir_to.find_repository()
739
except errors.NoRepositoryPresent:
742
# Found a branch, so we must have found a repository
743
repository_to = br_to.repository
748
# The destination doesn't exist; create it.
749
# XXX: Refactor the create_prefix/no_create_prefix code into a
750
# common helper function
752
def make_directory(transport):
756
def redirected(redirected_transport, e, redirection_notice):
757
return transport.get_transport(e.get_target_url())
760
to_transport = transport.do_catching_redirections(
761
make_directory, to_transport, redirected)
762
except errors.FileExists:
763
if not use_existing_dir:
764
raise errors.BzrCommandError("Target directory %s"
765
" already exists, but does not have a valid .bzr"
766
" directory. Supply --use-existing-dir to push"
767
" there anyway." % location)
768
except errors.NoSuchFile:
769
if not create_prefix:
770
raise errors.BzrCommandError("Parent directory of %s"
772
"\nYou may supply --create-prefix to create all"
773
" leading parent directories."
775
_create_prefix(to_transport)
776
except errors.TooManyRedirections:
777
raise errors.BzrCommandError("Too many redirections trying "
778
"to make %s." % location)
780
# Now the target directory exists, but doesn't have a .bzr
781
# directory. So we need to create it, along with any work to create
782
# all of the dependent branches, etc.
783
dir_to = br_from.bzrdir.clone_on_transport(to_transport,
784
revision_id=br_from.last_revision())
785
br_to = dir_to.open_branch()
786
# TODO: Some more useful message about what was copied
787
note('Created new branch.')
788
# We successfully created the target, remember it
789
if br_from.get_push_location() is None or remember:
790
br_from.set_push_location(br_to.base)
791
elif repository_to is None:
792
# we have a bzrdir but no branch or repository
793
# XXX: Figure out what to do other than complain.
794
raise errors.BzrCommandError("At %s you have a valid .bzr control"
795
" directory, but not a branch or repository. This is an"
796
" unsupported configuration. Please move the target directory"
797
" out of the way and try again."
800
# We have a repository but no branch, copy the revisions, and then
802
last_revision_id = br_from.last_revision()
803
repository_to.fetch(br_from.repository,
804
revision_id=last_revision_id)
805
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
806
note('Created new branch.')
807
if br_from.get_push_location() is None or remember:
808
br_from.set_push_location(br_to.base)
809
else: # We have a valid to branch
810
# We were able to connect to the remote location, so remember it
811
# we don't need to successfully push because of possible divergence.
812
if br_from.get_push_location() is None or remember:
813
br_from.set_push_location(br_to.base)
815
old_rh = br_to.revision_history()
818
tree_to = dir_to.open_workingtree()
819
except errors.NotLocalUrl:
820
warning("This transport does not update the working "
821
"tree of: %s. See 'bzr help working-trees' for "
822
"more information." % br_to.base)
823
push_result = br_from.push(br_to, overwrite)
824
except errors.NoWorkingTree:
825
push_result = br_from.push(br_to, overwrite)
829
push_result = br_from.push(tree_to.branch, overwrite)
833
except errors.DivergedBranches:
834
raise errors.BzrCommandError('These branches have diverged.'
835
' Try using "merge" and then "push".')
836
if push_result is not None:
837
push_result.report(self.outf)
839
new_rh = br_to.revision_history()
842
from bzrlib.log import show_changed_revisions
843
show_changed_revisions(br_to, old_rh, new_rh,
846
# we probably did a clone rather than a push, so a message was
851
class cmd_branch(Command):
852
"""Create a new copy of a branch.
854
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
855
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
856
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
857
is derived from the FROM_LOCATION by stripping a leading scheme or drive
858
identifier, if any. For example, "branch lp:foo-bar" will attempt to
861
To retrieve the branch as of a particular revision, supply the --revision
862
parameter, as in "branch foo/bar -r 5".
865
_see_also = ['checkout']
866
takes_args = ['from_location', 'to_location?']
867
takes_options = ['revision', Option('hardlink',
868
help='Hard-link working tree files where possible.')]
869
aliases = ['get', 'clone']
871
def run(self, from_location, to_location=None, revision=None,
873
from bzrlib.tag import _merge_tags_if_possible
876
elif len(revision) > 1:
877
raise errors.BzrCommandError(
878
'bzr branch --revision takes exactly 1 revision value')
880
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
884
if len(revision) == 1 and revision[0] is not None:
885
revision_id = revision[0].in_history(br_from)[1]
887
# FIXME - wt.last_revision, fallback to branch, fall back to
888
# None or perhaps NULL_REVISION to mean copy nothing
890
revision_id = br_from.last_revision()
891
if to_location is None:
892
to_location = urlutils.derive_to_location(from_location)
895
name = os.path.basename(to_location) + '\n'
897
to_transport = transport.get_transport(to_location)
899
to_transport.mkdir('.')
900
except errors.FileExists:
901
raise errors.BzrCommandError('Target directory "%s" already'
902
' exists.' % to_location)
903
except errors.NoSuchFile:
904
raise errors.BzrCommandError('Parent of "%s" does not exist.'
907
# preserve whatever source format we have.
908
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
909
possible_transports=[to_transport],
910
accelerator_tree=accelerator_tree,
912
branch = dir.open_branch()
913
except errors.NoSuchRevision:
914
to_transport.delete_tree('.')
915
msg = "The branch %s has no revision %s." % (from_location, revision[0])
916
raise errors.BzrCommandError(msg)
918
branch.control_files.put_utf8('branch-name', name)
919
_merge_tags_if_possible(br_from, branch)
920
note('Branched %d revision(s).' % branch.revno())
925
class cmd_checkout(Command):
926
"""Create a new checkout of an existing branch.
928
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
929
the branch found in '.'. This is useful if you have removed the working tree
930
or if it was never created - i.e. if you pushed the branch to its current
933
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
934
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
935
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
936
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
937
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
940
To retrieve the branch as of a particular revision, supply the --revision
941
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
942
out of date [so you cannot commit] but it may be useful (i.e. to examine old
946
_see_also = ['checkouts', 'branch']
947
takes_args = ['branch_location?', 'to_location?']
948
takes_options = ['revision',
949
Option('lightweight',
950
help="Perform a lightweight checkout. Lightweight "
951
"checkouts depend on access to the branch for "
952
"every operation. Normal checkouts can perform "
953
"common operations like diff and status without "
954
"such access, and also support local commits."
956
Option('files-from', type=str,
957
help="Get file contents from this tree."),
959
help='Hard-link working tree files where possible.'
964
def run(self, branch_location=None, to_location=None, revision=None,
965
lightweight=False, files_from=None, hardlink=False):
968
elif len(revision) > 1:
969
raise errors.BzrCommandError(
970
'bzr checkout --revision takes exactly 1 revision value')
971
if branch_location is None:
972
branch_location = osutils.getcwd()
973
to_location = branch_location
974
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
976
if files_from is not None:
977
accelerator_tree = WorkingTree.open(files_from)
978
if len(revision) == 1 and revision[0] is not None:
979
revision_id = _mod_revision.ensure_null(
980
revision[0].in_history(source)[1])
983
if to_location is None:
984
to_location = urlutils.derive_to_location(branch_location)
985
# if the source and to_location are the same,
986
# and there is no working tree,
987
# then reconstitute a branch
988
if (osutils.abspath(to_location) ==
989
osutils.abspath(branch_location)):
991
source.bzrdir.open_workingtree()
992
except errors.NoWorkingTree:
993
source.bzrdir.create_workingtree(revision_id)
995
source.create_checkout(to_location, revision_id, lightweight,
996
accelerator_tree, hardlink)
999
class cmd_renames(Command):
1000
"""Show list of renamed files.
1002
# TODO: Option to show renames between two historical versions.
1004
# TODO: Only show renames under dir, rather than in the whole branch.
1005
_see_also = ['status']
1006
takes_args = ['dir?']
1009
def run(self, dir=u'.'):
1010
tree = WorkingTree.open_containing(dir)[0]
1013
new_inv = tree.inventory
1014
old_tree = tree.basis_tree()
1015
old_tree.lock_read()
1017
old_inv = old_tree.inventory
1018
renames = list(_mod_tree.find_renames(old_inv, new_inv))
1020
for old_name, new_name in renames:
1021
self.outf.write("%s => %s\n" % (old_name, new_name))
1028
class cmd_update(Command):
1029
"""Update a tree to have the latest code committed to its branch.
1031
This will perform a merge into the working tree, and may generate
1032
conflicts. If you have any local changes, you will still
1033
need to commit them after the update for the update to be complete.
1035
If you want to discard your local changes, you can just do a
1036
'bzr revert' instead of 'bzr commit' after the update.
1039
_see_also = ['pull', 'working-trees', 'status-flags']
1040
takes_args = ['dir?']
1043
def run(self, dir='.'):
1044
tree = WorkingTree.open_containing(dir)[0]
1045
possible_transports = []
1046
master = tree.branch.get_master_branch(
1047
possible_transports=possible_transports)
1048
if master is not None:
1051
tree.lock_tree_write()
1053
existing_pending_merges = tree.get_parent_ids()[1:]
1054
last_rev = _mod_revision.ensure_null(tree.last_revision())
1055
if last_rev == _mod_revision.ensure_null(
1056
tree.branch.last_revision()):
1057
# may be up to date, check master too.
1058
if master is None or last_rev == _mod_revision.ensure_null(
1059
master.last_revision()):
1060
revno = tree.branch.revision_id_to_revno(last_rev)
1061
note("Tree is up to date at revision %d." % (revno,))
1063
conflicts = tree.update(
1064
delta._ChangeReporter(unversioned_filter=tree.is_ignored),
1065
possible_transports=possible_transports)
1066
revno = tree.branch.revision_id_to_revno(
1067
_mod_revision.ensure_null(tree.last_revision()))
1068
note('Updated to revision %d.' % (revno,))
1069
if tree.get_parent_ids()[1:] != existing_pending_merges:
1070
note('Your local commits will now show as pending merges with '
1071
"'bzr status', and can be committed with 'bzr commit'.")
1080
class cmd_info(Command):
1081
"""Show information about a working tree, branch or repository.
1083
This command will show all known locations and formats associated to the
1084
tree, branch or repository. Statistical information is included with
1087
Branches and working trees will also report any missing revisions.
1089
_see_also = ['revno', 'working-trees', 'repositories']
1090
takes_args = ['location?']
1091
takes_options = ['verbose']
1092
encoding_type = 'replace'
1095
def run(self, location=None, verbose=False):
1100
from bzrlib.info import show_bzrdir_info
1101
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1102
verbose=noise_level, outfile=self.outf)
1105
class cmd_remove(Command):
1106
"""Remove files or directories.
1108
This makes bzr stop tracking changes to the specified files and
1109
delete them if they can easily be recovered using revert.
1111
You can specify one or more files, and/or --new. If you specify --new,
1112
only 'added' files will be removed. If you specify both, then new files
1113
in the specified directories will be removed. If the directories are
1114
also new, they will also be removed.
1116
takes_args = ['file*']
1117
takes_options = ['verbose',
1118
Option('new', help='Remove newly-added files.'),
1119
RegistryOption.from_kwargs('file-deletion-strategy',
1120
'The file deletion mode to be used.',
1121
title='Deletion Strategy', value_switches=True, enum_switch=False,
1122
safe='Only delete files if they can be'
1123
' safely recovered (default).',
1124
keep="Don't delete any files.",
1125
force='Delete all the specified files, even if they can not be '
1126
'recovered and even if they are non-empty directories.')]
1128
encoding_type = 'replace'
1130
def run(self, file_list, verbose=False, new=False,
1131
file_deletion_strategy='safe'):
1132
tree, file_list = tree_files(file_list)
1134
if file_list is not None:
1135
file_list = [f for f in file_list]
1137
raise errors.BzrCommandError('Specify one or more files to'
1138
' remove, or use --new.')
1141
added = tree.changes_from(tree.basis_tree(),
1142
specific_files=file_list).added
1143
file_list = sorted([f[0] for f in added], reverse=True)
1144
if len(file_list) == 0:
1145
raise errors.BzrCommandError('No matching files.')
1146
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1147
keep_files=file_deletion_strategy=='keep',
1148
force=file_deletion_strategy=='force')
1151
class cmd_file_id(Command):
1152
"""Print file_id of a particular file or directory.
1154
The file_id is assigned when the file is first added and remains the
1155
same through all revisions where the file exists, even when it is
1160
_see_also = ['inventory', 'ls']
1161
takes_args = ['filename']
1164
def run(self, filename):
1165
tree, relpath = WorkingTree.open_containing(filename)
1166
i = tree.path2id(relpath)
1168
raise errors.NotVersionedError(filename)
1170
self.outf.write(i + '\n')
1173
class cmd_file_path(Command):
1174
"""Print path of file_ids to a file or directory.
1176
This prints one line for each directory down to the target,
1177
starting at the branch root.
1181
takes_args = ['filename']
1184
def run(self, filename):
1185
tree, relpath = WorkingTree.open_containing(filename)
1186
fid = tree.path2id(relpath)
1188
raise errors.NotVersionedError(filename)
1189
segments = osutils.splitpath(relpath)
1190
for pos in range(1, len(segments) + 1):
1191
path = osutils.joinpath(segments[:pos])
1192
self.outf.write("%s\n" % tree.path2id(path))
1195
class cmd_reconcile(Command):
1196
"""Reconcile bzr metadata in a branch.
1198
This can correct data mismatches that may have been caused by
1199
previous ghost operations or bzr upgrades. You should only
1200
need to run this command if 'bzr check' or a bzr developer
1201
advises you to run it.
1203
If a second branch is provided, cross-branch reconciliation is
1204
also attempted, which will check that data like the tree root
1205
id which was not present in very early bzr versions is represented
1206
correctly in both branches.
1208
At the same time it is run it may recompress data resulting in
1209
a potential saving in disk space or performance gain.
1211
The branch *MUST* be on a listable system such as local disk or sftp.
1214
_see_also = ['check']
1215
takes_args = ['branch?']
1217
def run(self, branch="."):
1218
from bzrlib.reconcile import reconcile
1219
dir = bzrdir.BzrDir.open(branch)
1223
class cmd_revision_history(Command):
1224
"""Display the list of revision ids on a branch."""
1227
takes_args = ['location?']
1232
def run(self, location="."):
1233
branch = Branch.open_containing(location)[0]
1234
for revid in branch.revision_history():
1235
self.outf.write(revid)
1236
self.outf.write('\n')
1239
class cmd_ancestry(Command):
1240
"""List all revisions merged into this branch."""
1242
_see_also = ['log', 'revision-history']
1243
takes_args = ['location?']
1248
def run(self, location="."):
1250
wt = WorkingTree.open_containing(location)[0]
1251
except errors.NoWorkingTree:
1252
b = Branch.open(location)
1253
last_revision = b.last_revision()
1256
last_revision = wt.last_revision()
1258
revision_ids = b.repository.get_ancestry(last_revision)
1259
assert revision_ids[0] is None
1261
for revision_id in revision_ids:
1262
self.outf.write(revision_id + '\n')
1265
class cmd_init(Command):
1266
"""Make a directory into a versioned branch.
1268
Use this to create an empty branch, or before importing an
1271
If there is a repository in a parent directory of the location, then
1272
the history of the branch will be stored in the repository. Otherwise
1273
init creates a standalone branch which carries its own history
1274
in the .bzr directory.
1276
If there is already a branch at the location but it has no working tree,
1277
the tree can be populated with 'bzr checkout'.
1279
Recipe for importing a tree of files::
1285
bzr commit -m "imported project"
1288
_see_also = ['init-repository', 'branch', 'checkout']
1289
takes_args = ['location?']
1291
Option('create-prefix',
1292
help='Create the path leading up to the branch '
1293
'if it does not already exist.'),
1294
RegistryOption('format',
1295
help='Specify a format for this branch. '
1296
'See "help formats".',
1297
registry=bzrdir.format_registry,
1298
converter=bzrdir.format_registry.make_bzrdir,
1299
value_switches=True,
1300
title="Branch Format",
1302
Option('append-revisions-only',
1303
help='Never change revnos or the existing log.'
1304
' Append revisions to it only.')
1306
def run(self, location=None, format=None, append_revisions_only=False,
1307
create_prefix=False):
1309
format = bzrdir.format_registry.make_bzrdir('default')
1310
if location is None:
1313
to_transport = transport.get_transport(location)
1315
# The path has to exist to initialize a
1316
# branch inside of it.
1317
# Just using os.mkdir, since I don't
1318
# believe that we want to create a bunch of
1319
# locations if the user supplies an extended path
1321
to_transport.ensure_base()
1322
except errors.NoSuchFile:
1323
if not create_prefix:
1324
raise errors.BzrCommandError("Parent directory of %s"
1326
"\nYou may supply --create-prefix to create all"
1327
" leading parent directories."
1329
_create_prefix(to_transport)
1332
existing_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
1333
except errors.NotBranchError:
1334
# really a NotBzrDir error...
1335
create_branch = bzrdir.BzrDir.create_branch_convenience
1336
branch = create_branch(to_transport.base, format=format,
1337
possible_transports=[to_transport])
1339
from bzrlib.transport.local import LocalTransport
1340
if existing_bzrdir.has_branch():
1341
if (isinstance(to_transport, LocalTransport)
1342
and not existing_bzrdir.has_workingtree()):
1343
raise errors.BranchExistsWithoutWorkingTree(location)
1344
raise errors.AlreadyBranchError(location)
1346
branch = existing_bzrdir.create_branch()
1347
existing_bzrdir.create_workingtree()
1348
if append_revisions_only:
1350
branch.set_append_revisions_only(True)
1351
except errors.UpgradeRequired:
1352
raise errors.BzrCommandError('This branch format cannot be set'
1353
' to append-revisions-only. Try --experimental-branch6')
1356
class cmd_init_repository(Command):
1357
"""Create a shared repository to hold branches.
1359
New branches created under the repository directory will store their
1360
revisions in the repository, not in the branch directory.
1362
If the --no-trees option is used then the branches in the repository
1363
will not have working trees by default.
1366
Create a shared repositories holding just branches::
1368
bzr init-repo --no-trees repo
1371
Make a lightweight checkout elsewhere::
1373
bzr checkout --lightweight repo/trunk trunk-checkout
1378
_see_also = ['init', 'branch', 'checkout', 'repositories']
1379
takes_args = ["location"]
1380
takes_options = [RegistryOption('format',
1381
help='Specify a format for this repository. See'
1382
' "bzr help formats" for details.',
1383
registry=bzrdir.format_registry,
1384
converter=bzrdir.format_registry.make_bzrdir,
1385
value_switches=True, title='Repository format'),
1387
help='Branches in the repository will default to'
1388
' not having a working tree.'),
1390
aliases = ["init-repo"]
1392
def run(self, location, format=None, no_trees=False):
1394
format = bzrdir.format_registry.make_bzrdir('default')
1396
if location is None:
1399
to_transport = transport.get_transport(location)
1400
to_transport.ensure_base()
1402
newdir = format.initialize_on_transport(to_transport)
1403
repo = newdir.create_repository(shared=True)
1404
repo.set_make_working_trees(not no_trees)
1407
class cmd_diff(Command):
1408
"""Show differences in the working tree, between revisions or branches.
1410
If no arguments are given, all changes for the current tree are listed.
1411
If files are given, only the changes in those files are listed.
1412
Remote and multiple branches can be compared by using the --old and
1413
--new options. If not provided, the default for both is derived from
1414
the first argument, if any, or the current tree if no arguments are
1417
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1418
produces patches suitable for "patch -p1".
1422
2 - unrepresentable changes
1427
Shows the difference in the working tree versus the last commit::
1431
Difference between the working tree and revision 1::
1435
Difference between revision 2 and revision 1::
1439
Difference between revision 2 and revision 1 for branch xxx::
1443
Show just the differences for file NEWS::
1447
Show the differences in working tree xxx for file NEWS::
1451
Show the differences from branch xxx to this working tree:
1455
Show the differences between two branches for file NEWS::
1457
bzr diff --old xxx --new yyy NEWS
1459
Same as 'bzr diff' but prefix paths with old/ and new/::
1461
bzr diff --prefix old/:new/
1463
_see_also = ['status']
1464
takes_args = ['file*']
1466
Option('diff-options', type=str,
1467
help='Pass these options to the external diff program.'),
1468
Option('prefix', type=str,
1470
help='Set prefixes added to old and new filenames, as '
1471
'two values separated by a colon. (eg "old/:new/").'),
1473
help='Branch/tree to compare from.',
1477
help='Branch/tree to compare to.',
1483
help='Use this command to compare files.',
1487
aliases = ['di', 'dif']
1488
encoding_type = 'exact'
1491
def run(self, revision=None, file_list=None, diff_options=None,
1492
prefix=None, old=None, new=None, using=None):
1493
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
1495
if (prefix is None) or (prefix == '0'):
1503
old_label, new_label = prefix.split(":")
1505
raise errors.BzrCommandError(
1506
'--prefix expects two values separated by a colon'
1507
' (eg "old/:new/")')
1509
if revision and len(revision) > 2:
1510
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1511
' one or two revision specifiers')
1513
old_tree, new_tree, specific_files, extra_trees = \
1514
_get_trees_to_diff(file_list, revision, old, new)
1515
return show_diff_trees(old_tree, new_tree, sys.stdout,
1516
specific_files=specific_files,
1517
external_diff_options=diff_options,
1518
old_label=old_label, new_label=new_label,
1519
extra_trees=extra_trees, using=using)
1522
class cmd_deleted(Command):
1523
"""List files deleted in the working tree.
1525
# TODO: Show files deleted since a previous revision, or
1526
# between two revisions.
1527
# TODO: Much more efficient way to do this: read in new
1528
# directories with readdir, rather than stating each one. Same
1529
# level of effort but possibly much less IO. (Or possibly not,
1530
# if the directories are very large...)
1531
_see_also = ['status', 'ls']
1532
takes_options = ['show-ids']
1535
def run(self, show_ids=False):
1536
tree = WorkingTree.open_containing(u'.')[0]
1539
old = tree.basis_tree()
1542
for path, ie in old.inventory.iter_entries():
1543
if not tree.has_id(ie.file_id):
1544
self.outf.write(path)
1546
self.outf.write(' ')
1547
self.outf.write(ie.file_id)
1548
self.outf.write('\n')
1555
class cmd_modified(Command):
1556
"""List files modified in working tree.
1560
_see_also = ['status', 'ls']
1564
tree = WorkingTree.open_containing(u'.')[0]
1565
td = tree.changes_from(tree.basis_tree())
1566
for path, id, kind, text_modified, meta_modified in td.modified:
1567
self.outf.write(path + '\n')
1570
class cmd_added(Command):
1571
"""List files added in working tree.
1575
_see_also = ['status', 'ls']
1579
wt = WorkingTree.open_containing(u'.')[0]
1582
basis = wt.basis_tree()
1585
basis_inv = basis.inventory
1588
if file_id in basis_inv:
1590
if inv.is_root(file_id) and len(basis_inv) == 0:
1592
path = inv.id2path(file_id)
1593
if not os.access(osutils.abspath(path), os.F_OK):
1595
self.outf.write(path + '\n')
1602
class cmd_root(Command):
1603
"""Show the tree root directory.
1605
The root is the nearest enclosing directory with a .bzr control
1608
takes_args = ['filename?']
1610
def run(self, filename=None):
1611
"""Print the branch root."""
1612
tree = WorkingTree.open_containing(filename)[0]
1613
self.outf.write(tree.basedir + '\n')
1616
def _parse_limit(limitstring):
1618
return int(limitstring)
1620
msg = "The limit argument must be an integer."
1621
raise errors.BzrCommandError(msg)
1624
class cmd_log(Command):
1625
"""Show log of a branch, file, or directory.
1627
By default show the log of the branch containing the working directory.
1629
To request a range of logs, you can use the command -r begin..end
1630
-r revision requests a specific revision, -r ..end or -r begin.. are
1634
Log the current branch::
1642
Log the last 10 revisions of a branch::
1644
bzr log -r -10.. http://server/branch
1647
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1649
takes_args = ['location?']
1652
help='Show from oldest to newest.'),
1655
help='Display timezone as local, original, or utc.'),
1656
custom_help('verbose',
1657
help='Show files changed in each revision.'),
1663
help='Show revisions whose message matches this '
1664
'regular expression.',
1668
help='Limit the output to the first N revisions.',
1672
encoding_type = 'replace'
1675
def run(self, location=None, timezone='original',
1683
from bzrlib.log import show_log
1684
assert message is None or isinstance(message, basestring), \
1685
"invalid message argument %r" % message
1686
direction = (forward and 'forward') or 'reverse'
1691
# find the file id to log:
1693
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1697
tree = b.basis_tree()
1698
file_id = tree.path2id(fp)
1700
raise errors.BzrCommandError(
1701
"Path does not have any revision history: %s" %
1705
# FIXME ? log the current subdir only RBC 20060203
1706
if revision is not None \
1707
and len(revision) > 0 and revision[0].get_branch():
1708
location = revision[0].get_branch()
1711
dir, relpath = bzrdir.BzrDir.open_containing(location)
1712
b = dir.open_branch()
1716
if revision is None:
1719
elif len(revision) == 1:
1720
rev1 = rev2 = revision[0].in_history(b)
1721
elif len(revision) == 2:
1722
if revision[1].get_branch() != revision[0].get_branch():
1723
# b is taken from revision[0].get_branch(), and
1724
# show_log will use its revision_history. Having
1725
# different branches will lead to weird behaviors.
1726
raise errors.BzrCommandError(
1727
"Log doesn't accept two revisions in different"
1729
rev1 = revision[0].in_history(b)
1730
rev2 = revision[1].in_history(b)
1732
raise errors.BzrCommandError(
1733
'bzr log --revision takes one or two values.')
1735
if log_format is None:
1736
log_format = log.log_formatter_registry.get_default(b)
1738
lf = log_format(show_ids=show_ids, to_file=self.outf,
1739
show_timezone=timezone)
1745
direction=direction,
1746
start_revision=rev1,
1754
def get_log_format(long=False, short=False, line=False, default='long'):
1755
log_format = default
1759
log_format = 'short'
1765
class cmd_touching_revisions(Command):
1766
"""Return revision-ids which affected a particular file.
1768
A more user-friendly interface is "bzr log FILE".
1772
takes_args = ["filename"]
1775
def run(self, filename):
1776
tree, relpath = WorkingTree.open_containing(filename)
1778
file_id = tree.path2id(relpath)
1779
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1780
self.outf.write("%6d %s\n" % (revno, what))
1783
class cmd_ls(Command):
1784
"""List files in a tree.
1787
_see_also = ['status', 'cat']
1788
takes_args = ['path?']
1789
# TODO: Take a revision or remote path and list that tree instead.
1793
Option('non-recursive',
1794
help='Don\'t recurse into subdirectories.'),
1796
help='Print paths relative to the root of the branch.'),
1797
Option('unknown', help='Print unknown files.'),
1798
Option('versioned', help='Print versioned files.'),
1799
Option('ignored', help='Print ignored files.'),
1801
help='Write an ascii NUL (\\0) separator '
1802
'between files rather than a newline.'),
1804
help='List entries of a particular kind: file, directory, symlink.',
1809
def run(self, revision=None, verbose=False,
1810
non_recursive=False, from_root=False,
1811
unknown=False, versioned=False, ignored=False,
1812
null=False, kind=None, show_ids=False, path=None):
1814
if kind and kind not in ('file', 'directory', 'symlink'):
1815
raise errors.BzrCommandError('invalid kind specified')
1817
if verbose and null:
1818
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1819
all = not (unknown or versioned or ignored)
1821
selection = {'I':ignored, '?':unknown, 'V':versioned}
1828
raise errors.BzrCommandError('cannot specify both --from-root'
1832
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1838
if revision is not None:
1839
tree = branch.repository.revision_tree(
1840
revision[0].in_history(branch).rev_id)
1842
tree = branch.basis_tree()
1846
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1847
if fp.startswith(relpath):
1848
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1849
if non_recursive and '/' in fp:
1851
if not all and not selection[fc]:
1853
if kind is not None and fkind != kind:
1856
kindch = entry.kind_character()
1857
outstring = '%-8s %s%s' % (fc, fp, kindch)
1858
if show_ids and fid is not None:
1859
outstring = "%-50s %s" % (outstring, fid)
1860
self.outf.write(outstring + '\n')
1862
self.outf.write(fp + '\0')
1865
self.outf.write(fid)
1866
self.outf.write('\0')
1874
self.outf.write('%-50s %s\n' % (fp, my_id))
1876
self.outf.write(fp + '\n')
1881
class cmd_unknowns(Command):
1882
"""List unknown files.
1890
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1891
self.outf.write(osutils.quotefn(f) + '\n')
1894
class cmd_ignore(Command):
1895
"""Ignore specified files or patterns.
1897
To remove patterns from the ignore list, edit the .bzrignore file.
1899
Trailing slashes on patterns are ignored.
1900
If the pattern contains a slash or is a regular expression, it is compared
1901
to the whole path from the branch root. Otherwise, it is compared to only
1902
the last component of the path. To match a file only in the root
1903
directory, prepend './'.
1905
Ignore patterns specifying absolute paths are not allowed.
1907
Ignore patterns may include globbing wildcards such as::
1909
? - Matches any single character except '/'
1910
* - Matches 0 or more characters except '/'
1911
/**/ - Matches 0 or more directories in a path
1912
[a-z] - Matches a single character from within a group of characters
1914
Ignore patterns may also be Python regular expressions.
1915
Regular expression ignore patterns are identified by a 'RE:' prefix
1916
followed by the regular expression. Regular expression ignore patterns
1917
may not include named or numbered groups.
1919
Note: ignore patterns containing shell wildcards must be quoted from
1923
Ignore the top level Makefile::
1925
bzr ignore ./Makefile
1927
Ignore class files in all directories::
1929
bzr ignore "*.class"
1931
Ignore .o files under the lib directory::
1933
bzr ignore "lib/**/*.o"
1935
Ignore .o files under the lib directory::
1937
bzr ignore "RE:lib/.*\.o"
1940
_see_also = ['status', 'ignored']
1941
takes_args = ['name_pattern*']
1943
Option('old-default-rules',
1944
help='Write out the ignore rules bzr < 0.9 always used.')
1947
def run(self, name_pattern_list=None, old_default_rules=None):
1948
from bzrlib.atomicfile import AtomicFile
1949
if old_default_rules is not None:
1950
# dump the rules and exit
1951
for pattern in ignores.OLD_DEFAULTS:
1954
if not name_pattern_list:
1955
raise errors.BzrCommandError("ignore requires at least one "
1956
"NAME_PATTERN or --old-default-rules")
1957
name_pattern_list = [globbing.normalize_pattern(p)
1958
for p in name_pattern_list]
1959
for name_pattern in name_pattern_list:
1960
if (name_pattern[0] == '/' or
1961
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1962
raise errors.BzrCommandError(
1963
"NAME_PATTERN should not be an absolute path")
1964
tree, relpath = WorkingTree.open_containing(u'.')
1965
ifn = tree.abspath('.bzrignore')
1966
if os.path.exists(ifn):
1969
igns = f.read().decode('utf-8')
1975
# TODO: If the file already uses crlf-style termination, maybe
1976
# we should use that for the newly added lines?
1978
if igns and igns[-1] != '\n':
1980
for name_pattern in name_pattern_list:
1981
igns += name_pattern + '\n'
1983
f = AtomicFile(ifn, 'wb')
1985
f.write(igns.encode('utf-8'))
1990
if not tree.path2id('.bzrignore'):
1991
tree.add(['.bzrignore'])
1993
ignored = globbing.Globster(name_pattern_list)
1996
for entry in tree.list_files():
2000
if ignored.match(filename):
2001
matches.append(filename.encode('utf-8'))
2003
if len(matches) > 0:
2004
print "Warning: the following files are version controlled and" \
2005
" match your ignore pattern:\n%s" % ("\n".join(matches),)
2007
class cmd_ignored(Command):
2008
"""List ignored files and the patterns that matched them.
2011
encoding_type = 'replace'
2012
_see_also = ['ignore']
2016
tree = WorkingTree.open_containing(u'.')[0]
2019
for path, file_class, kind, file_id, entry in tree.list_files():
2020
if file_class != 'I':
2022
## XXX: Slightly inefficient since this was already calculated
2023
pat = tree.is_ignored(path)
2024
self.outf.write('%-50s %s\n' % (path, pat))
2029
class cmd_lookup_revision(Command):
2030
"""Lookup the revision-id from a revision-number
2033
bzr lookup-revision 33
2036
takes_args = ['revno']
2039
def run(self, revno):
2043
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2045
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2048
class cmd_export(Command):
2049
"""Export current or past revision to a destination directory or archive.
2051
If no revision is specified this exports the last committed revision.
2053
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
2054
given, try to find the format with the extension. If no extension
2055
is found exports to a directory (equivalent to --format=dir).
2057
If root is supplied, it will be used as the root directory inside
2058
container formats (tar, zip, etc). If it is not supplied it will default
2059
to the exported filename. The root option has no effect for 'dir' format.
2061
If branch is omitted then the branch containing the current working
2062
directory will be used.
2064
Note: Export of tree with non-ASCII filenames to zip is not supported.
2066
================= =========================
2067
Supported formats Autodetected by extension
2068
================= =========================
2071
tbz2 .tar.bz2, .tbz2
2074
================= =========================
2076
takes_args = ['dest', 'branch?']
2079
help="Type of file to export to.",
2084
help="Name of the root directory inside the exported file."),
2086
def run(self, dest, branch=None, revision=None, format=None, root=None):
2087
from bzrlib.export import export
2090
tree = WorkingTree.open_containing(u'.')[0]
2093
b = Branch.open(branch)
2095
if revision is None:
2096
# should be tree.last_revision FIXME
2097
rev_id = b.last_revision()
2099
if len(revision) != 1:
2100
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
2101
rev_id = revision[0].in_history(b).rev_id
2102
t = b.repository.revision_tree(rev_id)
2104
export(t, dest, format, root)
2105
except errors.NoSuchExportFormat, e:
2106
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2109
class cmd_cat(Command):
2110
"""Write the contents of a file as of a given revision to standard output.
2112
If no revision is nominated, the last revision is used.
2114
Note: Take care to redirect standard output when using this command on a
2120
Option('name-from-revision', help='The path name in the old tree.'),
2123
takes_args = ['filename']
2124
encoding_type = 'exact'
2127
def run(self, filename, revision=None, name_from_revision=False):
2128
if revision is not None and len(revision) != 1:
2129
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2130
" one revision specifier")
2131
tree, branch, relpath = \
2132
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2135
return self._run(tree, branch, relpath, filename, revision,
2140
def _run(self, tree, b, relpath, filename, revision, name_from_revision):
2142
tree = b.basis_tree()
2143
if revision is None:
2144
revision_id = b.last_revision()
2146
revision_id = revision[0].in_history(b).rev_id
2148
cur_file_id = tree.path2id(relpath)
2149
rev_tree = b.repository.revision_tree(revision_id)
2150
old_file_id = rev_tree.path2id(relpath)
2152
if name_from_revision:
2153
if old_file_id is None:
2154
raise errors.BzrCommandError("%r is not present in revision %s"
2155
% (filename, revision_id))
2157
rev_tree.print_file(old_file_id)
2158
elif cur_file_id is not None:
2159
rev_tree.print_file(cur_file_id)
2160
elif old_file_id is not None:
2161
rev_tree.print_file(old_file_id)
2163
raise errors.BzrCommandError("%r is not present in revision %s" %
2164
(filename, revision_id))
2167
class cmd_local_time_offset(Command):
2168
"""Show the offset in seconds from GMT to local time."""
2172
print osutils.local_time_offset()
2176
class cmd_commit(Command):
2177
"""Commit changes into a new revision.
2179
If no arguments are given, the entire tree is committed.
2181
If selected files are specified, only changes to those files are
2182
committed. If a directory is specified then the directory and everything
2183
within it is committed.
2185
If author of the change is not the same person as the committer, you can
2186
specify the author's name using the --author option. The name should be
2187
in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
2189
A selected-file commit may fail in some cases where the committed
2190
tree would be invalid. Consider::
2195
bzr commit foo -m "committing foo"
2196
bzr mv foo/bar foo/baz
2199
bzr commit foo/bar -m "committing bar but not baz"
2201
In the example above, the last commit will fail by design. This gives
2202
the user the opportunity to decide whether they want to commit the
2203
rename at the same time, separately first, or not at all. (As a general
2204
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2206
Note: A selected-file commit after a merge is not yet supported.
2208
# TODO: Run hooks on tree to-be-committed, and after commit.
2210
# TODO: Strict commit that fails if there are deleted files.
2211
# (what does "deleted files" mean ??)
2213
# TODO: Give better message for -s, --summary, used by tla people
2215
# XXX: verbose currently does nothing
2217
_see_also = ['bugs', 'uncommit']
2218
takes_args = ['selected*']
2220
Option('message', type=unicode,
2222
help="Description of the new revision."),
2225
help='Commit even if nothing has changed.'),
2226
Option('file', type=str,
2229
help='Take commit message from this file.'),
2231
help="Refuse to commit if there are unknown "
2232
"files in the working tree."),
2233
ListOption('fixes', type=str,
2234
help="Mark a bug as being fixed by this revision."),
2235
Option('author', type=unicode,
2236
help="Set the author's name, if it's different "
2237
"from the committer."),
2239
help="Perform a local commit in a bound "
2240
"branch. Local commits are not pushed to "
2241
"the master branch until a normal commit "
2245
help='When no message is supplied, show the diff along'
2246
' with the status summary in the message editor.'),
2248
aliases = ['ci', 'checkin']
2250
def _get_bug_fix_properties(self, fixes, branch):
2252
# Configure the properties for bug fixing attributes.
2253
for fixed_bug in fixes:
2254
tokens = fixed_bug.split(':')
2255
if len(tokens) != 2:
2256
raise errors.BzrCommandError(
2257
"Invalid bug %s. Must be in the form of 'tag:id'. "
2258
"Commit refused." % fixed_bug)
2259
tag, bug_id = tokens
2261
bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
2262
except errors.UnknownBugTrackerAbbreviation:
2263
raise errors.BzrCommandError(
2264
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2265
except errors.MalformedBugIdentifier:
2266
raise errors.BzrCommandError(
2267
"Invalid bug identifier for %s. Commit refused."
2269
properties.append('%s fixed' % bug_url)
2270
return '\n'.join(properties)
2272
def run(self, message=None, file=None, verbose=False, selected_list=None,
2273
unchanged=False, strict=False, local=False, fixes=None,
2274
author=None, show_diff=False):
2275
from bzrlib.errors import (
2280
from bzrlib.msgeditor import (
2281
edit_commit_message_encoded,
2282
make_commit_message_template_encoded
2285
# TODO: Need a blackbox test for invoking the external editor; may be
2286
# slightly problematic to run this cross-platform.
2288
# TODO: do more checks that the commit will succeed before
2289
# spending the user's valuable time typing a commit message.
2293
tree, selected_list = tree_files(selected_list)
2294
if selected_list == ['']:
2295
# workaround - commit of root of tree should be exactly the same
2296
# as just default commit in that tree, and succeed even though
2297
# selected-file merge commit is not done yet
2302
bug_property = self._get_bug_fix_properties(fixes, tree.branch)
2304
properties['bugs'] = bug_property
2306
if local and not tree.branch.get_bound_location():
2307
raise errors.LocalRequiresBoundBranch()
2309
def get_message(commit_obj):
2310
"""Callback to get commit message"""
2311
my_message = message
2312
if my_message is None and not file:
2313
t = make_commit_message_template_encoded(tree,
2314
selected_list, diff=show_diff,
2315
output_encoding=bzrlib.user_encoding)
2316
my_message = edit_commit_message_encoded(t)
2317
if my_message is None:
2318
raise errors.BzrCommandError("please specify a commit"
2319
" message with either --message or --file")
2320
elif my_message and file:
2321
raise errors.BzrCommandError(
2322
"please specify either --message or --file")
2324
my_message = codecs.open(file, 'rt',
2325
bzrlib.user_encoding).read()
2326
if my_message == "":
2327
raise errors.BzrCommandError("empty commit message specified")
2331
tree.commit(message_callback=get_message,
2332
specific_files=selected_list,
2333
allow_pointless=unchanged, strict=strict, local=local,
2334
reporter=None, verbose=verbose, revprops=properties,
2336
except PointlessCommit:
2337
# FIXME: This should really happen before the file is read in;
2338
# perhaps prepare the commit; get the message; then actually commit
2339
raise errors.BzrCommandError("no changes to commit."
2340
" use --unchanged to commit anyhow")
2341
except ConflictsInTree:
2342
raise errors.BzrCommandError('Conflicts detected in working '
2343
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2345
except StrictCommitFailed:
2346
raise errors.BzrCommandError("Commit refused because there are"
2347
" unknown files in the working tree.")
2348
except errors.BoundBranchOutOfDate, e:
2349
raise errors.BzrCommandError(str(e) + "\n"
2350
'To commit to master branch, run update and then commit.\n'
2351
'You can also pass --local to commit to continue working '
2355
class cmd_check(Command):
2356
"""Validate consistency of branch history.
2358
This command checks various invariants about the branch storage to
2359
detect data corruption or bzr bugs.
2363
revisions: This is just the number of revisions checked. It doesn't
2365
versionedfiles: This is just the number of versionedfiles checked. It
2366
doesn't indicate a problem.
2367
unreferenced ancestors: Texts that are ancestors of other texts, but
2368
are not properly referenced by the revision ancestry. This is a
2369
subtle problem that Bazaar can work around.
2370
unique file texts: This is the total number of unique file contents
2371
seen in the checked revisions. It does not indicate a problem.
2372
repeated file texts: This is the total number of repeated texts seen
2373
in the checked revisions. Texts can be repeated when their file
2374
entries are modified, but the file contents are not. It does not
2378
_see_also = ['reconcile']
2379
takes_args = ['branch?']
2380
takes_options = ['verbose']
2382
def run(self, branch=None, verbose=False):
2383
from bzrlib.check import check
2385
branch_obj = Branch.open_containing('.')[0]
2387
branch_obj = Branch.open(branch)
2388
check(branch_obj, verbose)
2389
# bit hacky, check the tree parent is accurate
2392
tree = WorkingTree.open_containing('.')[0]
2394
tree = WorkingTree.open(branch)
2395
except (errors.NoWorkingTree, errors.NotLocalUrl):
2398
# This is a primitive 'check' for tree state. Currently this is not
2399
# integrated into the main check logic as yet.
2402
tree_basis = tree.basis_tree()
2403
tree_basis.lock_read()
2405
repo_basis = tree.branch.repository.revision_tree(
2406
tree.last_revision())
2407
if len(list(repo_basis._iter_changes(tree_basis))):
2408
raise errors.BzrCheckError(
2409
"Mismatched basis inventory content.")
2417
class cmd_upgrade(Command):
2418
"""Upgrade branch storage to current format.
2420
The check command or bzr developers may sometimes advise you to run
2421
this command. When the default format has changed you may also be warned
2422
during other operations to upgrade.
2425
_see_also = ['check']
2426
takes_args = ['url?']
2428
RegistryOption('format',
2429
help='Upgrade to a specific format. See "bzr help'
2430
' formats" for details.',
2431
registry=bzrdir.format_registry,
2432
converter=bzrdir.format_registry.make_bzrdir,
2433
value_switches=True, title='Branch format'),
2436
def run(self, url='.', format=None):
2437
from bzrlib.upgrade import upgrade
2439
format = bzrdir.format_registry.make_bzrdir('default')
2440
upgrade(url, format)
2443
class cmd_whoami(Command):
2444
"""Show or set bzr user id.
2447
Show the email of the current user::
2451
Set the current user::
2453
bzr whoami "Frank Chu <fchu@example.com>"
2455
takes_options = [ Option('email',
2456
help='Display email address only.'),
2458
help='Set identity for the current branch instead of '
2461
takes_args = ['name?']
2462
encoding_type = 'replace'
2465
def run(self, email=False, branch=False, name=None):
2467
# use branch if we're inside one; otherwise global config
2469
c = Branch.open_containing('.')[0].get_config()
2470
except errors.NotBranchError:
2471
c = config.GlobalConfig()
2473
self.outf.write(c.user_email() + '\n')
2475
self.outf.write(c.username() + '\n')
2478
# display a warning if an email address isn't included in the given name.
2480
config.extract_email_address(name)
2481
except errors.NoEmailInUsername, e:
2482
warning('"%s" does not seem to contain an email address. '
2483
'This is allowed, but not recommended.', name)
2485
# use global config unless --branch given
2487
c = Branch.open_containing('.')[0].get_config()
2489
c = config.GlobalConfig()
2490
c.set_user_option('email', name)
2493
class cmd_nick(Command):
2494
"""Print or set the branch nickname.
2496
If unset, the tree root directory name is used as the nickname
2497
To print the current nickname, execute with no argument.
2500
_see_also = ['info']
2501
takes_args = ['nickname?']
2502
def run(self, nickname=None):
2503
branch = Branch.open_containing(u'.')[0]
2504
if nickname is None:
2505
self.printme(branch)
2507
branch.nick = nickname
2510
def printme(self, branch):
2514
class cmd_selftest(Command):
2515
"""Run internal test suite.
2517
If arguments are given, they are regular expressions that say which tests
2518
should run. Tests matching any expression are run, and other tests are
2521
Alternatively if --first is given, matching tests are run first and then
2522
all other tests are run. This is useful if you have been working in a
2523
particular area, but want to make sure nothing else was broken.
2525
If --exclude is given, tests that match that regular expression are
2526
excluded, regardless of whether they match --first or not.
2528
To help catch accidential dependencies between tests, the --randomize
2529
option is useful. In most cases, the argument used is the word 'now'.
2530
Note that the seed used for the random number generator is displayed
2531
when this option is used. The seed can be explicitly passed as the
2532
argument to this option if required. This enables reproduction of the
2533
actual ordering used if and when an order sensitive problem is encountered.
2535
If --list-only is given, the tests that would be run are listed. This is
2536
useful when combined with --first, --exclude and/or --randomize to
2537
understand their impact. The test harness reports "Listed nn tests in ..."
2538
instead of "Ran nn tests in ..." when list mode is enabled.
2540
If the global option '--no-plugins' is given, plugins are not loaded
2541
before running the selftests. This has two effects: features provided or
2542
modified by plugins will not be tested, and tests provided by plugins will
2545
Tests that need working space on disk use a common temporary directory,
2546
typically inside $TMPDIR or /tmp.
2549
Run only tests relating to 'ignore'::
2553
Disable plugins and list tests as they're run::
2555
bzr --no-plugins selftest -v
2557
# NB: this is used from the class without creating an instance, which is
2558
# why it does not have a self parameter.
2559
def get_transport_type(typestring):
2560
"""Parse and return a transport specifier."""
2561
if typestring == "sftp":
2562
from bzrlib.transport.sftp import SFTPAbsoluteServer
2563
return SFTPAbsoluteServer
2564
if typestring == "memory":
2565
from bzrlib.transport.memory import MemoryServer
2567
if typestring == "fakenfs":
2568
from bzrlib.transport.fakenfs import FakeNFSServer
2569
return FakeNFSServer
2570
msg = "No known transport type %s. Supported types are: sftp\n" %\
2572
raise errors.BzrCommandError(msg)
2575
takes_args = ['testspecs*']
2576
takes_options = ['verbose',
2578
help='Stop when one test fails.',
2582
help='Use a different transport by default '
2583
'throughout the test suite.',
2584
type=get_transport_type),
2586
help='Run the benchmarks rather than selftests.'),
2587
Option('lsprof-timed',
2588
help='Generate lsprof output for benchmarked'
2589
' sections of code.'),
2590
Option('cache-dir', type=str,
2591
help='Cache intermediate benchmark output in this '
2594
help='Run all tests, but run specified tests first.',
2598
help='List the tests instead of running them.'),
2599
Option('randomize', type=str, argname="SEED",
2600
help='Randomize the order of tests using the given'
2601
' seed or "now" for the current time.'),
2602
Option('exclude', type=str, argname="PATTERN",
2604
help='Exclude tests that match this regular'
2606
Option('strict', help='Fail on missing dependencies or '
2608
Option('load-list', type=str, argname='TESTLISTFILE',
2609
help='Load a test id list from a text file.'),
2611
encoding_type = 'replace'
2613
def run(self, testspecs_list=None, verbose=False, one=False,
2614
transport=None, benchmark=None,
2615
lsprof_timed=None, cache_dir=None,
2616
first=False, list_only=False,
2617
randomize=None, exclude=None, strict=False,
2620
from bzrlib.tests import selftest
2621
import bzrlib.benchmarks as benchmarks
2622
from bzrlib.benchmarks import tree_creator
2624
if cache_dir is not None:
2625
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2627
print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
2628
print ' %s (%s python%s)' % (
2630
bzrlib.version_string,
2631
'.'.join(map(str, sys.version_info)),
2634
if testspecs_list is not None:
2635
pattern = '|'.join(testspecs_list)
2639
test_suite_factory = benchmarks.test_suite
2640
# Unless user explicitly asks for quiet, be verbose in benchmarks
2641
verbose = not is_quiet()
2642
# TODO: should possibly lock the history file...
2643
benchfile = open(".perf_history", "at", buffering=1)
2645
test_suite_factory = None
2648
result = selftest(verbose=verbose,
2650
stop_on_failure=one,
2651
transport=transport,
2652
test_suite_factory=test_suite_factory,
2653
lsprof_timed=lsprof_timed,
2654
bench_history=benchfile,
2655
matching_tests_first=first,
2656
list_only=list_only,
2657
random_seed=randomize,
2658
exclude_pattern=exclude,
2660
load_list=load_list,
2663
if benchfile is not None:
2666
note('tests passed')
2668
note('tests failed')
2669
return int(not result)
2672
class cmd_version(Command):
2673
"""Show version of bzr."""
2675
encoding_type = 'replace'
2679
from bzrlib.version import show_version
2680
show_version(to_file=self.outf)
2683
class cmd_rocks(Command):
2684
"""Statement of optimism."""
2690
print "It sure does!"
2693
class cmd_find_merge_base(Command):
2694
"""Find and print a base revision for merging two branches."""
2695
# TODO: Options to specify revisions on either side, as if
2696
# merging only part of the history.
2697
takes_args = ['branch', 'other']
2701
def run(self, branch, other):
2702
from bzrlib.revision import ensure_null
2704
branch1 = Branch.open_containing(branch)[0]
2705
branch2 = Branch.open_containing(other)[0]
2710
last1 = ensure_null(branch1.last_revision())
2711
last2 = ensure_null(branch2.last_revision())
2713
graph = branch1.repository.get_graph(branch2.repository)
2714
base_rev_id = graph.find_unique_lca(last1, last2)
2716
print 'merge base is revision %s' % base_rev_id
2723
class cmd_merge(Command):
2724
"""Perform a three-way merge.
2726
The branch is the branch you will merge from. By default, it will merge
2727
the latest revision. If you specify a revision, that revision will be
2728
merged. If you specify two revisions, the first will be used as a BASE,
2729
and the second one as OTHER. Revision numbers are always relative to the
2732
By default, bzr will try to merge in all new work from the other
2733
branch, automatically determining an appropriate base. If this
2734
fails, you may need to give an explicit base.
2736
Merge will do its best to combine the changes in two branches, but there
2737
are some kinds of problems only a human can fix. When it encounters those,
2738
it will mark a conflict. A conflict means that you need to fix something,
2739
before you should commit.
2741
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2743
If there is no default branch set, the first merge will set it. After
2744
that, you can omit the branch to use the default. To change the
2745
default, use --remember. The value will only be saved if the remote
2746
location can be accessed.
2748
The results of the merge are placed into the destination working
2749
directory, where they can be reviewed (with bzr diff), tested, and then
2750
committed to record the result of the merge.
2752
merge refuses to run if there are any uncommitted changes, unless
2756
To merge the latest revision from bzr.dev::
2758
bzr merge ../bzr.dev
2760
To merge changes up to and including revision 82 from bzr.dev::
2762
bzr merge -r 82 ../bzr.dev
2764
To merge the changes introduced by 82, without previous changes::
2766
bzr merge -r 81..82 ../bzr.dev
2769
encoding_type = 'exact'
2770
_see_also = ['update', 'remerge', 'status-flags']
2771
takes_args = ['branch?']
2776
help='Merge even if the destination tree has uncommitted changes.'),
2780
Option('show-base', help="Show base revision text in "
2782
Option('uncommitted', help='Apply uncommitted changes'
2783
' from a working copy, instead of branch changes.'),
2784
Option('pull', help='If the destination is already'
2785
' completely merged into the source, pull from the'
2786
' source rather than merging. When this happens,'
2787
' you do not need to commit the result.'),
2789
help='Branch to merge into, '
2790
'rather than the one containing the working directory.',
2794
Option('preview', help='Instead of merging, show a diff of the merge.')
2797
def run(self, branch=None, revision=None, force=False, merge_type=None,
2798
show_base=False, reprocess=False, remember=False,
2799
uncommitted=False, pull=False,
2803
# This is actually a branch (or merge-directive) *location*.
2807
if merge_type is None:
2808
merge_type = _mod_merge.Merge3Merger
2810
if directory is None: directory = u'.'
2811
possible_transports = []
2813
allow_pending = True
2814
verified = 'inapplicable'
2815
tree = WorkingTree.open_containing(directory)[0]
2816
change_reporter = delta._ChangeReporter(
2817
unversioned_filter=tree.is_ignored)
2820
pb = ui.ui_factory.nested_progress_bar()
2821
cleanups.append(pb.finished)
2823
cleanups.append(tree.unlock)
2824
if location is not None:
2825
mergeable, other_transport = _get_mergeable_helper(location)
2828
raise errors.BzrCommandError('Cannot use --uncommitted'
2829
' with bundles or merge directives.')
2831
if revision is not None:
2832
raise errors.BzrCommandError(
2833
'Cannot use -r with merge directives or bundles')
2834
merger, verified = _mod_merge.Merger.from_mergeable(tree,
2836
possible_transports.append(other_transport)
2838
if merger is None and uncommitted:
2839
if revision is not None and len(revision) > 0:
2840
raise errors.BzrCommandError('Cannot use --uncommitted and'
2841
' --revision at the same time.')
2842
location = self._select_branch_location(tree, location)[0]
2843
other_tree, other_path = WorkingTree.open_containing(location)
2844
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
2846
allow_pending = False
2847
if other_path != '':
2848
merger.interesting_files = [other_path]
2851
merger, allow_pending = self._get_merger_from_branch(tree,
2852
location, revision, remember, possible_transports, pb)
2854
merger.merge_type = merge_type
2855
merger.reprocess = reprocess
2856
merger.show_base = show_base
2857
self.sanity_check_merger(merger)
2858
if (merger.base_rev_id == merger.other_rev_id and
2859
merger.other_rev_id != None):
2860
note('Nothing to do.')
2863
if merger.interesting_files is not None:
2864
raise errors.BzrCommandError('Cannot pull individual files')
2865
if (merger.base_rev_id == tree.last_revision()):
2866
result = tree.pull(merger.other_branch, False,
2867
merger.other_rev_id)
2868
result.report(self.outf)
2870
merger.check_basis(not force)
2872
return self._do_preview(merger)
2874
return self._do_merge(merger, change_reporter, allow_pending,
2877
for cleanup in reversed(cleanups):
2880
def _do_preview(self, merger):
2881
from bzrlib.diff import show_diff_trees
2882
tree_merger = merger.make_merger()
2883
tt = tree_merger.make_preview_transform()
2885
result_tree = tt.get_preview_tree()
2886
show_diff_trees(merger.this_tree, result_tree, self.outf,
2887
old_label='', new_label='')
2891
def _do_merge(self, merger, change_reporter, allow_pending, verified):
2892
merger.change_reporter = change_reporter
2893
conflict_count = merger.do_merge()
2895
merger.set_pending()
2896
if verified == 'failed':
2897
warning('Preview patch does not match changes')
2898
if conflict_count != 0:
2903
def sanity_check_merger(self, merger):
2904
if (merger.show_base and
2905
not merger.merge_type is _mod_merge.Merge3Merger):
2906
raise errors.BzrCommandError("Show-base is not supported for this"
2907
" merge type. %s" % merger.merge_type)
2908
if merger.reprocess and not merger.merge_type.supports_reprocess:
2909
raise errors.BzrCommandError("Conflict reduction is not supported"
2910
" for merge type %s." %
2912
if merger.reprocess and merger.show_base:
2913
raise errors.BzrCommandError("Cannot do conflict reduction and"
2916
def _get_merger_from_branch(self, tree, location, revision, remember,
2917
possible_transports, pb):
2918
"""Produce a merger from a location, assuming it refers to a branch."""
2919
from bzrlib.tag import _merge_tags_if_possible
2920
assert revision is None or len(revision) < 3
2921
# find the branch locations
2922
other_loc, user_location = self._select_branch_location(tree, location,
2924
if revision is not None and len(revision) == 2:
2925
base_loc, _unused = self._select_branch_location(tree,
2926
location, revision, 0)
2928
base_loc = other_loc
2930
other_branch, other_path = Branch.open_containing(other_loc,
2931
possible_transports)
2932
if base_loc == other_loc:
2933
base_branch = other_branch
2935
base_branch, base_path = Branch.open_containing(base_loc,
2936
possible_transports)
2937
# Find the revision ids
2938
if revision is None or len(revision) < 1 or revision[-1] is None:
2939
other_revision_id = _mod_revision.ensure_null(
2940
other_branch.last_revision())
2942
other_revision_id = \
2943
_mod_revision.ensure_null(
2944
revision[-1].in_history(other_branch).rev_id)
2945
if (revision is not None and len(revision) == 2
2946
and revision[0] is not None):
2947
base_revision_id = \
2948
_mod_revision.ensure_null(
2949
revision[0].in_history(base_branch).rev_id)
2951
base_revision_id = None
2952
# Remember where we merge from
2953
if ((remember or tree.branch.get_submit_branch() is None) and
2954
user_location is not None):
2955
tree.branch.set_submit_branch(other_branch.base)
2956
_merge_tags_if_possible(other_branch, tree.branch)
2957
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
2958
other_revision_id, base_revision_id, other_branch, base_branch)
2959
if other_path != '':
2960
allow_pending = False
2961
merger.interesting_files = [other_path]
2963
allow_pending = True
2964
return merger, allow_pending
2966
def _select_branch_location(self, tree, user_location, revision=None,
2968
"""Select a branch location, according to possible inputs.
2970
If provided, branches from ``revision`` are preferred. (Both
2971
``revision`` and ``index`` must be supplied.)
2973
Otherwise, the ``location`` parameter is used. If it is None, then the
2974
``submit`` or ``parent`` location is used, and a note is printed.
2976
:param tree: The working tree to select a branch for merging into
2977
:param location: The location entered by the user
2978
:param revision: The revision parameter to the command
2979
:param index: The index to use for the revision parameter. Negative
2980
indices are permitted.
2981
:return: (selected_location, user_location). The default location
2982
will be the user-entered location.
2984
if (revision is not None and index is not None
2985
and revision[index] is not None):
2986
branch = revision[index].get_branch()
2987
if branch is not None:
2988
return branch, branch
2989
if user_location is None:
2990
location = self._get_remembered(tree, 'Merging from')
2992
location = user_location
2993
return location, user_location
2995
def _get_remembered(self, tree, verb_string):
2996
"""Use tree.branch's parent if none was supplied.
2998
Report if the remembered location was used.
3000
stored_location = tree.branch.get_submit_branch()
3001
if stored_location is None:
3002
stored_location = tree.branch.get_parent()
3003
mutter("%s", stored_location)
3004
if stored_location is None:
3005
raise errors.BzrCommandError("No location specified or remembered")
3006
display_url = urlutils.unescape_for_display(stored_location,
3008
self.outf.write("%s remembered location %s\n" % (verb_string,
3010
return stored_location
3013
class cmd_remerge(Command):
3016
Use this if you want to try a different merge technique while resolving
3017
conflicts. Some merge techniques are better than others, and remerge
3018
lets you try different ones on different files.
3020
The options for remerge have the same meaning and defaults as the ones for
3021
merge. The difference is that remerge can (only) be run when there is a
3022
pending merge, and it lets you specify particular files.
3025
Re-do the merge of all conflicted files, and show the base text in
3026
conflict regions, in addition to the usual THIS and OTHER texts::
3028
bzr remerge --show-base
3030
Re-do the merge of "foobar", using the weave merge algorithm, with
3031
additional processing to reduce the size of conflict regions::
3033
bzr remerge --merge-type weave --reprocess foobar
3035
takes_args = ['file*']
3040
help="Show base revision text in conflicts."),
3043
def run(self, file_list=None, merge_type=None, show_base=False,
3045
if merge_type is None:
3046
merge_type = _mod_merge.Merge3Merger
3047
tree, file_list = tree_files(file_list)
3050
parents = tree.get_parent_ids()
3051
if len(parents) != 2:
3052
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3053
" merges. Not cherrypicking or"
3055
repository = tree.branch.repository
3056
interesting_ids = None
3058
conflicts = tree.conflicts()
3059
if file_list is not None:
3060
interesting_ids = set()
3061
for filename in file_list:
3062
file_id = tree.path2id(filename)
3064
raise errors.NotVersionedError(filename)
3065
interesting_ids.add(file_id)
3066
if tree.kind(file_id) != "directory":
3069
for name, ie in tree.inventory.iter_entries(file_id):
3070
interesting_ids.add(ie.file_id)
3071
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3073
# Remerge only supports resolving contents conflicts
3074
allowed_conflicts = ('text conflict', 'contents conflict')
3075
restore_files = [c.path for c in conflicts
3076
if c.typestring in allowed_conflicts]
3077
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3078
tree.set_conflicts(ConflictList(new_conflicts))
3079
if file_list is not None:
3080
restore_files = file_list
3081
for filename in restore_files:
3083
restore(tree.abspath(filename))
3084
except errors.NotConflicted:
3086
# Disable pending merges, because the file texts we are remerging
3087
# have not had those merges performed. If we use the wrong parents
3088
# list, we imply that the working tree text has seen and rejected
3089
# all the changes from the other tree, when in fact those changes
3090
# have not yet been seen.
3091
pb = ui.ui_factory.nested_progress_bar()
3092
tree.set_parent_ids(parents[:1])
3094
merger = _mod_merge.Merger.from_revision_ids(pb,
3096
merger.interesting_ids = interesting_ids
3097
merger.merge_type = merge_type
3098
merger.show_base = show_base
3099
merger.reprocess = reprocess
3100
conflicts = merger.do_merge()
3102
tree.set_parent_ids(parents)
3112
class cmd_revert(Command):
3113
"""Revert files to a previous revision.
3115
Giving a list of files will revert only those files. Otherwise, all files
3116
will be reverted. If the revision is not specified with '--revision', the
3117
last committed revision is used.
3119
To remove only some changes, without reverting to a prior version, use
3120
merge instead. For example, "merge . --revision -2..-3" will remove the
3121
changes introduced by -2, without affecting the changes introduced by -1.
3122
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
3124
By default, any files that have been manually changed will be backed up
3125
first. (Files changed only by merge are not backed up.) Backup files have
3126
'.~#~' appended to their name, where # is a number.
3128
When you provide files, you can use their current pathname or the pathname
3129
from the target revision. So you can use revert to "undelete" a file by
3130
name. If you name a directory, all the contents of that directory will be
3133
Any files that have been newly added since that revision will be deleted,
3134
with a backup kept if appropriate. Directories containing unknown files
3135
will not be deleted.
3137
The working tree contains a list of pending merged revisions, which will
3138
be included as parents in the next commit. Normally, revert clears that
3139
list as well as reverting the files. If any files are specified, revert
3140
leaves the pending merge list alone and reverts only the files. Use "bzr
3141
revert ." in the tree root to revert all files but keep the merge record,
3142
and "bzr revert --forget-merges" to clear the pending merge list without
3143
reverting any files.
3146
_see_also = ['cat', 'export']
3149
Option('no-backup', "Do not save backups of reverted files."),
3150
Option('forget-merges',
3151
'Remove pending merge marker, without changing any files.'),
3153
takes_args = ['file*']
3155
def run(self, revision=None, no_backup=False, file_list=None,
3156
forget_merges=None):
3157
tree, file_list = tree_files(file_list)
3159
tree.set_parent_ids(tree.get_parent_ids()[:1])
3161
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
3164
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
3165
if revision is None:
3166
rev_id = tree.last_revision()
3167
elif len(revision) != 1:
3168
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
3170
rev_id = revision[0].in_history(tree.branch).rev_id
3171
pb = ui.ui_factory.nested_progress_bar()
3173
tree.revert(file_list,
3174
tree.branch.repository.revision_tree(rev_id),
3175
not no_backup, pb, report_changes=True)
3180
class cmd_assert_fail(Command):
3181
"""Test reporting of assertion failures"""
3182
# intended just for use in testing
3187
raise AssertionError("always fails")
3190
class cmd_help(Command):
3191
"""Show help on a command or other topic.
3194
_see_also = ['topics']
3196
Option('long', 'Show help on all commands.'),
3198
takes_args = ['topic?']
3199
aliases = ['?', '--help', '-?', '-h']
3202
def run(self, topic=None, long=False):
3204
if topic is None and long:
3206
bzrlib.help.help(topic)
3209
class cmd_shell_complete(Command):
3210
"""Show appropriate completions for context.
3212
For a list of all available commands, say 'bzr shell-complete'.
3214
takes_args = ['context?']
3219
def run(self, context=None):
3220
import shellcomplete
3221
shellcomplete.shellcomplete(context)
3224
class cmd_fetch(Command):
3225
"""Copy in history from another branch but don't merge it.
3227
This is an internal method used for pull and merge.
3230
takes_args = ['from_branch', 'to_branch']
3231
def run(self, from_branch, to_branch):
3232
from bzrlib.fetch import Fetcher
3233
from_b = Branch.open(from_branch)
3234
to_b = Branch.open(to_branch)
3235
Fetcher(to_b, from_b)
3238
class cmd_missing(Command):
3239
"""Show unmerged/unpulled revisions between two branches.
3241
OTHER_BRANCH may be local or remote.
3244
_see_also = ['merge', 'pull']
3245
takes_args = ['other_branch?']
3247
Option('reverse', 'Reverse the order of revisions.'),
3249
'Display changes in the local branch only.'),
3250
Option('this' , 'Same as --mine-only.'),
3251
Option('theirs-only',
3252
'Display changes in the remote branch only.'),
3253
Option('other', 'Same as --theirs-only.'),
3258
encoding_type = 'replace'
3261
def run(self, other_branch=None, reverse=False, mine_only=False,
3262
theirs_only=False, log_format=None, long=False, short=False, line=False,
3263
show_ids=False, verbose=False, this=False, other=False):
3264
from bzrlib.missing import find_unmerged, iter_log_revisions
3271
local_branch = Branch.open_containing(u".")[0]
3272
parent = local_branch.get_parent()
3273
if other_branch is None:
3274
other_branch = parent
3275
if other_branch is None:
3276
raise errors.BzrCommandError("No peer location known"
3278
display_url = urlutils.unescape_for_display(parent,
3280
self.outf.write("Using last location: " + display_url + "\n")
3282
remote_branch = Branch.open(other_branch)
3283
if remote_branch.base == local_branch.base:
3284
remote_branch = local_branch
3285
local_branch.lock_read()
3287
remote_branch.lock_read()
3289
local_extra, remote_extra = find_unmerged(local_branch,
3291
if log_format is None:
3292
registry = log.log_formatter_registry
3293
log_format = registry.get_default(local_branch)
3294
lf = log_format(to_file=self.outf,
3296
show_timezone='original')
3297
if reverse is False:
3298
local_extra.reverse()
3299
remote_extra.reverse()
3300
if local_extra and not theirs_only:
3301
self.outf.write("You have %d extra revision(s):\n" %
3303
for revision in iter_log_revisions(local_extra,
3304
local_branch.repository,
3306
lf.log_revision(revision)
3307
printed_local = True
3309
printed_local = False
3310
if remote_extra and not mine_only:
3311
if printed_local is True:
3312
self.outf.write("\n\n\n")
3313
self.outf.write("You are missing %d revision(s):\n" %
3315
for revision in iter_log_revisions(remote_extra,
3316
remote_branch.repository,
3318
lf.log_revision(revision)
3319
if not remote_extra and not local_extra:
3321
self.outf.write("Branches are up to date.\n")
3325
remote_branch.unlock()
3327
local_branch.unlock()
3328
if not status_code and parent is None and other_branch is not None:
3329
local_branch.lock_write()
3331
# handle race conditions - a parent might be set while we run.
3332
if local_branch.get_parent() is None:
3333
local_branch.set_parent(remote_branch.base)
3335
local_branch.unlock()
3339
class cmd_pack(Command):
3340
"""Compress the data within a repository."""
3342
_see_also = ['repositories']
3343
takes_args = ['branch_or_repo?']
3345
def run(self, branch_or_repo='.'):
3346
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
3348
branch = dir.open_branch()
3349
repository = branch.repository
3350
except errors.NotBranchError:
3351
repository = dir.open_repository()
3355
class cmd_plugins(Command):
3356
"""List the installed plugins.
3358
This command displays the list of installed plugins including
3359
version of plugin and a short description of each.
3361
--verbose shows the path where each plugin is located.
3363
A plugin is an external component for Bazaar that extends the
3364
revision control system, by adding or replacing code in Bazaar.
3365
Plugins can do a variety of things, including overriding commands,
3366
adding new commands, providing additional network transports and
3367
customizing log output.
3369
See the Bazaar web site, http://bazaar-vcs.org, for further
3370
information on plugins including where to find them and how to
3371
install them. Instructions are also provided there on how to
3372
write new plugins using the Python programming language.
3374
takes_options = ['verbose']
3377
def run(self, verbose=False):
3378
import bzrlib.plugin
3379
from inspect import getdoc
3381
for name, plugin in bzrlib.plugin.plugins().items():
3382
version = plugin.__version__
3383
if version == 'unknown':
3385
name_ver = '%s %s' % (name, version)
3386
d = getdoc(plugin.module)
3388
doc = d.split('\n')[0]
3390
doc = '(no description)'
3391
result.append((name_ver, doc, plugin.path()))
3392
for name_ver, doc, path in sorted(result):
3400
class cmd_testament(Command):
3401
"""Show testament (signing-form) of a revision."""
3404
Option('long', help='Produce long-format testament.'),
3406
help='Produce a strict-format testament.')]
3407
takes_args = ['branch?']
3409
def run(self, branch=u'.', revision=None, long=False, strict=False):
3410
from bzrlib.testament import Testament, StrictTestament
3412
testament_class = StrictTestament
3414
testament_class = Testament
3415
b = WorkingTree.open_containing(branch)[0].branch
3418
if revision is None:
3419
rev_id = b.last_revision()
3421
rev_id = revision[0].in_history(b).rev_id
3422
t = testament_class.from_revision(b.repository, rev_id)
3424
sys.stdout.writelines(t.as_text_lines())
3426
sys.stdout.write(t.as_short_text())
3431
class cmd_annotate(Command):
3432
"""Show the origin of each line in a file.
3434
This prints out the given file with an annotation on the left side
3435
indicating which revision, author and date introduced the change.
3437
If the origin is the same for a run of consecutive lines, it is
3438
shown only at the top, unless the --all option is given.
3440
# TODO: annotate directories; showing when each file was last changed
3441
# TODO: if the working copy is modified, show annotations on that
3442
# with new uncommitted lines marked
3443
aliases = ['ann', 'blame', 'praise']
3444
takes_args = ['filename']
3445
takes_options = [Option('all', help='Show annotations on all lines.'),
3446
Option('long', help='Show commit date in annotations.'),
3450
encoding_type = 'exact'
3453
def run(self, filename, all=False, long=False, revision=None,
3455
from bzrlib.annotate import annotate_file
3456
wt, branch, relpath = \
3457
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
3463
if revision is None:
3464
revision_id = branch.last_revision()
3465
elif len(revision) != 1:
3466
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
3468
revision_id = revision[0].in_history(branch).rev_id
3469
tree = branch.repository.revision_tree(revision_id)
3471
file_id = wt.path2id(relpath)
3473
file_id = tree.path2id(relpath)
3475
raise errors.NotVersionedError(filename)
3476
file_version = tree.inventory[file_id].revision
3477
annotate_file(branch, file_version, file_id, long, all, self.outf,
3486
class cmd_re_sign(Command):
3487
"""Create a digital signature for an existing revision."""
3488
# TODO be able to replace existing ones.
3490
hidden = True # is this right ?
3491
takes_args = ['revision_id*']
3492
takes_options = ['revision']
3494
def run(self, revision_id_list=None, revision=None):
3495
if revision_id_list is not None and revision is not None:
3496
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3497
if revision_id_list is None and revision is None:
3498
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3499
b = WorkingTree.open_containing(u'.')[0].branch
3502
return self._run(b, revision_id_list, revision)
3506
def _run(self, b, revision_id_list, revision):
3507
import bzrlib.gpg as gpg
3508
gpg_strategy = gpg.GPGStrategy(b.get_config())
3509
if revision_id_list is not None:
3510
b.repository.start_write_group()
3512
for revision_id in revision_id_list:
3513
b.repository.sign_revision(revision_id, gpg_strategy)
3515
b.repository.abort_write_group()
3518
b.repository.commit_write_group()
3519
elif revision is not None:
3520
if len(revision) == 1:
3521
revno, rev_id = revision[0].in_history(b)
3522
b.repository.start_write_group()
3524
b.repository.sign_revision(rev_id, gpg_strategy)
3526
b.repository.abort_write_group()
3529
b.repository.commit_write_group()
3530
elif len(revision) == 2:
3531
# are they both on rh- if so we can walk between them
3532
# might be nice to have a range helper for arbitrary
3533
# revision paths. hmm.
3534
from_revno, from_revid = revision[0].in_history(b)
3535
to_revno, to_revid = revision[1].in_history(b)
3536
if to_revid is None:
3537
to_revno = b.revno()
3538
if from_revno is None or to_revno is None:
3539
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3540
b.repository.start_write_group()
3542
for revno in range(from_revno, to_revno + 1):
3543
b.repository.sign_revision(b.get_rev_id(revno),
3546
b.repository.abort_write_group()
3549
b.repository.commit_write_group()
3551
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3554
class cmd_bind(Command):
3555
"""Convert the current branch into a checkout of the supplied branch.
3557
Once converted into a checkout, commits must succeed on the master branch
3558
before they will be applied to the local branch.
3561
_see_also = ['checkouts', 'unbind']
3562
takes_args = ['location?']
3565
def run(self, location=None):
3566
b, relpath = Branch.open_containing(u'.')
3567
if location is None:
3569
location = b.get_old_bound_location()
3570
except errors.UpgradeRequired:
3571
raise errors.BzrCommandError('No location supplied. '
3572
'This format does not remember old locations.')
3574
if location is None:
3575
raise errors.BzrCommandError('No location supplied and no '
3576
'previous location known')
3577
b_other = Branch.open(location)
3580
except errors.DivergedBranches:
3581
raise errors.BzrCommandError('These branches have diverged.'
3582
' Try merging, and then bind again.')
3585
class cmd_unbind(Command):
3586
"""Convert the current checkout into a regular branch.
3588
After unbinding, the local branch is considered independent and subsequent
3589
commits will be local only.
3592
_see_also = ['checkouts', 'bind']
3597
b, relpath = Branch.open_containing(u'.')
3599
raise errors.BzrCommandError('Local branch is not bound')
3602
class cmd_uncommit(Command):
3603
"""Remove the last committed revision.
3605
--verbose will print out what is being removed.
3606
--dry-run will go through all the motions, but not actually
3609
If --revision is specified, uncommit revisions to leave the branch at the
3610
specified revision. For example, "bzr uncommit -r 15" will leave the
3611
branch at revision 15.
3613
In the future, uncommit will create a revision bundle, which can then
3617
# TODO: jam 20060108 Add an option to allow uncommit to remove
3618
# unreferenced information in 'branch-as-repository' branches.
3619
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3620
# information in shared branches as well.
3621
_see_also = ['commit']
3622
takes_options = ['verbose', 'revision',
3623
Option('dry-run', help='Don\'t actually make changes.'),
3624
Option('force', help='Say yes to all questions.')]
3625
takes_args = ['location?']
3627
encoding_type = 'replace'
3629
def run(self, location=None,
3630
dry_run=False, verbose=False,
3631
revision=None, force=False):
3632
if location is None:
3634
control, relpath = bzrdir.BzrDir.open_containing(location)
3636
tree = control.open_workingtree()
3638
except (errors.NoWorkingTree, errors.NotLocalUrl):
3640
b = control.open_branch()
3642
if tree is not None:
3647
return self._run(b, tree, dry_run, verbose, revision, force)
3649
if tree is not None:
3654
def _run(self, b, tree, dry_run, verbose, revision, force):
3655
from bzrlib.log import log_formatter, show_log
3656
from bzrlib.uncommit import uncommit
3658
last_revno, last_rev_id = b.last_revision_info()
3661
if revision is None:
3663
rev_id = last_rev_id
3665
# 'bzr uncommit -r 10' actually means uncommit
3666
# so that the final tree is at revno 10.
3667
# but bzrlib.uncommit.uncommit() actually uncommits
3668
# the revisions that are supplied.
3669
# So we need to offset it by one
3670
revno = revision[0].in_history(b).revno + 1
3671
if revno <= last_revno:
3672
rev_id = b.get_rev_id(revno)
3674
if rev_id is None or _mod_revision.is_null(rev_id):
3675
self.outf.write('No revisions to uncommit.\n')
3678
lf = log_formatter('short',
3680
show_timezone='original')
3685
direction='forward',
3686
start_revision=revno,
3687
end_revision=last_revno)
3690
print 'Dry-run, pretending to remove the above revisions.'
3692
val = raw_input('Press <enter> to continue')
3694
print 'The above revision(s) will be removed.'
3696
val = raw_input('Are you sure [y/N]? ')
3697
if val.lower() not in ('y', 'yes'):
3701
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3705
class cmd_break_lock(Command):
3706
"""Break a dead lock on a repository, branch or working directory.
3708
CAUTION: Locks should only be broken when you are sure that the process
3709
holding the lock has been stopped.
3711
You can get information on what locks are open via the 'bzr info' command.
3716
takes_args = ['location?']
3718
def run(self, location=None, show=False):
3719
if location is None:
3721
control, relpath = bzrdir.BzrDir.open_containing(location)
3723
control.break_lock()
3724
except NotImplementedError:
3728
class cmd_wait_until_signalled(Command):
3729
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3731
This just prints a line to signal when it is ready, then blocks on stdin.
3737
sys.stdout.write("running\n")
3739
sys.stdin.readline()
3742
class cmd_serve(Command):
3743
"""Run the bzr server."""
3745
aliases = ['server']
3749
help='Serve on stdin/out for use from inetd or sshd.'),
3751
help='Listen for connections on nominated port of the form '
3752
'[hostname:]portnumber. Passing 0 as the port number will '
3753
'result in a dynamically allocated port. The default port is '
3757
help='Serve contents of this directory.',
3759
Option('allow-writes',
3760
help='By default the server is a readonly server. Supplying '
3761
'--allow-writes enables write access to the contents of '
3762
'the served directory and below.'
3766
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3767
from bzrlib import lockdir
3768
from bzrlib.smart import medium, server
3769
from bzrlib.transport import get_transport
3770
from bzrlib.transport.chroot import ChrootServer
3771
if directory is None:
3772
directory = os.getcwd()
3773
url = urlutils.local_path_to_url(directory)
3774
if not allow_writes:
3775
url = 'readonly+' + url
3776
chroot_server = ChrootServer(get_transport(url))
3777
chroot_server.setUp()
3778
t = get_transport(chroot_server.get_url())
3780
smart_server = medium.SmartServerPipeStreamMedium(
3781
sys.stdin, sys.stdout, t)
3783
host = medium.BZR_DEFAULT_INTERFACE
3785
port = medium.BZR_DEFAULT_PORT
3788
host, port = port.split(':')
3790
smart_server = server.SmartTCPServer(t, host=host, port=port)
3791
print 'listening on port: ', smart_server.port
3793
# for the duration of this server, no UI output is permitted.
3794
# note that this may cause problems with blackbox tests. This should
3795
# be changed with care though, as we dont want to use bandwidth sending
3796
# progress over stderr to smart server clients!
3797
old_factory = ui.ui_factory
3798
old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
3800
ui.ui_factory = ui.SilentUIFactory()
3801
lockdir._DEFAULT_TIMEOUT_SECONDS = 0
3802
smart_server.serve()
3804
ui.ui_factory = old_factory
3805
lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
3808
class cmd_join(Command):
3809
"""Combine a subtree into its containing tree.
3811
This command is for experimental use only. It requires the target tree
3812
to be in dirstate-with-subtree format, which cannot be converted into
3815
The TREE argument should be an independent tree, inside another tree, but
3816
not part of it. (Such trees can be produced by "bzr split", but also by
3817
running "bzr branch" with the target inside a tree.)
3819
The result is a combined tree, with the subtree no longer an independant
3820
part. This is marked as a merge of the subtree into the containing tree,
3821
and all history is preserved.
3823
If --reference is specified, the subtree retains its independence. It can
3824
be branched by itself, and can be part of multiple projects at the same
3825
time. But operations performed in the containing tree, such as commit
3826
and merge, will recurse into the subtree.
3829
_see_also = ['split']
3830
takes_args = ['tree']
3832
Option('reference', help='Join by reference.'),
3836
def run(self, tree, reference=False):
3837
sub_tree = WorkingTree.open(tree)
3838
parent_dir = osutils.dirname(sub_tree.basedir)
3839
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3840
repo = containing_tree.branch.repository
3841
if not repo.supports_rich_root():
3842
raise errors.BzrCommandError(
3843
"Can't join trees because %s doesn't support rich root data.\n"
3844
"You can use bzr upgrade on the repository."
3848
containing_tree.add_reference(sub_tree)
3849
except errors.BadReferenceTarget, e:
3850
# XXX: Would be better to just raise a nicely printable
3851
# exception from the real origin. Also below. mbp 20070306
3852
raise errors.BzrCommandError("Cannot join %s. %s" %
3856
containing_tree.subsume(sub_tree)
3857
except errors.BadSubsumeSource, e:
3858
raise errors.BzrCommandError("Cannot join %s. %s" %
3862
class cmd_split(Command):
3863
"""Split a subdirectory of a tree into a separate tree.
3865
This command will produce a target tree in a format that supports
3866
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
3867
converted into earlier formats like 'dirstate-tags'.
3869
The TREE argument should be a subdirectory of a working tree. That
3870
subdirectory will be converted into an independent tree, with its own
3871
branch. Commits in the top-level tree will not apply to the new subtree.
3874
# join is not un-hidden yet
3875
#_see_also = ['join']
3876
takes_args = ['tree']
3878
def run(self, tree):
3879
containing_tree, subdir = WorkingTree.open_containing(tree)
3880
sub_id = containing_tree.path2id(subdir)
3882
raise errors.NotVersionedError(subdir)
3884
containing_tree.extract(sub_id)
3885
except errors.RootNotRich:
3886
raise errors.UpgradeRequired(containing_tree.branch.base)
3889
class cmd_merge_directive(Command):
3890
"""Generate a merge directive for auto-merge tools.
3892
A directive requests a merge to be performed, and also provides all the
3893
information necessary to do so. This means it must either include a
3894
revision bundle, or the location of a branch containing the desired
3897
A submit branch (the location to merge into) must be supplied the first
3898
time the command is issued. After it has been supplied once, it will
3899
be remembered as the default.
3901
A public branch is optional if a revision bundle is supplied, but required
3902
if --diff or --plain is specified. It will be remembered as the default
3903
after the first use.
3906
takes_args = ['submit_branch?', 'public_branch?']
3910
_see_also = ['send']
3913
RegistryOption.from_kwargs('patch-type',
3914
'The type of patch to include in the directive.',
3916
value_switches=True,
3918
bundle='Bazaar revision bundle (default).',
3919
diff='Normal unified diff.',
3920
plain='No patch, just directive.'),
3921
Option('sign', help='GPG-sign the directive.'), 'revision',
3922
Option('mail-to', type=str,
3923
help='Instead of printing the directive, email to this address.'),
3924
Option('message', type=str, short_name='m',
3925
help='Message to use when committing this merge.')
3928
encoding_type = 'exact'
3930
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3931
sign=False, revision=None, mail_to=None, message=None):
3932
from bzrlib.revision import ensure_null, NULL_REVISION
3933
include_patch, include_bundle = {
3934
'plain': (False, False),
3935
'diff': (True, False),
3936
'bundle': (True, True),
3938
branch = Branch.open('.')
3939
stored_submit_branch = branch.get_submit_branch()
3940
if submit_branch is None:
3941
submit_branch = stored_submit_branch
3943
if stored_submit_branch is None:
3944
branch.set_submit_branch(submit_branch)
3945
if submit_branch is None:
3946
submit_branch = branch.get_parent()
3947
if submit_branch is None:
3948
raise errors.BzrCommandError('No submit branch specified or known')
3950
stored_public_branch = branch.get_public_branch()
3951
if public_branch is None:
3952
public_branch = stored_public_branch
3953
elif stored_public_branch is None:
3954
branch.set_public_branch(public_branch)
3955
if not include_bundle and public_branch is None:
3956
raise errors.BzrCommandError('No public branch specified or'
3958
base_revision_id = None
3959
if revision is not None:
3960
if len(revision) > 2:
3961
raise errors.BzrCommandError('bzr merge-directive takes '
3962
'at most two one revision identifiers')
3963
revision_id = revision[-1].in_history(branch).rev_id
3964
if len(revision) == 2:
3965
base_revision_id = revision[0].in_history(branch).rev_id
3966
base_revision_id = ensure_null(base_revision_id)
3968
revision_id = branch.last_revision()
3969
revision_id = ensure_null(revision_id)
3970
if revision_id == NULL_REVISION:
3971
raise errors.BzrCommandError('No revisions to bundle.')
3972
directive = merge_directive.MergeDirective2.from_objects(
3973
branch.repository, revision_id, time.time(),
3974
osutils.local_time_offset(), submit_branch,
3975
public_branch=public_branch, include_patch=include_patch,
3976
include_bundle=include_bundle, message=message,
3977
base_revision_id=base_revision_id)
3980
self.outf.write(directive.to_signed(branch))
3982
self.outf.writelines(directive.to_lines())
3984
message = directive.to_email(mail_to, branch, sign)
3985
s = SMTPConnection(branch.get_config())
3986
s.send_email(message)
3989
class cmd_send(Command):
3990
"""Mail or create a merge-directive for submiting changes.
3992
A merge directive provides many things needed for requesting merges:
3994
* A machine-readable description of the merge to perform
3996
* An optional patch that is a preview of the changes requested
3998
* An optional bundle of revision data, so that the changes can be applied
3999
directly from the merge directive, without retrieving data from a
4002
If --no-bundle is specified, then public_branch is needed (and must be
4003
up-to-date), so that the receiver can perform the merge using the
4004
public_branch. The public_branch is always included if known, so that
4005
people can check it later.
4007
The submit branch defaults to the parent, but can be overridden. Both
4008
submit branch and public branch will be remembered if supplied.
4010
If a public_branch is known for the submit_branch, that public submit
4011
branch is used in the merge instructions. This means that a local mirror
4012
can be used as your actual submit branch, once you have set public_branch
4015
Mail is sent using your preferred mail program. This should be transparent
4016
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
4017
If the preferred client can't be found (or used), your editor will be used.
4019
To use a specific mail program, set the mail_client configuration option.
4020
(For Thunderbird 1.5, this works around some bugs.) Supported values for
4021
specific clients are "evolution", "kmail", "mutt", and "thunderbird";
4022
generic options are "default", "editor", "mapi", and "xdg-email".
4024
If mail is being sent, a to address is required. This can be supplied
4025
either on the commandline, or by setting the submit_to configuration
4028
Two formats are currently supported: "4" uses revision bundle format 4 and
4029
merge directive format 2. It is significantly faster and smaller than
4030
older formats. It is compatible with Bazaar 0.19 and later. It is the
4031
default. "0.9" uses revision bundle format 0.9 and merge directive
4032
format 1. It is compatible with Bazaar 0.12 - 0.18.
4035
encoding_type = 'exact'
4037
_see_also = ['merge']
4039
takes_args = ['submit_branch?', 'public_branch?']
4043
help='Do not include a bundle in the merge directive.'),
4044
Option('no-patch', help='Do not include a preview patch in the merge'
4047
help='Remember submit and public branch.'),
4049
help='Branch to generate the submission from, '
4050
'rather than the one containing the working directory.',
4053
Option('output', short_name='o', help='Write directive to this file.',
4055
Option('mail-to', help='Mail the request to this address.',
4059
RegistryOption.from_kwargs('format',
4060
'Use the specified output format.',
4061
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4062
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4065
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4066
no_patch=False, revision=None, remember=False, output=None,
4067
format='4', mail_to=None, message=None, **kwargs):
4068
return self._run(submit_branch, revision, public_branch, remember,
4069
format, no_bundle, no_patch, output,
4070
kwargs.get('from', '.'), mail_to, message)
4072
def _run(self, submit_branch, revision, public_branch, remember, format,
4073
no_bundle, no_patch, output, from_, mail_to, message):
4074
from bzrlib.revision import NULL_REVISION
4075
branch = Branch.open_containing(from_)[0]
4077
outfile = StringIO()
4081
outfile = open(output, 'wb')
4082
# we may need to write data into branch's repository to calculate
4087
config = branch.get_config()
4089
mail_to = config.get_user_option('submit_to')
4090
mail_client = config.get_mail_client()
4091
if remember and submit_branch is None:
4092
raise errors.BzrCommandError(
4093
'--remember requires a branch to be specified.')
4094
stored_submit_branch = branch.get_submit_branch()
4095
remembered_submit_branch = False
4096
if submit_branch is None:
4097
submit_branch = stored_submit_branch
4098
remembered_submit_branch = True
4100
if stored_submit_branch is None or remember:
4101
branch.set_submit_branch(submit_branch)
4102
if submit_branch is None:
4103
submit_branch = branch.get_parent()
4104
remembered_submit_branch = True
4105
if submit_branch is None:
4106
raise errors.BzrCommandError('No submit branch known or'
4108
if remembered_submit_branch:
4109
note('Using saved location: %s', submit_branch)
4111
stored_public_branch = branch.get_public_branch()
4112
if public_branch is None:
4113
public_branch = stored_public_branch
4114
elif stored_public_branch is None or remember:
4115
branch.set_public_branch(public_branch)
4116
if no_bundle and public_branch is None:
4117
raise errors.BzrCommandError('No public branch specified or'
4119
base_revision_id = None
4121
if revision is not None:
4122
if len(revision) > 2:
4123
raise errors.BzrCommandError('bzr send takes '
4124
'at most two one revision identifiers')
4125
revision_id = revision[-1].in_history(branch).rev_id
4126
if len(revision) == 2:
4127
base_revision_id = revision[0].in_history(branch).rev_id
4128
if revision_id is None:
4129
revision_id = branch.last_revision()
4130
if revision_id == NULL_REVISION:
4131
raise errors.BzrCommandError('No revisions to submit.')
4133
directive = merge_directive.MergeDirective2.from_objects(
4134
branch.repository, revision_id, time.time(),
4135
osutils.local_time_offset(), submit_branch,
4136
public_branch=public_branch, include_patch=not no_patch,
4137
include_bundle=not no_bundle, message=message,
4138
base_revision_id=base_revision_id)
4139
elif format == '0.9':
4142
patch_type = 'bundle'
4144
raise errors.BzrCommandError('Format 0.9 does not'
4145
' permit bundle with no patch')
4151
directive = merge_directive.MergeDirective.from_objects(
4152
branch.repository, revision_id, time.time(),
4153
osutils.local_time_offset(), submit_branch,
4154
public_branch=public_branch, patch_type=patch_type,
4157
outfile.writelines(directive.to_lines())
4159
subject = '[MERGE] '
4160
if message is not None:
4163
revision = branch.repository.get_revision(revision_id)
4164
subject += revision.get_summary()
4165
mail_client.compose_merge_request(mail_to, subject,
4173
class cmd_bundle_revisions(cmd_send):
4175
"""Create a merge-directive for submiting changes.
4177
A merge directive provides many things needed for requesting merges:
4179
* A machine-readable description of the merge to perform
4181
* An optional patch that is a preview of the changes requested
4183
* An optional bundle of revision data, so that the changes can be applied
4184
directly from the merge directive, without retrieving data from a
4187
If --no-bundle is specified, then public_branch is needed (and must be
4188
up-to-date), so that the receiver can perform the merge using the
4189
public_branch. The public_branch is always included if known, so that
4190
people can check it later.
4192
The submit branch defaults to the parent, but can be overridden. Both
4193
submit branch and public branch will be remembered if supplied.
4195
If a public_branch is known for the submit_branch, that public submit
4196
branch is used in the merge instructions. This means that a local mirror
4197
can be used as your actual submit branch, once you have set public_branch
4200
Two formats are currently supported: "4" uses revision bundle format 4 and
4201
merge directive format 2. It is significantly faster and smaller than
4202
older formats. It is compatible with Bazaar 0.19 and later. It is the
4203
default. "0.9" uses revision bundle format 0.9 and merge directive
4204
format 1. It is compatible with Bazaar 0.12 - 0.18.
4209
help='Do not include a bundle in the merge directive.'),
4210
Option('no-patch', help='Do not include a preview patch in the merge'
4213
help='Remember submit and public branch.'),
4215
help='Branch to generate the submission from, '
4216
'rather than the one containing the working directory.',
4219
Option('output', short_name='o', help='Write directive to this file.',
4222
RegistryOption.from_kwargs('format',
4223
'Use the specified output format.',
4224
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4225
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4227
aliases = ['bundle']
4229
_see_also = ['send', 'merge']
4233
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4234
no_patch=False, revision=None, remember=False, output=None,
4235
format='4', **kwargs):
4238
return self._run(submit_branch, revision, public_branch, remember,
4239
format, no_bundle, no_patch, output,
4240
kwargs.get('from', '.'), None, None)
4243
class cmd_tag(Command):
4244
"""Create, remove or modify a tag naming a revision.
4246
Tags give human-meaningful names to revisions. Commands that take a -r
4247
(--revision) option can be given -rtag:X, where X is any previously
4250
Tags are stored in the branch. Tags are copied from one branch to another
4251
along when you branch, push, pull or merge.
4253
It is an error to give a tag name that already exists unless you pass
4254
--force, in which case the tag is moved to point to the new revision.
4257
_see_also = ['commit', 'tags']
4258
takes_args = ['tag_name']
4261
help='Delete this tag rather than placing it.',
4264
help='Branch in which to place the tag.',
4269
help='Replace existing tags.',
4274
def run(self, tag_name,
4280
branch, relpath = Branch.open_containing(directory)
4284
branch.tags.delete_tag(tag_name)
4285
self.outf.write('Deleted tag %s.\n' % tag_name)
4288
if len(revision) != 1:
4289
raise errors.BzrCommandError(
4290
"Tags can only be placed on a single revision, "
4292
revision_id = revision[0].in_history(branch).rev_id
4294
revision_id = branch.last_revision()
4295
if (not force) and branch.tags.has_tag(tag_name):
4296
raise errors.TagAlreadyExists(tag_name)
4297
branch.tags.set_tag(tag_name, revision_id)
4298
self.outf.write('Created tag %s.\n' % tag_name)
4303
class cmd_tags(Command):
4306
This command shows a table of tag names and the revisions they reference.
4312
help='Branch whose tags should be displayed.',
4316
RegistryOption.from_kwargs('sort',
4317
'Sort tags by different criteria.', title='Sorting',
4318
alpha='Sort tags lexicographically (default).',
4319
time='Sort tags chronologically.',
4330
branch, relpath = Branch.open_containing(directory)
4331
tags = branch.tags.get_tag_dict().items()
4334
elif sort == 'time':
4336
for tag, revid in tags:
4338
revobj = branch.repository.get_revision(revid)
4339
except errors.NoSuchRevision:
4340
timestamp = sys.maxint # place them at the end
4342
timestamp = revobj.timestamp
4343
timestamps[revid] = timestamp
4344
tags.sort(key=lambda x: timestamps[x[1]])
4346
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
4347
revno_map = branch.get_revision_id_to_revno_map()
4348
tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
4349
for tag, revid in tags ]
4350
for tag, revspec in tags:
4351
self.outf.write('%-20s %s\n' % (tag, revspec))
4354
class cmd_reconfigure(Command):
4355
"""Reconfigure the type of a bzr directory.
4357
A target configuration must be specified.
4359
For checkouts, the bind-to location will be auto-detected if not specified.
4360
The order of preference is
4361
1. For a lightweight checkout, the current bound location.
4362
2. For branches that used to be checkouts, the previously-bound location.
4363
3. The push location.
4364
4. The parent location.
4365
If none of these is available, --bind-to must be specified.
4368
takes_args = ['location?']
4369
takes_options = [RegistryOption.from_kwargs('target_type',
4370
title='Target type',
4371
help='The type to reconfigure the directory to.',
4372
value_switches=True, enum_switch=False,
4373
branch='Reconfigure to a branch.',
4374
tree='Reconfigure to a tree.',
4375
checkout='Reconfigure to a checkout.',
4376
lightweight_checkout='Reconfigure to a lightweight'
4378
Option('bind-to', help='Branch to bind checkout to.',
4381
help='Perform reconfiguration even if local changes'
4385
def run(self, location=None, target_type=None, bind_to=None, force=False):
4386
directory = bzrdir.BzrDir.open(location)
4387
if target_type is None:
4388
raise errors.BzrCommandError('No target configuration specified')
4389
elif target_type == 'branch':
4390
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
4391
elif target_type == 'tree':
4392
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
4393
elif target_type == 'checkout':
4394
reconfiguration = reconfigure.Reconfigure.to_checkout(directory,
4396
elif target_type == 'lightweight-checkout':
4397
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
4399
reconfiguration.apply(force)
4402
class cmd_switch(Command):
4403
"""Set the branch of a checkout and update.
4405
For lightweight checkouts, this changes the branch being referenced.
4406
For heavyweight checkouts, this checks that there are no local commits
4407
versus the current bound branch, then it makes the local branch a mirror
4408
of the new location and binds to it.
4410
In both cases, the working tree is updated and uncommitted changes
4411
are merged. The user can commit or revert these as they desire.
4413
Pending merges need to be committed or reverted before using switch.
4416
takes_args = ['to_location']
4417
takes_options = [Option('force',
4418
help='Switch even if local commits will be lost.')
4421
def run(self, to_location, force=False):
4422
from bzrlib import switch
4423
to_branch = Branch.open(to_location)
4425
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
4426
switch.switch(control_dir, to_branch, force)
4427
note('Switched to branch: %s',
4428
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
4431
def _create_prefix(cur_transport):
4432
needed = [cur_transport]
4433
# Recurse upwards until we can create a directory successfully
4435
new_transport = cur_transport.clone('..')
4436
if new_transport.base == cur_transport.base:
4437
raise errors.BzrCommandError(
4438
"Failed to create path prefix for %s."
4439
% cur_transport.base)
4441
new_transport.mkdir('.')
4442
except errors.NoSuchFile:
4443
needed.append(new_transport)
4444
cur_transport = new_transport
4447
# Now we only need to create child directories
4449
cur_transport = needed.pop()
4450
cur_transport.ensure_base()
4453
def _get_mergeable_helper(location):
4454
"""Get a merge directive or bundle if 'location' points to one.
4456
Try try to identify a bundle and returns its mergeable form. If it's not,
4457
we return the tried transport anyway so that it can reused to access the
4460
:param location: can point to a bundle or a branch.
4462
:return: mergeable, transport
4465
url = urlutils.normalize_url(location)
4466
url, filename = urlutils.split(url, exclude_trailing_slash=False)
4467
location_transport = transport.get_transport(url)
4470
# There may be redirections but we ignore the intermediate
4471
# and final transports used
4472
read = bundle.read_mergeable_from_transport
4473
mergeable, t = read(location_transport, filename)
4474
except errors.NotABundle:
4475
# Continue on considering this url a Branch but adjust the
4476
# location_transport
4477
location_transport = location_transport.clone(filename)
4478
return mergeable, location_transport
4481
# these get imported and then picked up by the scan for cmd_*
4482
# TODO: Some more consistent way to split command definitions across files;
4483
# we do need to load at least some information about them to know of
4484
# aliases. ideally we would avoid loading the implementation until the
4485
# details were needed.
4486
from bzrlib.cmd_version_info import cmd_version_info
4487
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
4488
from bzrlib.bundle.commands import (
4491
from bzrlib.sign_my_commits import cmd_sign_my_commits
4492
from bzrlib.weave_commands import cmd_versionedfile_list, cmd_weave_join, \
4493
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
