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