1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""builtin bzr commands"""
27
from bzrlib.branch import Branch, BranchReferenceFormat
28
from bzrlib import (bundle, branch, bzrdir, errors, osutils, ui, config,
30
from bzrlib.bundle import read_bundle_from_url
31
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
32
from bzrlib.conflicts import ConflictList
33
from bzrlib.commands import Command, display_command
34
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch,
37
NotVersionedError, NotABundle)
38
from bzrlib.merge import Merge3Merger
39
from bzrlib.option import Option
40
from bzrlib.progress import DummyProgress, ProgressPhase
41
from bzrlib.revision import common_ancestor
42
from bzrlib.revisionspec import RevisionSpec
43
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
44
from bzrlib.transport.local import LocalTransport
45
import bzrlib.urlutils as urlutils
46
from bzrlib.workingtree import WorkingTree
49
def tree_files(file_list, default_branch=u'.'):
51
return internal_tree_files(file_list, default_branch)
52
except FileInWrongBranch, e:
53
raise BzrCommandError("%s is not in the same branch as %s" %
54
(e.path, file_list[0]))
57
# XXX: Bad function name; should possibly also be a class method of
58
# WorkingTree rather than a function.
59
def internal_tree_files(file_list, default_branch=u'.'):
60
"""Convert command-line paths to a WorkingTree and relative paths.
62
This is typically used for command-line processors that take one or
63
more filenames, and infer the workingtree that contains them.
65
The filenames given are not required to exist.
67
:param file_list: Filenames to convert.
69
:param default_branch: Fallback tree path to use if file_list is empty or None.
71
:return: workingtree, [relative_paths]
73
if file_list is None or len(file_list) == 0:
74
return WorkingTree.open_containing(default_branch)[0], file_list
75
tree = WorkingTree.open_containing(file_list[0])[0]
77
for filename in file_list:
79
new_list.append(tree.relpath(filename))
80
except errors.PathNotChild:
81
raise FileInWrongBranch(tree.branch, filename)
85
def get_format_type(typestring):
86
"""Parse and return a format specifier."""
87
if typestring == "weave":
88
return bzrdir.BzrDirFormat6()
89
if typestring == "default":
90
return bzrdir.BzrDirMetaFormat1()
91
if typestring == "metaweave":
92
format = bzrdir.BzrDirMetaFormat1()
93
format.repository_format = repository.RepositoryFormat7()
95
if typestring == "knit":
96
format = bzrdir.BzrDirMetaFormat1()
97
format.repository_format = repository.RepositoryFormatKnit1()
99
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
100
"metaweave and weave" % typestring
101
raise BzrCommandError(msg)
104
# TODO: Make sure no commands unconditionally use the working directory as a
105
# branch. If a filename argument is used, the first of them should be used to
106
# specify the branch. (Perhaps this can be factored out into some kind of
107
# Argument class, representing a file in a branch, where the first occurrence
110
class cmd_status(Command):
111
"""Display status summary.
113
This reports on versioned and unknown files, reporting them
114
grouped by state. Possible states are:
117
Versioned in the working copy but not in the previous revision.
120
Versioned in the previous revision but removed or deleted
124
Path of this file changed from the previous revision;
125
the text may also have changed. This includes files whose
126
parent directory was renamed.
129
Text has changed since the previous revision.
132
Not versioned and not matching an ignore pattern.
134
To see ignored files use 'bzr ignored'. For details in the
135
changes to file texts, use 'bzr diff'.
137
If no arguments are specified, the status of the entire working
138
directory is shown. Otherwise, only the status of the specified
139
files or directories is reported. If a directory is given, status
140
is reported for everything inside that directory.
142
If a revision argument is given, the status is calculated against
143
that revision, or between two revisions if two are provided.
146
# TODO: --no-recurse, --recurse options
148
takes_args = ['file*']
149
takes_options = ['show-ids', 'revision']
150
aliases = ['st', 'stat']
152
encoding_type = 'replace'
155
def run(self, show_ids=False, file_list=None, revision=None):
156
from bzrlib.status import show_tree_status
158
tree, file_list = tree_files(file_list)
160
show_tree_status(tree, show_ids=show_ids,
161
specific_files=file_list, revision=revision,
165
class cmd_cat_revision(Command):
166
"""Write out metadata for a revision.
168
The revision to print can either be specified by a specific
169
revision identifier, or you can use --revision.
173
takes_args = ['revision_id?']
174
takes_options = ['revision']
175
# cat-revision is more for frontends so should be exact
179
def run(self, revision_id=None, revision=None):
181
if revision_id is not None and revision is not None:
182
raise BzrCommandError('You can only supply one of revision_id or --revision')
183
if revision_id is None and revision is None:
184
raise BzrCommandError('You must supply either --revision or a revision_id')
185
b = WorkingTree.open_containing(u'.')[0].branch
187
# TODO: jam 20060112 should cat-revision always output utf-8?
188
if revision_id is not None:
189
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
190
elif revision is not None:
193
raise BzrCommandError('You cannot specify a NULL revision.')
194
revno, rev_id = rev.in_history(b)
195
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
198
class cmd_revno(Command):
199
"""Show current revision number.
201
This is equal to the number of revisions on this branch.
204
takes_args = ['location?']
207
def run(self, location=u'.'):
208
self.outf.write(str(Branch.open_containing(location)[0].revno()))
209
self.outf.write('\n')
212
class cmd_revision_info(Command):
213
"""Show revision number and revision id for a given revision identifier.
216
takes_args = ['revision_info*']
217
takes_options = ['revision']
220
def run(self, revision=None, revision_info_list=[]):
223
if revision is not None:
224
revs.extend(revision)
225
if revision_info_list is not None:
226
for rev in revision_info_list:
227
revs.append(RevisionSpec(rev))
229
raise BzrCommandError('You must supply a revision identifier')
231
b = WorkingTree.open_containing(u'.')[0].branch
234
revinfo = rev.in_history(b)
235
if revinfo.revno is None:
236
print ' %s' % revinfo.rev_id
238
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
241
class cmd_add(Command):
242
"""Add specified files or directories.
244
In non-recursive mode, all the named items are added, regardless
245
of whether they were previously ignored. A warning is given if
246
any of the named files are already versioned.
248
In recursive mode (the default), files are treated the same way
249
but the behaviour for directories is different. Directories that
250
are already versioned do not give a warning. All directories,
251
whether already versioned or not, are searched for files or
252
subdirectories that are neither versioned or ignored, and these
253
are added. This search proceeds recursively into versioned
254
directories. If no names are given '.' is assumed.
256
Therefore simply saying 'bzr add' will version all files that
257
are currently unknown.
259
Adding a file whose parent directory is not versioned will
260
implicitly add the parent, and so on up to the root. This means
261
you should never need to explicitly add a directory, they'll just
262
get added when you add a file in the directory.
264
--dry-run will show which files would be added, but not actually
267
takes_args = ['file*']
268
takes_options = ['no-recurse', 'dry-run', 'verbose']
269
encoding_type = 'replace'
271
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
274
action = bzrlib.add.AddAction(to_file=self.outf,
275
should_print=(not is_quiet()))
277
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
278
action=action, save=not dry_run)
281
for glob in sorted(ignored.keys()):
282
for path in ignored[glob]:
283
self.outf.write("ignored %s matching \"%s\"\n"
287
for glob, paths in ignored.items():
288
match_len += len(paths)
289
self.outf.write("ignored %d file(s).\n" % match_len)
290
self.outf.write("If you wish to add some of these files,"
291
" please add them by name.\n")
294
class cmd_mkdir(Command):
295
"""Create a new versioned directory.
297
This is equivalent to creating the directory and then adding it.
300
takes_args = ['dir+']
301
encoding_type = 'replace'
303
def run(self, dir_list):
306
wt, dd = WorkingTree.open_containing(d)
308
self.outf.write('added %s\n' % d)
311
class cmd_relpath(Command):
312
"""Show path of a file relative to root"""
314
takes_args = ['filename']
318
def run(self, filename):
319
# TODO: jam 20050106 Can relpath return a munged path if
320
# sys.stdout encoding cannot represent it?
321
tree, relpath = WorkingTree.open_containing(filename)
322
self.outf.write(relpath)
323
self.outf.write('\n')
326
class cmd_inventory(Command):
327
"""Show inventory of the current working copy or a revision.
329
It is possible to limit the output to a particular entry
330
type using the --kind option. For example; --kind file.
333
takes_options = ['revision', 'show-ids', 'kind']
336
def run(self, revision=None, show_ids=False, kind=None):
337
if kind and kind not in ['file', 'directory', 'symlink']:
338
raise BzrCommandError('invalid kind specified')
339
tree = WorkingTree.open_containing(u'.')[0]
341
inv = tree.read_working_inventory()
343
if len(revision) > 1:
344
raise BzrCommandError('bzr inventory --revision takes'
345
' exactly one revision identifier')
346
inv = tree.branch.repository.get_revision_inventory(
347
revision[0].in_history(tree.branch).rev_id)
349
for path, entry in inv.entries():
350
if kind and kind != entry.kind:
353
self.outf.write('%-50s %s\n' % (path, entry.file_id))
355
self.outf.write(path)
356
self.outf.write('\n')
359
class cmd_mv(Command):
360
"""Move or rename a file.
363
bzr mv OLDNAME NEWNAME
364
bzr mv SOURCE... DESTINATION
366
If the last argument is a versioned directory, all the other names
367
are moved into it. Otherwise, there must be exactly two arguments
368
and the file is changed to a new name, which must not already exist.
370
Files cannot be moved between branches.
373
takes_args = ['names*']
374
aliases = ['move', 'rename']
375
encoding_type = 'replace'
377
def run(self, names_list):
378
if names_list is None:
381
if len(names_list) < 2:
382
raise BzrCommandError("missing file argument")
383
tree, rel_names = tree_files(names_list)
385
if os.path.isdir(names_list[-1]):
386
# move into existing directory
387
for pair in tree.move(rel_names[:-1], rel_names[-1]):
388
self.outf.write("%s => %s\n" % pair)
390
if len(names_list) != 2:
391
raise BzrCommandError('to mv multiple files the destination '
392
'must be a versioned directory')
393
tree.rename_one(rel_names[0], rel_names[1])
394
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
397
class cmd_pull(Command):
398
"""Turn this branch into a mirror of another branch.
400
This command only works on branches that have not diverged. Branches are
401
considered diverged if the destination branch's most recent commit is one
402
that has not been merged (directly or indirectly) into the parent.
404
If branches have diverged, you can use 'bzr merge' to integrate the changes
405
from one into the other. Once one branch has merged, the other should
406
be able to pull it again.
408
If you want to forget your local changes and just update your branch to
409
match the remote one, use pull --overwrite.
411
If there is no default location set, the first pull will set it. After
412
that, you can omit the location to use the default. To change the
413
default, use --remember. The value will only be saved if the remote
414
location can be accessed.
417
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
418
takes_args = ['location?']
419
encoding_type = 'replace'
421
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
422
# FIXME: too much stuff is in the command class
424
tree_to = WorkingTree.open_containing(u'.')[0]
425
branch_to = tree_to.branch
426
except NoWorkingTree:
428
branch_to = Branch.open_containing(u'.')[0]
431
if location is not None:
433
reader = bundle.read_bundle_from_url(location)
435
pass # Continue on considering this url a Branch
437
stored_loc = branch_to.get_parent()
439
if stored_loc is None:
440
raise BzrCommandError("No pull location known or specified.")
442
display_url = urlutils.unescape_for_display(stored_loc,
444
self.outf.write("Using saved location: %s\n" % display_url)
445
location = stored_loc
448
if reader is not None:
449
install_bundle(branch_to.repository, reader)
450
branch_from = branch_to
452
branch_from = Branch.open(location)
454
if branch_to.get_parent() is None or remember:
455
branch_to.set_parent(branch_from.base)
459
if reader is not None:
460
rev_id = reader.target
461
elif len(revision) == 1:
462
rev_id = revision[0].in_history(branch_from).rev_id
464
raise BzrCommandError('bzr pull --revision takes one value.')
466
old_rh = branch_to.revision_history()
467
if tree_to is not None:
468
count = tree_to.pull(branch_from, overwrite, rev_id)
470
count = branch_to.pull(branch_from, overwrite, rev_id)
471
note('%d revision(s) pulled.' % (count,))
474
new_rh = branch_to.revision_history()
477
from bzrlib.log import show_changed_revisions
478
show_changed_revisions(branch_to, old_rh, new_rh,
482
class cmd_push(Command):
483
"""Update a mirror of this branch.
485
The target branch will not have its working tree populated because this
486
is both expensive, and is not supported on remote file systems.
488
Some smart servers or protocols *may* put the working tree in place in
491
This command only works on branches that have not diverged. Branches are
492
considered diverged if the destination branch's most recent commit is one
493
that has not been merged (directly or indirectly) by the source branch.
495
If branches have diverged, you can use 'bzr push --overwrite' to replace
496
the other branch completely, discarding its unmerged changes.
498
If you want to ensure you have the different changes in the other branch,
499
do a merge (see bzr help merge) from the other branch, and commit that.
500
After that you will be able to do a push without '--overwrite'.
502
If there is no default push location set, the first push will set it.
503
After that, you can omit the location to use the default. To change the
504
default, use --remember. The value will only be saved if the remote
505
location can be accessed.
508
takes_options = ['remember', 'overwrite', 'verbose',
509
Option('create-prefix',
510
help='Create the path leading up to the branch '
511
'if it does not already exist')]
512
takes_args = ['location?']
513
encoding_type = 'replace'
515
def run(self, location=None, remember=False, overwrite=False,
516
create_prefix=False, verbose=False):
517
# FIXME: Way too big! Put this into a function called from the
519
from bzrlib.transport import get_transport
521
br_from = Branch.open_containing('.')[0]
522
stored_loc = br_from.get_push_location()
524
if stored_loc is None:
525
raise BzrCommandError("No push location known or specified.")
527
display_url = urlutils.unescape_for_display(stored_loc,
529
self.outf.write("Using saved location: %s\n" % display_url)
530
location = stored_loc
532
transport = get_transport(location)
533
location_url = transport.base
537
dir_to = bzrdir.BzrDir.open(location_url)
538
br_to = dir_to.open_branch()
539
except NotBranchError:
541
transport = transport.clone('..')
542
if not create_prefix:
544
relurl = transport.relpath(location_url)
545
mutter('creating directory %s => %s', location_url, relurl)
546
transport.mkdir(relurl)
548
raise BzrCommandError("Parent directory of %s "
549
"does not exist." % location)
551
current = transport.base
552
needed = [(transport, transport.relpath(location_url))]
555
transport, relpath = needed[-1]
556
transport.mkdir(relpath)
559
new_transport = transport.clone('..')
560
needed.append((new_transport,
561
new_transport.relpath(transport.base)))
562
if new_transport.base == transport.base:
563
raise BzrCommandError("Could not create "
565
dir_to = br_from.bzrdir.clone(location_url,
566
revision_id=br_from.last_revision())
567
br_to = dir_to.open_branch()
568
count = len(br_to.revision_history())
569
# We successfully created the target, remember it
570
if br_from.get_push_location() is None or remember:
571
br_from.set_push_location(br_to.base)
573
# We were able to connect to the remote location, so remember it
574
# we don't need to successfully push because of possible divergence.
575
if br_from.get_push_location() is None or remember:
576
br_from.set_push_location(br_to.base)
577
old_rh = br_to.revision_history()
580
tree_to = dir_to.open_workingtree()
581
except errors.NotLocalUrl:
582
warning('This transport does not update the working '
583
'tree of: %s' % (br_to.base,))
584
count = br_to.pull(br_from, overwrite)
585
except NoWorkingTree:
586
count = br_to.pull(br_from, overwrite)
588
count = tree_to.pull(br_from, overwrite)
589
except DivergedBranches:
590
raise BzrCommandError("These branches have diverged."
591
" Try a merge then push with overwrite.")
592
note('%d revision(s) pushed.' % (count,))
595
new_rh = br_to.revision_history()
598
from bzrlib.log import show_changed_revisions
599
show_changed_revisions(br_to, old_rh, new_rh,
603
class cmd_branch(Command):
604
"""Create a new copy of a branch.
606
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
607
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
609
To retrieve the branch as of a particular revision, supply the --revision
610
parameter, as in "branch foo/bar -r 5".
612
--basis is to speed up branching from remote branches. When specified, it
613
copies all the file-contents, inventory and revision data from the basis
614
branch before copying anything from the remote branch.
616
takes_args = ['from_location', 'to_location?']
617
takes_options = ['revision', 'basis']
618
aliases = ['get', 'clone']
620
def run(self, from_location, to_location=None, revision=None, basis=None):
621
from bzrlib.transport import get_transport
624
elif len(revision) > 1:
625
raise BzrCommandError(
626
'bzr branch --revision takes exactly 1 revision value')
628
br_from = Branch.open(from_location)
630
if e.errno == errno.ENOENT:
631
raise BzrCommandError('Source location "%s" does not'
632
' exist.' % to_location)
637
if basis is not None:
638
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
641
if len(revision) == 1 and revision[0] is not None:
642
revision_id = revision[0].in_history(br_from)[1]
644
# FIXME - wt.last_revision, fallback to branch, fall back to
645
# None or perhaps NULL_REVISION to mean copy nothing
647
revision_id = br_from.last_revision()
648
if to_location is None:
649
to_location = os.path.basename(from_location.rstrip("/\\"))
652
name = os.path.basename(to_location) + '\n'
654
to_transport = get_transport(to_location)
656
to_transport.mkdir('.')
657
except errors.FileExists:
658
raise BzrCommandError('Target directory "%s" already'
659
' exists.' % to_location)
660
except errors.NoSuchFile:
661
raise BzrCommandError('Parent of "%s" does not exist.' %
664
# preserve whatever source format we have.
665
dir = br_from.bzrdir.sprout(to_transport.base,
666
revision_id, basis_dir)
667
branch = dir.open_branch()
668
except errors.NoSuchRevision:
669
to_transport.delete_tree('.')
670
msg = "The branch %s has no revision %s." % (from_location, revision[0])
671
raise BzrCommandError(msg)
672
except errors.UnlistableBranch:
673
osutils.rmtree(to_location)
674
msg = "The branch %s cannot be used as a --basis" % (basis,)
675
raise BzrCommandError(msg)
677
branch.control_files.put_utf8('branch-name', name)
678
note('Branched %d revision(s).' % branch.revno())
683
class cmd_checkout(Command):
684
"""Create a new checkout of an existing branch.
686
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
687
the branch found in '.'. This is useful if you have removed the working tree
688
or if it was never created - i.e. if you pushed the branch to its current
691
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
692
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
694
To retrieve the branch as of a particular revision, supply the --revision
695
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
696
out of date [so you cannot commit] but it may be useful (i.e. to examine old
699
--basis is to speed up checking out from remote branches. When specified, it
700
uses the inventory and file contents from the basis branch in preference to the
701
branch being checked out.
703
takes_args = ['branch_location?', 'to_location?']
704
takes_options = ['revision', # , 'basis']
705
Option('lightweight',
706
help="perform a lightweight checkout. Lightweight "
707
"checkouts depend on access to the branch for "
708
"every operation. Normal checkouts can perform "
709
"common operations like diff and status without "
710
"such access, and also support local commits."
715
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
719
elif len(revision) > 1:
720
raise BzrCommandError(
721
'bzr checkout --revision takes exactly 1 revision value')
722
if branch_location is None:
723
branch_location = osutils.getcwd()
724
to_location = branch_location
725
source = Branch.open(branch_location)
726
if len(revision) == 1 and revision[0] is not None:
727
revision_id = revision[0].in_history(source)[1]
730
if to_location is None:
731
to_location = os.path.basename(branch_location.rstrip("/\\"))
732
# if the source and to_location are the same,
733
# and there is no working tree,
734
# then reconstitute a branch
735
if (osutils.abspath(to_location) ==
736
osutils.abspath(branch_location)):
738
source.bzrdir.open_workingtree()
739
except errors.NoWorkingTree:
740
source.bzrdir.create_workingtree()
743
os.mkdir(to_location)
745
if e.errno == errno.EEXIST:
746
raise BzrCommandError('Target directory "%s" already'
747
' exists.' % to_location)
748
if e.errno == errno.ENOENT:
749
raise BzrCommandError('Parent of "%s" does not exist.' %
753
old_format = bzrdir.BzrDirFormat.get_default_format()
754
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
757
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
758
branch.BranchReferenceFormat().initialize(checkout, source)
760
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
761
to_location, force_new_tree=False)
762
checkout = checkout_branch.bzrdir
763
checkout_branch.bind(source)
764
if revision_id is not None:
765
rh = checkout_branch.revision_history()
766
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
767
checkout.create_workingtree(revision_id)
769
bzrdir.BzrDirFormat.set_default_format(old_format)
772
class cmd_renames(Command):
773
"""Show list of renamed files.
775
# TODO: Option to show renames between two historical versions.
777
# TODO: Only show renames under dir, rather than in the whole branch.
778
takes_args = ['dir?']
781
def run(self, dir=u'.'):
782
from bzrlib.tree import find_renames
783
tree = WorkingTree.open_containing(dir)[0]
784
old_inv = tree.basis_tree().inventory
785
new_inv = tree.read_working_inventory()
786
renames = list(find_renames(old_inv, new_inv))
788
for old_name, new_name in renames:
789
self.outf.write("%s => %s\n" % (old_name, new_name))
792
class cmd_update(Command):
793
"""Update a tree to have the latest code committed to its branch.
795
This will perform a merge into the working tree, and may generate
796
conflicts. If you have any local changes, you will still
797
need to commit them after the update for the update to be complete.
799
If you want to discard your local changes, you can just do a
800
'bzr revert' instead of 'bzr commit' after the update.
802
takes_args = ['dir?']
804
def run(self, dir='.'):
805
tree = WorkingTree.open_containing(dir)[0]
808
last_rev = tree.last_revision()
809
if last_rev == tree.branch.last_revision():
810
# may be up to date, check master too.
811
master = tree.branch.get_master_branch()
812
if master is None or last_rev == master.last_revision():
813
revno = tree.branch.revision_id_to_revno(last_rev)
814
note("Tree is up to date at revision %d." % (revno,))
816
conflicts = tree.update()
817
revno = tree.branch.revision_id_to_revno(tree.last_revision())
818
note('Updated to revision %d.' % (revno,))
827
class cmd_info(Command):
828
"""Show information about a working tree, branch or repository.
830
This command will show all known locations and formats associated to the
831
tree, branch or repository. Statistical information is included with
834
Branches and working trees will also report any missing revisions.
836
takes_args = ['location?']
837
takes_options = ['verbose']
840
def run(self, location=None, verbose=False):
841
from bzrlib.info import show_bzrdir_info
842
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
846
class cmd_remove(Command):
847
"""Make a file unversioned.
849
This makes bzr stop tracking changes to a versioned file. It does
850
not delete the working copy.
852
You can specify one or more files, and/or --new. If you specify --new,
853
only 'added' files will be removed. If you specify both, then new files
854
in the specified directories will be removed. If the directories are
855
also new, they will also be removed.
857
takes_args = ['file*']
858
takes_options = ['verbose', Option('new', help='remove newly-added files')]
860
encoding_type = 'replace'
862
def run(self, file_list, verbose=False, new=False):
863
tree, file_list = tree_files(file_list)
865
if file_list is None:
866
raise BzrCommandError('Specify one or more files to remove, or'
869
from bzrlib.delta import compare_trees
870
added = [compare_trees(tree.basis_tree(), tree,
871
specific_files=file_list).added]
872
file_list = sorted([f[0] for f in added[0]], reverse=True)
873
if len(file_list) == 0:
874
raise BzrCommandError('No matching files.')
875
tree.remove(file_list, verbose=verbose, to_file=self.outf)
878
class cmd_file_id(Command):
879
"""Print file_id of a particular file or directory.
881
The file_id is assigned when the file is first added and remains the
882
same through all revisions where the file exists, even when it is
887
takes_args = ['filename']
890
def run(self, filename):
891
tree, relpath = WorkingTree.open_containing(filename)
892
i = tree.inventory.path2id(relpath)
894
raise BzrError("%r is not a versioned file" % filename)
896
self.outf.write(i + '\n')
899
class cmd_file_path(Command):
900
"""Print path of file_ids to a file or directory.
902
This prints one line for each directory down to the target,
903
starting at the branch root.
907
takes_args = ['filename']
910
def run(self, filename):
911
tree, relpath = WorkingTree.open_containing(filename)
913
fid = inv.path2id(relpath)
915
raise BzrError("%r is not a versioned file" % filename)
916
for fip in inv.get_idpath(fid):
917
self.outf.write(fip + '\n')
920
class cmd_reconcile(Command):
921
"""Reconcile bzr metadata in a branch.
923
This can correct data mismatches that may have been caused by
924
previous ghost operations or bzr upgrades. You should only
925
need to run this command if 'bzr check' or a bzr developer
926
advises you to run it.
928
If a second branch is provided, cross-branch reconciliation is
929
also attempted, which will check that data like the tree root
930
id which was not present in very early bzr versions is represented
931
correctly in both branches.
933
At the same time it is run it may recompress data resulting in
934
a potential saving in disk space or performance gain.
936
The branch *MUST* be on a listable system such as local disk or sftp.
938
takes_args = ['branch?']
940
def run(self, branch="."):
941
from bzrlib.reconcile import reconcile
942
dir = bzrdir.BzrDir.open(branch)
946
class cmd_revision_history(Command):
947
"""Display the list of revision ids on a branch."""
948
takes_args = ['location?']
953
def run(self, location="."):
954
branch = Branch.open_containing(location)[0]
955
for revid in branch.revision_history():
956
self.outf.write(revid)
957
self.outf.write('\n')
960
class cmd_ancestry(Command):
961
"""List all revisions merged into this branch."""
962
takes_args = ['location?']
967
def run(self, location="."):
969
wt = WorkingTree.open_containing(location)[0]
970
except errors.NoWorkingTree:
971
b = Branch.open(location)
972
last_revision = b.last_revision()
975
last_revision = wt.last_revision()
977
revision_ids = b.repository.get_ancestry(last_revision)
978
assert revision_ids[0] == None
980
for revision_id in revision_ids:
981
self.outf.write(revision_id + '\n')
984
class cmd_init(Command):
985
"""Make a directory into a versioned branch.
987
Use this to create an empty branch, or before importing an
990
If there is a repository in a parent directory of the location, then
991
the history of the branch will be stored in the repository. Otherwise
992
init creates a standalone branch which carries its own history in
995
If there is already a branch at the location but it has no working tree,
996
the tree can be populated with 'bzr checkout'.
998
Recipe for importing a tree of files:
1003
bzr commit -m 'imported project'
1005
takes_args = ['location?']
1008
help='Specify a format for this branch. Current'
1009
' formats are: default, knit, metaweave and'
1010
' weave. Default is knit; metaweave and'
1011
' weave are deprecated',
1012
type=get_format_type),
1014
def run(self, location=None, format=None):
1016
format = get_format_type('default')
1017
if location is None:
1020
# The path has to exist to initialize a
1021
# branch inside of it.
1022
# Just using os.mkdir, since I don't
1023
# believe that we want to create a bunch of
1024
# locations if the user supplies an extended path
1025
if not os.path.exists(location):
1028
existing_bzrdir = bzrdir.BzrDir.open(location)
1029
except NotBranchError:
1030
# really a NotBzrDir error...
1031
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1033
if existing_bzrdir.has_branch():
1034
if existing_bzrdir.has_workingtree():
1035
raise errors.AlreadyBranchError(location)
1037
raise errors.BranchExistsWithoutWorkingTree(location)
1039
existing_bzrdir.create_branch()
1040
existing_bzrdir.create_workingtree()
1043
class cmd_init_repository(Command):
1044
"""Create a shared repository to hold branches.
1046
New branches created under the repository directory will store their revisions
1047
in the repository, not in the branch directory, if the branch format supports
1053
bzr checkout --lightweight repo/trunk trunk-checkout
1057
takes_args = ["location"]
1058
takes_options = [Option('format',
1059
help='Specify a format for this repository.'
1060
' Current formats are: default, knit,'
1061
' metaweave and weave. Default is knit;'
1062
' metaweave and weave are deprecated',
1063
type=get_format_type),
1065
help='Allows branches in repository to have'
1067
aliases = ["init-repo"]
1068
def run(self, location, format=None, trees=False):
1069
from bzrlib.transport import get_transport
1071
format = get_format_type('default')
1072
transport = get_transport(location)
1073
if not transport.has('.'):
1075
newdir = format.initialize_on_transport(transport)
1076
repo = newdir.create_repository(shared=True)
1077
repo.set_make_working_trees(trees)
1080
class cmd_diff(Command):
1081
"""Show differences in working tree.
1083
If files are listed, only the changes in those files are listed.
1084
Otherwise, all changes for the tree are listed.
1086
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1087
produces patches suitable for "patch -p1".
1093
bzr diff --diff-prefix old/:new/
1094
bzr diff bzr.mine bzr.dev
1097
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1098
# or a graphical diff.
1100
# TODO: Python difflib is not exactly the same as unidiff; should
1101
# either fix it up or prefer to use an external diff.
1103
# TODO: Selected-file diff is inefficient and doesn't show you
1106
# TODO: This probably handles non-Unix newlines poorly.
1108
takes_args = ['file*']
1109
takes_options = ['revision', 'diff-options', 'prefix']
1110
aliases = ['di', 'dif']
1111
encoding_type = 'exact'
1114
def run(self, revision=None, file_list=None, diff_options=None,
1116
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1118
if (prefix is None) or (prefix == '0'):
1126
if not ':' in prefix:
1127
raise BzrError("--diff-prefix expects two values separated by a colon")
1128
old_label, new_label = prefix.split(":")
1131
tree1, file_list = internal_tree_files(file_list)
1135
except FileInWrongBranch:
1136
if len(file_list) != 2:
1137
raise BzrCommandError("Files are in different branches")
1139
tree1, file1 = WorkingTree.open_containing(file_list[0])
1140
tree2, file2 = WorkingTree.open_containing(file_list[1])
1141
if file1 != "" or file2 != "":
1142
# FIXME diff those two files. rbc 20051123
1143
raise BzrCommandError("Files are in different branches")
1145
if revision is not None:
1146
if tree2 is not None:
1147
raise BzrCommandError("Can't specify -r with two branches")
1148
if (len(revision) == 1) or (revision[1].spec is None):
1149
return diff_cmd_helper(tree1, file_list, diff_options,
1151
old_label=old_label, new_label=new_label)
1152
elif len(revision) == 2:
1153
return diff_cmd_helper(tree1, file_list, diff_options,
1154
revision[0], revision[1],
1155
old_label=old_label, new_label=new_label)
1157
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1159
if tree2 is not None:
1160
return show_diff_trees(tree1, tree2, sys.stdout,
1161
specific_files=file_list,
1162
external_diff_options=diff_options,
1163
old_label=old_label, new_label=new_label)
1165
return diff_cmd_helper(tree1, file_list, diff_options,
1166
old_label=old_label, new_label=new_label)
1169
class cmd_deleted(Command):
1170
"""List files deleted in the working tree.
1172
# TODO: Show files deleted since a previous revision, or
1173
# between two revisions.
1174
# TODO: Much more efficient way to do this: read in new
1175
# directories with readdir, rather than stating each one. Same
1176
# level of effort but possibly much less IO. (Or possibly not,
1177
# if the directories are very large...)
1178
takes_options = ['show-ids']
1181
def run(self, show_ids=False):
1182
tree = WorkingTree.open_containing(u'.')[0]
1183
old = tree.basis_tree()
1184
for path, ie in old.inventory.iter_entries():
1185
if not tree.has_id(ie.file_id):
1186
self.outf.write(path)
1188
self.outf.write(' ')
1189
self.outf.write(ie.file_id)
1190
self.outf.write('\n')
1193
class cmd_modified(Command):
1194
"""List files modified in working tree."""
1198
from bzrlib.delta import compare_trees
1200
tree = WorkingTree.open_containing(u'.')[0]
1201
td = compare_trees(tree.basis_tree(), tree)
1203
for path, id, kind, text_modified, meta_modified in td.modified:
1204
self.outf.write(path + '\n')
1207
class cmd_added(Command):
1208
"""List files added in working tree."""
1212
wt = WorkingTree.open_containing(u'.')[0]
1213
basis_inv = wt.basis_tree().inventory
1216
if file_id in basis_inv:
1218
path = inv.id2path(file_id)
1219
if not os.access(osutils.abspath(path), os.F_OK):
1221
self.outf.write(path + '\n')
1224
class cmd_root(Command):
1225
"""Show the tree root directory.
1227
The root is the nearest enclosing directory with a .bzr control
1229
takes_args = ['filename?']
1231
def run(self, filename=None):
1232
"""Print the branch root."""
1233
tree = WorkingTree.open_containing(filename)[0]
1234
self.outf.write(tree.basedir + '\n')
1237
class cmd_log(Command):
1238
"""Show log of a branch, file, or directory.
1240
By default show the log of the branch containing the working directory.
1242
To request a range of logs, you can use the command -r begin..end
1243
-r revision requests a specific revision, -r ..end or -r begin.. are
1249
bzr log -r -10.. http://server/branch
1252
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1254
takes_args = ['location?']
1255
takes_options = [Option('forward',
1256
help='show from oldest to newest'),
1259
help='show files changed in each revision'),
1260
'show-ids', 'revision',
1264
help='show revisions whose message matches this regexp',
1268
encoding_type = 'replace'
1271
def run(self, location=None, timezone='original',
1281
from bzrlib.log import log_formatter, show_log
1282
assert message is None or isinstance(message, basestring), \
1283
"invalid message argument %r" % message
1284
direction = (forward and 'forward') or 'reverse'
1289
# find the file id to log:
1291
dir, fp = bzrdir.BzrDir.open_containing(location)
1292
b = dir.open_branch()
1296
inv = dir.open_workingtree().inventory
1297
except (errors.NotBranchError, errors.NotLocalUrl):
1298
# either no tree, or is remote.
1299
inv = b.basis_tree().inventory
1300
file_id = inv.path2id(fp)
1303
# FIXME ? log the current subdir only RBC 20060203
1304
dir, relpath = bzrdir.BzrDir.open_containing('.')
1305
b = dir.open_branch()
1307
if revision is None:
1310
elif len(revision) == 1:
1311
rev1 = rev2 = revision[0].in_history(b).revno
1312
elif len(revision) == 2:
1313
if revision[0].spec is None:
1314
# missing begin-range means first revision
1317
rev1 = revision[0].in_history(b).revno
1319
if revision[1].spec is None:
1320
# missing end-range means last known revision
1323
rev2 = revision[1].in_history(b).revno
1325
raise BzrCommandError('bzr log --revision takes one or two values.')
1327
# By this point, the revision numbers are converted to the +ve
1328
# form if they were supplied in the -ve form, so we can do
1329
# this comparison in relative safety
1331
(rev2, rev1) = (rev1, rev2)
1333
if (log_format == None):
1334
default = b.get_config().log_format()
1335
log_format = get_log_format(long=long, short=short, line=line,
1337
lf = log_formatter(log_format,
1340
show_timezone=timezone)
1346
direction=direction,
1347
start_revision=rev1,
1352
def get_log_format(long=False, short=False, line=False, default='long'):
1353
log_format = default
1357
log_format = 'short'
1363
class cmd_touching_revisions(Command):
1364
"""Return revision-ids which affected a particular file.
1366
A more user-friendly interface is "bzr log FILE".
1370
takes_args = ["filename"]
1373
def run(self, filename):
1374
tree, relpath = WorkingTree.open_containing(filename)
1376
inv = tree.read_working_inventory()
1377
file_id = inv.path2id(relpath)
1378
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1379
self.outf.write("%6d %s\n" % (revno, what))
1382
class cmd_ls(Command):
1383
"""List files in a tree.
1385
# TODO: Take a revision or remote path and list that tree instead.
1387
takes_options = ['verbose', 'revision',
1388
Option('non-recursive',
1389
help='don\'t recurse into sub-directories'),
1391
help='Print all paths from the root of the branch.'),
1392
Option('unknown', help='Print unknown files'),
1393
Option('versioned', help='Print versioned files'),
1394
Option('ignored', help='Print ignored files'),
1396
Option('null', help='Null separate the files'),
1399
def run(self, revision=None, verbose=False,
1400
non_recursive=False, from_root=False,
1401
unknown=False, versioned=False, ignored=False,
1404
if verbose and null:
1405
raise BzrCommandError('Cannot set both --verbose and --null')
1406
all = not (unknown or versioned or ignored)
1408
selection = {'I':ignored, '?':unknown, 'V':versioned}
1410
tree, relpath = WorkingTree.open_containing(u'.')
1415
if revision is not None:
1416
tree = tree.branch.repository.revision_tree(
1417
revision[0].in_history(tree.branch).rev_id)
1419
for fp, fc, kind, fid, entry in tree.list_files():
1420
if fp.startswith(relpath):
1421
fp = fp[len(relpath):]
1422
if non_recursive and '/' in fp:
1424
if not all and not selection[fc]:
1427
kindch = entry.kind_character()
1428
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1430
self.outf.write(fp + '\0')
1433
self.outf.write(fp + '\n')
1436
class cmd_unknowns(Command):
1437
"""List unknown files."""
1440
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1441
self.outf.write(osutils.quotefn(f) + '\n')
1444
class cmd_ignore(Command):
1445
"""Ignore a command or pattern.
1447
To remove patterns from the ignore list, edit the .bzrignore file.
1449
If the pattern contains a slash, it is compared to the whole path
1450
from the branch root. Otherwise, it is compared to only the last
1451
component of the path. To match a file only in the root directory,
1454
Ignore patterns are case-insensitive on case-insensitive systems.
1456
Note: wildcards must be quoted from the shell on Unix.
1459
bzr ignore ./Makefile
1460
bzr ignore '*.class'
1462
# TODO: Complain if the filename is absolute
1463
takes_args = ['name_pattern?']
1465
Option('old-default-rules',
1466
help='Out the ignore rules bzr < 0.9 always used.')
1469
def run(self, name_pattern=None, old_default_rules=None):
1470
from bzrlib.atomicfile import AtomicFile
1471
if old_default_rules is not None:
1472
# dump the rules and exit
1473
for pattern in bzrlib.DEFAULT_IGNORE:
1476
if name_pattern is None:
1477
raise BzrCommandError("ignore requires a NAME_PATTERN")
1478
tree, relpath = WorkingTree.open_containing(u'.')
1479
ifn = tree.abspath('.bzrignore')
1480
if os.path.exists(ifn):
1483
igns = f.read().decode('utf-8')
1489
# TODO: If the file already uses crlf-style termination, maybe
1490
# we should use that for the newly added lines?
1492
if igns and igns[-1] != '\n':
1494
igns += name_pattern + '\n'
1496
f = AtomicFile(ifn, 'wt')
1498
f.write(igns.encode('utf-8'))
1503
inv = tree.inventory
1504
if inv.path2id('.bzrignore'):
1505
mutter('.bzrignore is already versioned')
1507
mutter('need to make new .bzrignore file versioned')
1508
tree.add(['.bzrignore'])
1511
class cmd_ignored(Command):
1512
"""List ignored files and the patterns that matched them.
1514
See also: bzr ignore"""
1517
tree = WorkingTree.open_containing(u'.')[0]
1518
for path, file_class, kind, file_id, entry in tree.list_files():
1519
if file_class != 'I':
1521
## XXX: Slightly inefficient since this was already calculated
1522
pat = tree.is_ignored(path)
1523
print '%-50s %s' % (path, pat)
1526
class cmd_lookup_revision(Command):
1527
"""Lookup the revision-id from a revision-number
1530
bzr lookup-revision 33
1533
takes_args = ['revno']
1536
def run(self, revno):
1540
raise BzrCommandError("not a valid revision-number: %r" % revno)
1542
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1545
class cmd_export(Command):
1546
"""Export past revision to destination directory.
1548
If no revision is specified this exports the last committed revision.
1550
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1551
given, try to find the format with the extension. If no extension
1552
is found exports to a directory (equivalent to --format=dir).
1554
Root may be the top directory for tar, tgz and tbz2 formats. If none
1555
is given, the top directory will be the root name of the file.
1557
Note: export of tree with non-ascii filenames to zip is not supported.
1559
Supported formats Autodetected by extension
1560
----------------- -------------------------
1563
tbz2 .tar.bz2, .tbz2
1567
takes_args = ['dest']
1568
takes_options = ['revision', 'format', 'root']
1569
def run(self, dest, revision=None, format=None, root=None):
1570
from bzrlib.export import export
1571
tree = WorkingTree.open_containing(u'.')[0]
1573
if revision is None:
1574
# should be tree.last_revision FIXME
1575
rev_id = b.last_revision()
1577
if len(revision) != 1:
1578
raise BzrError('bzr export --revision takes exactly 1 argument')
1579
rev_id = revision[0].in_history(b).rev_id
1580
t = b.repository.revision_tree(rev_id)
1582
export(t, dest, format, root)
1583
except errors.NoSuchExportFormat, e:
1584
raise BzrCommandError('Unsupported export format: %s' % e.format)
1587
class cmd_cat(Command):
1588
"""Write a file's text from a previous revision."""
1590
takes_options = ['revision']
1591
takes_args = ['filename']
1594
def run(self, filename, revision=None):
1595
if revision is not None and len(revision) != 1:
1596
raise BzrCommandError("bzr cat --revision takes exactly one number")
1599
tree, relpath = WorkingTree.open_containing(filename)
1601
except NotBranchError:
1605
b, relpath = Branch.open_containing(filename)
1606
if revision is None:
1607
revision_id = b.last_revision()
1609
revision_id = revision[0].in_history(b).rev_id
1610
b.print_file(relpath, revision_id)
1613
class cmd_local_time_offset(Command):
1614
"""Show the offset in seconds from GMT to local time."""
1618
print osutils.local_time_offset()
1622
class cmd_commit(Command):
1623
"""Commit changes into a new revision.
1625
If no arguments are given, the entire tree is committed.
1627
If selected files are specified, only changes to those files are
1628
committed. If a directory is specified then the directory and everything
1629
within it is committed.
1631
A selected-file commit may fail in some cases where the committed
1632
tree would be invalid, such as trying to commit a file in a
1633
newly-added directory that is not itself committed.
1635
# TODO: Run hooks on tree to-be-committed, and after commit.
1637
# TODO: Strict commit that fails if there are deleted files.
1638
# (what does "deleted files" mean ??)
1640
# TODO: Give better message for -s, --summary, used by tla people
1642
# XXX: verbose currently does nothing
1644
takes_args = ['selected*']
1645
takes_options = ['message', 'verbose',
1647
help='commit even if nothing has changed'),
1648
Option('file', type=str,
1650
help='file containing commit message'),
1652
help="refuse to commit if there are unknown "
1653
"files in the working tree."),
1655
help="perform a local only commit in a bound "
1656
"branch. Such commits are not pushed to "
1657
"the master branch until a normal commit "
1661
aliases = ['ci', 'checkin']
1663
def run(self, message=None, file=None, verbose=True, selected_list=None,
1664
unchanged=False, strict=False, local=False):
1665
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1666
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1668
from bzrlib.msgeditor import edit_commit_message, \
1669
make_commit_message_template
1670
from tempfile import TemporaryFile
1672
# TODO: Need a blackbox test for invoking the external editor; may be
1673
# slightly problematic to run this cross-platform.
1675
# TODO: do more checks that the commit will succeed before
1676
# spending the user's valuable time typing a commit message.
1678
# TODO: if the commit *does* happen to fail, then save the commit
1679
# message to a temporary file where it can be recovered
1680
tree, selected_list = tree_files(selected_list)
1681
if selected_list == ['']:
1682
# workaround - commit of root of tree should be exactly the same
1683
# as just default commit in that tree, and succeed even though
1684
# selected-file merge commit is not done yet
1687
if local and not tree.branch.get_bound_location():
1688
raise errors.LocalRequiresBoundBranch()
1689
if message is None and not file:
1690
template = make_commit_message_template(tree, selected_list)
1691
message = edit_commit_message(template)
1693
raise BzrCommandError("please specify a commit message"
1694
" with either --message or --file")
1695
elif message and file:
1696
raise BzrCommandError("please specify either --message or --file")
1699
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1702
raise BzrCommandError("empty commit message specified")
1705
reporter = ReportCommitToLog()
1707
reporter = NullCommitReporter()
1710
tree.commit(message, specific_files=selected_list,
1711
allow_pointless=unchanged, strict=strict, local=local,
1713
except PointlessCommit:
1714
# FIXME: This should really happen before the file is read in;
1715
# perhaps prepare the commit; get the message; then actually commit
1716
raise BzrCommandError("no changes to commit."
1717
" use --unchanged to commit anyhow")
1718
except ConflictsInTree:
1719
raise BzrCommandError("Conflicts detected in working tree. "
1720
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1721
except StrictCommitFailed:
1722
raise BzrCommandError("Commit refused because there are unknown "
1723
"files in the working tree.")
1724
except errors.BoundBranchOutOfDate, e:
1725
raise BzrCommandError(str(e)
1726
+ ' Either unbind, update, or'
1727
' pass --local to commit.')
1730
class cmd_check(Command):
1731
"""Validate consistency of branch history.
1733
This command checks various invariants about the branch storage to
1734
detect data corruption or bzr bugs.
1736
takes_args = ['branch?']
1737
takes_options = ['verbose']
1739
def run(self, branch=None, verbose=False):
1740
from bzrlib.check import check
1742
tree = WorkingTree.open_containing()[0]
1743
branch = tree.branch
1745
branch = Branch.open(branch)
1746
check(branch, verbose)
1749
class cmd_scan_cache(Command):
1752
from bzrlib.hashcache import HashCache
1758
print '%6d stats' % c.stat_count
1759
print '%6d in hashcache' % len(c._cache)
1760
print '%6d files removed from cache' % c.removed_count
1761
print '%6d hashes updated' % c.update_count
1762
print '%6d files changed too recently to cache' % c.danger_count
1768
class cmd_upgrade(Command):
1769
"""Upgrade branch storage to current format.
1771
The check command or bzr developers may sometimes advise you to run
1772
this command. When the default format has changed you may also be warned
1773
during other operations to upgrade.
1775
takes_args = ['url?']
1778
help='Upgrade to a specific format. Current formats'
1779
' are: default, knit, metaweave and weave.'
1780
' Default is knit; metaweave and weave are'
1782
type=get_format_type),
1786
def run(self, url='.', format=None):
1787
from bzrlib.upgrade import upgrade
1789
format = get_format_type('default')
1790
upgrade(url, format)
1793
class cmd_whoami(Command):
1794
"""Show or set bzr user id.
1798
bzr whoami 'Frank Chu <fchu@example.com>'
1800
takes_options = [ Option('email',
1801
help='display email address only'),
1803
help='set identity for the current branch instead of '
1806
takes_args = ['name?']
1807
encoding_type = 'replace'
1810
def run(self, email=False, branch=False, name=None):
1812
# use branch if we're inside one; otherwise global config
1814
c = Branch.open_containing('.')[0].get_config()
1815
except NotBranchError:
1816
c = config.GlobalConfig()
1818
self.outf.write(c.user_email() + '\n')
1820
self.outf.write(c.username() + '\n')
1823
# use global config unless --branch given
1825
c = Branch.open_containing('.')[0].get_config()
1827
c = config.GlobalConfig()
1828
c.set_user_option('email', name)
1831
class cmd_nick(Command):
1832
"""Print or set the branch nickname.
1834
If unset, the tree root directory name is used as the nickname
1835
To print the current nickname, execute with no argument.
1837
takes_args = ['nickname?']
1838
def run(self, nickname=None):
1839
branch = Branch.open_containing(u'.')[0]
1840
if nickname is None:
1841
self.printme(branch)
1843
branch.nick = nickname
1846
def printme(self, branch):
1850
class cmd_selftest(Command):
1851
"""Run internal test suite.
1853
This creates temporary test directories in the working directory,
1854
but not existing data is affected. These directories are deleted
1855
if the tests pass, or left behind to help in debugging if they
1856
fail and --keep-output is specified.
1858
If arguments are given, they are regular expressions that say
1859
which tests should run.
1861
If the global option '--no-plugins' is given, plugins are not loaded
1862
before running the selftests. This has two effects: features provided or
1863
modified by plugins will not be tested, and tests provided by plugins will
1868
bzr --no-plugins selftest -v
1870
# TODO: --list should give a list of all available tests
1872
# NB: this is used from the class without creating an instance, which is
1873
# why it does not have a self parameter.
1874
def get_transport_type(typestring):
1875
"""Parse and return a transport specifier."""
1876
if typestring == "sftp":
1877
from bzrlib.transport.sftp import SFTPAbsoluteServer
1878
return SFTPAbsoluteServer
1879
if typestring == "memory":
1880
from bzrlib.transport.memory import MemoryServer
1882
if typestring == "fakenfs":
1883
from bzrlib.transport.fakenfs import FakeNFSServer
1884
return FakeNFSServer
1885
msg = "No known transport type %s. Supported types are: sftp\n" %\
1887
raise BzrCommandError(msg)
1890
takes_args = ['testspecs*']
1891
takes_options = ['verbose',
1892
Option('one', help='stop when one test fails'),
1893
Option('keep-output',
1894
help='keep output directories when tests fail'),
1896
help='Use a different transport by default '
1897
'throughout the test suite.',
1898
type=get_transport_type),
1899
Option('benchmark', help='run the bzr bencharks.'),
1900
Option('lsprof-timed',
1901
help='generate lsprof output for benchmarked'
1902
' sections of code.'),
1905
def run(self, testspecs_list=None, verbose=None, one=False,
1906
keep_output=False, transport=None, benchmark=None,
1909
from bzrlib.tests import selftest
1910
import bzrlib.benchmarks as benchmarks
1911
# we don't want progress meters from the tests to go to the
1912
# real output; and we don't want log messages cluttering up
1914
save_ui = ui.ui_factory
1915
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1916
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1918
info('running tests...')
1920
ui.ui_factory = ui.SilentUIFactory()
1921
if testspecs_list is not None:
1922
pattern = '|'.join(testspecs_list)
1926
test_suite_factory = benchmarks.test_suite
1930
test_suite_factory = None
1933
result = selftest(verbose=verbose,
1935
stop_on_failure=one,
1936
keep_output=keep_output,
1937
transport=transport,
1938
test_suite_factory=test_suite_factory,
1939
lsprof_timed=lsprof_timed)
1941
info('tests passed')
1943
info('tests failed')
1944
return int(not result)
1946
ui.ui_factory = save_ui
1949
def _get_bzr_branch():
1950
"""If bzr is run from a branch, return Branch or None"""
1951
from os.path import dirname
1954
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1956
except errors.BzrError:
1962
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1963
# is bzrlib itself in a branch?
1964
branch = _get_bzr_branch()
1966
rh = branch.revision_history()
1968
print " bzr checkout, revision %d" % (revno,)
1969
print " nick: %s" % (branch.nick,)
1971
print " revid: %s" % (rh[-1],)
1972
print "Using python interpreter:", sys.executable
1974
print "Using python standard library:", os.path.dirname(site.__file__)
1975
print "Using bzrlib:",
1976
if len(bzrlib.__path__) > 1:
1977
# print repr, which is a good enough way of making it clear it's
1978
# more than one element (eg ['/foo/bar', '/foo/bzr'])
1979
print repr(bzrlib.__path__)
1981
print bzrlib.__path__[0]
1984
print bzrlib.__copyright__
1985
print "http://bazaar-vcs.org/"
1987
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1988
print "you may use, modify and redistribute it under the terms of the GNU"
1989
print "General Public License version 2 or later."
1992
class cmd_version(Command):
1993
"""Show version of bzr."""
1998
class cmd_rocks(Command):
1999
"""Statement of optimism."""
2003
print "it sure does!"
2006
class cmd_find_merge_base(Command):
2007
"""Find and print a base revision for merging two branches.
2009
# TODO: Options to specify revisions on either side, as if
2010
# merging only part of the history.
2011
takes_args = ['branch', 'other']
2015
def run(self, branch, other):
2016
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2018
branch1 = Branch.open_containing(branch)[0]
2019
branch2 = Branch.open_containing(other)[0]
2021
history_1 = branch1.revision_history()
2022
history_2 = branch2.revision_history()
2024
last1 = branch1.last_revision()
2025
last2 = branch2.last_revision()
2027
source = MultipleRevisionSources(branch1.repository,
2030
base_rev_id = common_ancestor(last1, last2, source)
2032
print 'merge base is revision %s' % base_rev_id
2035
class cmd_merge(Command):
2036
"""Perform a three-way merge.
2038
The branch is the branch you will merge from. By default, it will merge
2039
the latest revision. If you specify a revision, that revision will be
2040
merged. If you specify two revisions, the first will be used as a BASE,
2041
and the second one as OTHER. Revision numbers are always relative to the
2044
By default, bzr will try to merge in all new work from the other
2045
branch, automatically determining an appropriate base. If this
2046
fails, you may need to give an explicit base.
2048
Merge will do its best to combine the changes in two branches, but there
2049
are some kinds of problems only a human can fix. When it encounters those,
2050
it will mark a conflict. A conflict means that you need to fix something,
2051
before you should commit.
2053
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2055
If there is no default branch set, the first merge will set it. After
2056
that, you can omit the branch to use the default. To change the
2057
default, use --remember. The value will only be saved if the remote
2058
location can be accessed.
2062
To merge the latest revision from bzr.dev
2063
bzr merge ../bzr.dev
2065
To merge changes up to and including revision 82 from bzr.dev
2066
bzr merge -r 82 ../bzr.dev
2068
To merge the changes introduced by 82, without previous changes:
2069
bzr merge -r 81..82 ../bzr.dev
2071
merge refuses to run if there are any uncommitted changes, unless
2074
The following merge types are available:
2076
takes_args = ['branch?']
2077
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2078
Option('show-base', help="Show base revision text in "
2082
from merge import merge_type_help
2083
from inspect import getdoc
2084
return getdoc(self) + '\n' + merge_type_help()
2086
def run(self, branch=None, revision=None, force=False, merge_type=None,
2087
show_base=False, reprocess=False, remember=False):
2088
if merge_type is None:
2089
merge_type = Merge3Merger
2091
tree = WorkingTree.open_containing(u'.')[0]
2093
if branch is not None:
2095
reader = bundle.read_bundle_from_url(branch)
2097
pass # Continue on considering this url a Branch
2099
conflicts = merge_bundle(reader, tree, not force, merge_type,
2100
reprocess, show_base)
2106
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2108
if revision is None or len(revision) < 1:
2110
other = [branch, -1]
2111
other_branch, path = Branch.open_containing(branch)
2113
if len(revision) == 1:
2115
other_branch, path = Branch.open_containing(branch)
2116
revno = revision[0].in_history(other_branch).revno
2117
other = [branch, revno]
2119
assert len(revision) == 2
2120
if None in revision:
2121
raise BzrCommandError(
2122
"Merge doesn't permit that revision specifier.")
2123
other_branch, path = Branch.open_containing(branch)
2125
base = [branch, revision[0].in_history(other_branch).revno]
2126
other = [branch, revision[1].in_history(other_branch).revno]
2128
if tree.branch.get_parent() is None or remember:
2129
tree.branch.set_parent(other_branch.base)
2132
interesting_files = [path]
2134
interesting_files = None
2135
pb = ui.ui_factory.nested_progress_bar()
2138
conflict_count = merge(other, base, check_clean=(not force),
2139
merge_type=merge_type,
2140
reprocess=reprocess,
2141
show_base=show_base,
2142
pb=pb, file_list=interesting_files)
2145
if conflict_count != 0:
2149
except errors.AmbiguousBase, e:
2150
m = ("sorry, bzr can't determine the right merge base yet\n"
2151
"candidates are:\n "
2152
+ "\n ".join(e.bases)
2154
"please specify an explicit base with -r,\n"
2155
"and (if you want) report this to the bzr developers\n")
2158
# TODO: move up to common parent; this isn't merge-specific anymore.
2159
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2160
"""Use tree.branch's parent if none was supplied.
2162
Report if the remembered location was used.
2164
if supplied_location is not None:
2165
return supplied_location
2166
stored_location = tree.branch.get_parent()
2167
mutter("%s", stored_location)
2168
if stored_location is None:
2169
raise BzrCommandError("No location specified or remembered")
2170
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2171
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2172
return stored_location
2175
class cmd_remerge(Command):
2178
Use this if you want to try a different merge technique while resolving
2179
conflicts. Some merge techniques are better than others, and remerge
2180
lets you try different ones on different files.
2182
The options for remerge have the same meaning and defaults as the ones for
2183
merge. The difference is that remerge can (only) be run when there is a
2184
pending merge, and it lets you specify particular files.
2187
$ bzr remerge --show-base
2188
Re-do the merge of all conflicted files, and show the base text in
2189
conflict regions, in addition to the usual THIS and OTHER texts.
2191
$ bzr remerge --merge-type weave --reprocess foobar
2192
Re-do the merge of "foobar", using the weave merge algorithm, with
2193
additional processing to reduce the size of conflict regions.
2195
The following merge types are available:"""
2196
takes_args = ['file*']
2197
takes_options = ['merge-type', 'reprocess',
2198
Option('show-base', help="Show base revision text in "
2202
from merge import merge_type_help
2203
from inspect import getdoc
2204
return getdoc(self) + '\n' + merge_type_help()
2206
def run(self, file_list=None, merge_type=None, show_base=False,
2208
from bzrlib.merge import merge_inner, transform_tree
2209
if merge_type is None:
2210
merge_type = Merge3Merger
2211
tree, file_list = tree_files(file_list)
2214
pending_merges = tree.pending_merges()
2215
if len(pending_merges) != 1:
2216
raise BzrCommandError("Sorry, remerge only works after normal"
2217
" merges. Not cherrypicking or"
2219
repository = tree.branch.repository
2220
base_revision = common_ancestor(tree.branch.last_revision(),
2221
pending_merges[0], repository)
2222
base_tree = repository.revision_tree(base_revision)
2223
other_tree = repository.revision_tree(pending_merges[0])
2224
interesting_ids = None
2226
conflicts = tree.conflicts()
2227
if file_list is not None:
2228
interesting_ids = set()
2229
for filename in file_list:
2230
file_id = tree.path2id(filename)
2232
raise NotVersionedError(filename)
2233
interesting_ids.add(file_id)
2234
if tree.kind(file_id) != "directory":
2237
for name, ie in tree.inventory.iter_entries(file_id):
2238
interesting_ids.add(ie.file_id)
2239
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2240
transform_tree(tree, tree.basis_tree(), interesting_ids)
2241
tree.set_conflicts(ConflictList(new_conflicts))
2242
if file_list is None:
2243
restore_files = list(tree.iter_conflicts())
2245
restore_files = file_list
2246
for filename in restore_files:
2248
restore(tree.abspath(filename))
2249
except NotConflicted:
2251
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2253
interesting_ids=interesting_ids,
2254
other_rev_id=pending_merges[0],
2255
merge_type=merge_type,
2256
show_base=show_base,
2257
reprocess=reprocess)
2265
class cmd_revert(Command):
2266
"""Reverse all changes since the last commit.
2268
Only versioned files are affected. Specify filenames to revert only
2269
those files. By default, any files that are changed will be backed up
2270
first. Backup files have a '~' appended to their name.
2272
takes_options = ['revision', 'no-backup']
2273
takes_args = ['file*']
2274
aliases = ['merge-revert']
2276
def run(self, revision=None, no_backup=False, file_list=None):
2277
from bzrlib.commands import parse_spec
2278
if file_list is not None:
2279
if len(file_list) == 0:
2280
raise BzrCommandError("No files specified")
2284
tree, file_list = tree_files(file_list)
2285
if revision is None:
2286
# FIXME should be tree.last_revision
2287
rev_id = tree.last_revision()
2288
elif len(revision) != 1:
2289
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2291
rev_id = revision[0].in_history(tree.branch).rev_id
2292
pb = ui.ui_factory.nested_progress_bar()
2294
tree.revert(file_list,
2295
tree.branch.repository.revision_tree(rev_id),
2301
class cmd_assert_fail(Command):
2302
"""Test reporting of assertion failures"""
2305
assert False, "always fails"
2308
class cmd_help(Command):
2309
"""Show help on a command or other topic.
2311
For a list of all available commands, say 'bzr help commands'."""
2312
takes_options = [Option('long', 'show help on all commands')]
2313
takes_args = ['topic?']
2314
aliases = ['?', '--help', '-?', '-h']
2317
def run(self, topic=None, long=False):
2319
if topic is None and long:
2324
class cmd_shell_complete(Command):
2325
"""Show appropriate completions for context.
2327
For a list of all available commands, say 'bzr shell-complete'."""
2328
takes_args = ['context?']
2333
def run(self, context=None):
2334
import shellcomplete
2335
shellcomplete.shellcomplete(context)
2338
class cmd_fetch(Command):
2339
"""Copy in history from another branch but don't merge it.
2341
This is an internal method used for pull and merge."""
2343
takes_args = ['from_branch', 'to_branch']
2344
def run(self, from_branch, to_branch):
2345
from bzrlib.fetch import Fetcher
2346
from_b = Branch.open(from_branch)
2347
to_b = Branch.open(to_branch)
2348
Fetcher(to_b, from_b)
2351
class cmd_missing(Command):
2352
"""Show unmerged/unpulled revisions between two branches.
2354
OTHER_BRANCH may be local or remote."""
2355
takes_args = ['other_branch?']
2356
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2358
'Display changes in the local branch only'),
2359
Option('theirs-only',
2360
'Display changes in the remote branch only'),
2368
encoding_type = 'replace'
2371
def run(self, other_branch=None, reverse=False, mine_only=False,
2372
theirs_only=False, log_format=None, long=False, short=False, line=False,
2373
show_ids=False, verbose=False):
2374
from bzrlib.missing import find_unmerged, iter_log_data
2375
from bzrlib.log import log_formatter
2376
local_branch = Branch.open_containing(u".")[0]
2377
parent = local_branch.get_parent()
2378
if other_branch is None:
2379
other_branch = parent
2380
if other_branch is None:
2381
raise BzrCommandError("No missing location known or specified.")
2382
print "Using last location: " + local_branch.get_parent()
2383
remote_branch = Branch.open(other_branch)
2384
if remote_branch.base == local_branch.base:
2385
remote_branch = local_branch
2386
local_branch.lock_read()
2388
remote_branch.lock_read()
2390
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2391
if (log_format == None):
2392
default = local_branch.get_config().log_format()
2393
log_format = get_log_format(long=long, short=short,
2394
line=line, default=default)
2395
lf = log_formatter(log_format,
2398
show_timezone='original')
2399
if reverse is False:
2400
local_extra.reverse()
2401
remote_extra.reverse()
2402
if local_extra and not theirs_only:
2403
print "You have %d extra revision(s):" % len(local_extra)
2404
for data in iter_log_data(local_extra, local_branch.repository,
2407
printed_local = True
2409
printed_local = False
2410
if remote_extra and not mine_only:
2411
if printed_local is True:
2413
print "You are missing %d revision(s):" % len(remote_extra)
2414
for data in iter_log_data(remote_extra, remote_branch.repository,
2417
if not remote_extra and not local_extra:
2419
print "Branches are up to date."
2423
remote_branch.unlock()
2425
local_branch.unlock()
2426
if not status_code and parent is None and other_branch is not None:
2427
local_branch.lock_write()
2429
# handle race conditions - a parent might be set while we run.
2430
if local_branch.get_parent() is None:
2431
local_branch.set_parent(remote_branch.base)
2433
local_branch.unlock()
2437
class cmd_plugins(Command):
2442
import bzrlib.plugin
2443
from inspect import getdoc
2444
for name, plugin in bzrlib.plugin.all_plugins().items():
2445
if hasattr(plugin, '__path__'):
2446
print plugin.__path__[0]
2447
elif hasattr(plugin, '__file__'):
2448
print plugin.__file__
2454
print '\t', d.split('\n')[0]
2457
class cmd_testament(Command):
2458
"""Show testament (signing-form) of a revision."""
2459
takes_options = ['revision', 'long',
2460
Option('strict', help='Produce a strict-format'
2462
takes_args = ['branch?']
2464
def run(self, branch=u'.', revision=None, long=False, strict=False):
2465
from bzrlib.testament import Testament, StrictTestament
2467
testament_class = StrictTestament
2469
testament_class = Testament
2470
b = WorkingTree.open_containing(branch)[0].branch
2473
if revision is None:
2474
rev_id = b.last_revision()
2476
rev_id = revision[0].in_history(b).rev_id
2477
t = testament_class.from_revision(b.repository, rev_id)
2479
sys.stdout.writelines(t.as_text_lines())
2481
sys.stdout.write(t.as_short_text())
2486
class cmd_annotate(Command):
2487
"""Show the origin of each line in a file.
2489
This prints out the given file with an annotation on the left side
2490
indicating which revision, author and date introduced the change.
2492
If the origin is the same for a run of consecutive lines, it is
2493
shown only at the top, unless the --all option is given.
2495
# TODO: annotate directories; showing when each file was last changed
2496
# TODO: if the working copy is modified, show annotations on that
2497
# with new uncommitted lines marked
2498
aliases = ['ann', 'blame', 'praise']
2499
takes_args = ['filename']
2500
takes_options = [Option('all', help='show annotations on all lines'),
2501
Option('long', help='show date in annotations'),
2506
def run(self, filename, all=False, long=False, revision=None):
2507
from bzrlib.annotate import annotate_file
2508
tree, relpath = WorkingTree.open_containing(filename)
2509
branch = tree.branch
2512
if revision is None:
2513
revision_id = branch.last_revision()
2514
elif len(revision) != 1:
2515
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2517
revision_id = revision[0].in_history(branch).rev_id
2518
file_id = tree.inventory.path2id(relpath)
2519
tree = branch.repository.revision_tree(revision_id)
2520
file_version = tree.inventory[file_id].revision
2521
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2526
class cmd_re_sign(Command):
2527
"""Create a digital signature for an existing revision."""
2528
# TODO be able to replace existing ones.
2530
hidden = True # is this right ?
2531
takes_args = ['revision_id*']
2532
takes_options = ['revision']
2534
def run(self, revision_id_list=None, revision=None):
2535
import bzrlib.gpg as gpg
2536
if revision_id_list is not None and revision is not None:
2537
raise BzrCommandError('You can only supply one of revision_id or --revision')
2538
if revision_id_list is None and revision is None:
2539
raise BzrCommandError('You must supply either --revision or a revision_id')
2540
b = WorkingTree.open_containing(u'.')[0].branch
2541
gpg_strategy = gpg.GPGStrategy(b.get_config())
2542
if revision_id_list is not None:
2543
for revision_id in revision_id_list:
2544
b.repository.sign_revision(revision_id, gpg_strategy)
2545
elif revision is not None:
2546
if len(revision) == 1:
2547
revno, rev_id = revision[0].in_history(b)
2548
b.repository.sign_revision(rev_id, gpg_strategy)
2549
elif len(revision) == 2:
2550
# are they both on rh- if so we can walk between them
2551
# might be nice to have a range helper for arbitrary
2552
# revision paths. hmm.
2553
from_revno, from_revid = revision[0].in_history(b)
2554
to_revno, to_revid = revision[1].in_history(b)
2555
if to_revid is None:
2556
to_revno = b.revno()
2557
if from_revno is None or to_revno is None:
2558
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2559
for revno in range(from_revno, to_revno + 1):
2560
b.repository.sign_revision(b.get_rev_id(revno),
2563
raise BzrCommandError('Please supply either one revision, or a range.')
2566
class cmd_bind(Command):
2567
"""Bind the current branch to a master branch.
2569
After binding, commits must succeed on the master branch
2570
before they are executed on the local one.
2573
takes_args = ['location']
2576
def run(self, location=None):
2577
b, relpath = Branch.open_containing(u'.')
2578
b_other = Branch.open(location)
2581
except DivergedBranches:
2582
raise BzrCommandError('These branches have diverged.'
2583
' Try merging, and then bind again.')
2586
class cmd_unbind(Command):
2587
"""Unbind the current branch from its master branch.
2589
After unbinding, the local branch is considered independent.
2590
All subsequent commits will be local.
2597
b, relpath = Branch.open_containing(u'.')
2599
raise BzrCommandError('Local branch is not bound')
2602
class cmd_uncommit(Command):
2603
"""Remove the last committed revision.
2605
--verbose will print out what is being removed.
2606
--dry-run will go through all the motions, but not actually
2609
In the future, uncommit will create a revision bundle, which can then
2613
# TODO: jam 20060108 Add an option to allow uncommit to remove
2614
# unreferenced information in 'branch-as-repository' branches.
2615
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2616
# information in shared branches as well.
2617
takes_options = ['verbose', 'revision',
2618
Option('dry-run', help='Don\'t actually make changes'),
2619
Option('force', help='Say yes to all questions.')]
2620
takes_args = ['location?']
2623
def run(self, location=None,
2624
dry_run=False, verbose=False,
2625
revision=None, force=False):
2626
from bzrlib.log import log_formatter
2628
from bzrlib.uncommit import uncommit
2630
if location is None:
2632
control, relpath = bzrdir.BzrDir.open_containing(location)
2634
tree = control.open_workingtree()
2636
except (errors.NoWorkingTree, errors.NotLocalUrl):
2638
b = control.open_branch()
2640
if revision is None:
2642
rev_id = b.last_revision()
2644
revno, rev_id = revision[0].in_history(b)
2646
print 'No revisions to uncommit.'
2648
for r in range(revno, b.revno()+1):
2649
rev_id = b.get_rev_id(r)
2650
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2651
lf.show(r, b.repository.get_revision(rev_id), None)
2654
print 'Dry-run, pretending to remove the above revisions.'
2656
val = raw_input('Press <enter> to continue')
2658
print 'The above revision(s) will be removed.'
2660
val = raw_input('Are you sure [y/N]? ')
2661
if val.lower() not in ('y', 'yes'):
2665
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2669
class cmd_break_lock(Command):
2670
"""Break a dead lock on a repository, branch or working directory.
2672
CAUTION: Locks should only be broken when you are sure that the process
2673
holding the lock has been stopped.
2675
You can get information on what locks are open via the 'bzr info' command.
2680
takes_args = ['location?']
2682
def run(self, location=None, show=False):
2683
if location is None:
2685
control, relpath = bzrdir.BzrDir.open_containing(location)
2687
control.break_lock()
2688
except NotImplementedError:
2693
# command-line interpretation helper for merge-related commands
2694
def merge(other_revision, base_revision,
2695
check_clean=True, ignore_zero=False,
2696
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2697
file_list=None, show_base=False, reprocess=False,
2698
pb=DummyProgress()):
2699
"""Merge changes into a tree.
2702
list(path, revno) Base for three-way merge.
2703
If [None, None] then a base will be automatically determined.
2705
list(path, revno) Other revision for three-way merge.
2707
Directory to merge changes into; '.' by default.
2709
If true, this_dir must have no uncommitted changes before the
2711
ignore_zero - If true, suppress the "zero conflicts" message when
2712
there are no conflicts; should be set when doing something we expect
2713
to complete perfectly.
2714
file_list - If supplied, merge only changes to selected files.
2716
All available ancestors of other_revision and base_revision are
2717
automatically pulled into the branch.
2719
The revno may be -1 to indicate the last revision on the branch, which is
2722
This function is intended for use from the command line; programmatic
2723
clients might prefer to call merge.merge_inner(), which has less magic
2726
from bzrlib.merge import Merger
2727
if this_dir is None:
2729
this_tree = WorkingTree.open_containing(this_dir)[0]
2730
if show_base and not merge_type is Merge3Merger:
2731
raise BzrCommandError("Show-base is not supported for this merge"
2732
" type. %s" % merge_type)
2733
if reprocess and not merge_type.supports_reprocess:
2734
raise BzrCommandError("Conflict reduction is not supported for merge"
2735
" type %s." % merge_type)
2736
if reprocess and show_base:
2737
raise BzrCommandError("Cannot do conflict reduction and show base.")
2739
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2740
merger.pp = ProgressPhase("Merge phase", 5, pb)
2741
merger.pp.next_phase()
2742
merger.check_basis(check_clean)
2743
merger.set_other(other_revision)
2744
merger.pp.next_phase()
2745
merger.set_base(base_revision)
2746
if merger.base_rev_id == merger.other_rev_id:
2747
note('Nothing to do.')
2749
merger.backup_files = backup_files
2750
merger.merge_type = merge_type
2751
merger.set_interesting_files(file_list)
2752
merger.show_base = show_base
2753
merger.reprocess = reprocess
2754
conflicts = merger.do_merge()
2755
if file_list is None:
2756
merger.set_pending()
2762
# these get imported and then picked up by the scan for cmd_*
2763
# TODO: Some more consistent way to split command definitions across files;
2764
# we do need to load at least some information about them to know of
2765
# aliases. ideally we would avoid loading the implementation until the
2766
# details were needed.
2767
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2768
from bzrlib.bundle.commands import cmd_bundle_revisions
2769
from bzrlib.sign_my_commits import cmd_sign_my_commits
2770
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2771
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
