« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1596.2.27
- compare with another revision
- download diff
- download tarball
- view history from revision 1596.2.27
- Committer: Robert Collins
- Date: 2006-03-11 13:58:48 UTC
- mto: (1615.1.2 bzr.mbp.integration)
- mto: This revision was merged to the branch mainline in revision 1616.
- Revision ID: robertc@robertcollins.net-20060311135848-789fa616b8da4662
Note potential improvements in knit adds.
- files added:
- BRANCH.TODO
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- 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/workingtree_implementations
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- tools/doc_generate
- files removed:
- bzrlib/changeset.py
- patches
- files renamed:
- bzrlib/store/weave.py => bzrlib/store/versioned/__init__.py
- bzrlib/selftest/ => bzrlib/tests/
- bzrlib/selftest/test_revision_info.py => bzrlib/tests/blackbox/test_revision_info.py
- bzrlib/selftest/teststatus.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/selftest/blackbox.py => bzrlib/tests/blackbox/test_too_much.py
- bzrlib/selftest/versioning.py => bzrlib/tests/blackbox/test_versioning.py
- bzrlib/selftest/testbranch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/selftest/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testfetch.py => bzrlib/tests/test_fetch.py
- bzrlib/selftest/testgraph.py => bzrlib/tests/test_graph.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testinv.py => bzrlib/tests/test_inv.py
- bzrlib/selftest/testlog.py => bzrlib/tests/test_log.py
- bzrlib/selftest/testmerge.py => bzrlib/tests/test_merge.py
- bzrlib/selftest/testmerge3.py => bzrlib/tests/test_merge3.py
- bzrlib/selftest/plugins.py => bzrlib/tests/test_plugins.py
- bzrlib/selftest/testrevision.py => bzrlib/tests/test_revision.py
- bzrlib/selftest/testrevisionnamespaces.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- bzrlib/selftest/testtransport.py => bzrlib/tests/test_transport.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- bzrlib/selftest/testworkingtree.py => bzrlib/tests/test_workingtree.py
- bzrlib/ui.py => bzrlib/ui/__init__.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- bzr-man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006 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
17
"""builtin bzr commands"""
18
19
20
import errno
21
import os
22
from shutil import rmtree
18
23
import sys
19
import os
20
24
21
25
import bzrlib
26
import bzrlib.branch
27
from bzrlib.branch import Branch
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.commands import Command, display_command
30
from bzrlib.revision import common_ancestor
31
import bzrlib.errors as errors
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
NotBranchError, DivergedBranches, NotConflicted,
34
NoSuchFile, NoWorkingTree, FileInWrongBranch,
35
NotVersionedError)
36
from bzrlib.log import show_one_log
37
from bzrlib.merge import Merge3Merger
38
from bzrlib.option import Option
39
from bzrlib.progress import DummyProgress, ProgressPhase
40
from bzrlib.revisionspec import RevisionSpec
22
41
import bzrlib.trace
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
25
from bzrlib.branch import Branch
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
28
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
43
from bzrlib.transport.local import LocalTransport
44
import bzrlib.ui
45
from bzrlib.workingtree import WorkingTree
46
47
48
def tree_files(file_list, default_branch=u'.'):
49
try:
50
return internal_tree_files(file_list, default_branch)
51
except FileInWrongBranch, e:
52
raise BzrCommandError("%s is not in the same branch as %s" %
53
(e.path, file_list[0]))
54
55
def internal_tree_files(file_list, default_branch=u'.'):
56
"""\
57
Return a branch and list of branch-relative paths.
58
If supplied file_list is empty or None, the branch default will be used,
59
and returned file_list will match the original.
60
"""
61
if file_list is None or len(file_list) == 0:
62
return WorkingTree.open_containing(default_branch)[0], file_list
63
tree = WorkingTree.open_containing(file_list[0])[0]
64
new_list = []
65
for filename in file_list:
66
try:
67
new_list.append(tree.relpath(filename))
68
except errors.PathNotChild:
69
raise FileInWrongBranch(tree.branch, filename)
70
return tree, new_list
71
72
73
def get_format_type(typestring):
74
"""Parse and return a format specifier."""
75
if typestring == "metadir":
76
return bzrdir.BzrDirMetaFormat1()
77
if typestring == "knit":
78
format = bzrdir.BzrDirMetaFormat1()
79
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
80
return format
81
msg = "No known bzr-dir format %s. Supported types are: metadir\n" %\
82
(typestring)
83
raise BzrCommandError(msg)
84
85
86
# TODO: Make sure no commands unconditionally use the working directory as a
87
# branch. If a filename argument is used, the first of them should be used to
88
# specify the branch. (Perhaps this can be factored out into some kind of
89
# Argument class, representing a file in a branch, where the first occurrence
90
# opens the branch?)
29
91
30
92
class cmd_status(Command):
31
93
"""Display status summary.
66
128
If a revision argument is given, the status is calculated against
67
129
that revision, or between two revisions if two are provided.
68
130
"""
69
# XXX: FIXME: bzr status should accept a -r option to show changes
70
# relative to a revision, or between revisions
71
131
132
# TODO: --no-recurse, --recurse options
133
72
134
takes_args = ['file*']
73
takes_options = ['all', 'show-ids']
135
takes_options = ['all', 'show-ids', 'revision']
74
136
aliases = ['st', 'stat']
75
137
138
@display_command
76
139
def run(self, all=False, show_ids=False, file_list=None, revision=None):
77
if file_list:
78
b = Branch.open_containing(file_list[0])
79
file_list = [b.relpath(x) for x in file_list]
80
# special case: only one path was given and it's the root
81
# of the branch
82
if file_list == ['']:
83
file_list = None
84
else:
85
b = Branch.open_containing('.')
140
tree, file_list = tree_files(file_list)
86
141
87
from bzrlib.status import show_status
88
show_status(b, show_unchanged=all, show_ids=show_ids,
89
specific_files=file_list, revision=revision)
142
from bzrlib.status import show_tree_status
143
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
144
specific_files=file_list, revision=revision)
90
145
91
146
92
147
class cmd_cat_revision(Command):
100
155
takes_args = ['revision_id?']
101
156
takes_options = ['revision']
102
157
158
@display_command
103
159
def run(self, revision_id=None, revision=None):
104
from bzrlib.revisionspec import RevisionSpec
105
160
106
161
if revision_id is not None and revision is not None:
107
162
raise BzrCommandError('You can only supply one of revision_id or --revision')
108
163
if revision_id is None and revision is None:
109
164
raise BzrCommandError('You must supply either --revision or a revision_id')
110
b = Branch.open_containing('.')
165
b = WorkingTree.open_containing(u'.')[0].branch
111
166
if revision_id is not None:
112
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
167
sys.stdout.write(b.repository.get_revision_xml(revision_id))
113
168
elif revision is not None:
114
169
for rev in revision:
115
170
if rev is None:
116
171
raise BzrCommandError('You cannot specify a NULL revision.')
117
172
revno, rev_id = rev.in_history(b)
118
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
173
sys.stdout.write(b.repository.get_revision_xml(rev_id))
119
174
120
175
121
176
class cmd_revno(Command):
122
177
"""Show current revision number.
123
178
124
179
This is equal to the number of revisions on this branch."""
125
def run(self):
126
print Branch.open_containing('.').revno()
180
takes_args = ['location?']
181
@display_command
182
def run(self, location=u'.'):
183
print Branch.open_containing(location)[0].revno()
127
184
128
185
129
186
class cmd_revision_info(Command):
132
189
hidden = True
133
190
takes_args = ['revision_info*']
134
191
takes_options = ['revision']
192
@display_command
135
193
def run(self, revision=None, revision_info_list=[]):
136
from bzrlib.revisionspec import RevisionSpec
137
194
138
195
revs = []
139
196
if revision is not None:
144
201
if len(revs) == 0:
145
202
raise BzrCommandError('You must supply a revision identifier')
146
203
147
b = Branch.open_containing('.')
204
b = WorkingTree.open_containing(u'.')[0].branch
148
205
149
206
for rev in revs:
150
207
revinfo = rev.in_history(b)
176
233
implicitly add the parent, and so on up to the root. This means
177
234
you should never need to explictly add a directory, they'll just
178
235
get added when you add a file in the directory.
236
237
--dry-run will show which files would be added, but not actually
238
add them.
179
239
"""
180
240
takes_args = ['file*']
181
takes_options = ['verbose', 'no-recurse']
182
183
def run(self, file_list, verbose=False, no_recurse=False):
184
# verbose currently has no effect
185
from bzrlib.add import smart_add, add_reporter_print
186
smart_add(file_list, not no_recurse, add_reporter_print)
187
241
takes_options = ['no-recurse', 'dry-run', 'verbose']
242
243
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
244
import bzrlib.add
245
246
if dry_run:
247
if is_quiet():
248
# This is pointless, but I'd rather not raise an error
249
action = bzrlib.add.add_action_null
250
else:
251
action = bzrlib.add.add_action_print
252
elif is_quiet():
253
action = bzrlib.add.add_action_add
254
else:
255
action = bzrlib.add.add_action_add_and_print
256
257
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
258
action)
259
if len(ignored) > 0:
260
for glob in sorted(ignored.keys()):
261
match_len = len(ignored[glob])
262
if verbose:
263
for path in ignored[glob]:
264
print "ignored %s matching \"%s\"" % (path, glob)
265
else:
266
print "ignored %d file(s) matching \"%s\"" % (match_len,
267
glob)
268
print "If you wish to add some of these files, please add them"\
269
" by name."
188
270
189
271
190
272
class cmd_mkdir(Command):
195
277
takes_args = ['dir+']
196
278
197
279
def run(self, dir_list):
198
b = None
199
200
280
for d in dir_list:
201
281
os.mkdir(d)
202
if not b:
203
b = Branch.open_containing(d)
204
b.add([d])
282
wt, dd = WorkingTree.open_containing(d)
283
wt.add([dd])
205
284
print 'added', d
206
285
207
286
210
289
takes_args = ['filename']
211
290
hidden = True
212
291
292
@display_command
213
293
def run(self, filename):
214
print Branch.open_containing(filename).relpath(filename)
215
294
tree, relpath = WorkingTree.open_containing(filename)
295
print relpath
216
296
217
297
218
298
class cmd_inventory(Command):
219
"""Show inventory of the current working copy or a revision."""
220
takes_options = ['revision', 'show-ids']
299
"""Show inventory of the current working copy or a revision.
300
301
It is possible to limit the output to a particular entry
302
type using the --kind option. For example; --kind file.
303
"""
304
takes_options = ['revision', 'show-ids', 'kind']
221
305
222
def run(self, revision=None, show_ids=False):
223
b = Branch.open_containing('.')
306
@display_command
307
def run(self, revision=None, show_ids=False, kind=None):
308
if kind and kind not in ['file', 'directory', 'symlink']:
309
raise BzrCommandError('invalid kind specified')
310
tree = WorkingTree.open_containing(u'.')[0]
224
311
if revision is None:
225
inv = b.read_working_inventory()
312
inv = tree.read_working_inventory()
226
313
else:
227
314
if len(revision) > 1:
228
315
raise BzrCommandError('bzr inventory --revision takes'
229
316
' exactly one revision identifier')
230
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
317
inv = tree.branch.repository.get_revision_inventory(
318
revision[0].in_history(tree.branch).rev_id)
231
319
232
320
for path, entry in inv.entries():
321
if kind and kind != entry.kind:
322
continue
233
323
if show_ids:
234
324
print '%-50s %s' % (path, entry.file_id)
235
325
else:
246
336
"""
247
337
takes_args = ['source$', 'dest']
248
338
def run(self, source_list, dest):
249
b = Branch.open_containing('.')
250
339
tree, source_list = tree_files(source_list)
251
340
# TODO: glob expansion on windows?
252
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
341
tree.move(source_list, tree.relpath(dest))
253
342
254
343
255
344
class cmd_rename(Command):
263
352
264
353
See also the 'move' command, which moves files into a different
265
354
directory without changing their name.
266
267
TODO: Some way to rename multiple files without invoking bzr for each
268
one?"""
355
"""
356
# TODO: Some way to rename multiple files without invoking
357
# bzr for each one?"""
269
358
takes_args = ['from_name', 'to_name']
270
359
271
360
def run(self, from_name, to_name):
272
b = Branch.open_containing('.')
273
b.rename_one(b.relpath(from_name), b.relpath(to_name))
274
361
tree, (from_name, to_name) = tree_files((from_name, to_name))
362
tree.rename_one(from_name, to_name)
275
363
276
364
277
365
class cmd_mv(Command):
291
379
def run(self, names_list):
292
380
if len(names_list) < 2:
293
381
raise BzrCommandError("missing file argument")
294
b = Branch.open_containing(names_list[0])
295
296
rel_names = [b.relpath(x) for x in names_list]
382
tree, rel_names = tree_files(names_list)
297
383
298
384
if os.path.isdir(names_list[-1]):
299
385
# move into existing directory
300
for pair in b.move(rel_names[:-1], rel_names[-1]):
386
for pair in tree.move(rel_names[:-1], rel_names[-1]):
301
387
print "%s => %s" % pair
302
388
else:
303
389
if len(names_list) != 2:
304
390
raise BzrCommandError('to mv multiple files the destination '
305
391
'must be a versioned directory')
306
b.rename_one(rel_names[0], rel_names[1])
392
tree.rename_one(rel_names[0], rel_names[1])
307
393
print "%s => %s" % (rel_names[0], rel_names[1])
308
394
309
395
310
311
312
396
class cmd_pull(Command):
313
397
"""Pull any changes from another branch into the current one.
314
398
315
If the location is omitted, the last-used location will be used.
316
Both the revision history and the working directory will be
317
updated.
399
If there is no default location set, the first pull will set it. After
400
that, you can omit the location to use the default. To change the
401
default, use --remember.
318
402
319
403
This command only works on branches that have not diverged. Branches are
320
404
considered diverged if both branches have had commits without first
321
405
pulling from the other.
322
406
323
407
If branches have diverged, you can use 'bzr merge' to pull the text changes
324
from one into the other.
408
from one into the other. Once one branch has merged, the other should
409
be able to pull it again.
410
411
If you want to forget your local changes and just update your branch to
412
match the remote one, use --overwrite.
325
413
"""
414
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
326
415
takes_args = ['location?']
327
416
328
def run(self, location=None):
329
from bzrlib.merge import merge
330
import tempfile
331
from shutil import rmtree
332
import errno
333
334
br_to = Branch.open_containing('.')
335
stored_loc = br_to.get_parent()
417
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
418
# FIXME: too much stuff is in the command class
419
tree_to = WorkingTree.open_containing(u'.')[0]
420
stored_loc = tree_to.branch.get_parent()
336
421
if location is None:
337
422
if stored_loc is None:
338
423
raise BzrCommandError("No pull location known or specified.")
339
424
else:
340
print "Using last location: %s" % stored_loc
341
location = stored_loc
342
cache_root = tempfile.mkdtemp()
343
from bzrlib.errors import DivergedBranches
344
br_from = Branch.open_containing(location)
345
location = br_from.base
346
old_revno = br_to.revno()
347
try:
348
from bzrlib.errors import DivergedBranches
349
br_from = Branch.open(location)
350
br_from.setup_caching(cache_root)
351
location = br_from.base
352
old_revno = br_to.revno()
425
print "Using saved location: %s" % stored_loc
426
location = stored_loc
427
428
br_from = Branch.open(location)
429
br_to = tree_to.branch
430
431
if revision is None:
432
rev_id = None
433
elif len(revision) == 1:
434
rev_id = revision[0].in_history(br_from).rev_id
435
else:
436
raise BzrCommandError('bzr pull --revision takes one value.')
437
438
old_rh = br_to.revision_history()
439
count = tree_to.pull(br_from, overwrite, rev_id)
440
441
if br_to.get_parent() is None or remember:
442
br_to.set_parent(location)
443
note('%d revision(s) pulled.' % (count,))
444
445
if verbose:
446
new_rh = tree_to.branch.revision_history()
447
if old_rh != new_rh:
448
# Something changed
449
from bzrlib.log import show_changed_revisions
450
show_changed_revisions(tree_to.branch, old_rh, new_rh)
451
452
453
class cmd_push(Command):
454
"""Push this branch into another branch.
455
456
The remote branch will not have its working tree populated because this
457
is both expensive, and may not be supported on the remote file system.
458
459
Some smart servers or protocols *may* put the working tree in place.
460
461
If there is no default push location set, the first push will set it.
462
After that, you can omit the location to use the default. To change the
463
default, use --remember.
464
465
This command only works on branches that have not diverged. Branches are
466
considered diverged if the branch being pushed to is not an older version
467
of this branch.
468
469
If branches have diverged, you can use 'bzr push --overwrite' to replace
470
the other branch completely.
471
472
If you want to ensure you have the different changes in the other branch,
473
do a merge (see bzr help merge) from the other branch, and commit that
474
before doing a 'push --overwrite'.
475
"""
476
takes_options = ['remember', 'overwrite',
477
Option('create-prefix',
478
help='Create the path leading up to the branch '
479
'if it does not already exist')]
480
takes_args = ['location?']
481
482
def run(self, location=None, remember=False, overwrite=False,
483
create_prefix=False, verbose=False):
484
# FIXME: Way too big! Put this into a function called from the
485
# command.
486
from bzrlib.transport import get_transport
487
488
tree_from = WorkingTree.open_containing(u'.')[0]
489
br_from = tree_from.branch
490
stored_loc = tree_from.branch.get_push_location()
491
if location is None:
492
if stored_loc is None:
493
raise BzrCommandError("No push location known or specified.")
494
else:
495
print "Using saved location: %s" % stored_loc
496
location = stored_loc
497
try:
498
dir_to = bzrlib.bzrdir.BzrDir.open(location)
499
br_to = dir_to.open_branch()
500
except NotBranchError:
501
# create a branch.
502
transport = get_transport(location).clone('..')
503
if not create_prefix:
504
try:
505
transport.mkdir(transport.relpath(location))
506
except NoSuchFile:
507
raise BzrCommandError("Parent directory of %s "
508
"does not exist." % location)
509
else:
510
current = transport.base
511
needed = [(transport, transport.relpath(location))]
512
while needed:
513
try:
514
transport, relpath = needed[-1]
515
transport.mkdir(relpath)
516
needed.pop()
517
except NoSuchFile:
518
new_transport = transport.clone('..')
519
needed.append((new_transport,
520
new_transport.relpath(transport.base)))
521
if new_transport.base == transport.base:
522
raise BzrCommandError("Could not creeate "
523
"path prefix.")
524
dir_to = br_from.bzrdir.clone(location)
525
br_to = dir_to.open_branch()
526
old_rh = br_to.revision_history()
527
try:
353
528
try:
354
br_to.update_revisions(br_from)
355
except DivergedBranches:
356
raise BzrCommandError("These branches have diverged."
357
" Try merge.")
358
359
merge(('.', -1), ('.', old_revno), check_clean=False)
360
if location != stored_loc:
361
br_to.set_parent(location)
362
finally:
363
rmtree(cache_root)
529
tree_to = dir_to.open_workingtree()
530
except errors.NotLocalUrl:
531
# TODO: This should be updated for branches which don't have a
532
# working tree, as opposed to ones where we just couldn't
533
# update the tree.
534
warning('Unable to update the working tree of: %s' % (br_to.base,))
535
count = br_to.pull(br_from, overwrite)
536
except NoWorkingTree:
537
count = br_to.pull(br_from, overwrite)
538
else:
539
count = tree_to.pull(br_from, overwrite)
540
except DivergedBranches:
541
raise BzrCommandError("These branches have diverged."
542
" Try a merge then push with overwrite.")
543
if br_from.get_push_location() is None or remember:
544
br_from.set_push_location(location)
545
note('%d revision(s) pushed.' % (count,))
364
546
547
if verbose:
548
new_rh = br_to.revision_history()
549
if old_rh != new_rh:
550
# Something changed
551
from bzrlib.log import show_changed_revisions
552
show_changed_revisions(br_to, old_rh, new_rh)
365
553
366
554
367
555
class cmd_branch(Command):
382
570
aliases = ['get', 'clone']
383
571
384
572
def run(self, from_location, to_location=None, revision=None, basis=None):
385
from bzrlib.clone import copy_branch
386
import tempfile
387
import errno
388
from shutil import rmtree
389
cache_root = tempfile.mkdtemp()
390
try:
391
if revision is None:
392
revision = [None]
393
elif len(revision) > 1:
394
raise BzrCommandError(
395
'bzr branch --revision takes exactly 1 revision value')
396
try:
397
br_from = Branch.open(from_location)
398
except OSError, e:
399
if e.errno == errno.ENOENT:
400
raise BzrCommandError('Source location "%s" does not'
401
' exist.' % to_location)
402
else:
403
raise
404
br_from.setup_caching(cache_root)
573
if revision is None:
574
revision = [None]
575
elif len(revision) > 1:
576
raise BzrCommandError(
577
'bzr branch --revision takes exactly 1 revision value')
578
try:
579
br_from = Branch.open(from_location)
580
except OSError, e:
581
if e.errno == errno.ENOENT:
582
raise BzrCommandError('Source location "%s" does not'
583
' exist.' % to_location)
584
else:
585
raise
586
br_from.lock_read()
587
try:
405
588
if basis is not None:
406
basis_branch = Branch.open_containing(basis)
589
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
407
590
else:
408
basis_branch = None
591
basis_dir = None
409
592
if len(revision) == 1 and revision[0] is not None:
410
593
revision_id = revision[0].in_history(br_from)[1]
411
594
else:
412
revision_id = None
595
# FIXME - wt.last_revision, fallback to branch, fall back to
596
# None or perhaps NULL_REVISION to mean copy nothing
597
# RBC 20060209
598
revision_id = br_from.last_revision()
413
599
if to_location is None:
414
600
to_location = os.path.basename(from_location.rstrip("/\\"))
601
name = None
602
else:
603
name = os.path.basename(to_location) + '\n'
415
604
try:
416
605
os.mkdir(to_location)
417
606
except OSError, e:
424
613
else:
425
614
raise
426
615
try:
427
copy_branch(br_from, to_location, revision_id, basis_branch)
616
# preserve whatever source format we have.
617
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
618
branch = dir.open_branch()
428
619
except bzrlib.errors.NoSuchRevision:
429
620
rmtree(to_location)
430
msg = "The branch %s has no revision %d." % (from_location, revision[0])
621
msg = "The branch %s has no revision %s." % (from_location, revision[0])
431
622
raise BzrCommandError(msg)
432
623
except bzrlib.errors.UnlistableBranch:
433
msg = "The branch %s cannot be used as a --basis"
434
finally:
435
rmtree(cache_root)
624
rmtree(to_location)
625
msg = "The branch %s cannot be used as a --basis" % (basis,)
626
raise BzrCommandError(msg)
627
if name:
628
branch.control_files.put_utf8('branch-name', name)
629
630
note('Branched %d revision(s).' % branch.revno())
631
finally:
632
br_from.unlock()
633
634
635
class cmd_checkout(Command):
636
"""Create a new checkout of an existing branch.
637
638
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
639
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
640
641
To retrieve the branch as of a particular revision, supply the --revision
642
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
643
out of date [so you cannot commit] but it may be useful (i.e. to examine old
644
code.)
645
646
--basis is to speed up checking out from remote branches. When specified, it
647
uses the inventory and file contents from the basis branch in preference to the
648
branch being checked out. [Not implemented yet.]
649
"""
650
takes_args = ['branch_location', 'to_location?']
651
takes_options = ['revision', # , 'basis']
652
Option('lightweight',
653
help="perform a lightweight checkout. Lightweight "
654
"checkouts depend on access to the branch for "
655
"every operation. Normal checkouts can perform "
656
"common operations like diff and status without "
657
"such access, and also support local commits."
658
),
659
]
660
661
def run(self, branch_location, to_location=None, revision=None, basis=None,
662
lightweight=False):
663
if revision is None:
664
revision = [None]
665
elif len(revision) > 1:
666
raise BzrCommandError(
667
'bzr checkout --revision takes exactly 1 revision value')
668
source = Branch.open(branch_location)
669
if len(revision) == 1 and revision[0] is not None:
670
revision_id = revision[0].in_history(source)[1]
671
else:
672
revision_id = None
673
if to_location is None:
674
to_location = os.path.basename(branch_location.rstrip("/\\"))
675
try:
676
os.mkdir(to_location)
677
except OSError, e:
678
if e.errno == errno.EEXIST:
679
raise BzrCommandError('Target directory "%s" already'
680
' exists.' % to_location)
681
if e.errno == errno.ENOENT:
682
raise BzrCommandError('Parent of "%s" does not exist.' %
683
to_location)
684
else:
685
raise
686
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
687
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
688
try:
689
if lightweight:
690
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
691
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
692
else:
693
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
694
to_location, force_new_tree=False)
695
checkout = checkout_branch.bzrdir
696
checkout_branch.bind(source)
697
if revision_id is not None:
698
rh = checkout_branch.revision_history()
699
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
700
checkout.create_workingtree(revision_id)
701
finally:
702
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
436
703
437
704
438
705
class cmd_renames(Command):
439
706
"""Show list of renamed files.
440
441
TODO: Option to show renames between two historical versions.
442
443
TODO: Only show renames under dir, rather than in the whole branch.
444
707
"""
708
# TODO: Option to show renames between two historical versions.
709
710
# TODO: Only show renames under dir, rather than in the whole branch.
445
711
takes_args = ['dir?']
446
712
447
def run(self, dir='.'):
448
b = Branch.open_containing(dir)
449
old_inv = b.basis_tree().inventory
450
new_inv = b.read_working_inventory()
713
@display_command
714
def run(self, dir=u'.'):
715
tree = WorkingTree.open_containing(dir)[0]
716
old_inv = tree.basis_tree().inventory
717
new_inv = tree.read_working_inventory()
451
718
452
719
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
453
720
renames.sort()
455
722
print "%s => %s" % (old_name, new_name)
456
723
457
724
725
class cmd_update(Command):
726
"""Update a tree to have the latest code committed to its branch.
727
728
This will perform a merge into the working tree, and may generate
729
conflicts. If you have any local changes, you will still
730
need to commit them after the update for the update to be complete.
731
732
If you want to discard your local changes, you can just do a
733
'bzr revert' instead of 'bzr commit' after the update.
734
"""
735
takes_args = ['dir?']
736
737
def run(self, dir='.'):
738
tree = WorkingTree.open_containing(dir)[0]
739
tree.lock_write()
740
try:
741
if tree.last_revision() == tree.branch.last_revision():
742
# may be up to date, check master too.
743
master = tree.branch.get_master_branch()
744
if master is None or master.last_revision == tree.last_revision():
745
note("Tree is up to date.")
746
return
747
conflicts = tree.update()
748
note('Updated to revision %d.' %
749
(tree.branch.revision_id_to_revno(tree.last_revision()),))
750
if conflicts != 0:
751
return 1
752
else:
753
return 0
754
finally:
755
tree.unlock()
756
757
458
758
class cmd_info(Command):
459
759
"""Show statistical information about a branch."""
460
760
takes_args = ['branch?']
461
761
762
@display_command
462
763
def run(self, branch=None):
463
import info
464
465
b = Branch.open_containing(branch)
466
info.show_info(b)
764
import bzrlib.info
765
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0])
467
766
468
767
469
768
class cmd_remove(Command):
474
773
"""
475
774
takes_args = ['file+']
476
775
takes_options = ['verbose']
776
aliases = ['rm']
477
777
478
778
def run(self, file_list, verbose=False):
479
b = Branch.open_containing(file_list[0])
480
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
779
tree, file_list = tree_files(file_list)
780
tree.remove(file_list, verbose=verbose)
481
781
482
782
483
783
class cmd_file_id(Command):
489
789
"""
490
790
hidden = True
491
791
takes_args = ['filename']
792
@display_command
492
793
def run(self, filename):
493
b = Branch.open_containing(filename)
494
i = b.inventory.path2id(b.relpath(filename))
794
tree, relpath = WorkingTree.open_containing(filename)
795
i = tree.inventory.path2id(relpath)
495
796
if i == None:
496
797
raise BzrError("%r is not a versioned file" % filename)
497
798
else:
505
806
starting at the branch root."""
506
807
hidden = True
507
808
takes_args = ['filename']
809
@display_command
508
810
def run(self, filename):
509
b = Branch.open_containing(filename)
510
inv = b.inventory
511
fid = inv.path2id(b.relpath(filename))
811
tree, relpath = WorkingTree.open_containing(filename)
812
inv = tree.inventory
813
fid = inv.path2id(relpath)
512
814
if fid == None:
513
815
raise BzrError("%r is not a versioned file" % filename)
514
816
for fip in inv.get_idpath(fid):
515
817
print fip
516
818
517
819
820
class cmd_reconcile(Command):
821
"""Reconcile bzr metadata in a branch.
822
823
This can correct data mismatches that may have been caused by
824
previous ghost operations or bzr upgrades. You should only
825
need to run this command if 'bzr check' or a bzr developer
826
advises you to run it.
827
828
If a second branch is provided, cross-branch reconciliation is
829
also attempted, which will check that data like the tree root
830
id which was not present in very early bzr versions is represented
831
correctly in both branches.
832
833
At the same time it is run it may recompress data resulting in
834
a potential saving in disk space or performance gain.
835
836
The branch *MUST* be on a listable system such as local disk or sftp.
837
"""
838
takes_args = ['branch?']
839
840
def run(self, branch="."):
841
from bzrlib.reconcile import reconcile
842
dir = bzrlib.bzrdir.BzrDir.open(branch)
843
reconcile(dir)
844
845
518
846
class cmd_revision_history(Command):
519
847
"""Display list of revision ids on this branch."""
520
848
hidden = True
849
@display_command
521
850
def run(self):
522
for patchid in Branch.open_containing('.').revision_history():
851
branch = WorkingTree.open_containing(u'.')[0].branch
852
for patchid in branch.revision_history():
523
853
print patchid
524
854
525
855
526
856
class cmd_ancestry(Command):
527
857
"""List all revisions merged into this branch."""
528
858
hidden = True
859
@display_command
529
860
def run(self):
530
b = find_branch('.')
531
for revision_id in b.get_ancestry(b.last_revision()):
861
tree = WorkingTree.open_containing(u'.')[0]
862
b = tree.branch
863
# FIXME. should be tree.last_revision
864
for revision_id in b.repository.get_ancestry(b.last_revision()):
532
865
print revision_id
533
866
534
867
535
class cmd_directories(Command):
536
"""Display list of versioned directories in this branch."""
537
def run(self):
538
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
539
if name == '':
540
print '.'
541
else:
542
print name
543
544
545
868
class cmd_init(Command):
546
869
"""Make a directory into a versioned branch.
547
870
551
874
Recipe for importing a tree of files:
552
875
cd ~/project
553
876
bzr init
554
bzr add -v .
877
bzr add .
555
878
bzr status
556
879
bzr commit -m 'imported project'
557
880
"""
558
def run(self):
559
Branch.initialize('.')
881
takes_args = ['location?']
882
takes_options = [
883
Option('format',
884
help='Create a specific format rather than the'
885
' current default format. Currently this '
886
' option only accepts =metadir',
887
type=get_format_type),
888
]
889
def run(self, location=None, format=None):
890
from bzrlib.branch import Branch
891
if location is None:
892
location = u'.'
893
else:
894
# The path has to exist to initialize a
895
# branch inside of it.
896
# Just using os.mkdir, since I don't
897
# believe that we want to create a bunch of
898
# locations if the user supplies an extended path
899
if not os.path.exists(location):
900
os.mkdir(location)
901
if format is None:
902
# create default
903
bzrdir.BzrDir.create_standalone_workingtree(location)
904
else:
905
new_dir = format.initialize(location)
906
new_dir.create_repository()
907
new_dir.create_branch()
908
# TODO: ask the bzrdir format for the right classs
909
import bzrlib.workingtree
910
bzrlib.workingtree.WorkingTreeFormat3().initialize(new_dir)
560
911
561
912
562
913
class cmd_diff(Command):
565
916
If files are listed, only the changes in those files are listed.
566
917
Otherwise, all changes for the tree are listed.
567
918
568
TODO: Allow diff across branches.
569
570
TODO: Option to use external diff command; could be GNU diff, wdiff,
571
or a graphical diff.
572
573
TODO: Python difflib is not exactly the same as unidiff; should
574
either fix it up or prefer to use an external diff.
575
576
TODO: If a directory is given, diff everything under that.
577
578
TODO: Selected-file diff is inefficient and doesn't show you
579
deleted files.
580
581
TODO: This probably handles non-Unix newlines poorly.
582
583
919
examples:
584
920
bzr diff
585
921
bzr diff -r1
586
922
bzr diff -r1..2
587
923
"""
924
# TODO: Allow diff across branches.
925
# TODO: Option to use external diff command; could be GNU diff, wdiff,
926
# or a graphical diff.
927
928
# TODO: Python difflib is not exactly the same as unidiff; should
929
# either fix it up or prefer to use an external diff.
930
931
# TODO: If a directory is given, diff everything under that.
932
933
# TODO: Selected-file diff is inefficient and doesn't show you
934
# deleted files.
935
936
# TODO: This probably handles non-Unix newlines poorly.
588
937
589
938
takes_args = ['file*']
590
939
takes_options = ['revision', 'diff-options']
591
940
aliases = ['di', 'dif']
592
941
942
@display_command
593
943
def run(self, revision=None, file_list=None, diff_options=None):
594
from bzrlib.diff import show_diff
595
596
if file_list:
597
b = Branch.open_containing(file_list[0])
598
file_list = [b.relpath(f) for f in file_list]
599
if file_list == ['']:
600
# just pointing to top-of-tree
601
file_list = None
602
else:
603
b = Branch.open_containing('.')
604
944
from bzrlib.diff import diff_cmd_helper, show_diff_trees
945
try:
946
tree1, file_list = internal_tree_files(file_list)
947
tree2 = None
948
b = None
949
b2 = None
950
except FileInWrongBranch:
951
if len(file_list) != 2:
952
raise BzrCommandError("Files are in different branches")
953
954
tree1, file1 = WorkingTree.open_containing(file_list[0])
955
tree2, file2 = WorkingTree.open_containing(file_list[1])
956
if file1 != "" or file2 != "":
957
# FIXME diff those two files. rbc 20051123
958
raise BzrCommandError("Files are in different branches")
959
file_list = None
605
960
if revision is not None:
606
if len(revision) == 1:
607
show_diff(b, revision[0], specific_files=file_list,
608
external_diff_options=diff_options)
961
if tree2 is not None:
962
raise BzrCommandError("Can't specify -r with two branches")
963
if (len(revision) == 1) or (revision[1].spec is None):
964
return diff_cmd_helper(tree1, file_list, diff_options,
965
revision[0])
609
966
elif len(revision) == 2:
610
show_diff(b, revision[0], specific_files=file_list,
611
external_diff_options=diff_options,
612
revision2=revision[1])
967
return diff_cmd_helper(tree1, file_list, diff_options,
968
revision[0], revision[1])
613
969
else:
614
970
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
615
971
else:
616
show_diff(b, None, specific_files=file_list,
617
external_diff_options=diff_options)
618
619
972
if tree2 is not None:
973
return show_diff_trees(tree1, tree2, sys.stdout,
974
specific_files=file_list,
975
external_diff_options=diff_options)
976
else:
977
return diff_cmd_helper(tree1, file_list, diff_options)
620
978
621
979
622
980
class cmd_deleted(Command):
623
981
"""List files deleted in the working tree.
624
625
TODO: Show files deleted since a previous revision, or between two revisions.
626
982
"""
983
# TODO: Show files deleted since a previous revision, or
984
# between two revisions.
985
# TODO: Much more efficient way to do this: read in new
986
# directories with readdir, rather than stating each one. Same
987
# level of effort but possibly much less IO. (Or possibly not,
988
# if the directories are very large...)
989
@display_command
627
990
def run(self, show_ids=False):
628
b = Branch.open_containing('.')
629
old = b.basis_tree()
630
new = b.working_tree()
631
632
## TODO: Much more efficient way to do this: read in new
633
## directories with readdir, rather than stating each one. Same
634
## level of effort but possibly much less IO. (Or possibly not,
635
## if the directories are very large...)
636
991
tree = WorkingTree.open_containing(u'.')[0]
992
old = tree.basis_tree()
637
993
for path, ie in old.inventory.iter_entries():
638
if not new.has_id(ie.file_id):
994
if not tree.has_id(ie.file_id):
639
995
if show_ids:
640
996
print '%-50s %s' % (path, ie.file_id)
641
997
else:
645
1001
class cmd_modified(Command):
646
1002
"""List files modified in working tree."""
647
1003
hidden = True
1004
@display_command
648
1005
def run(self):
649
1006
from bzrlib.delta import compare_trees
650
1007
651
b = Branch.open_containing('.')
652
td = compare_trees(b.basis_tree(), b.working_tree())
1008
tree = WorkingTree.open_containing(u'.')[0]
1009
td = compare_trees(tree.basis_tree(), tree)
653
1010
654
1011
for path, id, kind, text_modified, meta_modified in td.modified:
655
1012
print path
659
1016
class cmd_added(Command):
660
1017
"""List files added in working tree."""
661
1018
hidden = True
1019
@display_command
662
1020
def run(self):
663
b = Branch.open_containing('.')
664
wt = b.working_tree()
665
basis_inv = b.basis_tree().inventory
1021
wt = WorkingTree.open_containing(u'.')[0]
1022
basis_inv = wt.basis_tree().inventory
666
1023
inv = wt.inventory
667
1024
for file_id in inv:
668
1025
if file_id in basis_inv:
669
1026
continue
670
1027
path = inv.id2path(file_id)
671
if not os.access(b.abspath(path), os.F_OK):
1028
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
672
1029
continue
673
1030
print path
674
1031
680
1037
The root is the nearest enclosing directory with a .bzr control
681
1038
directory."""
682
1039
takes_args = ['filename?']
1040
@display_command
683
1041
def run(self, filename=None):
684
1042
"""Print the branch root."""
685
b = Branch.open_containing(filename)
686
print b.base
1043
tree = WorkingTree.open_containing(filename)[0]
1044
print tree.basedir
687
1045
688
1046
689
1047
class cmd_log(Command):
690
1048
"""Show log of this branch.
691
1049
692
To request a range of logs, you can use the command -r begin:end
693
-r revision requests a specific revision, -r :end or -r begin: are
1050
To request a range of logs, you can use the command -r begin..end
1051
-r revision requests a specific revision, -r ..end or -r begin.. are
694
1052
also valid.
695
696
--message allows you to give a regular expression, which will be evaluated
697
so that only matching entries will be displayed.
698
699
TODO: Make --revision support uuid: and hash: [future tag:] notation.
700
701
1053
"""
702
1054
1055
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1056
703
1057
takes_args = ['filename?']
704
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
705
'long', 'message', 'short',]
706
1058
takes_options = [Option('forward',
1059
help='show from oldest to newest'),
1060
'timezone', 'verbose',
1061
'show-ids', 'revision',
1062
'log-format',
1063
'line', 'long',
1064
Option('message',
1065
help='show revisions whose message matches this regexp',
1066
type=str),
1067
'short',
1068
]
1069
@display_command
707
1070
def run(self, filename=None, timezone='original',
708
1071
verbose=False,
709
1072
show_ids=False,
710
1073
forward=False,
711
1074
revision=None,
1075
log_format=None,
712
1076
message=None,
713
1077
long=False,
714
short=False):
1078
short=False,
1079
line=False):
715
1080
from bzrlib.log import log_formatter, show_log
716
1081
import codecs
717
1082
assert message is None or isinstance(message, basestring), \
1083
"invalid message argument %r" % message
718
1084
direction = (forward and 'forward') or 'reverse'
719
1085
1086
# log everything
1087
file_id = None
720
1088
if filename:
721
b = Branch.open_containing(filename)
722
fp = b.relpath(filename)
723
if fp:
724
file_id = b.read_working_inventory().path2id(fp)
725
else:
726
file_id = None # points to branch root
1089
# find the file id to log:
1090
1091
dir, fp = bzrdir.BzrDir.open_containing(filename)
1092
b = dir.open_branch()
1093
if fp != '':
1094
try:
1095
# might be a tree:
1096
inv = dir.open_workingtree().inventory
1097
except (errors.NotBranchError, errors.NotLocalUrl):
1098
# either no tree, or is remote.
1099
inv = b.basis_tree().inventory
1100
file_id = inv.path2id(fp)
727
1101
else:
728
b = Branch.open_containing('.')
729
file_id = None
1102
# local dir only
1103
# FIXME ? log the current subdir only RBC 20060203
1104
dir, relpath = bzrdir.BzrDir.open_containing('.')
1105
b = dir.open_branch()
730
1106
731
1107
if revision is None:
732
1108
rev1 = None
734
1110
elif len(revision) == 1:
735
1111
rev1 = rev2 = revision[0].in_history(b).revno
736
1112
elif len(revision) == 2:
737
rev1 = revision[0].in_history(b).revno
738
rev2 = revision[1].in_history(b).revno
1113
if revision[0].spec is None:
1114
# missing begin-range means first revision
1115
rev1 = 1
1116
else:
1117
rev1 = revision[0].in_history(b).revno
1118
1119
if revision[1].spec is None:
1120
# missing end-range means last known revision
1121
rev2 = b.revno()
1122
else:
1123
rev2 = revision[1].in_history(b).revno
739
1124
else:
740
1125
raise BzrCommandError('bzr log --revision takes one or two values.')
741
1126
742
if rev1 == 0:
743
rev1 = None
744
if rev2 == 0:
745
rev2 = None
1127
# By this point, the revision numbers are converted to the +ve
1128
# form if they were supplied in the -ve form, so we can do
1129
# this comparison in relative safety
1130
if rev1 > rev2:
1131
(rev2, rev1) = (rev1, rev2)
746
1132
747
mutter('encoding log as %r' % bzrlib.user_encoding)
1133
mutter('encoding log as %r', bzrlib.user_encoding)
748
1134
749
1135
# use 'replace' so that we don't abort if trying to write out
750
1136
# in e.g. the default C locale.
751
1137
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
752
1138
753
if not short:
754
log_format = 'long'
755
else:
756
log_format = 'short'
1139
if (log_format == None):
1140
default = bzrlib.config.BranchConfig(b).log_format()
1141
log_format = get_log_format(long=long, short=short, line=line, default=default)
1142
757
1143
lf = log_formatter(log_format,
758
1144
show_ids=show_ids,
759
1145
to_file=outf,
769
1155
search=message)
770
1156
771
1157
1158
def get_log_format(long=False, short=False, line=False, default='long'):
1159
log_format = default
1160
if long:
1161
log_format = 'long'
1162
if short:
1163
log_format = 'short'
1164
if line:
1165
log_format = 'line'
1166
return log_format
1167
772
1168
773
1169
class cmd_touching_revisions(Command):
774
1170
"""Return revision-ids which affected a particular file.
776
1172
A more user-friendly interface is "bzr log FILE"."""
777
1173
hidden = True
778
1174
takes_args = ["filename"]
1175
@display_command
779
1176
def run(self, filename):
780
b = Branch.open_containing(filename)
781
inv = b.read_working_inventory()
782
file_id = inv.path2id(b.relpath(filename))
1177
tree, relpath = WorkingTree.open_containing(filename)
1178
b = tree.branch
1179
inv = tree.read_working_inventory()
1180
file_id = inv.path2id(relpath)
783
1181
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
784
1182
print "%6d %s" % (revno, what)
785
1183
786
1184
787
1185
class cmd_ls(Command):
788
1186
"""List files in a tree.
789
790
TODO: Take a revision or remote path and list that tree instead.
791
1187
"""
1188
# TODO: Take a revision or remote path and list that tree instead.
792
1189
hidden = True
793
def run(self, revision=None, verbose=False):
794
b = Branch.open_containing('.')
795
if revision == None:
796
tree = b.working_tree()
797
else:
798
tree = b.revision_tree(revision.in_history(b).rev_id)
1190
takes_options = ['verbose', 'revision',
1191
Option('non-recursive',
1192
help='don\'t recurse into sub-directories'),
1193
Option('from-root',
1194
help='Print all paths from the root of the branch.'),
1195
Option('unknown', help='Print unknown files'),
1196
Option('versioned', help='Print versioned files'),
1197
Option('ignored', help='Print ignored files'),
1198
1199
Option('null', help='Null separate the files'),
1200
]
1201
@display_command
1202
def run(self, revision=None, verbose=False,
1203
non_recursive=False, from_root=False,
1204
unknown=False, versioned=False, ignored=False,
1205
null=False):
1206
1207
if verbose and null:
1208
raise BzrCommandError('Cannot set both --verbose and --null')
1209
all = not (unknown or versioned or ignored)
1210
1211
selection = {'I':ignored, '?':unknown, 'V':versioned}
1212
1213
tree, relpath = WorkingTree.open_containing(u'.')
1214
if from_root:
1215
relpath = u''
1216
elif relpath:
1217
relpath += '/'
1218
if revision is not None:
1219
tree = tree.branch.repository.revision_tree(
1220
revision[0].in_history(tree.branch).rev_id)
799
1221
for fp, fc, kind, fid, entry in tree.list_files():
800
if verbose:
801
kindch = entry.kind_character()
802
print '%-8s %s%s' % (fc, fp, kindch)
803
else:
804
print fp
805
1222
if fp.startswith(relpath):
1223
fp = fp[len(relpath):]
1224
if non_recursive and '/' in fp:
1225
continue
1226
if not all and not selection[fc]:
1227
continue
1228
if verbose:
1229
kindch = entry.kind_character()
1230
print '%-8s %s%s' % (fc, fp, kindch)
1231
elif null:
1232
sys.stdout.write(fp)
1233
sys.stdout.write('\0')
1234
sys.stdout.flush()
1235
else:
1236
print fp
806
1237
807
1238
808
1239
class cmd_unknowns(Command):
809
1240
"""List unknown files."""
1241
@display_command
810
1242
def run(self):
811
1243
from bzrlib.osutils import quotefn
812
for f in Branch.open_containing('.').unknowns():
1244
for f in WorkingTree.open_containing(u'.')[0].unknowns():
813
1245
print quotefn(f)
814
1246
815
1247
816
817
1248
class cmd_ignore(Command):
818
1249
"""Ignore a command or pattern.
819
1250
820
1251
To remove patterns from the ignore list, edit the .bzrignore file.
821
1252
822
1253
If the pattern contains a slash, it is compared to the whole path
823
from the branch root. Otherwise, it is comapred to only the last
824
component of the path.
1254
from the branch root. Otherwise, it is compared to only the last
1255
component of the path. To match a file only in the root directory,
1256
prepend './'.
825
1257
826
1258
Ignore patterns are case-insensitive on case-insensitive systems.
827
1259
831
1263
bzr ignore ./Makefile
832
1264
bzr ignore '*.class'
833
1265
"""
1266
# TODO: Complain if the filename is absolute
834
1267
takes_args = ['name_pattern']
835
1268
836
1269
def run(self, name_pattern):
837
1270
from bzrlib.atomicfile import AtomicFile
838
1271
import os.path
839
1272
840
b = Branch.open_containing('.')
841
ifn = b.abspath('.bzrignore')
1273
tree, relpath = WorkingTree.open_containing(u'.')
1274
ifn = tree.abspath('.bzrignore')
842
1275
843
1276
if os.path.exists(ifn):
844
1277
f = open(ifn, 'rt')
863
1296
finally:
864
1297
f.close()
865
1298
866
inv = b.working_tree().inventory
1299
inv = tree.inventory
867
1300
if inv.path2id('.bzrignore'):
868
1301
mutter('.bzrignore is already versioned')
869
1302
else:
870
1303
mutter('need to make new .bzrignore file versioned')
871
b.add(['.bzrignore'])
872
1304
tree.add(['.bzrignore'])
873
1305
874
1306
875
1307
class cmd_ignored(Command):
876
1308
"""List ignored files and the patterns that matched them.
877
1309
878
1310
See also: bzr ignore"""
1311
@display_command
879
1312
def run(self):
880
tree = Branch.open_containing('.').working_tree()
1313
tree = WorkingTree.open_containing(u'.')[0]
881
1314
for path, file_class, kind, file_id, entry in tree.list_files():
882
1315
if file_class != 'I':
883
1316
continue
895
1328
hidden = True
896
1329
takes_args = ['revno']
897
1330
1331
@display_command
898
1332
def run(self, revno):
899
1333
try:
900
1334
revno = int(revno)
901
1335
except ValueError:
902
1336
raise BzrCommandError("not a valid revision-number: %r" % revno)
903
1337
904
print Branch.open_containing('.').get_rev_id(revno)
1338
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
905
1339
906
1340
907
1341
class cmd_export(Command):
914
1348
is found exports to a directory (equivalent to --format=dir).
915
1349
916
1350
Root may be the top directory for tar, tgz and tbz2 formats. If none
917
is given, the top directory will be the root name of the file."""
918
# TODO: list known exporters
1351
is given, the top directory will be the root name of the file.
1352
1353
Note: export of tree with non-ascii filenames to zip is not supported.
1354
1355
Supported formats Autodetected by extension
1356
----------------- -------------------------
1357
dir -
1358
tar .tar
1359
tbz2 .tar.bz2, .tbz2
1360
tgz .tar.gz, .tgz
1361
zip .zip
1362
"""
919
1363
takes_args = ['dest']
920
1364
takes_options = ['revision', 'format', 'root']
921
1365
def run(self, dest, revision=None, format=None, root=None):
922
1366
import os.path
923
b = Branch.open_containing('.')
1367
from bzrlib.export import export
1368
tree = WorkingTree.open_containing(u'.')[0]
1369
b = tree.branch
924
1370
if revision is None:
1371
# should be tree.last_revision FIXME
925
1372
rev_id = b.last_revision()
926
1373
else:
927
1374
if len(revision) != 1:
928
1375
raise BzrError('bzr export --revision takes exactly 1 argument')
929
1376
rev_id = revision[0].in_history(b).rev_id
930
t = b.revision_tree(rev_id)
931
arg_root, ext = os.path.splitext(os.path.basename(dest))
932
if ext in ('.gz', '.bz2'):
933
new_root, new_ext = os.path.splitext(arg_root)
934
if new_ext == '.tar':
935
arg_root = new_root
936
ext = new_ext + ext
937
if root is None:
938
root = arg_root
939
if not format:
940
if ext in (".tar",):
941
format = "tar"
942
elif ext in (".tar.gz", ".tgz"):
943
format = "tgz"
944
elif ext in (".tar.bz2", ".tbz2"):
945
format = "tbz2"
946
else:
947
format = "dir"
948
t.export(dest, format, root)
1377
t = b.repository.revision_tree(rev_id)
1378
try:
1379
export(t, dest, format, root)
1380
except errors.NoSuchExportFormat, e:
1381
raise BzrCommandError('Unsupported export format: %s' % e.format)
949
1382
950
1383
951
1384
class cmd_cat(Command):
954
1387
takes_options = ['revision']
955
1388
takes_args = ['filename']
956
1389
1390
@display_command
957
1391
def run(self, filename, revision=None):
958
if revision is None:
959
raise BzrCommandError("bzr cat requires a revision number")
960
elif len(revision) != 1:
1392
if revision is not None and len(revision) != 1:
961
1393
raise BzrCommandError("bzr cat --revision takes exactly one number")
962
b = Branch.open_containing('.')
963
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
1394
tree = None
1395
try:
1396
tree, relpath = WorkingTree.open_containing(filename)
1397
b = tree.branch
1398
except NotBranchError:
1399
pass
1400
1401
if tree is None:
1402
b, relpath = Branch.open_containing(filename)
1403
if revision is None:
1404
revision_id = b.last_revision()
1405
else:
1406
revision_id = revision[0].in_history(b).rev_id
1407
b.print_file(relpath, revision_id)
964
1408
965
1409
966
1410
class cmd_local_time_offset(Command):
967
1411
"""Show the offset in seconds from GMT to local time."""
968
1412
hidden = True
1413
@display_command
969
1414
def run(self):
970
1415
print bzrlib.osutils.local_time_offset()
971
1416
983
1428
A selected-file commit may fail in some cases where the committed
984
1429
tree would be invalid, such as trying to commit a file in a
985
1430
newly-added directory that is not itself committed.
986
987
TODO: Run hooks on tree to-be-committed, and after commit.
988
989
TODO: Strict commit that fails if there are unknown or deleted files.
990
1431
"""
1432
# TODO: Run hooks on tree to-be-committed, and after commit.
1433
1434
# TODO: Strict commit that fails if there are deleted files.
1435
# (what does "deleted files" mean ??)
1436
1437
# TODO: Give better message for -s, --summary, used by tla people
1438
1439
# XXX: verbose currently does nothing
1440
991
1441
takes_args = ['selected*']
992
takes_options = ['message', 'file', 'verbose', 'unchanged']
1442
takes_options = ['message', 'verbose',
1443
Option('unchanged',
1444
help='commit even if nothing has changed'),
1445
Option('file', type=str,
1446
argname='msgfile',
1447
help='file containing commit message'),
1448
Option('strict',
1449
help="refuse to commit if there are unknown "
1450
"files in the working tree."),
1451
Option('local',
1452
help="perform a local only commit in a bound "
1453
"branch. Such commits are not pushed to "
1454
"the master branch until a normal commit "
1455
"is performed."
1456
),
1457
]
993
1458
aliases = ['ci', 'checkin']
994
1459
995
# TODO: Give better message for -s, --summary, used by tla people
996
997
# XXX: verbose currently does nothing
998
999
1460
def run(self, message=None, file=None, verbose=True, selected_list=None,
1000
unchanged=False):
1001
from bzrlib.errors import PointlessCommit
1002
from bzrlib.msgeditor import edit_commit_message
1003
from bzrlib.status import show_status
1004
from cStringIO import StringIO
1005
1006
b = Branch.open_containing('.')
1007
if selected_list:
1008
selected_list = [b.relpath(s) for s in selected_list]
1009
1461
unchanged=False, strict=False, local=False):
1462
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1463
StrictCommitFailed)
1464
from bzrlib.msgeditor import edit_commit_message, \
1465
make_commit_message_template
1466
from tempfile import TemporaryFile
1467
import codecs
1468
1469
# TODO: Need a blackbox test for invoking the external editor; may be
1470
# slightly problematic to run this cross-platform.
1471
1472
# TODO: do more checks that the commit will succeed before
1473
# spending the user's valuable time typing a commit message.
1474
#
1475
# TODO: if the commit *does* happen to fail, then save the commit
1476
# message to a temporary file where it can be recovered
1477
tree, selected_list = tree_files(selected_list)
1478
if local and not tree.branch.get_bound_location():
1479
raise errors.LocalRequiresBoundBranch()
1010
1480
if message is None and not file:
1011
catcher = StringIO()
1012
show_status(b, specific_files=selected_list,
1013
to_file=catcher)
1014
message = edit_commit_message(catcher.getvalue())
1015
1481
template = make_commit_message_template(tree, selected_list)
1482
message = edit_commit_message(template)
1016
1483
if message is None:
1017
1484
raise BzrCommandError("please specify a commit message"
1018
1485
" with either --message or --file")
1027
1494
raise BzrCommandError("empty commit message specified")
1028
1495
1029
1496
try:
1030
b.commit(message,
1031
specific_files=selected_list,
1032
allow_pointless=unchanged)
1497
tree.commit(message, specific_files=selected_list,
1498
allow_pointless=unchanged, strict=strict, local=local)
1033
1499
except PointlessCommit:
1034
1500
# FIXME: This should really happen before the file is read in;
1035
1501
# perhaps prepare the commit; get the message; then actually commit
1036
1502
raise BzrCommandError("no changes to commit",
1037
1503
["use --unchanged to commit anyhow"])
1504
except ConflictsInTree:
1505
raise BzrCommandError("Conflicts detected in working tree. "
1506
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1507
except StrictCommitFailed:
1508
raise BzrCommandError("Commit refused because there are unknown "
1509
"files in the working tree.")
1510
except errors.BoundBranchOutOfDate, e:
1511
raise BzrCommandError(str(e)
1512
+ ' Either unbind, update, or'
1513
' pass --local to commit.')
1514
1515
note('Committed revision %d.' % (tree.branch.revno(),))
1038
1516
1039
1517
1040
1518
class cmd_check(Command):
1043
1521
This command checks various invariants about the branch storage to
1044
1522
detect data corruption or bzr bugs.
1045
1523
"""
1046
takes_args = ['dir?']
1524
takes_args = ['branch?']
1525
takes_options = ['verbose']
1047
1526
1048
def run(self, dir='.'):
1527
def run(self, branch=None, verbose=False):
1049
1528
from bzrlib.check import check
1050
1051
check(Branch.open_containing(dir))
1529
if branch is None:
1530
tree = WorkingTree.open_containing()[0]
1531
branch = tree.branch
1532
else:
1533
branch = Branch.open(branch)
1534
check(branch, verbose)
1052
1535
1053
1536
1054
1537
class cmd_scan_cache(Command):
1056
1539
def run(self):
1057
1540
from bzrlib.hashcache import HashCache
1058
1541
1059
c = HashCache('.')
1542
c = HashCache(u'.')
1060
1543
c.read()
1061
1544
c.scan()
1062
1545
1068
1551
1069
1552
if c.needs_write:
1070
1553
c.write()
1071
1072
1554
1073
1555
1074
1556
class cmd_upgrade(Command):
1075
1557
"""Upgrade branch storage to current format.
1076
1558
1077
1559
The check command or bzr developers may sometimes advise you to run
1078
this command.
1079
1080
This version of this command upgrades from the full-text storage
1081
used by bzr 0.0.8 and earlier to the weave format (v5).
1560
this command. When the default format has changed you may also be warned
1561
during other operations to upgrade.
1082
1562
"""
1083
takes_args = ['dir?']
1084
1085
def run(self, dir='.'):
1563
takes_args = ['url?']
1564
takes_options = [
1565
Option('format',
1566
help='Upgrade to a specific format rather than the'
1567
' current default format. Currently this '
1568
' option only accepts =metadir',
1569
type=get_format_type),
1570
]
1571
1572
1573
def run(self, url='.', format=None):
1086
1574
from bzrlib.upgrade import upgrade
1087
upgrade(dir)
1575
upgrade(url, format)
1088
1576
1089
1577
1090
1578
class cmd_whoami(Command):
1091
1579
"""Show bzr user id."""
1092
1580
takes_options = ['email']
1093
1581
1582
@display_command
1094
1583
def run(self, email=False):
1095
1584
try:
1096
b = bzrlib.branch.Branch.open_containing('.')
1585
b = WorkingTree.open_containing(u'.')[0].branch
1586
config = bzrlib.config.BranchConfig(b)
1097
1587
except NotBranchError:
1098
b = None
1588
config = bzrlib.config.GlobalConfig()
1099
1589
1100
1590
if email:
1101
print bzrlib.osutils.user_email(b)
1102
else:
1103
print bzrlib.osutils.username(b)
1591
print config.user_email()
1592
else:
1593
print config.username()
1594
1595
1596
class cmd_nick(Command):
1597
"""Print or set the branch nickname.
1598
1599
If unset, the tree root directory name is used as the nickname
1600
To print the current nickname, execute with no argument.
1601
"""
1602
takes_args = ['nickname?']
1603
def run(self, nickname=None):
1604
branch = Branch.open_containing(u'.')[0]
1605
if nickname is None:
1606
self.printme(branch)
1607
else:
1608
branch.nick = nickname
1609
1610
@display_command
1611
def printme(self, branch):
1612
print branch.nick
1104
1613
1105
1614
1106
1615
class cmd_selftest(Command):
1109
1618
This creates temporary test directories in the working directory,
1110
1619
but not existing data is affected. These directories are deleted
1111
1620
if the tests pass, or left behind to help in debugging if they
1112
fail.
1621
fail and --keep-output is specified.
1113
1622
1114
1623
If arguments are given, they are regular expressions that say
1115
which tests should run."""
1624
which tests should run.
1625
1626
If the global option '--no-plugins' is given, plugins are not loaded
1627
before running the selftests. This has two effects: features provided or
1628
modified by plugins will not be tested, and tests provided by plugins will
1629
not be run.
1630
1631
examples:
1632
bzr selftest ignore
1633
bzr --no-plugins selftest -v
1634
"""
1116
1635
# TODO: --list should give a list of all available tests
1636
1637
# NB: this is used from the class without creating an instance, which is
1638
# why it does not have a self parameter.
1639
def get_transport_type(typestring):
1640
"""Parse and return a transport specifier."""
1641
if typestring == "sftp":
1642
from bzrlib.transport.sftp import SFTPAbsoluteServer
1643
return SFTPAbsoluteServer
1644
if typestring == "memory":
1645
from bzrlib.transport.memory import MemoryServer
1646
return MemoryServer
1647
msg = "No known transport type %s. Supported types are: sftp\n" %\
1648
(typestring)
1649
raise BzrCommandError(msg)
1650
1117
1651
hidden = True
1118
takes_args = ['testnames*']
1119
takes_options = ['verbose', 'pattern']
1120
def run(self, testnames_list=None, verbose=False, pattern=".*"):
1652
takes_args = ['testspecs*']
1653
takes_options = ['verbose',
1654
Option('one', help='stop when one test fails'),
1655
Option('keep-output',
1656
help='keep output directories when tests fail'),
1657
Option('transport',
1658
help='Use a different transport by default '
1659
'throughout the test suite.',
1660
type=get_transport_type),
1661
]
1662
1663
def run(self, testspecs_list=None, verbose=False, one=False,
1664
keep_output=False, transport=None):
1121
1665
import bzrlib.ui
1122
from bzrlib.selftest import selftest
1666
from bzrlib.tests import selftest
1123
1667
# we don't want progress meters from the tests to go to the
1124
1668
# real output; and we don't want log messages cluttering up
1125
1669
# the real logs.
1127
1671
bzrlib.trace.info('running tests...')
1128
1672
try:
1129
1673
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1674
if testspecs_list is not None:
1675
pattern = '|'.join(testspecs_list)
1676
else:
1677
pattern = ".*"
1130
1678
result = selftest(verbose=verbose,
1131
1679
pattern=pattern,
1132
testnames=testnames_list)
1680
stop_on_failure=one,
1681
keep_output=keep_output,
1682
transport=transport)
1133
1683
if result:
1134
1684
bzrlib.trace.info('tests passed')
1135
1685
else:
1139
1689
bzrlib.ui.ui_factory = save_ui
1140
1690
1141
1691
1692
def _get_bzr_branch():
1693
"""If bzr is run from a branch, return Branch or None"""
1694
import bzrlib.errors
1695
from bzrlib.branch import Branch
1696
from bzrlib.osutils import abspath
1697
from os.path import dirname
1698
1699
try:
1700
branch = Branch.open(dirname(abspath(dirname(__file__))))
1701
return branch
1702
except bzrlib.errors.BzrError:
1703
return None
1704
1705
1142
1706
def show_version():
1143
1707
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1144
1708
# is bzrlib itself in a branch?
1145
bzrrev = bzrlib.get_bzr_revision()
1146
if bzrrev:
1147
print " (bzr checkout, revision %d {%s})" % bzrrev
1709
branch = _get_bzr_branch()
1710
if branch:
1711
rh = branch.revision_history()
1712
revno = len(rh)
1713
print " bzr checkout, revision %d" % (revno,)
1714
print " nick: %s" % (branch.nick,)
1715
if rh:
1716
print " revid: %s" % (rh[-1],)
1148
1717
print bzrlib.__copyright__
1149
1718
print "http://bazaar-ng.org/"
1150
1719
print
1155
1724
1156
1725
class cmd_version(Command):
1157
1726
"""Show version of bzr."""
1727
@display_command
1158
1728
def run(self):
1159
1729
show_version()
1160
1730
1161
1731
class cmd_rocks(Command):
1162
1732
"""Statement of optimism."""
1163
1733
hidden = True
1734
@display_command
1164
1735
def run(self):
1165
1736
print "it sure does!"
1166
1737
1167
1738
1168
1739
class cmd_find_merge_base(Command):
1169
1740
"""Find and print a base revision for merging two branches.
1170
1171
TODO: Options to specify revisions on either side, as if
1172
merging only part of the history.
1173
1741
"""
1742
# TODO: Options to specify revisions on either side, as if
1743
# merging only part of the history.
1174
1744
takes_args = ['branch', 'other']
1175
1745
hidden = True
1176
1746
1747
@display_command
1177
1748
def run(self, branch, other):
1178
1749
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1179
1750
1180
branch1 = Branch.open_containing(branch)
1181
branch2 = Branch.open_containing(other)
1751
branch1 = Branch.open_containing(branch)[0]
1752
branch2 = Branch.open_containing(other)[0]
1182
1753
1183
1754
history_1 = branch1.revision_history()
1184
1755
history_2 = branch2.revision_history()
1186
1757
last1 = branch1.last_revision()
1187
1758
last2 = branch2.last_revision()
1188
1759
1189
source = MultipleRevisionSources(branch1, branch2)
1760
source = MultipleRevisionSources(branch1.repository,
1761
branch2.repository)
1190
1762
1191
1763
base_rev_id = common_ancestor(last1, last2, source)
1192
1764
1214
1786
will be used as a BASE, and the second one as OTHER. Revision
1215
1787
numbers are always relative to the specified branch.
1216
1788
1217
By default bzr will try to merge in all new work from the other
1789
By default, bzr will try to merge in all new work from the other
1218
1790
branch, automatically determining an appropriate base. If this
1219
1791
fails, you may need to give an explicit base.
1220
1792
1793
Merge will do its best to combine the changes in two branches, but there
1794
are some kinds of problems only a human can fix. When it encounters those,
1795
it will mark a conflict. A conflict means that you need to fix something,
1796
before you should commit.
1797
1798
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
1799
1221
1800
Examples:
1222
1801
1223
1802
To merge the latest revision from bzr.dev
1233
1812
--force is given.
1234
1813
"""
1235
1814
takes_args = ['branch?']
1236
takes_options = ['revision', 'force', 'merge-type']
1815
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1816
Option('show-base', help="Show base revision text in "
1817
"conflicts")]
1237
1818
1238
def run(self, branch='.', revision=None, force=False,
1239
merge_type=None):
1240
from bzrlib.merge import merge
1241
from bzrlib.merge_core import ApplyMerge3
1819
def run(self, branch=None, revision=None, force=False, merge_type=None,
1820
show_base=False, reprocess=False):
1242
1821
if merge_type is None:
1243
merge_type = ApplyMerge3
1244
1822
merge_type = Merge3Merger
1823
if branch is None:
1824
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1825
if branch is None:
1826
raise BzrCommandError("No merge location known or specified.")
1827
else:
1828
print "Using saved location: %s" % branch
1245
1829
if revision is None or len(revision) < 1:
1246
1830
base = [None, None]
1247
1831
other = [branch, -1]
1248
1832
else:
1249
1833
if len(revision) == 1:
1250
1834
base = [None, None]
1251
other = [branch, revision[0].in_history(branch).revno]
1835
other_branch = Branch.open_containing(branch)[0]
1836
revno = revision[0].in_history(other_branch).revno
1837
other = [branch, revno]
1252
1838
else:
1253
1839
assert len(revision) == 2
1254
1840
if None in revision:
1255
1841
raise BzrCommandError(
1256
1842
"Merge doesn't permit that revision specifier.")
1257
b = Branch.open(branch)
1843
b = Branch.open_containing(branch)[0]
1258
1844
1259
1845
base = [branch, revision[0].in_history(b).revno]
1260
1846
other = [branch, revision[1].in_history(b).revno]
1261
1847
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1262
1848
try:
1263
merge(other, base, check_clean=(not force), merge_type=merge_type)
1849
try:
1850
conflict_count = merge(other, base, check_clean=(not force),
1851
merge_type=merge_type,
1852
reprocess=reprocess,
1853
show_base=show_base,
1854
pb=pb)
1855
finally:
1856
pb.finished()
1857
if conflict_count != 0:
1858
return 1
1859
else:
1860
return 0
1264
1861
except bzrlib.errors.AmbiguousBase, e:
1265
1862
m = ("sorry, bzr can't determine the right merge base yet\n"
1266
1863
"candidates are:\n "
1271
1868
log_error(m)
1272
1869
1273
1870
1871
class cmd_remerge(Command):
1872
"""Redo a merge.
1873
"""
1874
takes_args = ['file*']
1875
takes_options = ['merge-type', 'reprocess',
1876
Option('show-base', help="Show base revision text in "
1877
"conflicts")]
1878
1879
def run(self, file_list=None, merge_type=None, show_base=False,
1880
reprocess=False):
1881
from bzrlib.merge import merge_inner, transform_tree
1882
if merge_type is None:
1883
merge_type = Merge3Merger
1884
tree, file_list = tree_files(file_list)
1885
tree.lock_write()
1886
try:
1887
pending_merges = tree.pending_merges()
1888
if len(pending_merges) != 1:
1889
raise BzrCommandError("Sorry, remerge only works after normal"
1890
+ " merges. Not cherrypicking or"
1891
+ "multi-merges.")
1892
repository = tree.branch.repository
1893
base_revision = common_ancestor(tree.branch.last_revision(),
1894
pending_merges[0], repository)
1895
base_tree = repository.revision_tree(base_revision)
1896
other_tree = repository.revision_tree(pending_merges[0])
1897
interesting_ids = None
1898
if file_list is not None:
1899
interesting_ids = set()
1900
for filename in file_list:
1901
file_id = tree.path2id(filename)
1902
if file_id is None:
1903
raise NotVersionedError(filename)
1904
interesting_ids.add(file_id)
1905
if tree.kind(file_id) != "directory":
1906
continue
1907
1908
for name, ie in tree.inventory.iter_entries(file_id):
1909
interesting_ids.add(ie.file_id)
1910
transform_tree(tree, tree.basis_tree(), interesting_ids)
1911
if file_list is None:
1912
restore_files = list(tree.iter_conflicts())
1913
else:
1914
restore_files = file_list
1915
for filename in restore_files:
1916
try:
1917
restore(tree.abspath(filename))
1918
except NotConflicted:
1919
pass
1920
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1921
this_tree=tree,
1922
interesting_ids = interesting_ids,
1923
other_rev_id=pending_merges[0],
1924
merge_type=merge_type,
1925
show_base=show_base,
1926
reprocess=reprocess)
1927
finally:
1928
tree.unlock()
1929
if conflicts > 0:
1930
return 1
1931
else:
1932
return 0
1933
1274
1934
class cmd_revert(Command):
1275
1935
"""Reverse all changes since the last commit.
1276
1936
1283
1943
aliases = ['merge-revert']
1284
1944
1285
1945
def run(self, revision=None, no_backup=False, file_list=None):
1286
from bzrlib.merge import merge
1287
1946
from bzrlib.commands import parse_spec
1288
1289
1947
if file_list is not None:
1290
1948
if len(file_list) == 0:
1291
1949
raise BzrCommandError("No files specified")
1950
else:
1951
file_list = []
1952
1953
tree, file_list = tree_files(file_list)
1292
1954
if revision is None:
1293
revno = -1
1955
# FIXME should be tree.last_revision
1956
rev_id = tree.last_revision()
1294
1957
elif len(revision) != 1:
1295
1958
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1296
1959
else:
1297
b = Branch.open_containing('.')
1298
revno = revision[0].in_history(b).revno
1299
merge(('.', revno), parse_spec('.'),
1300
check_clean=False,
1301
ignore_zero=True,
1302
backup_files=not no_backup,
1303
file_list=file_list)
1304
if not file_list:
1305
Branch.open_containing('.').set_pending_merges([])
1960
rev_id = revision[0].in_history(tree.branch).rev_id
1961
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1962
try:
1963
tree.revert(file_list,
1964
tree.branch.repository.revision_tree(rev_id),
1965
not no_backup, pb)
1966
finally:
1967
pb.finished()
1306
1968
1307
1969
1308
1970
class cmd_assert_fail(Command):
1316
1978
"""Show help on a command or other topic.
1317
1979
1318
1980
For a list of all available commands, say 'bzr help commands'."""
1319
takes_options = ['long']
1981
takes_options = [Option('long', 'show help on all commands')]
1320
1982
takes_args = ['topic?']
1321
1983
aliases = ['?']
1322
1984
1985
@display_command
1323
1986
def run(self, topic=None, long=False):
1324
1987
import help
1325
1988
if topic is None and long:
1335
1998
aliases = ['s-c']
1336
1999
hidden = True
1337
2000
2001
@display_command
1338
2002
def run(self, context=None):
1339
2003
import shellcomplete
1340
2004
shellcomplete.shellcomplete(context)
1349
2013
def run(self, from_branch, to_branch):
1350
2014
from bzrlib.fetch import Fetcher
1351
2015
from bzrlib.branch import Branch
1352
from_b = Branch(from_branch)
1353
to_b = Branch(to_branch)
2016
from_b = Branch.open(from_branch)
2017
to_b = Branch.open(to_branch)
1354
2018
Fetcher(to_b, from_b)
1355
1356
2019
1357
2020
1358
2021
class cmd_missing(Command):
1359
"""What is missing in this branch relative to other branch.
1360
"""
1361
# TODO: rewrite this in terms of ancestry so that it shows only
1362
# unmerged things
1363
1364
takes_args = ['remote?']
1365
aliases = ['mis', 'miss']
1366
# We don't have to add quiet to the list, because
1367
# unknown options are parsed as booleans
1368
takes_options = ['verbose', 'quiet']
1369
1370
def run(self, remote=None, verbose=False, quiet=False):
1371
from bzrlib.errors import BzrCommandError
1372
from bzrlib.missing import show_missing
1373
1374
if verbose and quiet:
1375
raise BzrCommandError('Cannot pass both quiet and verbose')
1376
1377
b = Branch.open_containing('.')
1378
parent = b.get_parent()
1379
if remote is None:
1380
if parent is None:
2022
"""Show unmerged/unpulled revisions between two branches.
2023
2024
OTHER_BRANCH may be local or remote."""
2025
takes_args = ['other_branch?']
2026
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2027
Option('mine-only',
2028
'Display changes in the local branch only'),
2029
Option('theirs-only',
2030
'Display changes in the remote branch only'),
2031
'log-format',
2032
'line',
2033
'long',
2034
'short',
2035
'show-ids',
2036
'verbose'
2037
]
2038
2039
def run(self, other_branch=None, reverse=False, mine_only=False,
2040
theirs_only=False, log_format=None, long=False, short=False, line=False,
2041
show_ids=False, verbose=False):
2042
from bzrlib.missing import find_unmerged, iter_log_data
2043
from bzrlib.log import log_formatter
2044
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2045
parent = local_branch.get_parent()
2046
if other_branch is None:
2047
other_branch = parent
2048
if other_branch is None:
1381
2049
raise BzrCommandError("No missing location known or specified.")
1382
else:
1383
if not quiet:
1384
print "Using last location: %s" % parent
1385
remote = parent
1386
elif parent is None:
1387
# We only update parent if it did not exist, missing
1388
# should not change the parent
1389
b.set_parent(remote)
1390
br_remote = Branch.open_containing(remote)
1391
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
2050
print "Using last location: " + local_branch.get_parent()
2051
remote_branch = bzrlib.branch.Branch.open(other_branch)
2052
remote_branch.lock_read()
2053
try:
2054
local_branch.lock_write()
2055
try:
2056
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2057
if (log_format == None):
2058
default = bzrlib.config.BranchConfig(local_branch).log_format()
2059
log_format = get_log_format(long=long, short=short, line=line, default=default)
2060
lf = log_formatter(log_format, sys.stdout,
2061
show_ids=show_ids,
2062
show_timezone='original')
2063
if reverse is False:
2064
local_extra.reverse()
2065
remote_extra.reverse()
2066
if local_extra and not theirs_only:
2067
print "You have %d extra revision(s):" % len(local_extra)
2068
for data in iter_log_data(local_extra, local_branch.repository,
2069
verbose):
2070
lf.show(*data)
2071
printed_local = True
2072
else:
2073
printed_local = False
2074
if remote_extra and not mine_only:
2075
if printed_local is True:
2076
print "\n\n"
2077
print "You are missing %d revision(s):" % len(remote_extra)
2078
for data in iter_log_data(remote_extra, remote_branch.repository,
2079
verbose):
2080
lf.show(*data)
2081
if not remote_extra and not local_extra:
2082
status_code = 0
2083
print "Branches are up to date."
2084
else:
2085
status_code = 1
2086
if parent is None and other_branch is not None:
2087
local_branch.set_parent(other_branch)
2088
return status_code
2089
finally:
2090
local_branch.unlock()
2091
finally:
2092
remote_branch.unlock()
1392
2093
1393
2094
1394
2095
class cmd_plugins(Command):
1395
2096
"""List plugins"""
1396
2097
hidden = True
2098
@display_command
1397
2099
def run(self):
1398
2100
import bzrlib.plugin
1399
2101
from inspect import getdoc
1400
for plugin in bzrlib.plugin.all_plugins:
2102
for name, plugin in bzrlib.plugin.all_plugins().items():
1401
2103
if hasattr(plugin, '__path__'):
1402
2104
print plugin.__path__[0]
1403
2105
elif hasattr(plugin, '__file__'):
1410
2112
print '\t', d.split('\n')[0]
1411
2113
1412
2114
2115
class cmd_testament(Command):
2116
"""Show testament (signing-form) of a revision."""
2117
takes_options = ['revision', 'long']
2118
takes_args = ['branch?']
2119
@display_command
2120
def run(self, branch=u'.', revision=None, long=False):
2121
from bzrlib.testament import Testament
2122
b = WorkingTree.open_containing(branch)[0].branch
2123
b.lock_read()
2124
try:
2125
if revision is None:
2126
rev_id = b.last_revision()
2127
else:
2128
rev_id = revision[0].in_history(b).rev_id
2129
t = Testament.from_revision(b.repository, rev_id)
2130
if long:
2131
sys.stdout.writelines(t.as_text_lines())
2132
else:
2133
sys.stdout.write(t.as_short_text())
2134
finally:
2135
b.unlock()
2136
2137
2138
class cmd_annotate(Command):
2139
"""Show the origin of each line in a file.
2140
2141
This prints out the given file with an annotation on the left side
2142
indicating which revision, author and date introduced the change.
2143
2144
If the origin is the same for a run of consecutive lines, it is
2145
shown only at the top, unless the --all option is given.
2146
"""
2147
# TODO: annotate directories; showing when each file was last changed
2148
# TODO: annotate a previous version of a file
2149
# TODO: if the working copy is modified, show annotations on that
2150
# with new uncommitted lines marked
2151
aliases = ['blame', 'praise']
2152
takes_args = ['filename']
2153
takes_options = [Option('all', help='show annotations on all lines'),
2154
Option('long', help='show date in annotations'),
2155
]
2156
2157
@display_command
2158
def run(self, filename, all=False, long=False):
2159
from bzrlib.annotate import annotate_file
2160
tree, relpath = WorkingTree.open_containing(filename)
2161
branch = tree.branch
2162
branch.lock_read()
2163
try:
2164
file_id = tree.inventory.path2id(relpath)
2165
tree = branch.repository.revision_tree(branch.last_revision())
2166
file_version = tree.inventory[file_id].revision
2167
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2168
finally:
2169
branch.unlock()
2170
2171
2172
class cmd_re_sign(Command):
2173
"""Create a digital signature for an existing revision."""
2174
# TODO be able to replace existing ones.
2175
2176
hidden = True # is this right ?
2177
takes_args = ['revision_id*']
2178
takes_options = ['revision']
2179
2180
def run(self, revision_id_list=None, revision=None):
2181
import bzrlib.config as config
2182
import bzrlib.gpg as gpg
2183
if revision_id_list is not None and revision is not None:
2184
raise BzrCommandError('You can only supply one of revision_id or --revision')
2185
if revision_id_list is None and revision is None:
2186
raise BzrCommandError('You must supply either --revision or a revision_id')
2187
b = WorkingTree.open_containing(u'.')[0].branch
2188
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2189
if revision_id_list is not None:
2190
for revision_id in revision_id_list:
2191
b.repository.sign_revision(revision_id, gpg_strategy)
2192
elif revision is not None:
2193
if len(revision) == 1:
2194
revno, rev_id = revision[0].in_history(b)
2195
b.repository.sign_revision(rev_id, gpg_strategy)
2196
elif len(revision) == 2:
2197
# are they both on rh- if so we can walk between them
2198
# might be nice to have a range helper for arbitrary
2199
# revision paths. hmm.
2200
from_revno, from_revid = revision[0].in_history(b)
2201
to_revno, to_revid = revision[1].in_history(b)
2202
if to_revid is None:
2203
to_revno = b.revno()
2204
if from_revno is None or to_revno is None:
2205
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2206
for revno in range(from_revno, to_revno + 1):
2207
b.repository.sign_revision(b.get_rev_id(revno),
2208
gpg_strategy)
2209
else:
2210
raise BzrCommandError('Please supply either one revision, or a range.')
2211
2212
2213
class cmd_bind(Command):
2214
"""Bind the current branch to a master branch.
2215
2216
After binding, commits must succeed on the master branch
2217
before they are executed on the local one.
2218
"""
2219
2220
takes_args = ['location']
2221
takes_options = []
2222
2223
def run(self, location=None):
2224
b, relpath = Branch.open_containing(u'.')
2225
b_other = Branch.open(location)
2226
try:
2227
b.bind(b_other)
2228
except DivergedBranches:
2229
raise BzrCommandError('These branches have diverged.'
2230
' Try merging, and then bind again.')
2231
2232
2233
class cmd_unbind(Command):
2234
"""Bind the current branch to its parent.
2235
2236
After unbinding, the local branch is considered independent.
2237
"""
2238
2239
takes_args = []
2240
takes_options = []
2241
2242
def run(self):
2243
b, relpath = Branch.open_containing(u'.')
2244
if not b.unbind():
2245
raise BzrCommandError('Local branch is not bound')
2246
2247
2248
class cmd_uncommit(bzrlib.commands.Command):
2249
"""Remove the last committed revision.
2250
2251
By supplying the --all flag, it will not only remove the entry
2252
from revision_history, but also remove all of the entries in the
2253
stores.
2254
2255
--verbose will print out what is being removed.
2256
--dry-run will go through all the motions, but not actually
2257
remove anything.
2258
2259
In the future, uncommit will create a changeset, which can then
2260
be re-applied.
2261
"""
2262
2263
# TODO: jam 20060108 Add an option to allow uncommit to remove
2264
# unreferenced information in 'branch-as-repostory' branches.
2265
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2266
# information in shared branches as well.
2267
takes_options = ['verbose', 'revision',
2268
Option('dry-run', help='Don\'t actually make changes'),
2269
Option('force', help='Say yes to all questions.')]
2270
takes_args = ['location?']
2271
aliases = []
2272
2273
def run(self, location=None,
2274
dry_run=False, verbose=False,
2275
revision=None, force=False):
2276
from bzrlib.branch import Branch
2277
from bzrlib.log import log_formatter
2278
import sys
2279
from bzrlib.uncommit import uncommit
2280
2281
if location is None:
2282
location = u'.'
2283
control, relpath = bzrdir.BzrDir.open_containing(location)
2284
b = control.open_branch()
2285
try:
2286
tree = control.open_workingtree()
2287
except (errors.NoWorkingTree, errors.NotLocalUrl):
2288
tree = None
2289
2290
if revision is None:
2291
revno = b.revno()
2292
rev_id = b.last_revision()
2293
else:
2294
revno, rev_id = revision[0].in_history(b)
2295
if rev_id is None:
2296
print 'No revisions to uncommit.'
2297
2298
for r in range(revno, b.revno()+1):
2299
rev_id = b.get_rev_id(r)
2300
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2301
lf.show(r, b.repository.get_revision(rev_id), None)
2302
2303
if dry_run:
2304
print 'Dry-run, pretending to remove the above revisions.'
2305
if not force:
2306
val = raw_input('Press <enter> to continue')
2307
else:
2308
print 'The above revision(s) will be removed.'
2309
if not force:
2310
val = raw_input('Are you sure [y/N]? ')
2311
if val.lower() not in ('y', 'yes'):
2312
print 'Canceled'
2313
return 0
2314
2315
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2316
revno=revno)
2317
2318
2319
class cmd_break_lock(Command):
2320
"""Break a dead lock on a repository, branch or working directory.
2321
2322
CAUTION: Locks should only be broken when you are sure that the process
2323
holding the lock has been stopped.
2324
2325
example:
2326
bzr break-lock .
2327
"""
2328
takes_args = ['location']
2329
takes_options = [Option('show',
2330
help="just show information on the lock, " \
2331
"don't break it"),
2332
]
2333
def run(self, location, show=False):
2334
d = bzrdir.BzrDir.open(location)
2335
repo = d.open_repository()
2336
if not repo.is_locked():
2337
raise errors.ObjectNotLocked(repo)
2338
2339
2340
# command-line interpretation helper for merge-related commands
2341
def merge(other_revision, base_revision,
2342
check_clean=True, ignore_zero=False,
2343
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2344
file_list=None, show_base=False, reprocess=False,
2345
pb=DummyProgress()):
2346
"""Merge changes into a tree.
2347
2348
base_revision
2349
list(path, revno) Base for three-way merge.
2350
If [None, None] then a base will be automatically determined.
2351
other_revision
2352
list(path, revno) Other revision for three-way merge.
2353
this_dir
2354
Directory to merge changes into; '.' by default.
2355
check_clean
2356
If true, this_dir must have no uncommitted changes before the
2357
merge begins.
2358
ignore_zero - If true, suppress the "zero conflicts" message when
2359
there are no conflicts; should be set when doing something we expect
2360
to complete perfectly.
2361
file_list - If supplied, merge only changes to selected files.
2362
2363
All available ancestors of other_revision and base_revision are
2364
automatically pulled into the branch.
2365
2366
The revno may be -1 to indicate the last revision on the branch, which is
2367
the typical case.
2368
2369
This function is intended for use from the command line; programmatic
2370
clients might prefer to call merge.merge_inner(), which has less magic
2371
behavior.
2372
"""
2373
from bzrlib.merge import Merger
2374
if this_dir is None:
2375
this_dir = u'.'
2376
this_tree = WorkingTree.open_containing(this_dir)[0]
2377
if show_base and not merge_type is Merge3Merger:
2378
raise BzrCommandError("Show-base is not supported for this merge"
2379
" type. %s" % merge_type)
2380
if reprocess and not merge_type is Merge3Merger:
2381
raise BzrCommandError("Reprocess is not supported for this merge"
2382
" type. %s" % merge_type)
2383
if reprocess and show_base:
2384
raise BzrCommandError("Cannot reprocess and show base.")
2385
try:
2386
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2387
merger.pp = ProgressPhase("Merge phase", 5, pb)
2388
merger.pp.next_phase()
2389
merger.check_basis(check_clean)
2390
merger.set_other(other_revision)
2391
merger.pp.next_phase()
2392
merger.set_base(base_revision)
2393
if merger.base_rev_id == merger.other_rev_id:
2394
note('Nothing to do.')
2395
return 0
2396
merger.backup_files = backup_files
2397
merger.merge_type = merge_type
2398
merger.set_interesting_files(file_list)
2399
merger.show_base = show_base
2400
merger.reprocess = reprocess
2401
conflicts = merger.do_merge()
2402
merger.set_pending()
2403
finally:
2404
pb.clear()
2405
return conflicts
2406
2407
2408
# these get imported and then picked up by the scan for cmd_*
2409
# TODO: Some more consistent way to split command definitions across files;
2410
# we do need to load at least some information about them to know of
2411
# aliases.
2412
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2413
from bzrlib.sign_my_commits import cmd_sign_my_commits
Loggerhead is a web-based interface for Breezy
Version: 2.0.1