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