« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 4794.1.14
- compare with another revision
- download diff
- download tarball
- view history from revision 4794.1.14
- Committer: Robert Collins
- Date: 2009-12-15 23:28:24 UTC
- mfrom: (4900 +trunk)
- mto: This revision was merged to the branch mainline in revision 4920.
- Revision ID: robertc@robertcollins.net-20091215232824-yewvn7pn7baaevux
Merge trunk, resolving NEWS conflicts.
- files added:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- files removed:
- .testr.conf
- apport
- bzrlib/doc_generate/builders
- bzrlib/doc_generate/writers
- bzrlib/help_topics/es
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/news_merge
- bzrlib/plugins/news_merge/tests
- bzrlib/plugins/weave_fmt
- bzrlib/plugins/weave_fmt/tests
- bzrlib/tests/doc_generate
- bzrlib/tests/doc_generate/builders
- bzrlib/tests/doc_generate/writers
- bzrlib/tests/per_bzrdir
- bzrlib/tests/per_controldir_colo
- bzrlib/tests/per_repository_vf
- contrib/debian
- doc/en/whats-new
- po
- files renamed:
- doc/en/release-notes/bzr-2.3.txt => NEWS
- bzrlib/doc_generate/conf.py => bzrlib/doc_generate/sphinx_conf.py
- bzrlib/help_topics/en/conflict-types.txt => bzrlib/help_topics/en/conflicts.txt
- bzrlib/plugins/weave_fmt/repository.py => bzrlib/repofmt/weaverepo.py
- bzrlib/commit_signature_commands.py => bzrlib/sign_my_commits.py
- bzrlib/tests/per_controldir/ => bzrlib/tests/per_bzrdir/
- bzrlib/tests/per_controldir/test_controldir.py => bzrlib/tests/per_bzrdir/test_bzrdir.py
- bzrlib/tests/per_repository_vf/helpers.py => bzrlib/tests/per_repository/helpers.py
- bzrlib/tests/per_repository_vf/test__generate_text_key_index.py => bzrlib/tests/per_repository/test__generate_text_key_index.py
- bzrlib/tests/per_repository_vf/test_add_inventory_by_delta.py => bzrlib/tests/per_repository/test_add_inventory_by_delta.py
- bzrlib/tests/per_repository_vf/test_check_reconcile.py => bzrlib/tests/per_repository/test_check_reconcile.py
- bzrlib/tests/per_repository_vf/test_find_text_key_references.py => bzrlib/tests/per_repository/test_find_text_key_references.py
- bzrlib/tests/per_repository/test_locking.py => bzrlib/tests/per_repository/test_is_write_locked.py
- bzrlib/tests/test__bencode.py => bzrlib/tests/test_bencode.py
- bzrlib/plugins/weave_fmt/xml4.py => bzrlib/xml4.py
- bzrlib/help_topics/es/conflict-types.txt => doc/es/user-guide/resolving_conflicts.txt
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2005-2011 Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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
20
20
21
21
from bzrlib.lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
import codecs
23
24
import cStringIO
24
25
import sys
25
26
import time
30
31
bundle,
31
32
btree_index,
32
33
bzrdir,
33
directory_service,
34
34
delta,
35
config as _mod_config,
35
config,
36
36
errors,
37
37
globbing,
38
38
hooks,
44
44
rename_map,
45
45
revision as _mod_revision,
46
46
static_tuple,
47
symbol_versioning,
47
48
timestamp,
48
49
transport,
49
50
ui,
50
51
urlutils,
51
52
views,
52
gpg,
53
53
)
54
54
from bzrlib.branch import Branch
55
55
from bzrlib.conflicts import ConflictList
56
from bzrlib.transport import memory
57
56
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
58
57
from bzrlib.smtp_connection import SMTPConnection
59
58
from bzrlib.workingtree import WorkingTree
60
59
""")
61
60
62
from bzrlib.commands import (
63
Command,
64
builtin_command_registry,
65
display_command,
66
)
61
from bzrlib.commands import Command, display_command
67
62
from bzrlib.option import (
68
63
ListOption,
69
64
Option,
72
67
_parse_revision_str,
73
68
)
74
69
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
75
from bzrlib import (
76
symbol_versioning,
77
)
78
79
80
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
70
71
81
72
def tree_files(file_list, default_branch=u'.', canonicalize=True,
82
73
apply_view=True):
83
return internal_tree_files(file_list, default_branch, canonicalize,
84
apply_view)
74
try:
75
return internal_tree_files(file_list, default_branch, canonicalize,
76
apply_view)
77
except errors.FileInWrongBranch, e:
78
raise errors.BzrCommandError("%s is not in the same branch as %s" %
79
(e.path, file_list[0]))
85
80
86
81
87
82
def tree_files_for_add(file_list):
151
146
152
147
# XXX: Bad function name; should possibly also be a class method of
153
148
# WorkingTree rather than a function.
154
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
149
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
150
apply_view=True):
157
151
"""Convert command-line paths to a WorkingTree and relative paths.
158
152
159
Deprecated: use WorkingTree.open_containing_paths instead.
160
161
153
This is typically used for command-line processors that take one or
162
154
more filenames, and infer the workingtree that contains them.
163
155
173
165
174
166
:return: workingtree, [relative_paths]
175
167
"""
176
return WorkingTree.open_containing_paths(
177
file_list, default_directory='.',
178
canonicalize=True,
179
apply_view=True)
168
if file_list is None or len(file_list) == 0:
169
tree = WorkingTree.open_containing(default_branch)[0]
170
if tree.supports_views() and apply_view:
171
view_files = tree.views.lookup_view()
172
if view_files:
173
file_list = view_files
174
view_str = views.view_display_str(view_files)
175
note("Ignoring files outside view. View is %s" % view_str)
176
return tree, file_list
177
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
178
return tree, safe_relpath_files(tree, file_list, canonicalize,
179
apply_view=apply_view)
180
181
182
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
183
"""Convert file_list into a list of relpaths in tree.
184
185
:param tree: A tree to operate on.
186
:param file_list: A list of user provided paths or None.
187
:param apply_view: if True and a view is set, apply it or check that
188
specified files are within it
189
:return: A list of relative paths.
190
:raises errors.PathNotChild: When a provided path is in a different tree
191
than tree.
192
"""
193
if file_list is None:
194
return None
195
if tree.supports_views() and apply_view:
196
view_files = tree.views.lookup_view()
197
else:
198
view_files = []
199
new_list = []
200
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
201
# doesn't - fix that up here before we enter the loop.
202
if canonicalize:
203
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
204
else:
205
fixer = tree.relpath
206
for filename in file_list:
207
try:
208
relpath = fixer(osutils.dereference_path(filename))
209
if view_files and not osutils.is_inside_any(view_files, relpath):
210
raise errors.FileOutsideView(filename, view_files)
211
new_list.append(relpath)
212
except errors.PathNotChild:
213
raise errors.FileInWrongBranch(tree.branch, filename)
214
return new_list
180
215
181
216
182
217
def _get_view_info_for_change_reporter(tree):
191
226
return view_info
192
227
193
228
194
def _open_directory_or_containing_tree_or_branch(filename, directory):
195
"""Open the tree or branch containing the specified file, unless
196
the --directory option is used to specify a different branch."""
197
if directory is not None:
198
return (None, Branch.open(directory), filename)
199
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
200
201
202
229
# TODO: Make sure no commands unconditionally use the working directory as a
203
230
# branch. If a filename argument is used, the first of them should be used to
204
231
# specify the branch. (Perhaps this can be factored out into some kind of
206
233
# opens the branch?)
207
234
208
235
class cmd_status(Command):
209
__doc__ = """Display status summary.
236
"""Display status summary.
210
237
211
238
This reports on versioned and unknown files, reporting them
212
239
grouped by state. Possible states are:
232
259
unknown
233
260
Not versioned and not matching an ignore pattern.
234
261
235
Additionally for directories, symlinks and files with a changed
236
executable bit, Bazaar indicates their type using a trailing
237
character: '/', '@' or '*' respectively. These decorations can be
238
disabled using the '--no-classify' option.
262
Additionally for directories, symlinks and files with an executable
263
bit, Bazaar indicates their type using a trailing character: '/', '@'
264
or '*' respectively.
239
265
240
266
To see ignored files use 'bzr ignored'. For details on the
241
267
changes to file texts, use 'bzr diff'.
254
280
To skip the display of pending merge information altogether, use
255
281
the no-pending option or specify a file/directory.
256
282
257
To compare the working directory to a specific revision, pass a
258
single revision to the revision argument.
259
260
To see which files have changed in a specific revision, or between
261
two revisions, pass a revision range to the revision argument.
262
This will produce the same results as calling 'bzr diff --summarize'.
283
If a revision argument is given, the status is calculated against
284
that revision, or between two revisions if two are provided.
263
285
"""
264
286
265
287
# TODO: --no-recurse, --recurse options
272
294
short_name='V'),
273
295
Option('no-pending', help='Don\'t show pending merges.',
274
296
),
275
Option('no-classify',
276
help='Do not mark object type using indicator.',
277
),
278
297
]
279
298
aliases = ['st', 'stat']
280
299
283
302
284
303
@display_command
285
304
def run(self, show_ids=False, file_list=None, revision=None, short=False,
286
versioned=False, no_pending=False, verbose=False,
287
no_classify=False):
305
versioned=False, no_pending=False, verbose=False):
288
306
from bzrlib.status import show_tree_status
289
307
290
308
if revision and len(revision) > 2:
291
309
raise errors.BzrCommandError('bzr status --revision takes exactly'
292
310
' one or two revision specifiers')
293
311
294
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
312
tree, relfile_list = tree_files(file_list)
295
313
# Avoid asking for specific files when that is not needed.
296
314
if relfile_list == ['']:
297
315
relfile_list = None
304
322
show_tree_status(tree, show_ids=show_ids,
305
323
specific_files=relfile_list, revision=revision,
306
324
to_file=self.outf, short=short, versioned=versioned,
307
show_pending=(not no_pending), verbose=verbose,
308
classify=not no_classify)
325
show_pending=(not no_pending), verbose=verbose)
309
326
310
327
311
328
class cmd_cat_revision(Command):
312
__doc__ = """Write out metadata for a revision.
329
"""Write out metadata for a revision.
313
330
314
331
The revision to print can either be specified by a specific
315
332
revision identifier, or you can use --revision.
317
334
318
335
hidden = True
319
336
takes_args = ['revision_id?']
320
takes_options = ['directory', 'revision']
337
takes_options = ['revision']
321
338
# cat-revision is more for frontends so should be exact
322
339
encoding = 'strict'
323
340
324
def print_revision(self, revisions, revid):
325
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
326
record = stream.next()
327
if record.storage_kind == 'absent':
328
raise errors.NoSuchRevision(revisions, revid)
329
revtext = record.get_bytes_as('fulltext')
330
self.outf.write(revtext.decode('utf-8'))
331
332
341
@display_command
333
def run(self, revision_id=None, revision=None, directory=u'.'):
342
def run(self, revision_id=None, revision=None):
334
343
if revision_id is not None and revision is not None:
335
344
raise errors.BzrCommandError('You can only supply one of'
336
345
' revision_id or --revision')
337
346
if revision_id is None and revision is None:
338
347
raise errors.BzrCommandError('You must supply either'
339
348
' --revision or a revision_id')
340
341
b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
342
343
revisions = b.repository.revisions
344
if revisions is None:
345
raise errors.BzrCommandError('Repository %r does not support '
346
'access to raw revision texts')
347
348
b.repository.lock_read()
349
try:
350
# TODO: jam 20060112 should cat-revision always output utf-8?
351
if revision_id is not None:
352
revision_id = osutils.safe_revision_id(revision_id, warn=False)
353
try:
354
self.print_revision(revisions, revision_id)
355
except errors.NoSuchRevision:
356
msg = "The repository %s contains no revision %s." % (
357
b.repository.base, revision_id)
358
raise errors.BzrCommandError(msg)
359
elif revision is not None:
360
for rev in revision:
361
if rev is None:
362
raise errors.BzrCommandError(
363
'You cannot specify a NULL revision.')
364
rev_id = rev.as_revision_id(b)
365
self.print_revision(revisions, rev_id)
366
finally:
367
b.repository.unlock()
368
349
b = WorkingTree.open_containing(u'.')[0].branch
350
351
# TODO: jam 20060112 should cat-revision always output utf-8?
352
if revision_id is not None:
353
revision_id = osutils.safe_revision_id(revision_id, warn=False)
354
try:
355
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
356
except errors.NoSuchRevision:
357
msg = "The repository %s contains no revision %s." % (b.repository.base,
358
revision_id)
359
raise errors.BzrCommandError(msg)
360
elif revision is not None:
361
for rev in revision:
362
if rev is None:
363
raise errors.BzrCommandError('You cannot specify a NULL'
364
' revision.')
365
rev_id = rev.as_revision_id(b)
366
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
367
369
368
370
369
class cmd_dump_btree(Command):
371
__doc__ = """Dump the contents of a btree index file to stdout.
370
"""Dump the contents of a btree index file to stdout.
372
371
373
372
PATH is a btree index file, it can be any URL. This includes things like
374
373
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
422
421
self.outf.write(page_bytes[:header_end])
423
422
page_bytes = data
424
423
self.outf.write('\nPage %d\n' % (page_idx,))
425
if len(page_bytes) == 0:
426
self.outf.write('(empty)\n');
427
else:
428
decomp_bytes = zlib.decompress(page_bytes)
429
self.outf.write(decomp_bytes)
430
self.outf.write('\n')
424
decomp_bytes = zlib.decompress(page_bytes)
425
self.outf.write(decomp_bytes)
426
self.outf.write('\n')
431
427
432
428
def _dump_entries(self, trans, basename):
433
429
try:
441
437
for node in bt.iter_all_entries():
442
438
# Node is made up of:
443
439
# (index, key, value, [references])
444
try:
445
refs = node[3]
446
except IndexError:
447
refs_as_tuples = None
448
else:
449
refs_as_tuples = static_tuple.as_tuples(refs)
440
refs_as_tuples = static_tuple.as_tuples(node[3])
450
441
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
451
442
self.outf.write('%s\n' % (as_tuple,))
452
443
453
444
454
445
class cmd_remove_tree(Command):
455
__doc__ = """Remove the working tree from a given branch/checkout.
446
"""Remove the working tree from a given branch/checkout.
456
447
457
448
Since a lightweight checkout is little more than a working tree
458
449
this will refuse to run against one.
460
451
To re-create the working tree, use "bzr checkout".
461
452
"""
462
453
_see_also = ['checkout', 'working-trees']
463
takes_args = ['location*']
454
takes_args = ['location?']
464
455
takes_options = [
465
456
Option('force',
466
457
help='Remove the working tree even if it has '
467
'uncommitted or shelved changes.'),
458
'uncommitted changes.'),
468
459
]
469
460
470
def run(self, location_list, force=False):
471
if not location_list:
472
location_list=['.']
473
474
for location in location_list:
475
d = bzrdir.BzrDir.open(location)
476
477
try:
478
working = d.open_workingtree()
479
except errors.NoWorkingTree:
480
raise errors.BzrCommandError("No working tree to remove")
481
except errors.NotLocalUrl:
482
raise errors.BzrCommandError("You cannot remove the working tree"
483
" of a remote path")
484
if not force:
485
if (working.has_changes()):
486
raise errors.UncommittedChanges(working)
487
if working.get_shelf_manager().last_shelf() is not None:
488
raise errors.ShelvedChanges(working)
489
490
if working.user_url != working.branch.user_url:
491
raise errors.BzrCommandError("You cannot remove the working tree"
492
" from a lightweight checkout")
493
494
d.destroy_workingtree()
495
496
497
class cmd_repair_workingtree(Command):
498
__doc__ = """Reset the working tree state file.
499
500
This is not meant to be used normally, but more as a way to recover from
501
filesystem corruption, etc. This rebuilds the working inventory back to a
502
'known good' state. Any new modifications (adding a file, renaming, etc)
503
will be lost, though modified files will still be detected as such.
504
505
Most users will want something more like "bzr revert" or "bzr update"
506
unless the state file has become corrupted.
507
508
By default this attempts to recover the current state by looking at the
509
headers of the state file. If the state file is too corrupted to even do
510
that, you can supply --revision to force the state of the tree.
511
"""
512
513
takes_options = ['revision', 'directory',
514
Option('force',
515
help='Reset the tree even if it doesn\'t appear to be'
516
' corrupted.'),
517
]
518
hidden = True
519
520
def run(self, revision=None, directory='.', force=False):
521
tree, _ = WorkingTree.open_containing(directory)
522
self.add_cleanup(tree.lock_tree_write().unlock)
461
def run(self, location='.', force=False):
462
d = bzrdir.BzrDir.open(location)
463
464
try:
465
working = d.open_workingtree()
466
except errors.NoWorkingTree:
467
raise errors.BzrCommandError("No working tree to remove")
468
except errors.NotLocalUrl:
469
raise errors.BzrCommandError("You cannot remove the working tree"
470
" of a remote path")
523
471
if not force:
524
try:
525
tree.check_state()
526
except errors.BzrError:
527
pass # There seems to be a real error here, so we'll reset
528
else:
529
# Refuse
530
raise errors.BzrCommandError(
531
'The tree does not appear to be corrupt. You probably'
532
' want "bzr revert" instead. Use "--force" if you are'
533
' sure you want to reset the working tree.')
534
if revision is None:
535
revision_ids = None
536
else:
537
revision_ids = [r.as_revision_id(tree.branch) for r in revision]
538
try:
539
tree.reset_state(revision_ids)
540
except errors.BzrError, e:
541
if revision_ids is None:
542
extra = (', the header appears corrupt, try passing -r -1'
543
' to set the state to the last commit')
544
else:
545
extra = ''
546
raise errors.BzrCommandError('failed to reset the tree state'
547
+ extra)
472
if (working.has_changes()):
473
raise errors.UncommittedChanges(working)
474
475
working_path = working.bzrdir.root_transport.base
476
branch_path = working.branch.bzrdir.root_transport.base
477
if working_path != branch_path:
478
raise errors.BzrCommandError("You cannot remove the working tree"
479
" from a lightweight checkout")
480
481
d.destroy_workingtree()
548
482
549
483
550
484
class cmd_revno(Command):
551
__doc__ = """Show current revision number.
485
"""Show current revision number.
552
486
553
487
This is equal to the number of revisions on this branch.
554
488
"""
564
498
if tree:
565
499
try:
566
500
wt = WorkingTree.open_containing(location)[0]
567
self.add_cleanup(wt.lock_read().unlock)
501
wt.lock_read()
568
502
except (errors.NoWorkingTree, errors.NotLocalUrl):
569
503
raise errors.NoWorkingTree(location)
570
revid = wt.last_revision()
571
504
try:
572
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
573
except errors.NoSuchRevision:
574
revno_t = ('???',)
575
revno = ".".join(str(n) for n in revno_t)
505
revid = wt.last_revision()
506
try:
507
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
508
except errors.NoSuchRevision:
509
revno_t = ('???',)
510
revno = ".".join(str(n) for n in revno_t)
511
finally:
512
wt.unlock()
576
513
else:
577
514
b = Branch.open_containing(location)[0]
578
self.add_cleanup(b.lock_read().unlock)
579
revno = b.revno()
580
self.cleanup_now()
515
b.lock_read()
516
try:
517
revno = b.revno()
518
finally:
519
b.unlock()
520
581
521
self.outf.write(str(revno) + '\n')
582
522
583
523
584
524
class cmd_revision_info(Command):
585
__doc__ = """Show revision number and revision id for a given revision identifier.
525
"""Show revision number and revision id for a given revision identifier.
586
526
"""
587
527
hidden = True
588
528
takes_args = ['revision_info*']
589
529
takes_options = [
590
530
'revision',
591
custom_help('directory',
531
Option('directory',
592
532
help='Branch to examine, '
593
'rather than the one containing the working directory.'),
533
'rather than the one containing the working directory.',
534
short_name='d',
535
type=unicode,
536
),
594
537
Option('tree', help='Show revno of working tree'),
595
538
]
596
539
601
544
try:
602
545
wt = WorkingTree.open_containing(directory)[0]
603
546
b = wt.branch
604
self.add_cleanup(wt.lock_read().unlock)
547
wt.lock_read()
605
548
except (errors.NoWorkingTree, errors.NotLocalUrl):
606
549
wt = None
607
550
b = Branch.open_containing(directory)[0]
608
self.add_cleanup(b.lock_read().unlock)
609
revision_ids = []
610
if revision is not None:
611
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
612
if revision_info_list is not None:
613
for rev_str in revision_info_list:
614
rev_spec = RevisionSpec.from_string(rev_str)
615
revision_ids.append(rev_spec.as_revision_id(b))
616
# No arguments supplied, default to the last revision
617
if len(revision_ids) == 0:
618
if tree:
619
if wt is None:
620
raise errors.NoWorkingTree(directory)
621
revision_ids.append(wt.last_revision())
551
b.lock_read()
552
try:
553
revision_ids = []
554
if revision is not None:
555
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
556
if revision_info_list is not None:
557
for rev_str in revision_info_list:
558
rev_spec = RevisionSpec.from_string(rev_str)
559
revision_ids.append(rev_spec.as_revision_id(b))
560
# No arguments supplied, default to the last revision
561
if len(revision_ids) == 0:
562
if tree:
563
if wt is None:
564
raise errors.NoWorkingTree(directory)
565
revision_ids.append(wt.last_revision())
566
else:
567
revision_ids.append(b.last_revision())
568
569
revinfos = []
570
maxlen = 0
571
for revision_id in revision_ids:
572
try:
573
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
574
revno = '.'.join(str(i) for i in dotted_revno)
575
except errors.NoSuchRevision:
576
revno = '???'
577
maxlen = max(maxlen, len(revno))
578
revinfos.append([revno, revision_id])
579
finally:
580
if wt is None:
581
b.unlock()
622
582
else:
623
revision_ids.append(b.last_revision())
624
625
revinfos = []
626
maxlen = 0
627
for revision_id in revision_ids:
628
try:
629
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
630
revno = '.'.join(str(i) for i in dotted_revno)
631
except errors.NoSuchRevision:
632
revno = '???'
633
maxlen = max(maxlen, len(revno))
634
revinfos.append([revno, revision_id])
635
636
self.cleanup_now()
583
wt.unlock()
584
637
585
for ri in revinfos:
638
586
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
639
587
640
588
641
589
class cmd_add(Command):
642
__doc__ = """Add specified files or directories.
590
"""Add specified files or directories.
643
591
644
592
In non-recursive mode, all the named items are added, regardless
645
593
of whether they were previously ignored. A warning is given if
710
658
should_print=(not is_quiet()))
711
659
712
660
if base_tree:
713
self.add_cleanup(base_tree.lock_read().unlock)
714
tree, file_list = tree_files_for_add(file_list)
715
added, ignored = tree.smart_add(file_list, not
716
no_recurse, action=action, save=not dry_run)
717
self.cleanup_now()
661
base_tree.lock_read()
662
try:
663
tree, file_list = tree_files_for_add(file_list)
664
added, ignored = tree.smart_add(file_list, not
665
no_recurse, action=action, save=not dry_run)
666
finally:
667
if base_tree is not None:
668
base_tree.unlock()
718
669
if len(ignored) > 0:
719
670
if verbose:
720
671
for glob in sorted(ignored.keys()):
724
675
725
676
726
677
class cmd_mkdir(Command):
727
__doc__ = """Create a new versioned directory.
678
"""Create a new versioned directory.
728
679
729
680
This is equivalent to creating the directory and then adding it.
730
681
"""
734
685
735
686
def run(self, dir_list):
736
687
for d in dir_list:
688
os.mkdir(d)
737
689
wt, dd = WorkingTree.open_containing(d)
738
base = os.path.dirname(dd)
739
id = wt.path2id(base)
740
if id != None:
741
os.mkdir(d)
742
wt.add([dd])
743
self.outf.write('added %s\n' % d)
744
else:
745
raise errors.NotVersionedError(path=base)
690
wt.add([dd])
691
self.outf.write('added %s\n' % d)
746
692
747
693
748
694
class cmd_relpath(Command):
749
__doc__ = """Show path of a file relative to root"""
695
"""Show path of a file relative to root"""
750
696
751
697
takes_args = ['filename']
752
698
hidden = True
761
707
762
708
763
709
class cmd_inventory(Command):
764
__doc__ = """Show inventory of the current working copy or a revision.
710
"""Show inventory of the current working copy or a revision.
765
711
766
712
It is possible to limit the output to a particular entry
767
713
type using the --kind option. For example: --kind file.
787
733
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
788
734
789
735
revision = _get_one_revision('inventory', revision)
790
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
791
self.add_cleanup(work_tree.lock_read().unlock)
792
if revision is not None:
793
tree = revision.as_tree(work_tree.branch)
794
795
extra_trees = [work_tree]
796
self.add_cleanup(tree.lock_read().unlock)
797
else:
798
tree = work_tree
799
extra_trees = []
800
801
if file_list is not None:
802
file_ids = tree.paths2ids(file_list, trees=extra_trees,
803
require_versioned=True)
804
# find_ids_across_trees may include some paths that don't
805
# exist in 'tree'.
806
entries = sorted(
807
(tree.id2path(file_id), tree.inventory[file_id])
808
for file_id in file_ids if tree.has_id(file_id))
809
else:
810
entries = tree.inventory.entries()
811
812
self.cleanup_now()
736
work_tree, file_list = tree_files(file_list)
737
work_tree.lock_read()
738
try:
739
if revision is not None:
740
tree = revision.as_tree(work_tree.branch)
741
742
extra_trees = [work_tree]
743
tree.lock_read()
744
else:
745
tree = work_tree
746
extra_trees = []
747
748
if file_list is not None:
749
file_ids = tree.paths2ids(file_list, trees=extra_trees,
750
require_versioned=True)
751
# find_ids_across_trees may include some paths that don't
752
# exist in 'tree'.
753
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
754
for file_id in file_ids if file_id in tree)
755
else:
756
entries = tree.inventory.entries()
757
finally:
758
tree.unlock()
759
if tree is not work_tree:
760
work_tree.unlock()
761
813
762
for path, entry in entries:
814
763
if kind and kind != entry.kind:
815
764
continue
821
770
822
771
823
772
class cmd_mv(Command):
824
__doc__ = """Move or rename a file.
773
"""Move or rename a file.
825
774
826
775
:Usage:
827
776
bzr mv OLDNAME NEWNAME
859
808
names_list = []
860
809
if len(names_list) < 2:
861
810
raise errors.BzrCommandError("missing file argument")
862
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
863
self.add_cleanup(tree.lock_tree_write().unlock)
864
self._run(tree, names_list, rel_names, after)
811
tree, rel_names = tree_files(names_list, canonicalize=False)
812
tree.lock_tree_write()
813
try:
814
self._run(tree, names_list, rel_names, after)
815
finally:
816
tree.unlock()
865
817
866
818
def run_auto(self, names_list, after, dry_run):
867
819
if names_list is not None and len(names_list) > 1:
870
822
if after:
871
823
raise errors.BzrCommandError('--after cannot be specified with'
872
824
' --auto.')
873
work_tree, file_list = WorkingTree.open_containing_paths(
874
names_list, default_directory='.')
875
self.add_cleanup(work_tree.lock_tree_write().unlock)
876
rename_map.RenameMap.guess_renames(work_tree, dry_run)
825
work_tree, file_list = tree_files(names_list, default_branch='.')
826
work_tree.lock_tree_write()
827
try:
828
rename_map.RenameMap.guess_renames(work_tree, dry_run)
829
finally:
830
work_tree.unlock()
877
831
878
832
def _run(self, tree, names_list, rel_names, after):
879
833
into_existing = osutils.isdir(names_list[-1])
957
911
958
912
959
913
class cmd_pull(Command):
960
__doc__ = """Turn this branch into a mirror of another branch.
914
"""Turn this branch into a mirror of another branch.
961
915
962
916
By default, this command only works on branches that have not diverged.
963
917
Branches are considered diverged if the destination branch's most recent
972
926
match the remote one, use pull --overwrite. This will work even if the two
973
927
branches have diverged.
974
928
975
If there is no default location set, the first pull will set it (use
976
--no-remember to avoid settting it). After that, you can omit the
977
location to use the default. To change the default, use --remember. The
978
value will only be saved if the remote location can be accessed.
929
If there is no default location set, the first pull will set it. After
930
that, you can omit the location to use the default. To change the
931
default, use --remember. The value will only be saved if the remote
932
location can be accessed.
979
933
980
934
Note: The location can be specified either in the form of a branch,
981
935
or in the form of a path to a file containing a merge directive generated
986
940
takes_options = ['remember', 'overwrite', 'revision',
987
941
custom_help('verbose',
988
942
help='Show logs of pulled revisions.'),
989
custom_help('directory',
943
Option('directory',
990
944
help='Branch to pull into, '
991
'rather than the one containing the working directory.'),
945
'rather than the one containing the working directory.',
946
short_name='d',
947
type=unicode,
948
),
992
949
Option('local',
993
950
help="Perform a local pull in a bound "
994
951
"branch. Local pulls are not applied to "
995
952
"the master branch."
996
953
),
997
Option('show-base',
998
help="Show base revision text in conflicts.")
999
954
]
1000
955
takes_args = ['location?']
1001
956
encoding_type = 'replace'
1002
957
1003
def run(self, location=None, remember=None, overwrite=False,
958
def run(self, location=None, remember=False, overwrite=False,
1004
959
revision=None, verbose=False,
1005
directory=None, local=False,
1006
show_base=False):
960
directory=None, local=False):
1007
961
# FIXME: too much stuff is in the command class
1008
962
revision_id = None
1009
963
mergeable = None
1012
966
try:
1013
967
tree_to = WorkingTree.open_containing(directory)[0]
1014
968
branch_to = tree_to.branch
1015
self.add_cleanup(tree_to.lock_write().unlock)
1016
969
except errors.NoWorkingTree:
1017
970
tree_to = None
1018
971
branch_to = Branch.open_containing(directory)[0]
1019
self.add_cleanup(branch_to.lock_write().unlock)
1020
1021
if tree_to is None and show_base:
1022
raise errors.BzrCommandError("Need working tree for --show-base.")
1023
972
1024
973
if local and not branch_to.get_bound_location():
1025
974
raise errors.LocalRequiresBoundBranch()
1026
975
1056
1005
else:
1057
1006
branch_from = Branch.open(location,
1058
1007
possible_transports=possible_transports)
1059
self.add_cleanup(branch_from.lock_read().unlock)
1060
# Remembers if asked explicitly or no previous location is set
1061
if (remember
1062
or (remember is None and branch_to.get_parent() is None)):
1008
1009
if branch_to.get_parent() is None or remember:
1063
1010
branch_to.set_parent(branch_from.base)
1064
1011
1065
if revision is not None:
1066
revision_id = revision.as_revision_id(branch_from)
1067
1068
if tree_to is not None:
1069
view_info = _get_view_info_for_change_reporter(tree_to)
1070
change_reporter = delta._ChangeReporter(
1071
unversioned_filter=tree_to.is_ignored,
1072
view_info=view_info)
1073
result = tree_to.pull(
1074
branch_from, overwrite, revision_id, change_reporter,
1075
possible_transports=possible_transports, local=local,
1076
show_base=show_base)
1077
else:
1078
result = branch_to.pull(
1079
branch_from, overwrite, revision_id, local=local)
1080
1081
result.report(self.outf)
1082
if verbose and result.old_revid != result.new_revid:
1083
log.show_branch_change(
1084
branch_to, self.outf, result.old_revno,
1085
result.old_revid)
1086
if getattr(result, 'tag_conflicts', None):
1087
return 1
1088
else:
1089
return 0
1012
if branch_from is not branch_to:
1013
branch_from.lock_read()
1014
try:
1015
if revision is not None:
1016
revision_id = revision.as_revision_id(branch_from)
1017
1018
branch_to.lock_write()
1019
try:
1020
if tree_to is not None:
1021
view_info = _get_view_info_for_change_reporter(tree_to)
1022
change_reporter = delta._ChangeReporter(
1023
unversioned_filter=tree_to.is_ignored,
1024
view_info=view_info)
1025
result = tree_to.pull(
1026
branch_from, overwrite, revision_id, change_reporter,
1027
possible_transports=possible_transports, local=local)
1028
else:
1029
result = branch_to.pull(
1030
branch_from, overwrite, revision_id, local=local)
1031
1032
result.report(self.outf)
1033
if verbose and result.old_revid != result.new_revid:
1034
log.show_branch_change(
1035
branch_to, self.outf, result.old_revno,
1036
result.old_revid)
1037
finally:
1038
branch_to.unlock()
1039
finally:
1040
if branch_from is not branch_to:
1041
branch_from.unlock()
1090
1042
1091
1043
1092
1044
class cmd_push(Command):
1093
__doc__ = """Update a mirror of this branch.
1045
"""Update a mirror of this branch.
1094
1046
1095
1047
The target branch will not have its working tree populated because this
1096
1048
is both expensive, and is not supported on remote file systems.
1109
1061
do a merge (see bzr help merge) from the other branch, and commit that.
1110
1062
After that you will be able to do a push without '--overwrite'.
1111
1063
1112
If there is no default push location set, the first push will set it (use
1113
--no-remember to avoid settting it). After that, you can omit the
1114
location to use the default. To change the default, use --remember. The
1115
value will only be saved if the remote location can be accessed.
1064
If there is no default push location set, the first push will set it.
1065
After that, you can omit the location to use the default. To change the
1066
default, use --remember. The value will only be saved if the remote
1067
location can be accessed.
1116
1068
"""
1117
1069
1118
1070
_see_also = ['pull', 'update', 'working-trees']
1120
1072
Option('create-prefix',
1121
1073
help='Create the path leading up to the branch '
1122
1074
'if it does not already exist.'),
1123
custom_help('directory',
1075
Option('directory',
1124
1076
help='Branch to push from, '
1125
'rather than the one containing the working directory.'),
1077
'rather than the one containing the working directory.',
1078
short_name='d',
1079
type=unicode,
1080
),
1126
1081
Option('use-existing-dir',
1127
1082
help='By default push will fail if the target'
1128
1083
' directory exists, but does not already'
1139
1094
Option('strict',
1140
1095
help='Refuse to push if there are uncommitted changes in'
1141
1096
' the working tree, --no-strict disables the check.'),
1142
Option('no-tree',
1143
help="Don't populate the working tree, even for protocols"
1144
" that support it."),
1145
1097
]
1146
1098
takes_args = ['location?']
1147
1099
encoding_type = 'replace'
1148
1100
1149
def run(self, location=None, remember=None, overwrite=False,
1101
def run(self, location=None, remember=False, overwrite=False,
1150
1102
create_prefix=False, verbose=False, revision=None,
1151
1103
use_existing_dir=False, directory=None, stacked_on=None,
1152
stacked=False, strict=None, no_tree=False):
1104
stacked=False, strict=None):
1153
1105
from bzrlib.push import _show_push_branch
1154
1106
1155
1107
if directory is None:
1157
1109
# Get the source branch
1158
1110
(tree, br_from,
1159
1111
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1112
if strict is None:
1113
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1114
if strict is None: strict = True # default value
1160
1115
# Get the tip's revision_id
1161
1116
revision = _get_one_revision('push', revision)
1162
1117
if revision is not None:
1163
1118
revision_id = revision.in_history(br_from).rev_id
1164
1119
else:
1165
1120
revision_id = None
1166
if tree is not None and revision_id is None:
1167
tree.check_changed_or_out_of_date(
1168
strict, 'push_strict',
1169
more_error='Use --no-strict to force the push.',
1170
more_warning='Uncommitted changes will not be pushed.')
1121
if strict and tree is not None and revision_id is None:
1122
if (tree.has_changes()):
1123
raise errors.UncommittedChanges(
1124
tree, more='Use --no-strict to force the push.')
1125
if tree.last_revision() != tree.branch.last_revision():
1126
# The tree has lost sync with its branch, there is little
1127
# chance that the user is aware of it but he can still force
1128
# the push with --no-strict
1129
raise errors.OutOfDateTree(
1130
tree, more='Use --no-strict to force the push.')
1131
1171
1132
# Get the stacked_on branch, if any
1172
1133
if stacked_on is not None:
1173
1134
stacked_on = urlutils.normalize_url(stacked_on)
1195
1156
else:
1196
1157
display_url = urlutils.unescape_for_display(stored_loc,
1197
1158
self.outf.encoding)
1198
note("Using saved push location: %s" % display_url)
1159
self.outf.write("Using saved push location: %s\n" % display_url)
1199
1160
location = stored_loc
1200
1161
1201
1162
_show_push_branch(br_from, revision_id, location, self.outf,
1202
1163
verbose=verbose, overwrite=overwrite, remember=remember,
1203
1164
stacked_on=stacked_on, create_prefix=create_prefix,
1204
use_existing_dir=use_existing_dir, no_tree=no_tree)
1165
use_existing_dir=use_existing_dir)
1205
1166
1206
1167
1207
1168
class cmd_branch(Command):
1208
__doc__ = """Create a new branch that is a copy of an existing branch.
1169
"""Create a new branch that is a copy of an existing branch.
1209
1170
1210
1171
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1211
1172
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1216
1177
1217
1178
To retrieve the branch as of a particular revision, supply the --revision
1218
1179
parameter, as in "branch foo/bar -r 5".
1219
1220
The synonyms 'clone' and 'get' for this command are deprecated.
1221
1180
"""
1222
1181
1223
1182
_see_also = ['checkout']
1224
1183
takes_args = ['from_location', 'to_location?']
1225
takes_options = ['revision',
1226
Option('hardlink', help='Hard-link working tree files where possible.'),
1227
Option('files-from', type=str,
1228
help="Get file contents from this tree."),
1184
takes_options = ['revision', Option('hardlink',
1185
help='Hard-link working tree files where possible.'),
1229
1186
Option('no-tree',
1230
1187
help="Create a branch without a working-tree."),
1231
1188
Option('switch',
1242
1199
' directory exists, but does not already'
1243
1200
' have a control directory. This flag will'
1244
1201
' allow branch to proceed.'),
1245
Option('bind',
1246
help="Bind new branch to from location."),
1247
1202
]
1248
1203
aliases = ['get', 'clone']
1249
1204
1250
1205
def run(self, from_location, to_location=None, revision=None,
1251
1206
hardlink=False, stacked=False, standalone=False, no_tree=False,
1252
use_existing_dir=False, switch=False, bind=False,
1253
files_from=None):
1207
use_existing_dir=False, switch=False):
1254
1208
from bzrlib import switch as _mod_switch
1255
1209
from bzrlib.tag import _merge_tags_if_possible
1256
if self.invoked_as in ['get', 'clone']:
1257
ui.ui_factory.show_user_warning(
1258
'deprecated_command',
1259
deprecated_name=self.invoked_as,
1260
recommended_name='branch',
1261
deprecated_in_version='2.4')
1262
1210
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1263
1211
from_location)
1264
if not (hardlink or files_from):
1265
# accelerator_tree is usually slower because you have to read N
1266
# files (no readahead, lots of seeks, etc), but allow the user to
1267
# explicitly request it
1268
accelerator_tree = None
1269
if files_from is not None and files_from != from_location:
1270
accelerator_tree = WorkingTree.open(files_from)
1271
1212
revision = _get_one_revision('branch', revision)
1272
self.add_cleanup(br_from.lock_read().unlock)
1273
if revision is not None:
1274
revision_id = revision.as_revision_id(br_from)
1275
else:
1276
# FIXME - wt.last_revision, fallback to branch, fall back to
1277
# None or perhaps NULL_REVISION to mean copy nothing
1278
# RBC 20060209
1279
revision_id = br_from.last_revision()
1280
if to_location is None:
1281
to_location = urlutils.derive_to_location(from_location)
1282
to_transport = transport.get_transport(to_location)
1213
br_from.lock_read()
1283
1214
try:
1284
to_transport.mkdir('.')
1285
except errors.FileExists:
1286
if not use_existing_dir:
1287
raise errors.BzrCommandError('Target directory "%s" '
1288
'already exists.' % to_location)
1215
if revision is not None:
1216
revision_id = revision.as_revision_id(br_from)
1289
1217
else:
1290
try:
1291
bzrdir.BzrDir.open_from_transport(to_transport)
1292
except errors.NotBranchError:
1293
pass
1218
# FIXME - wt.last_revision, fallback to branch, fall back to
1219
# None or perhaps NULL_REVISION to mean copy nothing
1220
# RBC 20060209
1221
revision_id = br_from.last_revision()
1222
if to_location is None:
1223
to_location = urlutils.derive_to_location(from_location)
1224
to_transport = transport.get_transport(to_location)
1225
try:
1226
to_transport.mkdir('.')
1227
except errors.FileExists:
1228
if not use_existing_dir:
1229
raise errors.BzrCommandError('Target directory "%s" '
1230
'already exists.' % to_location)
1294
1231
else:
1295
raise errors.AlreadyBranchError(to_location)
1296
except errors.NoSuchFile:
1297
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1298
% to_location)
1299
try:
1300
# preserve whatever source format we have.
1301
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1302
possible_transports=[to_transport],
1303
accelerator_tree=accelerator_tree,
1304
hardlink=hardlink, stacked=stacked,
1305
force_new_repo=standalone,
1306
create_tree_if_local=not no_tree,
1307
source_branch=br_from)
1308
branch = dir.open_branch()
1309
except errors.NoSuchRevision:
1310
to_transport.delete_tree('.')
1311
msg = "The branch %s has no revision %s." % (from_location,
1312
revision)
1313
raise errors.BzrCommandError(msg)
1314
_merge_tags_if_possible(br_from, branch)
1315
# If the source branch is stacked, the new branch may
1316
# be stacked whether we asked for that explicitly or not.
1317
# We therefore need a try/except here and not just 'if stacked:'
1318
try:
1319
note('Created new stacked branch referring to %s.' %
1320
branch.get_stacked_on_url())
1321
except (errors.NotStacked, errors.UnstackableBranchFormat,
1322
errors.UnstackableRepositoryFormat), e:
1323
note('Branched %d revision(s).' % branch.revno())
1324
if bind:
1325
# Bind to the parent
1326
parent_branch = Branch.open(from_location)
1327
branch.bind(parent_branch)
1328
note('New branch bound to %s' % from_location)
1329
if switch:
1330
# Switch to the new branch
1331
wt, _ = WorkingTree.open_containing('.')
1332
_mod_switch.switch(wt.bzrdir, branch)
1333
note('Switched to branch: %s',
1334
urlutils.unescape_for_display(branch.base, 'utf-8'))
1232
try:
1233
bzrdir.BzrDir.open_from_transport(to_transport)
1234
except errors.NotBranchError:
1235
pass
1236
else:
1237
raise errors.AlreadyBranchError(to_location)
1238
except errors.NoSuchFile:
1239
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1240
% to_location)
1241
try:
1242
# preserve whatever source format we have.
1243
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1244
possible_transports=[to_transport],
1245
accelerator_tree=accelerator_tree,
1246
hardlink=hardlink, stacked=stacked,
1247
force_new_repo=standalone,
1248
create_tree_if_local=not no_tree,
1249
source_branch=br_from)
1250
branch = dir.open_branch()
1251
except errors.NoSuchRevision:
1252
to_transport.delete_tree('.')
1253
msg = "The branch %s has no revision %s." % (from_location,
1254
revision)
1255
raise errors.BzrCommandError(msg)
1256
_merge_tags_if_possible(br_from, branch)
1257
# If the source branch is stacked, the new branch may
1258
# be stacked whether we asked for that explicitly or not.
1259
# We therefore need a try/except here and not just 'if stacked:'
1260
try:
1261
note('Created new stacked branch referring to %s.' %
1262
branch.get_stacked_on_url())
1263
except (errors.NotStacked, errors.UnstackableBranchFormat,
1264
errors.UnstackableRepositoryFormat), e:
1265
note('Branched %d revision(s).' % branch.revno())
1266
if switch:
1267
# Switch to the new branch
1268
wt, _ = WorkingTree.open_containing('.')
1269
_mod_switch.switch(wt.bzrdir, branch)
1270
note('Switched to branch: %s',
1271
urlutils.unescape_for_display(branch.base, 'utf-8'))
1272
finally:
1273
br_from.unlock()
1335
1274
1336
1275
1337
1276
class cmd_checkout(Command):
1338
__doc__ = """Create a new checkout of an existing branch.
1277
"""Create a new checkout of an existing branch.
1339
1278
1340
1279
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1341
1280
the branch found in '.'. This is useful if you have removed the working tree
1380
1319
to_location = branch_location
1381
1320
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1382
1321
branch_location)
1383
if not (hardlink or files_from):
1384
# accelerator_tree is usually slower because you have to read N
1385
# files (no readahead, lots of seeks, etc), but allow the user to
1386
# explicitly request it
1387
accelerator_tree = None
1388
1322
revision = _get_one_revision('checkout', revision)
1389
if files_from is not None and files_from != branch_location:
1323
if files_from is not None:
1390
1324
accelerator_tree = WorkingTree.open(files_from)
1391
1325
if revision is not None:
1392
1326
revision_id = revision.as_revision_id(source)
1409
1343
1410
1344
1411
1345
class cmd_renames(Command):
1412
__doc__ = """Show list of renamed files.
1346
"""Show list of renamed files.
1413
1347
"""
1414
1348
# TODO: Option to show renames between two historical versions.
1415
1349
1420
1354
@display_command
1421
1355
def run(self, dir=u'.'):
1422
1356
tree = WorkingTree.open_containing(dir)[0]
1423
self.add_cleanup(tree.lock_read().unlock)
1424
new_inv = tree.inventory
1425
old_tree = tree.basis_tree()
1426
self.add_cleanup(old_tree.lock_read().unlock)
1427
old_inv = old_tree.inventory
1428
renames = []
1429
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1430
for f, paths, c, v, p, n, k, e in iterator:
1431
if paths[0] == paths[1]:
1432
continue
1433
if None in (paths):
1434
continue
1435
renames.append(paths)
1436
renames.sort()
1437
for old_name, new_name in renames:
1438
self.outf.write("%s => %s\n" % (old_name, new_name))
1357
tree.lock_read()
1358
try:
1359
new_inv = tree.inventory
1360
old_tree = tree.basis_tree()
1361
old_tree.lock_read()
1362
try:
1363
old_inv = old_tree.inventory
1364
renames = []
1365
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1366
for f, paths, c, v, p, n, k, e in iterator:
1367
if paths[0] == paths[1]:
1368
continue
1369
if None in (paths):
1370
continue
1371
renames.append(paths)
1372
renames.sort()
1373
for old_name, new_name in renames:
1374
self.outf.write("%s => %s\n" % (old_name, new_name))
1375
finally:
1376
old_tree.unlock()
1377
finally:
1378
tree.unlock()
1439
1379
1440
1380
1441
1381
class cmd_update(Command):
1442
__doc__ = """Update a tree to have the latest code committed to its branch.
1382
"""Update a tree to have the latest code committed to its branch.
1443
1383
1444
1384
This will perform a merge into the working tree, and may generate
1445
1385
conflicts. If you have any local changes, you will still
1447
1387
1448
1388
If you want to discard your local changes, you can just do a
1449
1389
'bzr revert' instead of 'bzr commit' after the update.
1450
1451
If you want to restore a file that has been removed locally, use
1452
'bzr revert' instead of 'bzr update'.
1453
1454
If the tree's branch is bound to a master branch, it will also update
1455
the branch from the master.
1456
1390
"""
1457
1391
1458
1392
_see_also = ['pull', 'working-trees', 'status-flags']
1459
1393
takes_args = ['dir?']
1460
takes_options = ['revision',
1461
Option('show-base',
1462
help="Show base revision text in conflicts."),
1463
]
1464
1394
aliases = ['up']
1465
1395
1466
def run(self, dir='.', revision=None, show_base=None):
1467
if revision is not None and len(revision) != 1:
1468
raise errors.BzrCommandError(
1469
"bzr update --revision takes exactly one revision")
1396
def run(self, dir='.'):
1470
1397
tree = WorkingTree.open_containing(dir)[0]
1471
branch = tree.branch
1472
1398
possible_transports = []
1473
master = branch.get_master_branch(
1399
master = tree.branch.get_master_branch(
1474
1400
possible_transports=possible_transports)
1475
1401
if master is not None:
1402
tree.lock_write()
1476
1403
branch_location = master.base
1477
tree.lock_write()
1478
1404
else:
1405
tree.lock_tree_write()
1479
1406
branch_location = tree.branch.base
1480
tree.lock_tree_write()
1481
self.add_cleanup(tree.unlock)
1482
1407
# get rid of the final '/' and be ready for display
1483
branch_location = urlutils.unescape_for_display(
1484
branch_location.rstrip('/'),
1485
self.outf.encoding)
1486
existing_pending_merges = tree.get_parent_ids()[1:]
1487
if master is None:
1488
old_tip = None
1489
else:
1490
# may need to fetch data into a heavyweight checkout
1491
# XXX: this may take some time, maybe we should display a
1492
# message
1493
old_tip = branch.update(possible_transports)
1494
if revision is not None:
1495
revision_id = revision[0].as_revision_id(branch)
1496
else:
1497
revision_id = branch.last_revision()
1498
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1499
revno = branch.revision_id_to_dotted_revno(revision_id)
1500
note("Tree is up to date at revision %s of branch %s" %
1501
('.'.join(map(str, revno)), branch_location))
1502
return 0
1503
view_info = _get_view_info_for_change_reporter(tree)
1504
change_reporter = delta._ChangeReporter(
1505
unversioned_filter=tree.is_ignored,
1506
view_info=view_info)
1408
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1409
self.outf.encoding)
1507
1410
try:
1411
existing_pending_merges = tree.get_parent_ids()[1:]
1412
last_rev = _mod_revision.ensure_null(tree.last_revision())
1413
if last_rev == _mod_revision.ensure_null(
1414
tree.branch.last_revision()):
1415
# may be up to date, check master too.
1416
if master is None or last_rev == _mod_revision.ensure_null(
1417
master.last_revision()):
1418
revno = tree.branch.revision_id_to_revno(last_rev)
1419
note('Tree is up to date at revision %d of branch %s'
1420
% (revno, branch_location))
1421
return 0
1422
view_info = _get_view_info_for_change_reporter(tree)
1508
1423
conflicts = tree.update(
1509
change_reporter,
1510
possible_transports=possible_transports,
1511
revision=revision_id,
1512
old_tip=old_tip,
1513
show_base=show_base)
1514
except errors.NoSuchRevision, e:
1515
raise errors.BzrCommandError(
1516
"branch has no revision %s\n"
1517
"bzr update --revision only works"
1518
" for a revision in the branch history"
1519
% (e.revision))
1520
revno = tree.branch.revision_id_to_dotted_revno(
1521
_mod_revision.ensure_null(tree.last_revision()))
1522
note('Updated to revision %s of branch %s' %
1523
('.'.join(map(str, revno)), branch_location))
1524
parent_ids = tree.get_parent_ids()
1525
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1526
note('Your local commits will now show as pending merges with '
1527
"'bzr status', and can be committed with 'bzr commit'.")
1528
if conflicts != 0:
1529
return 1
1530
else:
1531
return 0
1424
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1425
view_info=view_info), possible_transports=possible_transports)
1426
revno = tree.branch.revision_id_to_revno(
1427
_mod_revision.ensure_null(tree.last_revision()))
1428
note('Updated to revision %d of branch %s' %
1429
(revno, branch_location))
1430
if tree.get_parent_ids()[1:] != existing_pending_merges:
1431
note('Your local commits will now show as pending merges with '
1432
"'bzr status', and can be committed with 'bzr commit'.")
1433
if conflicts != 0:
1434
return 1
1435
else:
1436
return 0
1437
finally:
1438
tree.unlock()
1532
1439
1533
1440
1534
1441
class cmd_info(Command):
1535
__doc__ = """Show information about a working tree, branch or repository.
1442
"""Show information about a working tree, branch or repository.
1536
1443
1537
1444
This command will show all known locations and formats associated to the
1538
1445
tree, branch or repository.
1576
1483
1577
1484
1578
1485
class cmd_remove(Command):
1579
__doc__ = """Remove files or directories.
1486
"""Remove files or directories.
1580
1487
1581
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1582
delete them if they can easily be recovered using revert otherwise they
1583
will be backed up (adding an extention of the form .~#~). If no options or
1584
parameters are given Bazaar will scan for files that are being tracked by
1585
Bazaar but missing in your tree and stop tracking them for you.
1488
This makes bzr stop tracking changes to the specified files. bzr will delete
1489
them if they can easily be recovered using revert. If no options or
1490
parameters are given bzr will scan for files that are being tracked by bzr
1491
but missing in your tree and stop tracking them for you.
1586
1492
"""
1587
1493
takes_args = ['file*']
1588
1494
takes_options = ['verbose',
1590
1496
RegistryOption.from_kwargs('file-deletion-strategy',
1591
1497
'The file deletion mode to be used.',
1592
1498
title='Deletion Strategy', value_switches=True, enum_switch=False,
1593
safe='Backup changed files (default).',
1499
safe='Only delete files if they can be'
1500
' safely recovered (default).',
1594
1501
keep='Delete from bzr but leave the working copy.',
1595
no_backup='Don\'t backup changed files.',
1596
1502
force='Delete all the specified files, even if they can not be '
1597
'recovered and even if they are non-empty directories. '
1598
'(deprecated, use no-backup)')]
1503
'recovered and even if they are non-empty directories.')]
1599
1504
aliases = ['rm', 'del']
1600
1505
encoding_type = 'replace'
1601
1506
1602
1507
def run(self, file_list, verbose=False, new=False,
1603
1508
file_deletion_strategy='safe'):
1604
if file_deletion_strategy == 'force':
1605
note("(The --force option is deprecated, rather use --no-backup "
1606
"in future.)")
1607
file_deletion_strategy = 'no-backup'
1608
1609
tree, file_list = WorkingTree.open_containing_paths(file_list)
1509
tree, file_list = tree_files(file_list)
1610
1510
1611
1511
if file_list is not None:
1612
1512
file_list = [f for f in file_list]
1613
1513
1614
self.add_cleanup(tree.lock_write().unlock)
1615
# Heuristics should probably all move into tree.remove_smart or
1616
# some such?
1617
if new:
1618
added = tree.changes_from(tree.basis_tree(),
1619
specific_files=file_list).added
1620
file_list = sorted([f[0] for f in added], reverse=True)
1621
if len(file_list) == 0:
1622
raise errors.BzrCommandError('No matching files.')
1623
elif file_list is None:
1624
# missing files show up in iter_changes(basis) as
1625
# versioned-with-no-kind.
1626
missing = []
1627
for change in tree.iter_changes(tree.basis_tree()):
1628
# Find paths in the working tree that have no kind:
1629
if change[1][1] is not None and change[6][1] is None:
1630
missing.append(change[1][1])
1631
file_list = sorted(missing, reverse=True)
1632
file_deletion_strategy = 'keep'
1633
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1634
keep_files=file_deletion_strategy=='keep',
1635
force=(file_deletion_strategy=='no-backup'))
1514
tree.lock_write()
1515
try:
1516
# Heuristics should probably all move into tree.remove_smart or
1517
# some such?
1518
if new:
1519
added = tree.changes_from(tree.basis_tree(),
1520
specific_files=file_list).added
1521
file_list = sorted([f[0] for f in added], reverse=True)
1522
if len(file_list) == 0:
1523
raise errors.BzrCommandError('No matching files.')
1524
elif file_list is None:
1525
# missing files show up in iter_changes(basis) as
1526
# versioned-with-no-kind.
1527
missing = []
1528
for change in tree.iter_changes(tree.basis_tree()):
1529
# Find paths in the working tree that have no kind:
1530
if change[1][1] is not None and change[6][1] is None:
1531
missing.append(change[1][1])
1532
file_list = sorted(missing, reverse=True)
1533
file_deletion_strategy = 'keep'
1534
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1535
keep_files=file_deletion_strategy=='keep',
1536
force=file_deletion_strategy=='force')
1537
finally:
1538
tree.unlock()
1636
1539
1637
1540
1638
1541
class cmd_file_id(Command):
1639
__doc__ = """Print file_id of a particular file or directory.
1542
"""Print file_id of a particular file or directory.
1640
1543
1641
1544
The file_id is assigned when the file is first added and remains the
1642
1545
same through all revisions where the file exists, even when it is
1658
1561
1659
1562
1660
1563
class cmd_file_path(Command):
1661
__doc__ = """Print path of file_ids to a file or directory.
1564
"""Print path of file_ids to a file or directory.
1662
1565
1663
1566
This prints one line for each directory down to the target,
1664
1567
starting at the branch root.
1680
1583
1681
1584
1682
1585
class cmd_reconcile(Command):
1683
__doc__ = """Reconcile bzr metadata in a branch.
1586
"""Reconcile bzr metadata in a branch.
1684
1587
1685
1588
This can correct data mismatches that may have been caused by
1686
1589
previous ghost operations or bzr upgrades. You should only
1700
1603
1701
1604
_see_also = ['check']
1702
1605
takes_args = ['branch?']
1703
takes_options = [
1704
Option('canonicalize-chks',
1705
help='Make sure CHKs are in canonical form (repairs '
1706
'bug 522637).',
1707
hidden=True),
1708
]
1709
1606
1710
def run(self, branch=".", canonicalize_chks=False):
1607
def run(self, branch="."):
1711
1608
from bzrlib.reconcile import reconcile
1712
1609
dir = bzrdir.BzrDir.open(branch)
1713
reconcile(dir, canonicalize_chks=canonicalize_chks)
1610
reconcile(dir)
1714
1611
1715
1612
1716
1613
class cmd_revision_history(Command):
1717
__doc__ = """Display the list of revision ids on a branch."""
1614
"""Display the list of revision ids on a branch."""
1718
1615
1719
1616
_see_also = ['log']
1720
1617
takes_args = ['location?']
1730
1627
1731
1628
1732
1629
class cmd_ancestry(Command):
1733
__doc__ = """List all revisions merged into this branch."""
1630
"""List all revisions merged into this branch."""
1734
1631
1735
1632
_see_also = ['log', 'revision-history']
1736
1633
takes_args = ['location?']
1748
1645
b = wt.branch
1749
1646
last_revision = wt.last_revision()
1750
1647
1751
self.add_cleanup(b.repository.lock_read().unlock)
1752
graph = b.repository.get_graph()
1753
revisions = [revid for revid, parents in
1754
graph.iter_ancestry([last_revision])]
1755
for revision_id in reversed(revisions):
1756
if _mod_revision.is_null(revision_id):
1757
continue
1648
revision_ids = b.repository.get_ancestry(last_revision)
1649
revision_ids.pop(0)
1650
for revision_id in revision_ids:
1758
1651
self.outf.write(revision_id + '\n')
1759
1652
1760
1653
1761
1654
class cmd_init(Command):
1762
__doc__ = """Make a directory into a versioned branch.
1655
"""Make a directory into a versioned branch.
1763
1656
1764
1657
Use this to create an empty branch, or before importing an
1765
1658
existing project.
1797
1690
),
1798
1691
Option('append-revisions-only',
1799
1692
help='Never change revnos or the existing log.'
1800
' Append revisions to it only.'),
1801
Option('no-tree',
1802
'Create a branch without a working tree.')
1693
' Append revisions to it only.')
1803
1694
]
1804
1695
def run(self, location=None, format=None, append_revisions_only=False,
1805
create_prefix=False, no_tree=False):
1696
create_prefix=False):
1806
1697
if format is None:
1807
1698
format = bzrdir.format_registry.make_bzrdir('default')
1808
1699
if location is None:
1831
1722
except errors.NotBranchError:
1832
1723
# really a NotBzrDir error...
1833
1724
create_branch = bzrdir.BzrDir.create_branch_convenience
1834
if no_tree:
1835
force_new_tree = False
1836
else:
1837
force_new_tree = None
1838
1725
branch = create_branch(to_transport.base, format=format,
1839
possible_transports=[to_transport],
1840
force_new_tree=force_new_tree)
1726
possible_transports=[to_transport])
1841
1727
a_bzrdir = branch.bzrdir
1842
1728
else:
1843
1729
from bzrlib.transport.local import LocalTransport
1847
1733
raise errors.BranchExistsWithoutWorkingTree(location)
1848
1734
raise errors.AlreadyBranchError(location)
1849
1735
branch = a_bzrdir.create_branch()
1850
if not no_tree:
1851
a_bzrdir.create_workingtree()
1736
a_bzrdir.create_workingtree()
1852
1737
if append_revisions_only:
1853
1738
try:
1854
1739
branch.set_append_revisions_only(True)
1876
1761
1877
1762
1878
1763
class cmd_init_repository(Command):
1879
__doc__ = """Create a shared repository for branches to share storage space.
1764
"""Create a shared repository for branches to share storage space.
1880
1765
1881
1766
New branches created under the repository directory will store their
1882
1767
revisions in the repository, not in the branch directory. For branches
1936
1821
1937
1822
1938
1823
class cmd_diff(Command):
1939
__doc__ = """Show differences in the working tree, between revisions or branches.
1824
"""Show differences in the working tree, between revisions or branches.
1940
1825
1941
1826
If no arguments are given, all changes for the current tree are listed.
1942
1827
If files are given, only the changes in those files are listed.
1948
1833
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1949
1834
produces patches suitable for "patch -p1".
1950
1835
1951
Note that when using the -r argument with a range of revisions, the
1952
differences are computed between the two specified revisions. That
1953
is, the command does not show the changes introduced by the first
1954
revision in the range. This differs from the interpretation of
1955
revision ranges used by "bzr log" which includes the first revision
1956
in the range.
1957
1958
1836
:Exit values:
1959
1837
1 - changed
1960
1838
2 - unrepresentable changes
1978
1856
1979
1857
bzr diff -r1..3 xxx
1980
1858
1981
The changes introduced by revision 2 (equivalent to -r1..2)::
1982
1983
bzr diff -c2
1984
1985
To see the changes introduced by revision X::
1859
To see the changes introduced in revision X::
1986
1860
1987
1861
bzr diff -cX
1988
1862
1992
1866
1993
1867
bzr diff -r<chosen_parent>..X
1994
1868
1995
The changes between the current revision and the previous revision
1996
(equivalent to -c-1 and -r-2..-1)
1869
The changes introduced by revision 2 (equivalent to -r1..2)::
1997
1870
1998
bzr diff -r-2..
1871
bzr diff -c2
1999
1872
2000
1873
Show just the differences for file NEWS::
2001
1874
2016
1889
Same as 'bzr diff' but prefix paths with old/ and new/::
2017
1890
2018
1891
bzr diff --prefix old/:new/
2019
2020
Show the differences using a custom diff program with options::
2021
2022
bzr diff --using /usr/bin/diff --diff-options -wu
2023
1892
"""
2024
1893
_see_also = ['status']
2025
1894
takes_args = ['file*']
2044
1913
help='Use this command to compare files.',
2045
1914
type=unicode,
2046
1915
),
2047
RegistryOption('format',
2048
short_name='F',
2049
help='Diff format to use.',
2050
lazy_registry=('bzrlib.diff', 'format_registry'),
2051
title='Diff format'),
2052
1916
]
2053
1917
aliases = ['di', 'dif']
2054
1918
encoding_type = 'exact'
2055
1919
2056
1920
@display_command
2057
1921
def run(self, revision=None, file_list=None, diff_options=None,
2058
prefix=None, old=None, new=None, using=None, format=None):
2059
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
2060
show_diff_trees)
1922
prefix=None, old=None, new=None, using=None):
1923
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
2061
1924
2062
1925
if (prefix is None) or (prefix == '0'):
2063
1926
# diff -p0 format
2077
1940
raise errors.BzrCommandError('bzr diff --revision takes exactly'
2078
1941
' one or two revision specifiers')
2079
1942
2080
if using is not None and format is not None:
2081
raise errors.BzrCommandError('--using and --format are mutually '
2082
'exclusive.')
2083
2084
1943
(old_tree, new_tree,
2085
1944
old_branch, new_branch,
2086
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
2087
file_list, revision, old, new, self.add_cleanup, apply_view=True)
2088
# GNU diff on Windows uses ANSI encoding for filenames
2089
path_encoding = osutils.get_diff_header_encoding()
1945
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1946
file_list, revision, old, new, apply_view=True)
2090
1947
return show_diff_trees(old_tree, new_tree, sys.stdout,
2091
1948
specific_files=specific_files,
2092
1949
external_diff_options=diff_options,
2093
1950
old_label=old_label, new_label=new_label,
2094
extra_trees=extra_trees,
2095
path_encoding=path_encoding,
2096
using=using,
2097
format_cls=format)
1951
extra_trees=extra_trees, using=using)
2098
1952
2099
1953
2100
1954
class cmd_deleted(Command):
2101
__doc__ = """List files deleted in the working tree.
1955
"""List files deleted in the working tree.
2102
1956
"""
2103
1957
# TODO: Show files deleted since a previous revision, or
2104
1958
# between two revisions.
2107
1961
# level of effort but possibly much less IO. (Or possibly not,
2108
1962
# if the directories are very large...)
2109
1963
_see_also = ['status', 'ls']
2110
takes_options = ['directory', 'show-ids']
1964
takes_options = ['show-ids']
2111
1965
2112
1966
@display_command
2113
def run(self, show_ids=False, directory=u'.'):
2114
tree = WorkingTree.open_containing(directory)[0]
2115
self.add_cleanup(tree.lock_read().unlock)
2116
old = tree.basis_tree()
2117
self.add_cleanup(old.lock_read().unlock)
2118
for path, ie in old.inventory.iter_entries():
2119
if not tree.has_id(ie.file_id):
2120
self.outf.write(path)
2121
if show_ids:
2122
self.outf.write(' ')
2123
self.outf.write(ie.file_id)
2124
self.outf.write('\n')
1967
def run(self, show_ids=False):
1968
tree = WorkingTree.open_containing(u'.')[0]
1969
tree.lock_read()
1970
try:
1971
old = tree.basis_tree()
1972
old.lock_read()
1973
try:
1974
for path, ie in old.inventory.iter_entries():
1975
if not tree.has_id(ie.file_id):
1976
self.outf.write(path)
1977
if show_ids:
1978
self.outf.write(' ')
1979
self.outf.write(ie.file_id)
1980
self.outf.write('\n')
1981
finally:
1982
old.unlock()
1983
finally:
1984
tree.unlock()
2125
1985
2126
1986
2127
1987
class cmd_modified(Command):
2128
__doc__ = """List files modified in working tree.
1988
"""List files modified in working tree.
2129
1989
"""
2130
1990
2131
1991
hidden = True
2132
1992
_see_also = ['status', 'ls']
2133
takes_options = ['directory', 'null']
1993
takes_options = [
1994
Option('null',
1995
help='Write an ascii NUL (\\0) separator '
1996
'between files rather than a newline.')
1997
]
2134
1998
2135
1999
@display_command
2136
def run(self, null=False, directory=u'.'):
2137
tree = WorkingTree.open_containing(directory)[0]
2138
self.add_cleanup(tree.lock_read().unlock)
2000
def run(self, null=False):
2001
tree = WorkingTree.open_containing(u'.')[0]
2139
2002
td = tree.changes_from(tree.basis_tree())
2140
self.cleanup_now()
2141
2003
for path, id, kind, text_modified, meta_modified in td.modified:
2142
2004
if null:
2143
2005
self.outf.write(path + '\0')
2146
2008
2147
2009
2148
2010
class cmd_added(Command):
2149
__doc__ = """List files added in working tree.
2011
"""List files added in working tree.
2150
2012
"""
2151
2013
2152
2014
hidden = True
2153
2015
_see_also = ['status', 'ls']
2154
takes_options = ['directory', 'null']
2016
takes_options = [
2017
Option('null',
2018
help='Write an ascii NUL (\\0) separator '
2019
'between files rather than a newline.')
2020
]
2155
2021
2156
2022
@display_command
2157
def run(self, null=False, directory=u'.'):
2158
wt = WorkingTree.open_containing(directory)[0]
2159
self.add_cleanup(wt.lock_read().unlock)
2160
basis = wt.basis_tree()
2161
self.add_cleanup(basis.lock_read().unlock)
2162
basis_inv = basis.inventory
2163
inv = wt.inventory
2164
for file_id in inv:
2165
if basis_inv.has_id(file_id):
2166
continue
2167
if inv.is_root(file_id) and len(basis_inv) == 0:
2168
continue
2169
path = inv.id2path(file_id)
2170
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2171
continue
2172
if null:
2173
self.outf.write(path + '\0')
2174
else:
2175
self.outf.write(osutils.quotefn(path) + '\n')
2023
def run(self, null=False):
2024
wt = WorkingTree.open_containing(u'.')[0]
2025
wt.lock_read()
2026
try:
2027
basis = wt.basis_tree()
2028
basis.lock_read()
2029
try:
2030
basis_inv = basis.inventory
2031
inv = wt.inventory
2032
for file_id in inv:
2033
if file_id in basis_inv:
2034
continue
2035
if inv.is_root(file_id) and len(basis_inv) == 0:
2036
continue
2037
path = inv.id2path(file_id)
2038
if not os.access(osutils.abspath(path), os.F_OK):
2039
continue
2040
if null:
2041
self.outf.write(path + '\0')
2042
else:
2043
self.outf.write(osutils.quotefn(path) + '\n')
2044
finally:
2045
basis.unlock()
2046
finally:
2047
wt.unlock()
2176
2048
2177
2049
2178
2050
class cmd_root(Command):
2179
__doc__ = """Show the tree root directory.
2051
"""Show the tree root directory.
2180
2052
2181
2053
The root is the nearest enclosing directory with a .bzr control
2182
2054
directory."""
2206
2078
2207
2079
2208
2080
class cmd_log(Command):
2209
__doc__ = """Show historical log for a branch or subset of a branch.
2081
"""Show historical log for a branch or subset of a branch.
2210
2082
2211
2083
log is bzr's default tool for exploring the history of a branch.
2212
2084
The branch to use is taken from the first parameter. If no parameters
2317
2189
2318
2190
:Other filtering:
2319
2191
2320
The --match option can be used for finding revisions that match a
2321
regular expression in a commit message, committer, author or bug.
2322
Specifying the option several times will match any of the supplied
2323
expressions. --match-author, --match-bugs, --match-committer and
2324
--match-message can be used to only match a specific field.
2192
The --message option can be used for finding revisions that match a
2193
regular expression in a commit message.
2325
2194
2326
2195
:Tips & tricks:
2327
2196
2328
2197
GUI tools and IDEs are often better at exploring history than command
2329
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2330
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2331
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2332
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2198
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2199
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2200
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2201
2202
Web interfaces are often better at exploring history than command line
2203
tools, particularly for branches on servers. You may prefer Loggerhead
2204
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2333
2205
2334
2206
You may find it useful to add the aliases below to ``bazaar.conf``::
2335
2207
2376
2248
help='Show just the specified revision.'
2377
2249
' See also "help revisionspec".'),
2378
2250
'log-format',
2379
RegistryOption('authors',
2380
'What names to list as authors - first, all or committer.',
2381
title='Authors',
2382
lazy_registry=('bzrlib.log', 'author_list_registry'),
2383
),
2384
2251
Option('levels',
2385
2252
short_name='n',
2386
2253
help='Number of levels to display - 0 for all, 1 for flat.',
2387
2254
argname='N',
2388
2255
type=_parse_levels),
2389
2256
Option('message',
2257
short_name='m',
2390
2258
help='Show revisions whose message matches this '
2391
2259
'regular expression.',
2392
type=str,
2393
hidden=True),
2260
type=str),
2394
2261
Option('limit',
2395
2262
short_name='l',
2396
2263
help='Limit the output to the first N revisions.',
2401
2268
help='Show changes made in each revision as a patch.'),
2402
2269
Option('include-merges',
2403
2270
help='Show merged revisions like --levels 0 does.'),
2404
Option('exclude-common-ancestry',
2405
help='Display only the revisions that are not part'
2406
' of both ancestries (require -rX..Y)'
2407
),
2408
Option('signatures',
2409
help='Show digital signature validity'),
2410
ListOption('match',
2411
short_name='m',
2412
help='Show revisions whose properties match this '
2413
'expression.',
2414
type=str),
2415
ListOption('match-message',
2416
help='Show revisions whose message matches this '
2417
'expression.',
2418
type=str),
2419
ListOption('match-committer',
2420
help='Show revisions whose committer matches this '
2421
'expression.',
2422
type=str),
2423
ListOption('match-author',
2424
help='Show revisions whose authors match this '
2425
'expression.',
2426
type=str),
2427
ListOption('match-bugs',
2428
help='Show revisions whose bugs match this '
2429
'expression.',
2430
type=str)
2431
2271
]
2432
2272
encoding_type = 'replace'
2433
2273
2443
2283
message=None,
2444
2284
limit=None,
2445
2285
show_diff=False,
2446
include_merges=False,
2447
authors=None,
2448
exclude_common_ancestry=False,
2449
signatures=False,
2450
match=None,
2451
match_message=None,
2452
match_committer=None,
2453
match_author=None,
2454
match_bugs=None,
2455
):
2286
include_merges=False):
2456
2287
from bzrlib.log import (
2457
2288
Logger,
2458
2289
make_log_request_dict,
2459
2290
_get_info_for_log_files,
2460
2291
)
2461
2292
direction = (forward and 'forward') or 'reverse'
2462
if (exclude_common_ancestry
2463
and (revision is None or len(revision) != 2)):
2464
raise errors.BzrCommandError(
2465
'--exclude-common-ancestry requires -r with two revisions')
2466
2293
if include_merges:
2467
2294
if levels is None:
2468
2295
levels = 0
2481
2308
2482
2309
file_ids = []
2483
2310
filter_by_dir = False
2484
if file_list:
2485
# find the file ids to log and check for directory filtering
2486
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2487
revision, file_list, self.add_cleanup)
2488
for relpath, file_id, kind in file_info_list:
2489
if file_id is None:
2490
raise errors.BzrCommandError(
2491
"Path unknown at end or start of revision range: %s" %
2492
relpath)
2493
# If the relpath is the top of the tree, we log everything
2494
if relpath == '':
2495
file_ids = []
2496
break
2311
b = None
2312
try:
2313
if file_list:
2314
# find the file ids to log and check for directory filtering
2315
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2316
revision, file_list)
2317
for relpath, file_id, kind in file_info_list:
2318
if file_id is None:
2319
raise errors.BzrCommandError(
2320
"Path unknown at end or start of revision range: %s" %
2321
relpath)
2322
# If the relpath is the top of the tree, we log everything
2323
if relpath == '':
2324
file_ids = []
2325
break
2326
else:
2327
file_ids.append(file_id)
2328
filter_by_dir = filter_by_dir or (
2329
kind in ['directory', 'tree-reference'])
2330
else:
2331
# log everything
2332
# FIXME ? log the current subdir only RBC 20060203
2333
if revision is not None \
2334
and len(revision) > 0 and revision[0].get_branch():
2335
location = revision[0].get_branch()
2497
2336
else:
2498
file_ids.append(file_id)
2499
filter_by_dir = filter_by_dir or (
2500
kind in ['directory', 'tree-reference'])
2501
else:
2502
# log everything
2503
# FIXME ? log the current subdir only RBC 20060203
2504
if revision is not None \
2505
and len(revision) > 0 and revision[0].get_branch():
2506
location = revision[0].get_branch()
2507
else:
2508
location = '.'
2509
dir, relpath = bzrdir.BzrDir.open_containing(location)
2510
b = dir.open_branch()
2511
self.add_cleanup(b.lock_read().unlock)
2512
rev1, rev2 = _get_revision_range(revision, b, self.name())
2513
2514
if b.get_config().validate_signatures_in_log():
2515
signatures = True
2516
2517
if signatures:
2518
if not gpg.GPGStrategy.verify_signatures_available():
2519
raise errors.GpgmeNotInstalled(None)
2520
2521
# Decide on the type of delta & diff filtering to use
2522
# TODO: add an --all-files option to make this configurable & consistent
2523
if not verbose:
2524
delta_type = None
2525
else:
2526
delta_type = 'full'
2527
if not show_diff:
2528
diff_type = None
2529
elif file_ids:
2530
diff_type = 'partial'
2531
else:
2532
diff_type = 'full'
2533
2534
# Build the log formatter
2535
if log_format is None:
2536
log_format = log.log_formatter_registry.get_default(b)
2537
# Make a non-encoding output to include the diffs - bug 328007
2538
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2539
lf = log_format(show_ids=show_ids, to_file=self.outf,
2540
to_exact_file=unencoded_output,
2541
show_timezone=timezone,
2542
delta_format=get_verbosity_level(),
2543
levels=levels,
2544
show_advice=levels is None,
2545
author_list_handler=authors)
2546
2547
# Choose the algorithm for doing the logging. It's annoying
2548
# having multiple code paths like this but necessary until
2549
# the underlying repository format is faster at generating
2550
# deltas or can provide everything we need from the indices.
2551
# The default algorithm - match-using-deltas - works for
2552
# multiple files and directories and is faster for small
2553
# amounts of history (200 revisions say). However, it's too
2554
# slow for logging a single file in a repository with deep
2555
# history, i.e. > 10K revisions. In the spirit of "do no
2556
# evil when adding features", we continue to use the
2557
# original algorithm - per-file-graph - for the "single
2558
# file that isn't a directory without showing a delta" case.
2559
partial_history = revision and b.repository._format.supports_chks
2560
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2561
or delta_type or partial_history)
2562
2563
match_dict = {}
2564
if match:
2565
match_dict[''] = match
2566
if match_message:
2567
match_dict['message'] = match_message
2568
if match_committer:
2569
match_dict['committer'] = match_committer
2570
if match_author:
2571
match_dict['author'] = match_author
2572
if match_bugs:
2573
match_dict['bugs'] = match_bugs
2574
2575
# Build the LogRequest and execute it
2576
if len(file_ids) == 0:
2577
file_ids = None
2578
rqst = make_log_request_dict(
2579
direction=direction, specific_fileids=file_ids,
2580
start_revision=rev1, end_revision=rev2, limit=limit,
2581
message_search=message, delta_type=delta_type,
2582
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2583
exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
2584
signature=signatures
2585
)
2586
Logger(b, rqst).show(lf)
2337
location = '.'
2338
dir, relpath = bzrdir.BzrDir.open_containing(location)
2339
b = dir.open_branch()
2340
b.lock_read()
2341
rev1, rev2 = _get_revision_range(revision, b, self.name())
2342
2343
# Decide on the type of delta & diff filtering to use
2344
# TODO: add an --all-files option to make this configurable & consistent
2345
if not verbose:
2346
delta_type = None
2347
else:
2348
delta_type = 'full'
2349
if not show_diff:
2350
diff_type = None
2351
elif file_ids:
2352
diff_type = 'partial'
2353
else:
2354
diff_type = 'full'
2355
2356
# Build the log formatter
2357
if log_format is None:
2358
log_format = log.log_formatter_registry.get_default(b)
2359
# Make a non-encoding output to include the diffs - bug 328007
2360
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2361
lf = log_format(show_ids=show_ids, to_file=self.outf,
2362
to_exact_file=unencoded_output,
2363
show_timezone=timezone,
2364
delta_format=get_verbosity_level(),
2365
levels=levels,
2366
show_advice=levels is None)
2367
2368
# Choose the algorithm for doing the logging. It's annoying
2369
# having multiple code paths like this but necessary until
2370
# the underlying repository format is faster at generating
2371
# deltas or can provide everything we need from the indices.
2372
# The default algorithm - match-using-deltas - works for
2373
# multiple files and directories and is faster for small
2374
# amounts of history (200 revisions say). However, it's too
2375
# slow for logging a single file in a repository with deep
2376
# history, i.e. > 10K revisions. In the spirit of "do no
2377
# evil when adding features", we continue to use the
2378
# original algorithm - per-file-graph - for the "single
2379
# file that isn't a directory without showing a delta" case.
2380
partial_history = revision and b.repository._format.supports_chks
2381
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2382
or delta_type or partial_history)
2383
2384
# Build the LogRequest and execute it
2385
if len(file_ids) == 0:
2386
file_ids = None
2387
rqst = make_log_request_dict(
2388
direction=direction, specific_fileids=file_ids,
2389
start_revision=rev1, end_revision=rev2, limit=limit,
2390
message_search=message, delta_type=delta_type,
2391
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2392
Logger(b, rqst).show(lf)
2393
finally:
2394
if b is not None:
2395
b.unlock()
2587
2396
2588
2397
2589
2398
def _get_revision_range(revisionspec_list, branch, command_name):
2607
2416
raise errors.BzrCommandError(
2608
2417
"bzr %s doesn't accept two revisions in different"
2609
2418
" branches." % command_name)
2610
if start_spec.spec is None:
2611
# Avoid loading all the history.
2612
rev1 = RevisionInfo(branch, None, None)
2613
else:
2614
rev1 = start_spec.in_history(branch)
2419
rev1 = start_spec.in_history(branch)
2615
2420
# Avoid loading all of history when we know a missing
2616
2421
# end of range means the last revision ...
2617
2422
if end_spec.spec is None:
2646
2451
2647
2452
2648
2453
class cmd_touching_revisions(Command):
2649
__doc__ = """Return revision-ids which affected a particular file.
2454
"""Return revision-ids which affected a particular file.
2650
2455
2651
2456
A more user-friendly interface is "bzr log FILE".
2652
2457
"""
2659
2464
tree, relpath = WorkingTree.open_containing(filename)
2660
2465
file_id = tree.path2id(relpath)
2661
2466
b = tree.branch
2662
self.add_cleanup(b.lock_read().unlock)
2663
touching_revs = log.find_touching_revisions(b, file_id)
2664
for revno, revision_id, what in touching_revs:
2665
self.outf.write("%6d %s\n" % (revno, what))
2467
b.lock_read()
2468
try:
2469
touching_revs = log.find_touching_revisions(b, file_id)
2470
for revno, revision_id, what in touching_revs:
2471
self.outf.write("%6d %s\n" % (revno, what))
2472
finally:
2473
b.unlock()
2666
2474
2667
2475
2668
2476
class cmd_ls(Command):
2669
__doc__ = """List files in a tree.
2477
"""List files in a tree.
2670
2478
"""
2671
2479
2672
2480
_see_also = ['status', 'cat']
2678
2486
help='Recurse into subdirectories.'),
2679
2487
Option('from-root',
2680
2488
help='Print paths relative to the root of the branch.'),
2681
Option('unknown', short_name='u',
2682
help='Print unknown files.'),
2489
Option('unknown', help='Print unknown files.'),
2683
2490
Option('versioned', help='Print versioned files.',
2684
2491
short_name='V'),
2685
Option('ignored', short_name='i',
2686
help='Print ignored files.'),
2687
Option('kind', short_name='k',
2492
Option('ignored', help='Print ignored files.'),
2493
Option('null',
2494
help='Write an ascii NUL (\\0) separator '
2495
'between files rather than a newline.'),
2496
Option('kind',
2688
2497
help='List entries of a particular kind: file, directory, symlink.',
2689
2498
type=unicode),
2690
'null',
2691
2499
'show-ids',
2692
'directory',
2693
2500
]
2694
2501
@display_command
2695
2502
def run(self, revision=None, verbose=False,
2696
2503
recursive=False, from_root=False,
2697
2504
unknown=False, versioned=False, ignored=False,
2698
null=False, kind=None, show_ids=False, path=None, directory=None):
2505
null=False, kind=None, show_ids=False, path=None):
2699
2506
2700
2507
if kind and kind not in ('file', 'directory', 'symlink'):
2701
2508
raise errors.BzrCommandError('invalid kind specified')
2713
2520
raise errors.BzrCommandError('cannot specify both --from-root'
2714
2521
' and PATH')
2715
2522
fs_path = path
2716
tree, branch, relpath = \
2717
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2523
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2524
fs_path)
2718
2525
2719
2526
# Calculate the prefix to use
2720
2527
prefix = None
2735
2542
view_str = views.view_display_str(view_files)
2736
2543
note("Ignoring files outside view. View is %s" % view_str)
2737
2544
2738
self.add_cleanup(tree.lock_read().unlock)
2739
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2740
from_dir=relpath, recursive=recursive):
2741
# Apply additional masking
2742
if not all and not selection[fc]:
2743
continue
2744
if kind is not None and fkind != kind:
2745
continue
2746
if apply_view:
2747
try:
2748
if relpath:
2749
fullpath = osutils.pathjoin(relpath, fp)
2750
else:
2751
fullpath = fp
2752
views.check_path_in_view(tree, fullpath)
2753
except errors.FileOutsideView:
2754
continue
2545
tree.lock_read()
2546
try:
2547
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2548
from_dir=relpath, recursive=recursive):
2549
# Apply additional masking
2550
if not all and not selection[fc]:
2551
continue
2552
if kind is not None and fkind != kind:
2553
continue
2554
if apply_view:
2555
try:
2556
if relpath:
2557
fullpath = osutils.pathjoin(relpath, fp)
2558
else:
2559
fullpath = fp
2560
views.check_path_in_view(tree, fullpath)
2561
except errors.FileOutsideView:
2562
continue
2755
2563
2756
# Output the entry
2757
if prefix:
2758
fp = osutils.pathjoin(prefix, fp)
2759
kindch = entry.kind_character()
2760
outstring = fp + kindch
2761
ui.ui_factory.clear_term()
2762
if verbose:
2763
outstring = '%-8s %s' % (fc, outstring)
2764
if show_ids and fid is not None:
2765
outstring = "%-50s %s" % (outstring, fid)
2766
self.outf.write(outstring + '\n')
2767
elif null:
2768
self.outf.write(fp + '\0')
2769
if show_ids:
2770
if fid is not None:
2771
self.outf.write(fid)
2772
self.outf.write('\0')
2773
self.outf.flush()
2774
else:
2775
if show_ids:
2776
if fid is not None:
2777
my_id = fid
2778
else:
2779
my_id = ''
2780
self.outf.write('%-50s %s\n' % (outstring, my_id))
2781
else:
2564
# Output the entry
2565
if prefix:
2566
fp = osutils.pathjoin(prefix, fp)
2567
kindch = entry.kind_character()
2568
outstring = fp + kindch
2569
ui.ui_factory.clear_term()
2570
if verbose:
2571
outstring = '%-8s %s' % (fc, outstring)
2572
if show_ids and fid is not None:
2573
outstring = "%-50s %s" % (outstring, fid)
2782
2574
self.outf.write(outstring + '\n')
2575
elif null:
2576
self.outf.write(fp + '\0')
2577
if show_ids:
2578
if fid is not None:
2579
self.outf.write(fid)
2580
self.outf.write('\0')
2581
self.outf.flush()
2582
else:
2583
if show_ids:
2584
if fid is not None:
2585
my_id = fid
2586
else:
2587
my_id = ''
2588
self.outf.write('%-50s %s\n' % (outstring, my_id))
2589
else:
2590
self.outf.write(outstring + '\n')
2591
finally:
2592
tree.unlock()
2783
2593
2784
2594
2785
2595
class cmd_unknowns(Command):
2786
__doc__ = """List unknown files.
2596
"""List unknown files.
2787
2597
"""
2788
2598
2789
2599
hidden = True
2790
2600
_see_also = ['ls']
2791
takes_options = ['directory']
2792
2601
2793
2602
@display_command
2794
def run(self, directory=u'.'):
2795
for f in WorkingTree.open_containing(directory)[0].unknowns():
2603
def run(self):
2604
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2796
2605
self.outf.write(osutils.quotefn(f) + '\n')
2797
2606
2798
2607
2799
2608
class cmd_ignore(Command):
2800
__doc__ = """Ignore specified files or patterns.
2609
"""Ignore specified files or patterns.
2801
2610
2802
2611
See ``bzr help patterns`` for details on the syntax of patterns.
2803
2612
2811
2620
After adding, editing or deleting that file either indirectly by
2812
2621
using this command or directly by using an editor, be sure to commit
2813
2622
it.
2814
2815
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2816
the global ignore file can be found in the application data directory as
2817
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2818
Global ignores are not touched by this command. The global ignore file
2819
can be edited directly using an editor.
2820
2821
Patterns prefixed with '!' are exceptions to ignore patterns and take
2822
precedence over regular ignores. Such exceptions are used to specify
2823
files that should be versioned which would otherwise be ignored.
2824
2825
Patterns prefixed with '!!' act as regular ignore patterns, but have
2826
precedence over the '!' exception patterns.
2827
2828
:Notes:
2829
2830
* Ignore patterns containing shell wildcards must be quoted from
2831
the shell on Unix.
2832
2833
* Ignore patterns starting with "#" act as comments in the ignore file.
2834
To ignore patterns that begin with that character, use the "RE:" prefix.
2623
2624
Note: ignore patterns containing shell wildcards must be quoted from
2625
the shell on Unix.
2835
2626
2836
2627
:Examples:
2837
2628
Ignore the top level Makefile::
2838
2629
2839
2630
bzr ignore ./Makefile
2840
2631
2841
Ignore .class files in all directories...::
2632
Ignore class files in all directories::
2842
2633
2843
2634
bzr ignore "*.class"
2844
2635
2845
...but do not ignore "special.class"::
2846
2847
bzr ignore "!special.class"
2848
2849
Ignore files whose name begins with the "#" character::
2850
2851
bzr ignore "RE:^#"
2852
2853
2636
Ignore .o files under the lib directory::
2854
2637
2855
2638
bzr ignore "lib/**/*.o"
2861
2644
Ignore everything but the "debian" toplevel directory::
2862
2645
2863
2646
bzr ignore "RE:(?!debian/).*"
2864
2865
Ignore everything except the "local" toplevel directory,
2866
but always ignore autosave files ending in ~, even under local/::
2867
2868
bzr ignore "*"
2869
bzr ignore "!./local"
2870
bzr ignore "!!*~"
2871
2647
"""
2872
2648
2873
2649
_see_also = ['status', 'ignored', 'patterns']
2874
2650
takes_args = ['name_pattern*']
2875
takes_options = ['directory',
2876
Option('default-rules',
2877
help='Display the default ignore rules that bzr uses.')
2651
takes_options = [
2652
Option('old-default-rules',
2653
help='Write out the ignore rules bzr < 0.9 always used.')
2878
2654
]
2879
2655
2880
def run(self, name_pattern_list=None, default_rules=None,
2881
directory=u'.'):
2656
def run(self, name_pattern_list=None, old_default_rules=None):
2882
2657
from bzrlib import ignores
2883
if default_rules is not None:
2884
# dump the default rules and exit
2885
for pattern in ignores.USER_DEFAULTS:
2886
self.outf.write("%s\n" % pattern)
2658
if old_default_rules is not None:
2659
# dump the rules and exit
2660
for pattern in ignores.OLD_DEFAULTS:
2661
print pattern
2887
2662
return
2888
2663
if not name_pattern_list:
2889
2664
raise errors.BzrCommandError("ignore requires at least one "
2890
"NAME_PATTERN or --default-rules.")
2665
"NAME_PATTERN or --old-default-rules")
2891
2666
name_pattern_list = [globbing.normalize_pattern(p)
2892
2667
for p in name_pattern_list]
2893
bad_patterns = ''
2894
for p in name_pattern_list:
2895
if not globbing.Globster.is_pattern_valid(p):
2896
bad_patterns += ('\n %s' % p)
2897
if bad_patterns:
2898
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2899
ui.ui_factory.show_error(msg)
2900
raise errors.InvalidPattern('')
2901
2668
for name_pattern in name_pattern_list:
2902
2669
if (name_pattern[0] == '/' or
2903
2670
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2904
2671
raise errors.BzrCommandError(
2905
2672
"NAME_PATTERN should not be an absolute path")
2906
tree, relpath = WorkingTree.open_containing(directory)
2673
tree, relpath = WorkingTree.open_containing(u'.')
2907
2674
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2908
2675
ignored = globbing.Globster(name_pattern_list)
2909
2676
matches = []
2910
self.add_cleanup(tree.lock_read().unlock)
2677
tree.lock_read()
2911
2678
for entry in tree.list_files():
2912
2679
id = entry[3]
2913
2680
if id is not None:
2914
2681
filename = entry[0]
2915
2682
if ignored.match(filename):
2916
matches.append(filename)
2683
matches.append(filename.encode('utf-8'))
2684
tree.unlock()
2917
2685
if len(matches) > 0:
2918
self.outf.write("Warning: the following files are version controlled and"
2919
" match your ignore pattern:\n%s"
2920
"\nThese files will continue to be version controlled"
2921
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2686
print "Warning: the following files are version controlled and" \
2687
" match your ignore pattern:\n%s" \
2688
"\nThese files will continue to be version controlled" \
2689
" unless you 'bzr remove' them." % ("\n".join(matches),)
2922
2690
2923
2691
2924
2692
class cmd_ignored(Command):
2925
__doc__ = """List ignored files and the patterns that matched them.
2693
"""List ignored files and the patterns that matched them.
2926
2694
2927
2695
List all the ignored files and the ignore pattern that caused the file to
2928
2696
be ignored.
2934
2702
2935
2703
encoding_type = 'replace'
2936
2704
_see_also = ['ignore', 'ls']
2937
takes_options = ['directory']
2938
2705
2939
2706
@display_command
2940
def run(self, directory=u'.'):
2941
tree = WorkingTree.open_containing(directory)[0]
2942
self.add_cleanup(tree.lock_read().unlock)
2943
for path, file_class, kind, file_id, entry in tree.list_files():
2944
if file_class != 'I':
2945
continue
2946
## XXX: Slightly inefficient since this was already calculated
2947
pat = tree.is_ignored(path)
2948
self.outf.write('%-50s %s\n' % (path, pat))
2707
def run(self):
2708
tree = WorkingTree.open_containing(u'.')[0]
2709
tree.lock_read()
2710
try:
2711
for path, file_class, kind, file_id, entry in tree.list_files():
2712
if file_class != 'I':
2713
continue
2714
## XXX: Slightly inefficient since this was already calculated
2715
pat = tree.is_ignored(path)
2716
self.outf.write('%-50s %s\n' % (path, pat))
2717
finally:
2718
tree.unlock()
2949
2719
2950
2720
2951
2721
class cmd_lookup_revision(Command):
2952
__doc__ = """Lookup the revision-id from a revision-number
2722
"""Lookup the revision-id from a revision-number
2953
2723
2954
2724
:Examples:
2955
2725
bzr lookup-revision 33
2956
2726
"""
2957
2727
hidden = True
2958
2728
takes_args = ['revno']
2959
takes_options = ['directory']
2960
2729
2961
2730
@display_command
2962
def run(self, revno, directory=u'.'):
2731
def run(self, revno):
2963
2732
try:
2964
2733
revno = int(revno)
2965
2734
except ValueError:
2966
raise errors.BzrCommandError("not a valid revision-number: %r"
2967
% revno)
2968
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2969
self.outf.write("%s\n" % revid)
2735
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2736
2737
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2970
2738
2971
2739
2972
2740
class cmd_export(Command):
2973
__doc__ = """Export current or past revision to a destination directory or archive.
2741
"""Export current or past revision to a destination directory or archive.
2974
2742
2975
2743
If no revision is specified this exports the last committed revision.
2976
2744
2997
2765
zip .zip
2998
2766
================= =========================
2999
2767
"""
3000
encoding = 'exact'
3001
2768
takes_args = ['dest', 'branch_or_subdir?']
3002
takes_options = ['directory',
2769
takes_options = [
3003
2770
Option('format',
3004
2771
help="Type of file to export to.",
3005
2772
type=unicode),
3009
2776
Option('root',
3010
2777
type=str,
3011
2778
help="Name of the root directory inside the exported file."),
3012
Option('per-file-timestamps',
3013
help='Set modification time of files to that of the last '
3014
'revision in which it was changed.'),
3015
2779
]
3016
2780
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
3017
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2781
root=None, filters=False):
3018
2782
from bzrlib.export import export
3019
2783
3020
2784
if branch_or_subdir is None:
3021
tree = WorkingTree.open_containing(directory)[0]
2785
tree = WorkingTree.open_containing(u'.')[0]
3022
2786
b = tree.branch
3023
2787
subdir = None
3024
2788
else:
3027
2791
3028
2792
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
3029
2793
try:
3030
export(rev_tree, dest, format, root, subdir, filtered=filters,
3031
per_file_timestamps=per_file_timestamps)
2794
export(rev_tree, dest, format, root, subdir, filtered=filters)
3032
2795
except errors.NoSuchExportFormat, e:
3033
2796
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3034
2797
3035
2798
3036
2799
class cmd_cat(Command):
3037
__doc__ = """Write the contents of a file as of a given revision to standard output.
2800
"""Write the contents of a file as of a given revision to standard output.
3038
2801
3039
2802
If no revision is nominated, the last revision is used.
3040
2803
3043
2806
"""
3044
2807
3045
2808
_see_also = ['ls']
3046
takes_options = ['directory',
2809
takes_options = [
3047
2810
Option('name-from-revision', help='The path name in the old tree.'),
3048
2811
Option('filters', help='Apply content filters to display the '
3049
2812
'convenience form.'),
3054
2817
3055
2818
@display_command
3056
2819
def run(self, filename, revision=None, name_from_revision=False,
3057
filters=False, directory=None):
2820
filters=False):
3058
2821
if revision is not None and len(revision) != 1:
3059
2822
raise errors.BzrCommandError("bzr cat --revision takes exactly"
3060
2823
" one revision specifier")
3061
2824
tree, branch, relpath = \
3062
_open_directory_or_containing_tree_or_branch(filename, directory)
3063
self.add_cleanup(branch.lock_read().unlock)
3064
return self._run(tree, branch, relpath, filename, revision,
3065
name_from_revision, filters)
2825
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2826
branch.lock_read()
2827
try:
2828
return self._run(tree, branch, relpath, filename, revision,
2829
name_from_revision, filters)
2830
finally:
2831
branch.unlock()
3066
2832
3067
2833
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
3068
2834
filtered):
3069
2835
if tree is None:
3070
2836
tree = b.basis_tree()
3071
2837
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
3072
self.add_cleanup(rev_tree.lock_read().unlock)
3073
2838
3074
2839
old_file_id = rev_tree.path2id(relpath)
3075
2840
3076
# TODO: Split out this code to something that generically finds the
3077
# best id for a path across one or more trees; it's like
3078
# find_ids_across_trees but restricted to find just one. -- mbp
3079
# 20110705.
3080
2841
if name_from_revision:
3081
2842
# Try in revision if requested
3082
2843
if old_file_id is None:
3084
2845
"%r is not present in revision %s" % (
3085
2846
filename, rev_tree.get_revision_id()))
3086
2847
else:
3087
actual_file_id = old_file_id
2848
content = rev_tree.get_file_text(old_file_id)
3088
2849
else:
3089
2850
cur_file_id = tree.path2id(relpath)
3090
if cur_file_id is not None and rev_tree.has_id(cur_file_id):
3091
actual_file_id = cur_file_id
3092
elif old_file_id is not None:
3093
actual_file_id = old_file_id
3094
else:
2851
found = False
2852
if cur_file_id is not None:
2853
# Then try with the actual file id
2854
try:
2855
content = rev_tree.get_file_text(cur_file_id)
2856
found = True
2857
except errors.NoSuchId:
2858
# The actual file id didn't exist at that time
2859
pass
2860
if not found and old_file_id is not None:
2861
# Finally try with the old file id
2862
content = rev_tree.get_file_text(old_file_id)
2863
found = True
2864
if not found:
2865
# Can't be found anywhere
3095
2866
raise errors.BzrCommandError(
3096
2867
"%r is not present in revision %s" % (
3097
2868
filename, rev_tree.get_revision_id()))
3098
2869
if filtered:
3099
from bzrlib.filter_tree import ContentFilterTree
3100
filter_tree = ContentFilterTree(rev_tree,
3101
rev_tree._content_filter_stack)
3102
content = filter_tree.get_file_text(actual_file_id)
2870
from bzrlib.filters import (
2871
ContentFilterContext,
2872
filtered_output_bytes,
2873
)
2874
filters = rev_tree._content_filter_stack(relpath)
2875
chunks = content.splitlines(True)
2876
content = filtered_output_bytes(chunks, filters,
2877
ContentFilterContext(relpath, rev_tree))
2878
self.outf.writelines(content)
3103
2879
else:
3104
content = rev_tree.get_file_text(actual_file_id)
3105
self.cleanup_now()
3106
self.outf.write(content)
2880
self.outf.write(content)
3107
2881
3108
2882
3109
2883
class cmd_local_time_offset(Command):
3110
__doc__ = """Show the offset in seconds from GMT to local time."""
2884
"""Show the offset in seconds from GMT to local time."""
3111
2885
hidden = True
3112
2886
@display_command
3113
2887
def run(self):
3114
self.outf.write("%s\n" % osutils.local_time_offset())
2888
print osutils.local_time_offset()
3115
2889
3116
2890
3117
2891
3118
2892
class cmd_commit(Command):
3119
__doc__ = """Commit changes into a new revision.
2893
"""Commit changes into a new revision.
3120
2894
3121
2895
An explanatory message needs to be given for each commit. This is
3122
2896
often done by using the --message option (getting the message from the
3170
2944
to trigger updates to external systems like bug trackers. The --fixes
3171
2945
option can be used to record the association between a revision and
3172
2946
one or more bugs. See ``bzr help bugs`` for details.
2947
2948
A selective commit may fail in some cases where the committed
2949
tree would be invalid. Consider::
2950
2951
bzr init foo
2952
mkdir foo/bar
2953
bzr add foo/bar
2954
bzr commit foo -m "committing foo"
2955
bzr mv foo/bar foo/baz
2956
mkdir foo/bar
2957
bzr add foo/bar
2958
bzr commit foo/bar -m "committing bar but not baz"
2959
2960
In the example above, the last commit will fail by design. This gives
2961
the user the opportunity to decide whether they want to commit the
2962
rename at the same time, separately first, or not at all. (As a general
2963
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3173
2964
"""
2965
# TODO: Run hooks on tree to-be-committed, and after commit.
2966
2967
# TODO: Strict commit that fails if there are deleted files.
2968
# (what does "deleted files" mean ??)
2969
2970
# TODO: Give better message for -s, --summary, used by tla people
2971
2972
# XXX: verbose currently does nothing
3174
2973
3175
2974
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
3176
2975
takes_args = ['selected*']
3205
3004
"the master branch until a normal commit "
3206
3005
"is performed."
3207
3006
),
3208
Option('show-diff', short_name='p',
3007
Option('show-diff',
3209
3008
help='When no message is supplied, show the diff along'
3210
3009
' with the status summary in the message editor.'),
3211
Option('lossy',
3212
help='When committing to a foreign version control '
3213
'system do not push data that can not be natively '
3214
'represented.'),
3215
3010
]
3216
3011
aliases = ['ci', 'checkin']
3217
3012
3236
3031
3237
3032
def run(self, message=None, file=None, verbose=False, selected_list=None,
3238
3033
unchanged=False, strict=False, local=False, fixes=None,
3239
author=None, show_diff=False, exclude=None, commit_time=None,
3240
lossy=False):
3034
author=None, show_diff=False, exclude=None, commit_time=None):
3241
3035
from bzrlib.errors import (
3242
3036
PointlessCommit,
3243
3037
ConflictsInTree,
3246
3040
from bzrlib.msgeditor import (
3247
3041
edit_commit_message_encoded,
3248
3042
generate_commit_message_template,
3249
make_commit_message_template_encoded,
3250
set_commit_message,
3043
make_commit_message_template_encoded
3251
3044
)
3252
3045
3253
3046
commit_stamp = offset = None
3258
3051
raise errors.BzrCommandError(
3259
3052
"Could not parse --commit-time: " + str(e))
3260
3053
3054
# TODO: Need a blackbox test for invoking the external editor; may be
3055
# slightly problematic to run this cross-platform.
3056
3057
# TODO: do more checks that the commit will succeed before
3058
# spending the user's valuable time typing a commit message.
3059
3261
3060
properties = {}
3262
3061
3263
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3062
tree, selected_list = tree_files(selected_list)
3264
3063
if selected_list == ['']:
3265
3064
# workaround - commit of root of tree should be exactly the same
3266
3065
# as just default commit in that tree, and succeed even though
3291
3090
'(use --file "%(f)s" to take commit message from that file)'
3292
3091
% { 'f': message })
3293
3092
ui.ui_factory.show_warning(warning_msg)
3294
if '\r' in message:
3295
message = message.replace('\r\n', '\n')
3296
message = message.replace('\r', '\n')
3297
if file:
3298
raise errors.BzrCommandError(
3299
"please specify either --message or --file")
3300
3093
3301
3094
def get_message(commit_obj):
3302
3095
"""Callback to get commit message"""
3303
if file:
3304
f = open(file)
3305
try:
3306
my_message = f.read().decode(osutils.get_user_encoding())
3307
finally:
3308
f.close()
3309
elif message is not None:
3310
my_message = message
3311
else:
3312
# No message supplied: make one up.
3313
# text is the status of the tree
3314
text = make_commit_message_template_encoded(tree,
3096
my_message = message
3097
if my_message is not None and '\r' in my_message:
3098
my_message = my_message.replace('\r\n', '\n')
3099
my_message = my_message.replace('\r', '\n')
3100
if my_message is None and not file:
3101
t = make_commit_message_template_encoded(tree,
3315
3102
selected_list, diff=show_diff,
3316
3103
output_encoding=osutils.get_user_encoding())
3317
# start_message is the template generated from hooks
3318
# XXX: Warning - looks like hooks return unicode,
3319
# make_commit_message_template_encoded returns user encoding.
3320
# We probably want to be using edit_commit_message instead to
3321
# avoid this.
3322
my_message = set_commit_message(commit_obj)
3323
if my_message is None:
3324
start_message = generate_commit_message_template(commit_obj)
3325
my_message = edit_commit_message_encoded(text,
3326
start_message=start_message)
3104
start_message = generate_commit_message_template(commit_obj)
3105
my_message = edit_commit_message_encoded(t,
3106
start_message=start_message)
3327
3107
if my_message is None:
3328
3108
raise errors.BzrCommandError("please specify a commit"
3329
3109
" message with either --message or --file")
3110
elif my_message and file:
3111
raise errors.BzrCommandError(
3112
"please specify either --message or --file")
3113
if file:
3114
my_message = codecs.open(file, 'rt',
3115
osutils.get_user_encoding()).read()
3330
3116
if my_message == "":
3331
raise errors.BzrCommandError("Empty commit message specified."
3332
" Please specify a commit message with either"
3333
" --message or --file or leave a blank message"
3334
" with --message \"\".")
3117
raise errors.BzrCommandError("empty commit message specified")
3335
3118
return my_message
3336
3119
3337
3120
# The API permits a commit with a filter of [] to mean 'select nothing'
3345
3128
reporter=None, verbose=verbose, revprops=properties,
3346
3129
authors=author, timestamp=commit_stamp,
3347
3130
timezone=offset,
3348
exclude=tree.safe_relpath_files(exclude),
3349
lossy=lossy)
3131
exclude=safe_relpath_files(tree, exclude))
3350
3132
except PointlessCommit:
3133
# FIXME: This should really happen before the file is read in;
3134
# perhaps prepare the commit; get the message; then actually commit
3351
3135
raise errors.BzrCommandError("No changes to commit."
3352
" Please 'bzr add' the files you want to commit, or use"
3353
" --unchanged to force an empty commit.")
3136
" Use --unchanged to commit anyhow.")
3354
3137
except ConflictsInTree:
3355
3138
raise errors.BzrCommandError('Conflicts detected in working '
3356
3139
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3359
3142
raise errors.BzrCommandError("Commit refused because there are"
3360
3143
" unknown files in the working tree.")
3361
3144
except errors.BoundBranchOutOfDate, e:
3362
e.extra_help = ("\n"
3363
'To commit to master branch, run update and then commit.\n'
3364
'You can also pass --local to commit to continue working '
3365
'disconnected.')
3366
raise
3145
raise errors.BzrCommandError(str(e) + "\n"
3146
'To commit to master branch, run update and then commit.\n'
3147
'You can also pass --local to commit to continue working '
3148
'disconnected.')
3367
3149
3368
3150
3369
3151
class cmd_check(Command):
3370
__doc__ = """Validate working tree structure, branch consistency and repository history.
3152
"""Validate working tree structure, branch consistency and repository history.
3371
3153
3372
3154
This command checks various invariants about branch and repository storage
3373
3155
to detect data corruption or bzr bugs.
3437
3219
3438
3220
3439
3221
class cmd_upgrade(Command):
3440
__doc__ = """Upgrade a repository, branch or working tree to a newer format.
3441
3442
When the default format has changed after a major new release of
3443
Bazaar, you may be informed during certain operations that you
3444
should upgrade. Upgrading to a newer format may improve performance
3445
or make new features available. It may however limit interoperability
3446
with older repositories or with older versions of Bazaar.
3447
3448
If you wish to upgrade to a particular format rather than the
3449
current default, that can be specified using the --format option.
3450
As a consequence, you can use the upgrade command this way to
3451
"downgrade" to an earlier format, though some conversions are
3452
a one way process (e.g. changing from the 1.x default to the
3453
2.x default) so downgrading is not always possible.
3454
3455
A backup.bzr.~#~ directory is created at the start of the conversion
3456
process (where # is a number). By default, this is left there on
3457
completion. If the conversion fails, delete the new .bzr directory
3458
and rename this one back in its place. Use the --clean option to ask
3459
for the backup.bzr directory to be removed on successful conversion.
3460
Alternatively, you can delete it by hand if everything looks good
3461
afterwards.
3462
3463
If the location given is a shared repository, dependent branches
3464
are also converted provided the repository converts successfully.
3465
If the conversion of a branch fails, remaining branches are still
3466
tried.
3467
3468
For more information on upgrades, see the Bazaar Upgrade Guide,
3469
http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3222
"""Upgrade branch storage to current format.
3223
3224
The check command or bzr developers may sometimes advise you to run
3225
this command. When the default format has changed you may also be warned
3226
during other operations to upgrade.
3470
3227
"""
3471
3228
3472
_see_also = ['check', 'reconcile', 'formats']
3229
_see_also = ['check']
3473
3230
takes_args = ['url?']
3474
3231
takes_options = [
3475
RegistryOption('format',
3476
help='Upgrade to a specific format. See "bzr help'
3477
' formats" for details.',
3478
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3479
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3480
value_switches=True, title='Branch format'),
3481
Option('clean',
3482
help='Remove the backup.bzr directory if successful.'),
3483
Option('dry-run',
3484
help="Show what would be done, but don't actually do anything."),
3485
]
3232
RegistryOption('format',
3233
help='Upgrade to a specific format. See "bzr help'
3234
' formats" for details.',
3235
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3236
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3237
value_switches=True, title='Branch format'),
3238
]
3486
3239
3487
def run(self, url='.', format=None, clean=False, dry_run=False):
3240
def run(self, url='.', format=None):
3488
3241
from bzrlib.upgrade import upgrade
3489
exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3490
if exceptions:
3491
if len(exceptions) == 1:
3492
# Compatibility with historical behavior
3493
raise exceptions[0]
3494
else:
3495
return 3
3242
upgrade(url, format)
3496
3243
3497
3244
3498
3245
class cmd_whoami(Command):
3499
__doc__ = """Show or set bzr user id.
3246
"""Show or set bzr user id.
3500
3247
3501
3248
:Examples:
3502
3249
Show the email of the current user::
3507
3254
3508
3255
bzr whoami "Frank Chu <fchu@example.com>"
3509
3256
"""
3510
takes_options = [ 'directory',
3511
Option('email',
3257
takes_options = [ Option('email',
3512
3258
help='Display email address only.'),
3513
3259
Option('branch',
3514
3260
help='Set identity for the current branch instead of '
3518
3264
encoding_type = 'replace'
3519
3265
3520
3266
@display_command
3521
def run(self, email=False, branch=False, name=None, directory=None):
3267
def run(self, email=False, branch=False, name=None):
3522
3268
if name is None:
3523
if directory is None:
3524
# use branch if we're inside one; otherwise global config
3525
try:
3526
c = Branch.open_containing(u'.')[0].get_config()
3527
except errors.NotBranchError:
3528
c = _mod_config.GlobalConfig()
3529
else:
3530
c = Branch.open(directory).get_config()
3269
# use branch if we're inside one; otherwise global config
3270
try:
3271
c = Branch.open_containing('.')[0].get_config()
3272
except errors.NotBranchError:
3273
c = config.GlobalConfig()
3531
3274
if email:
3532
3275
self.outf.write(c.user_email() + '\n')
3533
3276
else:
3534
3277
self.outf.write(c.username() + '\n')
3535
3278
return
3536
3279
3537
if email:
3538
raise errors.BzrCommandError("--email can only be used to display existing "
3539
"identity")
3540
3541
3280
# display a warning if an email address isn't included in the given name.
3542
3281
try:
3543
_mod_config.extract_email_address(name)
3282
config.extract_email_address(name)
3544
3283
except errors.NoEmailInUsername, e:
3545
3284
warning('"%s" does not seem to contain an email address. '
3546
3285
'This is allowed, but not recommended.', name)
3547
3286
3548
3287
# use global config unless --branch given
3549
3288
if branch:
3550
if directory is None:
3551
c = Branch.open_containing(u'.')[0].get_config()
3552
else:
3553
c = Branch.open(directory).get_config()
3289
c = Branch.open_containing('.')[0].get_config()
3554
3290
else:
3555
c = _mod_config.GlobalConfig()
3291
c = config.GlobalConfig()
3556
3292
c.set_user_option('email', name)
3557
3293
3558
3294
3559
3295
class cmd_nick(Command):
3560
__doc__ = """Print or set the branch nickname.
3296
"""Print or set the branch nickname.
3561
3297
3562
3298
If unset, the tree root directory name is used as the nickname.
3563
3299
To print the current nickname, execute with no argument.
3568
3304
3569
3305
_see_also = ['info']
3570
3306
takes_args = ['nickname?']
3571
takes_options = ['directory']
3572
def run(self, nickname=None, directory=u'.'):
3573
branch = Branch.open_containing(directory)[0]
3307
def run(self, nickname=None):
3308
branch = Branch.open_containing(u'.')[0]
3574
3309
if nickname is None:
3575
3310
self.printme(branch)
3576
3311
else:
3578
3313
3579
3314
@display_command
3580
3315
def printme(self, branch):
3581
self.outf.write('%s\n' % branch.nick)
3316
print branch.nick
3582
3317
3583
3318
3584
3319
class cmd_alias(Command):
3585
__doc__ = """Set/unset and display aliases.
3320
"""Set/unset and display aliases.
3586
3321
3587
3322
:Examples:
3588
3323
Show the current aliases::
3625
3360
'bzr alias --remove expects an alias to remove.')
3626
3361
# If alias is not found, print something like:
3627
3362
# unalias: foo: not found
3628
c = _mod_config.GlobalConfig()
3363
c = config.GlobalConfig()
3629
3364
c.unset_alias(alias_name)
3630
3365
3631
3366
@display_command
3632
3367
def print_aliases(self):
3633
3368
"""Print out the defined aliases in a similar format to bash."""
3634
aliases = _mod_config.GlobalConfig().get_aliases()
3369
aliases = config.GlobalConfig().get_aliases()
3635
3370
for key, value in sorted(aliases.iteritems()):
3636
3371
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3637
3372
3647
3382
3648
3383
def set_alias(self, alias_name, alias_command):
3649
3384
"""Save the alias in the global config."""
3650
c = _mod_config.GlobalConfig()
3385
c = config.GlobalConfig()
3651
3386
c.set_alias(alias_name, alias_command)
3652
3387
3653
3388
3654
3389
class cmd_selftest(Command):
3655
__doc__ = """Run internal test suite.
3390
"""Run internal test suite.
3656
3391
3657
3392
If arguments are given, they are regular expressions that say which tests
3658
3393
should run. Tests matching any expression are run, and other tests are
3688
3423
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3689
3424
into a pdb postmortem session.
3690
3425
3691
The --coverage=DIRNAME global option produces a report with covered code
3692
indicated.
3693
3694
3426
:Examples:
3695
3427
Run only tests relating to 'ignore'::
3696
3428
3705
3437
def get_transport_type(typestring):
3706
3438
"""Parse and return a transport specifier."""
3707
3439
if typestring == "sftp":
3708
from bzrlib.tests import stub_sftp
3709
return stub_sftp.SFTPAbsoluteServer
3710
elif typestring == "memory":
3711
from bzrlib.tests import test_server
3712
return memory.MemoryServer
3713
elif typestring == "fakenfs":
3714
from bzrlib.tests import test_server
3715
return test_server.FakeNFSServer
3440
from bzrlib.transport.sftp import SFTPAbsoluteServer
3441
return SFTPAbsoluteServer
3442
if typestring == "memory":
3443
from bzrlib.transport.memory import MemoryServer
3444
return MemoryServer
3445
if typestring == "fakenfs":
3446
from bzrlib.transport.fakenfs import FakeNFSServer
3447
return FakeNFSServer
3716
3448
msg = "No known transport type %s. Supported types are: sftp\n" %\
3717
3449
(typestring)
3718
3450
raise errors.BzrCommandError(msg)
3729
3461
'throughout the test suite.',
3730
3462
type=get_transport_type),
3731
3463
Option('benchmark',
3732
help='Run the benchmarks rather than selftests.',
3733
hidden=True),
3464
help='Run the benchmarks rather than selftests.'),
3734
3465
Option('lsprof-timed',
3735
3466
help='Generate lsprof output for benchmarked'
3736
3467
' sections of code.'),
3737
3468
Option('lsprof-tests',
3738
3469
help='Generate lsprof output for each test.'),
3470
Option('cache-dir', type=str,
3471
help='Cache intermediate benchmark output in this '
3472
'directory.'),
3739
3473
Option('first',
3740
3474
help='Run all tests, but run specified tests first.',
3741
3475
short_name='f',
3750
3484
Option('randomize', type=str, argname="SEED",
3751
3485
help='Randomize the order of tests using the given'
3752
3486
' seed or "now" for the current time.'),
3753
ListOption('exclude', type=str, argname="PATTERN",
3754
short_name='x',
3755
help='Exclude tests that match this regular'
3756
' expression.'),
3487
Option('exclude', type=str, argname="PATTERN",
3488
short_name='x',
3489
help='Exclude tests that match this regular'
3490
' expression.'),
3757
3491
Option('subunit',
3758
3492
help='Output test progress via subunit.'),
3759
3493
Option('strict', help='Fail on missing dependencies or '
3775
3509
3776
3510
def run(self, testspecs_list=None, verbose=False, one=False,
3777
3511
transport=None, benchmark=None,
3778
lsprof_timed=None,
3512
lsprof_timed=None, cache_dir=None,
3779
3513
first=False, list_only=False,
3780
3514
randomize=None, exclude=None, strict=False,
3781
3515
load_list=None, debugflag=None, starting_with=None, subunit=False,
3782
3516
parallel=None, lsprof_tests=False):
3783
from bzrlib import tests
3784
3517
from bzrlib.tests import selftest
3518
import bzrlib.benchmarks as benchmarks
3519
from bzrlib.benchmarks import tree_creator
3520
3521
# Make deprecation warnings visible, unless -Werror is set
3522
symbol_versioning.activate_deprecation_warnings(override=False)
3523
3524
if cache_dir is not None:
3525
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3785
3526
if testspecs_list is not None:
3786
3527
pattern = '|'.join(testspecs_list)
3787
3528
else:
3793
3534
raise errors.BzrCommandError("subunit not available. subunit "
3794
3535
"needs to be installed to use --subunit.")
3795
3536
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3796
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3797
# stdout, which would corrupt the subunit stream.
3798
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3799
# following code can be deleted when it's sufficiently deployed
3800
# -- vila/mgz 20100514
3801
if (sys.platform == "win32"
3802
and getattr(sys.stdout, 'fileno', None) is not None):
3803
import msvcrt
3804
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3805
3537
if parallel:
3806
3538
self.additional_selftest_args.setdefault(
3807
3539
'suite_decorators', []).append(parallel)
3808
3540
if benchmark:
3809
raise errors.BzrCommandError(
3810
"--benchmark is no longer supported from bzr 2.2; "
3811
"use bzr-usertest instead")
3812
test_suite_factory = None
3813
if not exclude:
3814
exclude_pattern = None
3541
test_suite_factory = benchmarks.test_suite
3542
# Unless user explicitly asks for quiet, be verbose in benchmarks
3543
verbose = not is_quiet()
3544
# TODO: should possibly lock the history file...
3545
benchfile = open(".perf_history", "at", buffering=1)
3815
3546
else:
3816
exclude_pattern = '(' + '|'.join(exclude) + ')'
3817
selftest_kwargs = {"verbose": verbose,
3818
"pattern": pattern,
3819
"stop_on_failure": one,
3820
"transport": transport,
3821
"test_suite_factory": test_suite_factory,
3822
"lsprof_timed": lsprof_timed,
3823
"lsprof_tests": lsprof_tests,
3824
"matching_tests_first": first,
3825
"list_only": list_only,
3826
"random_seed": randomize,
3827
"exclude_pattern": exclude_pattern,
3828
"strict": strict,
3829
"load_list": load_list,
3830
"debug_flags": debugflag,
3831
"starting_with": starting_with
3832
}
3833
selftest_kwargs.update(self.additional_selftest_args)
3834
3835
# Make deprecation warnings visible, unless -Werror is set
3836
cleanup = symbol_versioning.activate_deprecation_warnings(
3837
override=False)
3547
test_suite_factory = None
3548
benchfile = None
3838
3549
try:
3839
result = tests.selftest(**selftest_kwargs)
3550
selftest_kwargs = {"verbose": verbose,
3551
"pattern": pattern,
3552
"stop_on_failure": one,
3553
"transport": transport,
3554
"test_suite_factory": test_suite_factory,
3555
"lsprof_timed": lsprof_timed,
3556
"lsprof_tests": lsprof_tests,
3557
"bench_history": benchfile,
3558
"matching_tests_first": first,
3559
"list_only": list_only,
3560
"random_seed": randomize,
3561
"exclude_pattern": exclude,
3562
"strict": strict,
3563
"load_list": load_list,
3564
"debug_flags": debugflag,
3565
"starting_with": starting_with
3566
}
3567
selftest_kwargs.update(self.additional_selftest_args)
3568
result = selftest(**selftest_kwargs)
3840
3569
finally:
3841
cleanup()
3570
if benchfile is not None:
3571
benchfile.close()
3842
3572
return int(not result)
3843
3573
3844
3574
3845
3575
class cmd_version(Command):
3846
__doc__ = """Show version of bzr."""
3576
"""Show version of bzr."""
3847
3577
3848
3578
encoding_type = 'replace'
3849
3579
takes_options = [
3860
3590
3861
3591
3862
3592
class cmd_rocks(Command):
3863
__doc__ = """Statement of optimism."""
3593
"""Statement of optimism."""
3864
3594
3865
3595
hidden = True
3866
3596
3867
3597
@display_command
3868
3598
def run(self):
3869
self.outf.write("It sure does!\n")
3599
print "It sure does!"
3870
3600
3871
3601
3872
3602
class cmd_find_merge_base(Command):
3873
__doc__ = """Find and print a base revision for merging two branches."""
3603
"""Find and print a base revision for merging two branches."""
3874
3604
# TODO: Options to specify revisions on either side, as if
3875
3605
# merging only part of the history.
3876
3606
takes_args = ['branch', 'other']
3882
3612
3883
3613
branch1 = Branch.open_containing(branch)[0]
3884
3614
branch2 = Branch.open_containing(other)[0]
3885
self.add_cleanup(branch1.lock_read().unlock)
3886
self.add_cleanup(branch2.lock_read().unlock)
3887
last1 = ensure_null(branch1.last_revision())
3888
last2 = ensure_null(branch2.last_revision())
3889
3890
graph = branch1.repository.get_graph(branch2.repository)
3891
base_rev_id = graph.find_unique_lca(last1, last2)
3892
3893
self.outf.write('merge base is revision %s\n' % base_rev_id)
3615
branch1.lock_read()
3616
try:
3617
branch2.lock_read()
3618
try:
3619
last1 = ensure_null(branch1.last_revision())
3620
last2 = ensure_null(branch2.last_revision())
3621
3622
graph = branch1.repository.get_graph(branch2.repository)
3623
base_rev_id = graph.find_unique_lca(last1, last2)
3624
3625
print 'merge base is revision %s' % base_rev_id
3626
finally:
3627
branch2.unlock()
3628
finally:
3629
branch1.unlock()
3894
3630
3895
3631
3896
3632
class cmd_merge(Command):
3897
__doc__ = """Perform a three-way merge.
3633
"""Perform a three-way merge.
3898
3634
3899
3635
The source of the merge can be specified either in the form of a branch,
3900
3636
or in the form of a path to a file containing a merge directive generated
3901
3637
with bzr send. If neither is specified, the default is the upstream branch
3902
or the branch most recently merged using --remember. The source of the
3903
merge may also be specified in the form of a path to a file in another
3904
branch: in this case, only the modifications to that file are merged into
3905
the current working tree.
3906
3907
When merging from a branch, by default bzr will try to merge in all new
3908
work from the other branch, automatically determining an appropriate base
3909
revision. If this fails, you may need to give an explicit base.
3910
3911
To pick a different ending revision, pass "--revision OTHER". bzr will
3912
try to merge in all new work up to and including revision OTHER.
3913
3914
If you specify two values, "--revision BASE..OTHER", only revisions BASE
3915
through OTHER, excluding BASE but including OTHER, will be merged. If this
3916
causes some revisions to be skipped, i.e. if the destination branch does
3917
not already contain revision BASE, such a merge is commonly referred to as
3918
a "cherrypick". Unlike a normal merge, Bazaar does not currently track
3919
cherrypicks. The changes look like a normal commit, and the history of the
3920
changes from the other branch is not stored in the commit.
3921
3922
Revision numbers are always relative to the source branch.
3638
or the branch most recently merged using --remember.
3639
3640
When merging a branch, by default the tip will be merged. To pick a different
3641
revision, pass --revision. If you specify two values, the first will be used as
3642
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3643
available revisions, like this is commonly referred to as "cherrypicking".
3644
3645
Revision numbers are always relative to the branch being merged.
3646
3647
By default, bzr will try to merge in all new work from the other
3648
branch, automatically determining an appropriate base. If this
3649
fails, you may need to give an explicit base.
3923
3650
3924
3651
Merge will do its best to combine the changes in two branches, but there
3925
3652
are some kinds of problems only a human can fix. When it encounters those,
3928
3655
3929
3656
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3930
3657
3931
If there is no default branch set, the first merge will set it (use
3932
--no-remember to avoid settting it). After that, you can omit the branch
3933
to use the default. To change the default, use --remember. The value will
3934
only be saved if the remote location can be accessed.
3658
If there is no default branch set, the first merge will set it. After
3659
that, you can omit the branch to use the default. To change the
3660
default, use --remember. The value will only be saved if the remote
3661
location can be accessed.
3935
3662
3936
3663
The results of the merge are placed into the destination working
3937
3664
directory, where they can be reviewed (with bzr diff), tested, and then
3938
3665
committed to record the result of the merge.
3939
3666
3940
3667
merge refuses to run if there are any uncommitted changes, unless
3941
--force is given. If --force is given, then the changes from the source
3942
will be merged with the current working tree, including any uncommitted
3943
changes in the tree. The --force option can also be used to create a
3944
merge revision which has more than two parents.
3945
3946
If one would like to merge changes from the working tree of the other
3947
branch without merging any committed revisions, the --uncommitted option
3948
can be given.
3668
--force is given.
3949
3669
3950
3670
To select only some changes to merge, use "merge -i", which will prompt
3951
3671
you to apply each diff hunk and file change, similar to "shelve".
3952
3672
3953
3673
:Examples:
3954
To merge all new revisions from bzr.dev::
3674
To merge the latest revision from bzr.dev::
3955
3675
3956
3676
bzr merge ../bzr.dev
3957
3677
3966
3686
To apply a merge directive contained in /tmp/merge::
3967
3687
3968
3688
bzr merge /tmp/merge
3969
3970
To create a merge revision with three parents from two branches
3971
feature1a and feature1b:
3972
3973
bzr merge ../feature1a
3974
bzr merge ../feature1b --force
3975
bzr commit -m 'revision with three parents'
3976
3689
"""
3977
3690
3978
3691
encoding_type = 'exact'
3994
3707
' completely merged into the source, pull from the'
3995
3708
' source rather than merging. When this happens,'
3996
3709
' you do not need to commit the result.'),
3997
custom_help('directory',
3710
Option('directory',
3998
3711
help='Branch to merge into, '
3999
'rather than the one containing the working directory.'),
3712
'rather than the one containing the working directory.',
3713
short_name='d',
3714
type=unicode,
3715
),
4000
3716
Option('preview', help='Instead of merging, show a diff of the'
4001
3717
' merge.'),
4002
3718
Option('interactive', help='Select changes interactively.',
4004
3720
]
4005
3721
4006
3722
def run(self, location=None, revision=None, force=False,
4007
merge_type=None, show_base=False, reprocess=None, remember=None,
3723
merge_type=None, show_base=False, reprocess=None, remember=False,
4008
3724
uncommitted=False, pull=False,
4009
3725
directory=None,
4010
3726
preview=False,
4018
3734
merger = None
4019
3735
allow_pending = True
4020
3736
verified = 'inapplicable'
4021
4022
3737
tree = WorkingTree.open_containing(directory)[0]
4023
if tree.branch.revno() == 0:
4024
raise errors.BzrCommandError('Merging into empty branches not currently supported, '
4025
'https://bugs.launchpad.net/bzr/+bug/308562')
4026
3738
4027
3739
try:
4028
3740
basis_tree = tree.revision_tree(tree.last_revision())
4037
3749
view_info = _get_view_info_for_change_reporter(tree)
4038
3750
change_reporter = delta._ChangeReporter(
4039
3751
unversioned_filter=tree.is_ignored, view_info=view_info)
4040
pb = ui.ui_factory.nested_progress_bar()
4041
self.add_cleanup(pb.finished)
4042
self.add_cleanup(tree.lock_write().unlock)
4043
if location is not None:
4044
try:
4045
mergeable = bundle.read_mergeable_from_url(location,
4046
possible_transports=possible_transports)
4047
except errors.NotABundle:
4048
mergeable = None
3752
cleanups = []
3753
try:
3754
pb = ui.ui_factory.nested_progress_bar()
3755
cleanups.append(pb.finished)
3756
tree.lock_write()
3757
cleanups.append(tree.unlock)
3758
if location is not None:
3759
try:
3760
mergeable = bundle.read_mergeable_from_url(location,
3761
possible_transports=possible_transports)
3762
except errors.NotABundle:
3763
mergeable = None
3764
else:
3765
if uncommitted:
3766
raise errors.BzrCommandError('Cannot use --uncommitted'
3767
' with bundles or merge directives.')
3768
3769
if revision is not None:
3770
raise errors.BzrCommandError(
3771
'Cannot use -r with merge directives or bundles')
3772
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3773
mergeable, pb)
3774
3775
if merger is None and uncommitted:
3776
if revision is not None and len(revision) > 0:
3777
raise errors.BzrCommandError('Cannot use --uncommitted and'
3778
' --revision at the same time.')
3779
merger = self.get_merger_from_uncommitted(tree, location, pb,
3780
cleanups)
3781
allow_pending = False
3782
3783
if merger is None:
3784
merger, allow_pending = self._get_merger_from_branch(tree,
3785
location, revision, remember, possible_transports, pb)
3786
3787
merger.merge_type = merge_type
3788
merger.reprocess = reprocess
3789
merger.show_base = show_base
3790
self.sanity_check_merger(merger)
3791
if (merger.base_rev_id == merger.other_rev_id and
3792
merger.other_rev_id is not None):
3793
note('Nothing to do.')
3794
return 0
3795
if pull:
3796
if merger.interesting_files is not None:
3797
raise errors.BzrCommandError('Cannot pull individual files')
3798
if (merger.base_rev_id == tree.last_revision()):
3799
result = tree.pull(merger.other_branch, False,
3800
merger.other_rev_id)
3801
result.report(self.outf)
3802
return 0
3803
if merger.this_basis is None:
3804
raise errors.BzrCommandError(
3805
"This branch has no commits."
3806
" (perhaps you would prefer 'bzr pull')")
3807
if preview:
3808
return self._do_preview(merger, cleanups)
3809
elif interactive:
3810
return self._do_interactive(merger, cleanups)
4049
3811
else:
4050
if uncommitted:
4051
raise errors.BzrCommandError('Cannot use --uncommitted'
4052
' with bundles or merge directives.')
4053
4054
if revision is not None:
4055
raise errors.BzrCommandError(
4056
'Cannot use -r with merge directives or bundles')
4057
merger, verified = _mod_merge.Merger.from_mergeable(tree,
4058
mergeable, None)
4059
4060
if merger is None and uncommitted:
4061
if revision is not None and len(revision) > 0:
4062
raise errors.BzrCommandError('Cannot use --uncommitted and'
4063
' --revision at the same time.')
4064
merger = self.get_merger_from_uncommitted(tree, location, None)
4065
allow_pending = False
4066
4067
if merger is None:
4068
merger, allow_pending = self._get_merger_from_branch(tree,
4069
location, revision, remember, possible_transports, None)
4070
4071
merger.merge_type = merge_type
4072
merger.reprocess = reprocess
4073
merger.show_base = show_base
4074
self.sanity_check_merger(merger)
4075
if (merger.base_rev_id == merger.other_rev_id and
4076
merger.other_rev_id is not None):
4077
# check if location is a nonexistent file (and not a branch) to
4078
# disambiguate the 'Nothing to do'
4079
if merger.interesting_files:
4080
if not merger.other_tree.has_filename(
4081
merger.interesting_files[0]):
4082
note("merger: " + str(merger))
4083
raise errors.PathsDoNotExist([location])
4084
note('Nothing to do.')
4085
return 0
4086
if pull and not preview:
4087
if merger.interesting_files is not None:
4088
raise errors.BzrCommandError('Cannot pull individual files')
4089
if (merger.base_rev_id == tree.last_revision()):
4090
result = tree.pull(merger.other_branch, False,
4091
merger.other_rev_id)
4092
result.report(self.outf)
4093
return 0
4094
if merger.this_basis is None:
4095
raise errors.BzrCommandError(
4096
"This branch has no commits."
4097
" (perhaps you would prefer 'bzr pull')")
4098
if preview:
4099
return self._do_preview(merger)
4100
elif interactive:
4101
return self._do_interactive(merger)
4102
else:
4103
return self._do_merge(merger, change_reporter, allow_pending,
4104
verified)
4105
4106
def _get_preview(self, merger):
3812
return self._do_merge(merger, change_reporter, allow_pending,
3813
verified)
3814
finally:
3815
for cleanup in reversed(cleanups):
3816
cleanup()
3817
3818
def _get_preview(self, merger, cleanups):
4107
3819
tree_merger = merger.make_merger()
4108
3820
tt = tree_merger.make_preview_transform()
4109
self.add_cleanup(tt.finalize)
3821
cleanups.append(tt.finalize)
4110
3822
result_tree = tt.get_preview_tree()
4111
3823
return result_tree
4112
3824
4113
def _do_preview(self, merger):
3825
def _do_preview(self, merger, cleanups):
4114
3826
from bzrlib.diff import show_diff_trees
4115
result_tree = self._get_preview(merger)
4116
path_encoding = osutils.get_diff_header_encoding()
3827
result_tree = self._get_preview(merger, cleanups)
4117
3828
show_diff_trees(merger.this_tree, result_tree, self.outf,
4118
old_label='', new_label='',
4119
path_encoding=path_encoding)
3829
old_label='', new_label='')
4120
3830
4121
3831
def _do_merge(self, merger, change_reporter, allow_pending, verified):
4122
3832
merger.change_reporter = change_reporter
4130
3840
else:
4131
3841
return 0
4132
3842
4133
def _do_interactive(self, merger):
3843
def _do_interactive(self, merger, cleanups):
4134
3844
"""Perform an interactive merge.
4135
3845
4136
3846
This works by generating a preview tree of the merge, then using
4138
3848
and the preview tree.
4139
3849
"""
4140
3850
from bzrlib import shelf_ui
4141
result_tree = self._get_preview(merger)
3851
result_tree = self._get_preview(merger, cleanups)
4142
3852
writer = bzrlib.option.diff_writer_registry.get()
4143
3853
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
4144
3854
reporter=shelf_ui.ApplyReporter(),
4198
3908
if other_revision_id is None:
4199
3909
other_revision_id = _mod_revision.ensure_null(
4200
3910
other_branch.last_revision())
4201
# Remember where we merge from. We need to remember if:
4202
# - user specify a location (and we don't merge from the parent
4203
# branch)
4204
# - user ask to remember or there is no previous location set to merge
4205
# from and user didn't ask to *not* remember
4206
if (user_location is not None
4207
and ((remember
4208
or (remember is None
4209
and tree.branch.get_submit_branch() is None)))):
3911
# Remember where we merge from
3912
if ((remember or tree.branch.get_submit_branch() is None) and
3913
user_location is not None):
4210
3914
tree.branch.set_submit_branch(other_branch.base)
4211
# Merge tags (but don't set them in the master branch yet, the user
4212
# might revert this merge). Commit will propagate them.
4213
_merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3915
_merge_tags_if_possible(other_branch, tree.branch)
4214
3916
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4215
3917
other_revision_id, base_revision_id, other_branch, base_branch)
4216
3918
if other_path != '':
4220
3922
allow_pending = True
4221
3923
return merger, allow_pending
4222
3924
4223
def get_merger_from_uncommitted(self, tree, location, pb):
3925
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
4224
3926
"""Get a merger for uncommitted changes.
4225
3927
4226
3928
:param tree: The tree the merger should apply to.
4227
3929
:param location: The location containing uncommitted changes.
4228
3930
:param pb: The progress bar to use for showing progress.
3931
:param cleanups: A list of operations to perform to clean up the
3932
temporary directories, unfinalized objects, etc.
4229
3933
"""
4230
3934
location = self._select_branch_location(tree, location)[0]
4231
3935
other_tree, other_path = WorkingTree.open_containing(location)
4283
3987
4284
3988
4285
3989
class cmd_remerge(Command):
4286
__doc__ = """Redo a merge.
3990
"""Redo a merge.
4287
3991
4288
3992
Use this if you want to try a different merge technique while resolving
4289
3993
conflicts. Some merge techniques are better than others, and remerge
4314
4018
4315
4019
def run(self, file_list=None, merge_type=None, show_base=False,
4316
4020
reprocess=False):
4317
from bzrlib.conflicts import restore
4318
4021
if merge_type is None:
4319
4022
merge_type = _mod_merge.Merge3Merger
4320
tree, file_list = WorkingTree.open_containing_paths(file_list)
4321
self.add_cleanup(tree.lock_write().unlock)
4322
parents = tree.get_parent_ids()
4323
if len(parents) != 2:
4324
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4325
" merges. Not cherrypicking or"
4326
" multi-merges.")
4327
repository = tree.branch.repository
4328
interesting_ids = None
4329
new_conflicts = []
4330
conflicts = tree.conflicts()
4331
if file_list is not None:
4332
interesting_ids = set()
4333
for filename in file_list:
4334
file_id = tree.path2id(filename)
4335
if file_id is None:
4336
raise errors.NotVersionedError(filename)
4337
interesting_ids.add(file_id)
4338
if tree.kind(file_id) != "directory":
4339
continue
4023
tree, file_list = tree_files(file_list)
4024
tree.lock_write()
4025
try:
4026
parents = tree.get_parent_ids()
4027
if len(parents) != 2:
4028
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4029
" merges. Not cherrypicking or"
4030
" multi-merges.")
4031
repository = tree.branch.repository
4032
interesting_ids = None
4033
new_conflicts = []
4034
conflicts = tree.conflicts()
4035
if file_list is not None:
4036
interesting_ids = set()
4037
for filename in file_list:
4038
file_id = tree.path2id(filename)
4039
if file_id is None:
4040
raise errors.NotVersionedError(filename)
4041
interesting_ids.add(file_id)
4042
if tree.kind(file_id) != "directory":
4043
continue
4340
4044
4341
for name, ie in tree.inventory.iter_entries(file_id):
4342
interesting_ids.add(ie.file_id)
4343
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4344
else:
4345
# Remerge only supports resolving contents conflicts
4346
allowed_conflicts = ('text conflict', 'contents conflict')
4347
restore_files = [c.path for c in conflicts
4348
if c.typestring in allowed_conflicts]
4349
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4350
tree.set_conflicts(ConflictList(new_conflicts))
4351
if file_list is not None:
4352
restore_files = file_list
4353
for filename in restore_files:
4045
for name, ie in tree.inventory.iter_entries(file_id):
4046
interesting_ids.add(ie.file_id)
4047
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4048
else:
4049
# Remerge only supports resolving contents conflicts
4050
allowed_conflicts = ('text conflict', 'contents conflict')
4051
restore_files = [c.path for c in conflicts
4052
if c.typestring in allowed_conflicts]
4053
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4054
tree.set_conflicts(ConflictList(new_conflicts))
4055
if file_list is not None:
4056
restore_files = file_list
4057
for filename in restore_files:
4058
try:
4059
restore(tree.abspath(filename))
4060
except errors.NotConflicted:
4061
pass
4062
# Disable pending merges, because the file texts we are remerging
4063
# have not had those merges performed. If we use the wrong parents
4064
# list, we imply that the working tree text has seen and rejected
4065
# all the changes from the other tree, when in fact those changes
4066
# have not yet been seen.
4067
pb = ui.ui_factory.nested_progress_bar()
4068
tree.set_parent_ids(parents[:1])
4354
4069
try:
4355
restore(tree.abspath(filename))
4356
except errors.NotConflicted:
4357
pass
4358
# Disable pending merges, because the file texts we are remerging
4359
# have not had those merges performed. If we use the wrong parents
4360
# list, we imply that the working tree text has seen and rejected
4361
# all the changes from the other tree, when in fact those changes
4362
# have not yet been seen.
4363
tree.set_parent_ids(parents[:1])
4364
try:
4365
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4366
merger.interesting_ids = interesting_ids
4367
merger.merge_type = merge_type
4368
merger.show_base = show_base
4369
merger.reprocess = reprocess
4370
conflicts = merger.do_merge()
4070
merger = _mod_merge.Merger.from_revision_ids(pb,
4071
tree, parents[1])
4072
merger.interesting_ids = interesting_ids
4073
merger.merge_type = merge_type
4074
merger.show_base = show_base
4075
merger.reprocess = reprocess
4076
conflicts = merger.do_merge()
4077
finally:
4078
tree.set_parent_ids(parents)
4079
pb.finished()
4371
4080
finally:
4372
tree.set_parent_ids(parents)
4081
tree.unlock()
4373
4082
if conflicts > 0:
4374
4083
return 1
4375
4084
else:
4377
4086
4378
4087
4379
4088
class cmd_revert(Command):
4380
__doc__ = """Revert files to a previous revision.
4089
"""Revert files to a previous revision.
4381
4090
4382
4091
Giving a list of files will revert only those files. Otherwise, all files
4383
4092
will be reverted. If the revision is not specified with '--revision', the
4384
4093
last committed revision is used.
4385
4094
4386
4095
To remove only some changes, without reverting to a prior version, use
4387
merge instead. For example, "merge . -r -2..-3" (don't forget the ".")
4388
will remove the changes introduced by the second last commit (-2), without
4389
affecting the changes introduced by the last commit (-1). To remove
4390
certain changes on a hunk-by-hunk basis, see the shelve command.
4096
merge instead. For example, "merge . --revision -2..-3" will remove the
4097
changes introduced by -2, without affecting the changes introduced by -1.
4098
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4391
4099
4392
4100
By default, any files that have been manually changed will be backed up
4393
4101
first. (Files changed only by merge are not backed up.) Backup files have
4403
4111
created as above. Directories containing unknown files will not be
4404
4112
deleted.
4405
4113
4406
The working tree contains a list of revisions that have been merged but
4407
not yet committed. These revisions will be included as additional parents
4408
of the next commit. Normally, using revert clears that list as well as
4409
reverting the files. If any files are specified, revert leaves the list
4410
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4411
.`` in the tree root to revert all files but keep the recorded merges,
4412
and ``bzr revert --forget-merges`` to clear the pending merge list without
4114
The working tree contains a list of pending merged revisions, which will
4115
be included as parents in the next commit. Normally, revert clears that
4116
list as well as reverting the files. If any files are specified, revert
4117
leaves the pending merge list alone and reverts only the files. Use "bzr
4118
revert ." in the tree root to revert all files but keep the merge record,
4119
and "bzr revert --forget-merges" to clear the pending merge list without
4413
4120
reverting any files.
4414
4121
4415
Using "bzr revert --forget-merges", it is possible to apply all of the
4416
changes from a branch in a single revision. To do this, perform the merge
4417
as desired. Then doing revert with the "--forget-merges" option will keep
4418
the content of the tree as it was, but it will clear the list of pending
4419
merges. The next commit will then contain all of the changes that are
4420
present in the other branch, but without any other parent revisions.
4421
Because this technique forgets where these changes originated, it may
4422
cause additional conflicts on later merges involving the same source and
4122
Using "bzr revert --forget-merges", it is possible to apply the changes
4123
from an arbitrary merge as a single revision. To do this, perform the
4124
merge as desired. Then doing revert with the "--forget-merges" option will
4125
keep the content of the tree as it was, but it will clear the list of
4126
pending merges. The next commit will then contain all of the changes that
4127
would have been in the merge, but without any mention of the other parent
4128
revisions. Because this technique forgets where these changes originated,
4129
it may cause additional conflicts on later merges involving the source and
4423
4130
target branches.
4424
4131
"""
4425
4132
4426
_see_also = ['cat', 'export', 'merge', 'shelve']
4133
_see_also = ['cat', 'export']
4427
4134
takes_options = [
4428
4135
'revision',
4429
4136
Option('no-backup', "Do not save backups of reverted files."),
4434
4141
4435
4142
def run(self, revision=None, no_backup=False, file_list=None,
4436
4143
forget_merges=None):
4437
tree, file_list = WorkingTree.open_containing_paths(file_list)
4438
self.add_cleanup(tree.lock_tree_write().unlock)
4439
if forget_merges:
4440
tree.set_parent_ids(tree.get_parent_ids()[:1])
4441
else:
4442
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4144
tree, file_list = tree_files(file_list)
4145
tree.lock_write()
4146
try:
4147
if forget_merges:
4148
tree.set_parent_ids(tree.get_parent_ids()[:1])
4149
else:
4150
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4151
finally:
4152
tree.unlock()
4443
4153
4444
4154
@staticmethod
4445
4155
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4446
4156
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4447
tree.revert(file_list, rev_tree, not no_backup, None,
4448
report_changes=True)
4157
pb = ui.ui_factory.nested_progress_bar()
4158
try:
4159
tree.revert(file_list, rev_tree, not no_backup, pb,
4160
report_changes=True)
4161
finally:
4162
pb.finished()
4449
4163
4450
4164
4451
4165
class cmd_assert_fail(Command):
4452
__doc__ = """Test reporting of assertion failures"""
4166
"""Test reporting of assertion failures"""
4453
4167
# intended just for use in testing
4454
4168
4455
4169
hidden = True
4459
4173
4460
4174
4461
4175
class cmd_help(Command):
4462
__doc__ = """Show help on a command or other topic.
4176
"""Show help on a command or other topic.
4463
4177
"""
4464
4178
4465
4179
_see_also = ['topics']
4478
4192
4479
4193
4480
4194
class cmd_shell_complete(Command):
4481
__doc__ = """Show appropriate completions for context.
4195
"""Show appropriate completions for context.
4482
4196
4483
4197
For a list of all available commands, say 'bzr shell-complete'.
4484
4198
"""
4493
4207
4494
4208
4495
4209
class cmd_missing(Command):
4496
__doc__ = """Show unmerged/unpulled revisions between two branches.
4210
"""Show unmerged/unpulled revisions between two branches.
4497
4211
4498
4212
OTHER_BRANCH may be local or remote.
4499
4213
4530
4244
_see_also = ['merge', 'pull']
4531
4245
takes_args = ['other_branch?']
4532
4246
takes_options = [
4533
'directory',
4534
4247
Option('reverse', 'Reverse the order of revisions.'),
4535
4248
Option('mine-only',
4536
4249
'Display changes in the local branch only.'),
4558
4271
theirs_only=False,
4559
4272
log_format=None, long=False, short=False, line=False,
4560
4273
show_ids=False, verbose=False, this=False, other=False,
4561
include_merges=False, revision=None, my_revision=None,
4562
directory=u'.'):
4274
include_merges=False, revision=None, my_revision=None):
4563
4275
from bzrlib.missing import find_unmerged, iter_log_revisions
4564
4276
def message(s):
4565
4277
if not is_quiet():
4578
4290
elif theirs_only:
4579
4291
restrict = 'remote'
4580
4292
4581
local_branch = Branch.open_containing(directory)[0]
4582
self.add_cleanup(local_branch.lock_read().unlock)
4583
4293
local_branch = Branch.open_containing(u".")[0]
4584
4294
parent = local_branch.get_parent()
4585
4295
if other_branch is None:
4586
4296
other_branch = parent
4595
4305
remote_branch = Branch.open(other_branch)
4596
4306
if remote_branch.base == local_branch.base:
4597
4307
remote_branch = local_branch
4598
else:
4599
self.add_cleanup(remote_branch.lock_read().unlock)
4600
4308
4601
4309
local_revid_range = _revision_range_to_revid_range(
4602
4310
_get_revision_range(my_revision, local_branch,
4606
4314
_get_revision_range(revision,
4607
4315
remote_branch, self.name()))
4608
4316
4609
local_extra, remote_extra = find_unmerged(
4610
local_branch, remote_branch, restrict,
4611
backward=not reverse,
4612
include_merges=include_merges,
4613
local_revid_range=local_revid_range,
4614
remote_revid_range=remote_revid_range)
4615
4616
if log_format is None:
4617
registry = log.log_formatter_registry
4618
log_format = registry.get_default(local_branch)
4619
lf = log_format(to_file=self.outf,
4620
show_ids=show_ids,
4621
show_timezone='original')
4622
4623
status_code = 0
4624
if local_extra and not theirs_only:
4625
message("You have %d extra revision(s):\n" %
4626
len(local_extra))
4627
for revision in iter_log_revisions(local_extra,
4628
local_branch.repository,
4629
verbose):
4630
lf.log_revision(revision)
4631
printed_local = True
4632
status_code = 1
4633
else:
4634
printed_local = False
4635
4636
if remote_extra and not mine_only:
4637
if printed_local is True:
4638
message("\n\n\n")
4639
message("You are missing %d revision(s):\n" %
4640
len(remote_extra))
4641
for revision in iter_log_revisions(remote_extra,
4642
remote_branch.repository,
4643
verbose):
4644
lf.log_revision(revision)
4645
status_code = 1
4646
4647
if mine_only and not local_extra:
4648
# We checked local, and found nothing extra
4649
message('This branch is up to date.\n')
4650
elif theirs_only and not remote_extra:
4651
# We checked remote, and found nothing extra
4652
message('Other branch is up to date.\n')
4653
elif not (mine_only or theirs_only or local_extra or
4654
remote_extra):
4655
# We checked both branches, and neither one had extra
4656
# revisions
4657
message("Branches are up to date.\n")
4658
self.cleanup_now()
4317
local_branch.lock_read()
4318
try:
4319
remote_branch.lock_read()
4320
try:
4321
local_extra, remote_extra = find_unmerged(
4322
local_branch, remote_branch, restrict,
4323
backward=not reverse,
4324
include_merges=include_merges,
4325
local_revid_range=local_revid_range,
4326
remote_revid_range=remote_revid_range)
4327
4328
if log_format is None:
4329
registry = log.log_formatter_registry
4330
log_format = registry.get_default(local_branch)
4331
lf = log_format(to_file=self.outf,
4332
show_ids=show_ids,
4333
show_timezone='original')
4334
4335
status_code = 0
4336
if local_extra and not theirs_only:
4337
message("You have %d extra revision(s):\n" %
4338
len(local_extra))
4339
for revision in iter_log_revisions(local_extra,
4340
local_branch.repository,
4341
verbose):
4342
lf.log_revision(revision)
4343
printed_local = True
4344
status_code = 1
4345
else:
4346
printed_local = False
4347
4348
if remote_extra and not mine_only:
4349
if printed_local is True:
4350
message("\n\n\n")
4351
message("You are missing %d revision(s):\n" %
4352
len(remote_extra))
4353
for revision in iter_log_revisions(remote_extra,
4354
remote_branch.repository,
4355
verbose):
4356
lf.log_revision(revision)
4357
status_code = 1
4358
4359
if mine_only and not local_extra:
4360
# We checked local, and found nothing extra
4361
message('This branch is up to date.\n')
4362
elif theirs_only and not remote_extra:
4363
# We checked remote, and found nothing extra
4364
message('Other branch is up to date.\n')
4365
elif not (mine_only or theirs_only or local_extra or
4366
remote_extra):
4367
# We checked both branches, and neither one had extra
4368
# revisions
4369
message("Branches are up to date.\n")
4370
finally:
4371
remote_branch.unlock()
4372
finally:
4373
local_branch.unlock()
4659
4374
if not status_code and parent is None and other_branch is not None:
4660
self.add_cleanup(local_branch.lock_write().unlock)
4661
# handle race conditions - a parent might be set while we run.
4662
if local_branch.get_parent() is None:
4663
local_branch.set_parent(remote_branch.base)
4375
local_branch.lock_write()
4376
try:
4377
# handle race conditions - a parent might be set while we run.
4378
if local_branch.get_parent() is None:
4379
local_branch.set_parent(remote_branch.base)
4380
finally:
4381
local_branch.unlock()
4664
4382
return status_code
4665
4383
4666
4384
4667
4385
class cmd_pack(Command):
4668
__doc__ = """Compress the data within a repository.
4669
4670
This operation compresses the data within a bazaar repository. As
4671
bazaar supports automatic packing of repository, this operation is
4672
normally not required to be done manually.
4673
4674
During the pack operation, bazaar takes a backup of existing repository
4675
data, i.e. pack files. This backup is eventually removed by bazaar
4676
automatically when it is safe to do so. To save disk space by removing
4677
the backed up pack files, the --clean-obsolete-packs option may be
4678
used.
4679
4680
Warning: If you use --clean-obsolete-packs and your machine crashes
4681
during or immediately after repacking, you may be left with a state
4682
where the deletion has been written to disk but the new packs have not
4683
been. In this case the repository may be unusable.
4684
"""
4386
"""Compress the data within a repository."""
4685
4387
4686
4388
_see_also = ['repositories']
4687
4389
takes_args = ['branch_or_repo?']
4688
takes_options = [
4689
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4690
]
4691
4390
4692
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4391
def run(self, branch_or_repo='.'):
4693
4392
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4694
4393
try:
4695
4394
branch = dir.open_branch()
4696
4395
repository = branch.repository
4697
4396
except errors.NotBranchError:
4698
4397
repository = dir.open_repository()
4699
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4398
repository.pack()
4700
4399
4701
4400
4702
4401
class cmd_plugins(Command):
4703
__doc__ = """List the installed plugins.
4402
"""List the installed plugins.
4704
4403
4705
4404
This command displays the list of installed plugins including
4706
4405
version of plugin and a short description of each.
4713
4412
adding new commands, providing additional network transports and
4714
4413
customizing log output.
4715
4414
4716
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
4717
for further information on plugins including where to find them and how to
4718
install them. Instructions are also provided there on how to write new
4719
plugins using the Python programming language.
4415
See the Bazaar web site, http://bazaar-vcs.org, for further
4416
information on plugins including where to find them and how to
4417
install them. Instructions are also provided there on how to
4418
write new plugins using the Python programming language.
4720
4419
"""
4721
4420
takes_options = ['verbose']
4722
4421
4723
4422
@display_command
4724
4423
def run(self, verbose=False):
4725
from bzrlib import plugin
4726
# Don't give writelines a generator as some codecs don't like that
4727
self.outf.writelines(
4728
list(plugin.describe_plugins(show_paths=verbose)))
4424
import bzrlib.plugin
4425
from inspect import getdoc
4426
result = []
4427
for name, plugin in bzrlib.plugin.plugins().items():
4428
version = plugin.__version__
4429
if version == 'unknown':
4430
version = ''
4431
name_ver = '%s %s' % (name, version)
4432
d = getdoc(plugin.module)
4433
if d:
4434
doc = d.split('\n')[0]
4435
else:
4436
doc = '(no description)'
4437
result.append((name_ver, doc, plugin.path()))
4438
for name_ver, doc, path in sorted(result):
4439
print name_ver
4440
print ' ', doc
4441
if verbose:
4442
print ' ', path
4443
print
4729
4444
4730
4445
4731
4446
class cmd_testament(Command):
4732
__doc__ = """Show testament (signing-form) of a revision."""
4447
"""Show testament (signing-form) of a revision."""
4733
4448
takes_options = [
4734
4449
'revision',
4735
4450
Option('long', help='Produce long-format testament.'),
4747
4462
b = Branch.open_containing(branch)[0]
4748
4463
else:
4749
4464
b = Branch.open(branch)
4750
self.add_cleanup(b.lock_read().unlock)
4751
if revision is None:
4752
rev_id = b.last_revision()
4753
else:
4754
rev_id = revision[0].as_revision_id(b)
4755
t = testament_class.from_revision(b.repository, rev_id)
4756
if long:
4757
sys.stdout.writelines(t.as_text_lines())
4758
else:
4759
sys.stdout.write(t.as_short_text())
4465
b.lock_read()
4466
try:
4467
if revision is None:
4468
rev_id = b.last_revision()
4469
else:
4470
rev_id = revision[0].as_revision_id(b)
4471
t = testament_class.from_revision(b.repository, rev_id)
4472
if long:
4473
sys.stdout.writelines(t.as_text_lines())
4474
else:
4475
sys.stdout.write(t.as_short_text())
4476
finally:
4477
b.unlock()
4760
4478
4761
4479
4762
4480
class cmd_annotate(Command):
4763
__doc__ = """Show the origin of each line in a file.
4481
"""Show the origin of each line in a file.
4764
4482
4765
4483
This prints out the given file with an annotation on the left side
4766
4484
indicating which revision, author and date introduced the change.
4777
4495
Option('long', help='Show commit date in annotations.'),
4778
4496
'revision',
4779
4497
'show-ids',
4780
'directory',
4781
4498
]
4782
4499
encoding_type = 'exact'
4783
4500
4784
4501
@display_command
4785
4502
def run(self, filename, all=False, long=False, revision=None,
4786
show_ids=False, directory=None):
4787
from bzrlib.annotate import (
4788
annotate_file_tree,
4789
)
4503
show_ids=False):
4504
from bzrlib.annotate import annotate_file, annotate_file_tree
4790
4505
wt, branch, relpath = \
4791
_open_directory_or_containing_tree_or_branch(filename, directory)
4506
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4792
4507
if wt is not None:
4793
self.add_cleanup(wt.lock_read().unlock)
4794
else:
4795
self.add_cleanup(branch.lock_read().unlock)
4796
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4797
self.add_cleanup(tree.lock_read().unlock)
4798
if wt is not None and revision is None:
4799
file_id = wt.path2id(relpath)
4800
else:
4801
file_id = tree.path2id(relpath)
4802
if file_id is None:
4803
raise errors.NotVersionedError(filename)
4804
if wt is not None and revision is None:
4805
# If there is a tree and we're not annotating historical
4806
# versions, annotate the working tree's content.
4807
annotate_file_tree(wt, file_id, self.outf, long, all,
4808
show_ids=show_ids)
4809
else:
4810
annotate_file_tree(tree, file_id, self.outf, long, all,
4811
show_ids=show_ids, branch=branch)
4508
wt.lock_read()
4509
else:
4510
branch.lock_read()
4511
try:
4512
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4513
if wt is not None:
4514
file_id = wt.path2id(relpath)
4515
else:
4516
file_id = tree.path2id(relpath)
4517
if file_id is None:
4518
raise errors.NotVersionedError(filename)
4519
file_version = tree.inventory[file_id].revision
4520
if wt is not None and revision is None:
4521
# If there is a tree and we're not annotating historical
4522
# versions, annotate the working tree's content.
4523
annotate_file_tree(wt, file_id, self.outf, long, all,
4524
show_ids=show_ids)
4525
else:
4526
annotate_file(branch, file_version, file_id, long, all, self.outf,
4527
show_ids=show_ids)
4528
finally:
4529
if wt is not None:
4530
wt.unlock()
4531
else:
4532
branch.unlock()
4812
4533
4813
4534
4814
4535
class cmd_re_sign(Command):
4815
__doc__ = """Create a digital signature for an existing revision."""
4536
"""Create a digital signature for an existing revision."""
4816
4537
# TODO be able to replace existing ones.
4817
4538
4818
4539
hidden = True # is this right ?
4819
4540
takes_args = ['revision_id*']
4820
takes_options = ['directory', 'revision']
4541
takes_options = ['revision']
4821
4542
4822
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4543
def run(self, revision_id_list=None, revision=None):
4823
4544
if revision_id_list is not None and revision is not None:
4824
4545
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4825
4546
if revision_id_list is None and revision is None:
4826
4547
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4827
b = WorkingTree.open_containing(directory)[0].branch
4828
self.add_cleanup(b.lock_write().unlock)
4829
return self._run(b, revision_id_list, revision)
4548
b = WorkingTree.open_containing(u'.')[0].branch
4549
b.lock_write()
4550
try:
4551
return self._run(b, revision_id_list, revision)
4552
finally:
4553
b.unlock()
4830
4554
4831
4555
def _run(self, b, revision_id_list, revision):
4832
4556
import bzrlib.gpg as gpg
4877
4601
4878
4602
4879
4603
class cmd_bind(Command):
4880
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4881
If no branch is supplied, rebind to the last bound location.
4604
"""Convert the current branch into a checkout of the supplied branch.
4882
4605
4883
4606
Once converted into a checkout, commits must succeed on the master branch
4884
4607
before they will be applied to the local branch.
4890
4613
4891
4614
_see_also = ['checkouts', 'unbind']
4892
4615
takes_args = ['location?']
4893
takes_options = ['directory']
4616
takes_options = []
4894
4617
4895
def run(self, location=None, directory=u'.'):
4896
b, relpath = Branch.open_containing(directory)
4618
def run(self, location=None):
4619
b, relpath = Branch.open_containing(u'.')
4897
4620
if location is None:
4898
4621
try:
4899
4622
location = b.get_old_bound_location()
4902
4625
'This format does not remember old locations.')
4903
4626
else:
4904
4627
if location is None:
4905
if b.get_bound_location() is not None:
4906
raise errors.BzrCommandError('Branch is already bound')
4907
else:
4908
raise errors.BzrCommandError('No location supplied '
4909
'and no previous location known')
4628
raise errors.BzrCommandError('No location supplied and no '
4629
'previous location known')
4910
4630
b_other = Branch.open(location)
4911
4631
try:
4912
4632
b.bind(b_other)
4918
4638
4919
4639
4920
4640
class cmd_unbind(Command):
4921
__doc__ = """Convert the current checkout into a regular branch.
4641
"""Convert the current checkout into a regular branch.
4922
4642
4923
4643
After unbinding, the local branch is considered independent and subsequent
4924
4644
commits will be local only.
4926
4646
4927
4647
_see_also = ['checkouts', 'bind']
4928
4648
takes_args = []
4929
takes_options = ['directory']
4649
takes_options = []
4930
4650
4931
def run(self, directory=u'.'):
4932
b, relpath = Branch.open_containing(directory)
4651
def run(self):
4652
b, relpath = Branch.open_containing(u'.')
4933
4653
if not b.unbind():
4934
4654
raise errors.BzrCommandError('Local branch is not bound')
4935
4655
4936
4656
4937
4657
class cmd_uncommit(Command):
4938
__doc__ = """Remove the last committed revision.
4658
"""Remove the last committed revision.
4939
4659
4940
4660
--verbose will print out what is being removed.
4941
4661
--dry-run will go through all the motions, but not actually
4981
4701
b = control.open_branch()
4982
4702
4983
4703
if tree is not None:
4984
self.add_cleanup(tree.lock_write().unlock)
4704
tree.lock_write()
4985
4705
else:
4986
self.add_cleanup(b.lock_write().unlock)
4987
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4706
b.lock_write()
4707
try:
4708
return self._run(b, tree, dry_run, verbose, revision, force,
4709
local=local)
4710
finally:
4711
if tree is not None:
4712
tree.unlock()
4713
else:
4714
b.unlock()
4988
4715
4989
4716
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4990
4717
from bzrlib.log import log_formatter, show_log
5022
4749
end_revision=last_revno)
5023
4750
5024
4751
if dry_run:
5025
self.outf.write('Dry-run, pretending to remove'
5026
' the above revisions.\n')
4752
print 'Dry-run, pretending to remove the above revisions.'
4753
if not force:
4754
val = raw_input('Press <enter> to continue')
5027
4755
else:
5028
self.outf.write('The above revision(s) will be removed.\n')
5029
5030
if not force:
5031
if not ui.ui_factory.confirm_action(
5032
u'Uncommit these revisions',
5033
'bzrlib.builtins.uncommit',
5034
{}):
5035
self.outf.write('Canceled\n')
5036
return 0
4756
print 'The above revision(s) will be removed.'
4757
if not force:
4758
val = raw_input('Are you sure [y/N]? ')
4759
if val.lower() not in ('y', 'yes'):
4760
print 'Canceled'
4761
return 0
5037
4762
5038
4763
mutter('Uncommitting from {%s} to {%s}',
5039
4764
last_rev_id, rev_id)
5040
4765
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
5041
4766
revno=revno, local=local)
5042
self.outf.write('You can restore the old tip by running:\n'
5043
' bzr pull . -r revid:%s\n' % last_rev_id)
4767
note('You can restore the old tip by running:\n'
4768
' bzr pull . -r revid:%s', last_rev_id)
5044
4769
5045
4770
5046
4771
class cmd_break_lock(Command):
5047
__doc__ = """Break a dead lock.
5048
5049
This command breaks a lock on a repository, branch, working directory or
5050
config file.
4772
"""Break a dead lock on a repository, branch or working directory.
5051
4773
5052
4774
CAUTION: Locks should only be broken when you are sure that the process
5053
4775
holding the lock has been stopped.
5054
4776
5055
You can get information on what locks are open via the 'bzr info
5056
[location]' command.
4777
You can get information on what locks are open via the 'bzr info' command.
5057
4778
5058
4779
:Examples:
5059
4780
bzr break-lock
5060
bzr break-lock bzr+ssh://example.com/bzr/foo
5061
bzr break-lock --conf ~/.bazaar
5062
4781
"""
5063
5064
4782
takes_args = ['location?']
5065
takes_options = [
5066
Option('config',
5067
help='LOCATION is the directory where the config lock is.'),
5068
Option('force',
5069
help='Do not ask for confirmation before breaking the lock.'),
5070
]
5071
4783
5072
def run(self, location=None, config=False, force=False):
4784
def run(self, location=None, show=False):
5073
4785
if location is None:
5074
4786
location = u'.'
5075
if force:
5076
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
5077
None,
5078
{'bzrlib.lockdir.break': True})
5079
if config:
5080
conf = _mod_config.LockableConfig(file_name=location)
5081
conf.break_lock()
5082
else:
5083
control, relpath = bzrdir.BzrDir.open_containing(location)
5084
try:
5085
control.break_lock()
5086
except NotImplementedError:
5087
pass
4787
control, relpath = bzrdir.BzrDir.open_containing(location)
4788
try:
4789
control.break_lock()
4790
except NotImplementedError:
4791
pass
5088
4792
5089
4793
5090
4794
class cmd_wait_until_signalled(Command):
5091
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4795
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
5092
4796
5093
4797
This just prints a line to signal when it is ready, then blocks on stdin.
5094
4798
"""
5102
4806
5103
4807
5104
4808
class cmd_serve(Command):
5105
__doc__ = """Run the bzr server."""
4809
"""Run the bzr server."""
5106
4810
5107
4811
aliases = ['server']
5108
4812
5119
4823
'result in a dynamically allocated port. The default port '
5120
4824
'depends on the protocol.',
5121
4825
type=str),
5122
custom_help('directory',
5123
help='Serve contents of this directory.'),
4826
Option('directory',
4827
help='Serve contents of this directory.',
4828
type=unicode),
5124
4829
Option('allow-writes',
5125
4830
help='By default the server is a readonly server. Supplying '
5126
4831
'--allow-writes enables write access to the contents of '
5153
4858
5154
4859
def run(self, port=None, inet=False, directory=None, allow_writes=False,
5155
4860
protocol=None):
5156
from bzrlib import transport
4861
from bzrlib.transport import get_transport, transport_server_registry
5157
4862
if directory is None:
5158
4863
directory = os.getcwd()
5159
4864
if protocol is None:
5160
protocol = transport.transport_server_registry.get()
4865
protocol = transport_server_registry.get()
5161
4866
host, port = self.get_host_and_port(port)
5162
4867
url = urlutils.local_path_to_url(directory)
5163
4868
if not allow_writes:
5164
4869
url = 'readonly+' + url
5165
t = transport.get_transport(url)
5166
protocol(t, host, port, inet)
4870
transport = get_transport(url)
4871
protocol(transport, host, port, inet)
5167
4872
5168
4873
5169
4874
class cmd_join(Command):
5170
__doc__ = """Combine a tree into its containing tree.
4875
"""Combine a tree into its containing tree.
5171
4876
5172
4877
This command requires the target tree to be in a rich-root format.
5173
4878
5175
4880
not part of it. (Such trees can be produced by "bzr split", but also by
5176
4881
running "bzr branch" with the target inside a tree.)
5177
4882
5178
The result is a combined tree, with the subtree no longer an independent
4883
The result is a combined tree, with the subtree no longer an independant
5179
4884
part. This is marked as a merge of the subtree into the containing tree,
5180
4885
and all history is preserved.
5181
4886
"""
5213
4918
5214
4919
5215
4920
class cmd_split(Command):
5216
__doc__ = """Split a subdirectory of a tree into a separate tree.
4921
"""Split a subdirectory of a tree into a separate tree.
5217
4922
5218
4923
This command will produce a target tree in a format that supports
5219
4924
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5239
4944
5240
4945
5241
4946
class cmd_merge_directive(Command):
5242
__doc__ = """Generate a merge directive for auto-merge tools.
4947
"""Generate a merge directive for auto-merge tools.
5243
4948
5244
4949
A directive requests a merge to be performed, and also provides all the
5245
4950
information necessary to do so. This means it must either include a
5262
4967
_see_also = ['send']
5263
4968
5264
4969
takes_options = [
5265
'directory',
5266
4970
RegistryOption.from_kwargs('patch-type',
5267
4971
'The type of patch to include in the directive.',
5268
4972
title='Patch type',
5281
4985
encoding_type = 'exact'
5282
4986
5283
4987
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5284
sign=False, revision=None, mail_to=None, message=None,
5285
directory=u'.'):
4988
sign=False, revision=None, mail_to=None, message=None):
5286
4989
from bzrlib.revision import ensure_null, NULL_REVISION
5287
4990
include_patch, include_bundle = {
5288
4991
'plain': (False, False),
5289
4992
'diff': (True, False),
5290
4993
'bundle': (True, True),
5291
4994
}[patch_type]
5292
branch = Branch.open(directory)
4995
branch = Branch.open('.')
5293
4996
stored_submit_branch = branch.get_submit_branch()
5294
4997
if submit_branch is None:
5295
4998
submit_branch = stored_submit_branch
5340
5043
5341
5044
5342
5045
class cmd_send(Command):
5343
__doc__ = """Mail or create a merge-directive for submitting changes.
5046
"""Mail or create a merge-directive for submitting changes.
5344
5047
5345
5048
A merge directive provides many things needed for requesting merges:
5346
5049
5352
5055
directly from the merge directive, without retrieving data from a
5353
5056
branch.
5354
5057
5355
`bzr send` creates a compact data set that, when applied using bzr
5356
merge, has the same effect as merging from the source branch.
5357
5358
By default the merge directive is self-contained and can be applied to any
5359
branch containing submit_branch in its ancestory without needing access to
5360
the source branch.
5361
5362
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5363
revisions, but only a structured request to merge from the
5364
public_location. In that case the public_branch is needed and it must be
5365
up-to-date and accessible to the recipient. The public_branch is always
5366
included if known, so that people can check it later.
5367
5368
The submit branch defaults to the parent of the source branch, but can be
5369
overridden. Both submit branch and public branch will be remembered in
5370
branch.conf the first time they are used for a particular branch. The
5371
source branch defaults to that containing the working directory, but can
5372
be changed using --from.
5373
5374
Both the submit branch and the public branch follow the usual behavior with
5375
respect to --remember: If there is no default location set, the first send
5376
will set it (use --no-remember to avoid settting it). After that, you can
5377
omit the location to use the default. To change the default, use
5378
--remember. The value will only be saved if the location can be accessed.
5379
5380
In order to calculate those changes, bzr must analyse the submit branch.
5381
Therefore it is most efficient for the submit branch to be a local mirror.
5382
If a public location is known for the submit_branch, that location is used
5383
in the merge directive.
5384
5385
The default behaviour is to send the merge directive by mail, unless -o is
5386
given, in which case it is sent to a file.
5058
If --no-bundle is specified, then public_branch is needed (and must be
5059
up-to-date), so that the receiver can perform the merge using the
5060
public_branch. The public_branch is always included if known, so that
5061
people can check it later.
5062
5063
The submit branch defaults to the parent, but can be overridden. Both
5064
submit branch and public branch will be remembered if supplied.
5065
5066
If a public_branch is known for the submit_branch, that public submit
5067
branch is used in the merge instructions. This means that a local mirror
5068
can be used as your actual submit branch, once you have set public_branch
5069
for that mirror.
5387
5070
5388
5071
Mail is sent using your preferred mail program. This should be transparent
5389
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5072
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5390
5073
If the preferred client can't be found (or used), your editor will be used.
5391
5074
5392
5075
To use a specific mail program, set the mail_client configuration option.
5409
5092
5410
5093
The merge directives created by bzr send may be applied using bzr merge or
5411
5094
bzr pull by specifying a file containing a merge directive as the location.
5412
5413
bzr send makes extensive use of public locations to map local locations into
5414
URLs that can be used by other people. See `bzr help configuration` to
5415
set them, and use `bzr info` to display them.
5416
5095
"""
5417
5096
5418
5097
encoding_type = 'exact'
5434
5113
short_name='f',
5435
5114
type=unicode),
5436
5115
Option('output', short_name='o',
5437
help='Write merge directive to this file or directory; '
5116
help='Write merge directive to this file; '
5438
5117
'use - for stdout.',
5439
5118
type=unicode),
5440
5119
Option('strict',
5451
5130
]
5452
5131
5453
5132
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5454
no_patch=False, revision=None, remember=None, output=None,
5133
no_patch=False, revision=None, remember=False, output=None,
5455
5134
format=None, mail_to=None, message=None, body=None,
5456
5135
strict=None, **kwargs):
5457
5136
from bzrlib.send import send
5463
5142
5464
5143
5465
5144
class cmd_bundle_revisions(cmd_send):
5466
__doc__ = """Create a merge-directive for submitting changes.
5145
"""Create a merge-directive for submitting changes.
5467
5146
5468
5147
A merge directive provides many things needed for requesting merges:
5469
5148
5536
5215
5537
5216
5538
5217
class cmd_tag(Command):
5539
__doc__ = """Create, remove or modify a tag naming a revision.
5218
"""Create, remove or modify a tag naming a revision.
5540
5219
5541
5220
Tags give human-meaningful names to revisions. Commands that take a -r
5542
5221
(--revision) option can be given -rtag:X, where X is any previously
5550
5229
5551
5230
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5552
5231
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5553
5554
If no tag name is specified it will be determined through the
5555
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5556
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5557
details.
5558
5232
"""
5559
5233
5560
5234
_see_also = ['commit', 'tags']
5561
takes_args = ['tag_name?']
5235
takes_args = ['tag_name']
5562
5236
takes_options = [
5563
5237
Option('delete',
5564
5238
help='Delete this tag rather than placing it.',
5565
5239
),
5566
custom_help('directory',
5567
help='Branch in which to place the tag.'),
5240
Option('directory',
5241
help='Branch in which to place the tag.',
5242
short_name='d',
5243
type=unicode,
5244
),
5568
5245
Option('force',
5569
5246
help='Replace existing tags.',
5570
5247
),
5571
5248
'revision',
5572
5249
]
5573
5250
5574
def run(self, tag_name=None,
5251
def run(self, tag_name,
5575
5252
delete=None,
5576
5253
directory='.',
5577
5254
force=None,
5578
5255
revision=None,
5579
5256
):
5580
5257
branch, relpath = Branch.open_containing(directory)
5581
self.add_cleanup(branch.lock_write().unlock)
5582
if delete:
5583
if tag_name is None:
5584
raise errors.BzrCommandError("No tag specified to delete.")
5585
branch.tags.delete_tag(tag_name)
5586
note('Deleted tag %s.' % tag_name)
5587
else:
5588
if revision:
5589
if len(revision) != 1:
5590
raise errors.BzrCommandError(
5591
"Tags can only be placed on a single revision, "
5592
"not on a range")
5593
revision_id = revision[0].as_revision_id(branch)
5258
branch.lock_write()
5259
try:
5260
if delete:
5261
branch.tags.delete_tag(tag_name)
5262
self.outf.write('Deleted tag %s.\n' % tag_name)
5594
5263
else:
5595
revision_id = branch.last_revision()
5596
if tag_name is None:
5597
tag_name = branch.automatic_tag_name(revision_id)
5598
if tag_name is None:
5599
raise errors.BzrCommandError(
5600
"Please specify a tag name.")
5601
if (not force) and branch.tags.has_tag(tag_name):
5602
raise errors.TagAlreadyExists(tag_name)
5603
branch.tags.set_tag(tag_name, revision_id)
5604
note('Created tag %s.' % tag_name)
5264
if revision:
5265
if len(revision) != 1:
5266
raise errors.BzrCommandError(
5267
"Tags can only be placed on a single revision, "
5268
"not on a range")
5269
revision_id = revision[0].as_revision_id(branch)
5270
else:
5271
revision_id = branch.last_revision()
5272
if (not force) and branch.tags.has_tag(tag_name):
5273
raise errors.TagAlreadyExists(tag_name)
5274
branch.tags.set_tag(tag_name, revision_id)
5275
self.outf.write('Created tag %s.\n' % tag_name)
5276
finally:
5277
branch.unlock()
5605
5278
5606
5279
5607
5280
class cmd_tags(Command):
5608
__doc__ = """List tags.
5281
"""List tags.
5609
5282
5610
5283
This command shows a table of tag names and the revisions they reference.
5611
5284
"""
5612
5285
5613
5286
_see_also = ['tag']
5614
5287
takes_options = [
5615
custom_help('directory',
5616
help='Branch whose tags should be displayed.'),
5617
RegistryOption('sort',
5288
Option('directory',
5289
help='Branch whose tags should be displayed.',
5290
short_name='d',
5291
type=unicode,
5292
),
5293
RegistryOption.from_kwargs('sort',
5618
5294
'Sort tags by different criteria.', title='Sorting',
5619
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5295
alpha='Sort tags lexicographically (default).',
5296
time='Sort tags chronologically.',
5620
5297
),
5621
5298
'show-ids',
5622
5299
'revision',
5623
5300
]
5624
5301
5625
5302
@display_command
5626
def run(self, directory='.', sort=None, show_ids=False, revision=None):
5627
from bzrlib.tag import tag_sort_methods
5303
def run(self,
5304
directory='.',
5305
sort='alpha',
5306
show_ids=False,
5307
revision=None,
5308
):
5628
5309
branch, relpath = Branch.open_containing(directory)
5629
5310
5630
5311
tags = branch.tags.get_tag_dict().items()
5631
5312
if not tags:
5632
5313
return
5633
5314
5634
self.add_cleanup(branch.lock_read().unlock)
5635
if revision:
5636
graph = branch.repository.get_graph()
5637
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5638
revid1, revid2 = rev1.rev_id, rev2.rev_id
5639
# only show revisions between revid1 and revid2 (inclusive)
5640
tags = [(tag, revid) for tag, revid in tags if
5641
graph.is_between(revid, revid1, revid2)]
5642
if sort is None:
5643
sort = tag_sort_methods.get()
5644
sort(branch, tags)
5645
if not show_ids:
5646
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5647
for index, (tag, revid) in enumerate(tags):
5648
try:
5649
revno = branch.revision_id_to_dotted_revno(revid)
5650
if isinstance(revno, tuple):
5651
revno = '.'.join(map(str, revno))
5652
except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
5653
# Bad tag data/merges can lead to tagged revisions
5654
# which are not in this branch. Fail gracefully ...
5655
revno = '?'
5656
tags[index] = (tag, revno)
5657
self.cleanup_now()
5315
branch.lock_read()
5316
try:
5317
if revision:
5318
graph = branch.repository.get_graph()
5319
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5320
revid1, revid2 = rev1.rev_id, rev2.rev_id
5321
# only show revisions between revid1 and revid2 (inclusive)
5322
tags = [(tag, revid) for tag, revid in tags if
5323
graph.is_between(revid, revid1, revid2)]
5324
if sort == 'alpha':
5325
tags.sort()
5326
elif sort == 'time':
5327
timestamps = {}
5328
for tag, revid in tags:
5329
try:
5330
revobj = branch.repository.get_revision(revid)
5331
except errors.NoSuchRevision:
5332
timestamp = sys.maxint # place them at the end
5333
else:
5334
timestamp = revobj.timestamp
5335
timestamps[revid] = timestamp
5336
tags.sort(key=lambda x: timestamps[x[1]])
5337
if not show_ids:
5338
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5339
for index, (tag, revid) in enumerate(tags):
5340
try:
5341
revno = branch.revision_id_to_dotted_revno(revid)
5342
if isinstance(revno, tuple):
5343
revno = '.'.join(map(str, revno))
5344
except errors.NoSuchRevision:
5345
# Bad tag data/merges can lead to tagged revisions
5346
# which are not in this branch. Fail gracefully ...
5347
revno = '?'
5348
tags[index] = (tag, revno)
5349
finally:
5350
branch.unlock()
5658
5351
for tag, revspec in tags:
5659
5352
self.outf.write('%-20s %s\n' % (tag, revspec))
5660
5353
5661
5354
5662
5355
class cmd_reconfigure(Command):
5663
__doc__ = """Reconfigure the type of a bzr directory.
5356
"""Reconfigure the type of a bzr directory.
5664
5357
5665
5358
A target configuration must be specified.
5666
5359
5713
5406
unstacked=None):
5714
5407
directory = bzrdir.BzrDir.open(location)
5715
5408
if stacked_on and unstacked:
5716
raise errors.BzrCommandError("Can't use both --stacked-on and --unstacked")
5409
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
5717
5410
elif stacked_on is not None:
5718
5411
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5719
5412
elif unstacked:
5751
5444
5752
5445
5753
5446
class cmd_switch(Command):
5754
__doc__ = """Set the branch of a checkout and update.
5447
"""Set the branch of a checkout and update.
5755
5448
5756
5449
For lightweight checkouts, this changes the branch being referenced.
5757
5450
For heavyweight checkouts, this checks that there are no local commits
5773
5466
that of the master.
5774
5467
"""
5775
5468
5776
takes_args = ['to_location?']
5777
takes_options = ['directory',
5778
Option('force',
5469
takes_args = ['to_location']
5470
takes_options = [Option('force',
5779
5471
help='Switch even if local commits will be lost.'),
5780
'revision',
5781
5472
Option('create-branch', short_name='b',
5782
5473
help='Create the target branch from this one before'
5783
5474
' switching to it.'),
5784
]
5475
]
5785
5476
5786
def run(self, to_location=None, force=False, create_branch=False,
5787
revision=None, directory=u'.'):
5477
def run(self, to_location, force=False, create_branch=False):
5788
5478
from bzrlib import switch
5789
tree_location = directory
5790
revision = _get_one_revision('switch', revision)
5479
tree_location = '.'
5791
5480
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5792
if to_location is None:
5793
if revision is None:
5794
raise errors.BzrCommandError('You must supply either a'
5795
' revision or a location')
5796
to_location = tree_location
5797
5481
try:
5798
5482
branch = control_dir.open_branch()
5799
5483
had_explicit_nick = branch.get_config().has_explicit_nickname()
5804
5488
if branch is None:
5805
5489
raise errors.BzrCommandError('cannot create branch without'
5806
5490
' source branch')
5807
to_location = directory_service.directories.dereference(
5808
to_location)
5809
5491
if '/' not in to_location and '\\' not in to_location:
5810
5492
# This path is meant to be relative to the existing branch
5811
5493
this_url = self._get_branch_location(control_dir)
5813
5495
to_branch = branch.bzrdir.sprout(to_location,
5814
5496
possible_transports=[branch.bzrdir.root_transport],
5815
5497
source_branch=branch).open_branch()
5498
# try:
5499
# from_branch = control_dir.open_branch()
5500
# except errors.NotBranchError:
5501
# raise BzrCommandError('Cannot create a branch from this'
5502
# ' location when we cannot open this branch')
5503
# from_branch.bzrdir.sprout(
5504
pass
5816
5505
else:
5817
5506
try:
5818
5507
to_branch = Branch.open(to_location)
5820
5509
this_url = self._get_branch_location(control_dir)
5821
5510
to_branch = Branch.open(
5822
5511
urlutils.join(this_url, '..', to_location))
5823
if revision is not None:
5824
revision = revision.as_revision_id(to_branch)
5825
switch.switch(control_dir, to_branch, force, revision_id=revision)
5512
switch.switch(control_dir, to_branch, force)
5826
5513
if had_explicit_nick:
5827
5514
branch = control_dir.open_branch() #get the new branch!
5828
5515
branch.nick = to_branch.nick
5848
5535
5849
5536
5850
5537
class cmd_view(Command):
5851
__doc__ = """Manage filtered views.
5538
"""Manage filtered views.
5852
5539
5853
5540
Views provide a mask over the tree so that users can focus on
5854
5541
a subset of a tree when doing their work. After creating a view,
5934
5621
name=None,
5935
5622
switch=None,
5936
5623
):
5937
tree, file_list = WorkingTree.open_containing_paths(file_list,
5938
apply_view=False)
5624
tree, file_list = tree_files(file_list, apply_view=False)
5939
5625
current_view, view_dict = tree.views.get_view_info()
5940
5626
if name is None:
5941
5627
name = current_view
6003
5689
6004
5690
6005
5691
class cmd_hooks(Command):
6006
__doc__ = """Show hooks."""
5692
"""Show hooks."""
6007
5693
6008
5694
hidden = True
6009
5695
6022
5708
self.outf.write(" <no hooks installed>\n")
6023
5709
6024
5710
6025
class cmd_remove_branch(Command):
6026
__doc__ = """Remove a branch.
6027
6028
This will remove the branch from the specified location but
6029
will keep any working tree or repository in place.
6030
6031
:Examples:
6032
6033
Remove the branch at repo/trunk::
6034
6035
bzr remove-branch repo/trunk
6036
6037
"""
6038
6039
takes_args = ["location?"]
6040
6041
aliases = ["rmbranch"]
6042
6043
def run(self, location=None):
6044
if location is None:
6045
location = "."
6046
branch = Branch.open_containing(location)[0]
6047
branch.bzrdir.destroy_branch()
6048
6049
6050
5711
class cmd_shelve(Command):
6051
__doc__ = """Temporarily set aside some changes from the current tree.
5712
"""Temporarily set aside some changes from the current tree.
6052
5713
6053
5714
Shelve allows you to temporarily put changes you've made "on the shelf",
6054
5715
ie. out of the way, until a later time when you can bring them back from
6070
5731
6071
5732
You can put multiple items on the shelf, and by default, 'unshelve' will
6072
5733
restore the most recently shelved changes.
6073
6074
For complicated changes, it is possible to edit the changes in a separate
6075
editor program to decide what the file remaining in the working copy
6076
should look like. To do this, add the configuration option
6077
6078
change_editor = PROGRAM @new_path @old_path
6079
6080
where @new_path is replaced with the path of the new version of the
6081
file and @old_path is replaced with the path of the old version of
6082
the file. The PROGRAM should save the new file with the desired
6083
contents of the file in the working tree.
6084
6085
5734
"""
6086
5735
6087
5736
takes_args = ['file*']
6088
5737
6089
5738
takes_options = [
6090
'directory',
6091
5739
'revision',
6092
5740
Option('all', help='Shelve all changes.'),
6093
5741
'message',
6099
5747
Option('destroy',
6100
5748
help='Destroy removed changes instead of shelving them.'),
6101
5749
]
6102
_see_also = ['unshelve', 'configuration']
5750
_see_also = ['unshelve']
6103
5751
6104
5752
def run(self, revision=None, all=False, file_list=None, message=None,
6105
writer=None, list=False, destroy=False, directory=None):
5753
writer=None, list=False, destroy=False):
6106
5754
if list:
6107
return self.run_for_list(directory=directory)
5755
return self.run_for_list()
6108
5756
from bzrlib.shelf_ui import Shelver
6109
5757
if writer is None:
6110
5758
writer = bzrlib.option.diff_writer_registry.get()
6111
5759
try:
6112
5760
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6113
file_list, message, destroy=destroy, directory=directory)
5761
file_list, message, destroy=destroy)
6114
5762
try:
6115
5763
shelver.run()
6116
5764
finally:
6118
5766
except errors.UserAbort:
6119
5767
return 0
6120
5768
6121
def run_for_list(self, directory=None):
6122
if directory is None:
6123
directory = u'.'
6124
tree = WorkingTree.open_containing(directory)[0]
6125
self.add_cleanup(tree.lock_read().unlock)
6126
manager = tree.get_shelf_manager()
6127
shelves = manager.active_shelves()
6128
if len(shelves) == 0:
6129
note('No shelved changes.')
6130
return 0
6131
for shelf_id in reversed(shelves):
6132
message = manager.get_metadata(shelf_id).get('message')
6133
if message is None:
6134
message = '<no message>'
6135
self.outf.write('%3d: %s\n' % (shelf_id, message))
6136
return 1
5769
def run_for_list(self):
5770
tree = WorkingTree.open_containing('.')[0]
5771
tree.lock_read()
5772
try:
5773
manager = tree.get_shelf_manager()
5774
shelves = manager.active_shelves()
5775
if len(shelves) == 0:
5776
note('No shelved changes.')
5777
return 0
5778
for shelf_id in reversed(shelves):
5779
message = manager.get_metadata(shelf_id).get('message')
5780
if message is None:
5781
message = '<no message>'
5782
self.outf.write('%3d: %s\n' % (shelf_id, message))
5783
return 1
5784
finally:
5785
tree.unlock()
6137
5786
6138
5787
6139
5788
class cmd_unshelve(Command):
6140
__doc__ = """Restore shelved changes.
5789
"""Restore shelved changes.
6141
5790
6142
5791
By default, the most recently shelved changes are restored. However if you
6143
5792
specify a shelf by id those changes will be restored instead. This works
6146
5795
6147
5796
takes_args = ['shelf_id?']
6148
5797
takes_options = [
6149
'directory',
6150
5798
RegistryOption.from_kwargs(
6151
5799
'action', help="The action to perform.",
6152
5800
enum_switch=False, value_switches=True,
6153
5801
apply="Apply changes and remove from the shelf.",
6154
5802
dry_run="Show changes, but do not apply or remove them.",
6155
preview="Instead of unshelving the changes, show the diff that "
6156
"would result from unshelving.",
6157
5803
delete_only="Delete changes without applying them.",
6158
5804
keep="Apply changes but don't delete them.",
6159
5805
)
6160
5806
]
6161
5807
_see_also = ['shelve']
6162
5808
6163
def run(self, shelf_id=None, action='apply', directory=u'.'):
5809
def run(self, shelf_id=None, action='apply'):
6164
5810
from bzrlib.shelf_ui import Unshelver
6165
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5811
unshelver = Unshelver.from_args(shelf_id, action)
6166
5812
try:
6167
5813
unshelver.run()
6168
5814
finally:
6170
5816
6171
5817
6172
5818
class cmd_clean_tree(Command):
6173
__doc__ = """Remove unwanted files from working tree.
5819
"""Remove unwanted files from working tree.
6174
5820
6175
5821
By default, only unknown files, not ignored files, are deleted. Versioned
6176
5822
files are never deleted.
6184
5830
6185
5831
To check what clean-tree will do, use --dry-run.
6186
5832
"""
6187
takes_options = ['directory',
6188
Option('ignored', help='Delete all ignored files.'),
6189
Option('detritus', help='Delete conflict files, merge and revert'
5833
takes_options = [Option('ignored', help='Delete all ignored files.'),
5834
Option('detritus', help='Delete conflict files, merge'
6190
5835
' backups, and failed selftest dirs.'),
6191
5836
Option('unknown',
6192
5837
help='Delete files unknown to bzr (default).'),
6194
5839
' deleting them.'),
6195
5840
Option('force', help='Do not prompt before deleting.')]
6196
5841
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6197
force=False, directory=u'.'):
5842
force=False):
6198
5843
from bzrlib.clean_tree import clean_tree
6199
5844
if not (unknown or ignored or detritus):
6200
5845
unknown = True
6201
5846
if dry_run:
6202
5847
force = True
6203
clean_tree(directory, unknown=unknown, ignored=ignored,
6204
detritus=detritus, dry_run=dry_run, no_prompt=force)
5848
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5849
dry_run=dry_run, no_prompt=force)
6205
5850
6206
5851
6207
5852
class cmd_reference(Command):
6208
__doc__ = """list, view and set branch locations for nested trees.
5853
"""list, view and set branch locations for nested trees.
6209
5854
6210
5855
If no arguments are provided, lists the branch locations for nested trees.
6211
5856
If one argument is provided, display the branch location for that tree.
6251
5896
self.outf.write('%s %s\n' % (path, location))
6252
5897
6253
5898
6254
class cmd_export_pot(Command):
6255
__doc__ = """Export command helps and error messages in po format."""
6256
6257
hidden = True
6258
6259
def run(self):
6260
from bzrlib.export_pot import export_pot
6261
export_pot(self.outf)
6262
6263
6264
def _register_lazy_builtins():
6265
# register lazy builtins from other modules; called at startup and should
6266
# be only called once.
6267
for (name, aliases, module_name) in [
6268
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6269
('cmd_config', [], 'bzrlib.config'),
6270
('cmd_dpush', [], 'bzrlib.foreign'),
6271
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6272
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6273
('cmd_conflicts', [], 'bzrlib.conflicts'),
6274
('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6275
('cmd_verify_signatures', [],
6276
'bzrlib.commit_signature_commands'),
6277
('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6278
]:
6279
builtin_command_registry.register_lazy(name, aliases, module_name)
5899
# these get imported and then picked up by the scan for cmd_*
5900
# TODO: Some more consistent way to split command definitions across files;
5901
# we do need to load at least some information about them to know of
5902
# aliases. ideally we would avoid loading the implementation until the
5903
# details were needed.
5904
from bzrlib.cmd_version_info import cmd_version_info
5905
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5906
from bzrlib.bundle.commands import (
5907
cmd_bundle_info,
5908
)
5909
from bzrlib.foreign import cmd_dpush
5910
from bzrlib.sign_my_commits import cmd_sign_my_commits
5911
from bzrlib.weave_commands import cmd_versionedfile_list, \
5912
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1