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