« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1614.2.8
- compare with another revision
- download diff
- download tarball
- view history from revision 1614.2.8
- Committer: Olaf Conradi
- Date: 2006-03-28 23:30:02 UTC
- mto: (1661.1.1 bzr.mbp.remember)
- mto: This revision was merged to the branch mainline in revision 1663.
- Revision ID: olaf@conradi.org-20060328233002-f6262df0e19c1963
Added testcases for using pull with --remember. Moved remember code to
beginning of cmd_pull. This remembers the location in case of a failure
during pull.
beginning of cmd_pull. This remembers the location in case of a failure
during pull.
- 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/transport/http
- 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/testannotate.py => bzrlib/tests/test_annotate.py
- bzrlib/selftest/testconfig.py => bzrlib/tests/test_config.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testfetch.py => bzrlib/tests/test_fetch.py
- bzrlib/selftest/testgpg.py => bzrlib/tests/test_gpg.py
- bzrlib/selftest/testgraph.py => bzrlib/tests/test_graph.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testhttp.py => bzrlib/tests/test_http.py
- bzrlib/selftest/testidentitymap.py => bzrlib/tests/test_identitymap.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/testnonascii.py => bzrlib/tests/test_nonascii.py
- bzrlib/selftest/testoptions.py => bzrlib/tests/test_options.py
- bzrlib/selftest/testplugins.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/testrevprops.py => bzrlib/tests/test_revprops.py
- bzrlib/selftest/testsampler.py => bzrlib/tests/test_sampler.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- bzrlib/selftest/testtestament.py => bzrlib/tests/test_testament.py
- bzrlib/selftest/testtransactions.py => bzrlib/tests/test_transactions.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/transport/http.py => bzrlib/transport/http/__init__.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
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
22
from bzrlib import BZRDIR
23
from bzrlib.commands import Command
26
import bzrlib.branch
24
27
from bzrlib.branch import Branch
25
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
26
from bzrlib.errors import DivergedBranches
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
27
38
from bzrlib.option import Option
39
from bzrlib.progress import DummyProgress, ProgressPhase
28
40
from bzrlib.revisionspec import RevisionSpec
29
41
import bzrlib.trace
30
from bzrlib.trace import mutter, note, log_error, warning
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
43
from bzrlib.transport.local import LocalTransport
44
import bzrlib.ui
31
45
from bzrlib.workingtree import WorkingTree
32
46
33
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?)
91
34
92
class cmd_status(Command):
35
93
"""Display status summary.
36
94
71
129
that revision, or between two revisions if two are provided.
72
130
"""
73
131
74
# XXX: FIXME: bzr status should accept a -r option to show changes
75
# relative to a revision, or between revisions
76
77
132
# TODO: --no-recurse, --recurse options
78
133
79
134
takes_args = ['file*']
80
takes_options = ['all', 'show-ids']
135
takes_options = ['all', 'show-ids', 'revision']
81
136
aliases = ['st', 'stat']
82
137
138
@display_command
83
139
def run(self, all=False, show_ids=False, file_list=None, revision=None):
84
if file_list:
85
b, relpath = Branch.open_containing(file_list[0])
86
if relpath == '' and len(file_list) == 1:
87
file_list = None
88
else:
89
# generate relative paths.
90
# note that if this is a remote branch, we would want
91
# relpath against the transport. RBC 20051018
92
tree = WorkingTree(b.base, b)
93
file_list = [tree.relpath(x) for x in file_list]
94
else:
95
b = Branch.open_containing('.')[0]
140
tree, file_list = tree_files(file_list)
96
141
97
from bzrlib.status import show_status
98
show_status(b, show_unchanged=all, show_ids=show_ids,
99
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)
100
145
101
146
102
147
class cmd_cat_revision(Command):
110
155
takes_args = ['revision_id?']
111
156
takes_options = ['revision']
112
157
158
@display_command
113
159
def run(self, revision_id=None, revision=None):
114
160
115
161
if revision_id is not None and revision is not None:
116
162
raise BzrCommandError('You can only supply one of revision_id or --revision')
117
163
if revision_id is None and revision is None:
118
164
raise BzrCommandError('You must supply either --revision or a revision_id')
119
b = Branch.open_containing('.')[0]
165
b = WorkingTree.open_containing(u'.')[0].branch
120
166
if revision_id is not None:
121
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
167
sys.stdout.write(b.repository.get_revision_xml(revision_id))
122
168
elif revision is not None:
123
169
for rev in revision:
124
170
if rev is None:
125
171
raise BzrCommandError('You cannot specify a NULL revision.')
126
172
revno, rev_id = rev.in_history(b)
127
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
173
sys.stdout.write(b.repository.get_revision_xml(rev_id))
128
174
129
175
130
176
class cmd_revno(Command):
131
177
"""Show current revision number.
132
178
133
179
This is equal to the number of revisions on this branch."""
134
def run(self):
135
print Branch.open_containing('.')[0].revno()
180
takes_args = ['location?']
181
@display_command
182
def run(self, location=u'.'):
183
print Branch.open_containing(location)[0].revno()
136
184
137
185
138
186
class cmd_revision_info(Command):
141
189
hidden = True
142
190
takes_args = ['revision_info*']
143
191
takes_options = ['revision']
192
@display_command
144
193
def run(self, revision=None, revision_info_list=[]):
145
194
146
195
revs = []
152
201
if len(revs) == 0:
153
202
raise BzrCommandError('You must supply a revision identifier')
154
203
155
b = Branch.open_containing('.')[0]
204
b = WorkingTree.open_containing(u'.')[0].branch
156
205
157
206
for rev in revs:
158
207
revinfo = rev.in_history(b)
184
233
implicitly add the parent, and so on up to the root. This means
185
234
you should never need to explictly add a directory, they'll just
186
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.
187
239
"""
188
240
takes_args = ['file*']
189
takes_options = ['no-recurse', 'quiet']
190
191
def run(self, file_list, no_recurse=False, quiet=False):
192
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
193
if quiet:
194
reporter = add_reporter_null
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
195
254
else:
196
reporter = add_reporter_print
197
smart_add(file_list, not no_recurse, reporter)
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."
198
270
199
271
200
272
class cmd_mkdir(Command):
205
277
takes_args = ['dir+']
206
278
207
279
def run(self, dir_list):
208
b = None
209
210
280
for d in dir_list:
211
281
os.mkdir(d)
212
if not b:
213
b = Branch.open_containing(d)[0]
214
b.add([d])
282
wt, dd = WorkingTree.open_containing(d)
283
wt.add([dd])
215
284
print 'added', d
216
285
217
286
220
289
takes_args = ['filename']
221
290
hidden = True
222
291
292
@display_command
223
293
def run(self, filename):
224
branch, relpath = Branch.open_containing(filename)
294
tree, relpath = WorkingTree.open_containing(filename)
225
295
print relpath
226
296
227
297
228
298
class cmd_inventory(Command):
229
"""Show inventory of the current working copy or a revision."""
230
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']
231
305
232
def run(self, revision=None, show_ids=False):
233
b = Branch.open_containing('.')[0]
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]
234
311
if revision is None:
235
inv = b.read_working_inventory()
312
inv = tree.read_working_inventory()
236
313
else:
237
314
if len(revision) > 1:
238
315
raise BzrCommandError('bzr inventory --revision takes'
239
316
' exactly one revision identifier')
240
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)
241
319
242
320
for path, entry in inv.entries():
321
if kind and kind != entry.kind:
322
continue
243
323
if show_ids:
244
324
print '%-50s %s' % (path, entry.file_id)
245
325
else:
256
336
"""
257
337
takes_args = ['source$', 'dest']
258
338
def run(self, source_list, dest):
259
b = Branch.open_containing('.')[0]
260
339
tree, source_list = tree_files(source_list)
261
340
# TODO: glob expansion on windows?
262
tree = WorkingTree(b.base, b)
263
b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
341
tree.move(source_list, tree.relpath(dest))
264
342
265
343
266
344
class cmd_rename(Command):
280
358
takes_args = ['from_name', 'to_name']
281
359
282
360
def run(self, from_name, to_name):
283
b = Branch.open_containing('.')[0]
284
tree = WorkingTree(b.base, b)
285
b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
361
tree, (from_name, to_name) = tree_files((from_name, to_name))
362
tree.rename_one(from_name, to_name)
286
363
287
364
288
365
class cmd_mv(Command):
302
379
def run(self, names_list):
303
380
if len(names_list) < 2:
304
381
raise BzrCommandError("missing file argument")
305
b = Branch.open_containing(names_list[0])[0]
306
tree = WorkingTree(b.base, b)
307
rel_names = [tree.relpath(x) for x in names_list]
382
tree, rel_names = tree_files(names_list)
308
383
309
384
if os.path.isdir(names_list[-1]):
310
385
# move into existing directory
311
for pair in b.move(rel_names[:-1], rel_names[-1]):
386
for pair in tree.move(rel_names[:-1], rel_names[-1]):
312
387
print "%s => %s" % pair
313
388
else:
314
389
if len(names_list) != 2:
315
390
raise BzrCommandError('to mv multiple files the destination '
316
391
'must be a versioned directory')
317
b.rename_one(rel_names[0], rel_names[1])
392
tree.rename_one(rel_names[0], rel_names[1])
318
393
print "%s => %s" % (rel_names[0], rel_names[1])
319
394
320
395
321
322
323
396
class cmd_pull(Command):
324
397
"""Pull any changes from another branch into the current one.
325
398
326
If the location is omitted, the last-used location will be used.
327
Both the revision history and the working directory will be
328
updated.
329
330
399
This command only works on branches that have not diverged. Branches are
331
400
considered diverged if both branches have had commits without first
332
401
pulling from the other.
333
402
334
403
If branches have diverged, you can use 'bzr merge' to pull the text changes
335
from one into the other.
404
from one into the other. Once one branch has merged, the other should
405
be able to pull it again.
406
407
If you want to forget your local changes and just update your branch to
408
match the remote one, use --overwrite.
409
410
If there is no default location set, the first pull will set it. After
411
that, you can omit the location to use the default. To change the
412
default, use --remember.
336
413
"""
337
takes_options = ['remember', 'clobber']
414
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
338
415
takes_args = ['location?']
339
416
340
def run(self, location=None, remember=False, clobber=False):
341
from bzrlib.merge import merge
342
import tempfile
343
from shutil import rmtree
344
import errno
345
346
br_to = Branch.open_containing('.')[0]
347
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
br_to = tree_to.branch
421
stored_loc = tree_to.branch.get_parent()
348
422
if location is None:
349
423
if stored_loc is None:
350
424
raise BzrCommandError("No pull location known or specified.")
351
425
else:
352
426
print "Using saved location: %s" % stored_loc
353
427
location = stored_loc
428
429
if br_to.get_parent() is None or remember:
430
br_to.set_parent(location)
431
354
432
br_from = Branch.open(location)
355
try:
356
br_to.working_tree().pull(br_from, remember, clobber)
433
434
if revision is None:
435
rev_id = None
436
elif len(revision) == 1:
437
rev_id = revision[0].in_history(br_from).rev_id
438
else:
439
raise BzrCommandError('bzr pull --revision takes one value.')
440
441
old_rh = br_to.revision_history()
442
count = tree_to.pull(br_from, overwrite, rev_id)
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
This command only works on branches that have not diverged. Branches are
462
considered diverged if the branch being pushed to is not an older version
463
of this branch.
464
465
If branches have diverged, you can use 'bzr push --overwrite' to replace
466
the other branch completely.
467
468
If you want to ensure you have the different changes in the other branch,
469
do a merge (see bzr help merge) from the other branch, and commit that
470
before doing a 'push --overwrite'.
471
472
If there is no default push location set, the first push will set it.
473
After that, you can omit the location to use the default. To change the
474
default, use --remember.
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:
528
try:
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)
357
540
except DivergedBranches:
358
541
raise BzrCommandError("These branches have diverged."
359
" Try merge.")
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,))
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)
360
553
361
554
362
555
class cmd_branch(Command):
377
570
aliases = ['get', 'clone']
378
571
379
572
def run(self, from_location, to_location=None, revision=None, basis=None):
380
from bzrlib.clone import copy_branch
381
import tempfile
382
import errno
383
from shutil import rmtree
384
cache_root = tempfile.mkdtemp()
385
573
if revision is None:
386
574
revision = [None]
387
575
elif len(revision) > 1:
397
585
raise
398
586
br_from.lock_read()
399
587
try:
400
br_from.setup_caching(cache_root)
401
588
if basis is not None:
402
basis_branch = Branch.open_containing(basis)[0]
589
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
403
590
else:
404
basis_branch = None
591
basis_dir = None
405
592
if len(revision) == 1 and revision[0] is not None:
406
593
revision_id = revision[0].in_history(br_from)[1]
407
594
else:
408
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()
409
599
if to_location is None:
410
600
to_location = os.path.basename(from_location.rstrip("/\\"))
601
name = None
602
else:
603
name = os.path.basename(to_location) + '\n'
411
604
try:
412
605
os.mkdir(to_location)
413
606
except OSError, e:
420
613
else:
421
614
raise
422
615
try:
423
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()
424
619
except bzrlib.errors.NoSuchRevision:
425
620
rmtree(to_location)
426
621
msg = "The branch %s has no revision %s." % (from_location, revision[0])
427
622
raise BzrCommandError(msg)
428
623
except bzrlib.errors.UnlistableBranch:
429
msg = "The branch %s cannot be used as a --basis"
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())
430
631
finally:
431
632
br_from.unlock()
432
rmtree(cache_root)
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)
433
703
434
704
435
705
class cmd_renames(Command):
440
710
# TODO: Only show renames under dir, rather than in the whole branch.
441
711
takes_args = ['dir?']
442
712
443
def run(self, dir='.'):
444
b = Branch.open_containing(dir)[0]
445
old_inv = b.basis_tree().inventory
446
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()
447
718
448
719
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
449
720
renames.sort()
451
722
print "%s => %s" % (old_name, new_name)
452
723
453
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
454
758
class cmd_info(Command):
455
759
"""Show statistical information about a branch."""
456
760
takes_args = ['branch?']
457
761
762
@display_command
458
763
def run(self, branch=None):
459
import info
460
b = Branch.open_containing(branch)[0]
461
info.show_info(b)
764
import bzrlib.info
765
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0])
462
766
463
767
464
768
class cmd_remove(Command):
472
776
aliases = ['rm']
473
777
474
778
def run(self, file_list, verbose=False):
475
b = Branch.open_containing(file_list[0])[0]
476
tree = WorkingTree(b.base, b)
477
tree.remove([tree.relpath(f) for f in file_list], verbose=verbose)
779
tree, file_list = tree_files(file_list)
780
tree.remove(file_list, verbose=verbose)
478
781
479
782
480
783
class cmd_file_id(Command):
486
789
"""
487
790
hidden = True
488
791
takes_args = ['filename']
792
@display_command
489
793
def run(self, filename):
490
b, relpath = Branch.open_containing(filename)
491
i = b.inventory.path2id(relpath)
794
tree, relpath = WorkingTree.open_containing(filename)
795
i = tree.inventory.path2id(relpath)
492
796
if i == None:
493
797
raise BzrError("%r is not a versioned file" % filename)
494
798
else:
502
806
starting at the branch root."""
503
807
hidden = True
504
808
takes_args = ['filename']
809
@display_command
505
810
def run(self, filename):
506
b, relpath = Branch.open_containing(filename)
507
inv = b.inventory
811
tree, relpath = WorkingTree.open_containing(filename)
812
inv = tree.inventory
508
813
fid = inv.path2id(relpath)
509
814
if fid == None:
510
815
raise BzrError("%r is not a versioned file" % filename)
512
817
print fip
513
818
514
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
515
846
class cmd_revision_history(Command):
516
847
"""Display list of revision ids on this branch."""
517
848
hidden = True
849
@display_command
518
850
def run(self):
519
for patchid in Branch.open_containing('.')[0].revision_history():
851
branch = WorkingTree.open_containing(u'.')[0].branch
852
for patchid in branch.revision_history():
520
853
print patchid
521
854
522
855
523
856
class cmd_ancestry(Command):
524
857
"""List all revisions merged into this branch."""
525
858
hidden = True
859
@display_command
526
860
def run(self):
527
b = find_branch('.')
528
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()):
529
865
print revision_id
530
866
531
867
532
class cmd_directories(Command):
533
"""Display list of versioned directories in this branch."""
534
def run(self):
535
for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
536
if name == '':
537
print '.'
538
else:
539
print name
540
541
542
868
class cmd_init(Command):
543
869
"""Make a directory into a versioned branch.
544
870
548
874
Recipe for importing a tree of files:
549
875
cd ~/project
550
876
bzr init
551
bzr add -v .
877
bzr add .
552
878
bzr status
553
879
bzr commit -m 'imported project'
554
880
"""
555
def run(self):
556
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)
557
911
558
912
559
913
class cmd_diff(Command):
585
939
takes_options = ['revision', 'diff-options']
586
940
aliases = ['di', 'dif']
587
941
942
@display_command
588
943
def run(self, revision=None, file_list=None, diff_options=None):
589
from bzrlib.diff import show_diff
590
591
if file_list:
592
b = Branch.open_containing(file_list[0])[0]
593
tree = WorkingTree(b.base, b)
594
file_list = [tree.relpath(f) for f in file_list]
595
if file_list == ['']:
596
# just pointing to top-of-tree
597
file_list = None
598
else:
599
b = Branch.open_containing('.')[0]
600
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
601
960
if revision is not None:
602
if len(revision) == 1:
603
show_diff(b, revision[0], specific_files=file_list,
604
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])
605
966
elif len(revision) == 2:
606
show_diff(b, revision[0], specific_files=file_list,
607
external_diff_options=diff_options,
608
revision2=revision[1])
967
return diff_cmd_helper(tree1, file_list, diff_options,
968
revision[0], revision[1])
609
969
else:
610
970
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
611
971
else:
612
show_diff(b, None, specific_files=file_list,
613
external_diff_options=diff_options)
614
615
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)
616
978
617
979
618
980
class cmd_deleted(Command):
624
986
# directories with readdir, rather than stating each one. Same
625
987
# level of effort but possibly much less IO. (Or possibly not,
626
988
# if the directories are very large...)
989
@display_command
627
990
def run(self, show_ids=False):
628
b = Branch.open_containing('.')[0]
629
old = b.basis_tree()
630
new = b.working_tree()
991
tree = WorkingTree.open_containing(u'.')[0]
992
old = tree.basis_tree()
631
993
for path, ie in old.inventory.iter_entries():
632
if not new.has_id(ie.file_id):
994
if not tree.has_id(ie.file_id):
633
995
if show_ids:
634
996
print '%-50s %s' % (path, ie.file_id)
635
997
else:
639
1001
class cmd_modified(Command):
640
1002
"""List files modified in working tree."""
641
1003
hidden = True
1004
@display_command
642
1005
def run(self):
643
1006
from bzrlib.delta import compare_trees
644
1007
645
b = Branch.open_containing('.')[0]
646
td = compare_trees(b.basis_tree(), b.working_tree())
1008
tree = WorkingTree.open_containing(u'.')[0]
1009
td = compare_trees(tree.basis_tree(), tree)
647
1010
648
1011
for path, id, kind, text_modified, meta_modified in td.modified:
649
1012
print path
653
1016
class cmd_added(Command):
654
1017
"""List files added in working tree."""
655
1018
hidden = True
1019
@display_command
656
1020
def run(self):
657
b = Branch.open_containing('.')[0]
658
wt = b.working_tree()
659
basis_inv = b.basis_tree().inventory
1021
wt = WorkingTree.open_containing(u'.')[0]
1022
basis_inv = wt.basis_tree().inventory
660
1023
inv = wt.inventory
661
1024
for file_id in inv:
662
1025
if file_id in basis_inv:
663
1026
continue
664
1027
path = inv.id2path(file_id)
665
if not os.access(b.abspath(path), os.F_OK):
1028
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
666
1029
continue
667
1030
print path
668
1031
674
1037
The root is the nearest enclosing directory with a .bzr control
675
1038
directory."""
676
1039
takes_args = ['filename?']
1040
@display_command
677
1041
def run(self, filename=None):
678
1042
"""Print the branch root."""
679
b = Branch.open_containing(filename)[0]
680
print b.base
1043
tree = WorkingTree.open_containing(filename)[0]
1044
print tree.basedir
681
1045
682
1046
683
1047
class cmd_log(Command):
684
1048
"""Show log of this branch.
685
1049
686
To request a range of logs, you can use the command -r begin:end
687
-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
688
1052
also valid.
689
1053
"""
690
1054
695
1059
help='show from oldest to newest'),
696
1060
'timezone', 'verbose',
697
1061
'show-ids', 'revision',
698
Option('line', help='format with one line per revision'),
699
'long',
1062
'log-format',
1063
'line', 'long',
700
1064
Option('message',
701
1065
help='show revisions whose message matches this regexp',
702
1066
type=str),
703
Option('short', help='use moderately short format'),
1067
'short',
704
1068
]
705
1069
@display_command
706
1070
def run(self, filename=None, timezone='original',
707
1071
verbose=False,
708
1072
show_ids=False,
709
1073
forward=False,
710
1074
revision=None,
1075
log_format=None,
711
1076
message=None,
712
1077
long=False,
713
1078
short=False,
718
1083
"invalid message argument %r" % message
719
1084
direction = (forward and 'forward') or 'reverse'
720
1085
1086
# log everything
1087
file_id = None
721
1088
if filename:
722
b, fp = Branch.open_containing(filename)
1089
# find the file id to log:
1090
1091
dir, fp = bzrdir.BzrDir.open_containing(filename)
1092
b = dir.open_branch()
723
1093
if fp != '':
724
file_id = b.read_working_inventory().path2id(fp)
725
else:
726
file_id = None # points to branch root
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, relpath = 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
log_format = 'long'
754
if short:
755
log_format = 'short'
756
if line:
757
log_format = 'line'
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
758
1143
lf = log_formatter(log_format,
759
1144
show_ids=show_ids,
760
1145
to_file=outf,
770
1155
search=message)
771
1156
772
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
773
1168
774
1169
class cmd_touching_revisions(Command):
775
1170
"""Return revision-ids which affected a particular file.
777
1172
A more user-friendly interface is "bzr log FILE"."""
778
1173
hidden = True
779
1174
takes_args = ["filename"]
1175
@display_command
780
1176
def run(self, filename):
781
b, relpath = Branch.open_containing(filename)[0]
782
inv = b.read_working_inventory()
1177
tree, relpath = WorkingTree.open_containing(filename)
1178
b = tree.branch
1179
inv = tree.read_working_inventory()
783
1180
file_id = inv.path2id(relpath)
784
1181
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
785
1182
print "%6d %s" % (revno, what)
790
1187
"""
791
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, relpath = Branch.open_containing('.')[0]
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('.')[0].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
839
1270
from bzrlib.atomicfile import AtomicFile
840
1271
import os.path
841
1272
842
b, relpath = Branch.open_containing('.')
843
ifn = b.abspath('.bzrignore')
1273
tree, relpath = WorkingTree.open_containing(u'.')
1274
ifn = tree.abspath('.bzrignore')
844
1275
845
1276
if os.path.exists(ifn):
846
1277
f = open(ifn, 'rt')
865
1296
finally:
866
1297
f.close()
867
1298
868
inv = b.working_tree().inventory
1299
inv = tree.inventory
869
1300
if inv.path2id('.bzrignore'):
870
1301
mutter('.bzrignore is already versioned')
871
1302
else:
872
1303
mutter('need to make new .bzrignore file versioned')
873
b.add(['.bzrignore'])
874
1304
tree.add(['.bzrignore'])
875
1305
876
1306
877
1307
class cmd_ignored(Command):
878
1308
"""List ignored files and the patterns that matched them.
879
1309
880
1310
See also: bzr ignore"""
1311
@display_command
881
1312
def run(self):
882
tree = Branch.open_containing('.')[0].working_tree()
1313
tree = WorkingTree.open_containing(u'.')[0]
883
1314
for path, file_class, kind, file_id, entry in tree.list_files():
884
1315
if file_class != 'I':
885
1316
continue
897
1328
hidden = True
898
1329
takes_args = ['revno']
899
1330
1331
@display_command
900
1332
def run(self, revno):
901
1333
try:
902
1334
revno = int(revno)
903
1335
except ValueError:
904
1336
raise BzrCommandError("not a valid revision-number: %r" % revno)
905
1337
906
print Branch.open_containing('.')[0].get_rev_id(revno)
1338
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
907
1339
908
1340
909
1341
class cmd_export(Command):
916
1348
is found exports to a directory (equivalent to --format=dir).
917
1349
918
1350
Root may be the top directory for tar, tgz and tbz2 formats. If none
919
is given, the top directory will be the root name of the file."""
920
# 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
"""
921
1363
takes_args = ['dest']
922
1364
takes_options = ['revision', 'format', 'root']
923
1365
def run(self, dest, revision=None, format=None, root=None):
924
1366
import os.path
925
b = Branch.open_containing('.')[0]
1367
from bzrlib.export import export
1368
tree = WorkingTree.open_containing(u'.')[0]
1369
b = tree.branch
926
1370
if revision is None:
1371
# should be tree.last_revision FIXME
927
1372
rev_id = b.last_revision()
928
1373
else:
929
1374
if len(revision) != 1:
930
1375
raise BzrError('bzr export --revision takes exactly 1 argument')
931
1376
rev_id = revision[0].in_history(b).rev_id
932
t = b.revision_tree(rev_id)
933
arg_root, ext = os.path.splitext(os.path.basename(dest))
934
if ext in ('.gz', '.bz2'):
935
new_root, new_ext = os.path.splitext(arg_root)
936
if new_ext == '.tar':
937
arg_root = new_root
938
ext = new_ext + ext
939
if root is None:
940
root = arg_root
941
if not format:
942
if ext in (".tar",):
943
format = "tar"
944
elif ext in (".tar.gz", ".tgz"):
945
format = "tgz"
946
elif ext in (".tar.bz2", ".tbz2"):
947
format = "tbz2"
948
else:
949
format = "dir"
950
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)
951
1382
952
1383
953
1384
class cmd_cat(Command):
956
1387
takes_options = ['revision']
957
1388
takes_args = ['filename']
958
1389
1390
@display_command
959
1391
def run(self, filename, revision=None):
960
if revision is None:
961
raise BzrCommandError("bzr cat requires a revision number")
962
elif len(revision) != 1:
1392
if revision is not None and len(revision) != 1:
963
1393
raise BzrCommandError("bzr cat --revision takes exactly one number")
964
b, relpath = Branch.open_containing(filename)
965
b.print_file(relpath, 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)
966
1408
967
1409
968
1410
class cmd_local_time_offset(Command):
969
1411
"""Show the offset in seconds from GMT to local time."""
970
1412
hidden = True
1413
@display_command
971
1414
def run(self):
972
1415
print bzrlib.osutils.local_time_offset()
973
1416
1005
1448
Option('strict',
1006
1449
help="refuse to commit if there are unknown "
1007
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
),
1008
1457
]
1009
1458
aliases = ['ci', 'checkin']
1010
1459
1011
1460
def run(self, message=None, file=None, verbose=True, selected_list=None,
1012
unchanged=False, strict=False):
1461
unchanged=False, strict=False, local=False):
1013
1462
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1014
1463
StrictCommitFailed)
1015
from bzrlib.msgeditor import edit_commit_message
1016
from bzrlib.status import show_status
1017
from cStringIO import StringIO
1018
1019
b = Branch.open_containing('.')[0]
1020
tree = WorkingTree(b.base, b)
1021
if selected_list:
1022
selected_list = [tree.relpath(s) for s in selected_list]
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()
1023
1480
if message is None and not file:
1024
catcher = StringIO()
1025
show_status(b, specific_files=selected_list,
1026
to_file=catcher)
1027
message = edit_commit_message(catcher.getvalue())
1028
1481
template = make_commit_message_template(tree, selected_list)
1482
message = edit_commit_message(template)
1029
1483
if message is None:
1030
1484
raise BzrCommandError("please specify a commit message"
1031
1485
" with either --message or --file")
1040
1494
raise BzrCommandError("empty commit message specified")
1041
1495
1042
1496
try:
1043
b.commit(message, specific_files=selected_list,
1044
allow_pointless=unchanged, strict=strict)
1497
tree.commit(message, specific_files=selected_list,
1498
allow_pointless=unchanged, strict=strict, local=local)
1045
1499
except PointlessCommit:
1046
1500
# FIXME: This should really happen before the file is read in;
1047
1501
# perhaps prepare the commit; get the message; then actually commit
1053
1507
except StrictCommitFailed:
1054
1508
raise BzrCommandError("Commit refused because there are unknown "
1055
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(),))
1056
1516
1057
1517
1058
1518
class cmd_check(Command):
1061
1521
This command checks various invariants about the branch storage to
1062
1522
detect data corruption or bzr bugs.
1063
1523
"""
1064
takes_args = ['dir?']
1524
takes_args = ['branch?']
1065
1525
takes_options = ['verbose']
1066
1526
1067
def run(self, dir='.', verbose=False):
1527
def run(self, branch=None, verbose=False):
1068
1528
from bzrlib.check import check
1069
check(Branch.open_containing(dir)[0], verbose)
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)
1070
1535
1071
1536
1072
1537
class cmd_scan_cache(Command):
1074
1539
def run(self):
1075
1540
from bzrlib.hashcache import HashCache
1076
1541
1077
c = HashCache('.')
1542
c = HashCache(u'.')
1078
1543
c.read()
1079
1544
c.scan()
1080
1545
1086
1551
1087
1552
if c.needs_write:
1088
1553
c.write()
1089
1090
1554
1091
1555
1092
1556
class cmd_upgrade(Command):
1093
1557
"""Upgrade branch storage to current format.
1094
1558
1095
1559
The check command or bzr developers may sometimes advise you to run
1096
this command.
1097
1098
This version of this command upgrades from the full-text storage
1099
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.
1100
1562
"""
1101
takes_args = ['dir?']
1102
1103
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):
1104
1574
from bzrlib.upgrade import upgrade
1105
upgrade(dir)
1575
upgrade(url, format)
1106
1576
1107
1577
1108
1578
class cmd_whoami(Command):
1109
1579
"""Show bzr user id."""
1110
1580
takes_options = ['email']
1111
1581
1582
@display_command
1112
1583
def run(self, email=False):
1113
1584
try:
1114
b = bzrlib.branch.Branch.open_containing('.')[0]
1585
b = WorkingTree.open_containing(u'.')[0].branch
1115
1586
config = bzrlib.config.BranchConfig(b)
1116
1587
except NotBranchError:
1117
1588
config = bzrlib.config.GlobalConfig()
1122
1593
print config.username()
1123
1594
1124
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
1613
1614
1125
1615
class cmd_selftest(Command):
1126
1616
"""Run internal test suite.
1127
1617
1128
1618
This creates temporary test directories in the working directory,
1129
1619
but not existing data is affected. These directories are deleted
1130
1620
if the tests pass, or left behind to help in debugging if they
1131
fail.
1621
fail and --keep-output is specified.
1132
1622
1133
1623
If arguments are given, they are regular expressions that say
1134
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
1135
1634
"""
1136
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
1137
1651
hidden = True
1138
1652
takes_args = ['testspecs*']
1139
takes_options = ['verbose',
1653
takes_options = ['verbose',
1140
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),
1141
1661
]
1142
1662
1143
def run(self, testspecs_list=None, verbose=False, one=False):
1663
def run(self, testspecs_list=None, verbose=False, one=False,
1664
keep_output=False, transport=None):
1144
1665
import bzrlib.ui
1145
from bzrlib.selftest import selftest
1666
from bzrlib.tests import selftest
1146
1667
# we don't want progress meters from the tests to go to the
1147
1668
# real output; and we don't want log messages cluttering up
1148
1669
# the real logs.
1156
1677
pattern = ".*"
1157
1678
result = selftest(verbose=verbose,
1158
1679
pattern=pattern,
1159
stop_on_failure=one)
1680
stop_on_failure=one,
1681
keep_output=keep_output,
1682
transport=transport)
1160
1683
if result:
1161
1684
bzrlib.trace.info('tests passed')
1162
1685
else:
1166
1689
bzrlib.ui.ui_factory = save_ui
1167
1690
1168
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
1169
1706
def show_version():
1170
1707
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1171
1708
# is bzrlib itself in a branch?
1172
bzrrev = bzrlib.get_bzr_revision()
1173
if bzrrev:
1174
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],)
1175
1717
print bzrlib.__copyright__
1176
1718
print "http://bazaar-ng.org/"
1177
1719
print
1182
1724
1183
1725
class cmd_version(Command):
1184
1726
"""Show version of bzr."""
1727
@display_command
1185
1728
def run(self):
1186
1729
show_version()
1187
1730
1188
1731
class cmd_rocks(Command):
1189
1732
"""Statement of optimism."""
1190
1733
hidden = True
1734
@display_command
1191
1735
def run(self):
1192
1736
print "it sure does!"
1193
1737
1200
1744
takes_args = ['branch', 'other']
1201
1745
hidden = True
1202
1746
1747
@display_command
1203
1748
def run(self, branch, other):
1204
1749
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1205
1750
1212
1757
last1 = branch1.last_revision()
1213
1758
last2 = branch2.last_revision()
1214
1759
1215
source = MultipleRevisionSources(branch1, branch2)
1760
source = MultipleRevisionSources(branch1.repository,
1761
branch2.repository)
1216
1762
1217
1763
base_rev_id = common_ancestor(last1, last2, source)
1218
1764
1240
1786
will be used as a BASE, and the second one as OTHER. Revision
1241
1787
numbers are always relative to the specified branch.
1242
1788
1243
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
1244
1790
branch, automatically determining an appropriate base. If this
1245
1791
fails, you may need to give an explicit base.
1246
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
1800
If there is no default branch set, the first merge will set it. After
1801
that, you can omit the branch to use the default. To change the
1802
default, use --remember.
1803
1247
1804
Examples:
1248
1805
1249
1806
To merge the latest revision from bzr.dev
1259
1816
--force is given.
1260
1817
"""
1261
1818
takes_args = ['branch?']
1262
takes_options = ['revision', 'force', 'merge-type']
1819
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1820
Option('show-base', help="Show base revision text in "
1821
"conflicts")]
1263
1822
1264
def run(self, branch=None, revision=None, force=False,
1265
merge_type=None):
1266
from bzrlib.merge import merge
1267
from bzrlib.merge_core import ApplyMerge3
1823
def run(self, branch=None, revision=None, force=False, merge_type=None,
1824
show_base=False, reprocess=False, remember=False):
1268
1825
if merge_type is None:
1269
merge_type = ApplyMerge3
1826
merge_type = Merge3Merger
1827
1828
tree = WorkingTree.open_containing(u'.')[0]
1829
stored_loc = tree.branch.get_parent()
1270
1830
if branch is None:
1271
branch = Branch.open_containing('.')[0].get_parent()
1272
if branch is None:
1273
raise BzrCommandError("No merge location known or specified.")
1831
if stored_loc is None:
1832
raise BzrCommandError("No merge branch known or specified.")
1274
1833
else:
1275
print "Using saved location: %s" % branch
1834
print "Using saved branch: %s" % stored_loc
1835
branch = stored_loc
1836
1837
if tree.branch.get_parent() is None or remember:
1838
tree.branch.set_parent(branch)
1839
1276
1840
if revision is None or len(revision) < 1:
1277
1841
base = [None, None]
1278
1842
other = [branch, -1]
1279
1843
else:
1280
1844
if len(revision) == 1:
1281
1845
base = [None, None]
1282
other = [branch, revision[0].in_history(branch).revno]
1846
other_branch = Branch.open_containing(branch)[0]
1847
revno = revision[0].in_history(other_branch).revno
1848
other = [branch, revno]
1283
1849
else:
1284
1850
assert len(revision) == 2
1285
1851
if None in revision:
1286
1852
raise BzrCommandError(
1287
1853
"Merge doesn't permit that revision specifier.")
1288
b = Branch.open(branch)
1289
1290
base = [branch, revision[0].in_history(b).revno]
1291
other = [branch, revision[1].in_history(b).revno]
1292
1293
try:
1294
merge(other, base, check_clean=(not force), merge_type=merge_type)
1295
except bzrlib.errors.AmbiguousBase, e:
1296
m = ("sorry, bzr can't determine the right merge base yet\n"
1297
"candidates are:\n "
1298
+ "\n ".join(e.bases)
1299
+ "\n"
1300
"please specify an explicit base with -r,\n"
1301
"and (if you want) report this to the bzr developers\n")
1302
log_error(m)
1303
1854
other_branch = Branch.open_containing(branch)[0]
1855
1856
base = [branch, revision[0].in_history(other_branch).revno]
1857
other = [branch, revision[1].in_history(other_branch).revno]
1858
1859
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1860
try:
1861
conflict_count = merge(other, base, check_clean=(not force),
1862
merge_type=merge_type,
1863
reprocess=reprocess,
1864
show_base=show_base,
1865
pb=pb)
1866
finally:
1867
pb.finished()
1868
if conflict_count != 0:
1869
return 1
1870
else:
1871
return 0
1872
1873
1874
class cmd_remerge(Command):
1875
"""Redo a merge.
1876
"""
1877
takes_args = ['file*']
1878
takes_options = ['merge-type', 'reprocess',
1879
Option('show-base', help="Show base revision text in "
1880
"conflicts")]
1881
1882
def run(self, file_list=None, merge_type=None, show_base=False,
1883
reprocess=False):
1884
from bzrlib.merge import merge_inner, transform_tree
1885
if merge_type is None:
1886
merge_type = Merge3Merger
1887
tree, file_list = tree_files(file_list)
1888
tree.lock_write()
1889
try:
1890
pending_merges = tree.pending_merges()
1891
if len(pending_merges) != 1:
1892
raise BzrCommandError("Sorry, remerge only works after normal"
1893
+ " merges. Not cherrypicking or"
1894
+ "multi-merges.")
1895
repository = tree.branch.repository
1896
base_revision = common_ancestor(tree.branch.last_revision(),
1897
pending_merges[0], repository)
1898
base_tree = repository.revision_tree(base_revision)
1899
other_tree = repository.revision_tree(pending_merges[0])
1900
interesting_ids = None
1901
if file_list is not None:
1902
interesting_ids = set()
1903
for filename in file_list:
1904
file_id = tree.path2id(filename)
1905
if file_id is None:
1906
raise NotVersionedError(filename)
1907
interesting_ids.add(file_id)
1908
if tree.kind(file_id) != "directory":
1909
continue
1910
1911
for name, ie in tree.inventory.iter_entries(file_id):
1912
interesting_ids.add(ie.file_id)
1913
transform_tree(tree, tree.basis_tree(), interesting_ids)
1914
if file_list is None:
1915
restore_files = list(tree.iter_conflicts())
1916
else:
1917
restore_files = file_list
1918
for filename in restore_files:
1919
try:
1920
restore(tree.abspath(filename))
1921
except NotConflicted:
1922
pass
1923
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1924
this_tree=tree,
1925
interesting_ids = interesting_ids,
1926
other_rev_id=pending_merges[0],
1927
merge_type=merge_type,
1928
show_base=show_base,
1929
reprocess=reprocess)
1930
finally:
1931
tree.unlock()
1932
if conflicts > 0:
1933
return 1
1934
else:
1935
return 0
1304
1936
1305
1937
class cmd_revert(Command):
1306
1938
"""Reverse all changes since the last commit.
1314
1946
aliases = ['merge-revert']
1315
1947
1316
1948
def run(self, revision=None, no_backup=False, file_list=None):
1317
from bzrlib.merge import merge
1318
1949
from bzrlib.commands import parse_spec
1319
1320
1950
if file_list is not None:
1321
1951
if len(file_list) == 0:
1322
1952
raise BzrCommandError("No files specified")
1953
else:
1954
file_list = []
1955
1956
tree, file_list = tree_files(file_list)
1323
1957
if revision is None:
1324
revno = -1
1958
# FIXME should be tree.last_revision
1959
rev_id = tree.last_revision()
1325
1960
elif len(revision) != 1:
1326
1961
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1327
1962
else:
1328
b = Branch.open_containing('.')[0]
1329
revno = revision[0].in_history(b).revno
1330
merge(('.', revno), parse_spec('.'),
1331
check_clean=False,
1332
ignore_zero=True,
1333
backup_files=not no_backup,
1334
file_list=file_list)
1335
if not file_list:
1336
Branch.open_containing('.')[0].set_pending_merges([])
1963
rev_id = revision[0].in_history(tree.branch).rev_id
1964
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1965
try:
1966
tree.revert(file_list,
1967
tree.branch.repository.revision_tree(rev_id),
1968
not no_backup, pb)
1969
finally:
1970
pb.finished()
1337
1971
1338
1972
1339
1973
class cmd_assert_fail(Command):
1347
1981
"""Show help on a command or other topic.
1348
1982
1349
1983
For a list of all available commands, say 'bzr help commands'."""
1350
takes_options = ['long']
1984
takes_options = [Option('long', 'show help on all commands')]
1351
1985
takes_args = ['topic?']
1352
1986
aliases = ['?']
1353
1987
1988
@display_command
1354
1989
def run(self, topic=None, long=False):
1355
1990
import help
1356
1991
if topic is None and long:
1366
2001
aliases = ['s-c']
1367
2002
hidden = True
1368
2003
2004
@display_command
1369
2005
def run(self, context=None):
1370
2006
import shellcomplete
1371
2007
shellcomplete.shellcomplete(context)
1380
2016
def run(self, from_branch, to_branch):
1381
2017
from bzrlib.fetch import Fetcher
1382
2018
from bzrlib.branch import Branch
1383
from_b = Branch(from_branch)
1384
to_b = Branch(to_branch)
2019
from_b = Branch.open(from_branch)
2020
to_b = Branch.open(to_branch)
1385
2021
Fetcher(to_b, from_b)
1386
1387
2022
1388
2023
1389
2024
class cmd_missing(Command):
1390
"""What is missing in this branch relative to other branch.
1391
"""
1392
# TODO: rewrite this in terms of ancestry so that it shows only
1393
# unmerged things
1394
1395
takes_args = ['remote?']
1396
aliases = ['mis', 'miss']
1397
# We don't have to add quiet to the list, because
1398
# unknown options are parsed as booleans
1399
takes_options = ['verbose', 'quiet']
1400
1401
def run(self, remote=None, verbose=False, quiet=False):
1402
from bzrlib.errors import BzrCommandError
1403
from bzrlib.missing import show_missing
1404
1405
if verbose and quiet:
1406
raise BzrCommandError('Cannot pass both quiet and verbose')
1407
1408
b = Branch.open_containing('.')[0]
1409
parent = b.get_parent()
1410
if remote is None:
1411
if parent is None:
2025
"""Show unmerged/unpulled revisions between two branches.
2026
2027
OTHER_BRANCH may be local or remote."""
2028
takes_args = ['other_branch?']
2029
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2030
Option('mine-only',
2031
'Display changes in the local branch only'),
2032
Option('theirs-only',
2033
'Display changes in the remote branch only'),
2034
'log-format',
2035
'line',
2036
'long',
2037
'short',
2038
'show-ids',
2039
'verbose'
2040
]
2041
2042
def run(self, other_branch=None, reverse=False, mine_only=False,
2043
theirs_only=False, log_format=None, long=False, short=False, line=False,
2044
show_ids=False, verbose=False):
2045
from bzrlib.missing import find_unmerged, iter_log_data
2046
from bzrlib.log import log_formatter
2047
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2048
parent = local_branch.get_parent()
2049
if other_branch is None:
2050
other_branch = parent
2051
if other_branch is None:
1412
2052
raise BzrCommandError("No missing location known or specified.")
1413
else:
1414
if not quiet:
1415
print "Using last location: %s" % parent
1416
remote = parent
1417
elif parent is None:
1418
# We only update parent if it did not exist, missing
1419
# should not change the parent
1420
b.set_parent(remote)
1421
br_remote = Branch.open_containing(remote)[0]
1422
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
2053
print "Using last location: " + local_branch.get_parent()
2054
remote_branch = bzrlib.branch.Branch.open(other_branch)
2055
remote_branch.lock_read()
2056
try:
2057
local_branch.lock_write()
2058
try:
2059
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2060
if (log_format == None):
2061
default = bzrlib.config.BranchConfig(local_branch).log_format()
2062
log_format = get_log_format(long=long, short=short, line=line, default=default)
2063
lf = log_formatter(log_format, sys.stdout,
2064
show_ids=show_ids,
2065
show_timezone='original')
2066
if reverse is False:
2067
local_extra.reverse()
2068
remote_extra.reverse()
2069
if local_extra and not theirs_only:
2070
print "You have %d extra revision(s):" % len(local_extra)
2071
for data in iter_log_data(local_extra, local_branch.repository,
2072
verbose):
2073
lf.show(*data)
2074
printed_local = True
2075
else:
2076
printed_local = False
2077
if remote_extra and not mine_only:
2078
if printed_local is True:
2079
print "\n\n"
2080
print "You are missing %d revision(s):" % len(remote_extra)
2081
for data in iter_log_data(remote_extra, remote_branch.repository,
2082
verbose):
2083
lf.show(*data)
2084
if not remote_extra and not local_extra:
2085
status_code = 0
2086
print "Branches are up to date."
2087
else:
2088
status_code = 1
2089
if parent is None and other_branch is not None:
2090
local_branch.set_parent(other_branch)
2091
return status_code
2092
finally:
2093
local_branch.unlock()
2094
finally:
2095
remote_branch.unlock()
1423
2096
1424
2097
1425
2098
class cmd_plugins(Command):
1426
2099
"""List plugins"""
1427
2100
hidden = True
2101
@display_command
1428
2102
def run(self):
1429
2103
import bzrlib.plugin
1430
2104
from inspect import getdoc
1431
for plugin in bzrlib.plugin.all_plugins:
2105
for name, plugin in bzrlib.plugin.all_plugins().items():
1432
2106
if hasattr(plugin, '__path__'):
1433
2107
print plugin.__path__[0]
1434
2108
elif hasattr(plugin, '__file__'):
1445
2119
"""Show testament (signing-form) of a revision."""
1446
2120
takes_options = ['revision', 'long']
1447
2121
takes_args = ['branch?']
1448
def run(self, branch='.', revision=None, long=False):
2122
@display_command
2123
def run(self, branch=u'.', revision=None, long=False):
1449
2124
from bzrlib.testament import Testament
1450
b = Branch.open_containing(branch)[0]
2125
b = WorkingTree.open_containing(branch)[0].branch
1451
2126
b.lock_read()
1452
2127
try:
1453
2128
if revision is None:
1454
2129
rev_id = b.last_revision()
1455
2130
else:
1456
2131
rev_id = revision[0].in_history(b).rev_id
1457
t = Testament.from_revision(b, rev_id)
2132
t = Testament.from_revision(b.repository, rev_id)
1458
2133
if long:
1459
2134
sys.stdout.writelines(t.as_text_lines())
1460
2135
else:
1482
2157
Option('long', help='show date in annotations'),
1483
2158
]
1484
2159
2160
@display_command
1485
2161
def run(self, filename, all=False, long=False):
1486
2162
from bzrlib.annotate import annotate_file
1487
b, relpath = Branch.open_containing(filename)
1488
b.lock_read()
2163
tree, relpath = WorkingTree.open_containing(filename)
2164
branch = tree.branch
2165
branch.lock_read()
1489
2166
try:
1490
tree = WorkingTree(b.base, b)
1491
tree = b.revision_tree(b.last_revision())
1492
2167
file_id = tree.inventory.path2id(relpath)
2168
tree = branch.repository.revision_tree(branch.last_revision())
1493
2169
file_version = tree.inventory[file_id].revision
1494
annotate_file(b, file_version, file_id, long, all, sys.stdout)
2170
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1495
2171
finally:
1496
b.unlock()
2172
branch.unlock()
1497
2173
1498
2174
1499
2175
class cmd_re_sign(Command):
1501
2177
# TODO be able to replace existing ones.
1502
2178
1503
2179
hidden = True # is this right ?
1504
takes_args = ['revision_id?']
2180
takes_args = ['revision_id*']
1505
2181
takes_options = ['revision']
1506
2182
1507
def run(self, revision_id=None, revision=None):
2183
def run(self, revision_id_list=None, revision=None):
1508
2184
import bzrlib.config as config
1509
2185
import bzrlib.gpg as gpg
1510
if revision_id is not None and revision is not None:
2186
if revision_id_list is not None and revision is not None:
1511
2187
raise BzrCommandError('You can only supply one of revision_id or --revision')
1512
if revision_id is None and revision is None:
2188
if revision_id_list is None and revision is None:
1513
2189
raise BzrCommandError('You must supply either --revision or a revision_id')
1514
b = Branch.open_containing('.')[0]
2190
b = WorkingTree.open_containing(u'.')[0].branch
1515
2191
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1516
if revision_id is not None:
1517
b.sign_revision(revision_id, gpg_strategy)
2192
if revision_id_list is not None:
2193
for revision_id in revision_id_list:
2194
b.repository.sign_revision(revision_id, gpg_strategy)
1518
2195
elif revision is not None:
1519
for rev in revision:
1520
if rev is None:
1521
raise BzrCommandError('You cannot specify a NULL revision.')
1522
revno, rev_id = rev.in_history(b)
1523
b.sign_revision(rev_id, gpg_strategy)
2196
if len(revision) == 1:
2197
revno, rev_id = revision[0].in_history(b)
2198
b.repository.sign_revision(rev_id, gpg_strategy)
2199
elif len(revision) == 2:
2200
# are they both on rh- if so we can walk between them
2201
# might be nice to have a range helper for arbitrary
2202
# revision paths. hmm.
2203
from_revno, from_revid = revision[0].in_history(b)
2204
to_revno, to_revid = revision[1].in_history(b)
2205
if to_revid is None:
2206
to_revno = b.revno()
2207
if from_revno is None or to_revno is None:
2208
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2209
for revno in range(from_revno, to_revno + 1):
2210
b.repository.sign_revision(b.get_rev_id(revno),
2211
gpg_strategy)
2212
else:
2213
raise BzrCommandError('Please supply either one revision, or a range.')
2214
2215
2216
class cmd_bind(Command):
2217
"""Bind the current branch to a master branch.
2218
2219
After binding, commits must succeed on the master branch
2220
before they are executed on the local one.
2221
"""
2222
2223
takes_args = ['location']
2224
takes_options = []
2225
2226
def run(self, location=None):
2227
b, relpath = Branch.open_containing(u'.')
2228
b_other = Branch.open(location)
2229
try:
2230
b.bind(b_other)
2231
except DivergedBranches:
2232
raise BzrCommandError('These branches have diverged.'
2233
' Try merging, and then bind again.')
2234
2235
2236
class cmd_unbind(Command):
2237
"""Bind the current branch to its parent.
2238
2239
After unbinding, the local branch is considered independent.
2240
"""
2241
2242
takes_args = []
2243
takes_options = []
2244
2245
def run(self):
2246
b, relpath = Branch.open_containing(u'.')
2247
if not b.unbind():
2248
raise BzrCommandError('Local branch is not bound')
2249
2250
2251
class cmd_uncommit(bzrlib.commands.Command):
2252
"""Remove the last committed revision.
2253
2254
By supplying the --all flag, it will not only remove the entry
2255
from revision_history, but also remove all of the entries in the
2256
stores.
2257
2258
--verbose will print out what is being removed.
2259
--dry-run will go through all the motions, but not actually
2260
remove anything.
2261
2262
In the future, uncommit will create a changeset, which can then
2263
be re-applied.
2264
"""
2265
2266
# TODO: jam 20060108 Add an option to allow uncommit to remove
2267
# unreferenced information in 'branch-as-repostory' branches.
2268
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2269
# information in shared branches as well.
2270
takes_options = ['verbose', 'revision',
2271
Option('dry-run', help='Don\'t actually make changes'),
2272
Option('force', help='Say yes to all questions.')]
2273
takes_args = ['location?']
2274
aliases = []
2275
2276
def run(self, location=None,
2277
dry_run=False, verbose=False,
2278
revision=None, force=False):
2279
from bzrlib.branch import Branch
2280
from bzrlib.log import log_formatter
2281
import sys
2282
from bzrlib.uncommit import uncommit
2283
2284
if location is None:
2285
location = u'.'
2286
control, relpath = bzrdir.BzrDir.open_containing(location)
2287
b = control.open_branch()
2288
try:
2289
tree = control.open_workingtree()
2290
except (errors.NoWorkingTree, errors.NotLocalUrl):
2291
tree = None
2292
2293
if revision is None:
2294
revno = b.revno()
2295
rev_id = b.last_revision()
2296
else:
2297
revno, rev_id = revision[0].in_history(b)
2298
if rev_id is None:
2299
print 'No revisions to uncommit.'
2300
2301
for r in range(revno, b.revno()+1):
2302
rev_id = b.get_rev_id(r)
2303
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2304
lf.show(r, b.repository.get_revision(rev_id), None)
2305
2306
if dry_run:
2307
print 'Dry-run, pretending to remove the above revisions.'
2308
if not force:
2309
val = raw_input('Press <enter> to continue')
2310
else:
2311
print 'The above revision(s) will be removed.'
2312
if not force:
2313
val = raw_input('Are you sure [y/N]? ')
2314
if val.lower() not in ('y', 'yes'):
2315
print 'Canceled'
2316
return 0
2317
2318
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2319
revno=revno)
2320
2321
2322
class cmd_break_lock(Command):
2323
"""Break a dead lock on a repository, branch or working directory.
2324
2325
CAUTION: Locks should only be broken when you are sure that the process
2326
holding the lock has been stopped.
2327
2328
example:
2329
bzr break-lock .
2330
"""
2331
takes_args = ['location']
2332
takes_options = [Option('show',
2333
help="just show information on the lock, " \
2334
"don't break it"),
2335
]
2336
def run(self, location, show=False):
2337
d = bzrdir.BzrDir.open(location)
2338
repo = d.open_repository()
2339
if not repo.is_locked():
2340
raise errors.ObjectNotLocked(repo)
2341
2342
2343
# command-line interpretation helper for merge-related commands
2344
def merge(other_revision, base_revision,
2345
check_clean=True, ignore_zero=False,
2346
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2347
file_list=None, show_base=False, reprocess=False,
2348
pb=DummyProgress()):
2349
"""Merge changes into a tree.
2350
2351
base_revision
2352
list(path, revno) Base for three-way merge.
2353
If [None, None] then a base will be automatically determined.
2354
other_revision
2355
list(path, revno) Other revision for three-way merge.
2356
this_dir
2357
Directory to merge changes into; '.' by default.
2358
check_clean
2359
If true, this_dir must have no uncommitted changes before the
2360
merge begins.
2361
ignore_zero - If true, suppress the "zero conflicts" message when
2362
there are no conflicts; should be set when doing something we expect
2363
to complete perfectly.
2364
file_list - If supplied, merge only changes to selected files.
2365
2366
All available ancestors of other_revision and base_revision are
2367
automatically pulled into the branch.
2368
2369
The revno may be -1 to indicate the last revision on the branch, which is
2370
the typical case.
2371
2372
This function is intended for use from the command line; programmatic
2373
clients might prefer to call merge.merge_inner(), which has less magic
2374
behavior.
2375
"""
2376
from bzrlib.merge import Merger
2377
if this_dir is None:
2378
this_dir = u'.'
2379
this_tree = WorkingTree.open_containing(this_dir)[0]
2380
if show_base and not merge_type is Merge3Merger:
2381
raise BzrCommandError("Show-base is not supported for this merge"
2382
" type. %s" % merge_type)
2383
if reprocess and not merge_type is Merge3Merger:
2384
raise BzrCommandError("Reprocess is not supported for this merge"
2385
" type. %s" % merge_type)
2386
if reprocess and show_base:
2387
raise BzrCommandError("Cannot reprocess and show base.")
2388
try:
2389
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2390
merger.pp = ProgressPhase("Merge phase", 5, pb)
2391
merger.pp.next_phase()
2392
merger.check_basis(check_clean)
2393
merger.set_other(other_revision)
2394
merger.pp.next_phase()
2395
merger.set_base(base_revision)
2396
if merger.base_rev_id == merger.other_rev_id:
2397
note('Nothing to do.')
2398
return 0
2399
merger.backup_files = backup_files
2400
merger.merge_type = merge_type
2401
merger.set_interesting_files(file_list)
2402
merger.show_base = show_base
2403
merger.reprocess = reprocess
2404
conflicts = merger.do_merge()
2405
merger.set_pending()
2406
finally:
2407
pb.clear()
2408
return conflicts
1524
2409
1525
2410
1526
2411
# these get imported and then picked up by the scan for cmd_*
1527
2412
# TODO: Some more consistent way to split command definitions across files;
1528
2413
# we do need to load at least some information about them to know of
1529
2414
# aliases.
1530
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
2415
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2416
from bzrlib.sign_my_commits import cmd_sign_my_commits
Loggerhead is a web-based interface for Breezy
Version: 2.0.1