1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
1
# Copyright (C) 2004, 2005 by Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""builtin bzr commands"""
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
47
25
from bzrlib.branch import Branch
48
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
49
from bzrlib.conflicts import ConflictList
50
from bzrlib.revision import common_ancestor
51
from bzrlib.revisionspec import RevisionSpec
52
from bzrlib.workingtree import WorkingTree
55
from bzrlib.commands import Command, display_command
56
from bzrlib.option import Option, RegistryOption
57
from bzrlib.progress import DummyProgress, ProgressPhase
58
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
61
def tree_files(file_list, default_branch=u'.'):
63
return internal_tree_files(file_list, default_branch)
64
except errors.FileInWrongBranch, e:
65
raise errors.BzrCommandError("%s is not in the same branch as %s" %
66
(e.path, file_list[0]))
69
# XXX: Bad function name; should possibly also be a class method of
70
# WorkingTree rather than a function.
71
def internal_tree_files(file_list, default_branch=u'.'):
72
"""Convert command-line paths to a WorkingTree and relative paths.
74
This is typically used for command-line processors that take one or
75
more filenames, and infer the workingtree that contains them.
77
The filenames given are not required to exist.
79
:param file_list: Filenames to convert.
81
:param default_branch: Fallback tree path to use if file_list is empty or
84
:return: workingtree, [relative_paths]
86
if file_list is None or len(file_list) == 0:
87
return WorkingTree.open_containing(default_branch)[0], file_list
88
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
90
for filename in file_list:
92
new_list.append(tree.relpath(osutils.dereference_path(filename)))
93
except errors.PathNotChild:
94
raise errors.FileInWrongBranch(tree.branch, filename)
98
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
99
def get_format_type(typestring):
100
"""Parse and return a format specifier."""
101
# Have to use BzrDirMetaFormat1 directly, so that
102
# RepositoryFormat.set_default_format works
103
if typestring == "default":
104
return bzrdir.BzrDirMetaFormat1()
106
return bzrdir.format_registry.make_bzrdir(typestring)
108
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
109
raise errors.BzrCommandError(msg)
112
# TODO: Make sure no commands unconditionally use the working directory as a
113
# branch. If a filename argument is used, the first of them should be used to
114
# specify the branch. (Perhaps this can be factored out into some kind of
115
# Argument class, representing a file in a branch, where the first occurrence
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
118
30
class cmd_status(Command):
119
31
"""Display status summary.
380
193
This is equivalent to creating the directory and then adding it.
383
195
takes_args = ['dir+']
384
encoding_type = 'replace'
386
197
def run(self, dir_list):
387
200
for d in dir_list:
389
wt, dd = WorkingTree.open_containing(d)
391
self.outf.write('added %s\n' % d)
203
b = Branch.open_containing(d)
394
208
class cmd_relpath(Command):
395
209
"""Show path of a file relative to root"""
397
210
takes_args = ['filename']
401
213
def run(self, filename):
402
# TODO: jam 20050106 Can relpath return a munged path if
403
# sys.stdout encoding cannot represent it?
404
tree, relpath = WorkingTree.open_containing(filename)
405
self.outf.write(relpath)
406
self.outf.write('\n')
214
print Branch.open_containing(filename).relpath(filename)
409
218
class cmd_inventory(Command):
410
"""Show inventory of the current working copy or a revision.
412
It is possible to limit the output to a particular entry
413
type using the --kind option. For example: --kind file.
415
It is also possible to restrict the list of files to a specific
416
set. For example: bzr inventory --show-ids this/file
423
takes_options = ['revision', 'show-ids', 'kind']
425
takes_args = ['file*']
428
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
429
if kind and kind not in ['file', 'directory', 'symlink']:
430
raise errors.BzrCommandError('invalid kind specified')
432
work_tree, file_list = tree_files(file_list)
434
if revision is not None:
219
"""Show inventory of the current working copy or a revision."""
220
takes_options = ['revision', 'show-ids']
222
def run(self, revision=None, show_ids=False):
223
b = Branch.open_containing('.')
225
inv = b.read_working_inventory()
435
227
if len(revision) > 1:
436
raise errors.BzrCommandError('bzr inventory --revision takes'
437
' exactly one revision identifier')
438
revision_id = revision[0].in_history(work_tree.branch).rev_id
439
tree = work_tree.branch.repository.revision_tree(revision_id)
441
# We include work_tree as well as 'tree' here
442
# So that doing '-r 10 path/foo' will lookup whatever file
443
# exists now at 'path/foo' even if it has been renamed, as
444
# well as whatever files existed in revision 10 at path/foo
445
trees = [tree, work_tree]
450
if file_list is not None:
451
file_ids = _mod_tree.find_ids_across_trees(file_list, trees,
452
require_versioned=True)
453
# find_ids_across_trees may include some paths that don't
455
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
456
for file_id in file_ids if file_id in tree)
458
entries = tree.inventory.entries()
460
for path, entry in entries:
461
if kind and kind != entry.kind:
228
raise BzrCommandError('bzr inventory --revision takes'
229
' exactly one revision identifier')
230
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
232
for path, entry in inv.entries():
464
self.outf.write('%-50s %s\n' % (path, entry.file_id))
234
print '%-50s %s' % (path, entry.file_id)
466
self.outf.write(path)
467
self.outf.write('\n')
239
class cmd_move(Command):
240
"""Move files to a different directory.
245
The destination must be a versioned directory in the same branch.
247
takes_args = ['source$', 'dest']
248
def run(self, source_list, dest):
249
b = Branch.open_containing('.')
251
# TODO: glob expansion on windows?
252
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
255
class cmd_rename(Command):
256
"""Change the name of an entry.
259
bzr rename frob.c frobber.c
260
bzr rename src/frob.c lib/frob.c
262
It is an error if the destination name exists.
264
See also the 'move' command, which moves files into a different
265
directory without changing their name.
267
TODO: Some way to rename multiple files without invoking bzr for each
269
takes_args = ['from_name', 'to_name']
271
def run(self, from_name, to_name):
272
b = Branch.open_containing('.')
273
b.rename_one(b.relpath(from_name), b.relpath(to_name))
470
277
class cmd_mv(Command):
477
284
If the last argument is a versioned directory, all the other names
478
285
are moved into it. Otherwise, there must be exactly two arguments
479
and the file is changed to a new name.
481
If OLDNAME does not exist on the filesystem but is versioned and
482
NEWNAME does exist on the filesystem but is not versioned, mv
483
assumes that the file has been manually moved and only updates
484
its internal inventory to reflect that change.
485
The same is valid when moving many SOURCE files to a DESTINATION.
286
and the file is changed to a new name, which must not already exist.
487
288
Files cannot be moved between branches.
490
290
takes_args = ['names*']
491
takes_options = [Option("after", help="move only the bzr identifier"
492
" of the file (file has already been moved). Use this flag if"
493
" bzr is not able to detect this itself.")]
494
aliases = ['move', 'rename']
495
encoding_type = 'replace'
497
def run(self, names_list, after=False):
498
if names_list is None:
291
def run(self, names_list):
501
292
if len(names_list) < 2:
502
raise errors.BzrCommandError("missing file argument")
503
tree, rel_names = tree_files(names_list)
293
raise BzrCommandError("missing file argument")
294
b = Branch.open_containing(names_list[0])
296
rel_names = [b.relpath(x) for x in names_list]
505
298
if os.path.isdir(names_list[-1]):
506
299
# move into existing directory
507
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
508
self.outf.write("%s => %s\n" % pair)
300
for pair in b.move(rel_names[:-1], rel_names[-1]):
301
print "%s => %s" % pair
510
303
if len(names_list) != 2:
511
raise errors.BzrCommandError('to mv multiple files the'
512
' destination must be a versioned'
514
tree.rename_one(rel_names[0], rel_names[1], after=after)
515
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
304
raise BzrCommandError('to mv multiple files the destination '
305
'must be a versioned directory')
306
b.rename_one(rel_names[0], rel_names[1])
307
print "%s => %s" % (rel_names[0], rel_names[1])
518
312
class cmd_pull(Command):
519
"""Turn this branch into a mirror of another branch.
521
This command only works on branches that have not diverged. Branches are
522
considered diverged if the destination branch's most recent commit is one
523
that has not been merged (directly or indirectly) into the parent.
525
If branches have diverged, you can use 'bzr merge' to integrate the changes
526
from one into the other. Once one branch has merged, the other should
527
be able to pull it again.
529
If you want to forget your local changes and just update your branch to
530
match the remote one, use pull --overwrite.
532
If there is no default location set, the first pull will set it. After
533
that, you can omit the location to use the default. To change the
534
default, use --remember. The value will only be saved if the remote
535
location can be accessed.
538
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
540
help='branch to pull into, '
541
'rather than the one containing the working directory',
546
takes_args = ['location?']
547
encoding_type = 'replace'
549
def run(self, location=None, remember=False, overwrite=False,
550
revision=None, verbose=False,
552
# FIXME: too much stuff is in the command class
553
if directory is None:
556
tree_to = WorkingTree.open_containing(directory)[0]
557
branch_to = tree_to.branch
558
except errors.NoWorkingTree:
560
branch_to = Branch.open_containing(directory)[0]
563
if location is not None:
565
reader = bundle.read_bundle_from_url(location)
566
except errors.NotABundle:
567
pass # Continue on considering this url a Branch
569
stored_loc = branch_to.get_parent()
571
if stored_loc is None:
572
raise errors.BzrCommandError("No pull location known or"
575
display_url = urlutils.unescape_for_display(stored_loc,
577
self.outf.write("Using saved location: %s\n" % display_url)
578
location = stored_loc
580
if reader is not None:
581
install_bundle(branch_to.repository, reader)
582
branch_from = branch_to
584
branch_from = Branch.open(location)
586
if branch_to.get_parent() is None or remember:
587
branch_to.set_parent(branch_from.base)
591
if reader is not None:
592
rev_id = reader.target
593
elif len(revision) == 1:
594
rev_id = revision[0].in_history(branch_from).rev_id
596
raise errors.BzrCommandError('bzr pull --revision takes one value.')
598
old_rh = branch_to.revision_history()
599
if tree_to is not None:
600
count = tree_to.pull(branch_from, overwrite, rev_id,
601
delta.ChangeReporter(tree_to.inventory))
603
count = branch_to.pull(branch_from, overwrite, rev_id)
604
note('%d revision(s) pulled.' % (count,))
607
new_rh = branch_to.revision_history()
610
from bzrlib.log import show_changed_revisions
611
show_changed_revisions(branch_to, old_rh, new_rh,
615
class cmd_push(Command):
616
"""Update a mirror of this branch.
618
The target branch will not have its working tree populated because this
619
is both expensive, and is not supported on remote file systems.
621
Some smart servers or protocols *may* put the working tree in place in
624
This command only works on branches that have not diverged. Branches are
625
considered diverged if the destination branch's most recent commit is one
626
that has not been merged (directly or indirectly) by the source branch.
628
If branches have diverged, you can use 'bzr push --overwrite' to replace
629
the other branch completely, discarding its unmerged changes.
631
If you want to ensure you have the different changes in the other branch,
632
do a merge (see bzr help merge) from the other branch, and commit that.
633
After that you will be able to do a push without '--overwrite'.
635
If there is no default push location set, the first push will set it.
636
After that, you can omit the location to use the default. To change the
637
default, use --remember. The value will only be saved if the remote
638
location can be accessed.
641
takes_options = ['remember', 'overwrite', 'verbose',
642
Option('create-prefix',
643
help='Create the path leading up to the branch '
644
'if it does not already exist'),
646
help='branch to push from, '
647
'rather than the one containing the working directory',
651
Option('use-existing-dir',
652
help='By default push will fail if the target'
653
' directory exists, but does not already'
654
' have a control directory. This flag will'
655
' allow push to proceed.'),
657
takes_args = ['location?']
658
encoding_type = 'replace'
660
def run(self, location=None, remember=False, overwrite=False,
661
create_prefix=False, verbose=False,
662
use_existing_dir=False,
664
# FIXME: Way too big! Put this into a function called from the
666
if directory is None:
668
br_from = Branch.open_containing(directory)[0]
669
stored_loc = br_from.get_push_location()
671
if stored_loc is None:
672
raise errors.BzrCommandError("No push location known or specified.")
674
display_url = urlutils.unescape_for_display(stored_loc,
676
self.outf.write("Using saved location: %s\n" % display_url)
677
location = stored_loc
679
to_transport = transport.get_transport(location)
680
location_url = to_transport.base
685
br_to = repository_to = dir_to = None
687
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
688
except errors.NotBranchError:
689
pass # Didn't find anything
691
# If we can open a branch, use its direct repository, otherwise see
692
# if there is a repository without a branch.
694
br_to = dir_to.open_branch()
695
except errors.NotBranchError:
696
# Didn't find a branch, can we find a repository?
698
repository_to = dir_to.find_repository()
699
except errors.NoRepositoryPresent:
702
# Found a branch, so we must have found a repository
703
repository_to = br_to.repository
707
# XXX: Refactor the create_prefix/no_create_prefix code into a
708
# common helper function
710
to_transport.mkdir('.')
711
except errors.FileExists:
712
if not use_existing_dir:
713
raise errors.BzrCommandError("Target directory %s"
714
" already exists, but does not have a valid .bzr"
715
" directory. Supply --use-existing-dir to push"
716
" there anyway." % location)
717
except errors.NoSuchFile:
718
if not create_prefix:
719
raise errors.BzrCommandError("Parent directory of %s"
721
"\nYou may supply --create-prefix to create all"
722
" leading parent directories."
725
cur_transport = to_transport
726
needed = [cur_transport]
727
# Recurse upwards until we can create a directory successfully
729
new_transport = cur_transport.clone('..')
730
if new_transport.base == cur_transport.base:
731
raise errors.BzrCommandError("Failed to create path"
735
new_transport.mkdir('.')
736
except errors.NoSuchFile:
737
needed.append(new_transport)
738
cur_transport = new_transport
742
# Now we only need to create child directories
744
cur_transport = needed.pop()
745
cur_transport.mkdir('.')
747
# Now the target directory exists, but doesn't have a .bzr
748
# directory. So we need to create it, along with any work to create
749
# all of the dependent branches, etc.
750
dir_to = br_from.bzrdir.clone(location_url,
751
revision_id=br_from.last_revision())
752
br_to = dir_to.open_branch()
753
count = br_to.last_revision_info()[0]
754
# We successfully created the target, remember it
755
if br_from.get_push_location() is None or remember:
756
br_from.set_push_location(br_to.base)
757
elif repository_to is None:
758
# we have a bzrdir but no branch or repository
759
# XXX: Figure out what to do other than complain.
760
raise errors.BzrCommandError("At %s you have a valid .bzr control"
761
" directory, but not a branch or repository. This is an"
762
" unsupported configuration. Please move the target directory"
763
" out of the way and try again."
766
# We have a repository but no branch, copy the revisions, and then
768
last_revision_id = br_from.last_revision()
769
repository_to.fetch(br_from.repository,
770
revision_id=last_revision_id)
771
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
772
count = len(br_to.revision_history())
773
if br_from.get_push_location() is None or remember:
774
br_from.set_push_location(br_to.base)
775
else: # We have a valid to branch
776
# We were able to connect to the remote location, so remember it
777
# we don't need to successfully push because of possible divergence.
778
if br_from.get_push_location() is None or remember:
779
br_from.set_push_location(br_to.base)
780
old_rh = br_to.revision_history()
783
tree_to = dir_to.open_workingtree()
784
except errors.NotLocalUrl:
785
warning('This transport does not update the working '
786
'tree of: %s' % (br_to.base,))
787
count = br_from.push(br_to, overwrite)
788
except errors.NoWorkingTree:
789
count = br_from.push(br_to, overwrite)
793
count = br_from.push(tree_to.branch, overwrite)
797
except errors.DivergedBranches:
798
raise errors.BzrCommandError('These branches have diverged.'
799
' Try using "merge" and then "push".')
800
note('%d revision(s) pushed.' % (count,))
803
new_rh = br_to.revision_history()
806
from bzrlib.log import show_changed_revisions
807
show_changed_revisions(br_to, old_rh, new_rh,
313
"""Pull any changes from another branch into the current one.
315
If the location is omitted, the last-used location will be used.
316
Both the revision history and the working directory will be
319
This command only works on branches that have not diverged. Branches are
320
considered diverged if both branches have had commits without first
321
pulling from the other.
323
If branches have diverged, you can use 'bzr merge' to pull the text changes
324
from one into the other.
326
takes_args = ['location?']
328
def run(self, location=None):
329
from bzrlib.merge import merge
331
from shutil import rmtree
334
br_to = Branch.open_containing('.')
335
stored_loc = br_to.get_parent()
337
if stored_loc is None:
338
raise BzrCommandError("No pull location known or specified.")
340
print "Using last location: %s" % stored_loc
341
location = stored_loc
342
cache_root = tempfile.mkdtemp()
343
from bzrlib.errors import DivergedBranches
344
br_from = Branch.open_containing(location)
345
location = br_from.base
346
old_revno = br_to.revno()
348
from bzrlib.errors import DivergedBranches
349
br_from = Branch.open(location)
350
br_from.setup_caching(cache_root)
351
location = br_from.base
352
old_revno = br_to.revno()
354
br_to.update_revisions(br_from)
355
except DivergedBranches:
356
raise BzrCommandError("These branches have diverged."
359
merge(('.', -1), ('.', old_revno), check_clean=False)
360
if location != stored_loc:
361
br_to.set_parent(location)
811
367
class cmd_branch(Command):
826
382
aliases = ['get', 'clone']
828
384
def run(self, from_location, to_location=None, revision=None, basis=None):
831
elif len(revision) > 1:
832
raise errors.BzrCommandError(
833
'bzr branch --revision takes exactly 1 revision value')
835
br_from = Branch.open(from_location)
385
from bzrlib.clone import copy_branch
388
from shutil import rmtree
389
cache_root = tempfile.mkdtemp()
393
elif len(revision) > 1:
394
raise BzrCommandError(
395
'bzr branch --revision takes exactly 1 revision value')
397
br_from = Branch.open(from_location)
399
if e.errno == errno.ENOENT:
400
raise BzrCommandError('Source location "%s" does not'
401
' exist.' % to_location)
404
br_from.setup_caching(cache_root)
838
405
if basis is not None:
839
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
406
basis_branch = Branch.open_containing(basis)
842
409
if len(revision) == 1 and revision[0] is not None:
843
410
revision_id = revision[0].in_history(br_from)[1]
845
# FIXME - wt.last_revision, fallback to branch, fall back to
846
# None or perhaps NULL_REVISION to mean copy nothing
848
revision_id = br_from.last_revision()
849
413
if to_location is None:
850
414
to_location = os.path.basename(from_location.rstrip("/\\"))
853
name = os.path.basename(to_location) + '\n'
855
to_transport = transport.get_transport(to_location)
857
to_transport.mkdir('.')
858
except errors.FileExists:
859
raise errors.BzrCommandError('Target directory "%s" already'
860
' exists.' % to_location)
861
except errors.NoSuchFile:
862
raise errors.BzrCommandError('Parent of "%s" does not exist.'
865
# preserve whatever source format we have.
866
dir = br_from.bzrdir.sprout(to_transport.base,
867
revision_id, basis_dir)
868
branch = dir.open_branch()
869
except errors.NoSuchRevision:
870
to_transport.delete_tree('.')
871
msg = "The branch %s has no revision %s." % (from_location, revision[0])
872
raise errors.BzrCommandError(msg)
873
except errors.UnlistableBranch:
874
osutils.rmtree(to_location)
875
msg = "The branch %s cannot be used as a --basis" % (basis,)
876
raise errors.BzrCommandError(msg)
878
branch.control_files.put_utf8('branch-name', name)
879
note('Branched %d revision(s).' % branch.revno())
416
os.mkdir(to_location)
418
if e.errno == errno.EEXIST:
419
raise BzrCommandError('Target directory "%s" already'
420
' exists.' % to_location)
421
if e.errno == errno.ENOENT:
422
raise BzrCommandError('Parent of "%s" does not exist.' %
427
copy_branch(br_from, to_location, revision_id, basis_branch)
428
except bzrlib.errors.NoSuchRevision:
430
msg = "The branch %s has no revision %d." % (from_location, revision[0])
431
raise BzrCommandError(msg)
432
except bzrlib.errors.UnlistableBranch:
433
msg = "The branch %s cannot be used as a --basis"
884
class cmd_checkout(Command):
885
"""Create a new checkout of an existing branch.
887
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
888
the branch found in '.'. This is useful if you have removed the working tree
889
or if it was never created - i.e. if you pushed the branch to its current
892
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
893
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
895
To retrieve the branch as of a particular revision, supply the --revision
896
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
897
out of date [so you cannot commit] but it may be useful (i.e. to examine old
900
--basis is to speed up checking out from remote branches. When specified, it
901
uses the inventory and file contents from the basis branch in preference to the
902
branch being checked out.
904
See "help checkouts" for more information on checkouts.
906
takes_args = ['branch_location?', 'to_location?']
907
takes_options = ['revision', # , 'basis']
908
Option('lightweight',
909
help="perform a lightweight checkout. Lightweight "
910
"checkouts depend on access to the branch for "
911
"every operation. Normal checkouts can perform "
912
"common operations like diff and status without "
913
"such access, and also support local commits."
918
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
922
elif len(revision) > 1:
923
raise errors.BzrCommandError(
924
'bzr checkout --revision takes exactly 1 revision value')
925
if branch_location is None:
926
branch_location = osutils.getcwd()
927
to_location = branch_location
928
source = Branch.open(branch_location)
929
if len(revision) == 1 and revision[0] is not None:
930
revision_id = revision[0].in_history(source)[1]
933
if to_location is None:
934
to_location = os.path.basename(branch_location.rstrip("/\\"))
935
# if the source and to_location are the same,
936
# and there is no working tree,
937
# then reconstitute a branch
938
if (osutils.abspath(to_location) ==
939
osutils.abspath(branch_location)):
941
source.bzrdir.open_workingtree()
942
except errors.NoWorkingTree:
943
source.bzrdir.create_workingtree()
946
os.mkdir(to_location)
948
if e.errno == errno.EEXIST:
949
raise errors.BzrCommandError('Target directory "%s" already'
950
' exists.' % to_location)
951
if e.errno == errno.ENOENT:
952
raise errors.BzrCommandError('Parent of "%s" does not exist.'
956
source.create_checkout(to_location, revision_id, lightweight)
959
438
class cmd_renames(Command):
960
439
"""Show list of renamed files.
441
TODO: Option to show renames between two historical versions.
443
TODO: Only show renames under dir, rather than in the whole branch.
962
# TODO: Option to show renames between two historical versions.
964
# TODO: Only show renames under dir, rather than in the whole branch.
965
445
takes_args = ['dir?']
968
def run(self, dir=u'.'):
969
tree = WorkingTree.open_containing(dir)[0]
970
old_inv = tree.basis_tree().inventory
971
new_inv = tree.read_working_inventory()
972
renames = list(_mod_tree.find_renames(old_inv, new_inv))
447
def run(self, dir='.'):
448
b = Branch.open_containing(dir)
449
old_inv = b.basis_tree().inventory
450
new_inv = b.read_working_inventory()
452
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
974
454
for old_name, new_name in renames:
975
self.outf.write("%s => %s\n" % (old_name, new_name))
978
class cmd_update(Command):
979
"""Update a tree to have the latest code committed to its branch.
981
This will perform a merge into the working tree, and may generate
982
conflicts. If you have any local changes, you will still
983
need to commit them after the update for the update to be complete.
985
If you want to discard your local changes, you can just do a
986
'bzr revert' instead of 'bzr commit' after the update.
988
takes_args = ['dir?']
991
def run(self, dir='.'):
992
tree = WorkingTree.open_containing(dir)[0]
993
master = tree.branch.get_master_branch()
994
if master is not None:
997
tree.lock_tree_write()
999
existing_pending_merges = tree.get_parent_ids()[1:]
1000
last_rev = tree.last_revision()
1001
if last_rev == tree.branch.last_revision():
1002
# may be up to date, check master too.
1003
master = tree.branch.get_master_branch()
1004
if master is None or last_rev == master.last_revision():
1005
revno = tree.branch.revision_id_to_revno(last_rev)
1006
note("Tree is up to date at revision %d." % (revno,))
1008
conflicts = tree.update()
1009
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1010
note('Updated to revision %d.' % (revno,))
1011
if tree.get_parent_ids()[1:] != existing_pending_merges:
1012
note('Your local commits will now show as pending merges with '
1013
"'bzr status', and can be committed with 'bzr commit'.")
455
print "%s => %s" % (old_name, new_name)
1022
458
class cmd_info(Command):
1023
"""Show information about a working tree, branch or repository.
1025
This command will show all known locations and formats associated to the
1026
tree, branch or repository. Statistical information is included with
1029
Branches and working trees will also report any missing revisions.
1031
takes_args = ['location?']
1032
takes_options = ['verbose']
1035
def run(self, location=None, verbose=False):
1036
from bzrlib.info import show_bzrdir_info
1037
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
459
"""Show statistical information about a branch."""
460
takes_args = ['branch?']
462
def run(self, branch=None):
465
b = Branch.open_containing(branch)
1041
469
class cmd_remove(Command):
1181
548
Use this to create an empty branch, or before importing an
1182
549
existing project.
1184
If there is a repository in a parent directory of the location, then
1185
the history of the branch will be stored in the repository. Otherwise
1186
init creates a standalone branch which carries its own history in
1189
If there is already a branch at the location but it has no working tree,
1190
the tree can be populated with 'bzr checkout'.
1192
551
Recipe for importing a tree of files:
1197
556
bzr commit -m 'imported project'
1199
takes_args = ['location?']
1201
RegistryOption('format',
1202
help='Specify a format for this branch. '
1203
'See "help formats".',
1204
registry=bzrdir.format_registry,
1205
converter=bzrdir.format_registry.make_bzrdir,
1206
value_switches=True,
1207
title="Branch Format",
1209
Option('append-revisions-only',
1210
help='Never change revnos or the existing log.'
1211
' Append revisions to it only.')
1213
def run(self, location=None, format=None, append_revisions_only=False):
1215
format = bzrdir.format_registry.make_bzrdir('default')
1216
if location is None:
1219
to_transport = transport.get_transport(location)
1221
# The path has to exist to initialize a
1222
# branch inside of it.
1223
# Just using os.mkdir, since I don't
1224
# believe that we want to create a bunch of
1225
# locations if the user supplies an extended path
1226
# TODO: create-prefix
1228
to_transport.mkdir('.')
1229
except errors.FileExists:
1233
existing_bzrdir = bzrdir.BzrDir.open(location)
1234
except errors.NotBranchError:
1235
# really a NotBzrDir error...
1236
branch = bzrdir.BzrDir.create_branch_convenience(location,
1239
from bzrlib.transport.local import LocalTransport
1240
if existing_bzrdir.has_branch():
1241
if (isinstance(to_transport, LocalTransport)
1242
and not existing_bzrdir.has_workingtree()):
1243
raise errors.BranchExistsWithoutWorkingTree(location)
1244
raise errors.AlreadyBranchError(location)
1246
branch = existing_bzrdir.create_branch()
1247
existing_bzrdir.create_workingtree()
1248
if append_revisions_only:
1250
branch.set_append_revisions_only(True)
1251
except errors.UpgradeRequired:
1252
raise errors.BzrCommandError('This branch format cannot be set'
1253
' to append-revisions-only. Try --experimental-branch6')
1256
class cmd_init_repository(Command):
1257
"""Create a shared repository to hold branches.
1259
New branches created under the repository directory will store their revisions
1260
in the repository, not in the branch directory, if the branch format supports
1266
bzr checkout --lightweight repo/trunk trunk-checkout
1270
takes_args = ["location"]
1271
takes_options = [RegistryOption('format',
1272
help='Specify a format for this repository. See'
1273
' "bzr help formats" for details',
1274
registry=bzrdir.format_registry,
1275
converter=bzrdir.format_registry.make_bzrdir,
1276
value_switches=True, title='Repository format'),
1278
help='Allows branches in repository to have'
1280
aliases = ["init-repo"]
1281
def run(self, location, format=None, trees=False):
1283
format = bzrdir.format_registry.make_bzrdir('default')
1285
if location is None:
1288
to_transport = transport.get_transport(location)
1290
to_transport.mkdir('.')
1291
except errors.FileExists:
1294
newdir = format.initialize_on_transport(to_transport)
1295
repo = newdir.create_repository(shared=True)
1296
repo.set_make_working_trees(trees)
559
from bzrlib.branch import Branch
560
Branch.initialize('.')
1299
563
class cmd_diff(Command):
1300
"""Show differences in the working tree or between revisions.
564
"""Show differences in working tree.
1302
566
If files are listed, only the changes in those files are listed.
1303
567
Otherwise, all changes for the tree are listed.
1305
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1306
produces patches suitable for "patch -p1".
569
TODO: Allow diff across branches.
571
TODO: Option to use external diff command; could be GNU diff, wdiff,
574
TODO: Python difflib is not exactly the same as unidiff; should
575
either fix it up or prefer to use an external diff.
577
TODO: If a directory is given, diff everything under that.
579
TODO: Selected-file diff is inefficient and doesn't show you
582
TODO: This probably handles non-Unix newlines poorly.
1310
Shows the difference in the working tree versus the last commit
1312
Difference between the working tree and revision 1
1314
Difference between revision 2 and revision 1
1315
bzr diff --diff-prefix old/:new/
1316
Same as 'bzr diff' but prefix paths with old/ and new/
1317
bzr diff bzr.mine bzr.dev
1318
Show the differences between the two working trees
1320
Show just the differences for 'foo.c'
1322
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1323
# or a graphical diff.
1325
# TODO: Python difflib is not exactly the same as unidiff; should
1326
# either fix it up or prefer to use an external diff.
1328
# TODO: Selected-file diff is inefficient and doesn't show you
1331
# TODO: This probably handles non-Unix newlines poorly.
1333
590
takes_args = ['file*']
1334
takes_options = ['revision', 'diff-options',
1335
Option('prefix', type=str,
1337
help='Set prefixes to added to old and new filenames, as '
1338
'two values separated by a colon.'),
591
takes_options = ['revision', 'diff-options']
1340
592
aliases = ['di', 'dif']
1341
encoding_type = 'exact'
1344
def run(self, revision=None, file_list=None, diff_options=None,
1346
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1348
if (prefix is None) or (prefix == '0'):
1356
old_label, new_label = prefix.split(":")
1358
raise BzrCommandError(
1359
"--prefix expects two values separated by a colon")
1361
if revision and len(revision) > 2:
1362
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1363
' one or two revision specifiers')
594
def run(self, revision=None, file_list=None, diff_options=None):
595
from bzrlib.diff import show_diff
598
b = Branch.open_containing(file_list[0])
599
file_list = [b.relpath(f) for f in file_list]
600
if file_list == ['']:
601
# just pointing to top-of-tree
604
b = Branch.open_containing('.')
606
if revision is not None:
607
if len(revision) == 1:
608
show_diff(b, revision[0], specific_files=file_list,
609
external_diff_options=diff_options)
610
elif len(revision) == 2:
611
show_diff(b, revision[0], specific_files=file_list,
612
external_diff_options=diff_options,
613
revision2=revision[1])
615
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
617
show_diff(b, None, specific_files=file_list,
618
external_diff_options=diff_options)
1366
tree1, file_list = internal_tree_files(file_list)
1370
except errors.FileInWrongBranch:
1371
if len(file_list) != 2:
1372
raise errors.BzrCommandError("Files are in different branches")
1374
tree1, file1 = WorkingTree.open_containing(file_list[0])
1375
tree2, file2 = WorkingTree.open_containing(file_list[1])
1376
if file1 != "" or file2 != "":
1377
# FIXME diff those two files. rbc 20051123
1378
raise errors.BzrCommandError("Files are in different branches")
1380
except errors.NotBranchError:
1381
if (revision is not None and len(revision) == 2
1382
and not revision[0].needs_branch()
1383
and not revision[1].needs_branch()):
1384
# If both revision specs include a branch, we can
1385
# diff them without needing a local working tree
1386
tree1, tree2 = None, None
1390
if tree2 is not None:
1391
if revision is not None:
1392
# FIXME: but there should be a clean way to diff between
1393
# non-default versions of two trees, it's not hard to do
1395
raise errors.BzrCommandError(
1396
"Sorry, diffing arbitrary revisions across branches "
1397
"is not implemented yet")
1398
return show_diff_trees(tree1, tree2, sys.stdout,
1399
specific_files=file_list,
1400
external_diff_options=diff_options,
1401
old_label=old_label, new_label=new_label)
1403
return diff_cmd_helper(tree1, file_list, diff_options,
1404
revision_specs=revision,
1405
old_label=old_label, new_label=new_label)
1408
623
class cmd_deleted(Command):
1409
624
"""List files deleted in the working tree.
626
TODO: Show files deleted since a previous revision, or between two revisions.
1411
# TODO: Show files deleted since a previous revision, or
1412
# between two revisions.
1413
# TODO: Much more efficient way to do this: read in new
1414
# directories with readdir, rather than stating each one. Same
1415
# level of effort but possibly much less IO. (Or possibly not,
1416
# if the directories are very large...)
1417
takes_options = ['show-ids']
1420
628
def run(self, show_ids=False):
1421
tree = WorkingTree.open_containing(u'.')[0]
1422
old = tree.basis_tree()
629
b = Branch.open_containing('.')
631
new = b.working_tree()
633
## TODO: Much more efficient way to do this: read in new
634
## directories with readdir, rather than stating each one. Same
635
## level of effort but possibly much less IO. (Or possibly not,
636
## if the directories are very large...)
1423
638
for path, ie in old.inventory.iter_entries():
1424
if not tree.has_id(ie.file_id):
1425
self.outf.write(path)
639
if not new.has_id(ie.file_id):
1427
self.outf.write(' ')
1428
self.outf.write(ie.file_id)
1429
self.outf.write('\n')
641
print '%-50s %s' % (path, ie.file_id)
1432
646
class cmd_modified(Command):
1433
"""List files modified in working tree.
1435
See also: "bzr status".
647
"""List files modified in working tree."""
1442
tree = WorkingTree.open_containing(u'.')[0]
1443
td = tree.changes_from(tree.basis_tree())
1444
for path, id, kind, text_modified, meta_modified in td.modified:
1445
self.outf.write(path + '\n')
650
from bzrlib.delta import compare_trees
652
b = Branch.open_containing('.')
653
td = compare_trees(b.basis_tree(), b.working_tree())
655
for path, id, kind in td.modified:
1448
660
class cmd_added(Command):
1449
"""List files added in working tree.
1451
See also: "bzr status".
661
"""List files added in working tree."""
1458
wt = WorkingTree.open_containing(u'.')[0]
1459
basis_inv = wt.basis_tree().inventory
664
b = Branch.open_containing('.')
665
wt = b.working_tree()
666
basis_inv = b.basis_tree().inventory
1460
667
inv = wt.inventory
1461
668
for file_id in inv:
1462
669
if file_id in basis_inv:
1464
if inv.is_root(file_id) and len(basis_inv) == 0:
1466
671
path = inv.id2path(file_id)
1467
if not os.access(osutils.abspath(path), os.F_OK):
672
if not os.access(b.abspath(path), os.F_OK):
1469
self.outf.write(path + '\n')
1472
678
class cmd_root(Command):
1473
679
"""Show the tree root directory.
1475
681
The root is the nearest enclosing directory with a .bzr control
1477
683
takes_args = ['filename?']
1479
684
def run(self, filename=None):
1480
685
"""Print the branch root."""
1481
tree = WorkingTree.open_containing(filename)[0]
1482
self.outf.write(tree.basedir + '\n')
686
b = Branch.open_containing(filename)
1485
690
class cmd_log(Command):
1486
"""Show log of a branch, file, or directory.
1488
By default show the log of the branch containing the working directory.
1490
To request a range of logs, you can use the command -r begin..end
1491
-r revision requests a specific revision, -r ..end or -r begin.. are
691
"""Show log of this branch.
693
To request a range of logs, you can use the command -r begin:end
694
-r revision requests a specific revision, -r :end or -r begin: are
1497
bzr log -r -10.. http://server/branch
697
--message allows you to give a regular expression, which will be evaluated
698
so that only matching entries will be displayed.
700
TODO: Make --revision support uuid: and hash: [future tag:] notation.
1500
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1502
takes_args = ['location?']
1503
takes_options = [Option('forward',
1504
help='show from oldest to newest'),
1508
help='show files changed in each revision'),
1509
'show-ids', 'revision',
1513
help='show revisions whose message matches this regexp',
1516
encoding_type = 'replace'
1519
def run(self, location=None, timezone='original',
704
takes_args = ['filename?']
705
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
706
'long', 'message', 'short',]
708
def run(self, filename=None, timezone='original',
1526
from bzrlib.log import show_log
1527
assert message is None or isinstance(message, basestring), \
1528
"invalid message argument %r" % message
716
from bzrlib.log import log_formatter, show_log
1529
719
direction = (forward and 'forward') or 'reverse'
1534
# find the file id to log:
1536
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1540
tree = b.basis_tree()
1541
inv = tree.inventory
1542
file_id = inv.path2id(fp)
1544
raise errors.BzrCommandError(
1545
"Path does not have any revision history: %s" %
1549
# FIXME ? log the current subdir only RBC 20060203
1550
if revision is not None \
1551
and len(revision) > 0 and revision[0].get_branch():
1552
location = revision[0].get_branch()
1555
dir, relpath = bzrdir.BzrDir.open_containing(location)
1556
b = dir.open_branch()
1560
if revision is None:
1563
elif len(revision) == 1:
1564
rev1 = rev2 = revision[0].in_history(b).revno
1565
elif len(revision) == 2:
1566
if revision[1].get_branch() != revision[0].get_branch():
1567
# b is taken from revision[0].get_branch(), and
1568
# show_log will use its revision_history. Having
1569
# different branches will lead to weird behaviors.
1570
raise errors.BzrCommandError(
1571
"Log doesn't accept two revisions in different"
1573
if revision[0].spec is None:
1574
# missing begin-range means first revision
1577
rev1 = revision[0].in_history(b).revno
1579
if revision[1].spec is None:
1580
# missing end-range means last known revision
1583
rev2 = revision[1].in_history(b).revno
1585
raise errors.BzrCommandError(
1586
'bzr log --revision takes one or two values.')
1588
# By this point, the revision numbers are converted to the +ve
1589
# form if they were supplied in the -ve form, so we can do
1590
# this comparison in relative safety
1592
(rev2, rev1) = (rev1, rev2)
1594
if log_format is None:
1595
log_format = log.log_formatter_registry.get_default(b)
1597
lf = log_format(show_ids=show_ids, to_file=self.outf,
1598
show_timezone=timezone)
1604
direction=direction,
1605
start_revision=rev1,
1612
def get_log_format(long=False, short=False, line=False, default='long'):
1613
log_format = default
1617
log_format = 'short'
722
b = Branch.open_containing(filename)
723
fp = b.relpath(filename)
725
file_id = b.read_working_inventory().path2id(fp)
727
file_id = None # points to branch root
729
b = Branch.open_containing('.')
735
elif len(revision) == 1:
736
rev1 = rev2 = revision[0].in_history(b).revno
737
elif len(revision) == 2:
738
rev1 = revision[0].in_history(b).revno
739
rev2 = revision[1].in_history(b).revno
741
raise BzrCommandError('bzr log --revision takes one or two values.')
748
mutter('encoding log as %r' % bzrlib.user_encoding)
750
# use 'replace' so that we don't abort if trying to write out
751
# in e.g. the default C locale.
752
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
758
lf = log_formatter(log_format,
761
show_timezone=timezone)
1623
774
class cmd_touching_revisions(Command):
1624
775
"""Return revision-ids which affected a particular file.
1626
A more user-friendly interface is "bzr log FILE".
777
A more user-friendly interface is "bzr log FILE"."""
1630
779
takes_args = ["filename"]
1633
780
def run(self, filename):
1634
tree, relpath = WorkingTree.open_containing(filename)
1636
inv = tree.read_working_inventory()
1637
file_id = inv.path2id(relpath)
1638
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1639
self.outf.write("%6d %s\n" % (revno, what))
781
b = Branch.open_containing(filename)
782
inv = b.read_working_inventory()
783
file_id = inv.path2id(b.relpath(filename))
784
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
785
print "%6d %s" % (revno, what)
1642
788
class cmd_ls(Command):
1643
789
"""List files in a tree.
791
TODO: Take a revision or remote path and list that tree instead.
1646
takes_args = ['path?']
1647
# TODO: Take a revision or remote path and list that tree instead.
1648
takes_options = ['verbose', 'revision',
1649
Option('non-recursive',
1650
help='don\'t recurse into sub-directories'),
1652
help='Print all paths from the root of the branch.'),
1653
Option('unknown', help='Print unknown files'),
1654
Option('versioned', help='Print versioned files'),
1655
Option('ignored', help='Print ignored files'),
1657
Option('null', help='Null separate the files'),
1661
def run(self, revision=None, verbose=False,
1662
non_recursive=False, from_root=False,
1663
unknown=False, versioned=False, ignored=False,
1664
null=False, kind=None, show_ids=False, path=None):
1666
if kind and kind not in ('file', 'directory', 'symlink'):
1667
raise errors.BzrCommandError('invalid kind specified')
1669
if verbose and null:
1670
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1671
all = not (unknown or versioned or ignored)
1673
selection = {'I':ignored, '?':unknown, 'V':versioned}
794
def run(self, revision=None, verbose=False):
795
b = Branch.open_containing('.')
797
tree = b.working_tree()
1680
raise errors.BzrCommandError('cannot specify both --from-root'
1684
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1690
if revision is not None:
1691
tree = branch.repository.revision_tree(
1692
revision[0].in_history(branch).rev_id)
1694
tree = branch.basis_tree()
1698
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1699
if fp.startswith(relpath):
1700
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1701
if non_recursive and '/' in fp:
1703
if not all and not selection[fc]:
1705
if kind is not None and fkind != kind:
1708
kindch = entry.kind_character()
1709
outstring = '%-8s %s%s' % (fc, fp, kindch)
1710
if show_ids and fid is not None:
1711
outstring = "%-50s %s" % (outstring, fid)
1712
self.outf.write(outstring + '\n')
1714
self.outf.write(fp + '\0')
1717
self.outf.write(fid)
1718
self.outf.write('\0')
1726
self.outf.write('%-50s %s\n' % (fp, my_id))
1728
self.outf.write(fp + '\n')
799
tree = b.revision_tree(revision.in_history(b).rev_id)
801
for fp, fc, kind, fid in tree.list_files():
803
if kind == 'directory':
810
print '%-8s %s%s' % (fc, fp, kindch)
1733
816
class cmd_unknowns(Command):
1734
"""List unknown files.
1736
See also: "bzr ls --unknown".
817
"""List unknown files."""
1743
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1744
self.outf.write(osutils.quotefn(f) + '\n')
819
from bzrlib.osutils import quotefn
820
for f in Branch.open_containing('.').unknowns():
1747
825
class cmd_ignore(Command):
1748
"""Ignore specified files or patterns.
826
"""Ignore a command or pattern.
1750
828
To remove patterns from the ignore list, edit the .bzrignore file.
1752
Trailing slashes on patterns are ignored.
1753
If the pattern contains a slash or is a regular expression, it is compared
1754
to the whole path from the branch root. Otherwise, it is compared to only
1755
the last component of the path. To match a file only in the root
1756
directory, prepend './'.
1758
Ignore patterns specifying absolute paths are not allowed.
1760
Ignore patterns may include globbing wildcards such as:
1761
? - Matches any single character except '/'
1762
* - Matches 0 or more characters except '/'
1763
/**/ - Matches 0 or more directories in a path
1764
[a-z] - Matches a single character from within a group of characters
1766
Ignore patterns may also be Python regular expressions.
1767
Regular expression ignore patterns are identified by a 'RE:' prefix
1768
followed by the regular expression. Regular expression ignore patterns
1769
may not include named or numbered groups.
1771
Note: ignore patterns containing shell wildcards must be quoted from
830
If the pattern contains a slash, it is compared to the whole path
831
from the branch root. Otherwise, it is comapred to only the last
832
component of the path.
834
Ignore patterns are case-insensitive on case-insensitive systems.
836
Note: wildcards must be quoted from the shell on Unix.
1775
839
bzr ignore ./Makefile
1776
840
bzr ignore '*.class'
1777
bzr ignore 'lib/**/*.o'
1778
bzr ignore 'RE:lib/.*\.o'
1780
takes_args = ['name_pattern*']
1782
Option('old-default-rules',
1783
help='Out the ignore rules bzr < 0.9 always used.')
842
takes_args = ['name_pattern']
1786
def run(self, name_pattern_list=None, old_default_rules=None):
844
def run(self, name_pattern):
1787
845
from bzrlib.atomicfile import AtomicFile
1788
if old_default_rules is not None:
1789
# dump the rules and exit
1790
for pattern in ignores.OLD_DEFAULTS:
1793
if not name_pattern_list:
1794
raise errors.BzrCommandError("ignore requires at least one "
1795
"NAME_PATTERN or --old-default-rules")
1796
for name_pattern in name_pattern_list:
1797
if name_pattern[0] == '/':
1798
raise errors.BzrCommandError(
1799
"NAME_PATTERN should not be an absolute path")
1800
tree, relpath = WorkingTree.open_containing(u'.')
1801
ifn = tree.abspath('.bzrignore')
848
b = Branch.open_containing('.')
849
ifn = b.abspath('.bzrignore')
1802
851
if os.path.exists(ifn):
1803
852
f = open(ifn, 'rt')
1879
922
is found exports to a directory (equivalent to --format=dir).
1881
924
Root may be the top directory for tar, tgz and tbz2 formats. If none
1882
is given, the top directory will be the root name of the file.
1884
If branch is omitted then the branch containing the CWD will be used.
1886
Note: export of tree with non-ascii filenames to zip is not supported.
1888
Supported formats Autodetected by extension
1889
----------------- -------------------------
1892
tbz2 .tar.bz2, .tbz2
1896
takes_args = ['dest', 'branch?']
925
is given, the top directory will be the root name of the file."""
926
# TODO: list known exporters
927
takes_args = ['dest']
1897
928
takes_options = ['revision', 'format', 'root']
1898
def run(self, dest, branch=None, revision=None, format=None, root=None):
1899
from bzrlib.export import export
1902
tree = WorkingTree.open_containing(u'.')[0]
1905
b = Branch.open(branch)
929
def run(self, dest, revision=None, format=None, root=None):
931
b = Branch.open_containing('.')
1907
932
if revision is None:
1908
# should be tree.last_revision FIXME
1909
933
rev_id = b.last_revision()
1911
935
if len(revision) != 1:
1912
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
936
raise BzrError('bzr export --revision takes exactly 1 argument')
1913
937
rev_id = revision[0].in_history(b).rev_id
1914
t = b.repository.revision_tree(rev_id)
1916
export(t, dest, format, root)
1917
except errors.NoSuchExportFormat, e:
1918
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
938
t = b.revision_tree(rev_id)
939
root, ext = os.path.splitext(dest)
943
elif ext in (".gz", ".tgz"):
945
elif ext in (".bz2", ".tbz2"):
949
t.export(dest, format, root)
1921
952
class cmd_cat(Command):
1922
953
"""Write a file's text from a previous revision."""
1924
takes_options = ['revision', 'name-from-revision']
955
takes_options = ['revision']
1925
956
takes_args = ['filename']
1926
encoding_type = 'exact'
1929
def run(self, filename, revision=None, name_from_revision=False):
1930
if revision is not None and len(revision) != 1:
1931
raise errors.BzrCommandError("bzr cat --revision takes exactly"
1936
tree, relpath = WorkingTree.open_containing(filename)
1938
except (errors.NotBranchError, errors.NotLocalUrl):
1941
if revision is not None and revision[0].get_branch() is not None:
1942
b = Branch.open(revision[0].get_branch())
1944
b, relpath = Branch.open_containing(filename)
1945
tree = b.basis_tree()
958
def run(self, filename, revision=None):
1946
959
if revision is None:
1947
revision_id = b.last_revision()
1949
revision_id = revision[0].in_history(b).rev_id
1951
cur_file_id = tree.path2id(relpath)
1952
rev_tree = b.repository.revision_tree(revision_id)
1953
old_file_id = rev_tree.path2id(relpath)
1955
if name_from_revision:
1956
if old_file_id is None:
1957
raise errors.BzrCommandError("%r is not present in revision %s"
1958
% (filename, revision_id))
1960
rev_tree.print_file(old_file_id)
1961
elif cur_file_id is not None:
1962
rev_tree.print_file(cur_file_id)
1963
elif old_file_id is not None:
1964
rev_tree.print_file(old_file_id)
1966
raise errors.BzrCommandError("%r is not present in revision %s" %
1967
(filename, revision_id))
960
raise BzrCommandError("bzr cat requires a revision number")
961
elif len(revision) != 1:
962
raise BzrCommandError("bzr cat --revision takes exactly one number")
963
b = Branch.open_containing('.')
964
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
1970
967
class cmd_local_time_offset(Command):
1971
968
"""Show the offset in seconds from GMT to local time."""
1975
print osutils.local_time_offset()
971
print bzrlib.osutils.local_time_offset()
1988
984
A selected-file commit may fail in some cases where the committed
1989
985
tree would be invalid, such as trying to commit a file in a
1990
986
newly-added directory that is not itself committed.
988
TODO: Run hooks on tree to-be-committed, and after commit.
990
TODO: Strict commit that fails if there are unknown or deleted files.
1992
# TODO: Run hooks on tree to-be-committed, and after commit.
1994
# TODO: Strict commit that fails if there are deleted files.
1995
# (what does "deleted files" mean ??)
992
takes_args = ['selected*']
993
takes_options = ['message', 'file', 'verbose', 'unchanged']
994
aliases = ['ci', 'checkin']
1997
996
# TODO: Give better message for -s, --summary, used by tla people
1999
998
# XXX: verbose currently does nothing
2001
takes_args = ['selected*']
2002
takes_options = ['message', 'verbose',
2004
help='commit even if nothing has changed'),
2005
Option('file', type=str,
2008
help='file containing commit message'),
2010
help="refuse to commit if there are unknown "
2011
"files in the working tree."),
2013
help="perform a local only commit in a bound "
2014
"branch. Such commits are not pushed to "
2015
"the master branch until a normal commit "
2019
aliases = ['ci', 'checkin']
2021
1000
def run(self, message=None, file=None, verbose=True, selected_list=None,
2022
unchanged=False, strict=False, local=False):
2023
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
2024
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
2026
from bzrlib.msgeditor import edit_commit_message, \
2027
make_commit_message_template
2029
# TODO: Need a blackbox test for invoking the external editor; may be
2030
# slightly problematic to run this cross-platform.
2032
# TODO: do more checks that the commit will succeed before
2033
# spending the user's valuable time typing a commit message.
2034
tree, selected_list = tree_files(selected_list)
2035
if selected_list == ['']:
2036
# workaround - commit of root of tree should be exactly the same
2037
# as just default commit in that tree, and succeed even though
2038
# selected-file merge commit is not done yet
2041
if local and not tree.branch.get_bound_location():
2042
raise errors.LocalRequiresBoundBranch()
2044
def get_message(commit_obj):
2045
"""Callback to get commit message"""
2046
my_message = message
2047
if my_message is None and not file:
2048
template = make_commit_message_template(tree, selected_list)
2049
my_message = edit_commit_message(template)
2050
if my_message is None:
2051
raise errors.BzrCommandError("please specify a commit"
2052
" message with either --message or --file")
2053
elif my_message and file:
2054
raise errors.BzrCommandError(
2055
"please specify either --message or --file")
2057
my_message = codecs.open(file, 'rt',
2058
bzrlib.user_encoding).read()
2059
if my_message == "":
2060
raise errors.BzrCommandError("empty commit message specified")
1002
from bzrlib.errors import PointlessCommit
1003
from bzrlib.msgeditor import edit_commit_message
1004
from bzrlib.status import show_status
1005
from cStringIO import StringIO
1007
b = Branch.open_containing('.')
1009
selected_list = [b.relpath(s) for s in selected_list]
1011
if not message and not file:
1012
catcher = StringIO()
1013
show_status(b, specific_files=selected_list,
1015
message = edit_commit_message(catcher.getvalue())
1018
raise BzrCommandError("please specify a commit message"
1019
" with either --message or --file")
1020
elif message and file:
1021
raise BzrCommandError("please specify either --message or --file")
2064
reporter = ReportCommitToLog()
2066
reporter = NullCommitReporter()
1025
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
2069
tree.commit(message_callback=get_message,
2070
specific_files=selected_list,
2071
allow_pointless=unchanged, strict=strict, local=local,
1029
specific_files=selected_list,
1030
allow_pointless=unchanged)
2073
1031
except PointlessCommit:
2074
1032
# FIXME: This should really happen before the file is read in;
2075
1033
# perhaps prepare the commit; get the message; then actually commit
2076
raise errors.BzrCommandError("no changes to commit."
2077
" use --unchanged to commit anyhow")
2078
except ConflictsInTree:
2079
raise errors.BzrCommandError('Conflicts detected in working '
2080
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2082
except StrictCommitFailed:
2083
raise errors.BzrCommandError("Commit refused because there are"
2084
" unknown files in the working tree.")
2085
except errors.BoundBranchOutOfDate, e:
2086
raise errors.BzrCommandError(str(e) + "\n"
2087
'To commit to master branch, run update and then commit.\n'
2088
'You can also pass --local to commit to continue working '
1034
raise BzrCommandError("no changes to commit",
1035
["use --unchanged to commit anyhow"])
2092
1038
class cmd_check(Command):
2095
1041
This command checks various invariants about the branch storage to
2096
1042
detect data corruption or bzr bugs.
2098
takes_args = ['branch?']
2099
takes_options = ['verbose']
1044
takes_args = ['dir?']
2101
def run(self, branch=None, verbose=False):
1046
def run(self, dir='.'):
2102
1047
from bzrlib.check import check
2104
tree = WorkingTree.open_containing()[0]
2105
branch = tree.branch
2107
branch = Branch.open(branch)
2108
check(branch, verbose)
1049
check(Branch.open_containing(dir))
1052
class cmd_scan_cache(Command):
1055
from bzrlib.hashcache import HashCache
1061
print '%6d stats' % c.stat_count
1062
print '%6d in hashcache' % len(c._cache)
1063
print '%6d files removed from cache' % c.removed_count
1064
print '%6d hashes updated' % c.update_count
1065
print '%6d files changed too recently to cache' % c.danger_count
2111
1072
class cmd_upgrade(Command):
2112
1073
"""Upgrade branch storage to current format.
2114
1075
The check command or bzr developers may sometimes advise you to run
2115
this command. When the default format has changed you may also be warned
2116
during other operations to upgrade.
1078
This version of this command upgrades from the full-text storage
1079
used by bzr 0.0.8 and earlier to the weave format (v5).
2118
takes_args = ['url?']
2120
RegistryOption('format',
2121
help='Upgrade to a specific format. See "bzr help'
2122
' formats" for details',
2123
registry=bzrdir.format_registry,
2124
converter=bzrdir.format_registry.make_bzrdir,
2125
value_switches=True, title='Branch format'),
2129
def run(self, url='.', format=None):
1081
takes_args = ['dir?']
1083
def run(self, dir='.'):
2130
1084
from bzrlib.upgrade import upgrade
2132
format = bzrdir.format_registry.make_bzrdir('default')
2133
upgrade(url, format)
2136
1088
class cmd_whoami(Command):
2137
"""Show or set bzr user id.
2141
bzr whoami 'Frank Chu <fchu@example.com>'
2143
takes_options = [ Option('email',
2144
help='display email address only'),
2146
help='set identity for the current branch instead of '
2149
takes_args = ['name?']
2150
encoding_type = 'replace'
2153
def run(self, email=False, branch=False, name=None):
2155
# use branch if we're inside one; otherwise global config
2157
c = Branch.open_containing('.')[0].get_config()
2158
except errors.NotBranchError:
2159
c = config.GlobalConfig()
2161
self.outf.write(c.user_email() + '\n')
2163
self.outf.write(c.username() + '\n')
2166
# display a warning if an email address isn't included in the given name.
1089
"""Show bzr user id."""
1090
takes_options = ['email']
1092
def run(self, email=False):
2168
config.extract_email_address(name)
2169
except errors.NoEmailInUsername, e:
2170
warning('"%s" does not seem to contain an email address. '
2171
'This is allowed, but not recommended.', name)
1094
b = bzrlib.branch.Branch.open_containing('.')
1095
except NotBranchError:
2173
# use global config unless --branch given
2175
c = Branch.open_containing('.')[0].get_config()
2177
c = config.GlobalConfig()
2178
c.set_user_option('email', name)
2181
class cmd_nick(Command):
2182
"""Print or set the branch nickname.
2184
If unset, the tree root directory name is used as the nickname
2185
To print the current nickname, execute with no argument.
2187
takes_args = ['nickname?']
2188
def run(self, nickname=None):
2189
branch = Branch.open_containing(u'.')[0]
2190
if nickname is None:
2191
self.printme(branch)
2193
branch.nick = nickname
2196
def printme(self, branch):
1099
print bzrlib.osutils.user_email(b)
1101
print bzrlib.osutils.username(b)
2200
1104
class cmd_selftest(Command):
2201
"""Run internal test suite.
2203
This creates temporary test directories in the working directory, but not
2204
existing data is affected. These directories are deleted if the tests
2205
pass, or left behind to help in debugging if they fail and --keep-output
2208
If arguments are given, they are regular expressions that say which tests
2209
should run. Tests matching any expression are run, and other tests are
2212
Alternatively if --first is given, matching tests are run first and then
2213
all other tests are run. This is useful if you have been working in a
2214
particular area, but want to make sure nothing else was broken.
2216
If the global option '--no-plugins' is given, plugins are not loaded
2217
before running the selftests. This has two effects: features provided or
2218
modified by plugins will not be tested, and tests provided by plugins will
2223
run only tests relating to 'ignore'
2224
bzr --no-plugins selftest -v
2225
disable plugins and list tests as they're run
2227
# TODO: --list should give a list of all available tests
2229
# NB: this is used from the class without creating an instance, which is
2230
# why it does not have a self parameter.
2231
def get_transport_type(typestring):
2232
"""Parse and return a transport specifier."""
2233
if typestring == "sftp":
2234
from bzrlib.transport.sftp import SFTPAbsoluteServer
2235
return SFTPAbsoluteServer
2236
if typestring == "memory":
2237
from bzrlib.transport.memory import MemoryServer
2239
if typestring == "fakenfs":
2240
from bzrlib.transport.fakenfs import FakeNFSServer
2241
return FakeNFSServer
2242
msg = "No known transport type %s. Supported types are: sftp\n" %\
2244
raise errors.BzrCommandError(msg)
1105
"""Run internal test suite"""
2247
takes_args = ['testspecs*']
2248
takes_options = ['verbose',
2249
Option('one', help='stop when one test fails'),
2250
Option('keep-output',
2251
help='keep output directories when tests fail'),
2253
help='Use a different transport by default '
2254
'throughout the test suite.',
2255
type=get_transport_type),
2256
Option('benchmark', help='run the bzr bencharks.'),
2257
Option('lsprof-timed',
2258
help='generate lsprof output for benchmarked'
2259
' sections of code.'),
2260
Option('cache-dir', type=str,
2261
help='a directory to cache intermediate'
2262
' benchmark steps'),
2263
Option('clean-output',
2264
help='clean temporary tests directories'
2265
' without running tests'),
2267
help='run all tests, but run specified tests first',
2270
encoding_type = 'replace'
2272
def run(self, testspecs_list=None, verbose=None, one=False,
2273
keep_output=False, transport=None, benchmark=None,
2274
lsprof_timed=None, cache_dir=None, clean_output=False,
1107
takes_options = ['verbose', 'pattern']
1108
def run(self, verbose=False, pattern=".*"):
2276
1109
import bzrlib.ui
2277
from bzrlib.tests import selftest
2278
import bzrlib.benchmarks as benchmarks
2279
from bzrlib.benchmarks import tree_creator
2282
from bzrlib.tests import clean_selftest_output
2283
clean_selftest_output()
2286
if cache_dir is not None:
2287
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2288
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2289
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2291
if testspecs_list is not None:
2292
pattern = '|'.join(testspecs_list)
2296
test_suite_factory = benchmarks.test_suite
2299
# TODO: should possibly lock the history file...
2300
benchfile = open(".perf_history", "at", buffering=1)
2302
test_suite_factory = None
1110
from bzrlib.selftest import selftest
1111
# we don't want progress meters from the tests to go to the
1112
# real output; and we don't want log messages cluttering up
1114
save_ui = bzrlib.ui.ui_factory
1115
bzrlib.trace.info('running tests...')
2307
result = selftest(verbose=verbose,
2309
stop_on_failure=one,
2310
keep_output=keep_output,
2311
transport=transport,
2312
test_suite_factory=test_suite_factory,
2313
lsprof_timed=lsprof_timed,
2314
bench_history=benchfile,
2315
matching_tests_first=first,
1117
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1118
result = selftest(verbose=verbose, pattern=pattern)
1120
bzrlib.trace.info('tests passed')
1122
bzrlib.trace.info('tests failed')
1123
return int(not result)
2318
if benchfile is not None:
2321
info('tests passed')
2323
info('tests failed')
2324
return int(not result)
1125
bzrlib.ui.ui_factory = save_ui
1129
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1130
# is bzrlib itself in a branch?
1131
bzrrev = bzrlib.get_bzr_revision()
1133
print " (bzr checkout, revision %d {%s})" % bzrrev
1134
print bzrlib.__copyright__
1135
print "http://bazaar-ng.org/"
1137
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1138
print "you may use, modify and redistribute it under the terms of the GNU"
1139
print "General Public License version 2 or later."
2327
1142
class cmd_version(Command):
2328
1143
"""Show version of bzr."""
2332
from bzrlib.version import show_version
2336
1147
class cmd_rocks(Command):
2337
1148
"""Statement of optimism."""
2343
1151
print "it sure does!"
2346
1154
class cmd_find_merge_base(Command):
2347
"""Find and print a base revision for merging two branches."""
2348
# TODO: Options to specify revisions on either side, as if
2349
# merging only part of the history.
1155
"""Find and print a base revision for merging two branches.
1157
TODO: Options to specify revisions on either side, as if
1158
merging only part of the history.
2350
1160
takes_args = ['branch', 'other']
2354
1163
def run(self, branch, other):
2355
from bzrlib.revision import MultipleRevisionSources
1164
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2357
branch1 = Branch.open_containing(branch)[0]
2358
branch2 = Branch.open_containing(other)[0]
1166
branch1 = Branch.open_containing(branch)
1167
branch2 = Branch.open_containing(other)
1169
history_1 = branch1.revision_history()
1170
history_2 = branch2.revision_history()
2360
1172
last1 = branch1.last_revision()
2361
1173
last2 = branch2.last_revision()
2363
source = MultipleRevisionSources(branch1.repository,
1175
source = MultipleRevisionSources(branch1, branch2)
2366
1177
base_rev_id = common_ancestor(last1, last2, source)
2368
1179
print 'merge base is revision %s' % base_rev_id
1183
if base_revno is None:
1184
raise bzrlib.errors.UnrelatedBranches()
1186
print ' r%-6d in %s' % (base_revno, branch)
1188
other_revno = branch2.revision_id_to_revno(base_revid)
1190
print ' r%-6d in %s' % (other_revno, other)
2371
1194
class cmd_merge(Command):
2372
1195
"""Perform a three-way merge.
2374
The branch is the branch you will merge from. By default, it will merge
2375
the latest revision. If you specify a revision, that revision will be
2376
merged. If you specify two revisions, the first will be used as a BASE,
2377
and the second one as OTHER. Revision numbers are always relative to the
1197
The branch is the branch you will merge from. By default, it will
1198
merge the latest revision. If you specify a revision, that
1199
revision will be merged. If you specify two revisions, the first
1200
will be used as a BASE, and the second one as OTHER. Revision
1201
numbers are always relative to the specified branch.
2380
By default, bzr will try to merge in all new work from the other
1203
By default bzr will try to merge in all new work from the other
2381
1204
branch, automatically determining an appropriate base. If this
2382
1205
fails, you may need to give an explicit base.
2384
Merge will do its best to combine the changes in two branches, but there
2385
are some kinds of problems only a human can fix. When it encounters those,
2386
it will mark a conflict. A conflict means that you need to fix something,
2387
before you should commit.
2389
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2391
If there is no default branch set, the first merge will set it. After
2392
that, you can omit the branch to use the default. To change the
2393
default, use --remember. The value will only be saved if the remote
2394
location can be accessed.
2396
The results of the merge are placed into the destination working
2397
directory, where they can be reviewed (with bzr diff), tested, and then
2398
committed to record the result of the merge.
2402
1209
To merge the latest revision from bzr.dev
2411
1218
merge refuses to run if there are any uncommitted changes, unless
2412
1219
--force is given.
2414
The following merge types are available:
2416
1221
takes_args = ['branch?']
2417
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2418
Option('show-base', help="Show base revision text in "
2420
Option('uncommitted', help='Apply uncommitted changes'
2421
' from a working copy, instead of branch changes'),
2422
Option('pull', help='If the destination is already'
2423
' completely merged into the source, pull from the'
2424
' source rather than merging. When this happens,'
2425
' you do not need to commit the result.'),
2427
help='branch to merge into, '
2428
'rather than the one containing the working directory',
1222
takes_options = ['revision', 'force', 'merge-type']
2434
def run(self, branch=None, revision=None, force=False, merge_type=None,
2435
show_base=False, reprocess=False, remember=False,
2436
uncommitted=False, pull=False,
1224
def run(self, branch='.', revision=None, force=False,
1226
from bzrlib.merge import merge
1227
from bzrlib.merge_core import ApplyMerge3
2439
1228
if merge_type is None:
2440
merge_type = _mod_merge.Merge3Merger
2442
if directory is None: directory = u'.'
2443
tree = WorkingTree.open_containing(directory)[0]
2444
change_reporter = delta.ChangeReporter(tree.inventory)
2446
if branch is not None:
2448
reader = bundle.read_bundle_from_url(branch)
2449
except errors.NotABundle:
2450
pass # Continue on considering this url a Branch
2452
conflicts = merge_bundle(reader, tree, not force, merge_type,
2453
reprocess, show_base, change_reporter)
2459
if revision is None \
2460
or len(revision) < 1 or revision[0].needs_branch():
2461
branch = self._get_remembered_parent(tree, branch, 'Merging from')
1229
merge_type = ApplyMerge3
2463
1231
if revision is None or len(revision) < 1:
2466
other = [branch, None]
2469
other = [branch, -1]
2470
other_branch, path = Branch.open_containing(branch)
1233
other = [branch, -1]
2473
raise errors.BzrCommandError('Cannot use --uncommitted and'
2474
' --revision at the same time.')
2475
branch = revision[0].get_branch() or branch
2476
1235
if len(revision) == 1:
2477
1236
base = [None, None]
2478
other_branch, path = Branch.open_containing(branch)
2479
revno = revision[0].in_history(other_branch).revno
2480
other = [branch, revno]
1237
other = [branch, revision[0].in_history(branch).revno]
2482
1239
assert len(revision) == 2
2483
1240
if None in revision:
2484
raise errors.BzrCommandError(
2485
"Merge doesn't permit empty revision specifier.")
2486
base_branch, path = Branch.open_containing(branch)
2487
branch1 = revision[1].get_branch() or branch
2488
other_branch, path1 = Branch.open_containing(branch1)
2489
if revision[0].get_branch() is not None:
2490
# then path was obtained from it, and is None.
2493
base = [branch, revision[0].in_history(base_branch).revno]
2494
other = [branch1, revision[1].in_history(other_branch).revno]
2496
if tree.branch.get_parent() is None or remember:
2497
tree.branch.set_parent(other_branch.base)
2500
interesting_files = [path]
2502
interesting_files = None
2503
pb = ui.ui_factory.nested_progress_bar()
1241
raise BzrCommandError(
1242
"Merge doesn't permit that revision specifier.")
1243
from bzrlib.branch import Branch
1244
b = Branch.open(branch)
1246
base = [branch, revision[0].in_history(b).revno]
1247
other = [branch, revision[1].in_history(b).revno]
2506
conflict_count = _merge_helper(
2507
other, base, check_clean=(not force),
2508
merge_type=merge_type,
2509
reprocess=reprocess,
2510
show_base=show_base,
2513
pb=pb, file_list=interesting_files,
2514
change_reporter=change_reporter)
2517
if conflict_count != 0:
2521
except errors.AmbiguousBase, e:
1250
merge(other, base, check_clean=(not force), merge_type=merge_type)
1251
except bzrlib.errors.AmbiguousBase, e:
2522
1252
m = ("sorry, bzr can't determine the right merge base yet\n"
2523
1253
"candidates are:\n "
2524
1254
+ "\n ".join(e.bases)
2527
1257
"and (if you want) report this to the bzr developers\n")
2530
# TODO: move up to common parent; this isn't merge-specific anymore.
2531
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2532
"""Use tree.branch's parent if none was supplied.
2534
Report if the remembered location was used.
2536
if supplied_location is not None:
2537
return supplied_location
2538
stored_location = tree.branch.get_parent()
2539
mutter("%s", stored_location)
2540
if stored_location is None:
2541
raise errors.BzrCommandError("No location specified or remembered")
2542
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2543
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2544
return stored_location
2547
class cmd_remerge(Command):
2550
Use this if you want to try a different merge technique while resolving
2551
conflicts. Some merge techniques are better than others, and remerge
2552
lets you try different ones on different files.
2554
The options for remerge have the same meaning and defaults as the ones for
2555
merge. The difference is that remerge can (only) be run when there is a
2556
pending merge, and it lets you specify particular files.
2559
$ bzr remerge --show-base
2560
Re-do the merge of all conflicted files, and show the base text in
2561
conflict regions, in addition to the usual THIS and OTHER texts.
2563
$ bzr remerge --merge-type weave --reprocess foobar
2564
Re-do the merge of "foobar", using the weave merge algorithm, with
2565
additional processing to reduce the size of conflict regions.
2567
The following merge types are available:"""
2568
takes_args = ['file*']
2569
takes_options = ['merge-type', 'reprocess',
2570
Option('show-base', help="Show base revision text in "
2573
def run(self, file_list=None, merge_type=None, show_base=False,
2575
if merge_type is None:
2576
merge_type = _mod_merge.Merge3Merger
2577
tree, file_list = tree_files(file_list)
2580
parents = tree.get_parent_ids()
2581
if len(parents) != 2:
2582
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2583
" merges. Not cherrypicking or"
2585
repository = tree.branch.repository
2586
base_revision = common_ancestor(parents[0],
2587
parents[1], repository)
2588
base_tree = repository.revision_tree(base_revision)
2589
other_tree = repository.revision_tree(parents[1])
2590
interesting_ids = None
2592
conflicts = tree.conflicts()
2593
if file_list is not None:
2594
interesting_ids = set()
2595
for filename in file_list:
2596
file_id = tree.path2id(filename)
2598
raise errors.NotVersionedError(filename)
2599
interesting_ids.add(file_id)
2600
if tree.kind(file_id) != "directory":
2603
for name, ie in tree.inventory.iter_entries(file_id):
2604
interesting_ids.add(ie.file_id)
2605
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2607
# Remerge only supports resolving contents conflicts
2608
allowed_conflicts = ('text conflict', 'contents conflict')
2609
restore_files = [c.path for c in conflicts
2610
if c.typestring in allowed_conflicts]
2611
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2612
tree.set_conflicts(ConflictList(new_conflicts))
2613
if file_list is not None:
2614
restore_files = file_list
2615
for filename in restore_files:
2617
restore(tree.abspath(filename))
2618
except errors.NotConflicted:
2620
conflicts = _mod_merge.merge_inner(
2621
tree.branch, other_tree, base_tree,
2623
interesting_ids=interesting_ids,
2624
other_rev_id=parents[1],
2625
merge_type=merge_type,
2626
show_base=show_base,
2627
reprocess=reprocess)
2636
1261
class cmd_revert(Command):
2637
"""Revert files to a previous revision.
2639
Giving a list of files will revert only those files. Otherwise, all files
2640
will be reverted. If the revision is not specified with '--revision', the
2641
last committed revision is used.
2643
To remove only some changes, without reverting to a prior version, use
2644
merge instead. For example, "merge . --r-2..-3" will remove the changes
2645
introduced by -2, without affecting the changes introduced by -1. Or
2646
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2648
By default, any files that have been manually changed will be backed up
2649
first. (Files changed only by merge are not backed up.) Backup files have
2650
'.~#~' appended to their name, where # is a number.
2652
When you provide files, you can use their current pathname or the pathname
2653
from the target revision. So you can use revert to "undelete" a file by
2654
name. If you name a directory, all the contents of that directory will be
1262
"""Reverse all changes since the last commit.
1264
Only versioned files are affected. Specify filenames to revert only
1265
those files. By default, any files that are changed will be backed up
1266
first. Backup files have a '~' appended to their name.
2657
1268
takes_options = ['revision', 'no-backup']
2658
1269
takes_args = ['file*']
2659
1270
aliases = ['merge-revert']
2661
1272
def run(self, revision=None, no_backup=False, file_list=None):
1273
from bzrlib.merge import merge
1274
from bzrlib.branch import Branch
1275
from bzrlib.commands import parse_spec
2662
1277
if file_list is not None:
2663
1278
if len(file_list) == 0:
2664
raise errors.BzrCommandError("No files specified")
2668
tree, file_list = tree_files(file_list)
1279
raise BzrCommandError("No files specified")
2669
1280
if revision is None:
2670
# FIXME should be tree.last_revision
2671
rev_id = tree.last_revision()
2672
1282
elif len(revision) != 1:
2673
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
1283
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2675
rev_id = revision[0].in_history(tree.branch).rev_id
2676
pb = ui.ui_factory.nested_progress_bar()
2678
tree.revert(file_list,
2679
tree.branch.repository.revision_tree(rev_id),
2680
not no_backup, pb, report_changes=True)
1285
b = Branch.open_containing('.')
1286
revno = revision[0].in_history(b).revno
1287
merge(('.', revno), parse_spec('.'),
1290
backup_files=not no_backup,
1291
file_list=file_list)
1293
Branch.open_containing('.').set_pending_merges([])
2685
1296
class cmd_assert_fail(Command):
2686
1297
"""Test reporting of assertion failures"""
2687
# intended just for use in testing
2692
raise AssertionError("always fails")
1300
assert False, "always fails"
2695
1303
class cmd_help(Command):
2696
1304
"""Show help on a command or other topic.
2698
For a list of all available commands, say 'bzr help commands'.
2700
takes_options = [Option('long', 'show help on all commands')]
1306
For a list of all available commands, say 'bzr help commands'."""
1307
takes_options = ['long']
2701
1308
takes_args = ['topic?']
2702
aliases = ['?', '--help', '-?', '-h']
2705
1311
def run(self, topic=None, long=False):
2707
1313
if topic is None and long:
2708
1314
topic = "commands"
2709
bzrlib.help.help(topic)
2712
1318
class cmd_shell_complete(Command):
2713
1319
"""Show appropriate completions for context.
2715
For a list of all available commands, say 'bzr shell-complete'.
1321
For a list of all available commands, say 'bzr shell-complete'."""
2717
1322
takes_args = ['context?']
2718
1323
aliases = ['s-c']
2722
1326
def run(self, context=None):
2723
1327
import shellcomplete
2724
1328
shellcomplete.shellcomplete(context)
2727
1331
class cmd_fetch(Command):
2728
1332
"""Copy in history from another branch but don't merge it.
2730
This is an internal method used for pull and merge.
1334
This is an internal method used for pull and merge."""
2733
1336
takes_args = ['from_branch', 'to_branch']
2734
1337
def run(self, from_branch, to_branch):
2735
1338
from bzrlib.fetch import Fetcher
2736
from_b = Branch.open(from_branch)
2737
to_b = Branch.open(to_branch)
1339
from bzrlib.branch import Branch
1340
from_b = Branch(from_branch)
1341
to_b = Branch(to_branch)
2738
1342
Fetcher(to_b, from_b)
2741
1346
class cmd_missing(Command):
2742
"""Show unmerged/unpulled revisions between two branches.
2744
OTHER_BRANCH may be local or remote.
1347
"""What is missing in this branch relative to other branch.
2746
takes_args = ['other_branch?']
2747
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2749
'Display changes in the local branch only'),
2750
Option('theirs-only',
2751
'Display changes in the remote branch only'),
2756
encoding_type = 'replace'
2759
def run(self, other_branch=None, reverse=False, mine_only=False,
2760
theirs_only=False, log_format=None, long=False, short=False, line=False,
2761
show_ids=False, verbose=False):
2762
from bzrlib.missing import find_unmerged, iter_log_data
2763
from bzrlib.log import log_formatter
2764
local_branch = Branch.open_containing(u".")[0]
2765
parent = local_branch.get_parent()
2766
if other_branch is None:
2767
other_branch = parent
2768
if other_branch is None:
2769
raise errors.BzrCommandError("No peer location known or specified.")
2770
display_url = urlutils.unescape_for_display(parent,
2772
print "Using last location: " + display_url
2774
remote_branch = Branch.open(other_branch)
2775
if remote_branch.base == local_branch.base:
2776
remote_branch = local_branch
2777
local_branch.lock_read()
2779
remote_branch.lock_read()
2781
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2782
if (log_format is None):
2783
log_format = log.log_formatter_registry.get_default(
2785
lf = log_format(to_file=self.outf,
2787
show_timezone='original')
2788
if reverse is False:
2789
local_extra.reverse()
2790
remote_extra.reverse()
2791
if local_extra and not theirs_only:
2792
print "You have %d extra revision(s):" % len(local_extra)
2793
for data in iter_log_data(local_extra, local_branch.repository,
2796
printed_local = True
2798
printed_local = False
2799
if remote_extra and not mine_only:
2800
if printed_local is True:
2802
print "You are missing %d revision(s):" % len(remote_extra)
2803
for data in iter_log_data(remote_extra, remote_branch.repository,
2806
if not remote_extra and not local_extra:
2808
print "Branches are up to date."
2812
remote_branch.unlock()
2814
local_branch.unlock()
2815
if not status_code and parent is None and other_branch is not None:
2816
local_branch.lock_write()
2818
# handle race conditions - a parent might be set while we run.
2819
if local_branch.get_parent() is None:
2820
local_branch.set_parent(remote_branch.base)
2822
local_branch.unlock()
1349
# TODO: rewrite this in terms of ancestry so that it shows only
1352
takes_args = ['remote?']
1353
aliases = ['mis', 'miss']
1354
# We don't have to add quiet to the list, because
1355
# unknown options are parsed as booleans
1356
takes_options = ['verbose', 'quiet']
1358
def run(self, remote=None, verbose=False, quiet=False):
1359
from bzrlib.errors import BzrCommandError
1360
from bzrlib.missing import show_missing
1362
if verbose and quiet:
1363
raise BzrCommandError('Cannot pass both quiet and verbose')
1365
b = Branch.open_containing('.')
1366
parent = b.get_parent()
1369
raise BzrCommandError("No missing location known or specified.")
1372
print "Using last location: %s" % parent
1374
elif parent is None:
1375
# We only update parent if it did not exist, missing
1376
# should not change the parent
1377
b.set_parent(remote)
1378
br_remote = Branch.open_containing(remote)
1379
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
2826
1382
class cmd_plugins(Command):
2827
1383
"""List plugins"""
2831
1386
import bzrlib.plugin
2832
1387
from inspect import getdoc
2833
for name, plugin in bzrlib.plugin.all_plugins().items():
2834
if getattr(plugin, '__path__', None) is not None:
1388
for plugin in bzrlib.plugin.all_plugins:
1389
if hasattr(plugin, '__path__'):
2835
1390
print plugin.__path__[0]
2836
elif getattr(plugin, '__file__', None) is not None:
1391
elif hasattr(plugin, '__file__'):
2837
1392
print plugin.__file__
2841
1396
d = getdoc(plugin)
2843
1398
print '\t', d.split('\n')[0]
2846
class cmd_testament(Command):
2847
"""Show testament (signing-form) of a revision."""
2848
takes_options = ['revision',
2849
Option('long', help='Produce long-format testament'),
2850
Option('strict', help='Produce a strict-format'
2852
takes_args = ['branch?']
2854
def run(self, branch=u'.', revision=None, long=False, strict=False):
2855
from bzrlib.testament import Testament, StrictTestament
2857
testament_class = StrictTestament
2859
testament_class = Testament
2860
b = WorkingTree.open_containing(branch)[0].branch
2863
if revision is None:
2864
rev_id = b.last_revision()
2866
rev_id = revision[0].in_history(b).rev_id
2867
t = testament_class.from_revision(b.repository, rev_id)
2869
sys.stdout.writelines(t.as_text_lines())
2871
sys.stdout.write(t.as_short_text())
2876
class cmd_annotate(Command):
2877
"""Show the origin of each line in a file.
2879
This prints out the given file with an annotation on the left side
2880
indicating which revision, author and date introduced the change.
2882
If the origin is the same for a run of consecutive lines, it is
2883
shown only at the top, unless the --all option is given.
2885
# TODO: annotate directories; showing when each file was last changed
2886
# TODO: if the working copy is modified, show annotations on that
2887
# with new uncommitted lines marked
2888
aliases = ['ann', 'blame', 'praise']
2889
takes_args = ['filename']
2890
takes_options = [Option('all', help='show annotations on all lines'),
2891
Option('long', help='show date in annotations'),
2897
def run(self, filename, all=False, long=False, revision=None,
2899
from bzrlib.annotate import annotate_file
2900
tree, relpath = WorkingTree.open_containing(filename)
2901
branch = tree.branch
2904
if revision is None:
2905
revision_id = branch.last_revision()
2906
elif len(revision) != 1:
2907
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2909
revision_id = revision[0].in_history(branch).rev_id
2910
file_id = tree.inventory.path2id(relpath)
2911
tree = branch.repository.revision_tree(revision_id)
2912
file_version = tree.inventory[file_id].revision
2913
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
2919
class cmd_re_sign(Command):
2920
"""Create a digital signature for an existing revision."""
2921
# TODO be able to replace existing ones.
2923
hidden = True # is this right ?
2924
takes_args = ['revision_id*']
2925
takes_options = ['revision']
2927
def run(self, revision_id_list=None, revision=None):
2928
import bzrlib.gpg as gpg
2929
if revision_id_list is not None and revision is not None:
2930
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2931
if revision_id_list is None and revision is None:
2932
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2933
b = WorkingTree.open_containing(u'.')[0].branch
2934
gpg_strategy = gpg.GPGStrategy(b.get_config())
2935
if revision_id_list is not None:
2936
for revision_id in revision_id_list:
2937
b.repository.sign_revision(revision_id, gpg_strategy)
2938
elif revision is not None:
2939
if len(revision) == 1:
2940
revno, rev_id = revision[0].in_history(b)
2941
b.repository.sign_revision(rev_id, gpg_strategy)
2942
elif len(revision) == 2:
2943
# are they both on rh- if so we can walk between them
2944
# might be nice to have a range helper for arbitrary
2945
# revision paths. hmm.
2946
from_revno, from_revid = revision[0].in_history(b)
2947
to_revno, to_revid = revision[1].in_history(b)
2948
if to_revid is None:
2949
to_revno = b.revno()
2950
if from_revno is None or to_revno is None:
2951
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
2952
for revno in range(from_revno, to_revno + 1):
2953
b.repository.sign_revision(b.get_rev_id(revno),
2956
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2959
class cmd_bind(Command):
2960
"""Convert the current branch into a checkout of the supplied branch.
2962
Once converted into a checkout, commits must succeed on the master branch
2963
before they will be applied to the local branch.
2965
See "help checkouts" for more information on checkouts.
2968
takes_args = ['location?']
2971
def run(self, location=None):
2972
b, relpath = Branch.open_containing(u'.')
2973
if location is None:
2975
location = b.get_old_bound_location()
2976
except errors.UpgradeRequired:
2977
raise errors.BzrCommandError('No location supplied. '
2978
'This format does not remember old locations.')
2980
if location is None:
2981
raise errors.BzrCommandError('No location supplied and no '
2982
'previous location known')
2983
b_other = Branch.open(location)
2986
except errors.DivergedBranches:
2987
raise errors.BzrCommandError('These branches have diverged.'
2988
' Try merging, and then bind again.')
2991
class cmd_unbind(Command):
2992
"""Convert the current checkout into a regular branch.
2994
After unbinding, the local branch is considered independent and subsequent
2995
commits will be local only.
2997
See "help checkouts" for more information on checkouts.
3004
b, relpath = Branch.open_containing(u'.')
3006
raise errors.BzrCommandError('Local branch is not bound')
3009
class cmd_uncommit(Command):
3010
"""Remove the last committed revision.
3012
--verbose will print out what is being removed.
3013
--dry-run will go through all the motions, but not actually
3016
In the future, uncommit will create a revision bundle, which can then
3020
# TODO: jam 20060108 Add an option to allow uncommit to remove
3021
# unreferenced information in 'branch-as-repository' branches.
3022
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3023
# information in shared branches as well.
3024
takes_options = ['verbose', 'revision',
3025
Option('dry-run', help='Don\'t actually make changes'),
3026
Option('force', help='Say yes to all questions.')]
3027
takes_args = ['location?']
3030
def run(self, location=None,
3031
dry_run=False, verbose=False,
3032
revision=None, force=False):
3033
from bzrlib.log import log_formatter, show_log
3035
from bzrlib.uncommit import uncommit
3037
if location is None:
3039
control, relpath = bzrdir.BzrDir.open_containing(location)
3041
tree = control.open_workingtree()
3043
except (errors.NoWorkingTree, errors.NotLocalUrl):
3045
b = control.open_branch()
3048
if revision is None:
3051
# 'bzr uncommit -r 10' actually means uncommit
3052
# so that the final tree is at revno 10.
3053
# but bzrlib.uncommit.uncommit() actually uncommits
3054
# the revisions that are supplied.
3055
# So we need to offset it by one
3056
revno = revision[0].in_history(b).revno+1
3058
if revno <= b.revno():
3059
rev_id = b.get_rev_id(revno)
3061
self.outf.write('No revisions to uncommit.\n')
3064
lf = log_formatter('short',
3066
show_timezone='original')
3071
direction='forward',
3072
start_revision=revno,
3073
end_revision=b.revno())
3076
print 'Dry-run, pretending to remove the above revisions.'
3078
val = raw_input('Press <enter> to continue')
3080
print 'The above revision(s) will be removed.'
3082
val = raw_input('Are you sure [y/N]? ')
3083
if val.lower() not in ('y', 'yes'):
3087
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3091
class cmd_break_lock(Command):
3092
"""Break a dead lock on a repository, branch or working directory.
3094
CAUTION: Locks should only be broken when you are sure that the process
3095
holding the lock has been stopped.
3097
You can get information on what locks are open via the 'bzr info' command.
3102
takes_args = ['location?']
3104
def run(self, location=None, show=False):
3105
if location is None:
3107
control, relpath = bzrdir.BzrDir.open_containing(location)
3109
control.break_lock()
3110
except NotImplementedError:
3114
class cmd_wait_until_signalled(Command):
3115
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3117
This just prints a line to signal when it is ready, then blocks on stdin.
3123
sys.stdout.write("running\n")
3125
sys.stdin.readline()
3128
class cmd_serve(Command):
3129
"""Run the bzr server."""
3131
aliases = ['server']
3135
help='serve on stdin/out for use from inetd or sshd'),
3137
help='listen for connections on nominated port of the form '
3138
'[hostname:]portnumber. Passing 0 as the port number will '
3139
'result in a dynamically allocated port.',
3142
help='serve contents of directory',
3144
Option('allow-writes',
3145
help='By default the server is a readonly server. Supplying '
3146
'--allow-writes enables write access to the contents of '
3147
'the served directory and below. '
3151
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3152
from bzrlib.transport import smart
3153
from bzrlib.transport import get_transport
3154
if directory is None:
3155
directory = os.getcwd()
3156
url = urlutils.local_path_to_url(directory)
3157
if not allow_writes:
3158
url = 'readonly+' + url
3159
t = get_transport(url)
3161
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
3162
elif port is not None:
3164
host, port = port.split(':')
3167
server = smart.SmartTCPServer(t, host=host, port=int(port))
3168
print 'listening on port: ', server.port
3171
raise errors.BzrCommandError("bzr serve requires one of --inet or --port")
3175
# command-line interpretation helper for merge-related commands
3176
def _merge_helper(other_revision, base_revision,
3177
check_clean=True, ignore_zero=False,
3178
this_dir=None, backup_files=False,
3180
file_list=None, show_base=False, reprocess=False,
3183
change_reporter=None):
3184
"""Merge changes into a tree.
3187
list(path, revno) Base for three-way merge.
3188
If [None, None] then a base will be automatically determined.
3190
list(path, revno) Other revision for three-way merge.
3192
Directory to merge changes into; '.' by default.
3194
If true, this_dir must have no uncommitted changes before the
3196
ignore_zero - If true, suppress the "zero conflicts" message when
3197
there are no conflicts; should be set when doing something we expect
3198
to complete perfectly.
3199
file_list - If supplied, merge only changes to selected files.
3201
All available ancestors of other_revision and base_revision are
3202
automatically pulled into the branch.
3204
The revno may be -1 to indicate the last revision on the branch, which is
3207
This function is intended for use from the command line; programmatic
3208
clients might prefer to call merge.merge_inner(), which has less magic
3211
# Loading it late, so that we don't always have to import bzrlib.merge
3212
if merge_type is None:
3213
merge_type = _mod_merge.Merge3Merger
3214
if this_dir is None:
3216
this_tree = WorkingTree.open_containing(this_dir)[0]
3217
if show_base and not merge_type is _mod_merge.Merge3Merger:
3218
raise errors.BzrCommandError("Show-base is not supported for this merge"
3219
" type. %s" % merge_type)
3220
if reprocess and not merge_type.supports_reprocess:
3221
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3222
" type %s." % merge_type)
3223
if reprocess and show_base:
3224
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3226
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3227
pb=pb, change_reporter=change_reporter)
3228
merger.pp = ProgressPhase("Merge phase", 5, pb)
3229
merger.pp.next_phase()
3230
merger.check_basis(check_clean)
3231
merger.set_other(other_revision)
3232
merger.pp.next_phase()
3233
merger.set_base(base_revision)
3234
if merger.base_rev_id == merger.other_rev_id:
3235
note('Nothing to do.')
3237
if file_list is None:
3238
if pull and merger.base_rev_id == merger.this_rev_id:
3239
count = merger.this_tree.pull(merger.this_branch,
3240
False, merger.other_rev_id)
3241
note('%d revision(s) pulled.' % (count,))
3243
merger.backup_files = backup_files
3244
merger.merge_type = merge_type
3245
merger.set_interesting_files(file_list)
3246
merger.show_base = show_base
3247
merger.reprocess = reprocess
3248
conflicts = merger.do_merge()
3249
if file_list is None:
3250
merger.set_pending()
3257
merge = _merge_helper
3260
# these get imported and then picked up by the scan for cmd_*
3261
# TODO: Some more consistent way to split command definitions across files;
3262
# we do need to load at least some information about them to know of
3263
# aliases. ideally we would avoid loading the implementation until the
3264
# details were needed.
3265
from bzrlib.cmd_version_info import cmd_version_info
3266
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3267
from bzrlib.bundle.commands import cmd_bundle_revisions
3268
from bzrlib.sign_my_commits import cmd_sign_my_commits
3269
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3270
cmd_weave_plan_merge, cmd_weave_merge_text