« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 4907
- compare with another revision
- download diff
- download tarball
- view history from revision 4907
- Committer: Canonical.com Patch Queue Manager
- Date: 2009-12-18 09:05:13 UTC
- mfrom: (4505.6.30 lp-login-oauth-2)
- Revision ID: pqm@pqm.ubuntu.com-20091218090513-kzwkjw7rdf7bahqi
(jml) Add an lp-mirror command to request that Launchpad mirror a
branch now. Add an API for interacting with launchpadlib using Bazaar.
branch now. Add an API for interacting with launchpadlib using Bazaar.
- 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/news_merge
- bzrlib/plugins/news_merge/tests
- bzrlib/tests/doc_generate
- bzrlib/tests/doc_generate/builders
- bzrlib/tests/doc_generate/writers
- bzrlib/tests/per_controldir_colo
- contrib/debian
- doc/en/whats-new
- files renamed:
- 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/tests/per_controldir/ => bzrlib/tests/per_bzrdir/
- bzrlib/tests/per_controldir/test_controldir.py => bzrlib/tests/per_bzrdir/test_bzrdir.py
- bzrlib/tests/test__bencode.py => bzrlib/tests/test_bencode.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-2010 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,
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,
74
69
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
75
70
76
71
77
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
72
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
73
apply_view=True):
80
return internal_tree_files(file_list, default_branch, canonicalize,
81
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]))
82
80
83
81
84
82
def tree_files_for_add(file_list):
148
146
149
147
# XXX: Bad function name; should possibly also be a class method of
150
148
# WorkingTree rather than a function.
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
152
149
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
153
150
apply_view=True):
154
151
"""Convert command-line paths to a WorkingTree and relative paths.
155
152
156
Deprecated: use WorkingTree.open_containing_paths instead.
157
158
153
This is typically used for command-line processors that take one or
159
154
more filenames, and infer the workingtree that contains them.
160
155
170
165
171
166
:return: workingtree, [relative_paths]
172
167
"""
173
return WorkingTree.open_containing_paths(
174
file_list, default_directory='.',
175
canonicalize=True,
176
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
177
215
178
216
179
217
def _get_view_info_for_change_reporter(tree):
188
226
return view_info
189
227
190
228
191
def _open_directory_or_containing_tree_or_branch(filename, directory):
192
"""Open the tree or branch containing the specified file, unless
193
the --directory option is used to specify a different branch."""
194
if directory is not None:
195
return (None, Branch.open(directory), filename)
196
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
197
198
199
229
# TODO: Make sure no commands unconditionally use the working directory as a
200
230
# branch. If a filename argument is used, the first of them should be used to
201
231
# specify the branch. (Perhaps this can be factored out into some kind of
203
233
# opens the branch?)
204
234
205
235
class cmd_status(Command):
206
__doc__ = """Display status summary.
236
"""Display status summary.
207
237
208
238
This reports on versioned and unknown files, reporting them
209
239
grouped by state. Possible states are:
279
309
raise errors.BzrCommandError('bzr status --revision takes exactly'
280
310
' one or two revision specifiers')
281
311
282
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
312
tree, relfile_list = tree_files(file_list)
283
313
# Avoid asking for specific files when that is not needed.
284
314
if relfile_list == ['']:
285
315
relfile_list = None
296
326
297
327
298
328
class cmd_cat_revision(Command):
299
__doc__ = """Write out metadata for a revision.
329
"""Write out metadata for a revision.
300
330
301
331
The revision to print can either be specified by a specific
302
332
revision identifier, or you can use --revision.
304
334
305
335
hidden = True
306
336
takes_args = ['revision_id?']
307
takes_options = ['directory', 'revision']
337
takes_options = ['revision']
308
338
# cat-revision is more for frontends so should be exact
309
339
encoding = 'strict'
310
340
311
def print_revision(self, revisions, revid):
312
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
313
record = stream.next()
314
if record.storage_kind == 'absent':
315
raise errors.NoSuchRevision(revisions, revid)
316
revtext = record.get_bytes_as('fulltext')
317
self.outf.write(revtext.decode('utf-8'))
318
319
341
@display_command
320
def run(self, revision_id=None, revision=None, directory=u'.'):
342
def run(self, revision_id=None, revision=None):
321
343
if revision_id is not None and revision is not None:
322
344
raise errors.BzrCommandError('You can only supply one of'
323
345
' revision_id or --revision')
324
346
if revision_id is None and revision is None:
325
347
raise errors.BzrCommandError('You must supply either'
326
348
' --revision or a revision_id')
327
b = WorkingTree.open_containing(directory)[0].branch
328
329
revisions = b.repository.revisions
330
if revisions is None:
331
raise errors.BzrCommandError('Repository %r does not support '
332
'access to raw revision texts')
333
334
b.repository.lock_read()
335
try:
336
# TODO: jam 20060112 should cat-revision always output utf-8?
337
if revision_id is not None:
338
revision_id = osutils.safe_revision_id(revision_id, warn=False)
339
try:
340
self.print_revision(revisions, revision_id)
341
except errors.NoSuchRevision:
342
msg = "The repository %s contains no revision %s." % (
343
b.repository.base, revision_id)
344
raise errors.BzrCommandError(msg)
345
elif revision is not None:
346
for rev in revision:
347
if rev is None:
348
raise errors.BzrCommandError(
349
'You cannot specify a NULL revision.')
350
rev_id = rev.as_revision_id(b)
351
self.print_revision(revisions, rev_id)
352
finally:
353
b.repository.unlock()
354
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
355
368
356
369
class cmd_dump_btree(Command):
357
__doc__ = """Dump the contents of a btree index file to stdout.
370
"""Dump the contents of a btree index file to stdout.
358
371
359
372
PATH is a btree index file, it can be any URL. This includes things like
360
373
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
424
437
for node in bt.iter_all_entries():
425
438
# Node is made up of:
426
439
# (index, key, value, [references])
427
try:
428
refs = node[3]
429
except IndexError:
430
refs_as_tuples = None
431
else:
432
refs_as_tuples = static_tuple.as_tuples(refs)
440
refs_as_tuples = static_tuple.as_tuples(node[3])
433
441
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
434
442
self.outf.write('%s\n' % (as_tuple,))
435
443
436
444
437
445
class cmd_remove_tree(Command):
438
__doc__ = """Remove the working tree from a given branch/checkout.
446
"""Remove the working tree from a given branch/checkout.
439
447
440
448
Since a lightweight checkout is little more than a working tree
441
449
this will refuse to run against one.
443
451
To re-create the working tree, use "bzr checkout".
444
452
"""
445
453
_see_also = ['checkout', 'working-trees']
446
takes_args = ['location*']
454
takes_args = ['location?']
447
455
takes_options = [
448
456
Option('force',
449
457
help='Remove the working tree even if it has '
450
'uncommitted or shelved changes.'),
458
'uncommitted changes.'),
451
459
]
452
460
453
def run(self, location_list, force=False):
454
if not location_list:
455
location_list=['.']
456
457
for location in location_list:
458
d = bzrdir.BzrDir.open(location)
459
460
try:
461
working = d.open_workingtree()
462
except errors.NoWorkingTree:
463
raise errors.BzrCommandError("No working tree to remove")
464
except errors.NotLocalUrl:
465
raise errors.BzrCommandError("You cannot remove the working tree"
466
" of a remote path")
467
if not force:
468
if (working.has_changes()):
469
raise errors.UncommittedChanges(working)
470
if working.get_shelf_manager().last_shelf() is not None:
471
raise errors.ShelvedChanges(working)
472
473
if working.user_url != working.branch.user_url:
474
raise errors.BzrCommandError("You cannot remove the working tree"
475
" from a lightweight checkout")
476
477
d.destroy_workingtree()
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")
471
if not force:
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()
478
482
479
483
480
484
class cmd_revno(Command):
481
__doc__ = """Show current revision number.
485
"""Show current revision number.
482
486
483
487
This is equal to the number of revisions on this branch.
484
488
"""
494
498
if tree:
495
499
try:
496
500
wt = WorkingTree.open_containing(location)[0]
497
self.add_cleanup(wt.lock_read().unlock)
501
wt.lock_read()
498
502
except (errors.NoWorkingTree, errors.NotLocalUrl):
499
503
raise errors.NoWorkingTree(location)
500
revid = wt.last_revision()
501
504
try:
502
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
503
except errors.NoSuchRevision:
504
revno_t = ('???',)
505
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()
506
513
else:
507
514
b = Branch.open_containing(location)[0]
508
self.add_cleanup(b.lock_read().unlock)
509
revno = b.revno()
510
self.cleanup_now()
515
b.lock_read()
516
try:
517
revno = b.revno()
518
finally:
519
b.unlock()
520
511
521
self.outf.write(str(revno) + '\n')
512
522
513
523
514
524
class cmd_revision_info(Command):
515
__doc__ = """Show revision number and revision id for a given revision identifier.
525
"""Show revision number and revision id for a given revision identifier.
516
526
"""
517
527
hidden = True
518
528
takes_args = ['revision_info*']
519
529
takes_options = [
520
530
'revision',
521
custom_help('directory',
531
Option('directory',
522
532
help='Branch to examine, '
523
'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
),
524
537
Option('tree', help='Show revno of working tree'),
525
538
]
526
539
531
544
try:
532
545
wt = WorkingTree.open_containing(directory)[0]
533
546
b = wt.branch
534
self.add_cleanup(wt.lock_read().unlock)
547
wt.lock_read()
535
548
except (errors.NoWorkingTree, errors.NotLocalUrl):
536
549
wt = None
537
550
b = Branch.open_containing(directory)[0]
538
self.add_cleanup(b.lock_read().unlock)
539
revision_ids = []
540
if revision is not None:
541
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
542
if revision_info_list is not None:
543
for rev_str in revision_info_list:
544
rev_spec = RevisionSpec.from_string(rev_str)
545
revision_ids.append(rev_spec.as_revision_id(b))
546
# No arguments supplied, default to the last revision
547
if len(revision_ids) == 0:
548
if tree:
549
if wt is None:
550
raise errors.NoWorkingTree(directory)
551
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()
552
582
else:
553
revision_ids.append(b.last_revision())
554
555
revinfos = []
556
maxlen = 0
557
for revision_id in revision_ids:
558
try:
559
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
560
revno = '.'.join(str(i) for i in dotted_revno)
561
except errors.NoSuchRevision:
562
revno = '???'
563
maxlen = max(maxlen, len(revno))
564
revinfos.append([revno, revision_id])
565
566
self.cleanup_now()
583
wt.unlock()
584
567
585
for ri in revinfos:
568
586
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
569
587
570
588
571
589
class cmd_add(Command):
572
__doc__ = """Add specified files or directories.
590
"""Add specified files or directories.
573
591
574
592
In non-recursive mode, all the named items are added, regardless
575
593
of whether they were previously ignored. A warning is given if
640
658
should_print=(not is_quiet()))
641
659
642
660
if base_tree:
643
self.add_cleanup(base_tree.lock_read().unlock)
644
tree, file_list = tree_files_for_add(file_list)
645
added, ignored = tree.smart_add(file_list, not
646
no_recurse, action=action, save=not dry_run)
647
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()
648
669
if len(ignored) > 0:
649
670
if verbose:
650
671
for glob in sorted(ignored.keys()):
654
675
655
676
656
677
class cmd_mkdir(Command):
657
__doc__ = """Create a new versioned directory.
678
"""Create a new versioned directory.
658
679
659
680
This is equivalent to creating the directory and then adding it.
660
681
"""
664
685
665
686
def run(self, dir_list):
666
687
for d in dir_list:
688
os.mkdir(d)
667
689
wt, dd = WorkingTree.open_containing(d)
668
base = os.path.dirname(dd)
669
id = wt.path2id(base)
670
if id != None:
671
os.mkdir(d)
672
wt.add([dd])
673
self.outf.write('added %s\n' % d)
674
else:
675
raise errors.NotVersionedError(path=base)
690
wt.add([dd])
691
self.outf.write('added %s\n' % d)
676
692
677
693
678
694
class cmd_relpath(Command):
679
__doc__ = """Show path of a file relative to root"""
695
"""Show path of a file relative to root"""
680
696
681
697
takes_args = ['filename']
682
698
hidden = True
691
707
692
708
693
709
class cmd_inventory(Command):
694
__doc__ = """Show inventory of the current working copy or a revision.
710
"""Show inventory of the current working copy or a revision.
695
711
696
712
It is possible to limit the output to a particular entry
697
713
type using the --kind option. For example: --kind file.
717
733
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
718
734
719
735
revision = _get_one_revision('inventory', revision)
720
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
721
self.add_cleanup(work_tree.lock_read().unlock)
722
if revision is not None:
723
tree = revision.as_tree(work_tree.branch)
724
725
extra_trees = [work_tree]
726
self.add_cleanup(tree.lock_read().unlock)
727
else:
728
tree = work_tree
729
extra_trees = []
730
731
if file_list is not None:
732
file_ids = tree.paths2ids(file_list, trees=extra_trees,
733
require_versioned=True)
734
# find_ids_across_trees may include some paths that don't
735
# exist in 'tree'.
736
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
737
for file_id in file_ids if file_id in tree)
738
else:
739
entries = tree.inventory.entries()
740
741
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
742
762
for path, entry in entries:
743
763
if kind and kind != entry.kind:
744
764
continue
750
770
751
771
752
772
class cmd_mv(Command):
753
__doc__ = """Move or rename a file.
773
"""Move or rename a file.
754
774
755
775
:Usage:
756
776
bzr mv OLDNAME NEWNAME
788
808
names_list = []
789
809
if len(names_list) < 2:
790
810
raise errors.BzrCommandError("missing file argument")
791
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
792
self.add_cleanup(tree.lock_tree_write().unlock)
793
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()
794
817
795
818
def run_auto(self, names_list, after, dry_run):
796
819
if names_list is not None and len(names_list) > 1:
799
822
if after:
800
823
raise errors.BzrCommandError('--after cannot be specified with'
801
824
' --auto.')
802
work_tree, file_list = WorkingTree.open_containing_paths(
803
names_list, default_directory='.')
804
self.add_cleanup(work_tree.lock_tree_write().unlock)
805
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()
806
831
807
832
def _run(self, tree, names_list, rel_names, after):
808
833
into_existing = osutils.isdir(names_list[-1])
886
911
887
912
888
913
class cmd_pull(Command):
889
__doc__ = """Turn this branch into a mirror of another branch.
914
"""Turn this branch into a mirror of another branch.
890
915
891
916
By default, this command only works on branches that have not diverged.
892
917
Branches are considered diverged if the destination branch's most recent
915
940
takes_options = ['remember', 'overwrite', 'revision',
916
941
custom_help('verbose',
917
942
help='Show logs of pulled revisions.'),
918
custom_help('directory',
943
Option('directory',
919
944
help='Branch to pull into, '
920
'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
),
921
949
Option('local',
922
950
help="Perform a local pull in a bound "
923
951
"branch. Local pulls are not applied to "
938
966
try:
939
967
tree_to = WorkingTree.open_containing(directory)[0]
940
968
branch_to = tree_to.branch
941
self.add_cleanup(tree_to.lock_write().unlock)
942
969
except errors.NoWorkingTree:
943
970
tree_to = None
944
971
branch_to = Branch.open_containing(directory)[0]
945
self.add_cleanup(branch_to.lock_write().unlock)
946
972
947
973
if local and not branch_to.get_bound_location():
948
974
raise errors.LocalRequiresBoundBranch()
949
975
979
1005
else:
980
1006
branch_from = Branch.open(location,
981
1007
possible_transports=possible_transports)
982
self.add_cleanup(branch_from.lock_read().unlock)
983
1008
984
1009
if branch_to.get_parent() is None or remember:
985
1010
branch_to.set_parent(branch_from.base)
986
1011
987
if revision is not None:
988
revision_id = revision.as_revision_id(branch_from)
989
990
if tree_to is not None:
991
view_info = _get_view_info_for_change_reporter(tree_to)
992
change_reporter = delta._ChangeReporter(
993
unversioned_filter=tree_to.is_ignored,
994
view_info=view_info)
995
result = tree_to.pull(
996
branch_from, overwrite, revision_id, change_reporter,
997
possible_transports=possible_transports, local=local)
998
else:
999
result = branch_to.pull(
1000
branch_from, overwrite, revision_id, local=local)
1001
1002
result.report(self.outf)
1003
if verbose and result.old_revid != result.new_revid:
1004
log.show_branch_change(
1005
branch_to, self.outf, result.old_revno,
1006
result.old_revid)
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()
1007
1042
1008
1043
1009
1044
class cmd_push(Command):
1010
__doc__ = """Update a mirror of this branch.
1045
"""Update a mirror of this branch.
1011
1046
1012
1047
The target branch will not have its working tree populated because this
1013
1048
is both expensive, and is not supported on remote file systems.
1037
1072
Option('create-prefix',
1038
1073
help='Create the path leading up to the branch '
1039
1074
'if it does not already exist.'),
1040
custom_help('directory',
1075
Option('directory',
1041
1076
help='Branch to push from, '
1042
'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
),
1043
1081
Option('use-existing-dir',
1044
1082
help='By default push will fail if the target'
1045
1083
' directory exists, but does not already'
1071
1109
# Get the source branch
1072
1110
(tree, br_from,
1073
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
1074
1115
# Get the tip's revision_id
1075
1116
revision = _get_one_revision('push', revision)
1076
1117
if revision is not None:
1077
1118
revision_id = revision.in_history(br_from).rev_id
1078
1119
else:
1079
1120
revision_id = None
1080
if tree is not None and revision_id is None:
1081
tree.check_changed_or_out_of_date(
1082
strict, 'push_strict',
1083
more_error='Use --no-strict to force the push.',
1084
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
1085
1132
# Get the stacked_on branch, if any
1086
1133
if stacked_on is not None:
1087
1134
stacked_on = urlutils.normalize_url(stacked_on)
1119
1166
1120
1167
1121
1168
class cmd_branch(Command):
1122
__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.
1123
1170
1124
1171
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1125
1172
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1134
1181
1135
1182
_see_also = ['checkout']
1136
1183
takes_args = ['from_location', 'to_location?']
1137
takes_options = ['revision',
1138
Option('hardlink', help='Hard-link working tree files where possible.'),
1139
Option('files-from', type=str,
1140
help="Get file contents from this tree."),
1184
takes_options = ['revision', Option('hardlink',
1185
help='Hard-link working tree files where possible.'),
1141
1186
Option('no-tree',
1142
1187
help="Create a branch without a working-tree."),
1143
1188
Option('switch',
1154
1199
' directory exists, but does not already'
1155
1200
' have a control directory. This flag will'
1156
1201
' allow branch to proceed.'),
1157
Option('bind',
1158
help="Bind new branch to from location."),
1159
1202
]
1160
1203
aliases = ['get', 'clone']
1161
1204
1162
1205
def run(self, from_location, to_location=None, revision=None,
1163
1206
hardlink=False, stacked=False, standalone=False, no_tree=False,
1164
use_existing_dir=False, switch=False, bind=False,
1165
files_from=None):
1207
use_existing_dir=False, switch=False):
1166
1208
from bzrlib import switch as _mod_switch
1167
1209
from bzrlib.tag import _merge_tags_if_possible
1168
1210
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1169
1211
from_location)
1170
if not (hardlink or files_from):
1171
# accelerator_tree is usually slower because you have to read N
1172
# files (no readahead, lots of seeks, etc), but allow the user to
1173
# explicitly request it
1174
accelerator_tree = None
1175
if files_from is not None and files_from != from_location:
1176
accelerator_tree = WorkingTree.open(files_from)
1177
1212
revision = _get_one_revision('branch', revision)
1178
self.add_cleanup(br_from.lock_read().unlock)
1179
if revision is not None:
1180
revision_id = revision.as_revision_id(br_from)
1181
else:
1182
# FIXME - wt.last_revision, fallback to branch, fall back to
1183
# None or perhaps NULL_REVISION to mean copy nothing
1184
# RBC 20060209
1185
revision_id = br_from.last_revision()
1186
if to_location is None:
1187
to_location = urlutils.derive_to_location(from_location)
1188
to_transport = transport.get_transport(to_location)
1213
br_from.lock_read()
1189
1214
try:
1190
to_transport.mkdir('.')
1191
except errors.FileExists:
1192
if not use_existing_dir:
1193
raise errors.BzrCommandError('Target directory "%s" '
1194
'already exists.' % to_location)
1215
if revision is not None:
1216
revision_id = revision.as_revision_id(br_from)
1195
1217
else:
1196
try:
1197
bzrdir.BzrDir.open_from_transport(to_transport)
1198
except errors.NotBranchError:
1199
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)
1200
1231
else:
1201
raise errors.AlreadyBranchError(to_location)
1202
except errors.NoSuchFile:
1203
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1204
% to_location)
1205
try:
1206
# preserve whatever source format we have.
1207
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1208
possible_transports=[to_transport],
1209
accelerator_tree=accelerator_tree,
1210
hardlink=hardlink, stacked=stacked,
1211
force_new_repo=standalone,
1212
create_tree_if_local=not no_tree,
1213
source_branch=br_from)
1214
branch = dir.open_branch()
1215
except errors.NoSuchRevision:
1216
to_transport.delete_tree('.')
1217
msg = "The branch %s has no revision %s." % (from_location,
1218
revision)
1219
raise errors.BzrCommandError(msg)
1220
_merge_tags_if_possible(br_from, branch)
1221
# If the source branch is stacked, the new branch may
1222
# be stacked whether we asked for that explicitly or not.
1223
# We therefore need a try/except here and not just 'if stacked:'
1224
try:
1225
note('Created new stacked branch referring to %s.' %
1226
branch.get_stacked_on_url())
1227
except (errors.NotStacked, errors.UnstackableBranchFormat,
1228
errors.UnstackableRepositoryFormat), e:
1229
note('Branched %d revision(s).' % branch.revno())
1230
if bind:
1231
# Bind to the parent
1232
parent_branch = Branch.open(from_location)
1233
branch.bind(parent_branch)
1234
note('New branch bound to %s' % from_location)
1235
if switch:
1236
# Switch to the new branch
1237
wt, _ = WorkingTree.open_containing('.')
1238
_mod_switch.switch(wt.bzrdir, branch)
1239
note('Switched to branch: %s',
1240
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()
1241
1274
1242
1275
1243
1276
class cmd_checkout(Command):
1244
__doc__ = """Create a new checkout of an existing branch.
1277
"""Create a new checkout of an existing branch.
1245
1278
1246
1279
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1247
1280
the branch found in '.'. This is useful if you have removed the working tree
1286
1319
to_location = branch_location
1287
1320
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1288
1321
branch_location)
1289
if not (hardlink or files_from):
1290
# accelerator_tree is usually slower because you have to read N
1291
# files (no readahead, lots of seeks, etc), but allow the user to
1292
# explicitly request it
1293
accelerator_tree = None
1294
1322
revision = _get_one_revision('checkout', revision)
1295
if files_from is not None and files_from != branch_location:
1323
if files_from is not None:
1296
1324
accelerator_tree = WorkingTree.open(files_from)
1297
1325
if revision is not None:
1298
1326
revision_id = revision.as_revision_id(source)
1315
1343
1316
1344
1317
1345
class cmd_renames(Command):
1318
__doc__ = """Show list of renamed files.
1346
"""Show list of renamed files.
1319
1347
"""
1320
1348
# TODO: Option to show renames between two historical versions.
1321
1349
1326
1354
@display_command
1327
1355
def run(self, dir=u'.'):
1328
1356
tree = WorkingTree.open_containing(dir)[0]
1329
self.add_cleanup(tree.lock_read().unlock)
1330
new_inv = tree.inventory
1331
old_tree = tree.basis_tree()
1332
self.add_cleanup(old_tree.lock_read().unlock)
1333
old_inv = old_tree.inventory
1334
renames = []
1335
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1336
for f, paths, c, v, p, n, k, e in iterator:
1337
if paths[0] == paths[1]:
1338
continue
1339
if None in (paths):
1340
continue
1341
renames.append(paths)
1342
renames.sort()
1343
for old_name, new_name in renames:
1344
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()
1345
1379
1346
1380
1347
1381
class cmd_update(Command):
1348
__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.
1349
1383
1350
1384
This will perform a merge into the working tree, and may generate
1351
1385
conflicts. If you have any local changes, you will still
1353
1387
1354
1388
If you want to discard your local changes, you can just do a
1355
1389
'bzr revert' instead of 'bzr commit' after the update.
1356
1357
If the tree's branch is bound to a master branch, it will also update
1358
the branch from the master.
1359
1390
"""
1360
1391
1361
1392
_see_also = ['pull', 'working-trees', 'status-flags']
1362
1393
takes_args = ['dir?']
1363
takes_options = ['revision']
1364
1394
aliases = ['up']
1365
1395
1366
def run(self, dir='.', revision=None):
1367
if revision is not None and len(revision) != 1:
1368
raise errors.BzrCommandError(
1369
"bzr update --revision takes exactly one revision")
1396
def run(self, dir='.'):
1370
1397
tree = WorkingTree.open_containing(dir)[0]
1371
branch = tree.branch
1372
1398
possible_transports = []
1373
master = branch.get_master_branch(
1399
master = tree.branch.get_master_branch(
1374
1400
possible_transports=possible_transports)
1375
1401
if master is not None:
1402
tree.lock_write()
1376
1403
branch_location = master.base
1377
tree.lock_write()
1378
1404
else:
1405
tree.lock_tree_write()
1379
1406
branch_location = tree.branch.base
1380
tree.lock_tree_write()
1381
self.add_cleanup(tree.unlock)
1382
1407
# get rid of the final '/' and be ready for display
1383
branch_location = urlutils.unescape_for_display(
1384
branch_location.rstrip('/'),
1385
self.outf.encoding)
1386
existing_pending_merges = tree.get_parent_ids()[1:]
1387
if master is None:
1388
old_tip = None
1389
else:
1390
# may need to fetch data into a heavyweight checkout
1391
# XXX: this may take some time, maybe we should display a
1392
# message
1393
old_tip = branch.update(possible_transports)
1394
if revision is not None:
1395
revision_id = revision[0].as_revision_id(branch)
1396
else:
1397
revision_id = branch.last_revision()
1398
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1399
revno = branch.revision_id_to_dotted_revno(revision_id)
1400
note("Tree is up to date at revision %s of branch %s" %
1401
('.'.join(map(str, revno)), branch_location))
1402
return 0
1403
view_info = _get_view_info_for_change_reporter(tree)
1404
change_reporter = delta._ChangeReporter(
1405
unversioned_filter=tree.is_ignored,
1406
view_info=view_info)
1408
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1409
self.outf.encoding)
1407
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)
1408
1423
conflicts = tree.update(
1409
change_reporter,
1410
possible_transports=possible_transports,
1411
revision=revision_id,
1412
old_tip=old_tip)
1413
except errors.NoSuchRevision, e:
1414
raise errors.BzrCommandError(
1415
"branch has no revision %s\n"
1416
"bzr update --revision only works"
1417
" for a revision in the branch history"
1418
% (e.revision))
1419
revno = tree.branch.revision_id_to_dotted_revno(
1420
_mod_revision.ensure_null(tree.last_revision()))
1421
note('Updated to revision %s of branch %s' %
1422
('.'.join(map(str, revno)), branch_location))
1423
parent_ids = tree.get_parent_ids()
1424
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1425
note('Your local commits will now show as pending merges with '
1426
"'bzr status', and can be committed with 'bzr commit'.")
1427
if conflicts != 0:
1428
return 1
1429
else:
1430
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()
1431
1439
1432
1440
1433
1441
class cmd_info(Command):
1434
__doc__ = """Show information about a working tree, branch or repository.
1442
"""Show information about a working tree, branch or repository.
1435
1443
1436
1444
This command will show all known locations and formats associated to the
1437
1445
tree, branch or repository.
1475
1483
1476
1484
1477
1485
class cmd_remove(Command):
1478
__doc__ = """Remove files or directories.
1486
"""Remove files or directories.
1479
1487
1480
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1481
delete them if they can easily be recovered using revert otherwise they
1482
will be backed up (adding an extention of the form .~#~). If no options or
1483
parameters are given Bazaar will scan for files that are being tracked by
1484
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.
1485
1492
"""
1486
1493
takes_args = ['file*']
1487
1494
takes_options = ['verbose',
1489
1496
RegistryOption.from_kwargs('file-deletion-strategy',
1490
1497
'The file deletion mode to be used.',
1491
1498
title='Deletion Strategy', value_switches=True, enum_switch=False,
1492
safe='Backup changed files (default).',
1499
safe='Only delete files if they can be'
1500
' safely recovered (default).',
1493
1501
keep='Delete from bzr but leave the working copy.',
1494
1502
force='Delete all the specified files, even if they can not be '
1495
1503
'recovered and even if they are non-empty directories.')]
1498
1506
1499
1507
def run(self, file_list, verbose=False, new=False,
1500
1508
file_deletion_strategy='safe'):
1501
tree, file_list = WorkingTree.open_containing_paths(file_list)
1509
tree, file_list = tree_files(file_list)
1502
1510
1503
1511
if file_list is not None:
1504
1512
file_list = [f for f in file_list]
1505
1513
1506
self.add_cleanup(tree.lock_write().unlock)
1507
# Heuristics should probably all move into tree.remove_smart or
1508
# some such?
1509
if new:
1510
added = tree.changes_from(tree.basis_tree(),
1511
specific_files=file_list).added
1512
file_list = sorted([f[0] for f in added], reverse=True)
1513
if len(file_list) == 0:
1514
raise errors.BzrCommandError('No matching files.')
1515
elif file_list is None:
1516
# missing files show up in iter_changes(basis) as
1517
# versioned-with-no-kind.
1518
missing = []
1519
for change in tree.iter_changes(tree.basis_tree()):
1520
# Find paths in the working tree that have no kind:
1521
if change[1][1] is not None and change[6][1] is None:
1522
missing.append(change[1][1])
1523
file_list = sorted(missing, reverse=True)
1524
file_deletion_strategy = 'keep'
1525
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1526
keep_files=file_deletion_strategy=='keep',
1527
force=file_deletion_strategy=='force')
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()
1528
1539
1529
1540
1530
1541
class cmd_file_id(Command):
1531
__doc__ = """Print file_id of a particular file or directory.
1542
"""Print file_id of a particular file or directory.
1532
1543
1533
1544
The file_id is assigned when the file is first added and remains the
1534
1545
same through all revisions where the file exists, even when it is
1550
1561
1551
1562
1552
1563
class cmd_file_path(Command):
1553
__doc__ = """Print path of file_ids to a file or directory.
1564
"""Print path of file_ids to a file or directory.
1554
1565
1555
1566
This prints one line for each directory down to the target,
1556
1567
starting at the branch root.
1572
1583
1573
1584
1574
1585
class cmd_reconcile(Command):
1575
__doc__ = """Reconcile bzr metadata in a branch.
1586
"""Reconcile bzr metadata in a branch.
1576
1587
1577
1588
This can correct data mismatches that may have been caused by
1578
1589
previous ghost operations or bzr upgrades. You should only
1592
1603
1593
1604
_see_also = ['check']
1594
1605
takes_args = ['branch?']
1595
takes_options = [
1596
Option('canonicalize-chks',
1597
help='Make sure CHKs are in canonical form (repairs '
1598
'bug 522637).',
1599
hidden=True),
1600
]
1601
1606
1602
def run(self, branch=".", canonicalize_chks=False):
1607
def run(self, branch="."):
1603
1608
from bzrlib.reconcile import reconcile
1604
1609
dir = bzrdir.BzrDir.open(branch)
1605
reconcile(dir, canonicalize_chks=canonicalize_chks)
1610
reconcile(dir)
1606
1611
1607
1612
1608
1613
class cmd_revision_history(Command):
1609
__doc__ = """Display the list of revision ids on a branch."""
1614
"""Display the list of revision ids on a branch."""
1610
1615
1611
1616
_see_also = ['log']
1612
1617
takes_args = ['location?']
1622
1627
1623
1628
1624
1629
class cmd_ancestry(Command):
1625
__doc__ = """List all revisions merged into this branch."""
1630
"""List all revisions merged into this branch."""
1626
1631
1627
1632
_see_also = ['log', 'revision-history']
1628
1633
takes_args = ['location?']
1647
1652
1648
1653
1649
1654
class cmd_init(Command):
1650
__doc__ = """Make a directory into a versioned branch.
1655
"""Make a directory into a versioned branch.
1651
1656
1652
1657
Use this to create an empty branch, or before importing an
1653
1658
existing project.
1756
1761
1757
1762
1758
1763
class cmd_init_repository(Command):
1759
__doc__ = """Create a shared repository for branches to share storage space.
1764
"""Create a shared repository for branches to share storage space.
1760
1765
1761
1766
New branches created under the repository directory will store their
1762
1767
revisions in the repository, not in the branch directory. For branches
1816
1821
1817
1822
1818
1823
class cmd_diff(Command):
1819
__doc__ = """Show differences in the working tree, between revisions or branches.
1824
"""Show differences in the working tree, between revisions or branches.
1820
1825
1821
1826
If no arguments are given, all changes for the current tree are listed.
1822
1827
If files are given, only the changes in those files are listed.
1884
1889
Same as 'bzr diff' but prefix paths with old/ and new/::
1885
1890
1886
1891
bzr diff --prefix old/:new/
1887
1888
Show the differences using a custom diff program with options::
1889
1890
bzr diff --using /usr/bin/diff --diff-options -wu
1891
1892
"""
1892
1893
_see_also = ['status']
1893
1894
takes_args = ['file*']
1912
1913
help='Use this command to compare files.',
1913
1914
type=unicode,
1914
1915
),
1915
RegistryOption('format',
1916
help='Diff format to use.',
1917
lazy_registry=('bzrlib.diff', 'format_registry'),
1918
value_switches=False, title='Diff format'),
1919
1916
]
1920
1917
aliases = ['di', 'dif']
1921
1918
encoding_type = 'exact'
1922
1919
1923
1920
@display_command
1924
1921
def run(self, revision=None, file_list=None, diff_options=None,
1925
prefix=None, old=None, new=None, using=None, format=None):
1926
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1927
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
1928
1924
1929
1925
if (prefix is None) or (prefix == '0'):
1930
1926
# diff -p0 format
1944
1940
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1945
1941
' one or two revision specifiers')
1946
1942
1947
if using is not None and format is not None:
1948
raise errors.BzrCommandError('--using and --format are mutually '
1949
'exclusive.')
1950
1951
1943
(old_tree, new_tree,
1952
1944
old_branch, new_branch,
1953
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1954
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1955
# GNU diff on Windows uses ANSI encoding for filenames
1956
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)
1957
1947
return show_diff_trees(old_tree, new_tree, sys.stdout,
1958
1948
specific_files=specific_files,
1959
1949
external_diff_options=diff_options,
1960
1950
old_label=old_label, new_label=new_label,
1961
extra_trees=extra_trees,
1962
path_encoding=path_encoding,
1963
using=using,
1964
format_cls=format)
1951
extra_trees=extra_trees, using=using)
1965
1952
1966
1953
1967
1954
class cmd_deleted(Command):
1968
__doc__ = """List files deleted in the working tree.
1955
"""List files deleted in the working tree.
1969
1956
"""
1970
1957
# TODO: Show files deleted since a previous revision, or
1971
1958
# between two revisions.
1974
1961
# level of effort but possibly much less IO. (Or possibly not,
1975
1962
# if the directories are very large...)
1976
1963
_see_also = ['status', 'ls']
1977
takes_options = ['directory', 'show-ids']
1964
takes_options = ['show-ids']
1978
1965
1979
1966
@display_command
1980
def run(self, show_ids=False, directory=u'.'):
1981
tree = WorkingTree.open_containing(directory)[0]
1982
self.add_cleanup(tree.lock_read().unlock)
1983
old = tree.basis_tree()
1984
self.add_cleanup(old.lock_read().unlock)
1985
for path, ie in old.inventory.iter_entries():
1986
if not tree.has_id(ie.file_id):
1987
self.outf.write(path)
1988
if show_ids:
1989
self.outf.write(' ')
1990
self.outf.write(ie.file_id)
1991
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()
1992
1985
1993
1986
1994
1987
class cmd_modified(Command):
1995
__doc__ = """List files modified in working tree.
1988
"""List files modified in working tree.
1996
1989
"""
1997
1990
1998
1991
hidden = True
1999
1992
_see_also = ['status', 'ls']
2000
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
]
2001
1998
2002
1999
@display_command
2003
def run(self, null=False, directory=u'.'):
2004
tree = WorkingTree.open_containing(directory)[0]
2000
def run(self, null=False):
2001
tree = WorkingTree.open_containing(u'.')[0]
2005
2002
td = tree.changes_from(tree.basis_tree())
2006
2003
for path, id, kind, text_modified, meta_modified in td.modified:
2007
2004
if null:
2011
2008
2012
2009
2013
2010
class cmd_added(Command):
2014
__doc__ = """List files added in working tree.
2011
"""List files added in working tree.
2015
2012
"""
2016
2013
2017
2014
hidden = True
2018
2015
_see_also = ['status', 'ls']
2019
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
]
2020
2021
2021
2022
@display_command
2022
def run(self, null=False, directory=u'.'):
2023
wt = WorkingTree.open_containing(directory)[0]
2024
self.add_cleanup(wt.lock_read().unlock)
2025
basis = wt.basis_tree()
2026
self.add_cleanup(basis.lock_read().unlock)
2027
basis_inv = basis.inventory
2028
inv = wt.inventory
2029
for file_id in inv:
2030
if file_id in basis_inv:
2031
continue
2032
if inv.is_root(file_id) and len(basis_inv) == 0:
2033
continue
2034
path = inv.id2path(file_id)
2035
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2036
continue
2037
if null:
2038
self.outf.write(path + '\0')
2039
else:
2040
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()
2041
2048
2042
2049
2043
2050
class cmd_root(Command):
2044
__doc__ = """Show the tree root directory.
2051
"""Show the tree root directory.
2045
2052
2046
2053
The root is the nearest enclosing directory with a .bzr control
2047
2054
directory."""
2071
2078
2072
2079
2073
2080
class cmd_log(Command):
2074
__doc__ = """Show historical log for a branch or subset of a branch.
2081
"""Show historical log for a branch or subset of a branch.
2075
2082
2076
2083
log is bzr's default tool for exploring the history of a branch.
2077
2084
The branch to use is taken from the first parameter. If no parameters
2188
2195
:Tips & tricks:
2189
2196
2190
2197
GUI tools and IDEs are often better at exploring history than command
2191
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2192
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2193
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2194
<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.
2195
2205
2196
2206
You may find it useful to add the aliases below to ``bazaar.conf``::
2197
2207
2238
2248
help='Show just the specified revision.'
2239
2249
' See also "help revisionspec".'),
2240
2250
'log-format',
2241
RegistryOption('authors',
2242
'What names to list as authors - first, all or committer.',
2243
title='Authors',
2244
lazy_registry=('bzrlib.log', 'author_list_registry'),
2245
),
2246
2251
Option('levels',
2247
2252
short_name='n',
2248
2253
help='Number of levels to display - 0 for all, 1 for flat.',
2263
2268
help='Show changes made in each revision as a patch.'),
2264
2269
Option('include-merges',
2265
2270
help='Show merged revisions like --levels 0 does.'),
2266
Option('exclude-common-ancestry',
2267
help='Display only the revisions that are not part'
2268
' of both ancestries (require -rX..Y)'
2269
)
2270
2271
]
2271
2272
encoding_type = 'replace'
2272
2273
2282
2283
message=None,
2283
2284
limit=None,
2284
2285
show_diff=False,
2285
include_merges=False,
2286
authors=None,
2287
exclude_common_ancestry=False,
2288
):
2286
include_merges=False):
2289
2287
from bzrlib.log import (
2290
2288
Logger,
2291
2289
make_log_request_dict,
2292
2290
_get_info_for_log_files,
2293
2291
)
2294
2292
direction = (forward and 'forward') or 'reverse'
2295
if (exclude_common_ancestry
2296
and (revision is None or len(revision) != 2)):
2297
raise errors.BzrCommandError(
2298
'--exclude-common-ancestry requires -r with two revisions')
2299
2293
if include_merges:
2300
2294
if levels is None:
2301
2295
levels = 0
2314
2308
2315
2309
file_ids = []
2316
2310
filter_by_dir = False
2317
if file_list:
2318
# find the file ids to log and check for directory filtering
2319
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2320
revision, file_list, self.add_cleanup)
2321
for relpath, file_id, kind in file_info_list:
2322
if file_id is None:
2323
raise errors.BzrCommandError(
2324
"Path unknown at end or start of revision range: %s" %
2325
relpath)
2326
# If the relpath is the top of the tree, we log everything
2327
if relpath == '':
2328
file_ids = []
2329
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()
2330
2336
else:
2331
file_ids.append(file_id)
2332
filter_by_dir = filter_by_dir or (
2333
kind in ['directory', 'tree-reference'])
2334
else:
2335
# log everything
2336
# FIXME ? log the current subdir only RBC 20060203
2337
if revision is not None \
2338
and len(revision) > 0 and revision[0].get_branch():
2339
location = revision[0].get_branch()
2340
else:
2341
location = '.'
2342
dir, relpath = bzrdir.BzrDir.open_containing(location)
2343
b = dir.open_branch()
2344
self.add_cleanup(b.lock_read().unlock)
2345
rev1, rev2 = _get_revision_range(revision, b, self.name())
2346
2347
# Decide on the type of delta & diff filtering to use
2348
# TODO: add an --all-files option to make this configurable & consistent
2349
if not verbose:
2350
delta_type = None
2351
else:
2352
delta_type = 'full'
2353
if not show_diff:
2354
diff_type = None
2355
elif file_ids:
2356
diff_type = 'partial'
2357
else:
2358
diff_type = 'full'
2359
2360
# Build the log formatter
2361
if log_format is None:
2362
log_format = log.log_formatter_registry.get_default(b)
2363
# Make a non-encoding output to include the diffs - bug 328007
2364
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2365
lf = log_format(show_ids=show_ids, to_file=self.outf,
2366
to_exact_file=unencoded_output,
2367
show_timezone=timezone,
2368
delta_format=get_verbosity_level(),
2369
levels=levels,
2370
show_advice=levels is None,
2371
author_list_handler=authors)
2372
2373
# Choose the algorithm for doing the logging. It's annoying
2374
# having multiple code paths like this but necessary until
2375
# the underlying repository format is faster at generating
2376
# deltas or can provide everything we need from the indices.
2377
# The default algorithm - match-using-deltas - works for
2378
# multiple files and directories and is faster for small
2379
# amounts of history (200 revisions say). However, it's too
2380
# slow for logging a single file in a repository with deep
2381
# history, i.e. > 10K revisions. In the spirit of "do no
2382
# evil when adding features", we continue to use the
2383
# original algorithm - per-file-graph - for the "single
2384
# file that isn't a directory without showing a delta" case.
2385
partial_history = revision and b.repository._format.supports_chks
2386
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2387
or delta_type or partial_history)
2388
2389
# Build the LogRequest and execute it
2390
if len(file_ids) == 0:
2391
file_ids = None
2392
rqst = make_log_request_dict(
2393
direction=direction, specific_fileids=file_ids,
2394
start_revision=rev1, end_revision=rev2, limit=limit,
2395
message_search=message, delta_type=delta_type,
2396
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2397
exclude_common_ancestry=exclude_common_ancestry,
2398
)
2399
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()
2400
2396
2401
2397
2402
2398
def _get_revision_range(revisionspec_list, branch, command_name):
2420
2416
raise errors.BzrCommandError(
2421
2417
"bzr %s doesn't accept two revisions in different"
2422
2418
" branches." % command_name)
2423
if start_spec.spec is None:
2424
# Avoid loading all the history.
2425
rev1 = RevisionInfo(branch, None, None)
2426
else:
2427
rev1 = start_spec.in_history(branch)
2419
rev1 = start_spec.in_history(branch)
2428
2420
# Avoid loading all of history when we know a missing
2429
2421
# end of range means the last revision ...
2430
2422
if end_spec.spec is None:
2459
2451
2460
2452
2461
2453
class cmd_touching_revisions(Command):
2462
__doc__ = """Return revision-ids which affected a particular file.
2454
"""Return revision-ids which affected a particular file.
2463
2455
2464
2456
A more user-friendly interface is "bzr log FILE".
2465
2457
"""
2472
2464
tree, relpath = WorkingTree.open_containing(filename)
2473
2465
file_id = tree.path2id(relpath)
2474
2466
b = tree.branch
2475
self.add_cleanup(b.lock_read().unlock)
2476
touching_revs = log.find_touching_revisions(b, file_id)
2477
for revno, revision_id, what in touching_revs:
2478
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()
2479
2474
2480
2475
2481
2476
class cmd_ls(Command):
2482
__doc__ = """List files in a tree.
2477
"""List files in a tree.
2483
2478
"""
2484
2479
2485
2480
_see_also = ['status', 'cat']
2491
2486
help='Recurse into subdirectories.'),
2492
2487
Option('from-root',
2493
2488
help='Print paths relative to the root of the branch.'),
2494
Option('unknown', short_name='u',
2495
help='Print unknown files.'),
2489
Option('unknown', help='Print unknown files.'),
2496
2490
Option('versioned', help='Print versioned files.',
2497
2491
short_name='V'),
2498
Option('ignored', short_name='i',
2499
help='Print ignored files.'),
2500
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',
2501
2497
help='List entries of a particular kind: file, directory, symlink.',
2502
2498
type=unicode),
2503
'null',
2504
2499
'show-ids',
2505
'directory',
2506
2500
]
2507
2501
@display_command
2508
2502
def run(self, revision=None, verbose=False,
2509
2503
recursive=False, from_root=False,
2510
2504
unknown=False, versioned=False, ignored=False,
2511
null=False, kind=None, show_ids=False, path=None, directory=None):
2505
null=False, kind=None, show_ids=False, path=None):
2512
2506
2513
2507
if kind and kind not in ('file', 'directory', 'symlink'):
2514
2508
raise errors.BzrCommandError('invalid kind specified')
2526
2520
raise errors.BzrCommandError('cannot specify both --from-root'
2527
2521
' and PATH')
2528
2522
fs_path = path
2529
tree, branch, relpath = \
2530
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2523
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2524
fs_path)
2531
2525
2532
2526
# Calculate the prefix to use
2533
2527
prefix = None
2548
2542
view_str = views.view_display_str(view_files)
2549
2543
note("Ignoring files outside view. View is %s" % view_str)
2550
2544
2551
self.add_cleanup(tree.lock_read().unlock)
2552
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2553
from_dir=relpath, recursive=recursive):
2554
# Apply additional masking
2555
if not all and not selection[fc]:
2556
continue
2557
if kind is not None and fkind != kind:
2558
continue
2559
if apply_view:
2560
try:
2561
if relpath:
2562
fullpath = osutils.pathjoin(relpath, fp)
2563
else:
2564
fullpath = fp
2565
views.check_path_in_view(tree, fullpath)
2566
except errors.FileOutsideView:
2567
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
2568
2563
2569
# Output the entry
2570
if prefix:
2571
fp = osutils.pathjoin(prefix, fp)
2572
kindch = entry.kind_character()
2573
outstring = fp + kindch
2574
ui.ui_factory.clear_term()
2575
if verbose:
2576
outstring = '%-8s %s' % (fc, outstring)
2577
if show_ids and fid is not None:
2578
outstring = "%-50s %s" % (outstring, fid)
2579
self.outf.write(outstring + '\n')
2580
elif null:
2581
self.outf.write(fp + '\0')
2582
if show_ids:
2583
if fid is not None:
2584
self.outf.write(fid)
2585
self.outf.write('\0')
2586
self.outf.flush()
2587
else:
2588
if show_ids:
2589
if fid is not None:
2590
my_id = fid
2591
else:
2592
my_id = ''
2593
self.outf.write('%-50s %s\n' % (outstring, my_id))
2594
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)
2595
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()
2596
2593
2597
2594
2598
2595
class cmd_unknowns(Command):
2599
__doc__ = """List unknown files.
2596
"""List unknown files.
2600
2597
"""
2601
2598
2602
2599
hidden = True
2603
2600
_see_also = ['ls']
2604
takes_options = ['directory']
2605
2601
2606
2602
@display_command
2607
def run(self, directory=u'.'):
2608
for f in WorkingTree.open_containing(directory)[0].unknowns():
2603
def run(self):
2604
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2609
2605
self.outf.write(osutils.quotefn(f) + '\n')
2610
2606
2611
2607
2612
2608
class cmd_ignore(Command):
2613
__doc__ = """Ignore specified files or patterns.
2609
"""Ignore specified files or patterns.
2614
2610
2615
2611
See ``bzr help patterns`` for details on the syntax of patterns.
2616
2612
2624
2620
After adding, editing or deleting that file either indirectly by
2625
2621
using this command or directly by using an editor, be sure to commit
2626
2622
it.
2627
2628
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2629
the global ignore file can be found in the application data directory as
2630
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2631
Global ignores are not touched by this command. The global ignore file
2632
can be edited directly using an editor.
2633
2634
Patterns prefixed with '!' are exceptions to ignore patterns and take
2635
precedence over regular ignores. Such exceptions are used to specify
2636
files that should be versioned which would otherwise be ignored.
2637
2638
Patterns prefixed with '!!' act as regular ignore patterns, but have
2639
precedence over the '!' exception patterns.
2640
2623
2641
2624
Note: ignore patterns containing shell wildcards must be quoted from
2642
2625
the shell on Unix.
2646
2629
2647
2630
bzr ignore ./Makefile
2648
2631
2649
Ignore .class files in all directories...::
2632
Ignore class files in all directories::
2650
2633
2651
2634
bzr ignore "*.class"
2652
2635
2653
...but do not ignore "special.class"::
2654
2655
bzr ignore "!special.class"
2656
2657
2636
Ignore .o files under the lib directory::
2658
2637
2659
2638
bzr ignore "lib/**/*.o"
2665
2644
Ignore everything but the "debian" toplevel directory::
2666
2645
2667
2646
bzr ignore "RE:(?!debian/).*"
2668
2669
Ignore everything except the "local" toplevel directory,
2670
but always ignore "*~" autosave files, even under local/::
2671
2672
bzr ignore "*"
2673
bzr ignore "!./local"
2674
bzr ignore "!!*~"
2675
2647
"""
2676
2648
2677
2649
_see_also = ['status', 'ignored', 'patterns']
2678
2650
takes_args = ['name_pattern*']
2679
takes_options = ['directory',
2680
Option('default-rules',
2681
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.')
2682
2654
]
2683
2655
2684
def run(self, name_pattern_list=None, default_rules=None,
2685
directory=u'.'):
2656
def run(self, name_pattern_list=None, old_default_rules=None):
2686
2657
from bzrlib import ignores
2687
if default_rules is not None:
2688
# dump the default rules and exit
2689
for pattern in ignores.USER_DEFAULTS:
2690
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
2691
2662
return
2692
2663
if not name_pattern_list:
2693
2664
raise errors.BzrCommandError("ignore requires at least one "
2694
"NAME_PATTERN or --default-rules.")
2665
"NAME_PATTERN or --old-default-rules")
2695
2666
name_pattern_list = [globbing.normalize_pattern(p)
2696
2667
for p in name_pattern_list]
2697
bad_patterns = ''
2698
for p in name_pattern_list:
2699
if not globbing.Globster.is_pattern_valid(p):
2700
bad_patterns += ('\n %s' % p)
2701
if bad_patterns:
2702
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2703
ui.ui_factory.show_error(msg)
2704
raise errors.InvalidPattern('')
2705
2668
for name_pattern in name_pattern_list:
2706
2669
if (name_pattern[0] == '/' or
2707
2670
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2708
2671
raise errors.BzrCommandError(
2709
2672
"NAME_PATTERN should not be an absolute path")
2710
tree, relpath = WorkingTree.open_containing(directory)
2673
tree, relpath = WorkingTree.open_containing(u'.')
2711
2674
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2712
2675
ignored = globbing.Globster(name_pattern_list)
2713
2676
matches = []
2714
self.add_cleanup(tree.lock_read().unlock)
2677
tree.lock_read()
2715
2678
for entry in tree.list_files():
2716
2679
id = entry[3]
2717
2680
if id is not None:
2718
2681
filename = entry[0]
2719
2682
if ignored.match(filename):
2720
matches.append(filename)
2683
matches.append(filename.encode('utf-8'))
2684
tree.unlock()
2721
2685
if len(matches) > 0:
2722
self.outf.write("Warning: the following files are version controlled and"
2723
" match your ignore pattern:\n%s"
2724
"\nThese files will continue to be version controlled"
2725
" 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),)
2726
2690
2727
2691
2728
2692
class cmd_ignored(Command):
2729
__doc__ = """List ignored files and the patterns that matched them.
2693
"""List ignored files and the patterns that matched them.
2730
2694
2731
2695
List all the ignored files and the ignore pattern that caused the file to
2732
2696
be ignored.
2738
2702
2739
2703
encoding_type = 'replace'
2740
2704
_see_also = ['ignore', 'ls']
2741
takes_options = ['directory']
2742
2705
2743
2706
@display_command
2744
def run(self, directory=u'.'):
2745
tree = WorkingTree.open_containing(directory)[0]
2746
self.add_cleanup(tree.lock_read().unlock)
2747
for path, file_class, kind, file_id, entry in tree.list_files():
2748
if file_class != 'I':
2749
continue
2750
## XXX: Slightly inefficient since this was already calculated
2751
pat = tree.is_ignored(path)
2752
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()
2753
2719
2754
2720
2755
2721
class cmd_lookup_revision(Command):
2756
__doc__ = """Lookup the revision-id from a revision-number
2722
"""Lookup the revision-id from a revision-number
2757
2723
2758
2724
:Examples:
2759
2725
bzr lookup-revision 33
2760
2726
"""
2761
2727
hidden = True
2762
2728
takes_args = ['revno']
2763
takes_options = ['directory']
2764
2729
2765
2730
@display_command
2766
def run(self, revno, directory=u'.'):
2731
def run(self, revno):
2767
2732
try:
2768
2733
revno = int(revno)
2769
2734
except ValueError:
2770
raise errors.BzrCommandError("not a valid revision-number: %r"
2771
% revno)
2772
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2773
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)
2774
2738
2775
2739
2776
2740
class cmd_export(Command):
2777
__doc__ = """Export current or past revision to a destination directory or archive.
2741
"""Export current or past revision to a destination directory or archive.
2778
2742
2779
2743
If no revision is specified this exports the last committed revision.
2780
2744
2802
2766
================= =========================
2803
2767
"""
2804
2768
takes_args = ['dest', 'branch_or_subdir?']
2805
takes_options = ['directory',
2769
takes_options = [
2806
2770
Option('format',
2807
2771
help="Type of file to export to.",
2808
2772
type=unicode),
2812
2776
Option('root',
2813
2777
type=str,
2814
2778
help="Name of the root directory inside the exported file."),
2815
Option('per-file-timestamps',
2816
help='Set modification time of files to that of the last '
2817
'revision in which it was changed.'),
2818
2779
]
2819
2780
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2820
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2781
root=None, filters=False):
2821
2782
from bzrlib.export import export
2822
2783
2823
2784
if branch_or_subdir is None:
2824
tree = WorkingTree.open_containing(directory)[0]
2785
tree = WorkingTree.open_containing(u'.')[0]
2825
2786
b = tree.branch
2826
2787
subdir = None
2827
2788
else:
2830
2791
2831
2792
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2832
2793
try:
2833
export(rev_tree, dest, format, root, subdir, filtered=filters,
2834
per_file_timestamps=per_file_timestamps)
2794
export(rev_tree, dest, format, root, subdir, filtered=filters)
2835
2795
except errors.NoSuchExportFormat, e:
2836
2796
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2837
2797
2838
2798
2839
2799
class cmd_cat(Command):
2840
__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.
2841
2801
2842
2802
If no revision is nominated, the last revision is used.
2843
2803
2846
2806
"""
2847
2807
2848
2808
_see_also = ['ls']
2849
takes_options = ['directory',
2809
takes_options = [
2850
2810
Option('name-from-revision', help='The path name in the old tree.'),
2851
2811
Option('filters', help='Apply content filters to display the '
2852
2812
'convenience form.'),
2857
2817
2858
2818
@display_command
2859
2819
def run(self, filename, revision=None, name_from_revision=False,
2860
filters=False, directory=None):
2820
filters=False):
2861
2821
if revision is not None and len(revision) != 1:
2862
2822
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2863
2823
" one revision specifier")
2864
2824
tree, branch, relpath = \
2865
_open_directory_or_containing_tree_or_branch(filename, directory)
2866
self.add_cleanup(branch.lock_read().unlock)
2867
return self._run(tree, branch, relpath, filename, revision,
2868
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()
2869
2832
2870
2833
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2871
2834
filtered):
2872
2835
if tree is None:
2873
2836
tree = b.basis_tree()
2874
2837
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2875
self.add_cleanup(rev_tree.lock_read().unlock)
2876
2838
2877
2839
old_file_id = rev_tree.path2id(relpath)
2878
2840
2913
2875
chunks = content.splitlines(True)
2914
2876
content = filtered_output_bytes(chunks, filters,
2915
2877
ContentFilterContext(relpath, rev_tree))
2916
self.cleanup_now()
2917
2878
self.outf.writelines(content)
2918
2879
else:
2919
self.cleanup_now()
2920
2880
self.outf.write(content)
2921
2881
2922
2882
2923
2883
class cmd_local_time_offset(Command):
2924
__doc__ = """Show the offset in seconds from GMT to local time."""
2884
"""Show the offset in seconds from GMT to local time."""
2925
2885
hidden = True
2926
2886
@display_command
2927
2887
def run(self):
2928
self.outf.write("%s\n" % osutils.local_time_offset())
2888
print osutils.local_time_offset()
2929
2889
2930
2890
2931
2891
2932
2892
class cmd_commit(Command):
2933
__doc__ = """Commit changes into a new revision.
2893
"""Commit changes into a new revision.
2934
2894
2935
2895
An explanatory message needs to be given for each commit. This is
2936
2896
often done by using the --message option (getting the message from the
3044
3004
"the master branch until a normal commit "
3045
3005
"is performed."
3046
3006
),
3047
Option('show-diff', short_name='p',
3007
Option('show-diff',
3048
3008
help='When no message is supplied, show the diff along'
3049
3009
' with the status summary in the message editor.'),
3050
3010
]
3099
3059
3100
3060
properties = {}
3101
3061
3102
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3062
tree, selected_list = tree_files(selected_list)
3103
3063
if selected_list == ['']:
3104
3064
# workaround - commit of root of tree should be exactly the same
3105
3065
# as just default commit in that tree, and succeed even though
3130
3090
'(use --file "%(f)s" to take commit message from that file)'
3131
3091
% { 'f': message })
3132
3092
ui.ui_factory.show_warning(warning_msg)
3133
if '\r' in message:
3134
message = message.replace('\r\n', '\n')
3135
message = message.replace('\r', '\n')
3136
if file:
3137
raise errors.BzrCommandError(
3138
"please specify either --message or --file")
3139
3093
3140
3094
def get_message(commit_obj):
3141
3095
"""Callback to get commit message"""
3142
if file:
3143
f = open(file)
3144
try:
3145
my_message = f.read().decode(osutils.get_user_encoding())
3146
finally:
3147
f.close()
3148
elif message is not None:
3149
my_message = message
3150
else:
3151
# No message supplied: make one up.
3152
# text is the status of the tree
3153
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,
3154
3102
selected_list, diff=show_diff,
3155
3103
output_encoding=osutils.get_user_encoding())
3156
# start_message is the template generated from hooks
3157
# XXX: Warning - looks like hooks return unicode,
3158
# make_commit_message_template_encoded returns user encoding.
3159
# We probably want to be using edit_commit_message instead to
3160
# avoid this.
3161
3104
start_message = generate_commit_message_template(commit_obj)
3162
my_message = edit_commit_message_encoded(text,
3105
my_message = edit_commit_message_encoded(t,
3163
3106
start_message=start_message)
3164
3107
if my_message is None:
3165
3108
raise errors.BzrCommandError("please specify a commit"
3166
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()
3167
3116
if my_message == "":
3168
3117
raise errors.BzrCommandError("empty commit message specified")
3169
3118
return my_message
3179
3128
reporter=None, verbose=verbose, revprops=properties,
3180
3129
authors=author, timestamp=commit_stamp,
3181
3130
timezone=offset,
3182
exclude=tree.safe_relpath_files(exclude))
3131
exclude=safe_relpath_files(tree, exclude))
3183
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
3184
3135
raise errors.BzrCommandError("No changes to commit."
3185
3136
" Use --unchanged to commit anyhow.")
3186
3137
except ConflictsInTree:
3191
3142
raise errors.BzrCommandError("Commit refused because there are"
3192
3143
" unknown files in the working tree.")
3193
3144
except errors.BoundBranchOutOfDate, e:
3194
e.extra_help = ("\n"
3195
'To commit to master branch, run update and then commit.\n'
3196
'You can also pass --local to commit to continue working '
3197
'disconnected.')
3198
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.')
3199
3149
3200
3150
3201
3151
class cmd_check(Command):
3202
__doc__ = """Validate working tree structure, branch consistency and repository history.
3152
"""Validate working tree structure, branch consistency and repository history.
3203
3153
3204
3154
This command checks various invariants about branch and repository storage
3205
3155
to detect data corruption or bzr bugs.
3269
3219
3270
3220
3271
3221
class cmd_upgrade(Command):
3272
__doc__ = """Upgrade branch storage to current format.
3222
"""Upgrade branch storage to current format.
3273
3223
3274
3224
The check command or bzr developers may sometimes advise you to run
3275
3225
this command. When the default format has changed you may also be warned
3293
3243
3294
3244
3295
3245
class cmd_whoami(Command):
3296
__doc__ = """Show or set bzr user id.
3246
"""Show or set bzr user id.
3297
3247
3298
3248
:Examples:
3299
3249
Show the email of the current user::
3304
3254
3305
3255
bzr whoami "Frank Chu <fchu@example.com>"
3306
3256
"""
3307
takes_options = [ 'directory',
3308
Option('email',
3257
takes_options = [ Option('email',
3309
3258
help='Display email address only.'),
3310
3259
Option('branch',
3311
3260
help='Set identity for the current branch instead of '
3315
3264
encoding_type = 'replace'
3316
3265
3317
3266
@display_command
3318
def run(self, email=False, branch=False, name=None, directory=None):
3267
def run(self, email=False, branch=False, name=None):
3319
3268
if name is None:
3320
if directory is None:
3321
# use branch if we're inside one; otherwise global config
3322
try:
3323
c = Branch.open_containing(u'.')[0].get_config()
3324
except errors.NotBranchError:
3325
c = _mod_config.GlobalConfig()
3326
else:
3327
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()
3328
3274
if email:
3329
3275
self.outf.write(c.user_email() + '\n')
3330
3276
else:
3333
3279
3334
3280
# display a warning if an email address isn't included in the given name.
3335
3281
try:
3336
_mod_config.extract_email_address(name)
3282
config.extract_email_address(name)
3337
3283
except errors.NoEmailInUsername, e:
3338
3284
warning('"%s" does not seem to contain an email address. '
3339
3285
'This is allowed, but not recommended.', name)
3340
3286
3341
3287
# use global config unless --branch given
3342
3288
if branch:
3343
if directory is None:
3344
c = Branch.open_containing(u'.')[0].get_config()
3345
else:
3346
c = Branch.open(directory).get_config()
3289
c = Branch.open_containing('.')[0].get_config()
3347
3290
else:
3348
c = _mod_config.GlobalConfig()
3291
c = config.GlobalConfig()
3349
3292
c.set_user_option('email', name)
3350
3293
3351
3294
3352
3295
class cmd_nick(Command):
3353
__doc__ = """Print or set the branch nickname.
3296
"""Print or set the branch nickname.
3354
3297
3355
3298
If unset, the tree root directory name is used as the nickname.
3356
3299
To print the current nickname, execute with no argument.
3361
3304
3362
3305
_see_also = ['info']
3363
3306
takes_args = ['nickname?']
3364
takes_options = ['directory']
3365
def run(self, nickname=None, directory=u'.'):
3366
branch = Branch.open_containing(directory)[0]
3307
def run(self, nickname=None):
3308
branch = Branch.open_containing(u'.')[0]
3367
3309
if nickname is None:
3368
3310
self.printme(branch)
3369
3311
else:
3371
3313
3372
3314
@display_command
3373
3315
def printme(self, branch):
3374
self.outf.write('%s\n' % branch.nick)
3316
print branch.nick
3375
3317
3376
3318
3377
3319
class cmd_alias(Command):
3378
__doc__ = """Set/unset and display aliases.
3320
"""Set/unset and display aliases.
3379
3321
3380
3322
:Examples:
3381
3323
Show the current aliases::
3418
3360
'bzr alias --remove expects an alias to remove.')
3419
3361
# If alias is not found, print something like:
3420
3362
# unalias: foo: not found
3421
c = _mod_config.GlobalConfig()
3363
c = config.GlobalConfig()
3422
3364
c.unset_alias(alias_name)
3423
3365
3424
3366
@display_command
3425
3367
def print_aliases(self):
3426
3368
"""Print out the defined aliases in a similar format to bash."""
3427
aliases = _mod_config.GlobalConfig().get_aliases()
3369
aliases = config.GlobalConfig().get_aliases()
3428
3370
for key, value in sorted(aliases.iteritems()):
3429
3371
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3430
3372
3440
3382
3441
3383
def set_alias(self, alias_name, alias_command):
3442
3384
"""Save the alias in the global config."""
3443
c = _mod_config.GlobalConfig()
3385
c = config.GlobalConfig()
3444
3386
c.set_alias(alias_name, alias_command)
3445
3387
3446
3388
3447
3389
class cmd_selftest(Command):
3448
__doc__ = """Run internal test suite.
3390
"""Run internal test suite.
3449
3391
3450
3392
If arguments are given, they are regular expressions that say which tests
3451
3393
should run. Tests matching any expression are run, and other tests are
3495
3437
def get_transport_type(typestring):
3496
3438
"""Parse and return a transport specifier."""
3497
3439
if typestring == "sftp":
3498
from bzrlib.tests import stub_sftp
3499
return stub_sftp.SFTPAbsoluteServer
3440
from bzrlib.transport.sftp import SFTPAbsoluteServer
3441
return SFTPAbsoluteServer
3500
3442
if typestring == "memory":
3501
from bzrlib.tests import test_server
3502
return memory.MemoryServer
3443
from bzrlib.transport.memory import MemoryServer
3444
return MemoryServer
3503
3445
if typestring == "fakenfs":
3504
from bzrlib.tests import test_server
3505
return test_server.FakeNFSServer
3446
from bzrlib.transport.fakenfs import FakeNFSServer
3447
return FakeNFSServer
3506
3448
msg = "No known transport type %s. Supported types are: sftp\n" %\
3507
3449
(typestring)
3508
3450
raise errors.BzrCommandError(msg)
3519
3461
'throughout the test suite.',
3520
3462
type=get_transport_type),
3521
3463
Option('benchmark',
3522
help='Run the benchmarks rather than selftests.',
3523
hidden=True),
3464
help='Run the benchmarks rather than selftests.'),
3524
3465
Option('lsprof-timed',
3525
3466
help='Generate lsprof output for benchmarked'
3526
3467
' sections of code.'),
3527
3468
Option('lsprof-tests',
3528
3469
help='Generate lsprof output for each test.'),
3470
Option('cache-dir', type=str,
3471
help='Cache intermediate benchmark output in this '
3472
'directory.'),
3529
3473
Option('first',
3530
3474
help='Run all tests, but run specified tests first.',
3531
3475
short_name='f',
3565
3509
3566
3510
def run(self, testspecs_list=None, verbose=False, one=False,
3567
3511
transport=None, benchmark=None,
3568
lsprof_timed=None,
3512
lsprof_timed=None, cache_dir=None,
3569
3513
first=False, list_only=False,
3570
3514
randomize=None, exclude=None, strict=False,
3571
3515
load_list=None, debugflag=None, starting_with=None, subunit=False,
3572
3516
parallel=None, lsprof_tests=False):
3573
from bzrlib import tests
3574
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)
3575
3526
if testspecs_list is not None:
3576
3527
pattern = '|'.join(testspecs_list)
3577
3528
else:
3583
3534
raise errors.BzrCommandError("subunit not available. subunit "
3584
3535
"needs to be installed to use --subunit.")
3585
3536
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3586
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3587
# stdout, which would corrupt the subunit stream.
3588
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3589
# following code can be deleted when it's sufficiently deployed
3590
# -- vila/mgz 20100514
3591
if (sys.platform == "win32"
3592
and getattr(sys.stdout, 'fileno', None) is not None):
3593
import msvcrt
3594
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3595
3537
if parallel:
3596
3538
self.additional_selftest_args.setdefault(
3597
3539
'suite_decorators', []).append(parallel)
3598
3540
if benchmark:
3599
raise errors.BzrCommandError(
3600
"--benchmark is no longer supported from bzr 2.2; "
3601
"use bzr-usertest instead")
3602
test_suite_factory = None
3603
selftest_kwargs = {"verbose": verbose,
3604
"pattern": pattern,
3605
"stop_on_failure": one,
3606
"transport": transport,
3607
"test_suite_factory": test_suite_factory,
3608
"lsprof_timed": lsprof_timed,
3609
"lsprof_tests": lsprof_tests,
3610
"matching_tests_first": first,
3611
"list_only": list_only,
3612
"random_seed": randomize,
3613
"exclude_pattern": exclude,
3614
"strict": strict,
3615
"load_list": load_list,
3616
"debug_flags": debugflag,
3617
"starting_with": starting_with
3618
}
3619
selftest_kwargs.update(self.additional_selftest_args)
3620
3621
# Make deprecation warnings visible, unless -Werror is set
3622
cleanup = symbol_versioning.activate_deprecation_warnings(
3623
override=False)
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)
3546
else:
3547
test_suite_factory = None
3548
benchfile = None
3624
3549
try:
3625
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)
3626
3569
finally:
3627
cleanup()
3570
if benchfile is not None:
3571
benchfile.close()
3628
3572
return int(not result)
3629
3573
3630
3574
3631
3575
class cmd_version(Command):
3632
__doc__ = """Show version of bzr."""
3576
"""Show version of bzr."""
3633
3577
3634
3578
encoding_type = 'replace'
3635
3579
takes_options = [
3646
3590
3647
3591
3648
3592
class cmd_rocks(Command):
3649
__doc__ = """Statement of optimism."""
3593
"""Statement of optimism."""
3650
3594
3651
3595
hidden = True
3652
3596
3653
3597
@display_command
3654
3598
def run(self):
3655
self.outf.write("It sure does!\n")
3599
print "It sure does!"
3656
3600
3657
3601
3658
3602
class cmd_find_merge_base(Command):
3659
__doc__ = """Find and print a base revision for merging two branches."""
3603
"""Find and print a base revision for merging two branches."""
3660
3604
# TODO: Options to specify revisions on either side, as if
3661
3605
# merging only part of the history.
3662
3606
takes_args = ['branch', 'other']
3668
3612
3669
3613
branch1 = Branch.open_containing(branch)[0]
3670
3614
branch2 = Branch.open_containing(other)[0]
3671
self.add_cleanup(branch1.lock_read().unlock)
3672
self.add_cleanup(branch2.lock_read().unlock)
3673
last1 = ensure_null(branch1.last_revision())
3674
last2 = ensure_null(branch2.last_revision())
3675
3676
graph = branch1.repository.get_graph(branch2.repository)
3677
base_rev_id = graph.find_unique_lca(last1, last2)
3678
3679
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()
3680
3630
3681
3631
3682
3632
class cmd_merge(Command):
3683
__doc__ = """Perform a three-way merge.
3633
"""Perform a three-way merge.
3684
3634
3685
3635
The source of the merge can be specified either in the form of a branch,
3686
3636
or in the form of a path to a file containing a merge directive generated
3715
3665
committed to record the result of the merge.
3716
3666
3717
3667
merge refuses to run if there are any uncommitted changes, unless
3718
--force is given. The --force option can also be used to create a
3719
merge revision which has more than two parents.
3720
3721
If one would like to merge changes from the working tree of the other
3722
branch without merging any committed revisions, the --uncommitted option
3723
can be given.
3668
--force is given.
3724
3669
3725
3670
To select only some changes to merge, use "merge -i", which will prompt
3726
3671
you to apply each diff hunk and file change, similar to "shelve".
3741
3686
To apply a merge directive contained in /tmp/merge::
3742
3687
3743
3688
bzr merge /tmp/merge
3744
3745
To create a merge revision with three parents from two branches
3746
feature1a and feature1b:
3747
3748
bzr merge ../feature1a
3749
bzr merge ../feature1b --force
3750
bzr commit -m 'revision with three parents'
3751
3689
"""
3752
3690
3753
3691
encoding_type = 'exact'
3769
3707
' completely merged into the source, pull from the'
3770
3708
' source rather than merging. When this happens,'
3771
3709
' you do not need to commit the result.'),
3772
custom_help('directory',
3710
Option('directory',
3773
3711
help='Branch to merge into, '
3774
'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
),
3775
3716
Option('preview', help='Instead of merging, show a diff of the'
3776
3717
' merge.'),
3777
3718
Option('interactive', help='Select changes interactively.',
3808
3749
view_info = _get_view_info_for_change_reporter(tree)
3809
3750
change_reporter = delta._ChangeReporter(
3810
3751
unversioned_filter=tree.is_ignored, view_info=view_info)
3811
pb = ui.ui_factory.nested_progress_bar()
3812
self.add_cleanup(pb.finished)
3813
self.add_cleanup(tree.lock_write().unlock)
3814
if location is not None:
3815
try:
3816
mergeable = bundle.read_mergeable_from_url(location,
3817
possible_transports=possible_transports)
3818
except errors.NotABundle:
3819
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)
3820
3811
else:
3821
if uncommitted:
3822
raise errors.BzrCommandError('Cannot use --uncommitted'
3823
' with bundles or merge directives.')
3824
3825
if revision is not None:
3826
raise errors.BzrCommandError(
3827
'Cannot use -r with merge directives or bundles')
3828
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3829
mergeable, None)
3830
3831
if merger is None and uncommitted:
3832
if revision is not None and len(revision) > 0:
3833
raise errors.BzrCommandError('Cannot use --uncommitted and'
3834
' --revision at the same time.')
3835
merger = self.get_merger_from_uncommitted(tree, location, None)
3836
allow_pending = False
3837
3838
if merger is None:
3839
merger, allow_pending = self._get_merger_from_branch(tree,
3840
location, revision, remember, possible_transports, None)
3841
3842
merger.merge_type = merge_type
3843
merger.reprocess = reprocess
3844
merger.show_base = show_base
3845
self.sanity_check_merger(merger)
3846
if (merger.base_rev_id == merger.other_rev_id and
3847
merger.other_rev_id is not None):
3848
note('Nothing to do.')
3849
return 0
3850
if pull:
3851
if merger.interesting_files is not None:
3852
raise errors.BzrCommandError('Cannot pull individual files')
3853
if (merger.base_rev_id == tree.last_revision()):
3854
result = tree.pull(merger.other_branch, False,
3855
merger.other_rev_id)
3856
result.report(self.outf)
3857
return 0
3858
if merger.this_basis is None:
3859
raise errors.BzrCommandError(
3860
"This branch has no commits."
3861
" (perhaps you would prefer 'bzr pull')")
3862
if preview:
3863
return self._do_preview(merger)
3864
elif interactive:
3865
return self._do_interactive(merger)
3866
else:
3867
return self._do_merge(merger, change_reporter, allow_pending,
3868
verified)
3869
3870
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):
3871
3819
tree_merger = merger.make_merger()
3872
3820
tt = tree_merger.make_preview_transform()
3873
self.add_cleanup(tt.finalize)
3821
cleanups.append(tt.finalize)
3874
3822
result_tree = tt.get_preview_tree()
3875
3823
return result_tree
3876
3824
3877
def _do_preview(self, merger):
3825
def _do_preview(self, merger, cleanups):
3878
3826
from bzrlib.diff import show_diff_trees
3879
result_tree = self._get_preview(merger)
3880
path_encoding = osutils.get_diff_header_encoding()
3827
result_tree = self._get_preview(merger, cleanups)
3881
3828
show_diff_trees(merger.this_tree, result_tree, self.outf,
3882
old_label='', new_label='',
3883
path_encoding=path_encoding)
3829
old_label='', new_label='')
3884
3830
3885
3831
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3886
3832
merger.change_reporter = change_reporter
3894
3840
else:
3895
3841
return 0
3896
3842
3897
def _do_interactive(self, merger):
3843
def _do_interactive(self, merger, cleanups):
3898
3844
"""Perform an interactive merge.
3899
3845
3900
3846
This works by generating a preview tree of the merge, then using
3902
3848
and the preview tree.
3903
3849
"""
3904
3850
from bzrlib import shelf_ui
3905
result_tree = self._get_preview(merger)
3851
result_tree = self._get_preview(merger, cleanups)
3906
3852
writer = bzrlib.option.diff_writer_registry.get()
3907
3853
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3908
3854
reporter=shelf_ui.ApplyReporter(),
3976
3922
allow_pending = True
3977
3923
return merger, allow_pending
3978
3924
3979
def get_merger_from_uncommitted(self, tree, location, pb):
3925
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
3980
3926
"""Get a merger for uncommitted changes.
3981
3927
3982
3928
:param tree: The tree the merger should apply to.
3983
3929
:param location: The location containing uncommitted changes.
3984
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.
3985
3933
"""
3986
3934
location = self._select_branch_location(tree, location)[0]
3987
3935
other_tree, other_path = WorkingTree.open_containing(location)
4039
3987
4040
3988
4041
3989
class cmd_remerge(Command):
4042
__doc__ = """Redo a merge.
3990
"""Redo a merge.
4043
3991
4044
3992
Use this if you want to try a different merge technique while resolving
4045
3993
conflicts. Some merge techniques are better than others, and remerge
4070
4018
4071
4019
def run(self, file_list=None, merge_type=None, show_base=False,
4072
4020
reprocess=False):
4073
from bzrlib.conflicts import restore
4074
4021
if merge_type is None:
4075
4022
merge_type = _mod_merge.Merge3Merger
4076
tree, file_list = WorkingTree.open_containing_paths(file_list)
4077
self.add_cleanup(tree.lock_write().unlock)
4078
parents = tree.get_parent_ids()
4079
if len(parents) != 2:
4080
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4081
" merges. Not cherrypicking or"
4082
" multi-merges.")
4083
repository = tree.branch.repository
4084
interesting_ids = None
4085
new_conflicts = []
4086
conflicts = tree.conflicts()
4087
if file_list is not None:
4088
interesting_ids = set()
4089
for filename in file_list:
4090
file_id = tree.path2id(filename)
4091
if file_id is None:
4092
raise errors.NotVersionedError(filename)
4093
interesting_ids.add(file_id)
4094
if tree.kind(file_id) != "directory":
4095
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
4096
4044
4097
for name, ie in tree.inventory.iter_entries(file_id):
4098
interesting_ids.add(ie.file_id)
4099
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4100
else:
4101
# Remerge only supports resolving contents conflicts
4102
allowed_conflicts = ('text conflict', 'contents conflict')
4103
restore_files = [c.path for c in conflicts
4104
if c.typestring in allowed_conflicts]
4105
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4106
tree.set_conflicts(ConflictList(new_conflicts))
4107
if file_list is not None:
4108
restore_files = file_list
4109
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])
4110
4069
try:
4111
restore(tree.abspath(filename))
4112
except errors.NotConflicted:
4113
pass
4114
# Disable pending merges, because the file texts we are remerging
4115
# have not had those merges performed. If we use the wrong parents
4116
# list, we imply that the working tree text has seen and rejected
4117
# all the changes from the other tree, when in fact those changes
4118
# have not yet been seen.
4119
tree.set_parent_ids(parents[:1])
4120
try:
4121
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4122
merger.interesting_ids = interesting_ids
4123
merger.merge_type = merge_type
4124
merger.show_base = show_base
4125
merger.reprocess = reprocess
4126
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()
4127
4080
finally:
4128
tree.set_parent_ids(parents)
4081
tree.unlock()
4129
4082
if conflicts > 0:
4130
4083
return 1
4131
4084
else:
4133
4086
4134
4087
4135
4088
class cmd_revert(Command):
4136
__doc__ = """Revert files to a previous revision.
4089
"""Revert files to a previous revision.
4137
4090
4138
4091
Giving a list of files will revert only those files. Otherwise, all files
4139
4092
will be reverted. If the revision is not specified with '--revision', the
4158
4111
created as above. Directories containing unknown files will not be
4159
4112
deleted.
4160
4113
4161
The working tree contains a list of revisions that have been merged but
4162
not yet committed. These revisions will be included as additional parents
4163
of the next commit. Normally, using revert clears that list as well as
4164
reverting the files. If any files are specified, revert leaves the list
4165
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4166
.`` in the tree root to revert all files but keep the recorded merges,
4167
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
4168
4120
reverting any files.
4169
4121
4170
Using "bzr revert --forget-merges", it is possible to apply all of the
4171
changes from a branch in a single revision. To do this, perform the merge
4172
as desired. Then doing revert with the "--forget-merges" option will keep
4173
the content of the tree as it was, but it will clear the list of pending
4174
merges. The next commit will then contain all of the changes that are
4175
present in the other branch, but without any other parent revisions.
4176
Because this technique forgets where these changes originated, it may
4177
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
4178
4130
target branches.
4179
4131
"""
4180
4132
4189
4141
4190
4142
def run(self, revision=None, no_backup=False, file_list=None,
4191
4143
forget_merges=None):
4192
tree, file_list = WorkingTree.open_containing_paths(file_list)
4193
self.add_cleanup(tree.lock_tree_write().unlock)
4194
if forget_merges:
4195
tree.set_parent_ids(tree.get_parent_ids()[:1])
4196
else:
4197
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()
4198
4153
4199
4154
@staticmethod
4200
4155
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4201
4156
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4202
tree.revert(file_list, rev_tree, not no_backup, None,
4203
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()
4204
4163
4205
4164
4206
4165
class cmd_assert_fail(Command):
4207
__doc__ = """Test reporting of assertion failures"""
4166
"""Test reporting of assertion failures"""
4208
4167
# intended just for use in testing
4209
4168
4210
4169
hidden = True
4214
4173
4215
4174
4216
4175
class cmd_help(Command):
4217
__doc__ = """Show help on a command or other topic.
4176
"""Show help on a command or other topic.
4218
4177
"""
4219
4178
4220
4179
_see_also = ['topics']
4233
4192
4234
4193
4235
4194
class cmd_shell_complete(Command):
4236
__doc__ = """Show appropriate completions for context.
4195
"""Show appropriate completions for context.
4237
4196
4238
4197
For a list of all available commands, say 'bzr shell-complete'.
4239
4198
"""
4248
4207
4249
4208
4250
4209
class cmd_missing(Command):
4251
__doc__ = """Show unmerged/unpulled revisions between two branches.
4210
"""Show unmerged/unpulled revisions between two branches.
4252
4211
4253
4212
OTHER_BRANCH may be local or remote.
4254
4213
4285
4244
_see_also = ['merge', 'pull']
4286
4245
takes_args = ['other_branch?']
4287
4246
takes_options = [
4288
'directory',
4289
4247
Option('reverse', 'Reverse the order of revisions.'),
4290
4248
Option('mine-only',
4291
4249
'Display changes in the local branch only.'),
4313
4271
theirs_only=False,
4314
4272
log_format=None, long=False, short=False, line=False,
4315
4273
show_ids=False, verbose=False, this=False, other=False,
4316
include_merges=False, revision=None, my_revision=None,
4317
directory=u'.'):
4274
include_merges=False, revision=None, my_revision=None):
4318
4275
from bzrlib.missing import find_unmerged, iter_log_revisions
4319
4276
def message(s):
4320
4277
if not is_quiet():
4333
4290
elif theirs_only:
4334
4291
restrict = 'remote'
4335
4292
4336
local_branch = Branch.open_containing(directory)[0]
4337
self.add_cleanup(local_branch.lock_read().unlock)
4338
4293
local_branch = Branch.open_containing(u".")[0]
4339
4294
parent = local_branch.get_parent()
4340
4295
if other_branch is None:
4341
4296
other_branch = parent
4350
4305
remote_branch = Branch.open(other_branch)
4351
4306
if remote_branch.base == local_branch.base:
4352
4307
remote_branch = local_branch
4353
else:
4354
self.add_cleanup(remote_branch.lock_read().unlock)
4355
4308
4356
4309
local_revid_range = _revision_range_to_revid_range(
4357
4310
_get_revision_range(my_revision, local_branch,
4361
4314
_get_revision_range(revision,
4362
4315
remote_branch, self.name()))
4363
4316
4364
local_extra, remote_extra = find_unmerged(
4365
local_branch, remote_branch, restrict,
4366
backward=not reverse,
4367
include_merges=include_merges,
4368
local_revid_range=local_revid_range,
4369
remote_revid_range=remote_revid_range)
4370
4371
if log_format is None:
4372
registry = log.log_formatter_registry
4373
log_format = registry.get_default(local_branch)
4374
lf = log_format(to_file=self.outf,
4375
show_ids=show_ids,
4376
show_timezone='original')
4377
4378
status_code = 0
4379
if local_extra and not theirs_only:
4380
message("You have %d extra revision(s):\n" %
4381
len(local_extra))
4382
for revision in iter_log_revisions(local_extra,
4383
local_branch.repository,
4384
verbose):
4385
lf.log_revision(revision)
4386
printed_local = True
4387
status_code = 1
4388
else:
4389
printed_local = False
4390
4391
if remote_extra and not mine_only:
4392
if printed_local is True:
4393
message("\n\n\n")
4394
message("You are missing %d revision(s):\n" %
4395
len(remote_extra))
4396
for revision in iter_log_revisions(remote_extra,
4397
remote_branch.repository,
4398
verbose):
4399
lf.log_revision(revision)
4400
status_code = 1
4401
4402
if mine_only and not local_extra:
4403
# We checked local, and found nothing extra
4404
message('This branch is up to date.\n')
4405
elif theirs_only and not remote_extra:
4406
# We checked remote, and found nothing extra
4407
message('Other branch is up to date.\n')
4408
elif not (mine_only or theirs_only or local_extra or
4409
remote_extra):
4410
# We checked both branches, and neither one had extra
4411
# revisions
4412
message("Branches are up to date.\n")
4413
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()
4414
4374
if not status_code and parent is None and other_branch is not None:
4415
self.add_cleanup(local_branch.lock_write().unlock)
4416
# handle race conditions - a parent might be set while we run.
4417
if local_branch.get_parent() is None:
4418
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()
4419
4382
return status_code
4420
4383
4421
4384
4422
4385
class cmd_pack(Command):
4423
__doc__ = """Compress the data within a repository.
4424
4425
This operation compresses the data within a bazaar repository. As
4426
bazaar supports automatic packing of repository, this operation is
4427
normally not required to be done manually.
4428
4429
During the pack operation, bazaar takes a backup of existing repository
4430
data, i.e. pack files. This backup is eventually removed by bazaar
4431
automatically when it is safe to do so. To save disk space by removing
4432
the backed up pack files, the --clean-obsolete-packs option may be
4433
used.
4434
4435
Warning: If you use --clean-obsolete-packs and your machine crashes
4436
during or immediately after repacking, you may be left with a state
4437
where the deletion has been written to disk but the new packs have not
4438
been. In this case the repository may be unusable.
4439
"""
4386
"""Compress the data within a repository."""
4440
4387
4441
4388
_see_also = ['repositories']
4442
4389
takes_args = ['branch_or_repo?']
4443
takes_options = [
4444
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4445
]
4446
4390
4447
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4391
def run(self, branch_or_repo='.'):
4448
4392
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4449
4393
try:
4450
4394
branch = dir.open_branch()
4451
4395
repository = branch.repository
4452
4396
except errors.NotBranchError:
4453
4397
repository = dir.open_repository()
4454
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4398
repository.pack()
4455
4399
4456
4400
4457
4401
class cmd_plugins(Command):
4458
__doc__ = """List the installed plugins.
4402
"""List the installed plugins.
4459
4403
4460
4404
This command displays the list of installed plugins including
4461
4405
version of plugin and a short description of each.
4468
4412
adding new commands, providing additional network transports and
4469
4413
customizing log output.
4470
4414
4471
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
4472
for further information on plugins including where to find them and how to
4473
install them. Instructions are also provided there on how to write new
4474
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.
4475
4419
"""
4476
4420
takes_options = ['verbose']
4477
4421
4492
4436
doc = '(no description)'
4493
4437
result.append((name_ver, doc, plugin.path()))
4494
4438
for name_ver, doc, path in sorted(result):
4495
self.outf.write("%s\n" % name_ver)
4496
self.outf.write(" %s\n" % doc)
4439
print name_ver
4440
print ' ', doc
4497
4441
if verbose:
4498
self.outf.write(" %s\n" % path)
4499
self.outf.write("\n")
4442
print ' ', path
4443
print
4500
4444
4501
4445
4502
4446
class cmd_testament(Command):
4503
__doc__ = """Show testament (signing-form) of a revision."""
4447
"""Show testament (signing-form) of a revision."""
4504
4448
takes_options = [
4505
4449
'revision',
4506
4450
Option('long', help='Produce long-format testament.'),
4518
4462
b = Branch.open_containing(branch)[0]
4519
4463
else:
4520
4464
b = Branch.open(branch)
4521
self.add_cleanup(b.lock_read().unlock)
4522
if revision is None:
4523
rev_id = b.last_revision()
4524
else:
4525
rev_id = revision[0].as_revision_id(b)
4526
t = testament_class.from_revision(b.repository, rev_id)
4527
if long:
4528
sys.stdout.writelines(t.as_text_lines())
4529
else:
4530
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()
4531
4478
4532
4479
4533
4480
class cmd_annotate(Command):
4534
__doc__ = """Show the origin of each line in a file.
4481
"""Show the origin of each line in a file.
4535
4482
4536
4483
This prints out the given file with an annotation on the left side
4537
4484
indicating which revision, author and date introduced the change.
4548
4495
Option('long', help='Show commit date in annotations.'),
4549
4496
'revision',
4550
4497
'show-ids',
4551
'directory',
4552
4498
]
4553
4499
encoding_type = 'exact'
4554
4500
4555
4501
@display_command
4556
4502
def run(self, filename, all=False, long=False, revision=None,
4557
show_ids=False, directory=None):
4503
show_ids=False):
4558
4504
from bzrlib.annotate import annotate_file, annotate_file_tree
4559
4505
wt, branch, relpath = \
4560
_open_directory_or_containing_tree_or_branch(filename, directory)
4561
if wt is not None:
4562
self.add_cleanup(wt.lock_read().unlock)
4563
else:
4564
self.add_cleanup(branch.lock_read().unlock)
4565
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4566
self.add_cleanup(tree.lock_read().unlock)
4567
if wt is not None:
4568
file_id = wt.path2id(relpath)
4569
else:
4570
file_id = tree.path2id(relpath)
4571
if file_id is None:
4572
raise errors.NotVersionedError(filename)
4573
file_version = tree.inventory[file_id].revision
4574
if wt is not None and revision is None:
4575
# If there is a tree and we're not annotating historical
4576
# versions, annotate the working tree's content.
4577
annotate_file_tree(wt, file_id, self.outf, long, all,
4578
show_ids=show_ids)
4579
else:
4580
annotate_file(branch, file_version, file_id, long, all, self.outf,
4581
show_ids=show_ids)
4506
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4507
if wt is not None:
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()
4582
4533
4583
4534
4584
4535
class cmd_re_sign(Command):
4585
__doc__ = """Create a digital signature for an existing revision."""
4536
"""Create a digital signature for an existing revision."""
4586
4537
# TODO be able to replace existing ones.
4587
4538
4588
4539
hidden = True # is this right ?
4589
4540
takes_args = ['revision_id*']
4590
takes_options = ['directory', 'revision']
4541
takes_options = ['revision']
4591
4542
4592
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4543
def run(self, revision_id_list=None, revision=None):
4593
4544
if revision_id_list is not None and revision is not None:
4594
4545
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4595
4546
if revision_id_list is None and revision is None:
4596
4547
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4597
b = WorkingTree.open_containing(directory)[0].branch
4598
self.add_cleanup(b.lock_write().unlock)
4599
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()
4600
4554
4601
4555
def _run(self, b, revision_id_list, revision):
4602
4556
import bzrlib.gpg as gpg
4647
4601
4648
4602
4649
4603
class cmd_bind(Command):
4650
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4651
If no branch is supplied, rebind to the last bound location.
4604
"""Convert the current branch into a checkout of the supplied branch.
4652
4605
4653
4606
Once converted into a checkout, commits must succeed on the master branch
4654
4607
before they will be applied to the local branch.
4660
4613
4661
4614
_see_also = ['checkouts', 'unbind']
4662
4615
takes_args = ['location?']
4663
takes_options = ['directory']
4616
takes_options = []
4664
4617
4665
def run(self, location=None, directory=u'.'):
4666
b, relpath = Branch.open_containing(directory)
4618
def run(self, location=None):
4619
b, relpath = Branch.open_containing(u'.')
4667
4620
if location is None:
4668
4621
try:
4669
4622
location = b.get_old_bound_location()
4672
4625
'This format does not remember old locations.')
4673
4626
else:
4674
4627
if location is None:
4675
if b.get_bound_location() is not None:
4676
raise errors.BzrCommandError('Branch is already bound')
4677
else:
4678
raise errors.BzrCommandError('No location supplied '
4679
'and no previous location known')
4628
raise errors.BzrCommandError('No location supplied and no '
4629
'previous location known')
4680
4630
b_other = Branch.open(location)
4681
4631
try:
4682
4632
b.bind(b_other)
4688
4638
4689
4639
4690
4640
class cmd_unbind(Command):
4691
__doc__ = """Convert the current checkout into a regular branch.
4641
"""Convert the current checkout into a regular branch.
4692
4642
4693
4643
After unbinding, the local branch is considered independent and subsequent
4694
4644
commits will be local only.
4696
4646
4697
4647
_see_also = ['checkouts', 'bind']
4698
4648
takes_args = []
4699
takes_options = ['directory']
4649
takes_options = []
4700
4650
4701
def run(self, directory=u'.'):
4702
b, relpath = Branch.open_containing(directory)
4651
def run(self):
4652
b, relpath = Branch.open_containing(u'.')
4703
4653
if not b.unbind():
4704
4654
raise errors.BzrCommandError('Local branch is not bound')
4705
4655
4706
4656
4707
4657
class cmd_uncommit(Command):
4708
__doc__ = """Remove the last committed revision.
4658
"""Remove the last committed revision.
4709
4659
4710
4660
--verbose will print out what is being removed.
4711
4661
--dry-run will go through all the motions, but not actually
4751
4701
b = control.open_branch()
4752
4702
4753
4703
if tree is not None:
4754
self.add_cleanup(tree.lock_write().unlock)
4704
tree.lock_write()
4755
4705
else:
4756
self.add_cleanup(b.lock_write().unlock)
4757
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()
4758
4715
4759
4716
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4760
4717
from bzrlib.log import log_formatter, show_log
4792
4749
end_revision=last_revno)
4793
4750
4794
4751
if dry_run:
4795
self.outf.write('Dry-run, pretending to remove'
4796
' 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')
4797
4755
else:
4798
self.outf.write('The above revision(s) will be removed.\n')
4799
4800
if not force:
4801
if not ui.ui_factory.get_boolean('Are you sure'):
4802
self.outf.write('Canceled')
4803
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
4804
4762
4805
4763
mutter('Uncommitting from {%s} to {%s}',
4806
4764
last_rev_id, rev_id)
4807
4765
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4808
4766
revno=revno, local=local)
4809
self.outf.write('You can restore the old tip by running:\n'
4810
' 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)
4811
4769
4812
4770
4813
4771
class cmd_break_lock(Command):
4814
__doc__ = """Break a dead lock.
4815
4816
This command breaks a lock on a repository, branch, working directory or
4817
config file.
4772
"""Break a dead lock on a repository, branch or working directory.
4818
4773
4819
4774
CAUTION: Locks should only be broken when you are sure that the process
4820
4775
holding the lock has been stopped.
4821
4776
4822
You can get information on what locks are open via the 'bzr info
4823
[location]' command.
4777
You can get information on what locks are open via the 'bzr info' command.
4824
4778
4825
4779
:Examples:
4826
4780
bzr break-lock
4827
bzr break-lock bzr+ssh://example.com/bzr/foo
4828
bzr break-lock --conf ~/.bazaar
4829
4781
"""
4830
4831
4782
takes_args = ['location?']
4832
takes_options = [
4833
Option('config',
4834
help='LOCATION is the directory where the config lock is.'),
4835
]
4836
4783
4837
def run(self, location=None, config=False):
4784
def run(self, location=None, show=False):
4838
4785
if location is None:
4839
4786
location = u'.'
4840
if config:
4841
conf = _mod_config.LockableConfig(file_name=location)
4842
conf.break_lock()
4843
else:
4844
control, relpath = bzrdir.BzrDir.open_containing(location)
4845
try:
4846
control.break_lock()
4847
except NotImplementedError:
4848
pass
4787
control, relpath = bzrdir.BzrDir.open_containing(location)
4788
try:
4789
control.break_lock()
4790
except NotImplementedError:
4791
pass
4849
4792
4850
4793
4851
4794
class cmd_wait_until_signalled(Command):
4852
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4795
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4853
4796
4854
4797
This just prints a line to signal when it is ready, then blocks on stdin.
4855
4798
"""
4863
4806
4864
4807
4865
4808
class cmd_serve(Command):
4866
__doc__ = """Run the bzr server."""
4809
"""Run the bzr server."""
4867
4810
4868
4811
aliases = ['server']
4869
4812
4880
4823
'result in a dynamically allocated port. The default port '
4881
4824
'depends on the protocol.',
4882
4825
type=str),
4883
custom_help('directory',
4884
help='Serve contents of this directory.'),
4826
Option('directory',
4827
help='Serve contents of this directory.',
4828
type=unicode),
4885
4829
Option('allow-writes',
4886
4830
help='By default the server is a readonly server. Supplying '
4887
4831
'--allow-writes enables write access to the contents of '
4914
4858
4915
4859
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4916
4860
protocol=None):
4917
from bzrlib import transport
4861
from bzrlib.transport import get_transport, transport_server_registry
4918
4862
if directory is None:
4919
4863
directory = os.getcwd()
4920
4864
if protocol is None:
4921
protocol = transport.transport_server_registry.get()
4865
protocol = transport_server_registry.get()
4922
4866
host, port = self.get_host_and_port(port)
4923
4867
url = urlutils.local_path_to_url(directory)
4924
4868
if not allow_writes:
4925
4869
url = 'readonly+' + url
4926
t = transport.get_transport(url)
4927
protocol(t, host, port, inet)
4870
transport = get_transport(url)
4871
protocol(transport, host, port, inet)
4928
4872
4929
4873
4930
4874
class cmd_join(Command):
4931
__doc__ = """Combine a tree into its containing tree.
4875
"""Combine a tree into its containing tree.
4932
4876
4933
4877
This command requires the target tree to be in a rich-root format.
4934
4878
4974
4918
4975
4919
4976
4920
class cmd_split(Command):
4977
__doc__ = """Split a subdirectory of a tree into a separate tree.
4921
"""Split a subdirectory of a tree into a separate tree.
4978
4922
4979
4923
This command will produce a target tree in a format that supports
4980
4924
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5000
4944
5001
4945
5002
4946
class cmd_merge_directive(Command):
5003
__doc__ = """Generate a merge directive for auto-merge tools.
4947
"""Generate a merge directive for auto-merge tools.
5004
4948
5005
4949
A directive requests a merge to be performed, and also provides all the
5006
4950
information necessary to do so. This means it must either include a
5023
4967
_see_also = ['send']
5024
4968
5025
4969
takes_options = [
5026
'directory',
5027
4970
RegistryOption.from_kwargs('patch-type',
5028
4971
'The type of patch to include in the directive.',
5029
4972
title='Patch type',
5042
4985
encoding_type = 'exact'
5043
4986
5044
4987
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5045
sign=False, revision=None, mail_to=None, message=None,
5046
directory=u'.'):
4988
sign=False, revision=None, mail_to=None, message=None):
5047
4989
from bzrlib.revision import ensure_null, NULL_REVISION
5048
4990
include_patch, include_bundle = {
5049
4991
'plain': (False, False),
5050
4992
'diff': (True, False),
5051
4993
'bundle': (True, True),
5052
4994
}[patch_type]
5053
branch = Branch.open(directory)
4995
branch = Branch.open('.')
5054
4996
stored_submit_branch = branch.get_submit_branch()
5055
4997
if submit_branch is None:
5056
4998
submit_branch = stored_submit_branch
5101
5043
5102
5044
5103
5045
class cmd_send(Command):
5104
__doc__ = """Mail or create a merge-directive for submitting changes.
5046
"""Mail or create a merge-directive for submitting changes.
5105
5047
5106
5048
A merge directive provides many things needed for requesting merges:
5107
5049
5113
5055
directly from the merge directive, without retrieving data from a
5114
5056
branch.
5115
5057
5116
`bzr send` creates a compact data set that, when applied using bzr
5117
merge, has the same effect as merging from the source branch.
5118
5119
By default the merge directive is self-contained and can be applied to any
5120
branch containing submit_branch in its ancestory without needing access to
5121
the source branch.
5122
5123
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5124
revisions, but only a structured request to merge from the
5125
public_location. In that case the public_branch is needed and it must be
5126
up-to-date and accessible to the recipient. The public_branch is always
5127
included if known, so that people can check it later.
5128
5129
The submit branch defaults to the parent of the source branch, but can be
5130
overridden. Both submit branch and public branch will be remembered in
5131
branch.conf the first time they are used for a particular branch. The
5132
source branch defaults to that containing the working directory, but can
5133
be changed using --from.
5134
5135
In order to calculate those changes, bzr must analyse the submit branch.
5136
Therefore it is most efficient for the submit branch to be a local mirror.
5137
If a public location is known for the submit_branch, that location is used
5138
in the merge directive.
5139
5140
The default behaviour is to send the merge directive by mail, unless -o is
5141
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.
5142
5070
5143
5071
Mail is sent using your preferred mail program. This should be transparent
5144
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.
5145
5073
If the preferred client can't be found (or used), your editor will be used.
5146
5074
5147
5075
To use a specific mail program, set the mail_client configuration option.
5164
5092
5165
5093
The merge directives created by bzr send may be applied using bzr merge or
5166
5094
bzr pull by specifying a file containing a merge directive as the location.
5167
5168
bzr send makes extensive use of public locations to map local locations into
5169
URLs that can be used by other people. See `bzr help configuration` to
5170
set them, and use `bzr info` to display them.
5171
5095
"""
5172
5096
5173
5097
encoding_type = 'exact'
5189
5113
short_name='f',
5190
5114
type=unicode),
5191
5115
Option('output', short_name='o',
5192
help='Write merge directive to this file or directory; '
5116
help='Write merge directive to this file; '
5193
5117
'use - for stdout.',
5194
5118
type=unicode),
5195
5119
Option('strict',
5218
5142
5219
5143
5220
5144
class cmd_bundle_revisions(cmd_send):
5221
__doc__ = """Create a merge-directive for submitting changes.
5145
"""Create a merge-directive for submitting changes.
5222
5146
5223
5147
A merge directive provides many things needed for requesting merges:
5224
5148
5291
5215
5292
5216
5293
5217
class cmd_tag(Command):
5294
__doc__ = """Create, remove or modify a tag naming a revision.
5218
"""Create, remove or modify a tag naming a revision.
5295
5219
5296
5220
Tags give human-meaningful names to revisions. Commands that take a -r
5297
5221
(--revision) option can be given -rtag:X, where X is any previously
5305
5229
5306
5230
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5307
5231
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5308
5309
If no tag name is specified it will be determined through the
5310
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5311
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5312
details.
5313
5232
"""
5314
5233
5315
5234
_see_also = ['commit', 'tags']
5316
takes_args = ['tag_name?']
5235
takes_args = ['tag_name']
5317
5236
takes_options = [
5318
5237
Option('delete',
5319
5238
help='Delete this tag rather than placing it.',
5320
5239
),
5321
custom_help('directory',
5322
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
),
5323
5245
Option('force',
5324
5246
help='Replace existing tags.',
5325
5247
),
5326
5248
'revision',
5327
5249
]
5328
5250
5329
def run(self, tag_name=None,
5251
def run(self, tag_name,
5330
5252
delete=None,
5331
5253
directory='.',
5332
5254
force=None,
5333
5255
revision=None,
5334
5256
):
5335
5257
branch, relpath = Branch.open_containing(directory)
5336
self.add_cleanup(branch.lock_write().unlock)
5337
if delete:
5338
if tag_name is None:
5339
raise errors.BzrCommandError("No tag specified to delete.")
5340
branch.tags.delete_tag(tag_name)
5341
self.outf.write('Deleted tag %s.\n' % tag_name)
5342
else:
5343
if revision:
5344
if len(revision) != 1:
5345
raise errors.BzrCommandError(
5346
"Tags can only be placed on a single revision, "
5347
"not on a range")
5348
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)
5349
5263
else:
5350
revision_id = branch.last_revision()
5351
if tag_name is None:
5352
tag_name = branch.automatic_tag_name(revision_id)
5353
if tag_name is None:
5354
raise errors.BzrCommandError(
5355
"Please specify a tag name.")
5356
if (not force) and branch.tags.has_tag(tag_name):
5357
raise errors.TagAlreadyExists(tag_name)
5358
branch.tags.set_tag(tag_name, revision_id)
5359
self.outf.write('Created tag %s.\n' % 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()
5360
5278
5361
5279
5362
5280
class cmd_tags(Command):
5363
__doc__ = """List tags.
5281
"""List tags.
5364
5282
5365
5283
This command shows a table of tag names and the revisions they reference.
5366
5284
"""
5367
5285
5368
5286
_see_also = ['tag']
5369
5287
takes_options = [
5370
custom_help('directory',
5371
help='Branch whose tags should be displayed.'),
5288
Option('directory',
5289
help='Branch whose tags should be displayed.',
5290
short_name='d',
5291
type=unicode,
5292
),
5372
5293
RegistryOption.from_kwargs('sort',
5373
5294
'Sort tags by different criteria.', title='Sorting',
5374
5295
alpha='Sort tags lexicographically (default).',
5391
5312
if not tags:
5392
5313
return
5393
5314
5394
self.add_cleanup(branch.lock_read().unlock)
5395
if revision:
5396
graph = branch.repository.get_graph()
5397
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5398
revid1, revid2 = rev1.rev_id, rev2.rev_id
5399
# only show revisions between revid1 and revid2 (inclusive)
5400
tags = [(tag, revid) for tag, revid in tags if
5401
graph.is_between(revid, revid1, revid2)]
5402
if sort == 'alpha':
5403
tags.sort()
5404
elif sort == 'time':
5405
timestamps = {}
5406
for tag, revid in tags:
5407
try:
5408
revobj = branch.repository.get_revision(revid)
5409
except errors.NoSuchRevision:
5410
timestamp = sys.maxint # place them at the end
5411
else:
5412
timestamp = revobj.timestamp
5413
timestamps[revid] = timestamp
5414
tags.sort(key=lambda x: timestamps[x[1]])
5415
if not show_ids:
5416
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5417
for index, (tag, revid) in enumerate(tags):
5418
try:
5419
revno = branch.revision_id_to_dotted_revno(revid)
5420
if isinstance(revno, tuple):
5421
revno = '.'.join(map(str, revno))
5422
except errors.NoSuchRevision:
5423
# Bad tag data/merges can lead to tagged revisions
5424
# which are not in this branch. Fail gracefully ...
5425
revno = '?'
5426
tags[index] = (tag, revno)
5427
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()
5428
5351
for tag, revspec in tags:
5429
5352
self.outf.write('%-20s %s\n' % (tag, revspec))
5430
5353
5431
5354
5432
5355
class cmd_reconfigure(Command):
5433
__doc__ = """Reconfigure the type of a bzr directory.
5356
"""Reconfigure the type of a bzr directory.
5434
5357
5435
5358
A target configuration must be specified.
5436
5359
5521
5444
5522
5445
5523
5446
class cmd_switch(Command):
5524
__doc__ = """Set the branch of a checkout and update.
5447
"""Set the branch of a checkout and update.
5525
5448
5526
5449
For lightweight checkouts, this changes the branch being referenced.
5527
5450
For heavyweight checkouts, this checks that there are no local commits
5543
5466
that of the master.
5544
5467
"""
5545
5468
5546
takes_args = ['to_location?']
5547
takes_options = ['directory',
5548
Option('force',
5469
takes_args = ['to_location']
5470
takes_options = [Option('force',
5549
5471
help='Switch even if local commits will be lost.'),
5550
'revision',
5551
5472
Option('create-branch', short_name='b',
5552
5473
help='Create the target branch from this one before'
5553
5474
' switching to it.'),
5554
]
5475
]
5555
5476
5556
def run(self, to_location=None, force=False, create_branch=False,
5557
revision=None, directory=u'.'):
5477
def run(self, to_location, force=False, create_branch=False):
5558
5478
from bzrlib import switch
5559
tree_location = directory
5560
revision = _get_one_revision('switch', revision)
5479
tree_location = '.'
5561
5480
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5562
if to_location is None:
5563
if revision is None:
5564
raise errors.BzrCommandError('You must supply either a'
5565
' revision or a location')
5566
to_location = tree_location
5567
5481
try:
5568
5482
branch = control_dir.open_branch()
5569
5483
had_explicit_nick = branch.get_config().has_explicit_nickname()
5574
5488
if branch is None:
5575
5489
raise errors.BzrCommandError('cannot create branch without'
5576
5490
' source branch')
5577
to_location = directory_service.directories.dereference(
5578
to_location)
5579
5491
if '/' not in to_location and '\\' not in to_location:
5580
5492
# This path is meant to be relative to the existing branch
5581
5493
this_url = self._get_branch_location(control_dir)
5583
5495
to_branch = branch.bzrdir.sprout(to_location,
5584
5496
possible_transports=[branch.bzrdir.root_transport],
5585
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
5586
5505
else:
5587
5506
try:
5588
5507
to_branch = Branch.open(to_location)
5590
5509
this_url = self._get_branch_location(control_dir)
5591
5510
to_branch = Branch.open(
5592
5511
urlutils.join(this_url, '..', to_location))
5593
if revision is not None:
5594
revision = revision.as_revision_id(to_branch)
5595
switch.switch(control_dir, to_branch, force, revision_id=revision)
5512
switch.switch(control_dir, to_branch, force)
5596
5513
if had_explicit_nick:
5597
5514
branch = control_dir.open_branch() #get the new branch!
5598
5515
branch.nick = to_branch.nick
5618
5535
5619
5536
5620
5537
class cmd_view(Command):
5621
__doc__ = """Manage filtered views.
5538
"""Manage filtered views.
5622
5539
5623
5540
Views provide a mask over the tree so that users can focus on
5624
5541
a subset of a tree when doing their work. After creating a view,
5704
5621
name=None,
5705
5622
switch=None,
5706
5623
):
5707
tree, file_list = WorkingTree.open_containing_paths(file_list,
5708
apply_view=False)
5624
tree, file_list = tree_files(file_list, apply_view=False)
5709
5625
current_view, view_dict = tree.views.get_view_info()
5710
5626
if name is None:
5711
5627
name = current_view
5773
5689
5774
5690
5775
5691
class cmd_hooks(Command):
5776
__doc__ = """Show hooks."""
5692
"""Show hooks."""
5777
5693
5778
5694
hidden = True
5779
5695
5792
5708
self.outf.write(" <no hooks installed>\n")
5793
5709
5794
5710
5795
class cmd_remove_branch(Command):
5796
__doc__ = """Remove a branch.
5797
5798
This will remove the branch from the specified location but
5799
will keep any working tree or repository in place.
5800
5801
:Examples:
5802
5803
Remove the branch at repo/trunk::
5804
5805
bzr remove-branch repo/trunk
5806
5807
"""
5808
5809
takes_args = ["location?"]
5810
5811
aliases = ["rmbranch"]
5812
5813
def run(self, location=None):
5814
if location is None:
5815
location = "."
5816
branch = Branch.open_containing(location)[0]
5817
branch.bzrdir.destroy_branch()
5818
5819
5820
5711
class cmd_shelve(Command):
5821
__doc__ = """Temporarily set aside some changes from the current tree.
5712
"""Temporarily set aside some changes from the current tree.
5822
5713
5823
5714
Shelve allows you to temporarily put changes you've made "on the shelf",
5824
5715
ie. out of the way, until a later time when you can bring them back from
5845
5736
takes_args = ['file*']
5846
5737
5847
5738
takes_options = [
5848
'directory',
5849
5739
'revision',
5850
5740
Option('all', help='Shelve all changes.'),
5851
5741
'message',
5860
5750
_see_also = ['unshelve']
5861
5751
5862
5752
def run(self, revision=None, all=False, file_list=None, message=None,
5863
writer=None, list=False, destroy=False, directory=u'.'):
5753
writer=None, list=False, destroy=False):
5864
5754
if list:
5865
5755
return self.run_for_list()
5866
5756
from bzrlib.shelf_ui import Shelver
5868
5758
writer = bzrlib.option.diff_writer_registry.get()
5869
5759
try:
5870
5760
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5871
file_list, message, destroy=destroy, directory=directory)
5761
file_list, message, destroy=destroy)
5872
5762
try:
5873
5763
shelver.run()
5874
5764
finally:
5878
5768
5879
5769
def run_for_list(self):
5880
5770
tree = WorkingTree.open_containing('.')[0]
5881
self.add_cleanup(tree.lock_read().unlock)
5882
manager = tree.get_shelf_manager()
5883
shelves = manager.active_shelves()
5884
if len(shelves) == 0:
5885
note('No shelved changes.')
5886
return 0
5887
for shelf_id in reversed(shelves):
5888
message = manager.get_metadata(shelf_id).get('message')
5889
if message is None:
5890
message = '<no message>'
5891
self.outf.write('%3d: %s\n' % (shelf_id, message))
5892
return 1
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()
5893
5786
5894
5787
5895
5788
class cmd_unshelve(Command):
5896
__doc__ = """Restore shelved changes.
5789
"""Restore shelved changes.
5897
5790
5898
5791
By default, the most recently shelved changes are restored. However if you
5899
5792
specify a shelf by id those changes will be restored instead. This works
5902
5795
5903
5796
takes_args = ['shelf_id?']
5904
5797
takes_options = [
5905
'directory',
5906
5798
RegistryOption.from_kwargs(
5907
5799
'action', help="The action to perform.",
5908
5800
enum_switch=False, value_switches=True,
5909
5801
apply="Apply changes and remove from the shelf.",
5910
5802
dry_run="Show changes, but do not apply or remove them.",
5911
preview="Instead of unshelving the changes, show the diff that "
5912
"would result from unshelving.",
5913
5803
delete_only="Delete changes without applying them.",
5914
5804
keep="Apply changes but don't delete them.",
5915
5805
)
5916
5806
]
5917
5807
_see_also = ['shelve']
5918
5808
5919
def run(self, shelf_id=None, action='apply', directory=u'.'):
5809
def run(self, shelf_id=None, action='apply'):
5920
5810
from bzrlib.shelf_ui import Unshelver
5921
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5811
unshelver = Unshelver.from_args(shelf_id, action)
5922
5812
try:
5923
5813
unshelver.run()
5924
5814
finally:
5926
5816
5927
5817
5928
5818
class cmd_clean_tree(Command):
5929
__doc__ = """Remove unwanted files from working tree.
5819
"""Remove unwanted files from working tree.
5930
5820
5931
5821
By default, only unknown files, not ignored files, are deleted. Versioned
5932
5822
files are never deleted.
5940
5830
5941
5831
To check what clean-tree will do, use --dry-run.
5942
5832
"""
5943
takes_options = ['directory',
5944
Option('ignored', help='Delete all ignored files.'),
5833
takes_options = [Option('ignored', help='Delete all ignored files.'),
5945
5834
Option('detritus', help='Delete conflict files, merge'
5946
5835
' backups, and failed selftest dirs.'),
5947
5836
Option('unknown',
5950
5839
' deleting them.'),
5951
5840
Option('force', help='Do not prompt before deleting.')]
5952
5841
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5953
force=False, directory=u'.'):
5842
force=False):
5954
5843
from bzrlib.clean_tree import clean_tree
5955
5844
if not (unknown or ignored or detritus):
5956
5845
unknown = True
5957
5846
if dry_run:
5958
5847
force = True
5959
clean_tree(directory, unknown=unknown, ignored=ignored,
5960
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)
5961
5850
5962
5851
5963
5852
class cmd_reference(Command):
5964
__doc__ = """list, view and set branch locations for nested trees.
5853
"""list, view and set branch locations for nested trees.
5965
5854
5966
5855
If no arguments are provided, lists the branch locations for nested trees.
5967
5856
If one argument is provided, display the branch location for that tree.
6007
5896
self.outf.write('%s %s\n' % (path, location))
6008
5897
6009
5898
6010
def _register_lazy_builtins():
6011
# register lazy builtins from other modules; called at startup and should
6012
# be only called once.
6013
for (name, aliases, module_name) in [
6014
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6015
('cmd_dpush', [], 'bzrlib.foreign'),
6016
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6017
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6018
('cmd_conflicts', [], 'bzrlib.conflicts'),
6019
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6020
]:
6021
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