« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 4726
- compare with another revision
- download diff
- download tarball
- view history from revision 4726
- Committer: Canonical.com Patch Queue Manager
- Date: 2009-10-05 15:41:35 UTC
- mfrom: (4725.2.1 integration)
- Revision ID: pqm@pqm.ubuntu.com-20091005154135-k407ea8ssyhayv10
(vila) Disambiguate per_transport test IDs
- 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(working.basis_tree())
465
or len(working.get_parent_ids()) > 1):
466
raise errors.UncommittedChanges(working)
467
468
working_path = working.bzrdir.root_transport.base
469
branch_path = working.branch.bzrdir.root_transport.base
470
if working_path != branch_path:
471
raise errors.BzrCommandError("You cannot remove the working tree"
472
" from a lightweight checkout")
473
474
d.destroy_workingtree()
548
475
549
476
550
477
class cmd_revno(Command):
551
__doc__ = """Show current revision number.
478
"""Show current revision number.
552
479
553
480
This is equal to the number of revisions on this branch.
554
481
"""
564
491
if tree:
565
492
try:
566
493
wt = WorkingTree.open_containing(location)[0]
567
self.add_cleanup(wt.lock_read().unlock)
494
wt.lock_read()
568
495
except (errors.NoWorkingTree, errors.NotLocalUrl):
569
496
raise errors.NoWorkingTree(location)
570
revid = wt.last_revision()
571
497
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)
498
revid = wt.last_revision()
499
try:
500
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
501
except errors.NoSuchRevision:
502
revno_t = ('???',)
503
revno = ".".join(str(n) for n in revno_t)
504
finally:
505
wt.unlock()
576
506
else:
577
507
b = Branch.open_containing(location)[0]
578
self.add_cleanup(b.lock_read().unlock)
579
revno = b.revno()
580
self.cleanup_now()
508
b.lock_read()
509
try:
510
revno = b.revno()
511
finally:
512
b.unlock()
513
581
514
self.outf.write(str(revno) + '\n')
582
515
583
516
584
517
class cmd_revision_info(Command):
585
__doc__ = """Show revision number and revision id for a given revision identifier.
518
"""Show revision number and revision id for a given revision identifier.
586
519
"""
587
520
hidden = True
588
521
takes_args = ['revision_info*']
589
522
takes_options = [
590
523
'revision',
591
custom_help('directory',
524
Option('directory',
592
525
help='Branch to examine, '
593
'rather than the one containing the working directory.'),
526
'rather than the one containing the working directory.',
527
short_name='d',
528
type=unicode,
529
),
594
530
Option('tree', help='Show revno of working tree'),
595
531
]
596
532
601
537
try:
602
538
wt = WorkingTree.open_containing(directory)[0]
603
539
b = wt.branch
604
self.add_cleanup(wt.lock_read().unlock)
540
wt.lock_read()
605
541
except (errors.NoWorkingTree, errors.NotLocalUrl):
606
542
wt = None
607
543
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())
544
b.lock_read()
545
try:
546
revision_ids = []
547
if revision is not None:
548
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
549
if revision_info_list is not None:
550
for rev_str in revision_info_list:
551
rev_spec = RevisionSpec.from_string(rev_str)
552
revision_ids.append(rev_spec.as_revision_id(b))
553
# No arguments supplied, default to the last revision
554
if len(revision_ids) == 0:
555
if tree:
556
if wt is None:
557
raise errors.NoWorkingTree(directory)
558
revision_ids.append(wt.last_revision())
559
else:
560
revision_ids.append(b.last_revision())
561
562
revinfos = []
563
maxlen = 0
564
for revision_id in revision_ids:
565
try:
566
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
567
revno = '.'.join(str(i) for i in dotted_revno)
568
except errors.NoSuchRevision:
569
revno = '???'
570
maxlen = max(maxlen, len(revno))
571
revinfos.append([revno, revision_id])
572
finally:
573
if wt is None:
574
b.unlock()
622
575
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()
576
wt.unlock()
577
637
578
for ri in revinfos:
638
579
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
639
580
640
581
641
582
class cmd_add(Command):
642
__doc__ = """Add specified files or directories.
583
"""Add specified files or directories.
643
584
644
585
In non-recursive mode, all the named items are added, regardless
645
586
of whether they were previously ignored. A warning is given if
710
651
should_print=(not is_quiet()))
711
652
712
653
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()
654
base_tree.lock_read()
655
try:
656
file_list = self._maybe_expand_globs(file_list)
657
tree, file_list = tree_files_for_add(file_list)
658
added, ignored = tree.smart_add(file_list, not
659
no_recurse, action=action, save=not dry_run)
660
finally:
661
if base_tree is not None:
662
base_tree.unlock()
718
663
if len(ignored) > 0:
719
664
if verbose:
720
665
for glob in sorted(ignored.keys()):
724
669
725
670
726
671
class cmd_mkdir(Command):
727
__doc__ = """Create a new versioned directory.
672
"""Create a new versioned directory.
728
673
729
674
This is equivalent to creating the directory and then adding it.
730
675
"""
734
679
735
680
def run(self, dir_list):
736
681
for d in dir_list:
682
os.mkdir(d)
737
683
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)
684
wt.add([dd])
685
self.outf.write('added %s\n' % d)
746
686
747
687
748
688
class cmd_relpath(Command):
749
__doc__ = """Show path of a file relative to root"""
689
"""Show path of a file relative to root"""
750
690
751
691
takes_args = ['filename']
752
692
hidden = True
761
701
762
702
763
703
class cmd_inventory(Command):
764
__doc__ = """Show inventory of the current working copy or a revision.
704
"""Show inventory of the current working copy or a revision.
765
705
766
706
It is possible to limit the output to a particular entry
767
707
type using the --kind option. For example: --kind file.
787
727
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
788
728
789
729
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()
730
work_tree, file_list = tree_files(file_list)
731
work_tree.lock_read()
732
try:
733
if revision is not None:
734
tree = revision.as_tree(work_tree.branch)
735
736
extra_trees = [work_tree]
737
tree.lock_read()
738
else:
739
tree = work_tree
740
extra_trees = []
741
742
if file_list is not None:
743
file_ids = tree.paths2ids(file_list, trees=extra_trees,
744
require_versioned=True)
745
# find_ids_across_trees may include some paths that don't
746
# exist in 'tree'.
747
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
748
for file_id in file_ids if file_id in tree)
749
else:
750
entries = tree.inventory.entries()
751
finally:
752
tree.unlock()
753
if tree is not work_tree:
754
work_tree.unlock()
755
813
756
for path, entry in entries:
814
757
if kind and kind != entry.kind:
815
758
continue
821
764
822
765
823
766
class cmd_mv(Command):
824
__doc__ = """Move or rename a file.
767
"""Move or rename a file.
825
768
826
769
:Usage:
827
770
bzr mv OLDNAME NEWNAME
859
802
names_list = []
860
803
if len(names_list) < 2:
861
804
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)
805
tree, rel_names = tree_files(names_list, canonicalize=False)
806
tree.lock_tree_write()
807
try:
808
self._run(tree, names_list, rel_names, after)
809
finally:
810
tree.unlock()
865
811
866
812
def run_auto(self, names_list, after, dry_run):
867
813
if names_list is not None and len(names_list) > 1:
870
816
if after:
871
817
raise errors.BzrCommandError('--after cannot be specified with'
872
818
' --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)
819
work_tree, file_list = tree_files(names_list, default_branch='.')
820
work_tree.lock_tree_write()
821
try:
822
rename_map.RenameMap.guess_renames(work_tree, dry_run)
823
finally:
824
work_tree.unlock()
877
825
878
826
def _run(self, tree, names_list, rel_names, after):
879
827
into_existing = osutils.isdir(names_list[-1])
900
848
# All entries reference existing inventory items, so fix them up
901
849
# for cicp file-systems.
902
850
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))
851
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
852
self.outf.write("%s => %s\n" % pair)
906
853
else:
907
854
if len(names_list) != 2:
908
855
raise errors.BzrCommandError('to mv multiple files the'
952
899
dest = osutils.pathjoin(dest_parent, dest_tail)
953
900
mutter("attempting to move %s => %s", src, dest)
954
901
tree.rename_one(src, dest, after=after)
955
if not is_quiet():
956
self.outf.write("%s => %s\n" % (src, dest))
902
self.outf.write("%s => %s\n" % (src, dest))
957
903
958
904
959
905
class cmd_pull(Command):
960
__doc__ = """Turn this branch into a mirror of another branch.
906
"""Turn this branch into a mirror of another branch.
961
907
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.
908
This command only works on branches that have not diverged. Branches are
909
considered diverged if the destination branch's most recent commit is one
910
that has not been merged (directly or indirectly) into the parent.
966
911
967
912
If branches have diverged, you can use 'bzr merge' to integrate the changes
968
913
from one into the other. Once one branch has merged, the other should
969
914
be able to pull it again.
970
915
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.
916
If you want to forget your local changes and just update your branch to
917
match the remote one, use pull --overwrite.
974
918
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.
919
If there is no default location set, the first pull will set it. After
920
that, you can omit the location to use the default. To change the
921
default, use --remember. The value will only be saved if the remote
922
location can be accessed.
979
923
980
924
Note: The location can be specified either in the form of a branch,
981
925
or in the form of a path to a file containing a merge directive generated
986
930
takes_options = ['remember', 'overwrite', 'revision',
987
931
custom_help('verbose',
988
932
help='Show logs of pulled revisions.'),
989
custom_help('directory',
933
Option('directory',
990
934
help='Branch to pull into, '
991
'rather than the one containing the working directory.'),
935
'rather than the one containing the working directory.',
936
short_name='d',
937
type=unicode,
938
),
992
939
Option('local',
993
940
help="Perform a local pull in a bound "
994
941
"branch. Local pulls are not applied to "
995
942
"the master branch."
996
943
),
997
Option('show-base',
998
help="Show base revision text in conflicts.")
999
944
]
1000
945
takes_args = ['location?']
1001
946
encoding_type = 'replace'
1002
947
1003
def run(self, location=None, remember=None, overwrite=False,
948
def run(self, location=None, remember=False, overwrite=False,
1004
949
revision=None, verbose=False,
1005
directory=None, local=False,
1006
show_base=False):
950
directory=None, local=False):
1007
951
# FIXME: too much stuff is in the command class
1008
952
revision_id = None
1009
953
mergeable = None
1012
956
try:
1013
957
tree_to = WorkingTree.open_containing(directory)[0]
1014
958
branch_to = tree_to.branch
1015
self.add_cleanup(tree_to.lock_write().unlock)
1016
959
except errors.NoWorkingTree:
1017
960
tree_to = None
1018
961
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
962
1024
963
if local and not branch_to.get_bound_location():
1025
964
raise errors.LocalRequiresBoundBranch()
1026
965
1056
995
else:
1057
996
branch_from = Branch.open(location,
1058
997
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)):
998
999
if branch_to.get_parent() is None or remember:
1063
1000
branch_to.set_parent(branch_from.base)
1064
1001
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
1002
if branch_from is not branch_to:
1003
branch_from.lock_read()
1004
try:
1005
if revision is not None:
1006
revision_id = revision.as_revision_id(branch_from)
1007
1008
branch_to.lock_write()
1009
try:
1010
if tree_to is not None:
1011
view_info = _get_view_info_for_change_reporter(tree_to)
1012
change_reporter = delta._ChangeReporter(
1013
unversioned_filter=tree_to.is_ignored,
1014
view_info=view_info)
1015
result = tree_to.pull(
1016
branch_from, overwrite, revision_id, change_reporter,
1017
possible_transports=possible_transports, local=local)
1018
else:
1019
result = branch_to.pull(
1020
branch_from, overwrite, revision_id, local=local)
1021
1022
result.report(self.outf)
1023
if verbose and result.old_revid != result.new_revid:
1024
log.show_branch_change(
1025
branch_to, self.outf, result.old_revno,
1026
result.old_revid)
1027
finally:
1028
branch_to.unlock()
1029
finally:
1030
if branch_from is not branch_to:
1031
branch_from.unlock()
1090
1032
1091
1033
1092
1034
class cmd_push(Command):
1093
__doc__ = """Update a mirror of this branch.
1035
"""Update a mirror of this branch.
1094
1036
1095
1037
The target branch will not have its working tree populated because this
1096
1038
is both expensive, and is not supported on remote file systems.
1109
1051
do a merge (see bzr help merge) from the other branch, and commit that.
1110
1052
After that you will be able to do a push without '--overwrite'.
1111
1053
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.
1054
If there is no default push location set, the first push will set it.
1055
After that, you can omit the location to use the default. To change the
1056
default, use --remember. The value will only be saved if the remote
1057
location can be accessed.
1116
1058
"""
1117
1059
1118
1060
_see_also = ['pull', 'update', 'working-trees']
1120
1062
Option('create-prefix',
1121
1063
help='Create the path leading up to the branch '
1122
1064
'if it does not already exist.'),
1123
custom_help('directory',
1065
Option('directory',
1124
1066
help='Branch to push from, '
1125
'rather than the one containing the working directory.'),
1067
'rather than the one containing the working directory.',
1068
short_name='d',
1069
type=unicode,
1070
),
1126
1071
Option('use-existing-dir',
1127
1072
help='By default push will fail if the target'
1128
1073
' directory exists, but does not already'
1139
1084
Option('strict',
1140
1085
help='Refuse to push if there are uncommitted changes in'
1141
1086
' 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
1087
]
1146
1088
takes_args = ['location?']
1147
1089
encoding_type = 'replace'
1148
1090
1149
def run(self, location=None, remember=None, overwrite=False,
1091
def run(self, location=None, remember=False, overwrite=False,
1150
1092
create_prefix=False, verbose=False, revision=None,
1151
1093
use_existing_dir=False, directory=None, stacked_on=None,
1152
stacked=False, strict=None, no_tree=False):
1094
stacked=False, strict=None):
1153
1095
from bzrlib.push import _show_push_branch
1154
1096
1155
1097
if directory is None:
1157
1099
# Get the source branch
1158
1100
(tree, br_from,
1159
1101
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1102
if strict is None:
1103
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1104
if strict is None: strict = True # default value
1160
1105
# Get the tip's revision_id
1161
1106
revision = _get_one_revision('push', revision)
1162
1107
if revision is not None:
1163
1108
revision_id = revision.in_history(br_from).rev_id
1164
1109
else:
1165
1110
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.')
1111
if strict and tree is not None and revision_id is None:
1112
if (tree.has_changes(tree.basis_tree())
1113
or len(tree.get_parent_ids()) > 1):
1114
raise errors.UncommittedChanges(
1115
tree, more='Use --no-strict to force the push.')
1116
if tree.last_revision() != tree.branch.last_revision():
1117
# The tree has lost sync with its branch, there is little
1118
# chance that the user is aware of it but he can still force
1119
# the push with --no-strict
1120
raise errors.OutOfDateTree(
1121
tree, more='Use --no-strict to force the push.')
1122
1171
1123
# Get the stacked_on branch, if any
1172
1124
if stacked_on is not None:
1173
1125
stacked_on = urlutils.normalize_url(stacked_on)
1195
1147
else:
1196
1148
display_url = urlutils.unescape_for_display(stored_loc,
1197
1149
self.outf.encoding)
1198
note("Using saved push location: %s" % display_url)
1150
self.outf.write("Using saved push location: %s\n" % display_url)
1199
1151
location = stored_loc
1200
1152
1201
1153
_show_push_branch(br_from, revision_id, location, self.outf,
1202
1154
verbose=verbose, overwrite=overwrite, remember=remember,
1203
1155
stacked_on=stacked_on, create_prefix=create_prefix,
1204
use_existing_dir=use_existing_dir, no_tree=no_tree)
1156
use_existing_dir=use_existing_dir)
1205
1157
1206
1158
1207
1159
class cmd_branch(Command):
1208
__doc__ = """Create a new branch that is a copy of an existing branch.
1160
"""Create a new branch that is a copy of an existing branch.
1209
1161
1210
1162
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1211
1163
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1216
1168
1217
1169
To retrieve the branch as of a particular revision, supply the --revision
1218
1170
parameter, as in "branch foo/bar -r 5".
1219
1220
The synonyms 'clone' and 'get' for this command are deprecated.
1221
1171
"""
1222
1172
1223
1173
_see_also = ['checkout']
1224
1174
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."),
1175
takes_options = ['revision', Option('hardlink',
1176
help='Hard-link working tree files where possible.'),
1229
1177
Option('no-tree',
1230
1178
help="Create a branch without a working-tree."),
1231
1179
Option('switch',
1242
1190
' directory exists, but does not already'
1243
1191
' have a control directory. This flag will'
1244
1192
' allow branch to proceed.'),
1245
Option('bind',
1246
help="Bind new branch to from location."),
1247
1193
]
1248
1194
aliases = ['get', 'clone']
1249
1195
1250
1196
def run(self, from_location, to_location=None, revision=None,
1251
1197
hardlink=False, stacked=False, standalone=False, no_tree=False,
1252
use_existing_dir=False, switch=False, bind=False,
1253
files_from=None):
1198
use_existing_dir=False, switch=False):
1254
1199
from bzrlib import switch as _mod_switch
1255
1200
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
1201
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1263
1202
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
1203
if (accelerator_tree is not None and
1204
accelerator_tree.supports_content_filtering()):
1268
1205
accelerator_tree = None
1269
if files_from is not None and files_from != from_location:
1270
accelerator_tree = WorkingTree.open(files_from)
1271
1206
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)
1207
br_from.lock_read()
1283
1208
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)
1209
if revision is not None:
1210
revision_id = revision.as_revision_id(br_from)
1289
1211
else:
1290
try:
1291
bzrdir.BzrDir.open_from_transport(to_transport)
1292
except errors.NotBranchError:
1293
pass
1212
# FIXME - wt.last_revision, fallback to branch, fall back to
1213
# None or perhaps NULL_REVISION to mean copy nothing
1214
# RBC 20060209
1215
revision_id = br_from.last_revision()
1216
if to_location is None:
1217
to_location = urlutils.derive_to_location(from_location)
1218
to_transport = transport.get_transport(to_location)
1219
try:
1220
to_transport.mkdir('.')
1221
except errors.FileExists:
1222
if not use_existing_dir:
1223
raise errors.BzrCommandError('Target directory "%s" '
1224
'already exists.' % to_location)
1294
1225
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'))
1226
try:
1227
bzrdir.BzrDir.open_from_transport(to_transport)
1228
except errors.NotBranchError:
1229
pass
1230
else:
1231
raise errors.AlreadyBranchError(to_location)
1232
except errors.NoSuchFile:
1233
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1234
% to_location)
1235
try:
1236
# preserve whatever source format we have.
1237
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1238
possible_transports=[to_transport],
1239
accelerator_tree=accelerator_tree,
1240
hardlink=hardlink, stacked=stacked,
1241
force_new_repo=standalone,
1242
create_tree_if_local=not no_tree,
1243
source_branch=br_from)
1244
branch = dir.open_branch()
1245
except errors.NoSuchRevision:
1246
to_transport.delete_tree('.')
1247
msg = "The branch %s has no revision %s." % (from_location,
1248
revision)
1249
raise errors.BzrCommandError(msg)
1250
_merge_tags_if_possible(br_from, branch)
1251
# If the source branch is stacked, the new branch may
1252
# be stacked whether we asked for that explicitly or not.
1253
# We therefore need a try/except here and not just 'if stacked:'
1254
try:
1255
note('Created new stacked branch referring to %s.' %
1256
branch.get_stacked_on_url())
1257
except (errors.NotStacked, errors.UnstackableBranchFormat,
1258
errors.UnstackableRepositoryFormat), e:
1259
note('Branched %d revision(s).' % branch.revno())
1260
if switch:
1261
# Switch to the new branch
1262
wt, _ = WorkingTree.open_containing('.')
1263
_mod_switch.switch(wt.bzrdir, branch)
1264
note('Switched to branch: %s',
1265
urlutils.unescape_for_display(branch.base, 'utf-8'))
1266
finally:
1267
br_from.unlock()
1335
1268
1336
1269
1337
1270
class cmd_checkout(Command):
1338
__doc__ = """Create a new checkout of an existing branch.
1271
"""Create a new checkout of an existing branch.
1339
1272
1340
1273
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1341
1274
the branch found in '.'. This is useful if you have removed the working tree
1380
1313
to_location = branch_location
1381
1314
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1382
1315
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
1316
revision = _get_one_revision('checkout', revision)
1389
if files_from is not None and files_from != branch_location:
1317
if files_from is not None:
1390
1318
accelerator_tree = WorkingTree.open(files_from)
1391
1319
if revision is not None:
1392
1320
revision_id = revision.as_revision_id(source)
1409
1337
1410
1338
1411
1339
class cmd_renames(Command):
1412
__doc__ = """Show list of renamed files.
1340
"""Show list of renamed files.
1413
1341
"""
1414
1342
# TODO: Option to show renames between two historical versions.
1415
1343
1420
1348
@display_command
1421
1349
def run(self, dir=u'.'):
1422
1350
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))
1351
tree.lock_read()
1352
try:
1353
new_inv = tree.inventory
1354
old_tree = tree.basis_tree()
1355
old_tree.lock_read()
1356
try:
1357
old_inv = old_tree.inventory
1358
renames = []
1359
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1360
for f, paths, c, v, p, n, k, e in iterator:
1361
if paths[0] == paths[1]:
1362
continue
1363
if None in (paths):
1364
continue
1365
renames.append(paths)
1366
renames.sort()
1367
for old_name, new_name in renames:
1368
self.outf.write("%s => %s\n" % (old_name, new_name))
1369
finally:
1370
old_tree.unlock()
1371
finally:
1372
tree.unlock()
1439
1373
1440
1374
1441
1375
class cmd_update(Command):
1442
__doc__ = """Update a tree to have the latest code committed to its branch.
1376
"""Update a tree to have the latest code committed to its branch.
1443
1377
1444
1378
This will perform a merge into the working tree, and may generate
1445
1379
conflicts. If you have any local changes, you will still
1447
1381
1448
1382
If you want to discard your local changes, you can just do a
1449
1383
'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
1384
"""
1457
1385
1458
1386
_see_also = ['pull', 'working-trees', 'status-flags']
1459
1387
takes_args = ['dir?']
1460
takes_options = ['revision',
1461
Option('show-base',
1462
help="Show base revision text in conflicts."),
1463
]
1464
1388
aliases = ['up']
1465
1389
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")
1390
def run(self, dir='.'):
1470
1391
tree = WorkingTree.open_containing(dir)[0]
1471
branch = tree.branch
1472
1392
possible_transports = []
1473
master = branch.get_master_branch(
1393
master = tree.branch.get_master_branch(
1474
1394
possible_transports=possible_transports)
1475
1395
if master is not None:
1476
branch_location = master.base
1477
1396
tree.lock_write()
1478
1397
else:
1479
branch_location = tree.branch.base
1480
1398
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
1399
try:
1400
existing_pending_merges = tree.get_parent_ids()[1:]
1401
last_rev = _mod_revision.ensure_null(tree.last_revision())
1402
if last_rev == _mod_revision.ensure_null(
1403
tree.branch.last_revision()):
1404
# may be up to date, check master too.
1405
if master is None or last_rev == _mod_revision.ensure_null(
1406
master.last_revision()):
1407
revno = tree.branch.revision_id_to_revno(last_rev)
1408
note("Tree is up to date at revision %d." % (revno,))
1409
return 0
1410
view_info = _get_view_info_for_change_reporter(tree)
1508
1411
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
1412
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1413
view_info=view_info), possible_transports=possible_transports)
1414
revno = tree.branch.revision_id_to_revno(
1415
_mod_revision.ensure_null(tree.last_revision()))
1416
note('Updated to revision %d.' % (revno,))
1417
if tree.get_parent_ids()[1:] != existing_pending_merges:
1418
note('Your local commits will now show as pending merges with '
1419
"'bzr status', and can be committed with 'bzr commit'.")
1420
if conflicts != 0:
1421
return 1
1422
else:
1423
return 0
1424
finally:
1425
tree.unlock()
1532
1426
1533
1427
1534
1428
class cmd_info(Command):
1535
__doc__ = """Show information about a working tree, branch or repository.
1429
"""Show information about a working tree, branch or repository.
1536
1430
1537
1431
This command will show all known locations and formats associated to the
1538
1432
tree, branch or repository.
1576
1470
1577
1471
1578
1472
class cmd_remove(Command):
1579
__doc__ = """Remove files or directories.
1473
"""Remove files or directories.
1580
1474
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.
1475
This makes bzr stop tracking changes to the specified files. bzr will delete
1476
them if they can easily be recovered using revert. If no options or
1477
parameters are given bzr will scan for files that are being tracked by bzr
1478
but missing in your tree and stop tracking them for you.
1586
1479
"""
1587
1480
takes_args = ['file*']
1588
1481
takes_options = ['verbose',
1590
1483
RegistryOption.from_kwargs('file-deletion-strategy',
1591
1484
'The file deletion mode to be used.',
1592
1485
title='Deletion Strategy', value_switches=True, enum_switch=False,
1593
safe='Backup changed files (default).',
1486
safe='Only delete files if they can be'
1487
' safely recovered (default).',
1594
1488
keep='Delete from bzr but leave the working copy.',
1595
no_backup='Don\'t backup changed files.',
1596
1489
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)')]
1490
'recovered and even if they are non-empty directories.')]
1599
1491
aliases = ['rm', 'del']
1600
1492
encoding_type = 'replace'
1601
1493
1602
1494
def run(self, file_list, verbose=False, new=False,
1603
1495
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)
1496
tree, file_list = tree_files(file_list)
1610
1497
1611
1498
if file_list is not None:
1612
1499
file_list = [f for f in file_list]
1613
1500
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'))
1501
tree.lock_write()
1502
try:
1503
# Heuristics should probably all move into tree.remove_smart or
1504
# some such?
1505
if new:
1506
added = tree.changes_from(tree.basis_tree(),
1507
specific_files=file_list).added
1508
file_list = sorted([f[0] for f in added], reverse=True)
1509
if len(file_list) == 0:
1510
raise errors.BzrCommandError('No matching files.')
1511
elif file_list is None:
1512
# missing files show up in iter_changes(basis) as
1513
# versioned-with-no-kind.
1514
missing = []
1515
for change in tree.iter_changes(tree.basis_tree()):
1516
# Find paths in the working tree that have no kind:
1517
if change[1][1] is not None and change[6][1] is None:
1518
missing.append(change[1][1])
1519
file_list = sorted(missing, reverse=True)
1520
file_deletion_strategy = 'keep'
1521
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1522
keep_files=file_deletion_strategy=='keep',
1523
force=file_deletion_strategy=='force')
1524
finally:
1525
tree.unlock()
1636
1526
1637
1527
1638
1528
class cmd_file_id(Command):
1639
__doc__ = """Print file_id of a particular file or directory.
1529
"""Print file_id of a particular file or directory.
1640
1530
1641
1531
The file_id is assigned when the file is first added and remains the
1642
1532
same through all revisions where the file exists, even when it is
1658
1548
1659
1549
1660
1550
class cmd_file_path(Command):
1661
__doc__ = """Print path of file_ids to a file or directory.
1551
"""Print path of file_ids to a file or directory.
1662
1552
1663
1553
This prints one line for each directory down to the target,
1664
1554
starting at the branch root.
1680
1570
1681
1571
1682
1572
class cmd_reconcile(Command):
1683
__doc__ = """Reconcile bzr metadata in a branch.
1573
"""Reconcile bzr metadata in a branch.
1684
1574
1685
1575
This can correct data mismatches that may have been caused by
1686
1576
previous ghost operations or bzr upgrades. You should only
1700
1590
1701
1591
_see_also = ['check']
1702
1592
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
1593
1710
def run(self, branch=".", canonicalize_chks=False):
1594
def run(self, branch="."):
1711
1595
from bzrlib.reconcile import reconcile
1712
1596
dir = bzrdir.BzrDir.open(branch)
1713
reconcile(dir, canonicalize_chks=canonicalize_chks)
1597
reconcile(dir)
1714
1598
1715
1599
1716
1600
class cmd_revision_history(Command):
1717
__doc__ = """Display the list of revision ids on a branch."""
1601
"""Display the list of revision ids on a branch."""
1718
1602
1719
1603
_see_also = ['log']
1720
1604
takes_args = ['location?']
1730
1614
1731
1615
1732
1616
class cmd_ancestry(Command):
1733
__doc__ = """List all revisions merged into this branch."""
1617
"""List all revisions merged into this branch."""
1734
1618
1735
1619
_see_also = ['log', 'revision-history']
1736
1620
takes_args = ['location?']
1748
1632
b = wt.branch
1749
1633
last_revision = wt.last_revision()
1750
1634
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
1635
revision_ids = b.repository.get_ancestry(last_revision)
1636
revision_ids.pop(0)
1637
for revision_id in revision_ids:
1758
1638
self.outf.write(revision_id + '\n')
1759
1639
1760
1640
1761
1641
class cmd_init(Command):
1762
__doc__ = """Make a directory into a versioned branch.
1642
"""Make a directory into a versioned branch.
1763
1643
1764
1644
Use this to create an empty branch, or before importing an
1765
1645
existing project.
1797
1677
),
1798
1678
Option('append-revisions-only',
1799
1679
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.')
1680
' Append revisions to it only.')
1803
1681
]
1804
1682
def run(self, location=None, format=None, append_revisions_only=False,
1805
create_prefix=False, no_tree=False):
1683
create_prefix=False):
1806
1684
if format is None:
1807
1685
format = bzrdir.format_registry.make_bzrdir('default')
1808
1686
if location is None:
1831
1709
except errors.NotBranchError:
1832
1710
# really a NotBzrDir error...
1833
1711
create_branch = bzrdir.BzrDir.create_branch_convenience
1834
if no_tree:
1835
force_new_tree = False
1836
else:
1837
force_new_tree = None
1838
1712
branch = create_branch(to_transport.base, format=format,
1839
possible_transports=[to_transport],
1840
force_new_tree=force_new_tree)
1713
possible_transports=[to_transport])
1841
1714
a_bzrdir = branch.bzrdir
1842
1715
else:
1843
1716
from bzrlib.transport.local import LocalTransport
1847
1720
raise errors.BranchExistsWithoutWorkingTree(location)
1848
1721
raise errors.AlreadyBranchError(location)
1849
1722
branch = a_bzrdir.create_branch()
1850
if not no_tree:
1851
a_bzrdir.create_workingtree()
1723
a_bzrdir.create_workingtree()
1852
1724
if append_revisions_only:
1853
1725
try:
1854
1726
branch.set_append_revisions_only(True)
1876
1748
1877
1749
1878
1750
class cmd_init_repository(Command):
1879
__doc__ = """Create a shared repository for branches to share storage space.
1751
"""Create a shared repository to hold branches.
1880
1752
1881
1753
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.
1754
revisions in the repository, not in the branch directory.
1885
1755
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.
1756
If the --no-trees option is used then the branches in the repository
1757
will not have working trees by default.
1892
1758
1893
1759
:Examples:
1894
Create a shared repository holding just branches::
1760
Create a shared repositories holding just branches::
1895
1761
1896
1762
bzr init-repo --no-trees repo
1897
1763
bzr init repo/trunk
1936
1802
1937
1803
1938
1804
class cmd_diff(Command):
1939
__doc__ = """Show differences in the working tree, between revisions or branches.
1805
"""Show differences in the working tree, between revisions or branches.
1940
1806
1941
1807
If no arguments are given, all changes for the current tree are listed.
1942
1808
If files are given, only the changes in those files are listed.
1948
1814
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1949
1815
produces patches suitable for "patch -p1".
1950
1816
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
1817
:Exit values:
1959
1818
1 - changed
1960
1819
2 - unrepresentable changes
1970
1829
1971
1830
bzr diff -r1
1972
1831
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..
1832
Difference between revision 2 and revision 1::
1833
1834
bzr diff -r1..2
1835
1836
Difference between revision 2 and revision 1 for branch xxx::
1837
1838
bzr diff -r1..2 xxx
1999
1839
2000
1840
Show just the differences for file NEWS::
2001
1841
2016
1856
Same as 'bzr diff' but prefix paths with old/ and new/::
2017
1857
2018
1858
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
1859
"""
2024
1860
_see_also = ['status']
2025
1861
takes_args = ['file*']
2044
1880
help='Use this command to compare files.',
2045
1881
type=unicode,
2046
1882
),
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
1883
]
2053
1884
aliases = ['di', 'dif']
2054
1885
encoding_type = 'exact'
2055
1886
2056
1887
@display_command
2057
1888
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)
1889
prefix=None, old=None, new=None, using=None):
1890
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
2061
1891
2062
1892
if (prefix is None) or (prefix == '0'):
2063
1893
# diff -p0 format
2077
1907
raise errors.BzrCommandError('bzr diff --revision takes exactly'
2078
1908
' one or two revision specifiers')
2079
1909
2080
if using is not None and format is not None:
2081
raise errors.BzrCommandError('--using and --format are mutually '
2082
'exclusive.')
2083
2084
(old_tree, new_tree,
2085
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
old_tree, new_tree, specific_files, extra_trees = \
1911
_get_trees_to_diff(file_list, revision, old, new,
1912
apply_view=True)
2090
1913
return show_diff_trees(old_tree, new_tree, sys.stdout,
2091
1914
specific_files=specific_files,
2092
1915
external_diff_options=diff_options,
2093
1916
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)
1917
extra_trees=extra_trees, using=using)
2098
1918
2099
1919
2100
1920
class cmd_deleted(Command):
2101
__doc__ = """List files deleted in the working tree.
1921
"""List files deleted in the working tree.
2102
1922
"""
2103
1923
# TODO: Show files deleted since a previous revision, or
2104
1924
# between two revisions.
2107
1927
# level of effort but possibly much less IO. (Or possibly not,
2108
1928
# if the directories are very large...)
2109
1929
_see_also = ['status', 'ls']
2110
takes_options = ['directory', 'show-ids']
1930
takes_options = ['show-ids']
2111
1931
2112
1932
@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')
1933
def run(self, show_ids=False):
1934
tree = WorkingTree.open_containing(u'.')[0]
1935
tree.lock_read()
1936
try:
1937
old = tree.basis_tree()
1938
old.lock_read()
1939
try:
1940
for path, ie in old.inventory.iter_entries():
1941
if not tree.has_id(ie.file_id):
1942
self.outf.write(path)
1943
if show_ids:
1944
self.outf.write(' ')
1945
self.outf.write(ie.file_id)
1946
self.outf.write('\n')
1947
finally:
1948
old.unlock()
1949
finally:
1950
tree.unlock()
2125
1951
2126
1952
2127
1953
class cmd_modified(Command):
2128
__doc__ = """List files modified in working tree.
1954
"""List files modified in working tree.
2129
1955
"""
2130
1956
2131
1957
hidden = True
2132
1958
_see_also = ['status', 'ls']
2133
takes_options = ['directory', 'null']
1959
takes_options = [
1960
Option('null',
1961
help='Write an ascii NUL (\\0) separator '
1962
'between files rather than a newline.')
1963
]
2134
1964
2135
1965
@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)
1966
def run(self, null=False):
1967
tree = WorkingTree.open_containing(u'.')[0]
2139
1968
td = tree.changes_from(tree.basis_tree())
2140
self.cleanup_now()
2141
1969
for path, id, kind, text_modified, meta_modified in td.modified:
2142
1970
if null:
2143
1971
self.outf.write(path + '\0')
2146
1974
2147
1975
2148
1976
class cmd_added(Command):
2149
__doc__ = """List files added in working tree.
1977
"""List files added in working tree.
2150
1978
"""
2151
1979
2152
1980
hidden = True
2153
1981
_see_also = ['status', 'ls']
2154
takes_options = ['directory', 'null']
1982
takes_options = [
1983
Option('null',
1984
help='Write an ascii NUL (\\0) separator '
1985
'between files rather than a newline.')
1986
]
2155
1987
2156
1988
@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')
1989
def run(self, null=False):
1990
wt = WorkingTree.open_containing(u'.')[0]
1991
wt.lock_read()
1992
try:
1993
basis = wt.basis_tree()
1994
basis.lock_read()
1995
try:
1996
basis_inv = basis.inventory
1997
inv = wt.inventory
1998
for file_id in inv:
1999
if file_id in basis_inv:
2000
continue
2001
if inv.is_root(file_id) and len(basis_inv) == 0:
2002
continue
2003
path = inv.id2path(file_id)
2004
if not os.access(osutils.abspath(path), os.F_OK):
2005
continue
2006
if null:
2007
self.outf.write(path + '\0')
2008
else:
2009
self.outf.write(osutils.quotefn(path) + '\n')
2010
finally:
2011
basis.unlock()
2012
finally:
2013
wt.unlock()
2176
2014
2177
2015
2178
2016
class cmd_root(Command):
2179
__doc__ = """Show the tree root directory.
2017
"""Show the tree root directory.
2180
2018
2181
2019
The root is the nearest enclosing directory with a .bzr control
2182
2020
directory."""
2206
2044
2207
2045
2208
2046
class cmd_log(Command):
2209
__doc__ = """Show historical log for a branch or subset of a branch.
2047
"""Show historical log for a branch or subset of a branch.
2210
2048
2211
2049
log is bzr's default tool for exploring the history of a branch.
2212
2050
The branch to use is taken from the first parameter. If no parameters
2317
2155
2318
2156
:Other filtering:
2319
2157
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.
2158
The --message option can be used for finding revisions that match a
2159
regular expression in a commit message.
2325
2160
2326
2161
:Tips & tricks:
2327
2162
2328
2163
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>.
2164
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2165
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2166
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2167
2168
Web interfaces are often better at exploring history than command line
2169
tools, particularly for branches on servers. You may prefer Loggerhead
2170
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2333
2171
2334
2172
You may find it useful to add the aliases below to ``bazaar.conf``::
2335
2173
2376
2214
help='Show just the specified revision.'
2377
2215
' See also "help revisionspec".'),
2378
2216
'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
2217
Option('levels',
2385
2218
short_name='n',
2386
2219
help='Number of levels to display - 0 for all, 1 for flat.',
2387
2220
argname='N',
2388
2221
type=_parse_levels),
2389
2222
Option('message',
2223
short_name='m',
2390
2224
help='Show revisions whose message matches this '
2391
2225
'regular expression.',
2392
type=str,
2393
hidden=True),
2226
type=str),
2394
2227
Option('limit',
2395
2228
short_name='l',
2396
2229
help='Limit the output to the first N revisions.',
2401
2234
help='Show changes made in each revision as a patch.'),
2402
2235
Option('include-merges',
2403
2236
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
2237
]
2432
2238
encoding_type = 'replace'
2433
2239
2443
2249
message=None,
2444
2250
limit=None,
2445
2251
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
):
2252
include_merges=False):
2456
2253
from bzrlib.log import (
2457
2254
Logger,
2458
2255
make_log_request_dict,
2459
2256
_get_info_for_log_files,
2460
2257
)
2461
2258
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
2259
if include_merges:
2467
2260
if levels is None:
2468
2261
levels = 0
2483
2276
filter_by_dir = False
2484
2277
if file_list:
2485
2278
# 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)
2279
b, file_info_list, rev1, rev2 = _get_info_for_log_files(revision,
2280
file_list)
2488
2281
for relpath, file_id, kind in file_info_list:
2489
2282
if file_id is None:
2490
2283
raise errors.BzrCommandError(
2508
2301
location = '.'
2509
2302
dir, relpath = bzrdir.BzrDir.open_containing(location)
2510
2303
b = dir.open_branch()
2511
self.add_cleanup(b.lock_read().unlock)
2512
2304
rev1, rev2 = _get_revision_range(revision, b, self.name())
2513
2305
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
2306
# Decide on the type of delta & diff filtering to use
2522
2307
# TODO: add an --all-files option to make this configurable & consistent
2523
2308
if not verbose:
2531
2316
else:
2532
2317
diff_type = 'full'
2533
2318
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)
2319
b.lock_read()
2320
try:
2321
# Build the log formatter
2322
if log_format is None:
2323
log_format = log.log_formatter_registry.get_default(b)
2324
lf = log_format(show_ids=show_ids, to_file=self.outf,
2325
show_timezone=timezone,
2326
delta_format=get_verbosity_level(),
2327
levels=levels,
2328
show_advice=levels is None)
2329
2330
# Choose the algorithm for doing the logging. It's annoying
2331
# having multiple code paths like this but necessary until
2332
# the underlying repository format is faster at generating
2333
# deltas or can provide everything we need from the indices.
2334
# The default algorithm - match-using-deltas - works for
2335
# multiple files and directories and is faster for small
2336
# amounts of history (200 revisions say). However, it's too
2337
# slow for logging a single file in a repository with deep
2338
# history, i.e. > 10K revisions. In the spirit of "do no
2339
# evil when adding features", we continue to use the
2340
# original algorithm - per-file-graph - for the "single
2341
# file that isn't a directory without showing a delta" case.
2342
partial_history = revision and b.repository._format.supports_chks
2343
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2344
or delta_type or partial_history)
2345
2346
# Build the LogRequest and execute it
2347
if len(file_ids) == 0:
2348
file_ids = None
2349
rqst = make_log_request_dict(
2350
direction=direction, specific_fileids=file_ids,
2351
start_revision=rev1, end_revision=rev2, limit=limit,
2352
message_search=message, delta_type=delta_type,
2353
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2354
Logger(b, rqst).show(lf)
2355
finally:
2356
b.unlock()
2587
2357
2588
2358
2589
2359
def _get_revision_range(revisionspec_list, branch, command_name):
2607
2377
raise errors.BzrCommandError(
2608
2378
"bzr %s doesn't accept two revisions in different"
2609
2379
" 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)
2380
rev1 = start_spec.in_history(branch)
2615
2381
# Avoid loading all of history when we know a missing
2616
2382
# end of range means the last revision ...
2617
2383
if end_spec.spec is None:
2646
2412
2647
2413
2648
2414
class cmd_touching_revisions(Command):
2649
__doc__ = """Return revision-ids which affected a particular file.
2415
"""Return revision-ids which affected a particular file.
2650
2416
2651
2417
A more user-friendly interface is "bzr log FILE".
2652
2418
"""
2657
2423
@display_command
2658
2424
def run(self, filename):
2659
2425
tree, relpath = WorkingTree.open_containing(filename)
2426
b = tree.branch
2660
2427
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:
2428
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
2665
2429
self.outf.write("%6d %s\n" % (revno, what))
2666
2430
2667
2431
2668
2432
class cmd_ls(Command):
2669
__doc__ = """List files in a tree.
2433
"""List files in a tree.
2670
2434
"""
2671
2435
2672
2436
_see_also = ['status', 'cat']
2678
2442
help='Recurse into subdirectories.'),
2679
2443
Option('from-root',
2680
2444
help='Print paths relative to the root of the branch.'),
2681
Option('unknown', short_name='u',
2682
help='Print unknown files.'),
2445
Option('unknown', help='Print unknown files.'),
2683
2446
Option('versioned', help='Print versioned files.',
2684
2447
short_name='V'),
2685
Option('ignored', short_name='i',
2686
help='Print ignored files.'),
2687
Option('kind', short_name='k',
2448
Option('ignored', help='Print ignored files.'),
2449
Option('null',
2450
help='Write an ascii NUL (\\0) separator '
2451
'between files rather than a newline.'),
2452
Option('kind',
2688
2453
help='List entries of a particular kind: file, directory, symlink.',
2689
2454
type=unicode),
2690
'null',
2691
2455
'show-ids',
2692
'directory',
2693
2456
]
2694
2457
@display_command
2695
2458
def run(self, revision=None, verbose=False,
2696
2459
recursive=False, from_root=False,
2697
2460
unknown=False, versioned=False, ignored=False,
2698
null=False, kind=None, show_ids=False, path=None, directory=None):
2461
null=False, kind=None, show_ids=False, path=None):
2699
2462
2700
2463
if kind and kind not in ('file', 'directory', 'symlink'):
2701
2464
raise errors.BzrCommandError('invalid kind specified')
2713
2476
raise errors.BzrCommandError('cannot specify both --from-root'
2714
2477
' and PATH')
2715
2478
fs_path = path
2716
tree, branch, relpath = \
2717
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2479
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2480
fs_path)
2718
2481
2719
2482
# Calculate the prefix to use
2720
2483
prefix = None
2721
2484
if from_root:
2722
2485
if relpath:
2723
2486
prefix = relpath + '/'
2724
elif fs_path != '.' and not fs_path.endswith('/'):
2487
elif fs_path != '.':
2725
2488
prefix = fs_path + '/'
2726
2489
2727
2490
if revision is not None or tree is None:
2735
2498
view_str = views.view_display_str(view_files)
2736
2499
note("Ignoring files outside view. View is %s" % view_str)
2737
2500
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
2501
tree.lock_read()
2502
try:
2503
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2504
from_dir=relpath, recursive=recursive):
2505
# Apply additional masking
2506
if not all and not selection[fc]:
2507
continue
2508
if kind is not None and fkind != kind:
2509
continue
2510
if apply_view:
2511
try:
2512
if relpath:
2513
fullpath = osutils.pathjoin(relpath, fp)
2514
else:
2515
fullpath = fp
2516
views.check_path_in_view(tree, fullpath)
2517
except errors.FileOutsideView:
2518
continue
2755
2519
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:
2520
# Output the entry
2521
if prefix:
2522
fp = osutils.pathjoin(prefix, fp)
2523
kindch = entry.kind_character()
2524
outstring = fp + kindch
2525
ui.ui_factory.clear_term()
2526
if verbose:
2527
outstring = '%-8s %s' % (fc, outstring)
2528
if show_ids and fid is not None:
2529
outstring = "%-50s %s" % (outstring, fid)
2782
2530
self.outf.write(outstring + '\n')
2531
elif null:
2532
self.outf.write(fp + '\0')
2533
if show_ids:
2534
if fid is not None:
2535
self.outf.write(fid)
2536
self.outf.write('\0')
2537
self.outf.flush()
2538
else:
2539
if show_ids:
2540
if fid is not None:
2541
my_id = fid
2542
else:
2543
my_id = ''
2544
self.outf.write('%-50s %s\n' % (outstring, my_id))
2545
else:
2546
self.outf.write(outstring + '\n')
2547
finally:
2548
tree.unlock()
2783
2549
2784
2550
2785
2551
class cmd_unknowns(Command):
2786
__doc__ = """List unknown files.
2552
"""List unknown files.
2787
2553
"""
2788
2554
2789
2555
hidden = True
2790
2556
_see_also = ['ls']
2791
takes_options = ['directory']
2792
2557
2793
2558
@display_command
2794
def run(self, directory=u'.'):
2795
for f in WorkingTree.open_containing(directory)[0].unknowns():
2559
def run(self):
2560
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2796
2561
self.outf.write(osutils.quotefn(f) + '\n')
2797
2562
2798
2563
2799
2564
class cmd_ignore(Command):
2800
__doc__ = """Ignore specified files or patterns.
2565
"""Ignore specified files or patterns.
2801
2566
2802
2567
See ``bzr help patterns`` for details on the syntax of patterns.
2803
2568
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
2569
To remove patterns from the ignore list, edit the .bzrignore file.
2811
2570
After adding, editing or deleting that file either indirectly by
2812
2571
using this command or directly by using an editor, be sure to commit
2813
2572
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.
2573
2574
Note: ignore patterns containing shell wildcards must be quoted from
2575
the shell on Unix.
2835
2576
2836
2577
:Examples:
2837
2578
Ignore the top level Makefile::
2838
2579
2839
2580
bzr ignore ./Makefile
2840
2581
2841
Ignore .class files in all directories...::
2582
Ignore class files in all directories::
2842
2583
2843
2584
bzr ignore "*.class"
2844
2585
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
2586
Ignore .o files under the lib directory::
2854
2587
2855
2588
bzr ignore "lib/**/*.o"
2861
2594
Ignore everything but the "debian" toplevel directory::
2862
2595
2863
2596
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
2597
"""
2872
2598
2873
2599
_see_also = ['status', 'ignored', 'patterns']
2874
2600
takes_args = ['name_pattern*']
2875
takes_options = ['directory',
2876
Option('default-rules',
2877
help='Display the default ignore rules that bzr uses.')
2601
takes_options = [
2602
Option('old-default-rules',
2603
help='Write out the ignore rules bzr < 0.9 always used.')
2878
2604
]
2879
2605
2880
def run(self, name_pattern_list=None, default_rules=None,
2881
directory=u'.'):
2606
def run(self, name_pattern_list=None, old_default_rules=None):
2882
2607
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)
2608
if old_default_rules is not None:
2609
# dump the rules and exit
2610
for pattern in ignores.OLD_DEFAULTS:
2611
print pattern
2887
2612
return
2888
2613
if not name_pattern_list:
2889
2614
raise errors.BzrCommandError("ignore requires at least one "
2890
"NAME_PATTERN or --default-rules.")
2615
"NAME_PATTERN or --old-default-rules")
2891
2616
name_pattern_list = [globbing.normalize_pattern(p)
2892
2617
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
2618
for name_pattern in name_pattern_list:
2902
2619
if (name_pattern[0] == '/' or
2903
2620
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2904
2621
raise errors.BzrCommandError(
2905
2622
"NAME_PATTERN should not be an absolute path")
2906
tree, relpath = WorkingTree.open_containing(directory)
2623
tree, relpath = WorkingTree.open_containing(u'.')
2907
2624
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2908
2625
ignored = globbing.Globster(name_pattern_list)
2909
2626
matches = []
2910
self.add_cleanup(tree.lock_read().unlock)
2627
tree.lock_read()
2911
2628
for entry in tree.list_files():
2912
2629
id = entry[3]
2913
2630
if id is not None:
2914
2631
filename = entry[0]
2915
2632
if ignored.match(filename):
2916
matches.append(filename)
2633
matches.append(filename.encode('utf-8'))
2634
tree.unlock()
2917
2635
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),))
2636
print "Warning: the following files are version controlled and" \
2637
" match your ignore pattern:\n%s" \
2638
"\nThese files will continue to be version controlled" \
2639
" unless you 'bzr remove' them." % ("\n".join(matches),)
2922
2640
2923
2641
2924
2642
class cmd_ignored(Command):
2925
__doc__ = """List ignored files and the patterns that matched them.
2643
"""List ignored files and the patterns that matched them.
2926
2644
2927
2645
List all the ignored files and the ignore pattern that caused the file to
2928
2646
be ignored.
2934
2652
2935
2653
encoding_type = 'replace'
2936
2654
_see_also = ['ignore', 'ls']
2937
takes_options = ['directory']
2938
2655
2939
2656
@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))
2657
def run(self):
2658
tree = WorkingTree.open_containing(u'.')[0]
2659
tree.lock_read()
2660
try:
2661
for path, file_class, kind, file_id, entry in tree.list_files():
2662
if file_class != 'I':
2663
continue
2664
## XXX: Slightly inefficient since this was already calculated
2665
pat = tree.is_ignored(path)
2666
self.outf.write('%-50s %s\n' % (path, pat))
2667
finally:
2668
tree.unlock()
2949
2669
2950
2670
2951
2671
class cmd_lookup_revision(Command):
2952
__doc__ = """Lookup the revision-id from a revision-number
2672
"""Lookup the revision-id from a revision-number
2953
2673
2954
2674
:Examples:
2955
2675
bzr lookup-revision 33
2956
2676
"""
2957
2677
hidden = True
2958
2678
takes_args = ['revno']
2959
takes_options = ['directory']
2960
2679
2961
2680
@display_command
2962
def run(self, revno, directory=u'.'):
2681
def run(self, revno):
2963
2682
try:
2964
2683
revno = int(revno)
2965
2684
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)
2685
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2686
2687
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2970
2688
2971
2689
2972
2690
class cmd_export(Command):
2973
__doc__ = """Export current or past revision to a destination directory or archive.
2691
"""Export current or past revision to a destination directory or archive.
2974
2692
2975
2693
If no revision is specified this exports the last committed revision.
2976
2694
2997
2715
zip .zip
2998
2716
================= =========================
2999
2717
"""
3000
encoding = 'exact'
3001
2718
takes_args = ['dest', 'branch_or_subdir?']
3002
takes_options = ['directory',
2719
takes_options = [
3003
2720
Option('format',
3004
2721
help="Type of file to export to.",
3005
2722
type=unicode),
3009
2726
Option('root',
3010
2727
type=str,
3011
2728
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
2729
]
3016
2730
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
3017
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2731
root=None, filters=False):
3018
2732
from bzrlib.export import export
3019
2733
3020
2734
if branch_or_subdir is None:
3021
tree = WorkingTree.open_containing(directory)[0]
2735
tree = WorkingTree.open_containing(u'.')[0]
3022
2736
b = tree.branch
3023
2737
subdir = None
3024
2738
else:
3027
2741
3028
2742
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
3029
2743
try:
3030
export(rev_tree, dest, format, root, subdir, filtered=filters,
3031
per_file_timestamps=per_file_timestamps)
2744
export(rev_tree, dest, format, root, subdir, filtered=filters)
3032
2745
except errors.NoSuchExportFormat, e:
3033
2746
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3034
2747
3035
2748
3036
2749
class cmd_cat(Command):
3037
__doc__ = """Write the contents of a file as of a given revision to standard output.
2750
"""Write the contents of a file as of a given revision to standard output.
3038
2751
3039
2752
If no revision is nominated, the last revision is used.
3040
2753
3043
2756
"""
3044
2757
3045
2758
_see_also = ['ls']
3046
takes_options = ['directory',
2759
takes_options = [
3047
2760
Option('name-from-revision', help='The path name in the old tree.'),
3048
2761
Option('filters', help='Apply content filters to display the '
3049
2762
'convenience form.'),
3054
2767
3055
2768
@display_command
3056
2769
def run(self, filename, revision=None, name_from_revision=False,
3057
filters=False, directory=None):
2770
filters=False):
3058
2771
if revision is not None and len(revision) != 1:
3059
2772
raise errors.BzrCommandError("bzr cat --revision takes exactly"
3060
2773
" one revision specifier")
3061
2774
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)
2775
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2776
branch.lock_read()
2777
try:
2778
return self._run(tree, branch, relpath, filename, revision,
2779
name_from_revision, filters)
2780
finally:
2781
branch.unlock()
3066
2782
3067
2783
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
3068
2784
filtered):
3069
2785
if tree is None:
3070
2786
tree = b.basis_tree()
3071
2787
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
3072
self.add_cleanup(rev_tree.lock_read().unlock)
3073
2788
3074
2789
old_file_id = rev_tree.path2id(relpath)
3075
2790
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
2791
if name_from_revision:
3081
2792
# Try in revision if requested
3082
2793
if old_file_id is None:
3084
2795
"%r is not present in revision %s" % (
3085
2796
filename, rev_tree.get_revision_id()))
3086
2797
else:
3087
actual_file_id = old_file_id
2798
content = rev_tree.get_file_text(old_file_id)
3088
2799
else:
3089
2800
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:
2801
found = False
2802
if cur_file_id is not None:
2803
# Then try with the actual file id
2804
try:
2805
content = rev_tree.get_file_text(cur_file_id)
2806
found = True
2807
except errors.NoSuchId:
2808
# The actual file id didn't exist at that time
2809
pass
2810
if not found and old_file_id is not None:
2811
# Finally try with the old file id
2812
content = rev_tree.get_file_text(old_file_id)
2813
found = True
2814
if not found:
2815
# Can't be found anywhere
3095
2816
raise errors.BzrCommandError(
3096
2817
"%r is not present in revision %s" % (
3097
2818
filename, rev_tree.get_revision_id()))
3098
2819
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)
2820
from bzrlib.filters import (
2821
ContentFilterContext,
2822
filtered_output_bytes,
2823
)
2824
filters = rev_tree._content_filter_stack(relpath)
2825
chunks = content.splitlines(True)
2826
content = filtered_output_bytes(chunks, filters,
2827
ContentFilterContext(relpath, rev_tree))
2828
self.outf.writelines(content)
3103
2829
else:
3104
content = rev_tree.get_file_text(actual_file_id)
3105
self.cleanup_now()
3106
self.outf.write(content)
2830
self.outf.write(content)
3107
2831
3108
2832
3109
2833
class cmd_local_time_offset(Command):
3110
__doc__ = """Show the offset in seconds from GMT to local time."""
2834
"""Show the offset in seconds from GMT to local time."""
3111
2835
hidden = True
3112
2836
@display_command
3113
2837
def run(self):
3114
self.outf.write("%s\n" % osutils.local_time_offset())
2838
print osutils.local_time_offset()
3115
2839
3116
2840
3117
2841
3118
2842
class cmd_commit(Command):
3119
__doc__ = """Commit changes into a new revision.
2843
"""Commit changes into a new revision.
3120
2844
3121
2845
An explanatory message needs to be given for each commit. This is
3122
2846
often done by using the --message option (getting the message from the
3170
2894
to trigger updates to external systems like bug trackers. The --fixes
3171
2895
option can be used to record the association between a revision and
3172
2896
one or more bugs. See ``bzr help bugs`` for details.
2897
2898
A selective commit may fail in some cases where the committed
2899
tree would be invalid. Consider::
2900
2901
bzr init foo
2902
mkdir foo/bar
2903
bzr add foo/bar
2904
bzr commit foo -m "committing foo"
2905
bzr mv foo/bar foo/baz
2906
mkdir foo/bar
2907
bzr add foo/bar
2908
bzr commit foo/bar -m "committing bar but not baz"
2909
2910
In the example above, the last commit will fail by design. This gives
2911
the user the opportunity to decide whether they want to commit the
2912
rename at the same time, separately first, or not at all. (As a general
2913
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3173
2914
"""
2915
# TODO: Run hooks on tree to-be-committed, and after commit.
2916
2917
# TODO: Strict commit that fails if there are deleted files.
2918
# (what does "deleted files" mean ??)
2919
2920
# TODO: Give better message for -s, --summary, used by tla people
2921
2922
# XXX: verbose currently does nothing
3174
2923
3175
2924
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
3176
2925
takes_args = ['selected*']
3190
2939
Option('strict',
3191
2940
help="Refuse to commit if there are unknown "
3192
2941
"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
2942
ListOption('fixes', type=str,
3197
2943
help="Mark a bug as being fixed by this revision "
3198
2944
"(see \"bzr help bugs\")."),
3205
2951
"the master branch until a normal commit "
3206
2952
"is performed."
3207
2953
),
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.'),
2954
Option('show-diff',
2955
help='When no message is supplied, show the diff along'
2956
' with the status summary in the message editor.'),
3215
2957
]
3216
2958
aliases = ['ci', 'checkin']
3217
2959
3236
2978
3237
2979
def run(self, message=None, file=None, verbose=False, selected_list=None,
3238
2980
unchanged=False, strict=False, local=False, fixes=None,
3239
author=None, show_diff=False, exclude=None, commit_time=None,
3240
lossy=False):
2981
author=None, show_diff=False, exclude=None):
3241
2982
from bzrlib.errors import (
3242
2983
PointlessCommit,
3243
2984
ConflictsInTree,
3246
2987
from bzrlib.msgeditor import (
3247
2988
edit_commit_message_encoded,
3248
2989
generate_commit_message_template,
3249
make_commit_message_template_encoded,
3250
set_commit_message,
2990
make_commit_message_template_encoded
3251
2991
)
3252
2992
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))
2993
# TODO: Need a blackbox test for invoking the external editor; may be
2994
# slightly problematic to run this cross-platform.
2995
2996
# TODO: do more checks that the commit will succeed before
2997
# spending the user's valuable time typing a commit message.
3260
2998
3261
2999
properties = {}
3262
3000
3263
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3001
tree, selected_list = tree_files(selected_list)
3264
3002
if selected_list == ['']:
3265
3003
# workaround - commit of root of tree should be exactly the same
3266
3004
# as just default commit in that tree, and succeed even though
3277
3015
if local and not tree.branch.get_bound_location():
3278
3016
raise errors.LocalRequiresBoundBranch()
3279
3017
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
3018
def get_message(commit_obj):
3302
3019
"""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,
3020
my_message = message
3021
if my_message is None and not file:
3022
t = make_commit_message_template_encoded(tree,
3315
3023
selected_list, diff=show_diff,
3316
3024
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)
3025
start_message = generate_commit_message_template(commit_obj)
3026
my_message = edit_commit_message_encoded(t,
3027
start_message=start_message)
3327
3028
if my_message is None:
3328
3029
raise errors.BzrCommandError("please specify a commit"
3329
3030
" message with either --message or --file")
3031
elif my_message and file:
3032
raise errors.BzrCommandError(
3033
"please specify either --message or --file")
3034
if file:
3035
my_message = codecs.open(file, 'rt',
3036
osutils.get_user_encoding()).read()
3330
3037
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 \"\".")
3038
raise errors.BzrCommandError("empty commit message specified")
3335
3039
return my_message
3336
3040
3337
3041
# The API permits a commit with a filter of [] to mean 'select nothing'
3343
3047
specific_files=selected_list,
3344
3048
allow_pointless=unchanged, strict=strict, local=local,
3345
3049
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)
3050
authors=author,
3051
exclude=safe_relpath_files(tree, exclude))
3350
3052
except PointlessCommit:
3053
# FIXME: This should really happen before the file is read in;
3054
# perhaps prepare the commit; get the message; then actually commit
3351
3055
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.")
3056
" Use --unchanged to commit anyhow.")
3354
3057
except ConflictsInTree:
3355
3058
raise errors.BzrCommandError('Conflicts detected in working '
3356
3059
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3359
3062
raise errors.BzrCommandError("Commit refused because there are"
3360
3063
" unknown files in the working tree.")
3361
3064
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
3065
raise errors.BzrCommandError(str(e) + "\n"
3066
'To commit to master branch, run update and then commit.\n'
3067
'You can also pass --local to commit to continue working '
3068
'disconnected.')
3367
3069
3368
3070
3369
3071
class cmd_check(Command):
3370
__doc__ = """Validate working tree structure, branch consistency and repository history.
3072
"""Validate working tree structure, branch consistency and repository history.
3371
3073
3372
3074
This command checks various invariants about branch and repository storage
3373
3075
to detect data corruption or bzr bugs.
3437
3139
3438
3140
3439
3141
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/.
3142
"""Upgrade branch storage to current format.
3143
3144
The check command or bzr developers may sometimes advise you to run
3145
this command. When the default format has changed you may also be warned
3146
during other operations to upgrade.
3470
3147
"""
3471
3148
3472
_see_also = ['check', 'reconcile', 'formats']
3149
_see_also = ['check']
3473
3150
takes_args = ['url?']
3474
3151
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
]
3152
RegistryOption('format',
3153
help='Upgrade to a specific format. See "bzr help'
3154
' formats" for details.',
3155
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3156
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3157
value_switches=True, title='Branch format'),
3158
]
3486
3159
3487
def run(self, url='.', format=None, clean=False, dry_run=False):
3160
def run(self, url='.', format=None):
3488
3161
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
3162
upgrade(url, format)
3496
3163
3497
3164
3498
3165
class cmd_whoami(Command):
3499
__doc__ = """Show or set bzr user id.
3166
"""Show or set bzr user id.
3500
3167
3501
3168
:Examples:
3502
3169
Show the email of the current user::
3507
3174
3508
3175
bzr whoami "Frank Chu <fchu@example.com>"
3509
3176
"""
3510
takes_options = [ 'directory',
3511
Option('email',
3177
takes_options = [ Option('email',
3512
3178
help='Display email address only.'),
3513
3179
Option('branch',
3514
3180
help='Set identity for the current branch instead of '
3518
3184
encoding_type = 'replace'
3519
3185
3520
3186
@display_command
3521
def run(self, email=False, branch=False, name=None, directory=None):
3187
def run(self, email=False, branch=False, name=None):
3522
3188
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()
3189
# use branch if we're inside one; otherwise global config
3190
try:
3191
c = Branch.open_containing('.')[0].get_config()
3192
except errors.NotBranchError:
3193
c = config.GlobalConfig()
3531
3194
if email:
3532
3195
self.outf.write(c.user_email() + '\n')
3533
3196
else:
3534
3197
self.outf.write(c.username() + '\n')
3535
3198
return
3536
3199
3537
if email:
3538
raise errors.BzrCommandError("--email can only be used to display existing "
3539
"identity")
3540
3541
3200
# display a warning if an email address isn't included in the given name.
3542
3201
try:
3543
_mod_config.extract_email_address(name)
3202
config.extract_email_address(name)
3544
3203
except errors.NoEmailInUsername, e:
3545
3204
warning('"%s" does not seem to contain an email address. '
3546
3205
'This is allowed, but not recommended.', name)
3547
3206
3548
3207
# use global config unless --branch given
3549
3208
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()
3209
c = Branch.open_containing('.')[0].get_config()
3554
3210
else:
3555
c = _mod_config.GlobalConfig()
3211
c = config.GlobalConfig()
3556
3212
c.set_user_option('email', name)
3557
3213
3558
3214
3559
3215
class cmd_nick(Command):
3560
__doc__ = """Print or set the branch nickname.
3216
"""Print or set the branch nickname.
3561
3217
3562
3218
If unset, the tree root directory name is used as the nickname.
3563
3219
To print the current nickname, execute with no argument.
3568
3224
3569
3225
_see_also = ['info']
3570
3226
takes_args = ['nickname?']
3571
takes_options = ['directory']
3572
def run(self, nickname=None, directory=u'.'):
3573
branch = Branch.open_containing(directory)[0]
3227
def run(self, nickname=None):
3228
branch = Branch.open_containing(u'.')[0]
3574
3229
if nickname is None:
3575
3230
self.printme(branch)
3576
3231
else:
3578
3233
3579
3234
@display_command
3580
3235
def printme(self, branch):
3581
self.outf.write('%s\n' % branch.nick)
3236
print branch.nick
3582
3237
3583
3238
3584
3239
class cmd_alias(Command):
3585
__doc__ = """Set/unset and display aliases.
3240
"""Set/unset and display aliases.
3586
3241
3587
3242
:Examples:
3588
3243
Show the current aliases::
3625
3280
'bzr alias --remove expects an alias to remove.')
3626
3281
# If alias is not found, print something like:
3627
3282
# unalias: foo: not found
3628
c = _mod_config.GlobalConfig()
3283
c = config.GlobalConfig()
3629
3284
c.unset_alias(alias_name)
3630
3285
3631
3286
@display_command
3632
3287
def print_aliases(self):
3633
3288
"""Print out the defined aliases in a similar format to bash."""
3634
aliases = _mod_config.GlobalConfig().get_aliases()
3289
aliases = config.GlobalConfig().get_aliases()
3635
3290
for key, value in sorted(aliases.iteritems()):
3636
3291
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3637
3292
3647
3302
3648
3303
def set_alias(self, alias_name, alias_command):
3649
3304
"""Save the alias in the global config."""
3650
c = _mod_config.GlobalConfig()
3305
c = config.GlobalConfig()
3651
3306
c.set_alias(alias_name, alias_command)
3652
3307
3653
3308
3654
3309
class cmd_selftest(Command):
3655
__doc__ = """Run internal test suite.
3310
"""Run internal test suite.
3656
3311
3657
3312
If arguments are given, they are regular expressions that say which tests
3658
3313
should run. Tests matching any expression are run, and other tests are
3688
3343
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3689
3344
into a pdb postmortem session.
3690
3345
3691
The --coverage=DIRNAME global option produces a report with covered code
3692
indicated.
3693
3694
3346
:Examples:
3695
3347
Run only tests relating to 'ignore'::
3696
3348
3705
3357
def get_transport_type(typestring):
3706
3358
"""Parse and return a transport specifier."""
3707
3359
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
3360
from bzrlib.transport.sftp import SFTPAbsoluteServer
3361
return SFTPAbsoluteServer
3362
if typestring == "memory":
3363
from bzrlib.transport.memory import MemoryServer
3364
return MemoryServer
3365
if typestring == "fakenfs":
3366
from bzrlib.transport.fakenfs import FakeNFSServer
3367
return FakeNFSServer
3716
3368
msg = "No known transport type %s. Supported types are: sftp\n" %\
3717
3369
(typestring)
3718
3370
raise errors.BzrCommandError(msg)
3729
3381
'throughout the test suite.',
3730
3382
type=get_transport_type),
3731
3383
Option('benchmark',
3732
help='Run the benchmarks rather than selftests.',
3733
hidden=True),
3384
help='Run the benchmarks rather than selftests.'),
3734
3385
Option('lsprof-timed',
3735
3386
help='Generate lsprof output for benchmarked'
3736
3387
' sections of code.'),
3737
3388
Option('lsprof-tests',
3738
3389
help='Generate lsprof output for each test.'),
3390
Option('cache-dir', type=str,
3391
help='Cache intermediate benchmark output in this '
3392
'directory.'),
3739
3393
Option('first',
3740
3394
help='Run all tests, but run specified tests first.',
3741
3395
short_name='f',
3750
3404
Option('randomize', type=str, argname="SEED",
3751
3405
help='Randomize the order of tests using the given'
3752
3406
' 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.'),
3407
Option('exclude', type=str, argname="PATTERN",
3408
short_name='x',
3409
help='Exclude tests that match this regular'
3410
' expression.'),
3757
3411
Option('subunit',
3758
3412
help='Output test progress via subunit.'),
3759
3413
Option('strict', help='Fail on missing dependencies or '
3775
3429
3776
3430
def run(self, testspecs_list=None, verbose=False, one=False,
3777
3431
transport=None, benchmark=None,
3778
lsprof_timed=None,
3432
lsprof_timed=None, cache_dir=None,
3779
3433
first=False, list_only=False,
3780
3434
randomize=None, exclude=None, strict=False,
3781
3435
load_list=None, debugflag=None, starting_with=None, subunit=False,
3782
3436
parallel=None, lsprof_tests=False):
3783
from bzrlib import tests
3784
3437
from bzrlib.tests import selftest
3438
import bzrlib.benchmarks as benchmarks
3439
from bzrlib.benchmarks import tree_creator
3440
3441
# Make deprecation warnings visible, unless -Werror is set
3442
symbol_versioning.activate_deprecation_warnings(override=False)
3443
3444
if cache_dir is not None:
3445
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3785
3446
if testspecs_list is not None:
3786
3447
pattern = '|'.join(testspecs_list)
3787
3448
else:
3793
3454
raise errors.BzrCommandError("subunit not available. subunit "
3794
3455
"needs to be installed to use --subunit.")
3795
3456
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
3457
if parallel:
3806
3458
self.additional_selftest_args.setdefault(
3807
3459
'suite_decorators', []).append(parallel)
3808
3460
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
3461
test_suite_factory = benchmarks.test_suite
3462
# Unless user explicitly asks for quiet, be verbose in benchmarks
3463
verbose = not is_quiet()
3464
# TODO: should possibly lock the history file...
3465
benchfile = open(".perf_history", "at", buffering=1)
3815
3466
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)
3467
test_suite_factory = None
3468
benchfile = None
3838
3469
try:
3839
result = tests.selftest(**selftest_kwargs)
3470
selftest_kwargs = {"verbose": verbose,
3471
"pattern": pattern,
3472
"stop_on_failure": one,
3473
"transport": transport,
3474
"test_suite_factory": test_suite_factory,
3475
"lsprof_timed": lsprof_timed,
3476
"lsprof_tests": lsprof_tests,
3477
"bench_history": benchfile,
3478
"matching_tests_first": first,
3479
"list_only": list_only,
3480
"random_seed": randomize,
3481
"exclude_pattern": exclude,
3482
"strict": strict,
3483
"load_list": load_list,
3484
"debug_flags": debugflag,
3485
"starting_with": starting_with
3486
}
3487
selftest_kwargs.update(self.additional_selftest_args)
3488
result = selftest(**selftest_kwargs)
3840
3489
finally:
3841
cleanup()
3490
if benchfile is not None:
3491
benchfile.close()
3842
3492
return int(not result)
3843
3493
3844
3494
3845
3495
class cmd_version(Command):
3846
__doc__ = """Show version of bzr."""
3496
"""Show version of bzr."""
3847
3497
3848
3498
encoding_type = 'replace'
3849
3499
takes_options = [
3860
3510
3861
3511
3862
3512
class cmd_rocks(Command):
3863
__doc__ = """Statement of optimism."""
3513
"""Statement of optimism."""
3864
3514
3865
3515
hidden = True
3866
3516
3867
3517
@display_command
3868
3518
def run(self):
3869
self.outf.write("It sure does!\n")
3519
print "It sure does!"
3870
3520
3871
3521
3872
3522
class cmd_find_merge_base(Command):
3873
__doc__ = """Find and print a base revision for merging two branches."""
3523
"""Find and print a base revision for merging two branches."""
3874
3524
# TODO: Options to specify revisions on either side, as if
3875
3525
# merging only part of the history.
3876
3526
takes_args = ['branch', 'other']
3882
3532
3883
3533
branch1 = Branch.open_containing(branch)[0]
3884
3534
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)
3535
branch1.lock_read()
3536
try:
3537
branch2.lock_read()
3538
try:
3539
last1 = ensure_null(branch1.last_revision())
3540
last2 = ensure_null(branch2.last_revision())
3541
3542
graph = branch1.repository.get_graph(branch2.repository)
3543
base_rev_id = graph.find_unique_lca(last1, last2)
3544
3545
print 'merge base is revision %s' % base_rev_id
3546
finally:
3547
branch2.unlock()
3548
finally:
3549
branch1.unlock()
3894
3550
3895
3551
3896
3552
class cmd_merge(Command):
3897
__doc__ = """Perform a three-way merge.
3553
"""Perform a three-way merge.
3898
3554
3899
3555
The source of the merge can be specified either in the form of a branch,
3900
3556
or in the form of a path to a file containing a merge directive generated
3901
3557
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.
3558
or the branch most recently merged using --remember.
3559
3560
When merging a branch, by default the tip will be merged. To pick a different
3561
revision, pass --revision. If you specify two values, the first will be used as
3562
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3563
available revisions, like this is commonly referred to as "cherrypicking".
3564
3565
Revision numbers are always relative to the branch being merged.
3566
3567
By default, bzr will try to merge in all new work from the other
3568
branch, automatically determining an appropriate base. If this
3569
fails, you may need to give an explicit base.
3923
3570
3924
3571
Merge will do its best to combine the changes in two branches, but there
3925
3572
are some kinds of problems only a human can fix. When it encounters those,
3928
3575
3929
3576
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3930
3577
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.
3578
If there is no default branch set, the first merge will set it. After
3579
that, you can omit the branch to use the default. To change the
3580
default, use --remember. The value will only be saved if the remote
3581
location can be accessed.
3935
3582
3936
3583
The results of the merge are placed into the destination working
3937
3584
directory, where they can be reviewed (with bzr diff), tested, and then
3938
3585
committed to record the result of the merge.
3939
3586
3940
3587
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.
3588
--force is given.
3949
3589
3950
3590
To select only some changes to merge, use "merge -i", which will prompt
3951
3591
you to apply each diff hunk and file change, similar to "shelve".
3952
3592
3953
3593
:Examples:
3954
To merge all new revisions from bzr.dev::
3594
To merge the latest revision from bzr.dev::
3955
3595
3956
3596
bzr merge ../bzr.dev
3957
3597
3963
3603
3964
3604
bzr merge -r 81..82 ../bzr.dev
3965
3605
3966
To apply a merge directive contained in /tmp/merge::
3606
To apply a merge directive contained in /tmp/merge:
3967
3607
3968
3608
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
3609
"""
3977
3610
3978
3611
encoding_type = 'exact'
3994
3627
' completely merged into the source, pull from the'
3995
3628
' source rather than merging. When this happens,'
3996
3629
' you do not need to commit the result.'),
3997
custom_help('directory',
3630
Option('directory',
3998
3631
help='Branch to merge into, '
3999
'rather than the one containing the working directory.'),
3632
'rather than the one containing the working directory.',
3633
short_name='d',
3634
type=unicode,
3635
),
4000
3636
Option('preview', help='Instead of merging, show a diff of the'
4001
3637
' merge.'),
4002
3638
Option('interactive', help='Select changes interactively.',
4004
3640
]
4005
3641
4006
3642
def run(self, location=None, revision=None, force=False,
4007
merge_type=None, show_base=False, reprocess=None, remember=None,
3643
merge_type=None, show_base=False, reprocess=None, remember=False,
4008
3644
uncommitted=False, pull=False,
4009
3645
directory=None,
4010
3646
preview=False,
4018
3654
merger = None
4019
3655
allow_pending = True
4020
3656
verified = 'inapplicable'
4021
4022
3657
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
3658
4027
3659
try:
4028
3660
basis_tree = tree.revision_tree(tree.last_revision())
4031
3663
4032
3664
# die as quickly as possible if there are uncommitted changes
4033
3665
if not force:
4034
if tree.has_changes():
3666
if tree.has_changes(basis_tree) or len(tree.get_parent_ids()) > 1:
4035
3667
raise errors.UncommittedChanges(tree)
4036
3668
4037
3669
view_info = _get_view_info_for_change_reporter(tree)
4038
3670
change_reporter = delta._ChangeReporter(
4039
3671
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
3672
cleanups = []
3673
try:
3674
pb = ui.ui_factory.nested_progress_bar()
3675
cleanups.append(pb.finished)
3676
tree.lock_write()
3677
cleanups.append(tree.unlock)
3678
if location is not None:
3679
try:
3680
mergeable = bundle.read_mergeable_from_url(location,
3681
possible_transports=possible_transports)
3682
except errors.NotABundle:
3683
mergeable = None
3684
else:
3685
if uncommitted:
3686
raise errors.BzrCommandError('Cannot use --uncommitted'
3687
' with bundles or merge directives.')
3688
3689
if revision is not None:
3690
raise errors.BzrCommandError(
3691
'Cannot use -r with merge directives or bundles')
3692
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3693
mergeable, pb)
3694
3695
if merger is None and uncommitted:
3696
if revision is not None and len(revision) > 0:
3697
raise errors.BzrCommandError('Cannot use --uncommitted and'
3698
' --revision at the same time.')
3699
merger = self.get_merger_from_uncommitted(tree, location, pb,
3700
cleanups)
3701
allow_pending = False
3702
3703
if merger is None:
3704
merger, allow_pending = self._get_merger_from_branch(tree,
3705
location, revision, remember, possible_transports, pb)
3706
3707
merger.merge_type = merge_type
3708
merger.reprocess = reprocess
3709
merger.show_base = show_base
3710
self.sanity_check_merger(merger)
3711
if (merger.base_rev_id == merger.other_rev_id and
3712
merger.other_rev_id is not None):
3713
note('Nothing to do.')
3714
return 0
3715
if pull:
3716
if merger.interesting_files is not None:
3717
raise errors.BzrCommandError('Cannot pull individual files')
3718
if (merger.base_rev_id == tree.last_revision()):
3719
result = tree.pull(merger.other_branch, False,
3720
merger.other_rev_id)
3721
result.report(self.outf)
3722
return 0
3723
merger.check_basis(False)
3724
if preview:
3725
return self._do_preview(merger, cleanups)
3726
elif interactive:
3727
return self._do_interactive(merger, cleanups)
4049
3728
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):
3729
return self._do_merge(merger, change_reporter, allow_pending,
3730
verified)
3731
finally:
3732
for cleanup in reversed(cleanups):
3733
cleanup()
3734
3735
def _get_preview(self, merger, cleanups):
4107
3736
tree_merger = merger.make_merger()
4108
3737
tt = tree_merger.make_preview_transform()
4109
self.add_cleanup(tt.finalize)
3738
cleanups.append(tt.finalize)
4110
3739
result_tree = tt.get_preview_tree()
4111
3740
return result_tree
4112
3741
4113
def _do_preview(self, merger):
3742
def _do_preview(self, merger, cleanups):
4114
3743
from bzrlib.diff import show_diff_trees
4115
result_tree = self._get_preview(merger)
4116
path_encoding = osutils.get_diff_header_encoding()
3744
result_tree = self._get_preview(merger, cleanups)
4117
3745
show_diff_trees(merger.this_tree, result_tree, self.outf,
4118
old_label='', new_label='',
4119
path_encoding=path_encoding)
3746
old_label='', new_label='')
4120
3747
4121
3748
def _do_merge(self, merger, change_reporter, allow_pending, verified):
4122
3749
merger.change_reporter = change_reporter
4130
3757
else:
4131
3758
return 0
4132
3759
4133
def _do_interactive(self, merger):
3760
def _do_interactive(self, merger, cleanups):
4134
3761
"""Perform an interactive merge.
4135
3762
4136
3763
This works by generating a preview tree of the merge, then using
4138
3765
and the preview tree.
4139
3766
"""
4140
3767
from bzrlib import shelf_ui
4141
result_tree = self._get_preview(merger)
3768
result_tree = self._get_preview(merger, cleanups)
4142
3769
writer = bzrlib.option.diff_writer_registry.get()
4143
3770
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
4144
3771
reporter=shelf_ui.ApplyReporter(),
4145
3772
diff_writer=writer(sys.stdout))
4146
try:
4147
shelver.run()
4148
finally:
4149
shelver.finalize()
3773
shelver.run()
4150
3774
4151
3775
def sanity_check_merger(self, merger):
4152
3776
if (merger.show_base and
4198
3822
if other_revision_id is None:
4199
3823
other_revision_id = _mod_revision.ensure_null(
4200
3824
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)))):
3825
# Remember where we merge from
3826
if ((remember or tree.branch.get_submit_branch() is None) and
3827
user_location is not None):
4210
3828
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)
3829
_merge_tags_if_possible(other_branch, tree.branch)
4214
3830
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4215
3831
other_revision_id, base_revision_id, other_branch, base_branch)
4216
3832
if other_path != '':
4220
3836
allow_pending = True
4221
3837
return merger, allow_pending
4222
3838
4223
def get_merger_from_uncommitted(self, tree, location, pb):
3839
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
4224
3840
"""Get a merger for uncommitted changes.
4225
3841
4226
3842
:param tree: The tree the merger should apply to.
4227
3843
:param location: The location containing uncommitted changes.
4228
3844
:param pb: The progress bar to use for showing progress.
3845
:param cleanups: A list of operations to perform to clean up the
3846
temporary directories, unfinalized objects, etc.
4229
3847
"""
4230
3848
location = self._select_branch_location(tree, location)[0]
4231
3849
other_tree, other_path = WorkingTree.open_containing(location)
4283
3901
4284
3902
4285
3903
class cmd_remerge(Command):
4286
__doc__ = """Redo a merge.
3904
"""Redo a merge.
4287
3905
4288
3906
Use this if you want to try a different merge technique while resolving
4289
3907
conflicts. Some merge techniques are better than others, and remerge
4314
3932
4315
3933
def run(self, file_list=None, merge_type=None, show_base=False,
4316
3934
reprocess=False):
4317
from bzrlib.conflicts import restore
4318
3935
if merge_type is None:
4319
3936
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
3937
tree, file_list = tree_files(file_list)
3938
tree.lock_write()
3939
try:
3940
parents = tree.get_parent_ids()
3941
if len(parents) != 2:
3942
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3943
" merges. Not cherrypicking or"
3944
" multi-merges.")
3945
repository = tree.branch.repository
3946
interesting_ids = None
3947
new_conflicts = []
3948
conflicts = tree.conflicts()
3949
if file_list is not None:
3950
interesting_ids = set()
3951
for filename in file_list:
3952
file_id = tree.path2id(filename)
3953
if file_id is None:
3954
raise errors.NotVersionedError(filename)
3955
interesting_ids.add(file_id)
3956
if tree.kind(file_id) != "directory":
3957
continue
4340
3958
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:
3959
for name, ie in tree.inventory.iter_entries(file_id):
3960
interesting_ids.add(ie.file_id)
3961
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3962
else:
3963
# Remerge only supports resolving contents conflicts
3964
allowed_conflicts = ('text conflict', 'contents conflict')
3965
restore_files = [c.path for c in conflicts
3966
if c.typestring in allowed_conflicts]
3967
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3968
tree.set_conflicts(ConflictList(new_conflicts))
3969
if file_list is not None:
3970
restore_files = file_list
3971
for filename in restore_files:
3972
try:
3973
restore(tree.abspath(filename))
3974
except errors.NotConflicted:
3975
pass
3976
# Disable pending merges, because the file texts we are remerging
3977
# have not had those merges performed. If we use the wrong parents
3978
# list, we imply that the working tree text has seen and rejected
3979
# all the changes from the other tree, when in fact those changes
3980
# have not yet been seen.
3981
pb = ui.ui_factory.nested_progress_bar()
3982
tree.set_parent_ids(parents[:1])
4354
3983
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()
3984
merger = _mod_merge.Merger.from_revision_ids(pb,
3985
tree, parents[1])
3986
merger.interesting_ids = interesting_ids
3987
merger.merge_type = merge_type
3988
merger.show_base = show_base
3989
merger.reprocess = reprocess
3990
conflicts = merger.do_merge()
3991
finally:
3992
tree.set_parent_ids(parents)
3993
pb.finished()
4371
3994
finally:
4372
tree.set_parent_ids(parents)
3995
tree.unlock()
4373
3996
if conflicts > 0:
4374
3997
return 1
4375
3998
else:
4377
4000
4378
4001
4379
4002
class cmd_revert(Command):
4380
__doc__ = """Revert files to a previous revision.
4003
"""Revert files to a previous revision.
4381
4004
4382
4005
Giving a list of files will revert only those files. Otherwise, all files
4383
4006
will be reverted. If the revision is not specified with '--revision', the
4384
4007
last committed revision is used.
4385
4008
4386
4009
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.
4010
merge instead. For example, "merge . --revision -2..-3" will remove the
4011
changes introduced by -2, without affecting the changes introduced by -1.
4012
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4391
4013
4392
4014
By default, any files that have been manually changed will be backed up
4393
4015
first. (Files changed only by merge are not backed up.) Backup files have
4398
4020
name. If you name a directory, all the contents of that directory will be
4399
4021
reverted.
4400
4022
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.
4023
Any files that have been newly added since that revision will be deleted,
4024
with a backup kept if appropriate. Directories containing unknown files
4025
will not be deleted.
4405
4026
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
4027
The working tree contains a list of pending merged revisions, which will
4028
be included as parents in the next commit. Normally, revert clears that
4029
list as well as reverting the files. If any files are specified, revert
4030
leaves the pending merge list alone and reverts only the files. Use "bzr
4031
revert ." in the tree root to revert all files but keep the merge record,
4032
and "bzr revert --forget-merges" to clear the pending merge list without
4413
4033
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
4034
"""
4425
4035
4426
_see_also = ['cat', 'export', 'merge', 'shelve']
4036
_see_also = ['cat', 'export']
4427
4037
takes_options = [
4428
4038
'revision',
4429
4039
Option('no-backup', "Do not save backups of reverted files."),
4434
4044
4435
4045
def run(self, revision=None, no_backup=False, file_list=None,
4436
4046
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)
4047
tree, file_list = tree_files(file_list)
4048
tree.lock_write()
4049
try:
4050
if forget_merges:
4051
tree.set_parent_ids(tree.get_parent_ids()[:1])
4052
else:
4053
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4054
finally:
4055
tree.unlock()
4443
4056
4444
4057
@staticmethod
4445
4058
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4446
4059
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)
4060
pb = ui.ui_factory.nested_progress_bar()
4061
try:
4062
tree.revert(file_list, rev_tree, not no_backup, pb,
4063
report_changes=True)
4064
finally:
4065
pb.finished()
4449
4066
4450
4067
4451
4068
class cmd_assert_fail(Command):
4452
__doc__ = """Test reporting of assertion failures"""
4069
"""Test reporting of assertion failures"""
4453
4070
# intended just for use in testing
4454
4071
4455
4072
hidden = True
4459
4076
4460
4077
4461
4078
class cmd_help(Command):
4462
__doc__ = """Show help on a command or other topic.
4079
"""Show help on a command or other topic.
4463
4080
"""
4464
4081
4465
4082
_see_also = ['topics']
4478
4095
4479
4096
4480
4097
class cmd_shell_complete(Command):
4481
__doc__ = """Show appropriate completions for context.
4098
"""Show appropriate completions for context.
4482
4099
4483
4100
For a list of all available commands, say 'bzr shell-complete'.
4484
4101
"""
4493
4110
4494
4111
4495
4112
class cmd_missing(Command):
4496
__doc__ = """Show unmerged/unpulled revisions between two branches.
4113
"""Show unmerged/unpulled revisions between two branches.
4497
4114
4498
4115
OTHER_BRANCH may be local or remote.
4499
4116
4500
4117
To filter on a range of revisions, you can use the command -r begin..end
4501
4118
-r revision requests a specific revision, -r ..end or -r begin.. are
4502
4119
also valid.
4503
4504
:Exit values:
4505
1 - some missing revisions
4506
0 - no missing revisions
4507
4120
4508
4121
:Examples:
4509
4122
4530
4143
_see_also = ['merge', 'pull']
4531
4144
takes_args = ['other_branch?']
4532
4145
takes_options = [
4533
'directory',
4534
4146
Option('reverse', 'Reverse the order of revisions.'),
4535
4147
Option('mine-only',
4536
4148
'Display changes in the local branch only.'),
4558
4170
theirs_only=False,
4559
4171
log_format=None, long=False, short=False, line=False,
4560
4172
show_ids=False, verbose=False, this=False, other=False,
4561
include_merges=False, revision=None, my_revision=None,
4562
directory=u'.'):
4173
include_merges=False, revision=None, my_revision=None):
4563
4174
from bzrlib.missing import find_unmerged, iter_log_revisions
4564
4175
def message(s):
4565
4176
if not is_quiet():
4578
4189
elif theirs_only:
4579
4190
restrict = 'remote'
4580
4191
4581
local_branch = Branch.open_containing(directory)[0]
4582
self.add_cleanup(local_branch.lock_read().unlock)
4583
4192
local_branch = Branch.open_containing(u".")[0]
4584
4193
parent = local_branch.get_parent()
4585
4194
if other_branch is None:
4586
4195
other_branch = parent
4595
4204
remote_branch = Branch.open(other_branch)
4596
4205
if remote_branch.base == local_branch.base:
4597
4206
remote_branch = local_branch
4598
else:
4599
self.add_cleanup(remote_branch.lock_read().unlock)
4600
4207
4601
4208
local_revid_range = _revision_range_to_revid_range(
4602
4209
_get_revision_range(my_revision, local_branch,
4606
4213
_get_revision_range(revision,
4607
4214
remote_branch, self.name()))
4608
4215
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()
4216
local_branch.lock_read()
4217
try:
4218
remote_branch.lock_read()
4219
try:
4220
local_extra, remote_extra = find_unmerged(
4221
local_branch, remote_branch, restrict,
4222
backward=not reverse,
4223
include_merges=include_merges,
4224
local_revid_range=local_revid_range,
4225
remote_revid_range=remote_revid_range)
4226
4227
if log_format is None:
4228
registry = log.log_formatter_registry
4229
log_format = registry.get_default(local_branch)
4230
lf = log_format(to_file=self.outf,
4231
show_ids=show_ids,
4232
show_timezone='original')
4233
4234
status_code = 0
4235
if local_extra and not theirs_only:
4236
message("You have %d extra revision(s):\n" %
4237
len(local_extra))
4238
for revision in iter_log_revisions(local_extra,
4239
local_branch.repository,
4240
verbose):
4241
lf.log_revision(revision)
4242
printed_local = True
4243
status_code = 1
4244
else:
4245
printed_local = False
4246
4247
if remote_extra and not mine_only:
4248
if printed_local is True:
4249
message("\n\n\n")
4250
message("You are missing %d revision(s):\n" %
4251
len(remote_extra))
4252
for revision in iter_log_revisions(remote_extra,
4253
remote_branch.repository,
4254
verbose):
4255
lf.log_revision(revision)
4256
status_code = 1
4257
4258
if mine_only and not local_extra:
4259
# We checked local, and found nothing extra
4260
message('This branch is up to date.\n')
4261
elif theirs_only and not remote_extra:
4262
# We checked remote, and found nothing extra
4263
message('Other branch is up to date.\n')
4264
elif not (mine_only or theirs_only or local_extra or
4265
remote_extra):
4266
# We checked both branches, and neither one had extra
4267
# revisions
4268
message("Branches are up to date.\n")
4269
finally:
4270
remote_branch.unlock()
4271
finally:
4272
local_branch.unlock()
4659
4273
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)
4274
local_branch.lock_write()
4275
try:
4276
# handle race conditions - a parent might be set while we run.
4277
if local_branch.get_parent() is None:
4278
local_branch.set_parent(remote_branch.base)
4279
finally:
4280
local_branch.unlock()
4664
4281
return status_code
4665
4282
4666
4283
4667
4284
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
"""
4285
"""Compress the data within a repository."""
4685
4286
4686
4287
_see_also = ['repositories']
4687
4288
takes_args = ['branch_or_repo?']
4688
takes_options = [
4689
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4690
]
4691
4289
4692
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4290
def run(self, branch_or_repo='.'):
4693
4291
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4694
4292
try:
4695
4293
branch = dir.open_branch()
4696
4294
repository = branch.repository
4697
4295
except errors.NotBranchError:
4698
4296
repository = dir.open_repository()
4699
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4297
repository.pack()
4700
4298
4701
4299
4702
4300
class cmd_plugins(Command):
4703
__doc__ = """List the installed plugins.
4301
"""List the installed plugins.
4704
4302
4705
4303
This command displays the list of installed plugins including
4706
4304
version of plugin and a short description of each.
4713
4311
adding new commands, providing additional network transports and
4714
4312
customizing log output.
4715
4313
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.
4314
See the Bazaar web site, http://bazaar-vcs.org, for further
4315
information on plugins including where to find them and how to
4316
install them. Instructions are also provided there on how to
4317
write new plugins using the Python programming language.
4720
4318
"""
4721
4319
takes_options = ['verbose']
4722
4320
4723
4321
@display_command
4724
4322
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)))
4323
import bzrlib.plugin
4324
from inspect import getdoc
4325
result = []
4326
for name, plugin in bzrlib.plugin.plugins().items():
4327
version = plugin.__version__
4328
if version == 'unknown':
4329
version = ''
4330
name_ver = '%s %s' % (name, version)
4331
d = getdoc(plugin.module)
4332
if d:
4333
doc = d.split('\n')[0]
4334
else:
4335
doc = '(no description)'
4336
result.append((name_ver, doc, plugin.path()))
4337
for name_ver, doc, path in sorted(result):
4338
print name_ver
4339
print ' ', doc
4340
if verbose:
4341
print ' ', path
4342
print
4729
4343
4730
4344
4731
4345
class cmd_testament(Command):
4732
__doc__ = """Show testament (signing-form) of a revision."""
4346
"""Show testament (signing-form) of a revision."""
4733
4347
takes_options = [
4734
4348
'revision',
4735
4349
Option('long', help='Produce long-format testament.'),
4747
4361
b = Branch.open_containing(branch)[0]
4748
4362
else:
4749
4363
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())
4364
b.lock_read()
4365
try:
4366
if revision is None:
4367
rev_id = b.last_revision()
4368
else:
4369
rev_id = revision[0].as_revision_id(b)
4370
t = testament_class.from_revision(b.repository, rev_id)
4371
if long:
4372
sys.stdout.writelines(t.as_text_lines())
4373
else:
4374
sys.stdout.write(t.as_short_text())
4375
finally:
4376
b.unlock()
4760
4377
4761
4378
4762
4379
class cmd_annotate(Command):
4763
__doc__ = """Show the origin of each line in a file.
4380
"""Show the origin of each line in a file.
4764
4381
4765
4382
This prints out the given file with an annotation on the left side
4766
4383
indicating which revision, author and date introduced the change.
4777
4394
Option('long', help='Show commit date in annotations.'),
4778
4395
'revision',
4779
4396
'show-ids',
4780
'directory',
4781
4397
]
4782
4398
encoding_type = 'exact'
4783
4399
4784
4400
@display_command
4785
4401
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
)
4402
show_ids=False):
4403
from bzrlib.annotate import annotate_file, annotate_file_tree
4790
4404
wt, branch, relpath = \
4791
_open_directory_or_containing_tree_or_branch(filename, directory)
4405
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4792
4406
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)
4407
wt.lock_read()
4408
else:
4409
branch.lock_read()
4410
try:
4411
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4412
if wt is not None:
4413
file_id = wt.path2id(relpath)
4414
else:
4415
file_id = tree.path2id(relpath)
4416
if file_id is None:
4417
raise errors.NotVersionedError(filename)
4418
file_version = tree.inventory[file_id].revision
4419
if wt is not None and revision is None:
4420
# If there is a tree and we're not annotating historical
4421
# versions, annotate the working tree's content.
4422
annotate_file_tree(wt, file_id, self.outf, long, all,
4423
show_ids=show_ids)
4424
else:
4425
annotate_file(branch, file_version, file_id, long, all, self.outf,
4426
show_ids=show_ids)
4427
finally:
4428
if wt is not None:
4429
wt.unlock()
4430
else:
4431
branch.unlock()
4812
4432
4813
4433
4814
4434
class cmd_re_sign(Command):
4815
__doc__ = """Create a digital signature for an existing revision."""
4435
"""Create a digital signature for an existing revision."""
4816
4436
# TODO be able to replace existing ones.
4817
4437
4818
4438
hidden = True # is this right ?
4819
4439
takes_args = ['revision_id*']
4820
takes_options = ['directory', 'revision']
4440
takes_options = ['revision']
4821
4441
4822
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4442
def run(self, revision_id_list=None, revision=None):
4823
4443
if revision_id_list is not None and revision is not None:
4824
4444
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4825
4445
if revision_id_list is None and revision is None:
4826
4446
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)
4447
b = WorkingTree.open_containing(u'.')[0].branch
4448
b.lock_write()
4449
try:
4450
return self._run(b, revision_id_list, revision)
4451
finally:
4452
b.unlock()
4830
4453
4831
4454
def _run(self, b, revision_id_list, revision):
4832
4455
import bzrlib.gpg as gpg
4877
4500
4878
4501
4879
4502
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.
4503
"""Convert the current branch into a checkout of the supplied branch.
4882
4504
4883
4505
Once converted into a checkout, commits must succeed on the master branch
4884
4506
before they will be applied to the local branch.
4885
4507
4886
4508
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
4509
locally, in which case binding will update the the local nickname to be
4888
4510
that of the master.
4889
4511
"""
4890
4512
4891
4513
_see_also = ['checkouts', 'unbind']
4892
4514
takes_args = ['location?']
4893
takes_options = ['directory']
4515
takes_options = []
4894
4516
4895
def run(self, location=None, directory=u'.'):
4896
b, relpath = Branch.open_containing(directory)
4517
def run(self, location=None):
4518
b, relpath = Branch.open_containing(u'.')
4897
4519
if location is None:
4898
4520
try:
4899
4521
location = b.get_old_bound_location()
4902
4524
'This format does not remember old locations.')
4903
4525
else:
4904
4526
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')
4527
raise errors.BzrCommandError('No location supplied and no '
4528
'previous location known')
4910
4529
b_other = Branch.open(location)
4911
4530
try:
4912
4531
b.bind(b_other)
4918
4537
4919
4538
4920
4539
class cmd_unbind(Command):
4921
__doc__ = """Convert the current checkout into a regular branch.
4540
"""Convert the current checkout into a regular branch.
4922
4541
4923
4542
After unbinding, the local branch is considered independent and subsequent
4924
4543
commits will be local only.
4926
4545
4927
4546
_see_also = ['checkouts', 'bind']
4928
4547
takes_args = []
4929
takes_options = ['directory']
4548
takes_options = []
4930
4549
4931
def run(self, directory=u'.'):
4932
b, relpath = Branch.open_containing(directory)
4550
def run(self):
4551
b, relpath = Branch.open_containing(u'.')
4933
4552
if not b.unbind():
4934
4553
raise errors.BzrCommandError('Local branch is not bound')
4935
4554
4936
4555
4937
4556
class cmd_uncommit(Command):
4938
__doc__ = """Remove the last committed revision.
4557
"""Remove the last committed revision.
4939
4558
4940
4559
--verbose will print out what is being removed.
4941
4560
--dry-run will go through all the motions, but not actually
4981
4600
b = control.open_branch()
4982
4601
4983
4602
if tree is not None:
4984
self.add_cleanup(tree.lock_write().unlock)
4603
tree.lock_write()
4985
4604
else:
4986
self.add_cleanup(b.lock_write().unlock)
4987
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4605
b.lock_write()
4606
try:
4607
return self._run(b, tree, dry_run, verbose, revision, force,
4608
local=local)
4609
finally:
4610
if tree is not None:
4611
tree.unlock()
4612
else:
4613
b.unlock()
4988
4614
4989
4615
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4990
4616
from bzrlib.log import log_formatter, show_log
5022
4648
end_revision=last_revno)
5023
4649
5024
4650
if dry_run:
5025
self.outf.write('Dry-run, pretending to remove'
5026
' the above revisions.\n')
4651
print 'Dry-run, pretending to remove the above revisions.'
4652
if not force:
4653
val = raw_input('Press <enter> to continue')
5027
4654
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
4655
print 'The above revision(s) will be removed.'
4656
if not force:
4657
val = raw_input('Are you sure [y/N]? ')
4658
if val.lower() not in ('y', 'yes'):
4659
print 'Canceled'
4660
return 0
5037
4661
5038
4662
mutter('Uncommitting from {%s} to {%s}',
5039
4663
last_rev_id, rev_id)
5040
4664
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
5041
4665
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)
4666
note('You can restore the old tip by running:\n'
4667
' bzr pull . -r revid:%s', last_rev_id)
5044
4668
5045
4669
5046
4670
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.
4671
"""Break a dead lock on a repository, branch or working directory.
5051
4672
5052
4673
CAUTION: Locks should only be broken when you are sure that the process
5053
4674
holding the lock has been stopped.
5054
4675
5055
You can get information on what locks are open via the 'bzr info
5056
[location]' command.
4676
You can get information on what locks are open via the 'bzr info' command.
5057
4677
5058
4678
:Examples:
5059
4679
bzr break-lock
5060
bzr break-lock bzr+ssh://example.com/bzr/foo
5061
bzr break-lock --conf ~/.bazaar
5062
4680
"""
5063
5064
4681
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
4682
5072
def run(self, location=None, config=False, force=False):
4683
def run(self, location=None, show=False):
5073
4684
if location is None:
5074
4685
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
4686
control, relpath = bzrdir.BzrDir.open_containing(location)
4687
try:
4688
control.break_lock()
4689
except NotImplementedError:
4690
pass
5088
4691
5089
4692
5090
4693
class cmd_wait_until_signalled(Command):
5091
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4694
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
5092
4695
5093
4696
This just prints a line to signal when it is ready, then blocks on stdin.
5094
4697
"""
5102
4705
5103
4706
5104
4707
class cmd_serve(Command):
5105
__doc__ = """Run the bzr server."""
4708
"""Run the bzr server."""
5106
4709
5107
4710
aliases = ['server']
5108
4711
5109
4712
takes_options = [
5110
4713
Option('inet',
5111
4714
help='Serve on stdin/out for use from inetd or sshd.'),
5112
RegistryOption('protocol',
5113
help="Protocol to serve.",
4715
RegistryOption('protocol',
4716
help="Protocol to serve.",
5114
4717
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
5115
4718
value_switches=True),
5116
4719
Option('port',
5119
4722
'result in a dynamically allocated port. The default port '
5120
4723
'depends on the protocol.',
5121
4724
type=str),
5122
custom_help('directory',
5123
help='Serve contents of this directory.'),
4725
Option('directory',
4726
help='Serve contents of this directory.',
4727
type=unicode),
5124
4728
Option('allow-writes',
5125
4729
help='By default the server is a readonly server. Supplying '
5126
4730
'--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.'
4731
'the served directory and below.'
5132
4732
),
5133
4733
]
5134
4734
5153
4753
5154
4754
def run(self, port=None, inet=False, directory=None, allow_writes=False,
5155
4755
protocol=None):
5156
from bzrlib import transport
4756
from bzrlib.transport import get_transport, transport_server_registry
5157
4757
if directory is None:
5158
4758
directory = os.getcwd()
5159
4759
if protocol is None:
5160
protocol = transport.transport_server_registry.get()
4760
protocol = transport_server_registry.get()
5161
4761
host, port = self.get_host_and_port(port)
5162
4762
url = urlutils.local_path_to_url(directory)
5163
4763
if not allow_writes:
5164
4764
url = 'readonly+' + url
5165
t = transport.get_transport(url)
5166
protocol(t, host, port, inet)
4765
transport = get_transport(url)
4766
protocol(transport, host, port, inet)
5167
4767
5168
4768
5169
4769
class cmd_join(Command):
5170
__doc__ = """Combine a tree into its containing tree.
4770
"""Combine a tree into its containing tree.
5171
4771
5172
4772
This command requires the target tree to be in a rich-root format.
5173
4773
5175
4775
not part of it. (Such trees can be produced by "bzr split", but also by
5176
4776
running "bzr branch" with the target inside a tree.)
5177
4777
5178
The result is a combined tree, with the subtree no longer an independent
4778
The result is a combined tree, with the subtree no longer an independant
5179
4779
part. This is marked as a merge of the subtree into the containing tree,
5180
4780
and all history is preserved.
5181
4781
"""
5213
4813
5214
4814
5215
4815
class cmd_split(Command):
5216
__doc__ = """Split a subdirectory of a tree into a separate tree.
4816
"""Split a subdirectory of a tree into a separate tree.
5217
4817
5218
4818
This command will produce a target tree in a format that supports
5219
4819
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5239
4839
5240
4840
5241
4841
class cmd_merge_directive(Command):
5242
__doc__ = """Generate a merge directive for auto-merge tools.
4842
"""Generate a merge directive for auto-merge tools.
5243
4843
5244
4844
A directive requests a merge to be performed, and also provides all the
5245
4845
information necessary to do so. This means it must either include a
5262
4862
_see_also = ['send']
5263
4863
5264
4864
takes_options = [
5265
'directory',
5266
4865
RegistryOption.from_kwargs('patch-type',
5267
4866
'The type of patch to include in the directive.',
5268
4867
title='Patch type',
5281
4880
encoding_type = 'exact'
5282
4881
5283
4882
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'.'):
4883
sign=False, revision=None, mail_to=None, message=None):
5286
4884
from bzrlib.revision import ensure_null, NULL_REVISION
5287
4885
include_patch, include_bundle = {
5288
4886
'plain': (False, False),
5289
4887
'diff': (True, False),
5290
4888
'bundle': (True, True),
5291
4889
}[patch_type]
5292
branch = Branch.open(directory)
4890
branch = Branch.open('.')
5293
4891
stored_submit_branch = branch.get_submit_branch()
5294
4892
if submit_branch is None:
5295
4893
submit_branch = stored_submit_branch
5340
4938
5341
4939
5342
4940
class cmd_send(Command):
5343
__doc__ = """Mail or create a merge-directive for submitting changes.
4941
"""Mail or create a merge-directive for submitting changes.
5344
4942
5345
4943
A merge directive provides many things needed for requesting merges:
5346
4944
5352
4950
directly from the merge directive, without retrieving data from a
5353
4951
branch.
5354
4952
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.
4953
If --no-bundle is specified, then public_branch is needed (and must be
4954
up-to-date), so that the receiver can perform the merge using the
4955
public_branch. The public_branch is always included if known, so that
4956
people can check it later.
4957
4958
The submit branch defaults to the parent, but can be overridden. Both
4959
submit branch and public branch will be remembered if supplied.
4960
4961
If a public_branch is known for the submit_branch, that public submit
4962
branch is used in the merge instructions. This means that a local mirror
4963
can be used as your actual submit branch, once you have set public_branch
4964
for that mirror.
5387
4965
5388
4966
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.
4967
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5390
4968
If the preferred client can't be found (or used), your editor will be used.
5391
4969
5392
4970
To use a specific mail program, set the mail_client configuration option.
5393
4971
(For Thunderbird 1.5, this works around some bugs.) Supported values for
5394
specific clients are "claws", "evolution", "kmail", "mail.app" (MacOS X's
5395
Mail.app), "mutt", and "thunderbird"; generic options are "default",
5396
"editor", "emacsclient", "mapi", and "xdg-email". Plugins may also add
5397
supported clients.
4972
specific clients are "claws", "evolution", "kmail", "mutt", and
4973
"thunderbird"; generic options are "default", "editor", "emacsclient",
4974
"mapi", and "xdg-email". Plugins may also add supported clients.
5398
4975
5399
4976
If mail is being sent, a to address is required. This can be supplied
5400
4977
either on the commandline, by setting the submit_to configuration
5409
4986
5410
4987
The merge directives created by bzr send may be applied using bzr merge or
5411
4988
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
4989
"""
5417
4990
5418
4991
encoding_type = 'exact'
5434
5007
short_name='f',
5435
5008
type=unicode),
5436
5009
Option('output', short_name='o',
5437
help='Write merge directive to this file or directory; '
5010
help='Write merge directive to this file; '
5438
5011
'use - for stdout.',
5439
5012
type=unicode),
5440
5013
Option('strict',
5451
5024
]
5452
5025
5453
5026
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5454
no_patch=False, revision=None, remember=None, output=None,
5027
no_patch=False, revision=None, remember=False, output=None,
5455
5028
format=None, mail_to=None, message=None, body=None,
5456
5029
strict=None, **kwargs):
5457
5030
from bzrlib.send import send
5463
5036
5464
5037
5465
5038
class cmd_bundle_revisions(cmd_send):
5466
__doc__ = """Create a merge-directive for submitting changes.
5039
"""Create a merge-directive for submitting changes.
5467
5040
5468
5041
A merge directive provides many things needed for requesting merges:
5469
5042
5536
5109
5537
5110
5538
5111
class cmd_tag(Command):
5539
__doc__ = """Create, remove or modify a tag naming a revision.
5112
"""Create, remove or modify a tag naming a revision.
5540
5113
5541
5114
Tags give human-meaningful names to revisions. Commands that take a -r
5542
5115
(--revision) option can be given -rtag:X, where X is any previously
5550
5123
5551
5124
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5552
5125
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
5126
"""
5559
5127
5560
5128
_see_also = ['commit', 'tags']
5561
takes_args = ['tag_name?']
5129
takes_args = ['tag_name']
5562
5130
takes_options = [
5563
5131
Option('delete',
5564
5132
help='Delete this tag rather than placing it.',
5565
5133
),
5566
custom_help('directory',
5567
help='Branch in which to place the tag.'),
5134
Option('directory',
5135
help='Branch in which to place the tag.',
5136
short_name='d',
5137
type=unicode,
5138
),
5568
5139
Option('force',
5569
5140
help='Replace existing tags.',
5570
5141
),
5571
5142
'revision',
5572
5143
]
5573
5144
5574
def run(self, tag_name=None,
5145
def run(self, tag_name,
5575
5146
delete=None,
5576
5147
directory='.',
5577
5148
force=None,
5578
5149
revision=None,
5579
5150
):
5580
5151
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)
5152
branch.lock_write()
5153
try:
5154
if delete:
5155
branch.tags.delete_tag(tag_name)
5156
self.outf.write('Deleted tag %s.\n' % tag_name)
5594
5157
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)
5158
if revision:
5159
if len(revision) != 1:
5160
raise errors.BzrCommandError(
5161
"Tags can only be placed on a single revision, "
5162
"not on a range")
5163
revision_id = revision[0].as_revision_id(branch)
5164
else:
5165
revision_id = branch.last_revision()
5166
if (not force) and branch.tags.has_tag(tag_name):
5167
raise errors.TagAlreadyExists(tag_name)
5168
branch.tags.set_tag(tag_name, revision_id)
5169
self.outf.write('Created tag %s.\n' % tag_name)
5170
finally:
5171
branch.unlock()
5605
5172
5606
5173
5607
5174
class cmd_tags(Command):
5608
__doc__ = """List tags.
5175
"""List tags.
5609
5176
5610
5177
This command shows a table of tag names and the revisions they reference.
5611
5178
"""
5612
5179
5613
5180
_see_also = ['tag']
5614
5181
takes_options = [
5615
custom_help('directory',
5616
help='Branch whose tags should be displayed.'),
5617
RegistryOption('sort',
5182
Option('directory',
5183
help='Branch whose tags should be displayed.',
5184
short_name='d',
5185
type=unicode,
5186
),
5187
RegistryOption.from_kwargs('sort',
5618
5188
'Sort tags by different criteria.', title='Sorting',
5619
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5189
alpha='Sort tags lexicographically (default).',
5190
time='Sort tags chronologically.',
5620
5191
),
5621
5192
'show-ids',
5622
5193
'revision',
5623
5194
]
5624
5195
5625
5196
@display_command
5626
def run(self, directory='.', sort=None, show_ids=False, revision=None):
5627
from bzrlib.tag import tag_sort_methods
5197
def run(self,
5198
directory='.',
5199
sort='alpha',
5200
show_ids=False,
5201
revision=None,
5202
):
5628
5203
branch, relpath = Branch.open_containing(directory)
5629
5204
5630
5205
tags = branch.tags.get_tag_dict().items()
5631
5206
if not tags:
5632
5207
return
5633
5208
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()
5209
branch.lock_read()
5210
try:
5211
if revision:
5212
graph = branch.repository.get_graph()
5213
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5214
revid1, revid2 = rev1.rev_id, rev2.rev_id
5215
# only show revisions between revid1 and revid2 (inclusive)
5216
tags = [(tag, revid) for tag, revid in tags if
5217
graph.is_between(revid, revid1, revid2)]
5218
if sort == 'alpha':
5219
tags.sort()
5220
elif sort == 'time':
5221
timestamps = {}
5222
for tag, revid in tags:
5223
try:
5224
revobj = branch.repository.get_revision(revid)
5225
except errors.NoSuchRevision:
5226
timestamp = sys.maxint # place them at the end
5227
else:
5228
timestamp = revobj.timestamp
5229
timestamps[revid] = timestamp
5230
tags.sort(key=lambda x: timestamps[x[1]])
5231
if not show_ids:
5232
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5233
for index, (tag, revid) in enumerate(tags):
5234
try:
5235
revno = branch.revision_id_to_dotted_revno(revid)
5236
if isinstance(revno, tuple):
5237
revno = '.'.join(map(str, revno))
5238
except errors.NoSuchRevision:
5239
# Bad tag data/merges can lead to tagged revisions
5240
# which are not in this branch. Fail gracefully ...
5241
revno = '?'
5242
tags[index] = (tag, revno)
5243
finally:
5244
branch.unlock()
5658
5245
for tag, revspec in tags:
5659
5246
self.outf.write('%-20s %s\n' % (tag, revspec))
5660
5247
5661
5248
5662
5249
class cmd_reconfigure(Command):
5663
__doc__ = """Reconfigure the type of a bzr directory.
5250
"""Reconfigure the type of a bzr directory.
5664
5251
5665
5252
A target configuration must be specified.
5666
5253
5713
5300
unstacked=None):
5714
5301
directory = bzrdir.BzrDir.open(location)
5715
5302
if stacked_on and unstacked:
5716
raise errors.BzrCommandError("Can't use both --stacked-on and --unstacked")
5303
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
5717
5304
elif stacked_on is not None:
5718
5305
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5719
5306
elif unstacked:
5751
5338
5752
5339
5753
5340
class cmd_switch(Command):
5754
__doc__ = """Set the branch of a checkout and update.
5341
"""Set the branch of a checkout and update.
5755
5342
5756
5343
For lightweight checkouts, this changes the branch being referenced.
5757
5344
For heavyweight checkouts, this checks that there are no local commits
5769
5356
/path/to/newbranch.
5770
5357
5771
5358
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
5359
locally, in which case switching will update the the local nickname to be
5773
5360
that of the master.
5774
5361
"""
5775
5362
5776
takes_args = ['to_location?']
5777
takes_options = ['directory',
5778
Option('force',
5363
takes_args = ['to_location']
5364
takes_options = [Option('force',
5779
5365
help='Switch even if local commits will be lost.'),
5780
'revision',
5781
5366
Option('create-branch', short_name='b',
5782
5367
help='Create the target branch from this one before'
5783
5368
' switching to it.'),
5784
]
5369
]
5785
5370
5786
def run(self, to_location=None, force=False, create_branch=False,
5787
revision=None, directory=u'.'):
5371
def run(self, to_location, force=False, create_branch=False):
5788
5372
from bzrlib import switch
5789
tree_location = directory
5790
revision = _get_one_revision('switch', revision)
5373
tree_location = '.'
5791
5374
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
5375
try:
5798
5376
branch = control_dir.open_branch()
5799
5377
had_explicit_nick = branch.get_config().has_explicit_nickname()
5804
5382
if branch is None:
5805
5383
raise errors.BzrCommandError('cannot create branch without'
5806
5384
' source branch')
5807
to_location = directory_service.directories.dereference(
5808
to_location)
5809
5385
if '/' not in to_location and '\\' not in to_location:
5810
5386
# This path is meant to be relative to the existing branch
5811
5387
this_url = self._get_branch_location(control_dir)
5813
5389
to_branch = branch.bzrdir.sprout(to_location,
5814
5390
possible_transports=[branch.bzrdir.root_transport],
5815
5391
source_branch=branch).open_branch()
5392
# try:
5393
# from_branch = control_dir.open_branch()
5394
# except errors.NotBranchError:
5395
# raise BzrCommandError('Cannot create a branch from this'
5396
# ' location when we cannot open this branch')
5397
# from_branch.bzrdir.sprout(
5398
pass
5816
5399
else:
5817
5400
try:
5818
5401
to_branch = Branch.open(to_location)
5820
5403
this_url = self._get_branch_location(control_dir)
5821
5404
to_branch = Branch.open(
5822
5405
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)
5406
switch.switch(control_dir, to_branch, force)
5826
5407
if had_explicit_nick:
5827
5408
branch = control_dir.open_branch() #get the new branch!
5828
5409
branch.nick = to_branch.nick
5848
5429
5849
5430
5850
5431
class cmd_view(Command):
5851
__doc__ = """Manage filtered views.
5432
"""Manage filtered views.
5852
5433
5853
5434
Views provide a mask over the tree so that users can focus on
5854
5435
a subset of a tree when doing their work. After creating a view,
5934
5515
name=None,
5935
5516
switch=None,
5936
5517
):
5937
tree, file_list = WorkingTree.open_containing_paths(file_list,
5938
apply_view=False)
5518
tree, file_list = tree_files(file_list, apply_view=False)
5939
5519
current_view, view_dict = tree.views.get_view_info()
5940
5520
if name is None:
5941
5521
name = current_view
6003
5583
6004
5584
6005
5585
class cmd_hooks(Command):
6006
__doc__ = """Show hooks."""
5586
"""Show hooks."""
6007
5587
6008
5588
hidden = True
6009
5589
6022
5602
self.outf.write(" <no hooks installed>\n")
6023
5603
6024
5604
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
5605
class cmd_shelve(Command):
6051
__doc__ = """Temporarily set aside some changes from the current tree.
5606
"""Temporarily set aside some changes from the current tree.
6052
5607
6053
5608
Shelve allows you to temporarily put changes you've made "on the shelf",
6054
5609
ie. out of the way, until a later time when you can bring them back from
6070
5625
6071
5626
You can put multiple items on the shelf, and by default, 'unshelve' will
6072
5627
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
5628
"""
6086
5629
6087
5630
takes_args = ['file*']
6088
5631
6089
5632
takes_options = [
6090
'directory',
6091
5633
'revision',
6092
5634
Option('all', help='Shelve all changes.'),
6093
5635
'message',
6099
5641
Option('destroy',
6100
5642
help='Destroy removed changes instead of shelving them.'),
6101
5643
]
6102
_see_also = ['unshelve', 'configuration']
5644
_see_also = ['unshelve']
6103
5645
6104
5646
def run(self, revision=None, all=False, file_list=None, message=None,
6105
writer=None, list=False, destroy=False, directory=None):
5647
writer=None, list=False, destroy=False):
6106
5648
if list:
6107
return self.run_for_list(directory=directory)
5649
return self.run_for_list()
6108
5650
from bzrlib.shelf_ui import Shelver
6109
5651
if writer is None:
6110
5652
writer = bzrlib.option.diff_writer_registry.get()
6111
5653
try:
6112
5654
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6113
file_list, message, destroy=destroy, directory=directory)
5655
file_list, message, destroy=destroy)
6114
5656
try:
6115
5657
shelver.run()
6116
5658
finally:
6117
shelver.finalize()
5659
shelver.work_tree.unlock()
6118
5660
except errors.UserAbort:
6119
5661
return 0
6120
5662
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
5663
def run_for_list(self):
5664
tree = WorkingTree.open_containing('.')[0]
5665
tree.lock_read()
5666
try:
5667
manager = tree.get_shelf_manager()
5668
shelves = manager.active_shelves()
5669
if len(shelves) == 0:
5670
note('No shelved changes.')
5671
return 0
5672
for shelf_id in reversed(shelves):
5673
message = manager.get_metadata(shelf_id).get('message')
5674
if message is None:
5675
message = '<no message>'
5676
self.outf.write('%3d: %s\n' % (shelf_id, message))
5677
return 1
5678
finally:
5679
tree.unlock()
6137
5680
6138
5681
6139
5682
class cmd_unshelve(Command):
6140
__doc__ = """Restore shelved changes.
5683
"""Restore shelved changes.
6141
5684
6142
5685
By default, the most recently shelved changes are restored. However if you
6143
5686
specify a shelf by id those changes will be restored instead. This works
6146
5689
6147
5690
takes_args = ['shelf_id?']
6148
5691
takes_options = [
6149
'directory',
6150
5692
RegistryOption.from_kwargs(
6151
5693
'action', help="The action to perform.",
6152
5694
enum_switch=False, value_switches=True,
6153
5695
apply="Apply changes and remove from the shelf.",
6154
5696
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.",
5697
delete_only="Delete changes without applying them."
6159
5698
)
6160
5699
]
6161
5700
_see_also = ['shelve']
6162
5701
6163
def run(self, shelf_id=None, action='apply', directory=u'.'):
5702
def run(self, shelf_id=None, action='apply'):
6164
5703
from bzrlib.shelf_ui import Unshelver
6165
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5704
unshelver = Unshelver.from_args(shelf_id, action)
6166
5705
try:
6167
5706
unshelver.run()
6168
5707
finally:
6170
5709
6171
5710
6172
5711
class cmd_clean_tree(Command):
6173
__doc__ = """Remove unwanted files from working tree.
5712
"""Remove unwanted files from working tree.
6174
5713
6175
5714
By default, only unknown files, not ignored files, are deleted. Versioned
6176
5715
files are never deleted.
6184
5723
6185
5724
To check what clean-tree will do, use --dry-run.
6186
5725
"""
6187
takes_options = ['directory',
6188
Option('ignored', help='Delete all ignored files.'),
6189
Option('detritus', help='Delete conflict files, merge and revert'
5726
takes_options = [Option('ignored', help='Delete all ignored files.'),
5727
Option('detritus', help='Delete conflict files, merge'
6190
5728
' backups, and failed selftest dirs.'),
6191
5729
Option('unknown',
6192
5730
help='Delete files unknown to bzr (default).'),
6194
5732
' deleting them.'),
6195
5733
Option('force', help='Do not prompt before deleting.')]
6196
5734
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6197
force=False, directory=u'.'):
5735
force=False):
6198
5736
from bzrlib.clean_tree import clean_tree
6199
5737
if not (unknown or ignored or detritus):
6200
5738
unknown = True
6201
5739
if dry_run:
6202
5740
force = True
6203
clean_tree(directory, unknown=unknown, ignored=ignored,
6204
detritus=detritus, dry_run=dry_run, no_prompt=force)
5741
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5742
dry_run=dry_run, no_prompt=force)
6205
5743
6206
5744
6207
5745
class cmd_reference(Command):
6208
__doc__ = """list, view and set branch locations for nested trees.
5746
"""list, view and set branch locations for nested trees.
6209
5747
6210
5748
If no arguments are provided, lists the branch locations for nested trees.
6211
5749
If one argument is provided, display the branch location for that tree.
6251
5789
self.outf.write('%s %s\n' % (path, location))
6252
5790
6253
5791
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)
5792
# these get imported and then picked up by the scan for cmd_*
5793
# TODO: Some more consistent way to split command definitions across files;
5794
# we do need to load at least some information about them to know of
5795
# aliases. ideally we would avoid loading the implementation until the
5796
# details were needed.
5797
from bzrlib.cmd_version_info import cmd_version_info
5798
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5799
from bzrlib.bundle.commands import (
5800
cmd_bundle_info,
5801
)
5802
from bzrlib.foreign import cmd_dpush
5803
from bzrlib.sign_my_commits import cmd_sign_my_commits
5804
from bzrlib.weave_commands import cmd_versionedfile_list, \
5805
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1