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"""
23
from shutil import rmtree
28
from bzrlib.branch import Branch
29
import bzrlib.bzrdir as bzrdir
30
from bzrlib.bundle.read_bundle import BundleReader
31
from bzrlib.bundle.apply_bundle import merge_bundle
32
from bzrlib.commands import Command, display_command
33
import bzrlib.errors as errors
34
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch,
37
NotVersionedError, BadBundle)
38
from bzrlib.log import show_one_log
39
from bzrlib.merge import Merge3Merger
40
from bzrlib.option import Option
42
from bzrlib.progress import DummyProgress, ProgressPhase
43
from bzrlib.revision import common_ancestor
44
from bzrlib.revisionspec import RevisionSpec
46
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
47
from bzrlib.transport.local import LocalTransport
49
import bzrlib.urlutils as urlutils
50
from bzrlib.workingtree import WorkingTree
53
def tree_files(file_list, default_branch=u'.'):
55
return internal_tree_files(file_list, default_branch)
56
except FileInWrongBranch, e:
57
raise BzrCommandError("%s is not in the same branch as %s" %
58
(e.path, file_list[0]))
61
# XXX: Bad function name; should possibly also be a class method of
62
# WorkingTree rather than a function.
63
def internal_tree_files(file_list, default_branch=u'.'):
64
"""Convert command-line paths to a WorkingTree and relative paths.
66
This is typically used for command-line processors that take one or
67
more filenames, and infer the workingtree that contains them.
69
The filenames given are not required to exist.
71
:param file_list: Filenames to convert.
73
:param default_branch: Fallback tree path to use if file_list is empty or None.
75
:return: workingtree, [relative_paths]
77
if file_list is None or len(file_list) == 0:
78
return WorkingTree.open_containing(default_branch)[0], file_list
79
tree = WorkingTree.open_containing(file_list[0])[0]
81
for filename in file_list:
83
new_list.append(tree.relpath(filename))
84
except errors.PathNotChild:
85
raise FileInWrongBranch(tree.branch, filename)
89
def get_format_type(typestring):
90
"""Parse and return a format specifier."""
91
if typestring == "weave":
92
return bzrdir.BzrDirFormat6()
93
if typestring == "default":
94
return bzrdir.BzrDirMetaFormat1()
95
if typestring == "metaweave":
96
format = bzrdir.BzrDirMetaFormat1()
97
format.repository_format = bzrlib.repository.RepositoryFormat7()
99
if typestring == "knit":
100
format = bzrdir.BzrDirMetaFormat1()
101
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
103
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
104
"metaweave and weave" % typestring
105
raise BzrCommandError(msg)
108
# TODO: Make sure no commands unconditionally use the working directory as a
109
# branch. If a filename argument is used, the first of them should be used to
110
# specify the branch. (Perhaps this can be factored out into some kind of
111
# Argument class, representing a file in a branch, where the first occurrence
114
class cmd_status(Command):
115
"""Display status summary.
117
This reports on versioned and unknown files, reporting them
118
grouped by state. Possible states are:
121
Versioned in the working copy but not in the previous revision.
124
Versioned in the previous revision but removed or deleted
128
Path of this file changed from the previous revision;
129
the text may also have changed. This includes files whose
130
parent directory was renamed.
133
Text has changed since the previous revision.
136
Nothing about this file has changed since the previous revision.
137
Only shown with --all.
140
Not versioned and not matching an ignore pattern.
142
To see ignored files use 'bzr ignored'. For details in the
143
changes to file texts, use 'bzr diff'.
145
If no arguments are specified, the status of the entire working
146
directory is shown. Otherwise, only the status of the specified
147
files or directories is reported. If a directory is given, status
148
is reported for everything inside that directory.
150
If a revision argument is given, the status is calculated against
151
that revision, or between two revisions if two are provided.
154
# TODO: --no-recurse, --recurse options
156
takes_args = ['file*']
157
takes_options = ['all', 'show-ids', 'revision']
158
aliases = ['st', 'stat']
160
encoding_type = 'replace'
163
def run(self, all=False, show_ids=False, file_list=None, revision=None):
164
from bzrlib.status import show_tree_status
166
tree, file_list = tree_files(file_list)
168
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
169
specific_files=file_list, revision=revision,
173
class cmd_cat_revision(Command):
174
"""Write out metadata for a revision.
176
The revision to print can either be specified by a specific
177
revision identifier, or you can use --revision.
181
takes_args = ['revision_id?']
182
takes_options = ['revision']
183
# cat-revision is more for frontends so should be exact
187
def run(self, revision_id=None, revision=None):
189
if revision_id is not None and revision is not None:
190
raise BzrCommandError('You can only supply one of revision_id or --revision')
191
if revision_id is None and revision is None:
192
raise BzrCommandError('You must supply either --revision or a revision_id')
193
b = WorkingTree.open_containing(u'.')[0].branch
195
# TODO: jam 20060112 should cat-revision always output utf-8?
196
if revision_id is not None:
197
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
198
elif revision is not None:
201
raise BzrCommandError('You cannot specify a NULL revision.')
202
revno, rev_id = rev.in_history(b)
203
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
206
class cmd_revno(Command):
207
"""Show current revision number.
209
This is equal to the number of revisions on this branch.
212
takes_args = ['location?']
215
def run(self, location=u'.'):
216
self.outf.write(str(Branch.open_containing(location)[0].revno()))
217
self.outf.write('\n')
220
class cmd_revision_info(Command):
221
"""Show revision number and revision id for a given revision identifier.
224
takes_args = ['revision_info*']
225
takes_options = ['revision']
228
def run(self, revision=None, revision_info_list=[]):
231
if revision is not None:
232
revs.extend(revision)
233
if revision_info_list is not None:
234
for rev in revision_info_list:
235
revs.append(RevisionSpec(rev))
237
raise BzrCommandError('You must supply a revision identifier')
239
b = WorkingTree.open_containing(u'.')[0].branch
242
revinfo = rev.in_history(b)
243
if revinfo.revno is None:
244
print ' %s' % revinfo.rev_id
246
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
249
class cmd_add(Command):
250
"""Add specified files or directories.
252
In non-recursive mode, all the named items are added, regardless
253
of whether they were previously ignored. A warning is given if
254
any of the named files are already versioned.
256
In recursive mode (the default), files are treated the same way
257
but the behaviour for directories is different. Directories that
258
are already versioned do not give a warning. All directories,
259
whether already versioned or not, are searched for files or
260
subdirectories that are neither versioned or ignored, and these
261
are added. This search proceeds recursively into versioned
262
directories. If no names are given '.' is assumed.
264
Therefore simply saying 'bzr add' will version all files that
265
are currently unknown.
267
Adding a file whose parent directory is not versioned will
268
implicitly add the parent, and so on up to the root. This means
269
you should never need to explictly add a directory, they'll just
270
get added when you add a file in the directory.
272
--dry-run will show which files would be added, but not actually
275
takes_args = ['file*']
276
takes_options = ['no-recurse', 'dry-run', 'verbose']
277
encoding_type = 'replace'
279
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
282
action = bzrlib.add.AddAction(to_file=self.outf,
283
should_add=(not dry_run), should_print=(not is_quiet()))
285
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
289
for glob in sorted(ignored.keys()):
290
for path in ignored[glob]:
291
self.outf.write("ignored %s matching \"%s\"\n"
295
for glob, paths in ignored.items():
296
match_len += len(paths)
297
self.outf.write("ignored %d file(s).\n" % match_len)
298
self.outf.write("If you wish to add some of these files,"
299
" please add them by name.\n")
302
class cmd_mkdir(Command):
303
"""Create a new versioned directory.
305
This is equivalent to creating the directory and then adding it.
307
takes_args = ['dir+']
308
encoding_type = 'replace'
310
def run(self, dir_list):
313
wt, dd = WorkingTree.open_containing(d)
315
print >>self.outf, 'added', d
318
class cmd_relpath(Command):
319
"""Show path of a file relative to root"""
320
takes_args = ['filename']
324
def run(self, filename):
325
# TODO: jam 20050106 Can relpath return a munged path if
326
# sys.stdout encoding cannot represent it?
327
tree, relpath = WorkingTree.open_containing(filename)
328
self.outf.write(relpath)
329
self.outf.write('\n')
332
class cmd_inventory(Command):
333
"""Show inventory of the current working copy or a revision.
335
It is possible to limit the output to a particular entry
336
type using the --kind option. For example; --kind file.
338
takes_options = ['revision', 'show-ids', 'kind']
341
def run(self, revision=None, show_ids=False, kind=None):
342
if kind and kind not in ['file', 'directory', 'symlink']:
343
raise BzrCommandError('invalid kind specified')
344
tree = WorkingTree.open_containing(u'.')[0]
346
inv = tree.read_working_inventory()
348
if len(revision) > 1:
349
raise BzrCommandError('bzr inventory --revision takes'
350
' exactly one revision identifier')
351
inv = tree.branch.repository.get_revision_inventory(
352
revision[0].in_history(tree.branch).rev_id)
354
for path, entry in inv.entries():
355
if kind and kind != entry.kind:
358
self.outf.write('%-50s %s\n' % (path, entry.file_id))
360
self.outf.write(path)
361
self.outf.write('\n')
364
class cmd_mv(Command):
365
"""Move or rename a file.
368
bzr mv OLDNAME NEWNAME
369
bzr mv SOURCE... DESTINATION
371
If the last argument is a versioned directory, all the other names
372
are moved into it. Otherwise, there must be exactly two arguments
373
and the file is changed to a new name, which must not already exist.
375
Files cannot be moved between branches.
377
takes_args = ['names*']
378
aliases = ['move', 'rename']
380
encoding_type = 'replace'
382
def run(self, names_list):
383
if len(names_list) < 2:
384
raise BzrCommandError("missing file argument")
385
tree, rel_names = tree_files(names_list)
387
if os.path.isdir(names_list[-1]):
388
# move into existing directory
389
for pair in tree.move(rel_names[:-1], rel_names[-1]):
390
self.outf.write("%s => %s\n" % pair)
392
if len(names_list) != 2:
393
raise BzrCommandError('to mv multiple files the destination '
394
'must be a versioned directory')
395
tree.rename_one(rel_names[0], rel_names[1])
396
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
399
class cmd_pull(Command):
400
"""Turn this branch into a mirror of another branch.
402
This command only works on branches that have not diverged. Branches are
403
considered diverged if the destination branch's most recent commit is one
404
that has not been merged (directly or indirectly) into the parent.
406
If branches have diverged, you can use 'bzr merge' to integrate the changes
407
from one into the other. Once one branch has merged, the other should
408
be able to pull it again.
410
If branches have diverged, you can use 'bzr merge' to pull the text changes
411
from one into the other. Once one branch has merged, the other should
412
be able to pull it again.
414
If you want to forget your local changes and just update your branch to
415
match the remote one, use pull --overwrite.
417
If there is no default location set, the first pull will set it. After
418
that, you can omit the location to use the default. To change the
419
default, use --remember.
421
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
422
takes_args = ['location?']
423
encoding_type = 'replace'
425
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
426
# FIXME: too much stuff is in the command class
428
tree_to = WorkingTree.open_containing(u'.')[0]
429
branch_to = tree_to.branch
430
except NoWorkingTree:
432
branch_to = Branch.open_containing(u'.')[0]
433
stored_loc = branch_to.get_parent()
435
if stored_loc is None:
436
raise BzrCommandError("No pull location known or specified.")
438
display_url = urlutils.unescape_for_display(stored_loc,
440
self.outf.write("Using saved location: %s\n" % display_url)
441
location = stored_loc
443
branch_from = Branch.open(location)
445
if branch_to.get_parent() is None or remember:
446
branch_to.set_parent(branch_from.base)
450
elif len(revision) == 1:
451
rev_id = revision[0].in_history(branch_from).rev_id
453
raise BzrCommandError('bzr pull --revision takes one value.')
455
old_rh = branch_to.revision_history()
456
if tree_to is not None:
457
count = tree_to.pull(branch_from, overwrite, rev_id)
459
count = branch_to.pull(branch_from, overwrite, rev_id)
460
note('%d revision(s) pulled.' % (count,))
463
new_rh = branch_to.revision_history()
466
from bzrlib.log import show_changed_revisions
467
show_changed_revisions(branch_to, old_rh, new_rh,
471
class cmd_push(Command):
472
"""Update a mirror of this branch.
474
The target branch will not have its working tree populated because this
475
is both expensive, and is not supported on remote file systems.
477
Some smart servers or protocols *may* put the working tree in place in
480
This command only works on branches that have not diverged. Branches are
481
considered diverged if the destination branch's most recent commit is one
482
that has not been merged (directly or indirectly) by the source branch.
484
If branches have diverged, you can use 'bzr push --overwrite' to replace
485
the other branch completely, discarding its unmerged changes.
487
If you want to ensure you have the different changes in the other branch,
488
do a merge (see bzr help merge) from the other branch, and commit that.
489
After that you will be able to do a push without '--overwrite'.
491
If there is no default push location set, the first push will set it.
492
After that, you can omit the location to use the default. To change the
493
default, use --remember.
495
takes_options = ['remember', 'overwrite', 'verbose',
496
Option('create-prefix',
497
help='Create the path leading up to the branch '
498
'if it does not already exist')]
499
takes_args = ['location?']
500
encoding_type = 'replace'
502
def run(self, location=None, remember=False, overwrite=False,
503
create_prefix=False, verbose=False):
504
# FIXME: Way too big! Put this into a function called from the
506
from bzrlib.transport import get_transport
508
br_from = Branch.open_containing('.')[0]
509
stored_loc = br_from.get_push_location()
511
if stored_loc is None:
512
raise BzrCommandError("No push location known or specified.")
514
display_url = urlutils.unescape_for_display(stored_loc,
516
self.outf.write("Using saved location: %s" % display_url)
517
location = stored_loc
519
transport = get_transport(location)
520
location_url = transport.base
521
if br_from.get_push_location() is None or remember:
522
br_from.set_push_location(location_url)
526
dir_to = bzrlib.bzrdir.BzrDir.open(location_url)
527
br_to = dir_to.open_branch()
528
except NotBranchError:
530
transport = transport.clone('..')
531
if not create_prefix:
533
relurl = transport.relpath(location_url)
534
mutter('creating directory %s => %s', location_url, relurl)
535
transport.mkdir(relurl)
537
raise BzrCommandError("Parent directory of %s "
538
"does not exist." % location)
540
current = transport.base
541
needed = [(transport, transport.relpath(location_url))]
544
transport, relpath = needed[-1]
545
transport.mkdir(relpath)
548
new_transport = transport.clone('..')
549
needed.append((new_transport,
550
new_transport.relpath(transport.base)))
551
if new_transport.base == transport.base:
552
raise BzrCommandError("Could not create "
554
dir_to = br_from.bzrdir.clone(location_url,
555
revision_id=br_from.last_revision())
556
br_to = dir_to.open_branch()
557
count = len(br_to.revision_history())
559
old_rh = br_to.revision_history()
562
tree_to = dir_to.open_workingtree()
563
except errors.NotLocalUrl:
564
warning('This transport does not update the working '
565
'tree of: %s' % (br_to.base,))
566
count = br_to.pull(br_from, overwrite)
567
except NoWorkingTree:
568
count = br_to.pull(br_from, overwrite)
570
count = tree_to.pull(br_from, overwrite)
571
except DivergedBranches:
572
raise BzrCommandError("These branches have diverged."
573
" Try a merge then push with overwrite.")
574
note('%d revision(s) pushed.' % (count,))
577
new_rh = br_to.revision_history()
580
from bzrlib.log import show_changed_revisions
581
show_changed_revisions(br_to, old_rh, new_rh,
585
class cmd_branch(Command):
586
"""Create a new copy of a branch.
588
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
589
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
591
To retrieve the branch as of a particular revision, supply the --revision
592
parameter, as in "branch foo/bar -r 5".
594
--basis is to speed up branching from remote branches. When specified, it
595
copies all the file-contents, inventory and revision data from the basis
596
branch before copying anything from the remote branch.
598
takes_args = ['from_location', 'to_location?']
599
takes_options = ['revision', 'basis']
600
aliases = ['get', 'clone']
602
def run(self, from_location, to_location=None, revision=None, basis=None):
603
from bzrlib.transport import get_transport
604
from bzrlib.osutils import rmtree
607
elif len(revision) > 1:
608
raise BzrCommandError(
609
'bzr branch --revision takes exactly 1 revision value')
611
br_from = Branch.open(from_location)
613
if e.errno == errno.ENOENT:
614
raise BzrCommandError('Source location "%s" does not'
615
' exist.' % to_location)
620
if basis is not None:
621
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
624
if len(revision) == 1 and revision[0] is not None:
625
revision_id = revision[0].in_history(br_from)[1]
627
# FIXME - wt.last_revision, fallback to branch, fall back to
628
# None or perhaps NULL_REVISION to mean copy nothing
630
revision_id = br_from.last_revision()
631
if to_location is None:
632
to_location = os.path.basename(from_location.rstrip("/\\"))
635
name = os.path.basename(to_location) + '\n'
637
to_transport = get_transport(to_location)
639
to_transport.mkdir('.')
640
except bzrlib.errors.FileExists:
641
raise BzrCommandError('Target directory "%s" already'
642
' exists.' % to_location)
643
except bzrlib.errors.NoSuchFile:
644
raise BzrCommandError('Parent of "%s" does not exist.' %
647
# preserve whatever source format we have.
648
dir = br_from.bzrdir.sprout(to_transport.base,
649
revision_id, basis_dir)
650
branch = dir.open_branch()
651
except bzrlib.errors.NoSuchRevision:
652
# TODO: jam 20060426 This only works on local paths
653
# and it would be nice if 'bzr branch' could
654
# work on a remote path
656
msg = "The branch %s has no revision %s." % (from_location, revision[0])
657
raise BzrCommandError(msg)
658
except bzrlib.errors.UnlistableBranch:
660
msg = "The branch %s cannot be used as a --basis" % (basis,)
661
raise BzrCommandError(msg)
663
branch.control_files.put_utf8('branch-name', name)
664
note('Branched %d revision(s).' % branch.revno())
669
class cmd_checkout(Command):
670
"""Create a new checkout of an existing branch.
672
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
673
the branch found in '.'. This is useful if you have removed the working tree
674
or if it was never created - i.e. if you pushed the branch to its current
677
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
678
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
680
To retrieve the branch as of a particular revision, supply the --revision
681
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
682
out of date [so you cannot commit] but it may be useful (i.e. to examine old
685
--basis is to speed up checking out from remote branches. When specified, it
686
uses the inventory and file contents from the basis branch in preference to the
687
branch being checked out.
689
takes_args = ['branch_location?', 'to_location?']
690
takes_options = ['revision', # , 'basis']
691
Option('lightweight',
692
help="perform a lightweight checkout. Lightweight "
693
"checkouts depend on access to the branch for "
694
"every operation. Normal checkouts can perform "
695
"common operations like diff and status without "
696
"such access, and also support local commits."
700
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
704
elif len(revision) > 1:
705
raise BzrCommandError(
706
'bzr checkout --revision takes exactly 1 revision value')
707
if branch_location is None:
708
branch_location = bzrlib.osutils.getcwd()
709
to_location = branch_location
710
source = Branch.open(branch_location)
711
if len(revision) == 1 and revision[0] is not None:
712
revision_id = revision[0].in_history(source)[1]
715
if to_location is None:
716
to_location = os.path.basename(branch_location.rstrip("/\\"))
717
# if the source and to_location are the same,
718
# and there is no working tree,
719
# then reconstitute a branch
720
if (bzrlib.osutils.abspath(to_location) ==
721
bzrlib.osutils.abspath(branch_location)):
723
source.bzrdir.open_workingtree()
724
except errors.NoWorkingTree:
725
source.bzrdir.create_workingtree()
728
os.mkdir(to_location)
730
if e.errno == errno.EEXIST:
731
raise BzrCommandError('Target directory "%s" already'
732
' exists.' % to_location)
733
if e.errno == errno.ENOENT:
734
raise BzrCommandError('Parent of "%s" does not exist.' %
738
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
739
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
742
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
743
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
745
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
746
to_location, force_new_tree=False)
747
checkout = checkout_branch.bzrdir
748
checkout_branch.bind(source)
749
if revision_id is not None:
750
rh = checkout_branch.revision_history()
751
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
752
checkout.create_workingtree(revision_id)
754
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
757
class cmd_renames(Command):
758
"""Show list of renamed files.
760
# TODO: Option to show renames between two historical versions.
762
# TODO: Only show renames under dir, rather than in the whole branch.
763
takes_args = ['dir?']
766
def run(self, dir=u'.'):
767
tree = WorkingTree.open_containing(dir)[0]
768
old_inv = tree.basis_tree().inventory
769
new_inv = tree.read_working_inventory()
771
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
773
for old_name, new_name in renames:
774
self.outf.write("%s => %s\n" % (old_name, new_name))
777
class cmd_update(Command):
778
"""Update a tree to have the latest code committed to its branch.
780
This will perform a merge into the working tree, and may generate
781
conflicts. If you have any local changes, you will still
782
need to commit them after the update for the update to be complete.
784
If you want to discard your local changes, you can just do a
785
'bzr revert' instead of 'bzr commit' after the update.
787
takes_args = ['dir?']
789
def run(self, dir='.'):
790
tree = WorkingTree.open_containing(dir)[0]
793
if tree.last_revision() == tree.branch.last_revision():
794
# may be up to date, check master too.
795
master = tree.branch.get_master_branch()
796
if master is None or master.last_revision == tree.last_revision():
797
note("Tree is up to date.")
799
conflicts = tree.update()
800
note('Updated to revision %d.' %
801
(tree.branch.revision_id_to_revno(tree.last_revision()),))
810
class cmd_info(Command):
811
"""Show information about a working tree, branch or repository.
813
This command will show all known locations and formats associated to the
814
tree, branch or repository. Statistical information is included with
817
Branches and working trees will also report any missing revisions.
819
takes_args = ['location?']
820
takes_options = ['verbose']
823
def run(self, location=None, verbose=False):
824
from bzrlib.info import show_bzrdir_info
825
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
829
class cmd_remove(Command):
830
"""Make a file unversioned.
832
This makes bzr stop tracking changes to a versioned file. It does
833
not delete the working copy.
835
You can specify one or more files, and/or --new. If you specify --new,
836
only 'added' files will be removed. If you specify both, then new files
837
in the specified directories will be removed. If the directories are
838
also new, they will also be removed.
840
takes_args = ['file*']
841
takes_options = ['verbose', Option('new', help='remove newly-added files')]
843
encoding_type = 'replace'
845
def run(self, file_list, verbose=False, new=False):
846
tree, file_list = tree_files(file_list)
848
if file_list is None:
849
raise BzrCommandError('Specify one or more files to remove, or'
852
from bzrlib.delta import compare_trees
853
added = [compare_trees(tree.basis_tree(), tree,
854
specific_files=file_list).added]
855
file_list = sorted([f[0] for f in added[0]], reverse=True)
856
if len(file_list) == 0:
857
raise BzrCommandError('No matching files.')
858
tree.remove(file_list, verbose=verbose, to_file=self.outf)
861
class cmd_file_id(Command):
862
"""Print file_id of a particular file or directory.
864
The file_id is assigned when the file is first added and remains the
865
same through all revisions where the file exists, even when it is
869
takes_args = ['filename']
872
def run(self, filename):
873
tree, relpath = WorkingTree.open_containing(filename)
874
i = tree.inventory.path2id(relpath)
876
raise BzrError("%r is not a versioned file" % filename)
879
self.outf.write('\n')
882
class cmd_file_path(Command):
883
"""Print path of file_ids to a file or directory.
885
This prints one line for each directory down to the target,
886
starting at the branch root.
889
takes_args = ['filename']
892
def run(self, filename):
893
tree, relpath = WorkingTree.open_containing(filename)
895
fid = inv.path2id(relpath)
897
raise BzrError("%r is not a versioned file" % filename)
898
for fip in inv.get_idpath(fid):
900
self.outf.write('\n')
903
class cmd_reconcile(Command):
904
"""Reconcile bzr metadata in a branch.
906
This can correct data mismatches that may have been caused by
907
previous ghost operations or bzr upgrades. You should only
908
need to run this command if 'bzr check' or a bzr developer
909
advises you to run it.
911
If a second branch is provided, cross-branch reconciliation is
912
also attempted, which will check that data like the tree root
913
id which was not present in very early bzr versions is represented
914
correctly in both branches.
916
At the same time it is run it may recompress data resulting in
917
a potential saving in disk space or performance gain.
919
The branch *MUST* be on a listable system such as local disk or sftp.
921
takes_args = ['branch?']
923
def run(self, branch="."):
924
from bzrlib.reconcile import reconcile
925
dir = bzrlib.bzrdir.BzrDir.open(branch)
929
class cmd_revision_history(Command):
930
"""Display list of revision ids on this branch."""
935
branch = WorkingTree.open_containing(u'.')[0].branch
936
for patchid in branch.revision_history():
937
self.outf.write(patchid)
938
self.outf.write('\n')
941
class cmd_ancestry(Command):
942
"""List all revisions merged into this branch."""
947
tree = WorkingTree.open_containing(u'.')[0]
949
# FIXME. should be tree.last_revision
950
revision_ids = b.repository.get_ancestry(b.last_revision())
951
assert revision_ids[0] == None
953
for revision_id in revision_ids:
954
self.outf.write(revision_id + '\n')
957
class cmd_init(Command):
958
"""Make a directory into a versioned branch.
960
Use this to create an empty branch, or before importing an
963
If there is a repository in a parent directory of the location, then
964
the history of the branch will be stored in the repository. Otherwise
965
init creates a standalone branch which carries its own history in
968
If there is already a branch at the location but it has no working tree,
969
the tree can be populated with 'bzr checkout'.
971
Recipe for importing a tree of files:
976
bzr commit -m 'imported project'
978
takes_args = ['location?']
981
help='Specify a format for this branch. Current'
982
' formats are: default, knit, metaweave and'
983
' weave. Default is knit; metaweave and'
984
' weave are deprecated',
985
type=get_format_type),
987
def run(self, location=None, format=None):
988
from bzrlib.branch import Branch
990
format = get_format_type('default')
994
# The path has to exist to initialize a
995
# branch inside of it.
996
# Just using os.mkdir, since I don't
997
# believe that we want to create a bunch of
998
# locations if the user supplies an extended path
999
if not os.path.exists(location):
1002
existing_bzrdir = bzrdir.BzrDir.open(location)
1003
except NotBranchError:
1004
# really a NotBzrDir error...
1005
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1007
if existing_bzrdir.has_branch():
1008
if existing_bzrdir.has_workingtree():
1009
raise errors.AlreadyBranchError(location)
1011
raise errors.BranchExistsWithoutWorkingTree(location)
1013
existing_bzrdir.create_branch()
1014
existing_bzrdir.create_workingtree()
1017
class cmd_init_repository(Command):
1018
"""Create a shared repository to hold branches.
1020
New branches created under the repository directory will store their revisions
1021
in the repository, not in the branch directory, if the branch format supports
1027
bzr checkout --lightweight repo/trunk trunk-checkout
1031
takes_args = ["location"]
1032
takes_options = [Option('format',
1033
help='Specify a format for this repository.'
1034
' Current formats are: default, knit,'
1035
' metaweave and weave. Default is knit;'
1036
' metaweave and weave are deprecated',
1037
type=get_format_type),
1039
help='Allows branches in repository to have'
1041
aliases = ["init-repo"]
1042
def run(self, location, format=None, trees=False):
1043
from bzrlib.transport import get_transport
1045
format = get_format_type('default')
1046
transport = get_transport(location)
1047
if not transport.has('.'):
1049
newdir = format.initialize_on_transport(transport)
1050
repo = newdir.create_repository(shared=True)
1051
repo.set_make_working_trees(trees)
1054
class cmd_diff(Command):
1055
"""Show differences in working tree.
1057
If files are listed, only the changes in those files are listed.
1058
Otherwise, all changes for the tree are listed.
1060
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1061
produces patches suitable for "patch -p1".
1067
bzr diff --diff-prefix old/:new/
1068
bzr diff bzr.mine bzr.dev
1071
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1072
# or a graphical diff.
1074
# TODO: Python difflib is not exactly the same as unidiff; should
1075
# either fix it up or prefer to use an external diff.
1077
# TODO: Selected-file diff is inefficient and doesn't show you
1080
# TODO: This probably handles non-Unix newlines poorly.
1082
takes_args = ['file*']
1083
takes_options = ['revision', 'diff-options', 'prefix']
1084
aliases = ['di', 'dif']
1085
encoding_type = 'exact'
1088
def run(self, revision=None, file_list=None, diff_options=None,
1090
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1092
if (prefix is None) or (prefix == '0'):
1100
if not ':' in prefix:
1101
raise BzrError("--diff-prefix expects two values separated by a colon")
1102
old_label, new_label = prefix.split(":")
1105
tree1, file_list = internal_tree_files(file_list)
1109
except FileInWrongBranch:
1110
if len(file_list) != 2:
1111
raise BzrCommandError("Files are in different branches")
1113
tree1, file1 = WorkingTree.open_containing(file_list[0])
1114
tree2, file2 = WorkingTree.open_containing(file_list[1])
1115
if file1 != "" or file2 != "":
1116
# FIXME diff those two files. rbc 20051123
1117
raise BzrCommandError("Files are in different branches")
1119
if revision is not None:
1120
if tree2 is not None:
1121
raise BzrCommandError("Can't specify -r with two branches")
1122
if (len(revision) == 1) or (revision[1].spec is None):
1123
return diff_cmd_helper(tree1, file_list, diff_options,
1125
old_label=old_label, new_label=new_label)
1126
elif len(revision) == 2:
1127
return diff_cmd_helper(tree1, file_list, diff_options,
1128
revision[0], revision[1],
1129
old_label=old_label, new_label=new_label)
1131
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1133
if tree2 is not None:
1134
return show_diff_trees(tree1, tree2, sys.stdout,
1135
specific_files=file_list,
1136
external_diff_options=diff_options,
1137
old_label=old_label, new_label=new_label)
1139
return diff_cmd_helper(tree1, file_list, diff_options,
1140
old_label=old_label, new_label=new_label)
1143
class cmd_deleted(Command):
1144
"""List files deleted in the working tree.
1146
# TODO: Show files deleted since a previous revision, or
1147
# between two revisions.
1148
# TODO: Much more efficient way to do this: read in new
1149
# directories with readdir, rather than stating each one. Same
1150
# level of effort but possibly much less IO. (Or possibly not,
1151
# if the directories are very large...)
1152
takes_options = ['show-ids']
1155
def run(self, show_ids=False):
1156
tree = WorkingTree.open_containing(u'.')[0]
1157
old = tree.basis_tree()
1158
for path, ie in old.inventory.iter_entries():
1159
if not tree.has_id(ie.file_id):
1160
self.outf.write(path)
1162
self.outf.write(' ')
1163
self.outf.write(ie.file_id)
1164
self.outf.write('\n')
1167
class cmd_modified(Command):
1168
"""List files modified in working tree."""
1172
from bzrlib.delta import compare_trees
1174
tree = WorkingTree.open_containing(u'.')[0]
1175
td = compare_trees(tree.basis_tree(), tree)
1177
for path, id, kind, text_modified, meta_modified in td.modified:
1178
self.outf.write(path)
1179
self.outf.write('\n')
1182
class cmd_added(Command):
1183
"""List files added in working tree."""
1187
wt = WorkingTree.open_containing(u'.')[0]
1188
basis_inv = wt.basis_tree().inventory
1191
if file_id in basis_inv:
1193
path = inv.id2path(file_id)
1194
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1196
self.outf.write(path)
1197
self.outf.write('\n')
1200
class cmd_root(Command):
1201
"""Show the tree root directory.
1203
The root is the nearest enclosing directory with a .bzr control
1205
takes_args = ['filename?']
1207
def run(self, filename=None):
1208
"""Print the branch root."""
1209
tree = WorkingTree.open_containing(filename)[0]
1210
self.outf.write(tree.basedir)
1211
self.outf.write('\n')
1214
class cmd_log(Command):
1215
"""Show log of a branch, file, or directory.
1217
By default show the log of the branch containing the working directory.
1219
To request a range of logs, you can use the command -r begin..end
1220
-r revision requests a specific revision, -r ..end or -r begin.. are
1226
bzr log -r -10.. http://server/branch
1229
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1231
takes_args = ['location?']
1232
takes_options = [Option('forward',
1233
help='show from oldest to newest'),
1236
help='show files changed in each revision'),
1237
'show-ids', 'revision',
1241
help='show revisions whose message matches this regexp',
1245
encoding_type = 'replace'
1248
def run(self, location=None, timezone='original',
1258
from bzrlib.log import log_formatter, show_log
1259
assert message is None or isinstance(message, basestring), \
1260
"invalid message argument %r" % message
1261
direction = (forward and 'forward') or 'reverse'
1266
# find the file id to log:
1268
dir, fp = bzrdir.BzrDir.open_containing(location)
1269
b = dir.open_branch()
1273
inv = dir.open_workingtree().inventory
1274
except (errors.NotBranchError, errors.NotLocalUrl):
1275
# either no tree, or is remote.
1276
inv = b.basis_tree().inventory
1277
file_id = inv.path2id(fp)
1280
# FIXME ? log the current subdir only RBC 20060203
1281
dir, relpath = bzrdir.BzrDir.open_containing('.')
1282
b = dir.open_branch()
1284
if revision is None:
1287
elif len(revision) == 1:
1288
rev1 = rev2 = revision[0].in_history(b).revno
1289
elif len(revision) == 2:
1290
if revision[0].spec is None:
1291
# missing begin-range means first revision
1294
rev1 = revision[0].in_history(b).revno
1296
if revision[1].spec is None:
1297
# missing end-range means last known revision
1300
rev2 = revision[1].in_history(b).revno
1302
raise BzrCommandError('bzr log --revision takes one or two values.')
1304
# By this point, the revision numbers are converted to the +ve
1305
# form if they were supplied in the -ve form, so we can do
1306
# this comparison in relative safety
1308
(rev2, rev1) = (rev1, rev2)
1310
if (log_format == None):
1311
default = bzrlib.config.BranchConfig(b).log_format()
1312
log_format = get_log_format(long=long, short=short, line=line, default=default)
1313
lf = log_formatter(log_format,
1316
show_timezone=timezone)
1322
direction=direction,
1323
start_revision=rev1,
1328
def get_log_format(long=False, short=False, line=False, default='long'):
1329
log_format = default
1333
log_format = 'short'
1339
class cmd_touching_revisions(Command):
1340
"""Return revision-ids which affected a particular file.
1342
A more user-friendly interface is "bzr log FILE"."""
1344
takes_args = ["filename"]
1345
encoding_type = 'replace'
1348
def run(self, filename):
1349
tree, relpath = WorkingTree.open_containing(filename)
1351
inv = tree.read_working_inventory()
1352
file_id = inv.path2id(relpath)
1353
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1354
self.outf.write("%6d %s\n" % (revno, what))
1357
class cmd_ls(Command):
1358
"""List files in a tree.
1360
# TODO: Take a revision or remote path and list that tree instead.
1362
takes_options = ['verbose', 'revision',
1363
Option('non-recursive',
1364
help='don\'t recurse into sub-directories'),
1366
help='Print all paths from the root of the branch.'),
1367
Option('unknown', help='Print unknown files'),
1368
Option('versioned', help='Print versioned files'),
1369
Option('ignored', help='Print ignored files'),
1371
Option('null', help='Null separate the files'),
1374
def run(self, revision=None, verbose=False,
1375
non_recursive=False, from_root=False,
1376
unknown=False, versioned=False, ignored=False,
1379
if verbose and null:
1380
raise BzrCommandError('Cannot set both --verbose and --null')
1381
all = not (unknown or versioned or ignored)
1383
selection = {'I':ignored, '?':unknown, 'V':versioned}
1385
tree, relpath = WorkingTree.open_containing(u'.')
1390
if revision is not None:
1391
tree = tree.branch.repository.revision_tree(
1392
revision[0].in_history(tree.branch).rev_id)
1394
for fp, fc, kind, fid, entry in tree.list_files():
1395
if fp.startswith(relpath):
1396
fp = fp[len(relpath):]
1397
if non_recursive and '/' in fp:
1399
if not all and not selection[fc]:
1402
kindch = entry.kind_character()
1403
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1406
self.outf.write('\0')
1410
self.outf.write('\n')
1413
class cmd_unknowns(Command):
1414
"""List unknown files."""
1417
from bzrlib.osutils import quotefn
1418
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1419
self.outf.write(quotefn(f))
1420
self.outf.write('\n')
1423
class cmd_ignore(Command):
1424
"""Ignore a command or pattern.
1426
To remove patterns from the ignore list, edit the .bzrignore file.
1428
If the pattern contains a slash, it is compared to the whole path
1429
from the branch root. Otherwise, it is compared to only the last
1430
component of the path. To match a file only in the root directory,
1433
Ignore patterns are case-insensitive on case-insensitive systems.
1435
Note: wildcards must be quoted from the shell on Unix.
1438
bzr ignore ./Makefile
1439
bzr ignore '*.class'
1441
# TODO: Complain if the filename is absolute
1442
takes_args = ['name_pattern']
1444
def run(self, name_pattern):
1445
from bzrlib.atomicfile import AtomicFile
1448
tree, relpath = WorkingTree.open_containing(u'.')
1449
ifn = tree.abspath('.bzrignore')
1451
if os.path.exists(ifn):
1454
igns = f.read().decode('utf-8')
1460
# TODO: If the file already uses crlf-style termination, maybe
1461
# we should use that for the newly added lines?
1463
if igns and igns[-1] != '\n':
1465
igns += name_pattern + '\n'
1467
f = AtomicFile(ifn, 'wt')
1469
f.write(igns.encode('utf-8'))
1474
inv = tree.inventory
1475
if inv.path2id('.bzrignore'):
1476
mutter('.bzrignore is already versioned')
1478
mutter('need to make new .bzrignore file versioned')
1479
tree.add(['.bzrignore'])
1482
class cmd_ignored(Command):
1483
"""List ignored files and the patterns that matched them.
1485
See also: bzr ignore"""
1488
tree = WorkingTree.open_containing(u'.')[0]
1489
for path, file_class, kind, file_id, entry in tree.list_files():
1490
if file_class != 'I':
1492
## XXX: Slightly inefficient since this was already calculated
1493
pat = tree.is_ignored(path)
1494
print '%-50s %s' % (path, pat)
1497
class cmd_lookup_revision(Command):
1498
"""Lookup the revision-id from a revision-number
1501
bzr lookup-revision 33
1504
takes_args = ['revno']
1507
def run(self, revno):
1511
raise BzrCommandError("not a valid revision-number: %r" % revno)
1513
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1516
class cmd_export(Command):
1517
"""Export past revision to destination directory.
1519
If no revision is specified this exports the last committed revision.
1521
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1522
given, try to find the format with the extension. If no extension
1523
is found exports to a directory (equivalent to --format=dir).
1525
Root may be the top directory for tar, tgz and tbz2 formats. If none
1526
is given, the top directory will be the root name of the file.
1528
Note: export of tree with non-ascii filenames to zip is not supported.
1530
Supported formats Autodetected by extension
1531
----------------- -------------------------
1534
tbz2 .tar.bz2, .tbz2
1538
takes_args = ['dest']
1539
takes_options = ['revision', 'format', 'root']
1540
def run(self, dest, revision=None, format=None, root=None):
1542
from bzrlib.export import export
1543
tree = WorkingTree.open_containing(u'.')[0]
1545
if revision is None:
1546
# should be tree.last_revision FIXME
1547
rev_id = b.last_revision()
1549
if len(revision) != 1:
1550
raise BzrError('bzr export --revision takes exactly 1 argument')
1551
rev_id = revision[0].in_history(b).rev_id
1552
t = b.repository.revision_tree(rev_id)
1554
export(t, dest, format, root)
1555
except errors.NoSuchExportFormat, e:
1556
raise BzrCommandError('Unsupported export format: %s' % e.format)
1559
class cmd_cat(Command):
1560
"""Write a file's text from a previous revision."""
1562
takes_options = ['revision']
1563
takes_args = ['filename']
1566
def run(self, filename, revision=None):
1567
if revision is not None and len(revision) != 1:
1568
raise BzrCommandError("bzr cat --revision takes exactly one number")
1571
tree, relpath = WorkingTree.open_containing(filename)
1573
except NotBranchError:
1577
b, relpath = Branch.open_containing(filename)
1578
if revision is None:
1579
revision_id = b.last_revision()
1581
revision_id = revision[0].in_history(b).rev_id
1582
b.print_file(relpath, revision_id)
1585
class cmd_local_time_offset(Command):
1586
"""Show the offset in seconds from GMT to local time."""
1590
print bzrlib.osutils.local_time_offset()
1594
class cmd_commit(Command):
1595
"""Commit changes into a new revision.
1597
If no arguments are given, the entire tree is committed.
1599
If selected files are specified, only changes to those files are
1600
committed. If a directory is specified then the directory and everything
1601
within it is committed.
1603
A selected-file commit may fail in some cases where the committed
1604
tree would be invalid, such as trying to commit a file in a
1605
newly-added directory that is not itself committed.
1607
# TODO: Run hooks on tree to-be-committed, and after commit.
1609
# TODO: Strict commit that fails if there are deleted files.
1610
# (what does "deleted files" mean ??)
1612
# TODO: Give better message for -s, --summary, used by tla people
1614
# XXX: verbose currently does nothing
1616
takes_args = ['selected*']
1617
takes_options = ['message', 'verbose',
1619
help='commit even if nothing has changed'),
1620
Option('file', type=str,
1622
help='file containing commit message'),
1624
help="refuse to commit if there are unknown "
1625
"files in the working tree."),
1627
help="perform a local only commit in a bound "
1628
"branch. Such commits are not pushed to "
1629
"the master branch until a normal commit "
1633
aliases = ['ci', 'checkin']
1635
def run(self, message=None, file=None, verbose=True, selected_list=None,
1636
unchanged=False, strict=False, local=False):
1637
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1638
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1640
from bzrlib.msgeditor import edit_commit_message, \
1641
make_commit_message_template
1642
from tempfile import TemporaryFile
1644
# TODO: Need a blackbox test for invoking the external editor; may be
1645
# slightly problematic to run this cross-platform.
1647
# TODO: do more checks that the commit will succeed before
1648
# spending the user's valuable time typing a commit message.
1650
# TODO: if the commit *does* happen to fail, then save the commit
1651
# message to a temporary file where it can be recovered
1652
tree, selected_list = tree_files(selected_list)
1653
if selected_list == ['']:
1654
# workaround - commit of root of tree should be exactly the same
1655
# as just default commit in that tree, and succeed even though
1656
# selected-file merge commit is not done yet
1659
if local and not tree.branch.get_bound_location():
1660
raise errors.LocalRequiresBoundBranch()
1661
if message is None and not file:
1662
template = make_commit_message_template(tree, selected_list)
1663
message = edit_commit_message(template)
1665
raise BzrCommandError("please specify a commit message"
1666
" with either --message or --file")
1667
elif message and file:
1668
raise BzrCommandError("please specify either --message or --file")
1671
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1674
raise BzrCommandError("empty commit message specified")
1677
reporter = ReportCommitToLog()
1679
reporter = NullCommitReporter()
1682
tree.commit(message, specific_files=selected_list,
1683
allow_pointless=unchanged, strict=strict, local=local,
1685
except PointlessCommit:
1686
# FIXME: This should really happen before the file is read in;
1687
# perhaps prepare the commit; get the message; then actually commit
1688
raise BzrCommandError("no changes to commit",
1689
["use --unchanged to commit anyhow"])
1690
except ConflictsInTree:
1691
raise BzrCommandError("Conflicts detected in working tree. "
1692
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1693
except StrictCommitFailed:
1694
raise BzrCommandError("Commit refused because there are unknown "
1695
"files in the working tree.")
1696
except errors.BoundBranchOutOfDate, e:
1697
raise BzrCommandError(str(e)
1698
+ ' Either unbind, update, or'
1699
' pass --local to commit.')
1702
class cmd_check(Command):
1703
"""Validate consistency of branch history.
1705
This command checks various invariants about the branch storage to
1706
detect data corruption or bzr bugs.
1708
takes_args = ['branch?']
1709
takes_options = ['verbose']
1711
def run(self, branch=None, verbose=False):
1712
from bzrlib.check import check
1714
tree = WorkingTree.open_containing()[0]
1715
branch = tree.branch
1717
branch = Branch.open(branch)
1718
check(branch, verbose)
1721
class cmd_scan_cache(Command):
1724
from bzrlib.hashcache import HashCache
1730
print '%6d stats' % c.stat_count
1731
print '%6d in hashcache' % len(c._cache)
1732
print '%6d files removed from cache' % c.removed_count
1733
print '%6d hashes updated' % c.update_count
1734
print '%6d files changed too recently to cache' % c.danger_count
1740
class cmd_upgrade(Command):
1741
"""Upgrade branch storage to current format.
1743
The check command or bzr developers may sometimes advise you to run
1744
this command. When the default format has changed you may also be warned
1745
during other operations to upgrade.
1747
takes_args = ['url?']
1750
help='Upgrade to a specific format. Current formats'
1751
' are: default, knit, metaweave and weave.'
1752
' Default is knit; metaweave and weave are'
1754
type=get_format_type),
1758
def run(self, url='.', format=None):
1759
from bzrlib.upgrade import upgrade
1761
format = get_format_type('default')
1762
upgrade(url, format)
1765
class cmd_whoami(Command):
1766
"""Show bzr user id."""
1767
takes_options = ['email']
1770
def run(self, email=False):
1772
b = WorkingTree.open_containing(u'.')[0].branch
1773
config = bzrlib.config.BranchConfig(b)
1774
except NotBranchError:
1775
config = bzrlib.config.GlobalConfig()
1778
print config.user_email()
1780
print config.username()
1783
class cmd_nick(Command):
1784
"""Print or set the branch nickname.
1786
If unset, the tree root directory name is used as the nickname
1787
To print the current nickname, execute with no argument.
1789
takes_args = ['nickname?']
1790
def run(self, nickname=None):
1791
branch = Branch.open_containing(u'.')[0]
1792
if nickname is None:
1793
self.printme(branch)
1795
branch.nick = nickname
1798
def printme(self, branch):
1802
class cmd_selftest(Command):
1803
"""Run internal test suite.
1805
This creates temporary test directories in the working directory,
1806
but not existing data is affected. These directories are deleted
1807
if the tests pass, or left behind to help in debugging if they
1808
fail and --keep-output is specified.
1810
If arguments are given, they are regular expressions that say
1811
which tests should run.
1813
If the global option '--no-plugins' is given, plugins are not loaded
1814
before running the selftests. This has two effects: features provided or
1815
modified by plugins will not be tested, and tests provided by plugins will
1820
bzr --no-plugins selftest -v
1822
# TODO: --list should give a list of all available tests
1824
# NB: this is used from the class without creating an instance, which is
1825
# why it does not have a self parameter.
1826
def get_transport_type(typestring):
1827
"""Parse and return a transport specifier."""
1828
if typestring == "sftp":
1829
from bzrlib.transport.sftp import SFTPAbsoluteServer
1830
return SFTPAbsoluteServer
1831
if typestring == "memory":
1832
from bzrlib.transport.memory import MemoryServer
1834
if typestring == "fakenfs":
1835
from bzrlib.transport.fakenfs import FakeNFSServer
1836
return FakeNFSServer
1837
msg = "No known transport type %s. Supported types are: sftp\n" %\
1839
raise BzrCommandError(msg)
1842
takes_args = ['testspecs*']
1843
takes_options = ['verbose',
1844
Option('one', help='stop when one test fails'),
1845
Option('keep-output',
1846
help='keep output directories when tests fail'),
1848
help='Use a different transport by default '
1849
'throughout the test suite.',
1850
type=get_transport_type),
1851
Option('benchmark', help='run the bzr bencharks.'),
1852
Option('lsprof-timed',
1853
help='generate lsprof output for benchmarked'
1854
' sections of code.'),
1857
def run(self, testspecs_list=None, verbose=None, one=False,
1858
keep_output=False, transport=None, benchmark=None,
1861
from bzrlib.tests import selftest
1862
import bzrlib.benchmarks as benchmarks
1863
# we don't want progress meters from the tests to go to the
1864
# real output; and we don't want log messages cluttering up
1866
save_ui = bzrlib.ui.ui_factory
1867
print '%10s: %s' % ('bzr', bzrlib.osutils.realpath(sys.argv[0]))
1868
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1870
bzrlib.trace.info('running tests...')
1872
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1873
if testspecs_list is not None:
1874
pattern = '|'.join(testspecs_list)
1878
test_suite_factory = benchmarks.test_suite
1882
test_suite_factory = None
1885
result = selftest(verbose=verbose,
1887
stop_on_failure=one,
1888
keep_output=keep_output,
1889
transport=transport,
1890
test_suite_factory=test_suite_factory,
1891
lsprof_timed=lsprof_timed)
1893
bzrlib.trace.info('tests passed')
1895
bzrlib.trace.info('tests failed')
1896
return int(not result)
1898
bzrlib.ui.ui_factory = save_ui
1901
def _get_bzr_branch():
1902
"""If bzr is run from a branch, return Branch or None"""
1903
import bzrlib.errors
1904
from bzrlib.branch import Branch
1905
from bzrlib.osutils import abspath
1906
from os.path import dirname
1909
branch = Branch.open(dirname(abspath(dirname(__file__))))
1911
except bzrlib.errors.BzrError:
1916
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1917
# is bzrlib itself in a branch?
1918
branch = _get_bzr_branch()
1920
rh = branch.revision_history()
1922
print " bzr checkout, revision %d" % (revno,)
1923
print " nick: %s" % (branch.nick,)
1925
print " revid: %s" % (rh[-1],)
1926
print "Using python interpreter:", sys.executable
1928
print "Using python standard library:", os.path.dirname(site.__file__)
1929
print "Using bzrlib:",
1930
if len(bzrlib.__path__) > 1:
1931
# print repr, which is a good enough way of making it clear it's
1932
# more than one element (eg ['/foo/bar', '/foo/bzr'])
1933
print repr(bzrlib.__path__)
1935
print bzrlib.__path__[0]
1938
print bzrlib.__copyright__
1939
print "http://bazaar-vcs.org/"
1941
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1942
print "you may use, modify and redistribute it under the terms of the GNU"
1943
print "General Public License version 2 or later."
1946
class cmd_version(Command):
1947
"""Show version of bzr."""
1952
class cmd_rocks(Command):
1953
"""Statement of optimism."""
1957
print "it sure does!"
1960
class cmd_find_merge_base(Command):
1961
"""Find and print a base revision for merging two branches.
1963
# TODO: Options to specify revisions on either side, as if
1964
# merging only part of the history.
1965
takes_args = ['branch', 'other']
1969
def run(self, branch, other):
1970
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1972
branch1 = Branch.open_containing(branch)[0]
1973
branch2 = Branch.open_containing(other)[0]
1975
history_1 = branch1.revision_history()
1976
history_2 = branch2.revision_history()
1978
last1 = branch1.last_revision()
1979
last2 = branch2.last_revision()
1981
source = MultipleRevisionSources(branch1.repository,
1984
base_rev_id = common_ancestor(last1, last2, source)
1986
print 'merge base is revision %s' % base_rev_id
1990
if base_revno is None:
1991
raise bzrlib.errors.UnrelatedBranches()
1993
print ' r%-6d in %s' % (base_revno, branch)
1995
other_revno = branch2.revision_id_to_revno(base_revid)
1997
print ' r%-6d in %s' % (other_revno, other)
2001
class cmd_merge(Command):
2002
"""Perform a three-way merge.
2004
The branch is the branch you will merge from. By default, it will
2005
merge the latest revision. If you specify a revision, that
2006
revision will be merged. If you specify two revisions, the first
2007
will be used as a BASE, and the second one as OTHER. Revision
2008
numbers are always relative to the specified branch.
2010
By default, bzr will try to merge in all new work from the other
2011
branch, automatically determining an appropriate base. If this
2012
fails, you may need to give an explicit base.
2014
Merge will do its best to combine the changes in two branches, but there
2015
are some kinds of problems only a human can fix. When it encounters those,
2016
it will mark a conflict. A conflict means that you need to fix something,
2017
before you should commit.
2019
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2021
If there is no default branch set, the first merge will set it. After
2022
that, you can omit the branch to use the default. To change the
2023
default, use --remember.
2027
To merge the latest revision from bzr.dev
2028
bzr merge ../bzr.dev
2030
To merge changes up to and including revision 82 from bzr.dev
2031
bzr merge -r 82 ../bzr.dev
2033
To merge the changes introduced by 82, without previous changes:
2034
bzr merge -r 81..82 ../bzr.dev
2036
merge refuses to run if there are any uncommitted changes, unless
2039
The following merge types are available:
2041
takes_args = ['branch?']
2042
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2043
Option('show-base', help="Show base revision text in "
2047
from merge import merge_type_help
2048
from inspect import getdoc
2049
return getdoc(self) + '\n' + merge_type_help()
2051
def run(self, branch=None, revision=None, force=False, merge_type=None,
2052
show_base=False, reprocess=False, remember=False):
2053
if merge_type is None:
2054
merge_type = Merge3Merger
2056
tree = WorkingTree.open_containing(u'.')[0]
2059
if branch is not None:
2060
reader = BundleReader(file(branch, 'rb'))
2064
if e.errno not in (errno.ENOENT, errno.EISDIR):
2069
if reader is not None:
2070
conflicts = merge_bundle(reader, tree, not force, merge_type,
2071
reprocess, show_base)
2077
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2079
if revision is None or len(revision) < 1:
2081
other = [branch, -1]
2082
other_branch, path = Branch.open_containing(branch)
2084
if len(revision) == 1:
2086
other_branch, path = Branch.open_containing(branch)
2087
revno = revision[0].in_history(other_branch).revno
2088
other = [branch, revno]
2090
assert len(revision) == 2
2091
if None in revision:
2092
raise BzrCommandError(
2093
"Merge doesn't permit that revision specifier.")
2094
other_branch, path = Branch.open_containing(branch)
2096
base = [branch, revision[0].in_history(other_branch).revno]
2097
other = [branch, revision[1].in_history(other_branch).revno]
2099
if tree.branch.get_parent() is None or remember:
2100
tree.branch.set_parent(other_branch.base)
2103
interesting_files = [path]
2105
interesting_files = None
2106
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2109
conflict_count = merge(other, base, check_clean=(not force),
2110
merge_type=merge_type,
2111
reprocess=reprocess,
2112
show_base=show_base,
2113
pb=pb, file_list=interesting_files)
2116
if conflict_count != 0:
2120
except bzrlib.errors.AmbiguousBase, e:
2121
m = ("sorry, bzr can't determine the right merge base yet\n"
2122
"candidates are:\n "
2123
+ "\n ".join(e.bases)
2125
"please specify an explicit base with -r,\n"
2126
"and (if you want) report this to the bzr developers\n")
2129
# TODO: move up to common parent; this isn't merge-specific anymore.
2130
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2131
"""Use tree.branch's parent if none was supplied.
2133
Report if the remembered location was used.
2135
if supplied_location is not None:
2136
return supplied_location
2137
stored_location = tree.branch.get_parent()
2138
mutter("%s", stored_location)
2139
if stored_location is None:
2140
raise BzrCommandError("No location specified or remembered")
2141
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2142
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2143
return stored_location
2146
class cmd_remerge(Command):
2149
Use this if you want to try a different merge technique while resolving
2150
conflicts. Some merge techniques are better than others, and remerge
2151
lets you try different ones on different files.
2153
The options for remerge have the same meaning and defaults as the ones for
2154
merge. The difference is that remerge can (only) be run when there is a
2155
pending merge, and it lets you specify particular files.
2158
$ bzr remerge --show-base
2159
Re-do the merge of all conflicted files, and show the base text in
2160
conflict regions, in addition to the usual THIS and OTHER texts.
2162
$ bzr remerge --merge-type weave --reprocess foobar
2163
Re-do the merge of "foobar", using the weave merge algorithm, with
2164
additional processing to reduce the size of conflict regions.
2166
The following merge types are available:"""
2167
takes_args = ['file*']
2168
takes_options = ['merge-type', 'reprocess',
2169
Option('show-base', help="Show base revision text in "
2173
from merge import merge_type_help
2174
from inspect import getdoc
2175
return getdoc(self) + '\n' + merge_type_help()
2177
def run(self, file_list=None, merge_type=None, show_base=False,
2179
from bzrlib.merge import merge_inner, transform_tree
2180
if merge_type is None:
2181
merge_type = Merge3Merger
2182
tree, file_list = tree_files(file_list)
2185
pending_merges = tree.pending_merges()
2186
if len(pending_merges) != 1:
2187
raise BzrCommandError("Sorry, remerge only works after normal"
2188
+ " merges. Not cherrypicking or"
2190
repository = tree.branch.repository
2191
base_revision = common_ancestor(tree.branch.last_revision(),
2192
pending_merges[0], repository)
2193
base_tree = repository.revision_tree(base_revision)
2194
other_tree = repository.revision_tree(pending_merges[0])
2195
interesting_ids = None
2196
if file_list is not None:
2197
interesting_ids = set()
2198
for filename in file_list:
2199
file_id = tree.path2id(filename)
2201
raise NotVersionedError(filename)
2202
interesting_ids.add(file_id)
2203
if tree.kind(file_id) != "directory":
2206
for name, ie in tree.inventory.iter_entries(file_id):
2207
interesting_ids.add(ie.file_id)
2208
transform_tree(tree, tree.basis_tree(), interesting_ids)
2209
if file_list is None:
2210
restore_files = list(tree.iter_conflicts())
2212
restore_files = file_list
2213
for filename in restore_files:
2215
restore(tree.abspath(filename))
2216
except NotConflicted:
2218
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2220
interesting_ids = interesting_ids,
2221
other_rev_id=pending_merges[0],
2222
merge_type=merge_type,
2223
show_base=show_base,
2224
reprocess=reprocess)
2232
class cmd_revert(Command):
2233
"""Reverse all changes since the last commit.
2235
Only versioned files are affected. Specify filenames to revert only
2236
those files. By default, any files that are changed will be backed up
2237
first. Backup files have a '~' appended to their name.
2239
takes_options = ['revision', 'no-backup']
2240
takes_args = ['file*']
2241
aliases = ['merge-revert']
2243
def run(self, revision=None, no_backup=False, file_list=None):
2244
from bzrlib.commands import parse_spec
2245
if file_list is not None:
2246
if len(file_list) == 0:
2247
raise BzrCommandError("No files specified")
2251
tree, file_list = tree_files(file_list)
2252
if revision is None:
2253
# FIXME should be tree.last_revision
2254
rev_id = tree.last_revision()
2255
elif len(revision) != 1:
2256
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2258
rev_id = revision[0].in_history(tree.branch).rev_id
2259
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2261
tree.revert(file_list,
2262
tree.branch.repository.revision_tree(rev_id),
2268
class cmd_assert_fail(Command):
2269
"""Test reporting of assertion failures"""
2272
assert False, "always fails"
2275
class cmd_help(Command):
2276
"""Show help on a command or other topic.
2278
For a list of all available commands, say 'bzr help commands'."""
2279
takes_options = [Option('long', 'show help on all commands')]
2280
takes_args = ['topic?']
2281
aliases = ['?', '--help', '-?', '-h']
2284
def run(self, topic=None, long=False):
2286
if topic is None and long:
2291
class cmd_shell_complete(Command):
2292
"""Show appropriate completions for context.
2294
For a list of all available commands, say 'bzr shell-complete'."""
2295
takes_args = ['context?']
2300
def run(self, context=None):
2301
import shellcomplete
2302
shellcomplete.shellcomplete(context)
2305
class cmd_fetch(Command):
2306
"""Copy in history from another branch but don't merge it.
2308
This is an internal method used for pull and merge."""
2310
takes_args = ['from_branch', 'to_branch']
2311
def run(self, from_branch, to_branch):
2312
from bzrlib.fetch import Fetcher
2313
from bzrlib.branch import Branch
2314
from_b = Branch.open(from_branch)
2315
to_b = Branch.open(to_branch)
2316
Fetcher(to_b, from_b)
2319
class cmd_missing(Command):
2320
"""Show unmerged/unpulled revisions between two branches.
2322
OTHER_BRANCH may be local or remote."""
2323
takes_args = ['other_branch?']
2324
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2326
'Display changes in the local branch only'),
2327
Option('theirs-only',
2328
'Display changes in the remote branch only'),
2337
def run(self, other_branch=None, reverse=False, mine_only=False,
2338
theirs_only=False, log_format=None, long=False, short=False, line=False,
2339
show_ids=False, verbose=False):
2340
from bzrlib.missing import find_unmerged, iter_log_data
2341
from bzrlib.log import log_formatter
2342
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2343
parent = local_branch.get_parent()
2344
if other_branch is None:
2345
other_branch = parent
2346
if other_branch is None:
2347
raise BzrCommandError("No missing location known or specified.")
2348
print "Using last location: " + local_branch.get_parent()
2349
remote_branch = bzrlib.branch.Branch.open(other_branch)
2350
if remote_branch.base == local_branch.base:
2351
remote_branch = local_branch
2352
local_branch.lock_read()
2354
remote_branch.lock_read()
2356
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2357
if (log_format == None):
2358
default = bzrlib.config.BranchConfig(local_branch).log_format()
2359
log_format = get_log_format(long=long, short=short, line=line, default=default)
2360
lf = log_formatter(log_format, sys.stdout,
2362
show_timezone='original')
2363
if reverse is False:
2364
local_extra.reverse()
2365
remote_extra.reverse()
2366
if local_extra and not theirs_only:
2367
print "You have %d extra revision(s):" % len(local_extra)
2368
for data in iter_log_data(local_extra, local_branch.repository,
2371
printed_local = True
2373
printed_local = False
2374
if remote_extra and not mine_only:
2375
if printed_local is True:
2377
print "You are missing %d revision(s):" % len(remote_extra)
2378
for data in iter_log_data(remote_extra, remote_branch.repository,
2381
if not remote_extra and not local_extra:
2383
print "Branches are up to date."
2387
remote_branch.unlock()
2389
local_branch.unlock()
2390
if not status_code and parent is None and other_branch is not None:
2391
local_branch.lock_write()
2393
# handle race conditions - a parent might be set while we run.
2394
if local_branch.get_parent() is None:
2395
local_branch.set_parent(remote_branch.base)
2397
local_branch.unlock()
2401
class cmd_plugins(Command):
2406
import bzrlib.plugin
2407
from inspect import getdoc
2408
for name, plugin in bzrlib.plugin.all_plugins().items():
2409
if hasattr(plugin, '__path__'):
2410
print plugin.__path__[0]
2411
elif hasattr(plugin, '__file__'):
2412
print plugin.__file__
2418
print '\t', d.split('\n')[0]
2421
class cmd_testament(Command):
2422
"""Show testament (signing-form) of a revision."""
2423
takes_options = ['revision', 'long']
2424
takes_args = ['branch?']
2426
def run(self, branch=u'.', revision=None, long=False):
2427
from bzrlib.testament import Testament
2428
b = WorkingTree.open_containing(branch)[0].branch
2431
if revision is None:
2432
rev_id = b.last_revision()
2434
rev_id = revision[0].in_history(b).rev_id
2435
t = Testament.from_revision(b.repository, rev_id)
2437
sys.stdout.writelines(t.as_text_lines())
2439
sys.stdout.write(t.as_short_text())
2444
class cmd_annotate(Command):
2445
"""Show the origin of each line in a file.
2447
This prints out the given file with an annotation on the left side
2448
indicating which revision, author and date introduced the change.
2450
If the origin is the same for a run of consecutive lines, it is
2451
shown only at the top, unless the --all option is given.
2453
# TODO: annotate directories; showing when each file was last changed
2454
# TODO: if the working copy is modified, show annotations on that
2455
# with new uncommitted lines marked
2456
aliases = ['blame', 'praise']
2457
takes_args = ['filename']
2458
takes_options = [Option('all', help='show annotations on all lines'),
2459
Option('long', help='show date in annotations'),
2464
def run(self, filename, all=False, long=False, revision=None):
2465
from bzrlib.annotate import annotate_file
2466
tree, relpath = WorkingTree.open_containing(filename)
2467
branch = tree.branch
2470
if revision is None:
2471
revision_id = branch.last_revision()
2472
elif len(revision) != 1:
2473
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2475
revision_id = revision[0].in_history(branch).rev_id
2476
file_id = tree.inventory.path2id(relpath)
2477
tree = branch.repository.revision_tree(revision_id)
2478
file_version = tree.inventory[file_id].revision
2479
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2484
class cmd_re_sign(Command):
2485
"""Create a digital signature for an existing revision."""
2486
# TODO be able to replace existing ones.
2488
hidden = True # is this right ?
2489
takes_args = ['revision_id*']
2490
takes_options = ['revision']
2492
def run(self, revision_id_list=None, revision=None):
2493
import bzrlib.config as config
2494
import bzrlib.gpg as gpg
2495
if revision_id_list is not None and revision is not None:
2496
raise BzrCommandError('You can only supply one of revision_id or --revision')
2497
if revision_id_list is None and revision is None:
2498
raise BzrCommandError('You must supply either --revision or a revision_id')
2499
b = WorkingTree.open_containing(u'.')[0].branch
2500
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2501
if revision_id_list is not None:
2502
for revision_id in revision_id_list:
2503
b.repository.sign_revision(revision_id, gpg_strategy)
2504
elif revision is not None:
2505
if len(revision) == 1:
2506
revno, rev_id = revision[0].in_history(b)
2507
b.repository.sign_revision(rev_id, gpg_strategy)
2508
elif len(revision) == 2:
2509
# are they both on rh- if so we can walk between them
2510
# might be nice to have a range helper for arbitrary
2511
# revision paths. hmm.
2512
from_revno, from_revid = revision[0].in_history(b)
2513
to_revno, to_revid = revision[1].in_history(b)
2514
if to_revid is None:
2515
to_revno = b.revno()
2516
if from_revno is None or to_revno is None:
2517
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2518
for revno in range(from_revno, to_revno + 1):
2519
b.repository.sign_revision(b.get_rev_id(revno),
2522
raise BzrCommandError('Please supply either one revision, or a range.')
2525
class cmd_bind(Command):
2526
"""Bind the current branch to a master branch.
2528
After binding, commits must succeed on the master branch
2529
before they are executed on the local one.
2532
takes_args = ['location']
2535
def run(self, location=None):
2536
b, relpath = Branch.open_containing(u'.')
2537
b_other = Branch.open(location)
2540
except DivergedBranches:
2541
raise BzrCommandError('These branches have diverged.'
2542
' Try merging, and then bind again.')
2545
class cmd_unbind(Command):
2546
"""Unbind the current branch from its master branch.
2548
After unbinding, the local branch is considered independent.
2549
All subsequent commits will be local.
2556
b, relpath = Branch.open_containing(u'.')
2558
raise BzrCommandError('Local branch is not bound')
2561
class cmd_uncommit(bzrlib.commands.Command):
2562
"""Remove the last committed revision.
2564
--verbose will print out what is being removed.
2565
--dry-run will go through all the motions, but not actually
2568
In the future, uncommit will create a revision bundle, which can then
2572
# TODO: jam 20060108 Add an option to allow uncommit to remove
2573
# unreferenced information in 'branch-as-repostory' branches.
2574
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2575
# information in shared branches as well.
2576
takes_options = ['verbose', 'revision',
2577
Option('dry-run', help='Don\'t actually make changes'),
2578
Option('force', help='Say yes to all questions.')]
2579
takes_args = ['location?']
2582
def run(self, location=None,
2583
dry_run=False, verbose=False,
2584
revision=None, force=False):
2585
from bzrlib.branch import Branch
2586
from bzrlib.log import log_formatter
2588
from bzrlib.uncommit import uncommit
2590
if location is None:
2592
control, relpath = bzrdir.BzrDir.open_containing(location)
2594
tree = control.open_workingtree()
2596
except (errors.NoWorkingTree, errors.NotLocalUrl):
2598
b = control.open_branch()
2600
if revision is None:
2602
rev_id = b.last_revision()
2604
revno, rev_id = revision[0].in_history(b)
2606
print 'No revisions to uncommit.'
2608
for r in range(revno, b.revno()+1):
2609
rev_id = b.get_rev_id(r)
2610
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2611
lf.show(r, b.repository.get_revision(rev_id), None)
2614
print 'Dry-run, pretending to remove the above revisions.'
2616
val = raw_input('Press <enter> to continue')
2618
print 'The above revision(s) will be removed.'
2620
val = raw_input('Are you sure [y/N]? ')
2621
if val.lower() not in ('y', 'yes'):
2625
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2629
class cmd_break_lock(Command):
2630
"""Break a dead lock on a repository, branch or working directory.
2632
CAUTION: Locks should only be broken when you are sure that the process
2633
holding the lock has been stopped.
2635
You can get information on what locks are open via the 'bzr info' command.
2640
takes_args = ['location?']
2642
def run(self, location=None, show=False):
2643
if location is None:
2645
control, relpath = bzrdir.BzrDir.open_containing(location)
2647
control.break_lock()
2648
except NotImplementedError:
2653
# command-line interpretation helper for merge-related commands
2654
def merge(other_revision, base_revision,
2655
check_clean=True, ignore_zero=False,
2656
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2657
file_list=None, show_base=False, reprocess=False,
2658
pb=DummyProgress()):
2659
"""Merge changes into a tree.
2662
list(path, revno) Base for three-way merge.
2663
If [None, None] then a base will be automatically determined.
2665
list(path, revno) Other revision for three-way merge.
2667
Directory to merge changes into; '.' by default.
2669
If true, this_dir must have no uncommitted changes before the
2671
ignore_zero - If true, suppress the "zero conflicts" message when
2672
there are no conflicts; should be set when doing something we expect
2673
to complete perfectly.
2674
file_list - If supplied, merge only changes to selected files.
2676
All available ancestors of other_revision and base_revision are
2677
automatically pulled into the branch.
2679
The revno may be -1 to indicate the last revision on the branch, which is
2682
This function is intended for use from the command line; programmatic
2683
clients might prefer to call merge.merge_inner(), which has less magic
2686
from bzrlib.merge import Merger
2687
if this_dir is None:
2689
this_tree = WorkingTree.open_containing(this_dir)[0]
2690
if show_base and not merge_type is Merge3Merger:
2691
raise BzrCommandError("Show-base is not supported for this merge"
2692
" type. %s" % merge_type)
2693
if reprocess and not merge_type.supports_reprocess:
2694
raise BzrCommandError("Conflict reduction is not supported for merge"
2695
" type %s." % merge_type)
2696
if reprocess and show_base:
2697
raise BzrCommandError("Cannot do conflict reduction and show base.")
2699
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2700
merger.pp = ProgressPhase("Merge phase", 5, pb)
2701
merger.pp.next_phase()
2702
merger.check_basis(check_clean)
2703
merger.set_other(other_revision)
2704
merger.pp.next_phase()
2705
merger.set_base(base_revision)
2706
if merger.base_rev_id == merger.other_rev_id:
2707
note('Nothing to do.')
2709
merger.backup_files = backup_files
2710
merger.merge_type = merge_type
2711
merger.set_interesting_files(file_list)
2712
merger.show_base = show_base
2713
merger.reprocess = reprocess
2714
conflicts = merger.do_merge()
2715
if file_list is None:
2716
merger.set_pending()
2722
# these get imported and then picked up by the scan for cmd_*
2723
# TODO: Some more consistent way to split command definitions across files;
2724
# we do need to load at least some information about them to know of
2725
# aliases. ideally we would avoid loading the implementation until the
2726
# details were needed.
2727
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2728
from bzrlib.bundle.commands import cmd_bundle_revisions
2729
from bzrlib.sign_my_commits import cmd_sign_my_commits
2730
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2731
cmd_weave_plan_merge, cmd_weave_merge_text
added
removed
bzrlib/builtins.py
