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