To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1731.1.50
- compare with another revision
- download diff
- download tarball
- view history from revision 1731.1.50
- Committer: Aaron Bentley
- Date: 2006-09-22 04:52:17 UTC
- mfrom: (2029 +trunk)
- mto: (2100.3.5 by-reference-trees) (1731.2.8 nested-trees)
- mto: This revision was merged to the branch mainline in revision 2078.
- Revision ID: aaron.bentley@utoronto.ca-20060922045217-4e775bf2fc6d0b3b
Merge bzr.dev
- files added:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/version_info_formats
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- tools
- tools/doc_generate
- tools/win32
- files removed:
- .bzrignore
- foreign
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
#
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.
7
#
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.
12
#
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
16
17
"""builtin bzr commands"""
18
19
20
import codecs
21
import errno
22
import os
23
import os.path
24
import sys
25
26
import bzrlib
27
from bzrlib import (
28
branch,
29
bundle,
30
bzrdir,
31
config,
32
errors,
33
ignores,
34
log,
35
osutils,
36
repository,
37
transport,
38
ui,
39
urlutils,
40
)
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
from bzrlib.conflicts import ConflictList
45
from bzrlib.commands import Command, display_command
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
47
NotBranchError, DivergedBranches, NotConflicted,
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
54
from bzrlib.revisionspec import RevisionSpec
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
57
from bzrlib.workingtree import WorkingTree
58
59
60
def tree_files(file_list, default_branch=u'.'):
61
try:
62
return internal_tree_files(file_list, default_branch)
63
except FileInWrongBranch, e:
64
raise BzrCommandError("%s is not in the same branch as %s" %
65
(e.path, file_list[0]))
66
67
68
# XXX: Bad function name; should possibly also be a class method of
69
# WorkingTree rather than a function.
70
def internal_tree_files(file_list, default_branch=u'.'):
71
"""Convert command-line paths to a WorkingTree and relative paths.
72
73
This is typically used for command-line processors that take one or
74
more filenames, and infer the workingtree that contains them.
75
76
The filenames given are not required to exist.
77
78
:param file_list: Filenames to convert.
79
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
81
82
:return: workingtree, [relative_paths]
83
"""
84
if file_list is None or len(file_list) == 0:
85
return WorkingTree.open_containing(default_branch)[0], file_list
86
tree = WorkingTree.open_containing(file_list[0])[0]
87
new_list = []
88
for filename in file_list:
89
try:
90
new_list.append(tree.relpath(filename))
91
except errors.PathNotChild:
92
raise FileInWrongBranch(tree.branch, filename)
93
return tree, new_list
94
95
96
def get_format_type(typestring):
97
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
100
if typestring == "default":
101
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
105
return format
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
109
return format
110
if typestring == "experimental-knit2":
111
format = bzrdir.BzrDirMetaFormat1()
112
format.repository_format = repository.RepositoryFormatKnit2()
113
return format
114
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
115
"metaweave and weave" % typestring
116
raise BzrCommandError(msg)
117
118
119
# TODO: Make sure no commands unconditionally use the working directory as a
120
# branch. If a filename argument is used, the first of them should be used to
121
# specify the branch. (Perhaps this can be factored out into some kind of
122
# Argument class, representing a file in a branch, where the first occurrence
123
# opens the branch?)
124
125
class cmd_status(Command):
126
"""Display status summary.
127
128
This reports on versioned and unknown files, reporting them
129
grouped by state. Possible states are:
130
131
added
132
Versioned in the working copy but not in the previous revision.
133
134
removed
135
Versioned in the previous revision but removed or deleted
136
in the working copy.
137
138
renamed
139
Path of this file changed from the previous revision;
140
the text may also have changed. This includes files whose
141
parent directory was renamed.
142
143
modified
144
Text has changed since the previous revision.
145
146
unknown
147
Not versioned and not matching an ignore pattern.
148
149
To see ignored files use 'bzr ignored'. For details in the
150
changes to file texts, use 'bzr diff'.
151
152
If no arguments are specified, the status of the entire working
153
directory is shown. Otherwise, only the status of the specified
154
files or directories is reported. If a directory is given, status
155
is reported for everything inside that directory.
156
157
If a revision argument is given, the status is calculated against
158
that revision, or between two revisions if two are provided.
159
"""
160
161
# TODO: --no-recurse, --recurse options
162
163
takes_args = ['file*']
164
takes_options = ['show-ids', 'revision']
165
aliases = ['st', 'stat']
166
167
encoding_type = 'replace'
168
169
@display_command
170
def run(self, show_ids=False, file_list=None, revision=None):
171
from bzrlib.status import show_tree_status
172
173
tree, file_list = tree_files(file_list)
174
175
show_tree_status(tree, show_ids=show_ids,
176
specific_files=file_list, revision=revision,
177
to_file=self.outf)
178
179
180
class cmd_cat_revision(Command):
181
"""Write out metadata for a revision.
182
183
The revision to print can either be specified by a specific
184
revision identifier, or you can use --revision.
185
"""
186
187
hidden = True
188
takes_args = ['revision_id?']
189
takes_options = ['revision']
190
# cat-revision is more for frontends so should be exact
191
encoding = 'strict'
192
193
@display_command
194
def run(self, revision_id=None, revision=None):
195
196
if revision_id is not None and revision is not None:
197
raise BzrCommandError('You can only supply one of revision_id or --revision')
198
if revision_id is None and revision is None:
199
raise BzrCommandError('You must supply either --revision or a revision_id')
200
b = WorkingTree.open_containing(u'.')[0].branch
201
202
# TODO: jam 20060112 should cat-revision always output utf-8?
203
if revision_id is not None:
204
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
205
elif revision is not None:
206
for rev in revision:
207
if rev is None:
208
raise BzrCommandError('You cannot specify a NULL revision.')
209
revno, rev_id = rev.in_history(b)
210
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
211
212
213
class cmd_revno(Command):
214
"""Show current revision number.
215
216
This is equal to the number of revisions on this branch.
217
"""
218
219
takes_args = ['location?']
220
221
@display_command
222
def run(self, location=u'.'):
223
self.outf.write(str(Branch.open_containing(location)[0].revno()))
224
self.outf.write('\n')
225
226
227
class cmd_revision_info(Command):
228
"""Show revision number and revision id for a given revision identifier.
229
"""
230
hidden = True
231
takes_args = ['revision_info*']
232
takes_options = ['revision']
233
234
@display_command
235
def run(self, revision=None, revision_info_list=[]):
236
237
revs = []
238
if revision is not None:
239
revs.extend(revision)
240
if revision_info_list is not None:
241
for rev in revision_info_list:
242
revs.append(RevisionSpec.from_string(rev))
243
if len(revs) == 0:
244
raise BzrCommandError('You must supply a revision identifier')
245
246
b = WorkingTree.open_containing(u'.')[0].branch
247
248
for rev in revs:
249
revinfo = rev.in_history(b)
250
if revinfo.revno is None:
251
print ' %s' % revinfo.rev_id
252
else:
253
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
254
255
256
class cmd_add(Command):
257
"""Add specified files or directories.
258
259
In non-recursive mode, all the named items are added, regardless
260
of whether they were previously ignored. A warning is given if
261
any of the named files are already versioned.
262
263
In recursive mode (the default), files are treated the same way
264
but the behaviour for directories is different. Directories that
265
are already versioned do not give a warning. All directories,
266
whether already versioned or not, are searched for files or
267
subdirectories that are neither versioned or ignored, and these
268
are added. This search proceeds recursively into versioned
269
directories. If no names are given '.' is assumed.
270
271
Therefore simply saying 'bzr add' will version all files that
272
are currently unknown.
273
274
Adding a file whose parent directory is not versioned will
275
implicitly add the parent, and so on up to the root. This means
276
you should never need to explicitly add a directory, they'll just
277
get added when you add a file in the directory.
278
279
--dry-run will show which files would be added, but not actually
280
add them.
281
282
--file-ids-from will try to use the file ids from the supplied path.
283
It looks up ids trying to find a matching parent directory with the
284
same filename, and then by pure path.
285
"""
286
takes_args = ['file*']
287
takes_options = ['no-recurse', 'dry-run', 'verbose',
288
Option('file-ids-from', type=unicode,
289
help='Lookup file ids from here')]
290
encoding_type = 'replace'
291
292
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
293
file_ids_from=None):
294
import bzrlib.add
295
296
if file_ids_from is not None:
297
try:
298
base_tree, base_path = WorkingTree.open_containing(
299
file_ids_from)
300
except errors.NoWorkingTree:
301
base_branch, base_path = branch.Branch.open_containing(
302
file_ids_from)
303
base_tree = base_branch.basis_tree()
304
305
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
306
to_file=self.outf, should_print=(not is_quiet()))
307
else:
308
action = bzrlib.add.AddAction(to_file=self.outf,
309
should_print=(not is_quiet()))
310
311
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
312
action=action, save=not dry_run)
313
if len(ignored) > 0:
314
if verbose:
315
for glob in sorted(ignored.keys()):
316
for path in ignored[glob]:
317
self.outf.write("ignored %s matching \"%s\"\n"
318
% (path, glob))
319
else:
320
match_len = 0
321
for glob, paths in ignored.items():
322
match_len += len(paths)
323
self.outf.write("ignored %d file(s).\n" % match_len)
324
self.outf.write("If you wish to add some of these files,"
325
" please add them by name.\n")
326
327
328
class cmd_mkdir(Command):
329
"""Create a new versioned directory.
330
331
This is equivalent to creating the directory and then adding it.
332
"""
333
334
takes_args = ['dir+']
335
encoding_type = 'replace'
336
337
def run(self, dir_list):
338
for d in dir_list:
339
os.mkdir(d)
340
wt, dd = WorkingTree.open_containing(d)
341
wt.add([dd])
342
self.outf.write('added %s\n' % d)
343
344
345
class cmd_relpath(Command):
346
"""Show path of a file relative to root"""
347
348
takes_args = ['filename']
349
hidden = True
350
351
@display_command
352
def run(self, filename):
353
# TODO: jam 20050106 Can relpath return a munged path if
354
# sys.stdout encoding cannot represent it?
355
tree, relpath = WorkingTree.open_containing(filename)
356
self.outf.write(relpath)
357
self.outf.write('\n')
358
359
360
class cmd_inventory(Command):
361
"""Show inventory of the current working copy or a revision.
362
363
It is possible to limit the output to a particular entry
364
type using the --kind option. For example; --kind file.
365
"""
366
367
takes_options = ['revision', 'show-ids', 'kind']
368
369
@display_command
370
def run(self, revision=None, show_ids=False, kind=None):
371
if kind and kind not in ['file', 'directory', 'symlink']:
372
raise BzrCommandError('invalid kind specified')
373
tree = WorkingTree.open_containing(u'.')[0]
374
if revision is None:
375
inv = tree.read_working_inventory()
376
else:
377
if len(revision) > 1:
378
raise BzrCommandError('bzr inventory --revision takes'
379
' exactly one revision identifier')
380
inv = tree.branch.repository.get_revision_inventory(
381
revision[0].in_history(tree.branch).rev_id)
382
383
for path, entry in inv.entries():
384
if kind and kind != entry.kind:
385
continue
386
if show_ids:
387
self.outf.write('%-50s %s\n' % (path, entry.file_id))
388
else:
389
self.outf.write(path)
390
self.outf.write('\n')
391
392
393
class cmd_mv(Command):
394
"""Move or rename a file.
395
396
usage:
397
bzr mv OLDNAME NEWNAME
398
bzr mv SOURCE... DESTINATION
399
400
If the last argument is a versioned directory, all the other names
401
are moved into it. Otherwise, there must be exactly two arguments
402
and the file is changed to a new name, which must not already exist.
403
404
Files cannot be moved between branches.
405
"""
406
407
takes_args = ['names*']
408
aliases = ['move', 'rename']
409
encoding_type = 'replace'
410
411
def run(self, names_list):
412
if names_list is None:
413
names_list = []
414
415
if len(names_list) < 2:
416
raise BzrCommandError("missing file argument")
417
tree, rel_names = tree_files(names_list)
418
419
if os.path.isdir(names_list[-1]):
420
# move into existing directory
421
for pair in tree.move(rel_names[:-1], rel_names[-1]):
422
self.outf.write("%s => %s\n" % pair)
423
else:
424
if len(names_list) != 2:
425
raise BzrCommandError('to mv multiple files the destination '
426
'must be a versioned directory')
427
tree.rename_one(rel_names[0], rel_names[1])
428
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
429
430
431
class cmd_pull(Command):
432
"""Turn this branch into a mirror of another branch.
433
434
This command only works on branches that have not diverged. Branches are
435
considered diverged if the destination branch's most recent commit is one
436
that has not been merged (directly or indirectly) into the parent.
437
438
If branches have diverged, you can use 'bzr merge' to integrate the changes
439
from one into the other. Once one branch has merged, the other should
440
be able to pull it again.
441
442
If you want to forget your local changes and just update your branch to
443
match the remote one, use pull --overwrite.
444
445
If there is no default location set, the first pull will set it. After
446
that, you can omit the location to use the default. To change the
447
default, use --remember. The value will only be saved if the remote
448
location can be accessed.
449
"""
450
451
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
452
takes_args = ['location?']
453
encoding_type = 'replace'
454
455
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
456
# FIXME: too much stuff is in the command class
457
try:
458
tree_to = WorkingTree.open_containing(u'.')[0]
459
branch_to = tree_to.branch
460
except NoWorkingTree:
461
tree_to = None
462
branch_to = Branch.open_containing(u'.')[0]
463
464
reader = None
465
if location is not None:
466
try:
467
reader = bundle.read_bundle_from_url(location)
468
except NotABundle:
469
pass # Continue on considering this url a Branch
470
471
stored_loc = branch_to.get_parent()
472
if location is None:
473
if stored_loc is None:
474
raise BzrCommandError("No pull location known or specified.")
475
else:
476
display_url = urlutils.unescape_for_display(stored_loc,
477
self.outf.encoding)
478
self.outf.write("Using saved location: %s\n" % display_url)
479
location = stored_loc
480
481
482
if reader is not None:
483
install_bundle(branch_to.repository, reader)
484
branch_from = branch_to
485
else:
486
branch_from = Branch.open(location)
487
488
if branch_to.get_parent() is None or remember:
489
branch_to.set_parent(branch_from.base)
490
491
rev_id = None
492
if revision is None:
493
if reader is not None:
494
rev_id = reader.target
495
elif len(revision) == 1:
496
rev_id = revision[0].in_history(branch_from).rev_id
497
else:
498
raise BzrCommandError('bzr pull --revision takes one value.')
499
500
old_rh = branch_to.revision_history()
501
if tree_to is not None:
502
count = tree_to.pull(branch_from, overwrite, rev_id)
503
else:
504
count = branch_to.pull(branch_from, overwrite, rev_id)
505
note('%d revision(s) pulled.' % (count,))
506
507
if verbose:
508
new_rh = branch_to.revision_history()
509
if old_rh != new_rh:
510
# Something changed
511
from bzrlib.log import show_changed_revisions
512
show_changed_revisions(branch_to, old_rh, new_rh,
513
to_file=self.outf)
514
515
516
class cmd_push(Command):
517
"""Update a mirror of this branch.
518
519
The target branch will not have its working tree populated because this
520
is both expensive, and is not supported on remote file systems.
521
522
Some smart servers or protocols *may* put the working tree in place in
523
the future.
524
525
This command only works on branches that have not diverged. Branches are
526
considered diverged if the destination branch's most recent commit is one
527
that has not been merged (directly or indirectly) by the source branch.
528
529
If branches have diverged, you can use 'bzr push --overwrite' to replace
530
the other branch completely, discarding its unmerged changes.
531
532
If you want to ensure you have the different changes in the other branch,
533
do a merge (see bzr help merge) from the other branch, and commit that.
534
After that you will be able to do a push without '--overwrite'.
535
536
If there is no default push location set, the first push will set it.
537
After that, you can omit the location to use the default. To change the
538
default, use --remember. The value will only be saved if the remote
539
location can be accessed.
540
"""
541
542
takes_options = ['remember', 'overwrite', 'verbose',
543
Option('create-prefix',
544
help='Create the path leading up to the branch '
545
'if it does not already exist')]
546
takes_args = ['location?']
547
encoding_type = 'replace'
548
549
def run(self, location=None, remember=False, overwrite=False,
550
create_prefix=False, verbose=False):
551
# FIXME: Way too big! Put this into a function called from the
552
# command.
553
554
br_from = Branch.open_containing('.')[0]
555
stored_loc = br_from.get_push_location()
556
if location is None:
557
if stored_loc is None:
558
raise BzrCommandError("No push location known or specified.")
559
else:
560
display_url = urlutils.unescape_for_display(stored_loc,
561
self.outf.encoding)
562
self.outf.write("Using saved location: %s\n" % display_url)
563
location = stored_loc
564
565
to_transport = transport.get_transport(location)
566
location_url = to_transport.base
567
568
old_rh = []
569
try:
570
dir_to = bzrdir.BzrDir.open(location_url)
571
br_to = dir_to.open_branch()
572
except NotBranchError:
573
# create a branch.
574
to_transport = to_transport.clone('..')
575
if not create_prefix:
576
try:
577
relurl = to_transport.relpath(location_url)
578
mutter('creating directory %s => %s', location_url, relurl)
579
to_transport.mkdir(relurl)
580
except NoSuchFile:
581
raise BzrCommandError("Parent directory of %s "
582
"does not exist." % location)
583
else:
584
current = to_transport.base
585
needed = [(to_transport, to_transport.relpath(location_url))]
586
while needed:
587
try:
588
to_transport, relpath = needed[-1]
589
to_transport.mkdir(relpath)
590
needed.pop()
591
except NoSuchFile:
592
new_transport = to_transport.clone('..')
593
needed.append((new_transport,
594
new_transport.relpath(to_transport.base)))
595
if new_transport.base == to_transport.base:
596
raise BzrCommandError("Could not create "
597
"path prefix.")
598
dir_to = br_from.bzrdir.clone(location_url,
599
revision_id=br_from.last_revision())
600
br_to = dir_to.open_branch()
601
count = len(br_to.revision_history())
602
# We successfully created the target, remember it
603
if br_from.get_push_location() is None or remember:
604
br_from.set_push_location(br_to.base)
605
else:
606
# We were able to connect to the remote location, so remember it
607
# we don't need to successfully push because of possible divergence.
608
if br_from.get_push_location() is None or remember:
609
br_from.set_push_location(br_to.base)
610
old_rh = br_to.revision_history()
611
try:
612
try:
613
tree_to = dir_to.open_workingtree()
614
except errors.NotLocalUrl:
615
warning('This transport does not update the working '
616
'tree of: %s' % (br_to.base,))
617
count = br_to.pull(br_from, overwrite)
618
except NoWorkingTree:
619
count = br_to.pull(br_from, overwrite)
620
else:
621
count = tree_to.pull(br_from, overwrite)
622
except DivergedBranches:
623
raise BzrCommandError("These branches have diverged."
624
" Try a merge then push with overwrite.")
625
note('%d revision(s) pushed.' % (count,))
626
627
if verbose:
628
new_rh = br_to.revision_history()
629
if old_rh != new_rh:
630
# Something changed
631
from bzrlib.log import show_changed_revisions
632
show_changed_revisions(br_to, old_rh, new_rh,
633
to_file=self.outf)
634
635
636
class cmd_branch(Command):
637
"""Create a new copy of a branch.
638
639
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
640
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
641
642
To retrieve the branch as of a particular revision, supply the --revision
643
parameter, as in "branch foo/bar -r 5".
644
645
--basis is to speed up branching from remote branches. When specified, it
646
copies all the file-contents, inventory and revision data from the basis
647
branch before copying anything from the remote branch.
648
"""
649
takes_args = ['from_location', 'to_location?']
650
takes_options = ['revision', 'basis']
651
aliases = ['get', 'clone']
652
653
def run(self, from_location, to_location=None, revision=None, basis=None):
654
if revision is None:
655
revision = [None]
656
elif len(revision) > 1:
657
raise BzrCommandError(
658
'bzr branch --revision takes exactly 1 revision value')
659
try:
660
br_from = Branch.open(from_location)
661
except OSError, e:
662
if e.errno == errno.ENOENT:
663
raise BzrCommandError('Source location "%s" does not'
664
' exist.' % to_location)
665
else:
666
raise
667
br_from.lock_read()
668
try:
669
if basis is not None:
670
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
671
else:
672
basis_dir = None
673
if len(revision) == 1 and revision[0] is not None:
674
revision_id = revision[0].in_history(br_from)[1]
675
else:
676
# FIXME - wt.last_revision, fallback to branch, fall back to
677
# None or perhaps NULL_REVISION to mean copy nothing
678
# RBC 20060209
679
revision_id = br_from.last_revision()
680
if to_location is None:
681
to_location = os.path.basename(from_location.rstrip("/\\"))
682
name = None
683
else:
684
name = os.path.basename(to_location) + '\n'
685
686
to_transport = transport.get_transport(to_location)
687
try:
688
to_transport.mkdir('.')
689
except errors.FileExists:
690
raise BzrCommandError('Target directory "%s" already'
691
' exists.' % to_location)
692
except errors.NoSuchFile:
693
raise BzrCommandError('Parent of "%s" does not exist.' %
694
to_location)
695
try:
696
# preserve whatever source format we have.
697
dir = br_from.bzrdir.sprout(to_transport.base,
698
revision_id, basis_dir)
699
branch = dir.open_branch()
700
except errors.NoSuchRevision:
701
to_transport.delete_tree('.')
702
msg = "The branch %s has no revision %s." % (from_location, revision[0])
703
raise BzrCommandError(msg)
704
except errors.UnlistableBranch:
705
osutils.rmtree(to_location)
706
msg = "The branch %s cannot be used as a --basis" % (basis,)
707
raise BzrCommandError(msg)
708
if name:
709
branch.control_files.put_utf8('branch-name', name)
710
note('Branched %d revision(s).' % branch.revno())
711
finally:
712
br_from.unlock()
713
714
715
class cmd_checkout(Command):
716
"""Create a new checkout of an existing branch.
717
718
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
719
the branch found in '.'. This is useful if you have removed the working tree
720
or if it was never created - i.e. if you pushed the branch to its current
721
location using SFTP.
722
723
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
724
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
725
726
To retrieve the branch as of a particular revision, supply the --revision
727
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
728
out of date [so you cannot commit] but it may be useful (i.e. to examine old
729
code.)
730
731
--basis is to speed up checking out from remote branches. When specified, it
732
uses the inventory and file contents from the basis branch in preference to the
733
branch being checked out.
734
"""
735
takes_args = ['branch_location?', 'to_location?']
736
takes_options = ['revision', # , 'basis']
737
Option('lightweight',
738
help="perform a lightweight checkout. Lightweight "
739
"checkouts depend on access to the branch for "
740
"every operation. Normal checkouts can perform "
741
"common operations like diff and status without "
742
"such access, and also support local commits."
743
),
744
]
745
aliases = ['co']
746
747
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
748
lightweight=False):
749
if revision is None:
750
revision = [None]
751
elif len(revision) > 1:
752
raise BzrCommandError(
753
'bzr checkout --revision takes exactly 1 revision value')
754
if branch_location is None:
755
branch_location = osutils.getcwd()
756
to_location = branch_location
757
source = Branch.open(branch_location)
758
if len(revision) == 1 and revision[0] is not None:
759
revision_id = revision[0].in_history(source)[1]
760
else:
761
revision_id = None
762
if to_location is None:
763
to_location = os.path.basename(branch_location.rstrip("/\\"))
764
# if the source and to_location are the same,
765
# and there is no working tree,
766
# then reconstitute a branch
767
if (osutils.abspath(to_location) ==
768
osutils.abspath(branch_location)):
769
try:
770
source.bzrdir.open_workingtree()
771
except errors.NoWorkingTree:
772
source.bzrdir.create_workingtree()
773
return
774
try:
775
os.mkdir(to_location)
776
except OSError, e:
777
if e.errno == errno.EEXIST:
778
raise BzrCommandError('Target directory "%s" already'
779
' exists.' % to_location)
780
if e.errno == errno.ENOENT:
781
raise BzrCommandError('Parent of "%s" does not exist.' %
782
to_location)
783
else:
784
raise
785
old_format = bzrdir.BzrDirFormat.get_default_format()
786
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
787
try:
788
source.create_checkout(to_location, revision_id, lightweight)
789
finally:
790
bzrdir.BzrDirFormat.set_default_format(old_format)
791
792
793
class cmd_renames(Command):
794
"""Show list of renamed files.
795
"""
796
# TODO: Option to show renames between two historical versions.
797
798
# TODO: Only show renames under dir, rather than in the whole branch.
799
takes_args = ['dir?']
800
801
@display_command
802
def run(self, dir=u'.'):
803
from bzrlib.tree import find_renames
804
tree = WorkingTree.open_containing(dir)[0]
805
old_inv = tree.basis_tree().inventory
806
new_inv = tree.read_working_inventory()
807
renames = list(find_renames(old_inv, new_inv))
808
renames.sort()
809
for old_name, new_name in renames:
810
self.outf.write("%s => %s\n" % (old_name, new_name))
811
812
813
class cmd_update(Command):
814
"""Update a tree to have the latest code committed to its branch.
815
816
This will perform a merge into the working tree, and may generate
817
conflicts. If you have any local changes, you will still
818
need to commit them after the update for the update to be complete.
819
820
If you want to discard your local changes, you can just do a
821
'bzr revert' instead of 'bzr commit' after the update.
822
"""
823
takes_args = ['dir?']
824
aliases = ['up']
825
826
def run(self, dir='.'):
827
tree = WorkingTree.open_containing(dir)[0]
828
tree.lock_write()
829
try:
830
existing_pending_merges = tree.get_parent_ids()[1:]
831
last_rev = tree.last_revision()
832
if last_rev == tree.branch.last_revision():
833
# may be up to date, check master too.
834
master = tree.branch.get_master_branch()
835
if master is None or last_rev == master.last_revision():
836
revno = tree.branch.revision_id_to_revno(last_rev)
837
note("Tree is up to date at revision %d." % (revno,))
838
return 0
839
conflicts = tree.update()
840
revno = tree.branch.revision_id_to_revno(tree.last_revision())
841
note('Updated to revision %d.' % (revno,))
842
if tree.get_parent_ids()[1:] != existing_pending_merges:
843
note('Your local commits will now show as pending merges with '
844
"'bzr status', and can be committed with 'bzr commit'.")
845
if conflicts != 0:
846
return 1
847
else:
848
return 0
849
finally:
850
tree.unlock()
851
852
853
class cmd_info(Command):
854
"""Show information about a working tree, branch or repository.
855
856
This command will show all known locations and formats associated to the
857
tree, branch or repository. Statistical information is included with
858
each report.
859
860
Branches and working trees will also report any missing revisions.
861
"""
862
takes_args = ['location?']
863
takes_options = ['verbose']
864
865
@display_command
866
def run(self, location=None, verbose=False):
867
from bzrlib.info import show_bzrdir_info
868
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
869
verbose=verbose)
870
871
872
class cmd_remove(Command):
873
"""Make a file unversioned.
874
875
This makes bzr stop tracking changes to a versioned file. It does
876
not delete the working copy.
877
878
You can specify one or more files, and/or --new. If you specify --new,
879
only 'added' files will be removed. If you specify both, then new files
880
in the specified directories will be removed. If the directories are
881
also new, they will also be removed.
882
"""
883
takes_args = ['file*']
884
takes_options = ['verbose', Option('new', help='remove newly-added files')]
885
aliases = ['rm']
886
encoding_type = 'replace'
887
888
def run(self, file_list, verbose=False, new=False):
889
tree, file_list = tree_files(file_list)
890
if new is False:
891
if file_list is None:
892
raise BzrCommandError('Specify one or more files to remove, or'
893
' use --new.')
894
else:
895
added = tree.changes_from(tree.basis_tree(),
896
specific_files=file_list).added
897
file_list = sorted([f[0] for f in added], reverse=True)
898
if len(file_list) == 0:
899
raise BzrCommandError('No matching files.')
900
tree.remove(file_list, verbose=verbose, to_file=self.outf)
901
902
903
class cmd_file_id(Command):
904
"""Print file_id of a particular file or directory.
905
906
The file_id is assigned when the file is first added and remains the
907
same through all revisions where the file exists, even when it is
908
moved or renamed.
909
"""
910
911
hidden = True
912
takes_args = ['filename']
913
914
@display_command
915
def run(self, filename):
916
tree, relpath = WorkingTree.open_containing(filename)
917
i = tree.inventory.path2id(relpath)
918
if i is None:
919
raise BzrError("%r is not a versioned file" % filename)
920
else:
921
self.outf.write(i + '\n')
922
923
924
class cmd_file_path(Command):
925
"""Print path of file_ids to a file or directory.
926
927
This prints one line for each directory down to the target,
928
starting at the branch root.
929
"""
930
931
hidden = True
932
takes_args = ['filename']
933
934
@display_command
935
def run(self, filename):
936
tree, relpath = WorkingTree.open_containing(filename)
937
inv = tree.inventory
938
fid = inv.path2id(relpath)
939
if fid is None:
940
raise BzrError("%r is not a versioned file" % filename)
941
for fip in inv.get_idpath(fid):
942
self.outf.write(fip + '\n')
943
944
945
class cmd_reconcile(Command):
946
"""Reconcile bzr metadata in a branch.
947
948
This can correct data mismatches that may have been caused by
949
previous ghost operations or bzr upgrades. You should only
950
need to run this command if 'bzr check' or a bzr developer
951
advises you to run it.
952
953
If a second branch is provided, cross-branch reconciliation is
954
also attempted, which will check that data like the tree root
955
id which was not present in very early bzr versions is represented
956
correctly in both branches.
957
958
At the same time it is run it may recompress data resulting in
959
a potential saving in disk space or performance gain.
960
961
The branch *MUST* be on a listable system such as local disk or sftp.
962
"""
963
takes_args = ['branch?']
964
965
def run(self, branch="."):
966
from bzrlib.reconcile import reconcile
967
dir = bzrdir.BzrDir.open(branch)
968
reconcile(dir)
969
970
971
class cmd_revision_history(Command):
972
"""Display the list of revision ids on a branch."""
973
takes_args = ['location?']
974
975
hidden = True
976
977
@display_command
978
def run(self, location="."):
979
branch = Branch.open_containing(location)[0]
980
for revid in branch.revision_history():
981
self.outf.write(revid)
982
self.outf.write('\n')
983
984
985
class cmd_ancestry(Command):
986
"""List all revisions merged into this branch."""
987
takes_args = ['location?']
988
989
hidden = True
990
991
@display_command
992
def run(self, location="."):
993
try:
994
wt = WorkingTree.open_containing(location)[0]
995
except errors.NoWorkingTree:
996
b = Branch.open(location)
997
last_revision = b.last_revision()
998
else:
999
b = wt.branch
1000
last_revision = wt.last_revision()
1001
1002
revision_ids = b.repository.get_ancestry(last_revision)
1003
assert revision_ids[0] is None
1004
revision_ids.pop(0)
1005
for revision_id in revision_ids:
1006
self.outf.write(revision_id + '\n')
1007
1008
1009
class cmd_init(Command):
1010
"""Make a directory into a versioned branch.
1011
1012
Use this to create an empty branch, or before importing an
1013
existing project.
1014
1015
If there is a repository in a parent directory of the location, then
1016
the history of the branch will be stored in the repository. Otherwise
1017
init creates a standalone branch which carries its own history in
1018
.bzr.
1019
1020
If there is already a branch at the location but it has no working tree,
1021
the tree can be populated with 'bzr checkout'.
1022
1023
Recipe for importing a tree of files:
1024
cd ~/project
1025
bzr init
1026
bzr add .
1027
bzr status
1028
bzr commit -m 'imported project'
1029
"""
1030
takes_args = ['location?']
1031
takes_options = [
1032
Option('format',
1033
help='Specify a format for this branch. Current'
1034
' formats are: default, knit, metaweave and'
1035
' weave. Default is knit; metaweave and'
1036
' weave are deprecated',
1037
type=get_format_type),
1038
]
1039
def run(self, location=None, format=None):
1040
if format is None:
1041
format = get_format_type('default')
1042
if location is None:
1043
location = u'.'
1044
1045
to_transport = transport.get_transport(location)
1046
1047
# The path has to exist to initialize a
1048
# branch inside of it.
1049
# Just using os.mkdir, since I don't
1050
# believe that we want to create a bunch of
1051
# locations if the user supplies an extended path
1052
# TODO: create-prefix
1053
try:
1054
to_transport.mkdir('.')
1055
except errors.FileExists:
1056
pass
1057
1058
try:
1059
existing_bzrdir = bzrdir.BzrDir.open(location)
1060
except NotBranchError:
1061
# really a NotBzrDir error...
1062
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1063
else:
1064
if existing_bzrdir.has_branch():
1065
if (isinstance(to_transport, LocalTransport)
1066
and not existing_bzrdir.has_workingtree()):
1067
raise errors.BranchExistsWithoutWorkingTree(location)
1068
raise errors.AlreadyBranchError(location)
1069
else:
1070
existing_bzrdir.create_branch()
1071
existing_bzrdir.create_workingtree()
1072
1073
1074
class cmd_init_repository(Command):
1075
"""Create a shared repository to hold branches.
1076
1077
New branches created under the repository directory will store their revisions
1078
in the repository, not in the branch directory, if the branch format supports
1079
shared storage.
1080
1081
example:
1082
bzr init-repo repo
1083
bzr init repo/trunk
1084
bzr checkout --lightweight repo/trunk trunk-checkout
1085
cd trunk-checkout
1086
(add files here)
1087
"""
1088
takes_args = ["location"]
1089
takes_options = [Option('format',
1090
help='Specify a format for this repository.'
1091
' Current formats are: default, knit,'
1092
' metaweave and weave. Default is knit;'
1093
' metaweave and weave are deprecated',
1094
type=get_format_type),
1095
Option('trees',
1096
help='Allows branches in repository to have'
1097
' a working tree')]
1098
aliases = ["init-repo"]
1099
def run(self, location, format=None, trees=False):
1100
if format is None:
1101
format = get_format_type('default')
1102
1103
if location is None:
1104
location = '.'
1105
1106
to_transport = transport.get_transport(location)
1107
try:
1108
to_transport.mkdir('.')
1109
except errors.FileExists:
1110
pass
1111
1112
newdir = format.initialize_on_transport(to_transport)
1113
repo = newdir.create_repository(shared=True)
1114
repo.set_make_working_trees(trees)
1115
1116
1117
class cmd_diff(Command):
1118
"""Show differences in the working tree or between revisions.
1119
1120
If files are listed, only the changes in those files are listed.
1121
Otherwise, all changes for the tree are listed.
1122
1123
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1124
produces patches suitable for "patch -p1".
1125
1126
examples:
1127
bzr diff
1128
Shows the difference in the working tree versus the last commit
1129
bzr diff -r1
1130
Difference between the working tree and revision 1
1131
bzr diff -r1..2
1132
Difference between revision 2 and revision 1
1133
bzr diff --diff-prefix old/:new/
1134
Same as 'bzr diff' but prefix paths with old/ and new/
1135
bzr diff bzr.mine bzr.dev
1136
Show the differences between the two working trees
1137
bzr diff foo.c
1138
Show just the differences for 'foo.c'
1139
"""
1140
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1141
# or a graphical diff.
1142
1143
# TODO: Python difflib is not exactly the same as unidiff; should
1144
# either fix it up or prefer to use an external diff.
1145
1146
# TODO: Selected-file diff is inefficient and doesn't show you
1147
# deleted files.
1148
1149
# TODO: This probably handles non-Unix newlines poorly.
1150
1151
takes_args = ['file*']
1152
takes_options = ['revision', 'diff-options', 'prefix']
1153
aliases = ['di', 'dif']
1154
encoding_type = 'exact'
1155
1156
@display_command
1157
def run(self, revision=None, file_list=None, diff_options=None,
1158
prefix=None):
1159
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1160
1161
if (prefix is None) or (prefix == '0'):
1162
# diff -p0 format
1163
old_label = ''
1164
new_label = ''
1165
elif prefix == '1':
1166
old_label = 'old/'
1167
new_label = 'new/'
1168
else:
1169
if not ':' in prefix:
1170
raise BzrError("--diff-prefix expects two values separated by a colon")
1171
old_label, new_label = prefix.split(":")
1172
1173
try:
1174
tree1, file_list = internal_tree_files(file_list)
1175
tree2 = None
1176
b = None
1177
b2 = None
1178
except FileInWrongBranch:
1179
if len(file_list) != 2:
1180
raise BzrCommandError("Files are in different branches")
1181
1182
tree1, file1 = WorkingTree.open_containing(file_list[0])
1183
tree2, file2 = WorkingTree.open_containing(file_list[1])
1184
if file1 != "" or file2 != "":
1185
# FIXME diff those two files. rbc 20051123
1186
raise BzrCommandError("Files are in different branches")
1187
file_list = None
1188
except NotBranchError:
1189
if (revision is not None and len(revision) == 2
1190
and not revision[0].needs_branch()
1191
and not revision[1].needs_branch()):
1192
# If both revision specs include a branch, we can
1193
# diff them without needing a local working tree
1194
tree1, tree2 = None, None
1195
else:
1196
raise
1197
if revision is not None:
1198
if tree2 is not None:
1199
raise BzrCommandError("Can't specify -r with two branches")
1200
if (len(revision) == 1) or (revision[1].spec is None):
1201
return diff_cmd_helper(tree1, file_list, diff_options,
1202
revision[0],
1203
old_label=old_label, new_label=new_label)
1204
elif len(revision) == 2:
1205
return diff_cmd_helper(tree1, file_list, diff_options,
1206
revision[0], revision[1],
1207
old_label=old_label, new_label=new_label)
1208
else:
1209
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1210
else:
1211
if tree2 is not None:
1212
return show_diff_trees(tree1, tree2, sys.stdout,
1213
specific_files=file_list,
1214
external_diff_options=diff_options,
1215
old_label=old_label, new_label=new_label)
1216
else:
1217
return diff_cmd_helper(tree1, file_list, diff_options,
1218
old_label=old_label, new_label=new_label)
1219
1220
1221
class cmd_deleted(Command):
1222
"""List files deleted in the working tree.
1223
"""
1224
# TODO: Show files deleted since a previous revision, or
1225
# between two revisions.
1226
# TODO: Much more efficient way to do this: read in new
1227
# directories with readdir, rather than stating each one. Same
1228
# level of effort but possibly much less IO. (Or possibly not,
1229
# if the directories are very large...)
1230
takes_options = ['show-ids']
1231
1232
@display_command
1233
def run(self, show_ids=False):
1234
tree = WorkingTree.open_containing(u'.')[0]
1235
old = tree.basis_tree()
1236
for path, ie in old.inventory.iter_entries():
1237
if not tree.has_id(ie.file_id):
1238
self.outf.write(path)
1239
if show_ids:
1240
self.outf.write(' ')
1241
self.outf.write(ie.file_id)
1242
self.outf.write('\n')
1243
1244
1245
class cmd_modified(Command):
1246
"""List files modified in working tree."""
1247
hidden = True
1248
@display_command
1249
def run(self):
1250
tree = WorkingTree.open_containing(u'.')[0]
1251
td = tree.changes_from(tree.basis_tree())
1252
for path, id, kind, text_modified, meta_modified in td.modified:
1253
self.outf.write(path + '\n')
1254
1255
1256
class cmd_added(Command):
1257
"""List files added in working tree."""
1258
hidden = True
1259
@display_command
1260
def run(self):
1261
wt = WorkingTree.open_containing(u'.')[0]
1262
basis_inv = wt.basis_tree().inventory
1263
inv = wt.inventory
1264
for file_id in inv:
1265
if file_id in basis_inv:
1266
continue
1267
if inv.is_root(file_id) and len(basis_inv) == 0:
1268
continue
1269
path = inv.id2path(file_id)
1270
if not os.access(osutils.abspath(path), os.F_OK):
1271
continue
1272
self.outf.write(path + '\n')
1273
1274
1275
class cmd_root(Command):
1276
"""Show the tree root directory.
1277
1278
The root is the nearest enclosing directory with a .bzr control
1279
directory."""
1280
takes_args = ['filename?']
1281
@display_command
1282
def run(self, filename=None):
1283
"""Print the branch root."""
1284
tree = WorkingTree.open_containing(filename)[0]
1285
self.outf.write(tree.basedir + '\n')
1286
1287
1288
class cmd_log(Command):
1289
"""Show log of a branch, file, or directory.
1290
1291
By default show the log of the branch containing the working directory.
1292
1293
To request a range of logs, you can use the command -r begin..end
1294
-r revision requests a specific revision, -r ..end or -r begin.. are
1295
also valid.
1296
1297
examples:
1298
bzr log
1299
bzr log foo.c
1300
bzr log -r -10.. http://server/branch
1301
"""
1302
1303
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1304
1305
takes_args = ['location?']
1306
takes_options = [Option('forward',
1307
help='show from oldest to newest'),
1308
'timezone',
1309
Option('verbose',
1310
help='show files changed in each revision'),
1311
'show-ids', 'revision',
1312
'log-format',
1313
'line', 'long',
1314
Option('message',
1315
help='show revisions whose message matches this regexp',
1316
type=str),
1317
'short',
1318
]
1319
encoding_type = 'replace'
1320
1321
@display_command
1322
def run(self, location=None, timezone='original',
1323
verbose=False,
1324
show_ids=False,
1325
forward=False,
1326
revision=None,
1327
log_format=None,
1328
message=None,
1329
long=False,
1330
short=False,
1331
line=False):
1332
from bzrlib.log import log_formatter, show_log
1333
assert message is None or isinstance(message, basestring), \
1334
"invalid message argument %r" % message
1335
direction = (forward and 'forward') or 'reverse'
1336
1337
# log everything
1338
file_id = None
1339
if location:
1340
# find the file id to log:
1341
1342
dir, fp = bzrdir.BzrDir.open_containing(location)
1343
b = dir.open_branch()
1344
if fp != '':
1345
try:
1346
# might be a tree:
1347
inv = dir.open_workingtree().inventory
1348
except (errors.NotBranchError, errors.NotLocalUrl):
1349
# either no tree, or is remote.
1350
inv = b.basis_tree().inventory
1351
file_id = inv.path2id(fp)
1352
else:
1353
# local dir only
1354
# FIXME ? log the current subdir only RBC 20060203
1355
if revision is not None \
1356
and len(revision) > 0 and revision[0].get_branch():
1357
location = revision[0].get_branch()
1358
else:
1359
location = '.'
1360
dir, relpath = bzrdir.BzrDir.open_containing(location)
1361
b = dir.open_branch()
1362
1363
if revision is None:
1364
rev1 = None
1365
rev2 = None
1366
elif len(revision) == 1:
1367
rev1 = rev2 = revision[0].in_history(b).revno
1368
elif len(revision) == 2:
1369
if revision[1].get_branch() != revision[0].get_branch():
1370
# b is taken from revision[0].get_branch(), and
1371
# show_log will use its revision_history. Having
1372
# different branches will lead to weird behaviors.
1373
raise BzrCommandError(
1374
"Log doesn't accept two revisions in different branches.")
1375
if revision[0].spec is None:
1376
# missing begin-range means first revision
1377
rev1 = 1
1378
else:
1379
rev1 = revision[0].in_history(b).revno
1380
1381
if revision[1].spec is None:
1382
# missing end-range means last known revision
1383
rev2 = b.revno()
1384
else:
1385
rev2 = revision[1].in_history(b).revno
1386
else:
1387
raise BzrCommandError('bzr log --revision takes one or two values.')
1388
1389
# By this point, the revision numbers are converted to the +ve
1390
# form if they were supplied in the -ve form, so we can do
1391
# this comparison in relative safety
1392
if rev1 > rev2:
1393
(rev2, rev1) = (rev1, rev2)
1394
1395
if (log_format is None):
1396
default = b.get_config().log_format()
1397
log_format = get_log_format(long=long, short=short, line=line,
1398
default=default)
1399
lf = log_formatter(log_format,
1400
show_ids=show_ids,
1401
to_file=self.outf,
1402
show_timezone=timezone)
1403
1404
show_log(b,
1405
lf,
1406
file_id,
1407
verbose=verbose,
1408
direction=direction,
1409
start_revision=rev1,
1410
end_revision=rev2,
1411
search=message)
1412
1413
1414
def get_log_format(long=False, short=False, line=False, default='long'):
1415
log_format = default
1416
if long:
1417
log_format = 'long'
1418
if short:
1419
log_format = 'short'
1420
if line:
1421
log_format = 'line'
1422
return log_format
1423
1424
1425
class cmd_touching_revisions(Command):
1426
"""Return revision-ids which affected a particular file.
1427
1428
A more user-friendly interface is "bzr log FILE".
1429
"""
1430
1431
hidden = True
1432
takes_args = ["filename"]
1433
1434
@display_command
1435
def run(self, filename):
1436
tree, relpath = WorkingTree.open_containing(filename)
1437
b = tree.branch
1438
inv = tree.read_working_inventory()
1439
file_id = inv.path2id(relpath)
1440
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1441
self.outf.write("%6d %s\n" % (revno, what))
1442
1443
1444
class cmd_ls(Command):
1445
"""List files in a tree.
1446
"""
1447
# TODO: Take a revision or remote path and list that tree instead.
1448
hidden = True
1449
takes_options = ['verbose', 'revision',
1450
Option('non-recursive',
1451
help='don\'t recurse into sub-directories'),
1452
Option('from-root',
1453
help='Print all paths from the root of the branch.'),
1454
Option('unknown', help='Print unknown files'),
1455
Option('versioned', help='Print versioned files'),
1456
Option('ignored', help='Print ignored files'),
1457
1458
Option('null', help='Null separate the files'),
1459
]
1460
@display_command
1461
def run(self, revision=None, verbose=False,
1462
non_recursive=False, from_root=False,
1463
unknown=False, versioned=False, ignored=False,
1464
null=False):
1465
1466
if verbose and null:
1467
raise BzrCommandError('Cannot set both --verbose and --null')
1468
all = not (unknown or versioned or ignored)
1469
1470
selection = {'I':ignored, '?':unknown, 'V':versioned}
1471
1472
tree, relpath = WorkingTree.open_containing(u'.')
1473
if from_root:
1474
relpath = u''
1475
elif relpath:
1476
relpath += '/'
1477
if revision is not None:
1478
tree = tree.branch.repository.revision_tree(
1479
revision[0].in_history(tree.branch).rev_id)
1480
1481
for fp, fc, kind, fid, entry in tree.list_files(include_root=False):
1482
if fp.startswith(relpath):
1483
fp = fp[len(relpath):]
1484
if non_recursive and '/' in fp:
1485
continue
1486
if not all and not selection[fc]:
1487
continue
1488
if verbose:
1489
kindch = entry.kind_character()
1490
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1491
elif null:
1492
self.outf.write(fp + '\0')
1493
self.outf.flush()
1494
else:
1495
self.outf.write(fp + '\n')
1496
1497
1498
class cmd_unknowns(Command):
1499
"""List unknown files."""
1500
@display_command
1501
def run(self):
1502
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1503
self.outf.write(osutils.quotefn(f) + '\n')
1504
1505
1506
class cmd_ignore(Command):
1507
"""Ignore a command or pattern.
1508
1509
To remove patterns from the ignore list, edit the .bzrignore file.
1510
1511
If the pattern contains a slash, it is compared to the whole path
1512
from the branch root. Otherwise, it is compared to only the last
1513
component of the path. To match a file only in the root directory,
1514
prepend './'.
1515
1516
Ignore patterns are case-insensitive on case-insensitive systems.
1517
1518
Note: wildcards must be quoted from the shell on Unix.
1519
1520
examples:
1521
bzr ignore ./Makefile
1522
bzr ignore '*.class'
1523
"""
1524
# TODO: Complain if the filename is absolute
1525
takes_args = ['name_pattern?']
1526
takes_options = [
1527
Option('old-default-rules',
1528
help='Out the ignore rules bzr < 0.9 always used.')
1529
]
1530
1531
def run(self, name_pattern=None, old_default_rules=None):
1532
from bzrlib.atomicfile import AtomicFile
1533
if old_default_rules is not None:
1534
# dump the rules and exit
1535
for pattern in ignores.OLD_DEFAULTS:
1536
print pattern
1537
return
1538
if name_pattern is None:
1539
raise BzrCommandError("ignore requires a NAME_PATTERN")
1540
tree, relpath = WorkingTree.open_containing(u'.')
1541
ifn = tree.abspath('.bzrignore')
1542
if os.path.exists(ifn):
1543
f = open(ifn, 'rt')
1544
try:
1545
igns = f.read().decode('utf-8')
1546
finally:
1547
f.close()
1548
else:
1549
igns = ''
1550
1551
# TODO: If the file already uses crlf-style termination, maybe
1552
# we should use that for the newly added lines?
1553
1554
if igns and igns[-1] != '\n':
1555
igns += '\n'
1556
igns += name_pattern + '\n'
1557
1558
f = AtomicFile(ifn, 'wt')
1559
try:
1560
f.write(igns.encode('utf-8'))
1561
f.commit()
1562
finally:
1563
f.close()
1564
1565
inv = tree.inventory
1566
if inv.path2id('.bzrignore'):
1567
mutter('.bzrignore is already versioned')
1568
else:
1569
mutter('need to make new .bzrignore file versioned')
1570
tree.add(['.bzrignore'])
1571
1572
1573
class cmd_ignored(Command):
1574
"""List ignored files and the patterns that matched them.
1575
1576
See also: bzr ignore"""
1577
@display_command
1578
def run(self):
1579
tree = WorkingTree.open_containing(u'.')[0]
1580
for path, file_class, kind, file_id, entry in tree.list_files():
1581
if file_class != 'I':
1582
continue
1583
## XXX: Slightly inefficient since this was already calculated
1584
pat = tree.is_ignored(path)
1585
print '%-50s %s' % (path, pat)
1586
1587
1588
class cmd_lookup_revision(Command):
1589
"""Lookup the revision-id from a revision-number
1590
1591
example:
1592
bzr lookup-revision 33
1593
"""
1594
hidden = True
1595
takes_args = ['revno']
1596
1597
@display_command
1598
def run(self, revno):
1599
try:
1600
revno = int(revno)
1601
except ValueError:
1602
raise BzrCommandError("not a valid revision-number: %r" % revno)
1603
1604
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1605
1606
1607
class cmd_export(Command):
1608
"""Export past revision to destination directory.
1609
1610
If no revision is specified this exports the last committed revision.
1611
1612
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1613
given, try to find the format with the extension. If no extension
1614
is found exports to a directory (equivalent to --format=dir).
1615
1616
Root may be the top directory for tar, tgz and tbz2 formats. If none
1617
is given, the top directory will be the root name of the file.
1618
1619
Note: export of tree with non-ascii filenames to zip is not supported.
1620
1621
Supported formats Autodetected by extension
1622
----------------- -------------------------
1623
dir -
1624
tar .tar
1625
tbz2 .tar.bz2, .tbz2
1626
tgz .tar.gz, .tgz
1627
zip .zip
1628
"""
1629
takes_args = ['dest']
1630
takes_options = ['revision', 'format', 'root']
1631
def run(self, dest, revision=None, format=None, root=None):
1632
from bzrlib.export import export
1633
tree = WorkingTree.open_containing(u'.')[0]
1634
b = tree.branch
1635
if revision is None:
1636
# should be tree.last_revision FIXME
1637
rev_id = b.last_revision()
1638
else:
1639
if len(revision) != 1:
1640
raise BzrError('bzr export --revision takes exactly 1 argument')
1641
rev_id = revision[0].in_history(b).rev_id
1642
t = b.repository.revision_tree(rev_id)
1643
try:
1644
export(t, dest, format, root)
1645
except errors.NoSuchExportFormat, e:
1646
raise BzrCommandError('Unsupported export format: %s' % e.format)
1647
1648
1649
class cmd_cat(Command):
1650
"""Write a file's text from a previous revision."""
1651
1652
takes_options = ['revision']
1653
takes_args = ['filename']
1654
1655
@display_command
1656
def run(self, filename, revision=None):
1657
if revision is not None and len(revision) != 1:
1658
raise BzrCommandError("bzr cat --revision takes exactly one number")
1659
tree = None
1660
try:
1661
tree, relpath = WorkingTree.open_containing(filename)
1662
b = tree.branch
1663
except NotBranchError:
1664
pass
1665
1666
if tree is None:
1667
b, relpath = Branch.open_containing(filename)
1668
if revision is not None and revision[0].get_branch() is not None:
1669
b = Branch.open(revision[0].get_branch())
1670
if revision is None:
1671
revision_id = b.last_revision()
1672
else:
1673
revision_id = revision[0].in_history(b).rev_id
1674
b.print_file(relpath, revision_id)
1675
1676
1677
class cmd_local_time_offset(Command):
1678
"""Show the offset in seconds from GMT to local time."""
1679
hidden = True
1680
@display_command
1681
def run(self):
1682
print osutils.local_time_offset()
1683
1684
1685
1686
class cmd_commit(Command):
1687
"""Commit changes into a new revision.
1688
1689
If no arguments are given, the entire tree is committed.
1690
1691
If selected files are specified, only changes to those files are
1692
committed. If a directory is specified then the directory and everything
1693
within it is committed.
1694
1695
A selected-file commit may fail in some cases where the committed
1696
tree would be invalid, such as trying to commit a file in a
1697
newly-added directory that is not itself committed.
1698
"""
1699
# TODO: Run hooks on tree to-be-committed, and after commit.
1700
1701
# TODO: Strict commit that fails if there are deleted files.
1702
# (what does "deleted files" mean ??)
1703
1704
# TODO: Give better message for -s, --summary, used by tla people
1705
1706
# XXX: verbose currently does nothing
1707
1708
takes_args = ['selected*']
1709
takes_options = ['message', 'verbose',
1710
Option('unchanged',
1711
help='commit even if nothing has changed'),
1712
Option('file', type=str,
1713
argname='msgfile',
1714
help='file containing commit message'),
1715
Option('strict',
1716
help="refuse to commit if there are unknown "
1717
"files in the working tree."),
1718
Option('local',
1719
help="perform a local only commit in a bound "
1720
"branch. Such commits are not pushed to "
1721
"the master branch until a normal commit "
1722
"is performed."
1723
),
1724
]
1725
aliases = ['ci', 'checkin']
1726
1727
def run(self, message=None, file=None, verbose=True, selected_list=None,
1728
unchanged=False, strict=False, local=False):
1729
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1730
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1731
StrictCommitFailed)
1732
from bzrlib.msgeditor import edit_commit_message, \
1733
make_commit_message_template
1734
from tempfile import TemporaryFile
1735
1736
# TODO: Need a blackbox test for invoking the external editor; may be
1737
# slightly problematic to run this cross-platform.
1738
1739
# TODO: do more checks that the commit will succeed before
1740
# spending the user's valuable time typing a commit message.
1741
#
1742
# TODO: if the commit *does* happen to fail, then save the commit
1743
# message to a temporary file where it can be recovered
1744
tree, selected_list = tree_files(selected_list)
1745
if selected_list == ['']:
1746
# workaround - commit of root of tree should be exactly the same
1747
# as just default commit in that tree, and succeed even though
1748
# selected-file merge commit is not done yet
1749
selected_list = []
1750
1751
if local and not tree.branch.get_bound_location():
1752
raise errors.LocalRequiresBoundBranch()
1753
if message is None and not file:
1754
template = make_commit_message_template(tree, selected_list)
1755
message = edit_commit_message(template)
1756
if message is None:
1757
raise BzrCommandError("please specify a commit message"
1758
" with either --message or --file")
1759
elif message and file:
1760
raise BzrCommandError("please specify either --message or --file")
1761
1762
if file:
1763
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1764
1765
if message == "":
1766
raise BzrCommandError("empty commit message specified")
1767
1768
if verbose:
1769
reporter = ReportCommitToLog()
1770
else:
1771
reporter = NullCommitReporter()
1772
1773
try:
1774
tree.commit(message, specific_files=selected_list,
1775
allow_pointless=unchanged, strict=strict, local=local,
1776
reporter=reporter)
1777
except PointlessCommit:
1778
# FIXME: This should really happen before the file is read in;
1779
# perhaps prepare the commit; get the message; then actually commit
1780
raise BzrCommandError("no changes to commit."
1781
" use --unchanged to commit anyhow")
1782
except ConflictsInTree:
1783
raise BzrCommandError("Conflicts detected in working tree. "
1784
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1785
except StrictCommitFailed:
1786
raise BzrCommandError("Commit refused because there are unknown "
1787
"files in the working tree.")
1788
except errors.BoundBranchOutOfDate, e:
1789
raise BzrCommandError(str(e) + "\n"
1790
'To commit to master branch, run update and then commit.\n'
1791
'You can also pass --local to commit to continue working '
1792
'disconnected.')
1793
1794
class cmd_check(Command):
1795
"""Validate consistency of branch history.
1796
1797
This command checks various invariants about the branch storage to
1798
detect data corruption or bzr bugs.
1799
"""
1800
takes_args = ['branch?']
1801
takes_options = ['verbose']
1802
1803
def run(self, branch=None, verbose=False):
1804
from bzrlib.check import check
1805
if branch is None:
1806
tree = WorkingTree.open_containing()[0]
1807
branch = tree.branch
1808
else:
1809
branch = Branch.open(branch)
1810
check(branch, verbose)
1811
1812
1813
class cmd_scan_cache(Command):
1814
hidden = True
1815
def run(self):
1816
from bzrlib.hashcache import HashCache
1817
1818
c = HashCache(u'.')
1819
c.read()
1820
c.scan()
1821
1822
print '%6d stats' % c.stat_count
1823
print '%6d in hashcache' % len(c._cache)
1824
print '%6d files removed from cache' % c.removed_count
1825
print '%6d hashes updated' % c.update_count
1826
print '%6d files changed too recently to cache' % c.danger_count
1827
1828
if c.needs_write:
1829
c.write()
1830
1831
1832
class cmd_upgrade(Command):
1833
"""Upgrade branch storage to current format.
1834
1835
The check command or bzr developers may sometimes advise you to run
1836
this command. When the default format has changed you may also be warned
1837
during other operations to upgrade.
1838
"""
1839
takes_args = ['url?']
1840
takes_options = [
1841
Option('format',
1842
help='Upgrade to a specific format. Current formats'
1843
' are: default, knit, metaweave and weave.'
1844
' Default is knit; metaweave and weave are'
1845
' deprecated',
1846
type=get_format_type),
1847
]
1848
1849
1850
def run(self, url='.', format=None):
1851
from bzrlib.upgrade import upgrade
1852
if format is None:
1853
format = get_format_type('default')
1854
upgrade(url, format)
1855
1856
1857
class cmd_whoami(Command):
1858
"""Show or set bzr user id.
1859
1860
examples:
1861
bzr whoami --email
1862
bzr whoami 'Frank Chu <fchu@example.com>'
1863
"""
1864
takes_options = [ Option('email',
1865
help='display email address only'),
1866
Option('branch',
1867
help='set identity for the current branch instead of '
1868
'globally'),
1869
]
1870
takes_args = ['name?']
1871
encoding_type = 'replace'
1872
1873
@display_command
1874
def run(self, email=False, branch=False, name=None):
1875
if name is None:
1876
# use branch if we're inside one; otherwise global config
1877
try:
1878
c = Branch.open_containing('.')[0].get_config()
1879
except NotBranchError:
1880
c = config.GlobalConfig()
1881
if email:
1882
self.outf.write(c.user_email() + '\n')
1883
else:
1884
self.outf.write(c.username() + '\n')
1885
return
1886
1887
# display a warning if an email address isn't included in the given name.
1888
try:
1889
config.extract_email_address(name)
1890
except BzrError, e:
1891
warning('"%s" does not seem to contain an email address. '
1892
'This is allowed, but not recommended.', name)
1893
1894
# use global config unless --branch given
1895
if branch:
1896
c = Branch.open_containing('.')[0].get_config()
1897
else:
1898
c = config.GlobalConfig()
1899
c.set_user_option('email', name)
1900
1901
1902
class cmd_nick(Command):
1903
"""Print or set the branch nickname.
1904
1905
If unset, the tree root directory name is used as the nickname
1906
To print the current nickname, execute with no argument.
1907
"""
1908
takes_args = ['nickname?']
1909
def run(self, nickname=None):
1910
branch = Branch.open_containing(u'.')[0]
1911
if nickname is None:
1912
self.printme(branch)
1913
else:
1914
branch.nick = nickname
1915
1916
@display_command
1917
def printme(self, branch):
1918
print branch.nick
1919
1920
1921
class cmd_selftest(Command):
1922
"""Run internal test suite.
1923
1924
This creates temporary test directories in the working directory,
1925
but not existing data is affected. These directories are deleted
1926
if the tests pass, or left behind to help in debugging if they
1927
fail and --keep-output is specified.
1928
1929
If arguments are given, they are regular expressions that say
1930
which tests should run.
1931
1932
If the global option '--no-plugins' is given, plugins are not loaded
1933
before running the selftests. This has two effects: features provided or
1934
modified by plugins will not be tested, and tests provided by plugins will
1935
not be run.
1936
1937
examples:
1938
bzr selftest ignore
1939
bzr --no-plugins selftest -v
1940
"""
1941
# TODO: --list should give a list of all available tests
1942
1943
# NB: this is used from the class without creating an instance, which is
1944
# why it does not have a self parameter.
1945
def get_transport_type(typestring):
1946
"""Parse and return a transport specifier."""
1947
if typestring == "sftp":
1948
from bzrlib.transport.sftp import SFTPAbsoluteServer
1949
return SFTPAbsoluteServer
1950
if typestring == "memory":
1951
from bzrlib.transport.memory import MemoryServer
1952
return MemoryServer
1953
if typestring == "fakenfs":
1954
from bzrlib.transport.fakenfs import FakeNFSServer
1955
return FakeNFSServer
1956
msg = "No known transport type %s. Supported types are: sftp\n" %\
1957
(typestring)
1958
raise BzrCommandError(msg)
1959
1960
hidden = True
1961
takes_args = ['testspecs*']
1962
takes_options = ['verbose',
1963
Option('one', help='stop when one test fails'),
1964
Option('keep-output',
1965
help='keep output directories when tests fail'),
1966
Option('transport',
1967
help='Use a different transport by default '
1968
'throughout the test suite.',
1969
type=get_transport_type),
1970
Option('benchmark', help='run the bzr bencharks.'),
1971
Option('lsprof-timed',
1972
help='generate lsprof output for benchmarked'
1973
' sections of code.'),
1974
Option('cache-dir', type=str,
1975
help='a directory to cache intermediate'
1976
' benchmark steps'),
1977
]
1978
1979
def run(self, testspecs_list=None, verbose=None, one=False,
1980
keep_output=False, transport=None, benchmark=None,
1981
lsprof_timed=None, cache_dir=None):
1982
import bzrlib.ui
1983
from bzrlib.tests import selftest
1984
import bzrlib.benchmarks as benchmarks
1985
from bzrlib.benchmarks import tree_creator
1986
1987
if cache_dir is not None:
1988
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
1989
# we don't want progress meters from the tests to go to the
1990
# real output; and we don't want log messages cluttering up
1991
# the real logs.
1992
save_ui = ui.ui_factory
1993
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1994
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1995
print
1996
info('running tests...')
1997
try:
1998
ui.ui_factory = ui.SilentUIFactory()
1999
if testspecs_list is not None:
2000
pattern = '|'.join(testspecs_list)
2001
else:
2002
pattern = ".*"
2003
if benchmark:
2004
test_suite_factory = benchmarks.test_suite
2005
if verbose is None:
2006
verbose = True
2007
benchfile = open(".perf_history", "at")
2008
else:
2009
test_suite_factory = None
2010
if verbose is None:
2011
verbose = False
2012
benchfile = None
2013
try:
2014
result = selftest(verbose=verbose,
2015
pattern=pattern,
2016
stop_on_failure=one,
2017
keep_output=keep_output,
2018
transport=transport,
2019
test_suite_factory=test_suite_factory,
2020
lsprof_timed=lsprof_timed,
2021
bench_history=benchfile)
2022
finally:
2023
if benchfile is not None:
2024
benchfile.close()
2025
if result:
2026
info('tests passed')
2027
else:
2028
info('tests failed')
2029
return int(not result)
2030
finally:
2031
ui.ui_factory = save_ui
2032
2033
2034
class cmd_version(Command):
2035
"""Show version of bzr."""
2036
2037
@display_command
2038
def run(self):
2039
from bzrlib.version import show_version
2040
show_version()
2041
2042
2043
class cmd_rocks(Command):
2044
"""Statement of optimism."""
2045
2046
hidden = True
2047
2048
@display_command
2049
def run(self):
2050
print "it sure does!"
2051
2052
2053
class cmd_find_merge_base(Command):
2054
"""Find and print a base revision for merging two branches."""
2055
# TODO: Options to specify revisions on either side, as if
2056
# merging only part of the history.
2057
takes_args = ['branch', 'other']
2058
hidden = True
2059
2060
@display_command
2061
def run(self, branch, other):
2062
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2063
2064
branch1 = Branch.open_containing(branch)[0]
2065
branch2 = Branch.open_containing(other)[0]
2066
2067
history_1 = branch1.revision_history()
2068
history_2 = branch2.revision_history()
2069
2070
last1 = branch1.last_revision()
2071
last2 = branch2.last_revision()
2072
2073
source = MultipleRevisionSources(branch1.repository,
2074
branch2.repository)
2075
2076
base_rev_id = common_ancestor(last1, last2, source)
2077
2078
print 'merge base is revision %s' % base_rev_id
2079
2080
2081
class cmd_merge(Command):
2082
"""Perform a three-way merge.
2083
2084
The branch is the branch you will merge from. By default, it will merge
2085
the latest revision. If you specify a revision, that revision will be
2086
merged. If you specify two revisions, the first will be used as a BASE,
2087
and the second one as OTHER. Revision numbers are always relative to the
2088
specified branch.
2089
2090
By default, bzr will try to merge in all new work from the other
2091
branch, automatically determining an appropriate base. If this
2092
fails, you may need to give an explicit base.
2093
2094
Merge will do its best to combine the changes in two branches, but there
2095
are some kinds of problems only a human can fix. When it encounters those,
2096
it will mark a conflict. A conflict means that you need to fix something,
2097
before you should commit.
2098
2099
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2100
2101
If there is no default branch set, the first merge will set it. After
2102
that, you can omit the branch to use the default. To change the
2103
default, use --remember. The value will only be saved if the remote
2104
location can be accessed.
2105
2106
Examples:
2107
2108
To merge the latest revision from bzr.dev
2109
bzr merge ../bzr.dev
2110
2111
To merge changes up to and including revision 82 from bzr.dev
2112
bzr merge -r 82 ../bzr.dev
2113
2114
To merge the changes introduced by 82, without previous changes:
2115
bzr merge -r 81..82 ../bzr.dev
2116
2117
merge refuses to run if there are any uncommitted changes, unless
2118
--force is given.
2119
2120
The following merge types are available:
2121
"""
2122
takes_args = ['branch?']
2123
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2124
Option('show-base', help="Show base revision text in "
2125
"conflicts"),
2126
Option('uncommitted', help='Apply uncommitted changes'
2127
' from a working copy, instead of branch changes')]
2128
2129
def help(self):
2130
from merge import merge_type_help
2131
from inspect import getdoc
2132
return getdoc(self) + '\n' + merge_type_help()
2133
2134
def run(self, branch=None, revision=None, force=False, merge_type=None,
2135
show_base=False, reprocess=False, remember=False,
2136
uncommitted=False):
2137
if merge_type is None:
2138
merge_type = Merge3Merger
2139
2140
tree = WorkingTree.open_containing(u'.')[0]
2141
2142
if branch is not None:
2143
try:
2144
reader = bundle.read_bundle_from_url(branch)
2145
except NotABundle:
2146
pass # Continue on considering this url a Branch
2147
else:
2148
conflicts = merge_bundle(reader, tree, not force, merge_type,
2149
reprocess, show_base)
2150
if conflicts == 0:
2151
return 0
2152
else:
2153
return 1
2154
2155
if revision is None \
2156
or len(revision) < 1 or revision[0].needs_branch():
2157
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2158
2159
if revision is None or len(revision) < 1:
2160
if uncommitted:
2161
base = [branch, -1]
2162
other = [branch, None]
2163
else:
2164
base = [None, None]
2165
other = [branch, -1]
2166
other_branch, path = Branch.open_containing(branch)
2167
else:
2168
if uncommitted:
2169
raise BzrCommandError('Cannot use --uncommitted and --revision'
2170
' at the same time.')
2171
branch = revision[0].get_branch() or branch
2172
if len(revision) == 1:
2173
base = [None, None]
2174
other_branch, path = Branch.open_containing(branch)
2175
revno = revision[0].in_history(other_branch).revno
2176
other = [branch, revno]
2177
else:
2178
assert len(revision) == 2
2179
if None in revision:
2180
raise BzrCommandError(
2181
"Merge doesn't permit empty revision specifier.")
2182
base_branch, path = Branch.open_containing(branch)
2183
branch1 = revision[1].get_branch() or branch
2184
other_branch, path1 = Branch.open_containing(branch1)
2185
if revision[0].get_branch() is not None:
2186
# then path was obtained from it, and is None.
2187
path = path1
2188
2189
base = [branch, revision[0].in_history(base_branch).revno]
2190
other = [branch1, revision[1].in_history(other_branch).revno]
2191
2192
if tree.branch.get_parent() is None or remember:
2193
tree.branch.set_parent(other_branch.base)
2194
2195
if path != "":
2196
interesting_files = [path]
2197
else:
2198
interesting_files = None
2199
pb = ui.ui_factory.nested_progress_bar()
2200
try:
2201
try:
2202
conflict_count = merge(other, base, check_clean=(not force),
2203
merge_type=merge_type,
2204
reprocess=reprocess,
2205
show_base=show_base,
2206
pb=pb, file_list=interesting_files)
2207
finally:
2208
pb.finished()
2209
if conflict_count != 0:
2210
return 1
2211
else:
2212
return 0
2213
except errors.AmbiguousBase, e:
2214
m = ("sorry, bzr can't determine the right merge base yet\n"
2215
"candidates are:\n "
2216
+ "\n ".join(e.bases)
2217
+ "\n"
2218
"please specify an explicit base with -r,\n"
2219
"and (if you want) report this to the bzr developers\n")
2220
log_error(m)
2221
2222
# TODO: move up to common parent; this isn't merge-specific anymore.
2223
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2224
"""Use tree.branch's parent if none was supplied.
2225
2226
Report if the remembered location was used.
2227
"""
2228
if supplied_location is not None:
2229
return supplied_location
2230
stored_location = tree.branch.get_parent()
2231
mutter("%s", stored_location)
2232
if stored_location is None:
2233
raise BzrCommandError("No location specified or remembered")
2234
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2235
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2236
return stored_location
2237
2238
2239
class cmd_remerge(Command):
2240
"""Redo a merge.
2241
2242
Use this if you want to try a different merge technique while resolving
2243
conflicts. Some merge techniques are better than others, and remerge
2244
lets you try different ones on different files.
2245
2246
The options for remerge have the same meaning and defaults as the ones for
2247
merge. The difference is that remerge can (only) be run when there is a
2248
pending merge, and it lets you specify particular files.
2249
2250
Examples:
2251
$ bzr remerge --show-base
2252
Re-do the merge of all conflicted files, and show the base text in
2253
conflict regions, in addition to the usual THIS and OTHER texts.
2254
2255
$ bzr remerge --merge-type weave --reprocess foobar
2256
Re-do the merge of "foobar", using the weave merge algorithm, with
2257
additional processing to reduce the size of conflict regions.
2258
2259
The following merge types are available:"""
2260
takes_args = ['file*']
2261
takes_options = ['merge-type', 'reprocess',
2262
Option('show-base', help="Show base revision text in "
2263
"conflicts")]
2264
2265
def help(self):
2266
from merge import merge_type_help
2267
from inspect import getdoc
2268
return getdoc(self) + '\n' + merge_type_help()
2269
2270
def run(self, file_list=None, merge_type=None, show_base=False,
2271
reprocess=False):
2272
from bzrlib.merge import merge_inner, transform_tree
2273
if merge_type is None:
2274
merge_type = Merge3Merger
2275
tree, file_list = tree_files(file_list)
2276
tree.lock_write()
2277
try:
2278
parents = tree.get_parent_ids()
2279
if len(parents) != 2:
2280
raise BzrCommandError("Sorry, remerge only works after normal"
2281
" merges. Not cherrypicking or"
2282
" multi-merges.")
2283
repository = tree.branch.repository
2284
base_revision = common_ancestor(parents[0],
2285
parents[1], repository)
2286
base_tree = repository.revision_tree(base_revision)
2287
other_tree = repository.revision_tree(parents[1])
2288
interesting_ids = None
2289
new_conflicts = []
2290
conflicts = tree.conflicts()
2291
if file_list is not None:
2292
interesting_ids = set()
2293
for filename in file_list:
2294
file_id = tree.path2id(filename)
2295
if file_id is None:
2296
raise NotVersionedError(filename)
2297
interesting_ids.add(file_id)
2298
if tree.kind(file_id) != "directory":
2299
continue
2300
2301
for name, ie in tree.inventory.iter_entries(file_id):
2302
interesting_ids.add(ie.file_id)
2303
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2304
transform_tree(tree, tree.basis_tree(), interesting_ids)
2305
tree.set_conflicts(ConflictList(new_conflicts))
2306
if file_list is None:
2307
restore_files = list(tree.iter_conflicts())
2308
else:
2309
restore_files = file_list
2310
for filename in restore_files:
2311
try:
2312
restore(tree.abspath(filename))
2313
except NotConflicted:
2314
pass
2315
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2316
this_tree=tree,
2317
interesting_ids=interesting_ids,
2318
other_rev_id=parents[1],
2319
merge_type=merge_type,
2320
show_base=show_base,
2321
reprocess=reprocess)
2322
finally:
2323
tree.unlock()
2324
if conflicts > 0:
2325
return 1
2326
else:
2327
return 0
2328
2329
class cmd_revert(Command):
2330
"""Revert files to a previous revision.
2331
2332
Giving a list of files will revert only those files. Otherwise, all files
2333
will be reverted. If the revision is not specified with '--revision', the
2334
last committed revision is used.
2335
2336
To remove only some changes, without reverting to a prior version, use
2337
merge instead. For example, "merge . --r-2..-3" will remove the changes
2338
introduced by -2, without affecting the changes introduced by -1. Or
2339
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2340
2341
By default, any files that have been manually changed will be backed up
2342
first. (Files changed only by merge are not backed up.) Backup files have
2343
'.~#~' appended to their name, where # is a number.
2344
2345
When you provide files, you can use their current pathname or the pathname
2346
from the target revision. So you can use revert to "undelete" a file by
2347
name. If you name a directory, all the contents of that directory will be
2348
reverted.
2349
"""
2350
takes_options = ['revision', 'no-backup']
2351
takes_args = ['file*']
2352
aliases = ['merge-revert']
2353
2354
def run(self, revision=None, no_backup=False, file_list=None):
2355
from bzrlib.commands import parse_spec
2356
if file_list is not None:
2357
if len(file_list) == 0:
2358
raise BzrCommandError("No files specified")
2359
else:
2360
file_list = []
2361
2362
tree, file_list = tree_files(file_list)
2363
if revision is None:
2364
# FIXME should be tree.last_revision
2365
rev_id = tree.last_revision()
2366
elif len(revision) != 1:
2367
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2368
else:
2369
rev_id = revision[0].in_history(tree.branch).rev_id
2370
pb = ui.ui_factory.nested_progress_bar()
2371
try:
2372
tree.revert(file_list,
2373
tree.branch.repository.revision_tree(rev_id),
2374
not no_backup, pb)
2375
finally:
2376
pb.finished()
2377
2378
2379
class cmd_assert_fail(Command):
2380
"""Test reporting of assertion failures"""
2381
hidden = True
2382
def run(self):
2383
assert False, "always fails"
2384
2385
2386
class cmd_help(Command):
2387
"""Show help on a command or other topic.
2388
2389
For a list of all available commands, say 'bzr help commands'."""
2390
takes_options = [Option('long', 'show help on all commands')]
2391
takes_args = ['topic?']
2392
aliases = ['?', '--help', '-?', '-h']
2393
2394
@display_command
2395
def run(self, topic=None, long=False):
2396
import help
2397
if topic is None and long:
2398
topic = "commands"
2399
help.help(topic)
2400
2401
2402
class cmd_shell_complete(Command):
2403
"""Show appropriate completions for context.
2404
2405
For a list of all available commands, say 'bzr shell-complete'."""
2406
takes_args = ['context?']
2407
aliases = ['s-c']
2408
hidden = True
2409
2410
@display_command
2411
def run(self, context=None):
2412
import shellcomplete
2413
shellcomplete.shellcomplete(context)
2414
2415
2416
class cmd_fetch(Command):
2417
"""Copy in history from another branch but don't merge it.
2418
2419
This is an internal method used for pull and merge."""
2420
hidden = True
2421
takes_args = ['from_branch', 'to_branch']
2422
def run(self, from_branch, to_branch):
2423
from bzrlib.fetch import Fetcher
2424
from_b = Branch.open(from_branch)
2425
to_b = Branch.open(to_branch)
2426
Fetcher(to_b, from_b)
2427
2428
2429
class cmd_missing(Command):
2430
"""Show unmerged/unpulled revisions between two branches.
2431
2432
OTHER_BRANCH may be local or remote."""
2433
takes_args = ['other_branch?']
2434
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2435
Option('mine-only',
2436
'Display changes in the local branch only'),
2437
Option('theirs-only',
2438
'Display changes in the remote branch only'),
2439
'log-format',
2440
'line',
2441
'long',
2442
'short',
2443
'show-ids',
2444
'verbose'
2445
]
2446
encoding_type = 'replace'
2447
2448
@display_command
2449
def run(self, other_branch=None, reverse=False, mine_only=False,
2450
theirs_only=False, log_format=None, long=False, short=False, line=False,
2451
show_ids=False, verbose=False):
2452
from bzrlib.missing import find_unmerged, iter_log_data
2453
from bzrlib.log import log_formatter
2454
local_branch = Branch.open_containing(u".")[0]
2455
parent = local_branch.get_parent()
2456
if other_branch is None:
2457
other_branch = parent
2458
if other_branch is None:
2459
raise BzrCommandError("No peer location known or specified.")
2460
print "Using last location: " + local_branch.get_parent()
2461
remote_branch = Branch.open(other_branch)
2462
if remote_branch.base == local_branch.base:
2463
remote_branch = local_branch
2464
local_branch.lock_read()
2465
try:
2466
remote_branch.lock_read()
2467
try:
2468
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2469
if (log_format is None):
2470
default = local_branch.get_config().log_format()
2471
log_format = get_log_format(long=long, short=short,
2472
line=line, default=default)
2473
lf = log_formatter(log_format,
2474
to_file=self.outf,
2475
show_ids=show_ids,
2476
show_timezone='original')
2477
if reverse is False:
2478
local_extra.reverse()
2479
remote_extra.reverse()
2480
if local_extra and not theirs_only:
2481
print "You have %d extra revision(s):" % len(local_extra)
2482
for data in iter_log_data(local_extra, local_branch.repository,
2483
verbose):
2484
lf.show(*data)
2485
printed_local = True
2486
else:
2487
printed_local = False
2488
if remote_extra and not mine_only:
2489
if printed_local is True:
2490
print "\n\n"
2491
print "You are missing %d revision(s):" % len(remote_extra)
2492
for data in iter_log_data(remote_extra, remote_branch.repository,
2493
verbose):
2494
lf.show(*data)
2495
if not remote_extra and not local_extra:
2496
status_code = 0
2497
print "Branches are up to date."
2498
else:
2499
status_code = 1
2500
finally:
2501
remote_branch.unlock()
2502
finally:
2503
local_branch.unlock()
2504
if not status_code and parent is None and other_branch is not None:
2505
local_branch.lock_write()
2506
try:
2507
# handle race conditions - a parent might be set while we run.
2508
if local_branch.get_parent() is None:
2509
local_branch.set_parent(remote_branch.base)
2510
finally:
2511
local_branch.unlock()
2512
return status_code
2513
2514
2515
class cmd_plugins(Command):
2516
"""List plugins"""
2517
hidden = True
2518
@display_command
2519
def run(self):
2520
import bzrlib.plugin
2521
from inspect import getdoc
2522
for name, plugin in bzrlib.plugin.all_plugins().items():
2523
if getattr(plugin, '__path__', None) is not None:
2524
print plugin.__path__[0]
2525
elif getattr(plugin, '__file__', None) is not None:
2526
print plugin.__file__
2527
else:
2528
print repr(plugin)
2529
2530
d = getdoc(plugin)
2531
if d:
2532
print '\t', d.split('\n')[0]
2533
2534
2535
class cmd_testament(Command):
2536
"""Show testament (signing-form) of a revision."""
2537
takes_options = ['revision',
2538
Option('long', help='Produce long-format testament'),
2539
Option('strict', help='Produce a strict-format'
2540
' testament')]
2541
takes_args = ['branch?']
2542
@display_command
2543
def run(self, branch=u'.', revision=None, long=False, strict=False):
2544
from bzrlib.testament import Testament, StrictTestament
2545
if strict is True:
2546
testament_class = StrictTestament
2547
else:
2548
testament_class = Testament
2549
b = WorkingTree.open_containing(branch)[0].branch
2550
b.lock_read()
2551
try:
2552
if revision is None:
2553
rev_id = b.last_revision()
2554
else:
2555
rev_id = revision[0].in_history(b).rev_id
2556
t = testament_class.from_revision(b.repository, rev_id)
2557
if long:
2558
sys.stdout.writelines(t.as_text_lines())
2559
else:
2560
sys.stdout.write(t.as_short_text())
2561
finally:
2562
b.unlock()
2563
2564
2565
class cmd_annotate(Command):
2566
"""Show the origin of each line in a file.
2567
2568
This prints out the given file with an annotation on the left side
2569
indicating which revision, author and date introduced the change.
2570
2571
If the origin is the same for a run of consecutive lines, it is
2572
shown only at the top, unless the --all option is given.
2573
"""
2574
# TODO: annotate directories; showing when each file was last changed
2575
# TODO: if the working copy is modified, show annotations on that
2576
# with new uncommitted lines marked
2577
aliases = ['ann', 'blame', 'praise']
2578
takes_args = ['filename']
2579
takes_options = [Option('all', help='show annotations on all lines'),
2580
Option('long', help='show date in annotations'),
2581
'revision'
2582
]
2583
2584
@display_command
2585
def run(self, filename, all=False, long=False, revision=None):
2586
from bzrlib.annotate import annotate_file
2587
tree, relpath = WorkingTree.open_containing(filename)
2588
branch = tree.branch
2589
branch.lock_read()
2590
try:
2591
if revision is None:
2592
revision_id = branch.last_revision()
2593
elif len(revision) != 1:
2594
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2595
else:
2596
revision_id = revision[0].in_history(branch).rev_id
2597
file_id = tree.inventory.path2id(relpath)
2598
tree = branch.repository.revision_tree(revision_id)
2599
file_version = tree.inventory[file_id].revision
2600
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2601
finally:
2602
branch.unlock()
2603
2604
2605
class cmd_re_sign(Command):
2606
"""Create a digital signature for an existing revision."""
2607
# TODO be able to replace existing ones.
2608
2609
hidden = True # is this right ?
2610
takes_args = ['revision_id*']
2611
takes_options = ['revision']
2612
2613
def run(self, revision_id_list=None, revision=None):
2614
import bzrlib.gpg as gpg
2615
if revision_id_list is not None and revision is not None:
2616
raise BzrCommandError('You can only supply one of revision_id or --revision')
2617
if revision_id_list is None and revision is None:
2618
raise BzrCommandError('You must supply either --revision or a revision_id')
2619
b = WorkingTree.open_containing(u'.')[0].branch
2620
gpg_strategy = gpg.GPGStrategy(b.get_config())
2621
if revision_id_list is not None:
2622
for revision_id in revision_id_list:
2623
b.repository.sign_revision(revision_id, gpg_strategy)
2624
elif revision is not None:
2625
if len(revision) == 1:
2626
revno, rev_id = revision[0].in_history(b)
2627
b.repository.sign_revision(rev_id, gpg_strategy)
2628
elif len(revision) == 2:
2629
# are they both on rh- if so we can walk between them
2630
# might be nice to have a range helper for arbitrary
2631
# revision paths. hmm.
2632
from_revno, from_revid = revision[0].in_history(b)
2633
to_revno, to_revid = revision[1].in_history(b)
2634
if to_revid is None:
2635
to_revno = b.revno()
2636
if from_revno is None or to_revno is None:
2637
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2638
for revno in range(from_revno, to_revno + 1):
2639
b.repository.sign_revision(b.get_rev_id(revno),
2640
gpg_strategy)
2641
else:
2642
raise BzrCommandError('Please supply either one revision, or a range.')
2643
2644
2645
class cmd_bind(Command):
2646
"""Bind the current branch to a master branch.
2647
2648
After binding, commits must succeed on the master branch
2649
before they are executed on the local one.
2650
"""
2651
2652
takes_args = ['location']
2653
takes_options = []
2654
2655
def run(self, location=None):
2656
b, relpath = Branch.open_containing(u'.')
2657
b_other = Branch.open(location)
2658
try:
2659
b.bind(b_other)
2660
except DivergedBranches:
2661
raise BzrCommandError('These branches have diverged.'
2662
' Try merging, and then bind again.')
2663
2664
2665
class cmd_unbind(Command):
2666
"""Unbind the current branch from its master branch.
2667
2668
After unbinding, the local branch is considered independent.
2669
All subsequent commits will be local.
2670
"""
2671
2672
takes_args = []
2673
takes_options = []
2674
2675
def run(self):
2676
b, relpath = Branch.open_containing(u'.')
2677
if not b.unbind():
2678
raise BzrCommandError('Local branch is not bound')
2679
2680
2681
class cmd_uncommit(Command):
2682
"""Remove the last committed revision.
2683
2684
--verbose will print out what is being removed.
2685
--dry-run will go through all the motions, but not actually
2686
remove anything.
2687
2688
In the future, uncommit will create a revision bundle, which can then
2689
be re-applied.
2690
"""
2691
2692
# TODO: jam 20060108 Add an option to allow uncommit to remove
2693
# unreferenced information in 'branch-as-repository' branches.
2694
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2695
# information in shared branches as well.
2696
takes_options = ['verbose', 'revision',
2697
Option('dry-run', help='Don\'t actually make changes'),
2698
Option('force', help='Say yes to all questions.')]
2699
takes_args = ['location?']
2700
aliases = []
2701
2702
def run(self, location=None,
2703
dry_run=False, verbose=False,
2704
revision=None, force=False):
2705
from bzrlib.log import log_formatter, show_log
2706
import sys
2707
from bzrlib.uncommit import uncommit
2708
2709
if location is None:
2710
location = u'.'
2711
control, relpath = bzrdir.BzrDir.open_containing(location)
2712
try:
2713
tree = control.open_workingtree()
2714
b = tree.branch
2715
except (errors.NoWorkingTree, errors.NotLocalUrl):
2716
tree = None
2717
b = control.open_branch()
2718
2719
rev_id = None
2720
if revision is None:
2721
revno = b.revno()
2722
else:
2723
# 'bzr uncommit -r 10' actually means uncommit
2724
# so that the final tree is at revno 10.
2725
# but bzrlib.uncommit.uncommit() actually uncommits
2726
# the revisions that are supplied.
2727
# So we need to offset it by one
2728
revno = revision[0].in_history(b).revno+1
2729
2730
if revno <= b.revno():
2731
rev_id = b.get_rev_id(revno)
2732
if rev_id is None:
2733
self.outf.write('No revisions to uncommit.\n')
2734
return 1
2735
2736
lf = log_formatter('short',
2737
to_file=self.outf,
2738
show_timezone='original')
2739
2740
show_log(b,
2741
lf,
2742
verbose=False,
2743
direction='forward',
2744
start_revision=revno,
2745
end_revision=b.revno())
2746
2747
if dry_run:
2748
print 'Dry-run, pretending to remove the above revisions.'
2749
if not force:
2750
val = raw_input('Press <enter> to continue')
2751
else:
2752
print 'The above revision(s) will be removed.'
2753
if not force:
2754
val = raw_input('Are you sure [y/N]? ')
2755
if val.lower() not in ('y', 'yes'):
2756
print 'Canceled'
2757
return 0
2758
2759
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2760
revno=revno)
2761
2762
2763
class cmd_break_lock(Command):
2764
"""Break a dead lock on a repository, branch or working directory.
2765
2766
CAUTION: Locks should only be broken when you are sure that the process
2767
holding the lock has been stopped.
2768
2769
You can get information on what locks are open via the 'bzr info' command.
2770
2771
example:
2772
bzr break-lock
2773
"""
2774
takes_args = ['location?']
2775
2776
def run(self, location=None, show=False):
2777
if location is None:
2778
location = u'.'
2779
control, relpath = bzrdir.BzrDir.open_containing(location)
2780
try:
2781
control.break_lock()
2782
except NotImplementedError:
2783
pass
2784
2785
2786
class cmd_wait_until_signalled(Command):
2787
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2788
2789
This just prints a line to signal when it is ready, then blocks on stdin.
2790
"""
2791
2792
hidden = True
2793
2794
def run(self):
2795
sys.stdout.write("running\n")
2796
sys.stdout.flush()
2797
sys.stdin.readline()
2798
2799
2800
class cmd_serve(Command):
2801
"""Run the bzr server."""
2802
2803
aliases = ['server']
2804
2805
takes_options = [
2806
Option('inet',
2807
help='serve on stdin/out for use from inetd or sshd'),
2808
Option('port',
2809
help='listen for connections on nominated port of the form '
2810
'[hostname:]portnumber. Passing 0 as the port number will '
2811
'result in a dynamically allocated port.',
2812
type=str),
2813
Option('directory',
2814
help='serve contents of directory',
2815
type=unicode),
2816
Option('allow-writes',
2817
help='By default the server is a readonly server. Supplying '
2818
'--allow-writes enables write access to the contents of '
2819
'the served directory and below. '
2820
),
2821
]
2822
2823
def run(self, port=None, inet=False, directory=None, allow_writes=False):
2824
from bzrlib.transport import smart
2825
from bzrlib.transport import get_transport
2826
if directory is None:
2827
directory = os.getcwd()
2828
url = 'file://' + urlutils.escape(directory)
2829
if not allow_writes:
2830
url = 'readonly+' + url
2831
t = get_transport(url)
2832
if inet:
2833
server = smart.SmartStreamServer(sys.stdin, sys.stdout, t)
2834
elif port is not None:
2835
if ':' in port:
2836
host, port = port.split(':')
2837
else:
2838
host = '127.0.0.1'
2839
server = smart.SmartTCPServer(t, host=host, port=int(port))
2840
print 'listening on port: ', server.port
2841
sys.stdout.flush()
2842
else:
2843
raise BzrCommandError("bzr serve requires one of --inet or --port")
2844
server.serve()
2845
2846
2847
# command-line interpretation helper for merge-related commands
2848
def merge(other_revision, base_revision,
2849
check_clean=True, ignore_zero=False,
2850
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2851
file_list=None, show_base=False, reprocess=False,
2852
pb=DummyProgress()):
2853
"""Merge changes into a tree.
2854
2855
base_revision
2856
list(path, revno) Base for three-way merge.
2857
If [None, None] then a base will be automatically determined.
2858
other_revision
2859
list(path, revno) Other revision for three-way merge.
2860
this_dir
2861
Directory to merge changes into; '.' by default.
2862
check_clean
2863
If true, this_dir must have no uncommitted changes before the
2864
merge begins.
2865
ignore_zero - If true, suppress the "zero conflicts" message when
2866
there are no conflicts; should be set when doing something we expect
2867
to complete perfectly.
2868
file_list - If supplied, merge only changes to selected files.
2869
2870
All available ancestors of other_revision and base_revision are
2871
automatically pulled into the branch.
2872
2873
The revno may be -1 to indicate the last revision on the branch, which is
2874
the typical case.
2875
2876
This function is intended for use from the command line; programmatic
2877
clients might prefer to call merge.merge_inner(), which has less magic
2878
behavior.
2879
"""
2880
from bzrlib.merge import Merger
2881
if this_dir is None:
2882
this_dir = u'.'
2883
this_tree = WorkingTree.open_containing(this_dir)[0]
2884
if show_base and not merge_type is Merge3Merger:
2885
raise BzrCommandError("Show-base is not supported for this merge"
2886
" type. %s" % merge_type)
2887
if reprocess and not merge_type.supports_reprocess:
2888
raise BzrCommandError("Conflict reduction is not supported for merge"
2889
" type %s." % merge_type)
2890
if reprocess and show_base:
2891
raise BzrCommandError("Cannot do conflict reduction and show base.")
2892
try:
2893
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2894
merger.pp = ProgressPhase("Merge phase", 5, pb)
2895
merger.pp.next_phase()
2896
merger.check_basis(check_clean)
2897
merger.set_other(other_revision)
2898
merger.pp.next_phase()
2899
merger.set_base(base_revision)
2900
if merger.base_rev_id == merger.other_rev_id:
2901
note('Nothing to do.')
2902
return 0
2903
merger.backup_files = backup_files
2904
merger.merge_type = merge_type
2905
merger.set_interesting_files(file_list)
2906
merger.show_base = show_base
2907
merger.reprocess = reprocess
2908
conflicts = merger.do_merge()
2909
if file_list is None:
2910
merger.set_pending()
2911
finally:
2912
pb.clear()
2913
return conflicts
2914
2915
2916
# these get imported and then picked up by the scan for cmd_*
2917
# TODO: Some more consistent way to split command definitions across files;
2918
# we do need to load at least some information about them to know of
2919
# aliases. ideally we would avoid loading the implementation until the
2920
# details were needed.
2921
from bzrlib.cmd_version_info import cmd_version_info
2922
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2923
from bzrlib.bundle.commands import cmd_bundle_revisions
2924
from bzrlib.sign_my_commits import cmd_sign_my_commits
2925
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2926
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0