« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 974.1.92
- compare with another revision
- download diff
- download tarball
- view history from revision 974.1.92
- Committer: Aaron Bentley
- Date: 2005-09-19 02:52:24 UTC
- mto: (1185.1.29)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: aaron.bentley@utoronto.ca-20050919025224-1cc3c70640086e09
TODO re tests
- files added:
- bzrlib/mdiff.py
- files removed:
- INSTALL
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_fetch.py => bzrlib/selftest/testfetch.py
- bzrlib/tests/test_graph.py => bzrlib/selftest/testgraph.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge.py => bzrlib/selftest/testmerge.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/test_store.py => bzrlib/selftest/teststore.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/upgrade.py => tools/history2weaves.py
- bzrlib/tests/test_weave.py => tools/testweave.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
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
# 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
17
22
18
import sys
23
19
import os
24
20
25
21
import bzrlib
22
import bzrlib.trace
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.branch import Branch
26
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command, display_command
28
from bzrlib.branch import Branch
29
from bzrlib.revision import common_ancestor
30
import bzrlib.errors as errors
31
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
32
NotBranchError, DivergedBranches, NotConflicted,
33
NoSuchFile, NoWorkingTree, FileInWrongBranch)
34
from bzrlib.option import Option
35
from bzrlib.revisionspec import RevisionSpec
36
import bzrlib.trace
37
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
38
from bzrlib.workingtree import WorkingTree
39
40
41
def tree_files(file_list, default_branch=u'.'):
42
try:
43
return internal_tree_files(file_list, default_branch)
44
except FileInWrongBranch, e:
45
raise BzrCommandError("%s is not in the same branch as %s" %
46
(e.path, file_list[0]))
47
48
def internal_tree_files(file_list, default_branch=u'.'):
49
"""\
50
Return a branch and list of branch-relative paths.
51
If supplied file_list is empty or None, the branch default will be used,
52
and returned file_list will match the original.
53
"""
54
if file_list is None or len(file_list) == 0:
55
return WorkingTree.open_containing(default_branch)[0], file_list
56
tree = WorkingTree.open_containing(file_list[0])[0]
57
new_list = []
58
for filename in file_list:
59
try:
60
new_list.append(tree.relpath(filename))
61
except errors.PathNotChild:
62
raise FileInWrongBranch(tree.branch, filename)
63
return tree, new_list
64
65
66
# TODO: Make sure no commands unconditionally use the working directory as a
67
# branch. If a filename argument is used, the first of them should be used to
68
# specify the branch. (Perhaps this can be factored out into some kind of
69
# Argument class, representing a file in a branch, where the first occurrence
70
# opens the branch?)
27
from bzrlib.commands import Command
28
71
29
72
30
class cmd_status(Command):
73
31
"""Display status summary.
104
62
directory is shown. Otherwise, only the status of the specified
105
63
files or directories is reported. If a directory is given, status
106
64
is reported for everything inside that directory.
65
"""
66
# XXX: FIXME: bzr status should accept a -r option to show changes
67
# relative to a revision, or between revisions
107
68
108
If a revision argument is given, the status is calculated against
109
that revision, or between two revisions if two are provided.
110
"""
111
112
# TODO: --no-recurse, --recurse options
113
114
69
takes_args = ['file*']
115
takes_options = ['all', 'show-ids', 'revision']
70
takes_options = ['all', 'show-ids']
116
71
aliases = ['st', 'stat']
117
72
118
@display_command
119
def run(self, all=False, show_ids=False, file_list=None, revision=None):
120
tree, file_list = tree_files(file_list)
73
def run(self, all=False, show_ids=False, file_list=None):
74
if file_list:
75
b = Branch.open_containing(file_list[0])
76
file_list = [b.relpath(x) for x in file_list]
77
# special case: only one path was given and it's the root
78
# of the branch
79
if file_list == ['']:
80
file_list = None
81
else:
82
b = Branch.open_containing('.')
121
83
122
84
from bzrlib.status import show_status
123
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
124
specific_files=file_list, revision=revision)
85
show_status(b, show_unchanged=all, show_ids=show_ids,
86
specific_files=file_list)
125
87
126
88
127
89
class cmd_cat_revision(Command):
128
"""Write out metadata for a revision.
129
130
The revision to print can either be specified by a specific
131
revision identifier, or you can use --revision.
132
"""
90
"""Write out metadata for a revision."""
133
91
134
92
hidden = True
135
takes_args = ['revision_id?']
136
takes_options = ['revision']
93
takes_args = ['revision_id']
137
94
138
@display_command
139
def run(self, revision_id=None, revision=None):
95
def run(self, revision_id):
96
b = Branch.open_containing('.')
97
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
140
98
141
if revision_id is not None and revision is not None:
142
raise BzrCommandError('You can only supply one of revision_id or --revision')
143
if revision_id is None and revision is None:
144
raise BzrCommandError('You must supply either --revision or a revision_id')
145
b = WorkingTree.open_containing(u'.')[0].branch
146
if revision_id is not None:
147
sys.stdout.write(b.get_revision_xml(revision_id))
148
elif revision is not None:
149
for rev in revision:
150
if rev is None:
151
raise BzrCommandError('You cannot specify a NULL revision.')
152
revno, rev_id = rev.in_history(b)
153
sys.stdout.write(b.get_revision_xml(rev_id))
154
155
99
156
100
class cmd_revno(Command):
157
101
"""Show current revision number.
158
102
159
103
This is equal to the number of revisions on this branch."""
160
takes_args = ['location?']
161
@display_command
162
def run(self, location=u'.'):
163
print Branch.open_containing(location)[0].revno()
104
def run(self):
105
print Branch.open_containing('.').revno()
164
106
165
107
166
108
class cmd_revision_info(Command):
169
111
hidden = True
170
112
takes_args = ['revision_info*']
171
113
takes_options = ['revision']
172
@display_command
173
def run(self, revision=None, revision_info_list=[]):
114
def run(self, revision=None, revision_info_list=()):
115
from bzrlib.revisionspec import RevisionSpec
174
116
175
117
revs = []
176
118
if revision is not None:
177
119
revs.extend(revision)
178
if revision_info_list is not None:
179
for rev in revision_info_list:
180
revs.append(RevisionSpec(rev))
120
for rev in revision_info_list:
121
revs.append(RevisionSpec(revision_info_list))
181
122
if len(revs) == 0:
182
123
raise BzrCommandError('You must supply a revision identifier')
183
124
184
b = WorkingTree.open_containing(u'.')[0].branch
125
b = Branch.open_containing('.')
185
126
186
127
for rev in revs:
187
revinfo = rev.in_history(b)
188
if revinfo.revno is None:
189
print ' %s' % revinfo.rev_id
190
else:
191
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
128
print '%4d %s' % rev.in_history(b)
192
129
193
130
194
131
class cmd_add(Command):
215
152
get added when you add a file in the directory.
216
153
"""
217
154
takes_args = ['file*']
218
takes_options = ['no-recurse']
155
takes_options = ['verbose', 'no-recurse']
219
156
220
def run(self, file_list, no_recurse=False):
221
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
222
if is_quiet():
223
reporter = add_reporter_null
224
else:
225
reporter = add_reporter_print
226
smart_add(file_list, not no_recurse, reporter)
157
def run(self, file_list, verbose=False, no_recurse=False):
158
# verbose currently has no effect
159
from bzrlib.add import smart_add, add_reporter_print
160
smart_add(file_list, not no_recurse, add_reporter_print)
161
227
162
228
163
229
164
class cmd_mkdir(Command):
234
169
takes_args = ['dir+']
235
170
236
171
def run(self, dir_list):
172
b = None
173
237
174
for d in dir_list:
238
175
os.mkdir(d)
239
wt, dd = WorkingTree.open_containing(d)
240
wt.add([dd])
176
if not b:
177
b = Branch.open_containing(d)
178
b.add([d])
241
179
print 'added', d
242
180
243
181
246
184
takes_args = ['filename']
247
185
hidden = True
248
186
249
@display_command
250
187
def run(self, filename):
251
tree, relpath = WorkingTree.open_containing(filename)
252
print relpath
188
print Branch.open_containing(filename).relpath(filename)
189
253
190
254
191
255
192
class cmd_inventory(Command):
256
"""Show inventory of the current working copy or a revision.
257
258
It is possible to limit the output to a particular entry
259
type using the --kind option. For example; --kind file.
260
"""
261
takes_options = ['revision', 'show-ids', 'kind']
193
"""Show inventory of the current working copy or a revision."""
194
takes_options = ['revision', 'show-ids']
262
195
263
@display_command
264
def run(self, revision=None, show_ids=False, kind=None):
265
if kind and kind not in ['file', 'directory', 'symlink']:
266
raise BzrCommandError('invalid kind specified')
267
tree = WorkingTree.open_containing(u'.')[0]
196
def run(self, revision=None, show_ids=False):
197
b = Branch.open_containing('.')
268
198
if revision is None:
269
inv = tree.read_working_inventory()
199
inv = b.read_working_inventory()
270
200
else:
271
201
if len(revision) > 1:
272
202
raise BzrCommandError('bzr inventory --revision takes'
273
203
' exactly one revision identifier')
274
inv = tree.branch.get_revision_inventory(
275
revision[0].in_history(tree.branch).rev_id)
204
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
276
205
277
206
for path, entry in inv.entries():
278
if kind and kind != entry.kind:
279
continue
280
207
if show_ids:
281
208
print '%-50s %s' % (path, entry.file_id)
282
209
else:
293
220
"""
294
221
takes_args = ['source$', 'dest']
295
222
def run(self, source_list, dest):
296
tree, source_list = tree_files(source_list)
223
b = Branch.open_containing('.')
224
297
225
# TODO: glob expansion on windows?
298
tree.move(source_list, tree.relpath(dest))
226
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
299
227
300
228
301
229
class cmd_rename(Command):
309
237
310
238
See also the 'move' command, which moves files into a different
311
239
directory without changing their name.
312
"""
313
# TODO: Some way to rename multiple files without invoking
314
# bzr for each one?"""
240
241
TODO: Some way to rename multiple files without invoking bzr for each
242
one?"""
315
243
takes_args = ['from_name', 'to_name']
316
244
317
245
def run(self, from_name, to_name):
318
tree, (from_name, to_name) = tree_files((from_name, to_name))
319
tree.rename_one(from_name, to_name)
246
b = Branch.open_containing('.')
247
b.rename_one(b.relpath(from_name), b.relpath(to_name))
248
320
249
321
250
322
251
class cmd_mv(Command):
336
265
def run(self, names_list):
337
266
if len(names_list) < 2:
338
267
raise BzrCommandError("missing file argument")
339
tree, rel_names = tree_files(names_list)
268
b = Branch.open_containing(names_list[0])
269
270
rel_names = [b.relpath(x) for x in names_list]
340
271
341
272
if os.path.isdir(names_list[-1]):
342
273
# move into existing directory
343
for pair in tree.move(rel_names[:-1], rel_names[-1]):
274
for pair in b.move(rel_names[:-1], rel_names[-1]):
344
275
print "%s => %s" % pair
345
276
else:
346
277
if len(names_list) != 2:
347
278
raise BzrCommandError('to mv multiple files the destination '
348
279
'must be a versioned directory')
349
tree.rename_one(rel_names[0], rel_names[1])
280
b.rename_one(rel_names[0], rel_names[1])
350
281
print "%s => %s" % (rel_names[0], rel_names[1])
351
282
352
283
284
285
353
286
class cmd_pull(Command):
354
287
"""Pull any changes from another branch into the current one.
355
288
356
If there is no default location set, the first pull will set it. After
357
that, you can omit the location to use the default. To change the
358
default, use --remember.
289
If the location is omitted, the last-used location will be used.
290
Both the revision history and the working directory will be
291
updated.
359
292
360
293
This command only works on branches that have not diverged. Branches are
361
294
considered diverged if both branches have had commits without first
362
295
pulling from the other.
363
296
364
297
If branches have diverged, you can use 'bzr merge' to pull the text changes
365
from one into the other. Once one branch has merged, the other should
366
be able to pull it again.
367
368
If you want to forget your local changes and just update your branch to
369
match the remote one, use --overwrite.
298
from one into the other.
370
299
"""
371
takes_options = ['remember', 'overwrite', 'verbose']
372
300
takes_args = ['location?']
373
301
374
def run(self, location=None, remember=False, overwrite=False, verbose=False):
302
def run(self, location=None):
375
303
from bzrlib.merge import merge
304
import tempfile
376
305
from shutil import rmtree
377
306
import errno
378
# FIXME: too much stuff is in the command class
379
tree_to = WorkingTree.open_containing(u'.')[0]
380
stored_loc = tree_to.branch.get_parent()
307
308
br_to = Branch.open_containing('.')
309
stored_loc = br_to.get_parent()
381
310
if location is None:
382
311
if stored_loc is None:
383
312
raise BzrCommandError("No pull location known or specified.")
384
313
else:
385
print "Using saved location: %s" % stored_loc
386
location = stored_loc
387
388
br_from = Branch.open(location)
389
br_to = tree_to.branch
390
391
old_rh = br_to.revision_history()
392
count = tree_to.pull(br_from, overwrite)
393
394
if br_to.get_parent() is None or remember:
395
br_to.set_parent(location)
396
note('%d revision(s) pulled.' % (count,))
397
398
if verbose:
399
new_rh = tree_to.branch.revision_history()
400
if old_rh != new_rh:
401
# Something changed
402
from bzrlib.log import show_changed_revisions
403
show_changed_revisions(tree_to.branch, old_rh, new_rh)
404
405
406
class cmd_push(Command):
407
"""Push this branch into another branch.
408
409
The remote branch will not have its working tree populated because this
410
is both expensive, and may not be supported on the remote file system.
411
412
Some smart servers or protocols *may* put the working tree in place.
413
414
If there is no default push location set, the first push will set it.
415
After that, you can omit the location to use the default. To change the
416
default, use --remember.
417
418
This command only works on branches that have not diverged. Branches are
419
considered diverged if the branch being pushed to is not an older version
420
of this branch.
421
422
If branches have diverged, you can use 'bzr push --overwrite' to replace
423
the other branch completely.
424
425
If you want to ensure you have the different changes in the other branch,
426
do a merge (see bzr help merge) from the other branch, and commit that
427
before doing a 'push --overwrite'.
428
"""
429
takes_options = ['remember', 'overwrite',
430
Option('create-prefix',
431
help='Create the path leading up to the branch '
432
'if it does not already exist')]
433
takes_args = ['location?']
434
435
def run(self, location=None, remember=False, overwrite=False,
436
create_prefix=False, verbose=False):
437
# FIXME: Way too big! Put this into a function called from the
438
# command.
439
import errno
440
from shutil import rmtree
441
from bzrlib.transport import get_transport
442
443
tree_from = WorkingTree.open_containing(u'.')[0]
444
br_from = tree_from.branch
445
stored_loc = tree_from.branch.get_push_location()
446
if location is None:
447
if stored_loc is None:
448
raise BzrCommandError("No push location known or specified.")
449
else:
450
print "Using saved location: %s" % stored_loc
451
location = stored_loc
452
try:
453
br_to = Branch.open(location)
454
except NotBranchError:
455
# create a branch.
456
transport = get_transport(location).clone('..')
457
if not create_prefix:
458
try:
459
transport.mkdir(transport.relpath(location))
460
except NoSuchFile:
461
raise BzrCommandError("Parent directory of %s "
462
"does not exist." % location)
463
else:
464
current = transport.base
465
needed = [(transport, transport.relpath(location))]
466
while needed:
467
try:
468
transport, relpath = needed[-1]
469
transport.mkdir(relpath)
470
needed.pop()
471
except NoSuchFile:
472
new_transport = transport.clone('..')
473
needed.append((new_transport,
474
new_transport.relpath(transport.base)))
475
if new_transport.base == transport.base:
476
raise BzrCommandError("Could not creeate "
477
"path prefix.")
478
br_to = Branch.initialize(location)
479
old_rh = br_to.revision_history()
480
try:
314
print "Using last location: %s" % stored_loc
315
location = stored_loc
316
cache_root = tempfile.mkdtemp()
317
from bzrlib.errors import DivergedBranches
318
br_from = Branch.open_containing(location)
319
location = br_from.base
320
old_revno = br_to.revno()
321
try:
322
from bzrlib.errors import DivergedBranches
323
br_from = Branch.open(location)
324
br_from.setup_caching(cache_root)
325
location = br_from.base
326
old_revno = br_to.revno()
481
327
try:
482
tree_to = br_to.working_tree()
483
except NoWorkingTree:
484
# TODO: This should be updated for branches which don't have a
485
# working tree, as opposed to ones where we just couldn't
486
# update the tree.
487
warning('Unable to update the working tree of: %s' % (br_to.base,))
488
count = br_to.pull(br_from, overwrite)
489
else:
490
count = tree_to.pull(br_from, overwrite)
491
except DivergedBranches:
492
raise BzrCommandError("These branches have diverged."
493
" Try a merge then push with overwrite.")
494
if br_from.get_push_location() is None or remember:
495
br_from.set_push_location(location)
496
note('%d revision(s) pushed.' % (count,))
328
br_to.update_revisions(br_from)
329
except DivergedBranches:
330
raise BzrCommandError("These branches have diverged."
331
" Try merge.")
332
333
merge(('.', -1), ('.', old_revno), check_clean=False)
334
if location != stored_loc:
335
br_to.set_parent(location)
336
finally:
337
rmtree(cache_root)
497
338
498
if verbose:
499
new_rh = br_to.revision_history()
500
if old_rh != new_rh:
501
# Something changed
502
from bzrlib.log import show_changed_revisions
503
show_changed_revisions(br_to, old_rh, new_rh)
504
339
505
340
506
341
class cmd_branch(Command):
511
346
512
347
To retrieve the branch as of a particular revision, supply the --revision
513
348
parameter, as in "branch foo/bar -r 5".
514
515
--basis is to speed up branching from remote branches. When specified, it
516
copies all the file-contents, inventory and revision data from the basis
517
branch before copying anything from the remote branch.
518
349
"""
519
350
takes_args = ['from_location', 'to_location?']
520
takes_options = ['revision', 'basis']
351
takes_options = ['revision']
521
352
aliases = ['get', 'clone']
522
353
523
def run(self, from_location, to_location=None, revision=None, basis=None):
524
from bzrlib.clone import copy_branch
354
def run(self, from_location, to_location=None, revision=None):
355
from bzrlib.branch import copy_branch
356
import tempfile
525
357
import errno
526
358
from shutil import rmtree
527
if revision is None:
528
revision = [None]
529
elif len(revision) > 1:
530
raise BzrCommandError(
531
'bzr branch --revision takes exactly 1 revision value')
532
try:
533
br_from = Branch.open(from_location)
534
except OSError, e:
535
if e.errno == errno.ENOENT:
536
raise BzrCommandError('Source location "%s" does not'
537
' exist.' % to_location)
538
else:
539
raise
540
br_from.lock_read()
541
try:
542
if basis is not None:
543
basis_branch = WorkingTree.open_containing(basis)[0].branch
544
else:
545
basis_branch = None
546
if len(revision) == 1 and revision[0] is not None:
547
revision_id = revision[0].in_history(br_from)[1]
548
else:
549
revision_id = None
359
cache_root = tempfile.mkdtemp()
360
try:
361
if revision is None:
362
revision = [None]
363
elif len(revision) > 1:
364
raise BzrCommandError(
365
'bzr branch --revision takes exactly 1 revision value')
366
try:
367
br_from = Branch.open(from_location)
368
except OSError, e:
369
if e.errno == errno.ENOENT:
370
raise BzrCommandError('Source location "%s" does not'
371
' exist.' % to_location)
372
else:
373
raise
374
br_from.setup_caching(cache_root)
550
375
if to_location is None:
551
376
to_location = os.path.basename(from_location.rstrip("/\\"))
552
name = None
553
else:
554
name = os.path.basename(to_location) + '\n'
555
377
try:
556
378
os.mkdir(to_location)
557
379
except OSError, e:
564
386
else:
565
387
raise
566
388
try:
567
copy_branch(br_from, to_location, revision_id, basis_branch)
389
copy_branch(br_from, to_location, revision[0])
568
390
except bzrlib.errors.NoSuchRevision:
569
391
rmtree(to_location)
570
msg = "The branch %s has no revision %s." % (from_location, revision[0])
571
raise BzrCommandError(msg)
572
except bzrlib.errors.UnlistableBranch:
573
rmtree(to_location)
574
msg = "The branch %s cannot be used as a --basis"
575
raise BzrCommandError(msg)
576
branch = Branch.open(to_location)
577
if name:
578
name = StringIO(name)
579
branch.put_controlfile('branch-name', name)
580
note('Branched %d revision(s).' % branch.revno())
392
msg = "The branch %s has no revision %d." % (from_location, revision[0])
393
raise BzrCommandError(msg)
581
394
finally:
582
br_from.unlock()
395
rmtree(cache_root)
583
396
584
397
585
398
class cmd_renames(Command):
586
399
"""Show list of renamed files.
400
401
TODO: Option to show renames between two historical versions.
402
403
TODO: Only show renames under dir, rather than in the whole branch.
587
404
"""
588
# TODO: Option to show renames between two historical versions.
589
590
# TODO: Only show renames under dir, rather than in the whole branch.
591
405
takes_args = ['dir?']
592
406
593
@display_command
594
def run(self, dir=u'.'):
595
tree = WorkingTree.open_containing(dir)[0]
596
old_inv = tree.branch.basis_tree().inventory
597
new_inv = tree.read_working_inventory()
407
def run(self, dir='.'):
408
b = Branch.open_containing(dir)
409
old_inv = b.basis_tree().inventory
410
new_inv = b.read_working_inventory()
598
411
599
412
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
600
413
renames.sort()
606
419
"""Show statistical information about a branch."""
607
420
takes_args = ['branch?']
608
421
609
@display_command
610
422
def run(self, branch=None):
611
423
import info
612
b = WorkingTree.open_containing(branch)[0].branch
424
425
b = Branch.open_containing(branch)
613
426
info.show_info(b)
614
427
615
428
621
434
"""
622
435
takes_args = ['file+']
623
436
takes_options = ['verbose']
624
aliases = ['rm']
625
437
626
438
def run(self, file_list, verbose=False):
627
tree, file_list = tree_files(file_list)
628
tree.remove(file_list, verbose=verbose)
439
b = Branch.open_containing(file_list[0])
440
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
629
441
630
442
631
443
class cmd_file_id(Command):
637
449
"""
638
450
hidden = True
639
451
takes_args = ['filename']
640
@display_command
641
452
def run(self, filename):
642
tree, relpath = WorkingTree.open_containing(filename)
643
i = tree.inventory.path2id(relpath)
453
b = Branch.open_containing(filename)
454
i = b.inventory.path2id(b.relpath(filename))
644
455
if i == None:
645
456
raise BzrError("%r is not a versioned file" % filename)
646
457
else:
654
465
starting at the branch root."""
655
466
hidden = True
656
467
takes_args = ['filename']
657
@display_command
658
468
def run(self, filename):
659
tree, relpath = WorkingTree.open_containing(filename)
660
inv = tree.inventory
661
fid = inv.path2id(relpath)
469
b = Branch.open_containing(filename)
470
inv = b.inventory
471
fid = inv.path2id(b.relpath(filename))
662
472
if fid == None:
663
473
raise BzrError("%r is not a versioned file" % filename)
664
474
for fip in inv.get_idpath(fid):
668
478
class cmd_revision_history(Command):
669
479
"""Display list of revision ids on this branch."""
670
480
hidden = True
671
@display_command
672
481
def run(self):
673
branch = WorkingTree.open_containing(u'.')[0].branch
674
for patchid in branch.revision_history():
482
for patchid in Branch.open_containing('.').revision_history():
675
483
print patchid
676
484
677
485
678
class cmd_ancestry(Command):
679
"""List all revisions merged into this branch."""
680
hidden = True
681
@display_command
486
class cmd_directories(Command):
487
"""Display list of versioned directories in this branch."""
682
488
def run(self):
683
tree = WorkingTree.open_containing(u'.')[0]
684
b = tree.branch
685
# FIXME. should be tree.last_revision
686
for revision_id in b.get_ancestry(b.last_revision()):
687
print revision_id
489
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
490
if name == '':
491
print '.'
492
else:
493
print name
688
494
689
495
690
496
class cmd_init(Command):
696
502
Recipe for importing a tree of files:
697
503
cd ~/project
698
504
bzr init
699
bzr add .
505
bzr add -v .
700
506
bzr status
701
507
bzr commit -m 'imported project'
702
508
"""
703
takes_args = ['location?']
704
def run(self, location=None):
509
def run(self):
705
510
from bzrlib.branch import Branch
706
if location is None:
707
location = u'.'
708
else:
709
# The path has to exist to initialize a
710
# branch inside of it.
711
# Just using os.mkdir, since I don't
712
# believe that we want to create a bunch of
713
# locations if the user supplies an extended path
714
if not os.path.exists(location):
715
os.mkdir(location)
716
Branch.initialize(location)
511
Branch.initialize('.')
717
512
718
513
719
514
class cmd_diff(Command):
722
517
If files are listed, only the changes in those files are listed.
723
518
Otherwise, all changes for the tree are listed.
724
519
520
TODO: Allow diff across branches.
521
522
TODO: Option to use external diff command; could be GNU diff, wdiff,
523
or a graphical diff.
524
525
TODO: Python difflib is not exactly the same as unidiff; should
526
either fix it up or prefer to use an external diff.
527
528
TODO: If a directory is given, diff everything under that.
529
530
TODO: Selected-file diff is inefficient and doesn't show you
531
deleted files.
532
533
TODO: This probably handles non-Unix newlines poorly.
534
725
535
examples:
726
536
bzr diff
727
537
bzr diff -r1
728
538
bzr diff -r1..2
729
539
"""
730
# TODO: Allow diff across branches.
731
# TODO: Option to use external diff command; could be GNU diff, wdiff,
732
# or a graphical diff.
733
734
# TODO: Python difflib is not exactly the same as unidiff; should
735
# either fix it up or prefer to use an external diff.
736
737
# TODO: If a directory is given, diff everything under that.
738
739
# TODO: Selected-file diff is inefficient and doesn't show you
740
# deleted files.
741
742
# TODO: This probably handles non-Unix newlines poorly.
743
540
744
541
takes_args = ['file*']
745
542
takes_options = ['revision', 'diff-options']
746
543
aliases = ['di', 'dif']
747
544
748
@display_command
749
545
def run(self, revision=None, file_list=None, diff_options=None):
750
546
from bzrlib.diff import show_diff
751
try:
752
tree, file_list = internal_tree_files(file_list)
753
b = None
754
b2 = None
755
except FileInWrongBranch:
756
if len(file_list) != 2:
757
raise BzrCommandError("Files are in different branches")
758
759
b, file1 = Branch.open_containing(file_list[0])
760
b2, file2 = Branch.open_containing(file_list[1])
761
if file1 != "" or file2 != "":
762
# FIXME diff those two files. rbc 20051123
763
raise BzrCommandError("Files are in different branches")
764
file_list = None
547
548
if file_list:
549
b = Branch.open_containing(file_list[0])
550
file_list = [b.relpath(f) for f in file_list]
551
if file_list == ['']:
552
# just pointing to top-of-tree
553
file_list = None
554
else:
555
b = Branch.open_containing('.')
556
765
557
if revision is not None:
766
if b2 is not None:
767
raise BzrCommandError("Can't specify -r with two branches")
768
558
if len(revision) == 1:
769
return show_diff(tree.branch, revision[0], specific_files=file_list,
770
external_diff_options=diff_options)
559
show_diff(b, revision[0], specific_files=file_list,
560
external_diff_options=diff_options)
771
561
elif len(revision) == 2:
772
return show_diff(tree.branch, revision[0], specific_files=file_list,
773
external_diff_options=diff_options,
774
revision2=revision[1])
562
show_diff(b, revision[0], specific_files=file_list,
563
external_diff_options=diff_options,
564
revision2=revision[1])
775
565
else:
776
566
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
777
567
else:
778
if b is not None:
779
return show_diff(b, None, specific_files=file_list,
780
external_diff_options=diff_options, b2=b2)
781
else:
782
return show_diff(tree.branch, None, specific_files=file_list,
783
external_diff_options=diff_options)
568
show_diff(b, None, specific_files=file_list,
569
external_diff_options=diff_options)
570
571
784
572
785
573
786
574
class cmd_deleted(Command):
787
575
"""List files deleted in the working tree.
576
577
TODO: Show files deleted since a previous revision, or between two revisions.
788
578
"""
789
# TODO: Show files deleted since a previous revision, or
790
# between two revisions.
791
# TODO: Much more efficient way to do this: read in new
792
# directories with readdir, rather than stating each one. Same
793
# level of effort but possibly much less IO. (Or possibly not,
794
# if the directories are very large...)
795
@display_command
796
579
def run(self, show_ids=False):
797
tree = WorkingTree.open_containing(u'.')[0]
798
old = tree.branch.basis_tree()
580
b = Branch.open_containing('.')
581
old = b.basis_tree()
582
new = b.working_tree()
583
584
## TODO: Much more efficient way to do this: read in new
585
## directories with readdir, rather than stating each one. Same
586
## level of effort but possibly much less IO. (Or possibly not,
587
## if the directories are very large...)
588
799
589
for path, ie in old.inventory.iter_entries():
800
if not tree.has_id(ie.file_id):
590
if not new.has_id(ie.file_id):
801
591
if show_ids:
802
592
print '%-50s %s' % (path, ie.file_id)
803
593
else:
807
597
class cmd_modified(Command):
808
598
"""List files modified in working tree."""
809
599
hidden = True
810
@display_command
811
600
def run(self):
812
601
from bzrlib.delta import compare_trees
813
602
814
tree = WorkingTree.open_containing(u'.')[0]
815
td = compare_trees(tree.branch.basis_tree(), tree)
603
b = Branch.open_containing('.')
604
td = compare_trees(b.basis_tree(), b.working_tree())
816
605
817
for path, id, kind, text_modified, meta_modified in td.modified:
606
for path, id, kind in td.modified:
818
607
print path
819
608
820
609
822
611
class cmd_added(Command):
823
612
"""List files added in working tree."""
824
613
hidden = True
825
@display_command
826
614
def run(self):
827
wt = WorkingTree.open_containing(u'.')[0]
828
basis_inv = wt.branch.basis_tree().inventory
615
b = Branch.open_containing('.')
616
wt = b.working_tree()
617
basis_inv = b.basis_tree().inventory
829
618
inv = wt.inventory
830
619
for file_id in inv:
831
620
if file_id in basis_inv:
843
632
The root is the nearest enclosing directory with a .bzr control
844
633
directory."""
845
634
takes_args = ['filename?']
846
@display_command
847
635
def run(self, filename=None):
848
636
"""Print the branch root."""
849
tree = WorkingTree.open_containing(filename)[0]
850
print tree.basedir
637
b = Branch.open_containing(filename)
638
print b.base
851
639
852
640
853
641
class cmd_log(Command):
854
642
"""Show log of this branch.
855
643
856
To request a range of logs, you can use the command -r begin..end
857
-r revision requests a specific revision, -r ..end or -r begin.. are
644
To request a range of logs, you can use the command -r begin:end
645
-r revision requests a specific revision, -r :end or -r begin: are
858
646
also valid.
647
648
--message allows you to give a regular expression, which will be evaluated
649
so that only matching entries will be displayed.
650
651
TODO: Make --revision support uuid: and hash: [future tag:] notation.
652
859
653
"""
860
654
861
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
862
863
655
takes_args = ['filename?']
864
takes_options = [Option('forward',
865
help='show from oldest to newest'),
866
'timezone', 'verbose',
867
'show-ids', 'revision',
868
Option('line', help='format with one line per revision'),
869
'long',
870
Option('message',
871
help='show revisions whose message matches this regexp',
872
type=str),
873
Option('short', help='use moderately short format'),
874
]
875
@display_command
656
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
657
'long', 'message', 'short',]
658
876
659
def run(self, filename=None, timezone='original',
877
660
verbose=False,
878
661
show_ids=False,
880
663
revision=None,
881
664
message=None,
882
665
long=False,
883
short=False,
884
line=False):
666
short=False):
885
667
from bzrlib.log import log_formatter, show_log
886
668
import codecs
887
assert message is None or isinstance(message, basestring), \
888
"invalid message argument %r" % message
669
889
670
direction = (forward and 'forward') or 'reverse'
890
671
891
672
if filename:
892
# might be a tree:
893
tree = None
894
try:
895
tree, fp = WorkingTree.open_containing(filename)
896
b = tree.branch
897
if fp != '':
898
inv = tree.read_working_inventory()
899
except NotBranchError:
900
pass
901
if tree is None:
902
b, fp = Branch.open_containing(filename)
903
if fp != '':
904
inv = b.get_inventory(b.last_revision())
905
if fp != '':
906
file_id = inv.path2id(fp)
673
b = Branch.open_containing(filename)
674
fp = b.relpath(filename)
675
if fp:
676
file_id = b.read_working_inventory().path2id(fp)
907
677
else:
908
678
file_id = None # points to branch root
909
679
else:
910
tree, relpath = WorkingTree.open_containing(u'.')
911
b = tree.branch
680
b = Branch.open_containing('.')
912
681
file_id = None
913
682
914
683
if revision is None:
922
691
else:
923
692
raise BzrCommandError('bzr log --revision takes one or two values.')
924
693
925
# By this point, the revision numbers are converted to the +ve
926
# form if they were supplied in the -ve form, so we can do
927
# this comparison in relative safety
928
if rev1 > rev2:
929
(rev2, rev1) = (rev1, rev2)
694
if rev1 == 0:
695
rev1 = None
696
if rev2 == 0:
697
rev2 = None
930
698
931
mutter('encoding log as %r', bzrlib.user_encoding)
699
mutter('encoding log as %r' % bzrlib.user_encoding)
932
700
933
701
# use 'replace' so that we don't abort if trying to write out
934
702
# in e.g. the default C locale.
935
703
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
936
704
937
log_format = 'long'
938
if short:
705
if not short:
706
log_format = 'long'
707
else:
939
708
log_format = 'short'
940
if line:
941
log_format = 'line'
942
709
lf = log_formatter(log_format,
943
710
show_ids=show_ids,
944
711
to_file=outf,
961
728
A more user-friendly interface is "bzr log FILE"."""
962
729
hidden = True
963
730
takes_args = ["filename"]
964
@display_command
965
731
def run(self, filename):
966
tree, relpath = WorkingTree.open_containing(filename)
967
b = tree.branch
968
inv = tree.read_working_inventory()
969
file_id = inv.path2id(relpath)
732
b = Branch.open_containing(filename)
733
inv = b.read_working_inventory()
734
file_id = inv.path2id(b.relpath(filename))
970
735
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
971
736
print "%6d %s" % (revno, what)
972
737
973
738
974
739
class cmd_ls(Command):
975
740
"""List files in a tree.
741
742
TODO: Take a revision or remote path and list that tree instead.
976
743
"""
977
# TODO: Take a revision or remote path and list that tree instead.
978
744
hidden = True
979
takes_options = ['verbose', 'revision',
980
Option('non-recursive',
981
help='don\'t recurse into sub-directories'),
982
Option('from-root',
983
help='Print all paths from the root of the branch.'),
984
Option('unknown', help='Print unknown files'),
985
Option('versioned', help='Print versioned files'),
986
Option('ignored', help='Print ignored files'),
987
988
Option('null', help='Null separate the files'),
989
]
990
@display_command
991
def run(self, revision=None, verbose=False,
992
non_recursive=False, from_root=False,
993
unknown=False, versioned=False, ignored=False,
994
null=False):
995
996
if verbose and null:
997
raise BzrCommandError('Cannot set both --verbose and --null')
998
all = not (unknown or versioned or ignored)
999
1000
selection = {'I':ignored, '?':unknown, 'V':versioned}
1001
1002
tree, relpath = WorkingTree.open_containing(u'.')
1003
if from_root:
1004
relpath = u''
1005
elif relpath:
1006
relpath += '/'
1007
if revision is not None:
1008
tree = tree.branch.revision_tree(
1009
revision[0].in_history(tree.branch).rev_id)
1010
for fp, fc, kind, fid, entry in tree.list_files():
1011
if fp.startswith(relpath):
1012
fp = fp[len(relpath):]
1013
if non_recursive and '/' in fp:
1014
continue
1015
if not all and not selection[fc]:
1016
continue
1017
if verbose:
1018
kindch = entry.kind_character()
1019
print '%-8s %s%s' % (fc, fp, kindch)
1020
elif null:
1021
sys.stdout.write(fp)
1022
sys.stdout.write('\0')
1023
sys.stdout.flush()
745
def run(self, revision=None, verbose=False):
746
b = Branch.open_containing('.')
747
if revision == None:
748
tree = b.working_tree()
749
else:
750
tree = b.revision_tree(revision.in_history(b).rev_id)
751
752
for fp, fc, kind, fid in tree.list_files():
753
if verbose:
754
if kind == 'directory':
755
kindch = '/'
756
elif kind == 'file':
757
kindch = ''
1024
758
else:
1025
print fp
759
kindch = '???'
760
761
print '%-8s %s%s' % (fc, fp, kindch)
762
else:
763
print fp
764
1026
765
1027
766
1028
767
class cmd_unknowns(Command):
1029
768
"""List unknown files."""
1030
@display_command
1031
769
def run(self):
1032
770
from bzrlib.osutils import quotefn
1033
for f in WorkingTree.open_containing(u'.')[0].unknowns():
771
for f in Branch.open_containing('.').unknowns():
1034
772
print quotefn(f)
1035
773
1036
774
775
1037
776
class cmd_ignore(Command):
1038
777
"""Ignore a command or pattern.
1039
778
1040
779
To remove patterns from the ignore list, edit the .bzrignore file.
1041
780
1042
781
If the pattern contains a slash, it is compared to the whole path
1043
from the branch root. Otherwise, it is compared to only the last
1044
component of the path. To match a file only in the root directory,
1045
prepend './'.
782
from the branch root. Otherwise, it is comapred to only the last
783
component of the path.
1046
784
1047
785
Ignore patterns are case-insensitive on case-insensitive systems.
1048
786
1052
790
bzr ignore ./Makefile
1053
791
bzr ignore '*.class'
1054
792
"""
1055
# TODO: Complain if the filename is absolute
1056
793
takes_args = ['name_pattern']
1057
794
1058
795
def run(self, name_pattern):
1059
796
from bzrlib.atomicfile import AtomicFile
1060
797
import os.path
1061
798
1062
tree, relpath = WorkingTree.open_containing(u'.')
1063
ifn = tree.abspath('.bzrignore')
799
b = Branch.open_containing('.')
800
ifn = b.abspath('.bzrignore')
1064
801
1065
802
if os.path.exists(ifn):
1066
803
f = open(ifn, 'rt')
1085
822
finally:
1086
823
f.close()
1087
824
1088
inv = tree.inventory
825
inv = b.working_tree().inventory
1089
826
if inv.path2id('.bzrignore'):
1090
827
mutter('.bzrignore is already versioned')
1091
828
else:
1092
829
mutter('need to make new .bzrignore file versioned')
1093
tree.add(['.bzrignore'])
830
b.add(['.bzrignore'])
831
1094
832
1095
833
1096
834
class cmd_ignored(Command):
1097
835
"""List ignored files and the patterns that matched them.
1098
836
1099
837
See also: bzr ignore"""
1100
@display_command
1101
838
def run(self):
1102
tree = WorkingTree.open_containing(u'.')[0]
1103
for path, file_class, kind, file_id, entry in tree.list_files():
839
tree = Branch.open_containing('.').working_tree()
840
for path, file_class, kind, file_id in tree.list_files():
1104
841
if file_class != 'I':
1105
842
continue
1106
843
## XXX: Slightly inefficient since this was already calculated
1117
854
hidden = True
1118
855
takes_args = ['revno']
1119
856
1120
@display_command
1121
857
def run(self, revno):
1122
858
try:
1123
859
revno = int(revno)
1124
860
except ValueError:
1125
861
raise BzrCommandError("not a valid revision-number: %r" % revno)
1126
862
1127
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
863
print Branch.open_containing('.').get_rev_id(revno)
1128
864
1129
865
1130
866
class cmd_export(Command):
1137
873
is found exports to a directory (equivalent to --format=dir).
1138
874
1139
875
Root may be the top directory for tar, tgz and tbz2 formats. If none
1140
is given, the top directory will be the root name of the file.
1141
1142
Note: export of tree with non-ascii filenames to zip is not supported.
1143
1144
Supported formats Autodetected by extension
1145
----------------- -------------------------
1146
dir -
1147
tar .tar
1148
tbz2 .tar.bz2, .tbz2
1149
tgz .tar.gz, .tgz
1150
zip .zip
1151
"""
876
is given, the top directory will be the root name of the file."""
877
# TODO: list known exporters
1152
878
takes_args = ['dest']
1153
879
takes_options = ['revision', 'format', 'root']
1154
880
def run(self, dest, revision=None, format=None, root=None):
1155
881
import os.path
1156
from bzrlib.export import export
1157
tree = WorkingTree.open_containing(u'.')[0]
1158
b = tree.branch
882
b = Branch.open_containing('.')
1159
883
if revision is None:
1160
# should be tree.last_revision FIXME
1161
rev_id = b.last_revision()
884
rev_id = b.last_patch()
1162
885
else:
1163
886
if len(revision) != 1:
1164
887
raise BzrError('bzr export --revision takes exactly 1 argument')
1165
888
rev_id = revision[0].in_history(b).rev_id
1166
889
t = b.revision_tree(rev_id)
1167
try:
1168
export(t, dest, format, root)
1169
except errors.NoSuchExportFormat, e:
1170
raise BzrCommandError('Unsupported export format: %s' % e.format)
890
root, ext = os.path.splitext(dest)
891
if not format:
892
if ext in (".tar",):
893
format = "tar"
894
elif ext in (".gz", ".tgz"):
895
format = "tgz"
896
elif ext in (".bz2", ".tbz2"):
897
format = "tbz2"
898
else:
899
format = "dir"
900
t.export(dest, format, root)
1171
901
1172
902
1173
903
class cmd_cat(Command):
1176
906
takes_options = ['revision']
1177
907
takes_args = ['filename']
1178
908
1179
@display_command
1180
909
def run(self, filename, revision=None):
1181
if revision is not None and len(revision) != 1:
910
if revision is None:
911
raise BzrCommandError("bzr cat requires a revision number")
912
elif len(revision) != 1:
1182
913
raise BzrCommandError("bzr cat --revision takes exactly one number")
1183
tree = None
1184
try:
1185
tree, relpath = WorkingTree.open_containing(filename)
1186
b = tree.branch
1187
except NotBranchError:
1188
pass
1189
1190
if tree is None:
1191
b, relpath = Branch.open_containing(filename)
1192
if revision is None:
1193
revision_id = b.last_revision()
1194
else:
1195
revision_id = revision[0].in_history(b).rev_id
1196
b.print_file(relpath, revision_id)
914
b = Branch.open_containing('.')
915
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
1197
916
1198
917
1199
918
class cmd_local_time_offset(Command):
1200
919
"""Show the offset in seconds from GMT to local time."""
1201
920
hidden = True
1202
@display_command
1203
921
def run(self):
1204
922
print bzrlib.osutils.local_time_offset()
1205
923
1217
935
A selected-file commit may fail in some cases where the committed
1218
936
tree would be invalid, such as trying to commit a file in a
1219
937
newly-added directory that is not itself committed.
938
939
TODO: Run hooks on tree to-be-committed, and after commit.
940
941
TODO: Strict commit that fails if there are unknown or deleted files.
1220
942
"""
1221
# TODO: Run hooks on tree to-be-committed, and after commit.
1222
1223
# TODO: Strict commit that fails if there are deleted files.
1224
# (what does "deleted files" mean ??)
1225
1226
# TODO: Give better message for -s, --summary, used by tla people
1227
1228
# XXX: verbose currently does nothing
1229
1230
943
takes_args = ['selected*']
1231
takes_options = ['message', 'verbose',
1232
Option('unchanged',
1233
help='commit even if nothing has changed'),
1234
Option('file', type=str,
1235
argname='msgfile',
1236
help='file containing commit message'),
1237
Option('strict',
1238
help="refuse to commit if there are unknown "
1239
"files in the working tree."),
1240
]
944
takes_options = ['message', 'file', 'verbose', 'unchanged']
1241
945
aliases = ['ci', 'checkin']
1242
946
947
# TODO: Give better message for -s, --summary, used by tla people
948
1243
949
def run(self, message=None, file=None, verbose=True, selected_list=None,
1244
unchanged=False, strict=False):
1245
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1246
StrictCommitFailed)
1247
from bzrlib.msgeditor import edit_commit_message, \
1248
make_commit_message_template
950
unchanged=False):
951
from bzrlib.errors import PointlessCommit
952
from bzrlib.msgeditor import edit_commit_message
1249
953
from bzrlib.status import show_status
1250
from tempfile import TemporaryFile
1251
import codecs
1252
1253
# TODO: Need a blackbox test for invoking the external editor; may be
1254
# slightly problematic to run this cross-platform.
1255
1256
# TODO: do more checks that the commit will succeed before
1257
# spending the user's valuable time typing a commit message.
1258
#
1259
# TODO: if the commit *does* happen to fail, then save the commit
1260
# message to a temporary file where it can be recovered
1261
tree, selected_list = tree_files(selected_list)
1262
if message is None and not file:
1263
template = make_commit_message_template(tree, selected_list)
1264
message = edit_commit_message(template)
954
from cStringIO import StringIO
955
956
b = Branch.open_containing('.')
957
if selected_list:
958
selected_list = [b.relpath(s) for s in selected_list]
959
960
if not message and not file:
961
catcher = StringIO()
962
show_status(b, specific_files=selected_list,
963
to_file=catcher)
964
message = edit_commit_message(catcher.getvalue())
965
1265
966
if message is None:
1266
967
raise BzrCommandError("please specify a commit message"
1267
968
" with either --message or --file")
1272
973
import codecs
1273
974
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1274
975
1275
if message == "":
1276
raise BzrCommandError("empty commit message specified")
1277
1278
976
try:
1279
tree.commit(message, specific_files=selected_list,
1280
allow_pointless=unchanged, strict=strict)
977
b.commit(message, verbose=verbose,
978
specific_files=selected_list,
979
allow_pointless=unchanged)
1281
980
except PointlessCommit:
1282
981
# FIXME: This should really happen before the file is read in;
1283
982
# perhaps prepare the commit; get the message; then actually commit
1284
983
raise BzrCommandError("no changes to commit",
1285
984
["use --unchanged to commit anyhow"])
1286
except ConflictsInTree:
1287
raise BzrCommandError("Conflicts detected in working tree. "
1288
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1289
except StrictCommitFailed:
1290
raise BzrCommandError("Commit refused because there are unknown "
1291
"files in the working tree.")
1292
note('Committed revision %d.' % (tree.branch.revno(),))
1293
985
1294
986
1295
987
class cmd_check(Command):
1298
990
This command checks various invariants about the branch storage to
1299
991
detect data corruption or bzr bugs.
1300
992
"""
1301
takes_args = ['branch?']
1302
takes_options = ['verbose']
993
takes_args = ['dir?']
1303
994
1304
def run(self, branch=None, verbose=False):
995
def run(self, dir='.'):
1305
996
from bzrlib.check import check
1306
if branch is None:
1307
tree = WorkingTree.open_containing()[0]
1308
branch = tree.branch
1309
else:
1310
branch = Branch.open(branch)
1311
check(branch, verbose)
997
998
check(Branch.open_containing(dir))
1312
999
1313
1000
1314
1001
class cmd_scan_cache(Command):
1316
1003
def run(self):
1317
1004
from bzrlib.hashcache import HashCache
1318
1005
1319
c = HashCache(u'.')
1006
c = HashCache('.')
1320
1007
c.read()
1321
1008
c.scan()
1322
1009
1336
1023
1337
1024
The check command or bzr developers may sometimes advise you to run
1338
1025
this command.
1339
1340
This version of this command upgrades from the full-text storage
1341
used by bzr 0.0.8 and earlier to the weave format (v5).
1342
1026
"""
1343
1027
takes_args = ['dir?']
1344
1028
1345
def run(self, dir=u'.'):
1029
def run(self, dir='.'):
1346
1030
from bzrlib.upgrade import upgrade
1347
upgrade(dir)
1031
upgrade(Branch.open_containing(dir))
1032
1348
1033
1349
1034
1350
1035
class cmd_whoami(Command):
1351
1036
"""Show bzr user id."""
1352
1037
takes_options = ['email']
1353
1038
1354
@display_command
1355
1039
def run(self, email=False):
1356
1040
try:
1357
b = WorkingTree.open_containing(u'.')[0].branch
1358
config = bzrlib.config.BranchConfig(b)
1359
except NotBranchError:
1360
config = bzrlib.config.GlobalConfig()
1041
b = bzrlib.branch.Branch.open_containing('.')
1042
except:
1043
b = None
1361
1044
1362
1045
if email:
1363
print config.user_email()
1364
else:
1365
print config.username()
1366
1367
class cmd_nick(Command):
1368
"""\
1369
Print or set the branch nickname.
1370
If unset, the tree root directory name is used as the nickname
1371
To print the current nickname, execute with no argument.
1372
"""
1373
takes_args = ['nickname?']
1374
def run(self, nickname=None):
1375
branch = Branch.open_containing(u'.')[0]
1376
if nickname is None:
1377
self.printme(branch)
1378
else:
1379
branch.nick = nickname
1380
1381
@display_command
1382
def printme(self, branch):
1383
print branch.nick
1046
print bzrlib.osutils.user_email(b)
1047
else:
1048
print bzrlib.osutils.username(b)
1049
1384
1050
1385
1051
class cmd_selftest(Command):
1386
"""Run internal test suite.
1387
1388
This creates temporary test directories in the working directory,
1389
but not existing data is affected. These directories are deleted
1390
if the tests pass, or left behind to help in debugging if they
1391
fail and --keep-output is specified.
1392
1393
If arguments are given, they are regular expressions that say
1394
which tests should run.
1395
"""
1396
# TODO: --list should give a list of all available tests
1052
"""Run internal test suite"""
1397
1053
hidden = True
1398
takes_args = ['testspecs*']
1399
takes_options = ['verbose',
1400
Option('one', help='stop when one test fails'),
1401
Option('keep-output',
1402
help='keep output directories when tests fail')
1403
]
1404
1405
def run(self, testspecs_list=None, verbose=False, one=False,
1406
keep_output=False):
1054
takes_options = ['verbose', 'pattern']
1055
def run(self, verbose=False, pattern=".*"):
1407
1056
import bzrlib.ui
1408
from bzrlib.tests import selftest
1057
from bzrlib.selftest import selftest
1409
1058
# we don't want progress meters from the tests to go to the
1410
1059
# real output; and we don't want log messages cluttering up
1411
1060
# the real logs.
1413
1062
bzrlib.trace.info('running tests...')
1414
1063
try:
1415
1064
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1416
if testspecs_list is not None:
1417
pattern = '|'.join(testspecs_list)
1418
else:
1419
pattern = ".*"
1420
result = selftest(verbose=verbose,
1421
pattern=pattern,
1422
stop_on_failure=one,
1423
keep_output=keep_output)
1065
result = selftest(verbose=verbose, pattern=pattern)
1424
1066
if result:
1425
1067
bzrlib.trace.info('tests passed')
1426
1068
else:
1446
1088
1447
1089
class cmd_version(Command):
1448
1090
"""Show version of bzr."""
1449
@display_command
1450
1091
def run(self):
1451
1092
show_version()
1452
1093
1453
1094
class cmd_rocks(Command):
1454
1095
"""Statement of optimism."""
1455
1096
hidden = True
1456
@display_command
1457
1097
def run(self):
1458
1098
print "it sure does!"
1459
1099
1460
1100
1461
1101
class cmd_find_merge_base(Command):
1462
1102
"""Find and print a base revision for merging two branches.
1103
1104
TODO: Options to specify revisions on either side, as if
1105
merging only part of the history.
1463
1106
"""
1464
# TODO: Options to specify revisions on either side, as if
1465
# merging only part of the history.
1466
1107
takes_args = ['branch', 'other']
1467
1108
hidden = True
1468
1109
1469
@display_command
1470
1110
def run(self, branch, other):
1471
1111
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1472
1112
1473
branch1 = Branch.open_containing(branch)[0]
1474
branch2 = Branch.open_containing(other)[0]
1113
branch1 = Branch.open_containing(branch)
1114
branch2 = Branch.open_containing(other)
1475
1115
1476
1116
history_1 = branch1.revision_history()
1477
1117
history_2 = branch2.revision_history()
1478
1118
1479
last1 = branch1.last_revision()
1480
last2 = branch2.last_revision()
1119
last1 = branch1.last_patch()
1120
last2 = branch2.last_patch()
1481
1121
1482
1122
source = MultipleRevisionSources(branch1, branch2)
1483
1123
1526
1166
--force is given.
1527
1167
"""
1528
1168
takes_args = ['branch?']
1529
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1530
Option('show-base', help="Show base revision text in "
1531
"conflicts")]
1169
takes_options = ['revision', 'force', 'merge-type']
1532
1170
1533
def run(self, branch=None, revision=None, force=False, merge_type=None,
1534
show_base=False, reprocess=False):
1171
def run(self, branch='.', revision=None, force=False,
1172
merge_type=None):
1535
1173
from bzrlib.merge import merge
1536
1174
from bzrlib.merge_core import ApplyMerge3
1537
1175
if merge_type is None:
1538
1176
merge_type = ApplyMerge3
1539
if branch is None:
1540
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1541
if branch is None:
1542
raise BzrCommandError("No merge location known or specified.")
1543
else:
1544
print "Using saved location: %s" % branch
1177
1545
1178
if revision is None or len(revision) < 1:
1546
1179
base = [None, None]
1547
1180
other = [branch, -1]
1548
1181
else:
1549
1182
if len(revision) == 1:
1550
1183
base = [None, None]
1551
other_branch = Branch.open_containing(branch)[0]
1552
revno = revision[0].in_history(other_branch).revno
1553
other = [branch, revno]
1184
other = [branch, revision[0].in_history(branch).revno]
1554
1185
else:
1555
1186
assert len(revision) == 2
1556
1187
if None in revision:
1557
1188
raise BzrCommandError(
1558
1189
"Merge doesn't permit that revision specifier.")
1559
b = Branch.open_containing(branch)[0]
1560
1561
base = [branch, revision[0].in_history(b).revno]
1562
other = [branch, revision[1].in_history(b).revno]
1190
base = [branch, revision[0].in_history(branch).revno]
1191
other = [branch, revision[1].in_history(branch).revno]
1563
1192
1564
1193
try:
1565
conflict_count = merge(other, base, check_clean=(not force),
1566
merge_type=merge_type, reprocess=reprocess,
1567
show_base=show_base)
1568
if conflict_count != 0:
1569
return 1
1570
else:
1571
return 0
1194
merge(other, base, check_clean=(not force), merge_type=merge_type)
1572
1195
except bzrlib.errors.AmbiguousBase, e:
1573
1196
m = ("sorry, bzr can't determine the right merge base yet\n"
1574
1197
"candidates are:\n "
1579
1202
log_error(m)
1580
1203
1581
1204
1582
class cmd_remerge(Command):
1583
"""Redo a merge.
1584
"""
1585
takes_args = ['file*']
1586
takes_options = ['merge-type', 'reprocess',
1587
Option('show-base', help="Show base revision text in "
1588
"conflicts")]
1589
1590
def run(self, file_list=None, merge_type=None, show_base=False,
1591
reprocess=False):
1592
from bzrlib.merge import merge_inner, transform_tree
1593
from bzrlib.merge_core import ApplyMerge3
1594
if merge_type is None:
1595
merge_type = ApplyMerge3
1596
tree, file_list = tree_files(file_list)
1597
tree.lock_write()
1598
try:
1599
pending_merges = tree.pending_merges()
1600
if len(pending_merges) != 1:
1601
raise BzrCommandError("Sorry, remerge only works after normal"
1602
+ " merges. Not cherrypicking or"
1603
+ "multi-merges.")
1604
base_revision = common_ancestor(tree.branch.last_revision(),
1605
pending_merges[0], tree.branch)
1606
base_tree = tree.branch.revision_tree(base_revision)
1607
other_tree = tree.branch.revision_tree(pending_merges[0])
1608
interesting_ids = None
1609
if file_list is not None:
1610
interesting_ids = set()
1611
for filename in file_list:
1612
file_id = tree.path2id(filename)
1613
interesting_ids.add(file_id)
1614
if tree.kind(file_id) != "directory":
1615
continue
1616
1617
for name, ie in tree.inventory.iter_entries(file_id):
1618
interesting_ids.add(ie.file_id)
1619
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1620
if file_list is None:
1621
restore_files = list(tree.iter_conflicts())
1622
else:
1623
restore_files = file_list
1624
for filename in restore_files:
1625
try:
1626
restore(tree.abspath(filename))
1627
except NotConflicted:
1628
pass
1629
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1630
interesting_ids = interesting_ids,
1631
other_rev_id=pending_merges[0],
1632
merge_type=merge_type,
1633
show_base=show_base,
1634
reprocess=reprocess)
1635
finally:
1636
tree.unlock()
1637
if conflicts > 0:
1638
return 1
1639
else:
1640
return 0
1641
1642
1205
class cmd_revert(Command):
1643
1206
"""Reverse all changes since the last commit.
1644
1207
1651
1214
aliases = ['merge-revert']
1652
1215
1653
1216
def run(self, revision=None, no_backup=False, file_list=None):
1654
from bzrlib.merge import merge_inner
1217
from bzrlib.merge import merge
1218
from bzrlib.branch import Branch
1655
1219
from bzrlib.commands import parse_spec
1220
1656
1221
if file_list is not None:
1657
1222
if len(file_list) == 0:
1658
1223
raise BzrCommandError("No files specified")
1659
else:
1660
file_list = []
1661
1224
if revision is None:
1662
revno = -1
1663
tree = WorkingTree.open_containing(u'.')[0]
1664
# FIXME should be tree.last_revision
1665
rev_id = tree.branch.last_revision()
1225
revision = [-1]
1666
1226
elif len(revision) != 1:
1667
1227
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1668
else:
1669
tree, file_list = tree_files(file_list)
1670
rev_id = revision[0].in_history(tree.branch).rev_id
1671
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1672
not no_backup)
1228
merge(('.', revision[0]), parse_spec('.'),
1229
check_clean=False,
1230
ignore_zero=True,
1231
backup_files=not no_backup,
1232
file_list=file_list)
1233
if not file_list:
1234
Branch.open_containing('.').set_pending_merges([])
1673
1235
1674
1236
1675
1237
class cmd_assert_fail(Command):
1687
1249
takes_args = ['topic?']
1688
1250
aliases = ['?']
1689
1251
1690
@display_command
1691
1252
def run(self, topic=None, long=False):
1692
1253
import help
1693
1254
if topic is None and long:
1703
1264
aliases = ['s-c']
1704
1265
hidden = True
1705
1266
1706
@display_command
1707
1267
def run(self, context=None):
1708
1268
import shellcomplete
1709
1269
shellcomplete.shellcomplete(context)
1710
1270
1711
1271
1712
class cmd_fetch(Command):
1713
"""Copy in history from another branch but don't merge it.
1714
1715
This is an internal method used for pull and merge."""
1716
hidden = True
1717
takes_args = ['from_branch', 'to_branch']
1718
def run(self, from_branch, to_branch):
1719
from bzrlib.fetch import Fetcher
1720
from bzrlib.branch import Branch
1721
from_b = Branch.open(from_branch)
1722
to_b = Branch.open(to_branch)
1723
from_b.lock_read()
1724
try:
1725
to_b.lock_write()
1726
try:
1727
Fetcher(to_b, from_b)
1728
finally:
1729
to_b.unlock()
1730
finally:
1731
from_b.unlock()
1732
1733
1734
1272
class cmd_missing(Command):
1735
1273
"""What is missing in this branch relative to other branch.
1736
1274
"""
1737
# TODO: rewrite this in terms of ancestry so that it shows only
1738
# unmerged things
1739
1740
1275
takes_args = ['remote?']
1741
1276
aliases = ['mis', 'miss']
1742
takes_options = ['verbose']
1277
# We don't have to add quiet to the list, because
1278
# unknown options are parsed as booleans
1279
takes_options = ['verbose', 'quiet']
1743
1280
1744
@display_command
1745
def run(self, remote=None, verbose=False):
1281
def run(self, remote=None, verbose=False, quiet=False):
1746
1282
from bzrlib.errors import BzrCommandError
1747
1283
from bzrlib.missing import show_missing
1748
1284
1749
if verbose and is_quiet():
1285
if verbose and quiet:
1750
1286
raise BzrCommandError('Cannot pass both quiet and verbose')
1751
1287
1752
tree = WorkingTree.open_containing(u'.')[0]
1753
parent = tree.branch.get_parent()
1288
b = Branch.open_containing('.')
1289
parent = b.get_parent()
1754
1290
if remote is None:
1755
1291
if parent is None:
1756
1292
raise BzrCommandError("No missing location known or specified.")
1757
1293
else:
1758
if not is_quiet():
1294
if not quiet:
1759
1295
print "Using last location: %s" % parent
1760
1296
remote = parent
1761
1297
elif parent is None:
1762
1298
# We only update parent if it did not exist, missing
1763
1299
# should not change the parent
1764
tree.branch.set_parent(remote)
1765
br_remote = Branch.open_containing(remote)[0]
1766
return show_missing(tree.branch, br_remote, verbose=verbose,
1767
quiet=is_quiet())
1300
b.set_parent(remote)
1301
br_remote = Branch.open_containing(remote)
1302
1303
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1304
1768
1305
1769
1306
1770
1307
class cmd_plugins(Command):
1771
1308
"""List plugins"""
1772
1309
hidden = True
1773
@display_command
1774
1310
def run(self):
1775
1311
import bzrlib.plugin
1776
1312
from inspect import getdoc
1777
for name, plugin in bzrlib.plugin.all_plugins().items():
1313
for plugin in bzrlib.plugin.all_plugins:
1778
1314
if hasattr(plugin, '__path__'):
1779
1315
print plugin.__path__[0]
1780
1316
elif hasattr(plugin, '__file__'):
1787
1323
print '\t', d.split('\n')[0]
1788
1324
1789
1325
1790
class cmd_testament(Command):
1791
"""Show testament (signing-form) of a revision."""
1792
takes_options = ['revision', 'long']
1793
takes_args = ['branch?']
1794
@display_command
1795
def run(self, branch=u'.', revision=None, long=False):
1796
from bzrlib.testament import Testament
1797
b = WorkingTree.open_containing(branch)[0].branch
1798
b.lock_read()
1799
try:
1800
if revision is None:
1801
rev_id = b.last_revision()
1802
else:
1803
rev_id = revision[0].in_history(b).rev_id
1804
t = Testament.from_revision(b, rev_id)
1805
if long:
1806
sys.stdout.writelines(t.as_text_lines())
1807
else:
1808
sys.stdout.write(t.as_short_text())
1809
finally:
1810
b.unlock()
1811
1812
1813
class cmd_annotate(Command):
1814
"""Show the origin of each line in a file.
1815
1816
This prints out the given file with an annotation on the left side
1817
indicating which revision, author and date introduced the change.
1818
1819
If the origin is the same for a run of consecutive lines, it is
1820
shown only at the top, unless the --all option is given.
1821
"""
1822
# TODO: annotate directories; showing when each file was last changed
1823
# TODO: annotate a previous version of a file
1824
# TODO: if the working copy is modified, show annotations on that
1825
# with new uncommitted lines marked
1826
aliases = ['blame', 'praise']
1827
takes_args = ['filename']
1828
takes_options = [Option('all', help='show annotations on all lines'),
1829
Option('long', help='show date in annotations'),
1830
]
1831
1832
@display_command
1833
def run(self, filename, all=False, long=False):
1834
from bzrlib.annotate import annotate_file
1835
tree, relpath = WorkingTree.open_containing(filename)
1836
branch = tree.branch
1837
branch.lock_read()
1838
try:
1839
file_id = tree.inventory.path2id(relpath)
1840
tree = branch.revision_tree(branch.last_revision())
1841
file_version = tree.inventory[file_id].revision
1842
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1843
finally:
1844
branch.unlock()
1845
1846
1847
class cmd_re_sign(Command):
1848
"""Create a digital signature for an existing revision."""
1849
# TODO be able to replace existing ones.
1850
1851
hidden = True # is this right ?
1852
takes_args = ['revision_id?']
1853
takes_options = ['revision']
1854
1855
def run(self, revision_id=None, revision=None):
1856
import bzrlib.config as config
1857
import bzrlib.gpg as gpg
1858
if revision_id is not None and revision is not None:
1859
raise BzrCommandError('You can only supply one of revision_id or --revision')
1860
if revision_id is None and revision is None:
1861
raise BzrCommandError('You must supply either --revision or a revision_id')
1862
b = WorkingTree.open_containing(u'.')[0].branch
1863
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1864
if revision_id is not None:
1865
b.sign_revision(revision_id, gpg_strategy)
1866
elif revision is not None:
1867
if len(revision) == 1:
1868
revno, rev_id = revision[0].in_history(b)
1869
b.sign_revision(rev_id, gpg_strategy)
1870
elif len(revision) == 2:
1871
# are they both on rh- if so we can walk between them
1872
# might be nice to have a range helper for arbitrary
1873
# revision paths. hmm.
1874
from_revno, from_revid = revision[0].in_history(b)
1875
to_revno, to_revid = revision[1].in_history(b)
1876
if to_revid is None:
1877
to_revno = b.revno()
1878
if from_revno is None or to_revno is None:
1879
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1880
for revno in range(from_revno, to_revno + 1):
1881
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1882
else:
1883
raise BzrCommandError('Please supply either one revision, or a range.')
1884
1885
1886
class cmd_uncommit(bzrlib.commands.Command):
1887
"""Remove the last committed revision.
1888
1889
By supplying the --all flag, it will not only remove the entry
1890
from revision_history, but also remove all of the entries in the
1891
stores.
1892
1893
--verbose will print out what is being removed.
1894
--dry-run will go through all the motions, but not actually
1895
remove anything.
1896
1897
In the future, uncommit will create a changeset, which can then
1898
be re-applied.
1899
"""
1900
takes_options = ['all', 'verbose', 'revision',
1901
Option('dry-run', help='Don\'t actually make changes'),
1902
Option('force', help='Say yes to all questions.')]
1903
takes_args = ['location?']
1904
aliases = []
1905
1906
def run(self, location=None, all=False,
1907
dry_run=False, verbose=False,
1908
revision=None, force=False):
1909
from bzrlib.branch import Branch
1910
from bzrlib.log import log_formatter
1911
import sys
1912
from bzrlib.uncommit import uncommit
1913
1914
if location is None:
1915
location = u'.'
1916
b, relpath = Branch.open_containing(location)
1917
1918
if revision is None:
1919
revno = b.revno()
1920
rev_id = b.last_revision()
1921
else:
1922
revno, rev_id = revision[0].in_history(b)
1923
if rev_id is None:
1924
print 'No revisions to uncommit.'
1925
1926
for r in range(revno, b.revno()+1):
1927
rev_id = b.get_rev_id(r)
1928
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1929
lf.show(r, b.get_revision(rev_id), None)
1930
1931
if dry_run:
1932
print 'Dry-run, pretending to remove the above revisions.'
1933
if not force:
1934
val = raw_input('Press <enter> to continue')
1935
else:
1936
print 'The above revision(s) will be removed.'
1937
if not force:
1938
val = raw_input('Are you sure [y/N]? ')
1939
if val.lower() not in ('y', 'yes'):
1940
print 'Canceled'
1941
return 0
1942
1943
uncommit(b, remove_files=all,
1944
dry_run=dry_run, verbose=verbose,
1945
revno=revno)
1946
1947
1948
# these get imported and then picked up by the scan for cmd_*
1949
# TODO: Some more consistent way to split command definitions across files;
1950
# we do need to load at least some information about them to know of
1951
# aliases.
1952
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
Loggerhead is a web-based interface for Breezy
Version: 2.0.1