To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 5200.3.2
- compare with another revision
- download diff
- download tarball
- view history from revision 5200.3.2
- Committer: Robert Collins
- Date: 2010-05-06 11:08:10 UTC
- mto: This revision was merged to the branch mainline in revision 5223.
- Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.
- files added:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- files removed:
- NEWS
- bzrlib/branchfmt
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/po_merge
- bzrlib/plugins/po_merge/tests
- bzrlib/plugins/weave_fmt
- bzrlib/plugins/weave_fmt/tests
- bzrlib/tests/per_bzrdir
- bzrlib/tests/per_repository_vf
- po
- files renamed:
- doc/en/release-notes/bzr-2.3.txt => NEWS
- doc/en/release-notes/release-template.txt => NEWS-template.txt
- bzrlib/doc_generate/conf.py => bzrlib/doc_generate/sphinx_conf.py
- 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_controldir_colo/ => bzrlib/tests/per_bzrdir_colo/
- 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/per_repository_vf/test_merge_directive.py => bzrlib/tests/per_repository/test_merge_directive.py
- bzrlib/plugins/weave_fmt/xml4.py => bzrlib/xml4.py
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2005-2012 Canonical Ltd
1
# Copyright (C) 2005-2010 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
16
16
17
17
"""builtin bzr commands"""
18
18
19
from __future__ import absolute_import
20
21
19
import os
22
20
23
import bzrlib.bzrdir
24
25
from bzrlib import lazy_import
26
lazy_import.lazy_import(globals(), """
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
27
24
import cStringIO
28
import errno
29
25
import sys
30
26
import time
31
27
34
30
bugtracker,
35
31
bundle,
36
32
btree_index,
37
controldir,
33
bzrdir,
38
34
directory_service,
39
35
delta,
40
config as _mod_config,
36
config,
41
37
errors,
42
38
globbing,
43
39
hooks,
49
45
rename_map,
50
46
revision as _mod_revision,
51
47
static_tuple,
48
symbol_versioning,
52
49
timestamp,
53
50
transport,
54
51
ui,
55
52
urlutils,
56
53
views,
57
gpg,
58
54
)
59
55
from bzrlib.branch import Branch
60
56
from bzrlib.conflicts import ConflictList
62
58
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
63
59
from bzrlib.smtp_connection import SMTPConnection
64
60
from bzrlib.workingtree import WorkingTree
65
from bzrlib.i18n import gettext, ngettext
66
61
""")
67
62
68
63
from bzrlib.commands import (
78
73
_parse_revision_str,
79
74
)
80
75
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
81
from bzrlib import (
82
symbol_versioning,
83
)
84
85
86
def _get_branch_location(control_dir, possible_transports=None):
87
"""Return location of branch for this control dir."""
88
try:
89
target = control_dir.get_branch_reference()
90
except errors.NotBranchError:
91
return control_dir.root_transport.base
92
if target is not None:
93
return target
94
this_branch = control_dir.open_branch(
95
possible_transports=possible_transports)
96
# This may be a heavy checkout, where we want the master branch
97
master_location = this_branch.get_bound_location()
98
if master_location is not None:
99
return master_location
100
# If not, use a local sibling
101
return this_branch.base
102
103
104
def _is_colocated(control_dir, possible_transports=None):
105
"""Check if the branch in control_dir is colocated.
106
107
:param control_dir: Control directory
108
:return: Tuple with boolean indicating whether the branch is colocated
109
and the full URL to the actual branch
110
"""
111
# This path is meant to be relative to the existing branch
112
this_url = _get_branch_location(control_dir,
113
possible_transports=possible_transports)
114
# Perhaps the target control dir supports colocated branches?
115
try:
116
root = controldir.ControlDir.open(this_url,
117
possible_transports=possible_transports)
118
except errors.NotBranchError:
119
return (False, this_url)
120
else:
121
try:
122
wt = control_dir.open_workingtree()
123
except (errors.NoWorkingTree, errors.NotLocalUrl):
124
return (False, this_url)
125
else:
126
return (
127
root._format.colocated_branches and
128
control_dir.control_url == root.control_url,
129
this_url)
130
131
132
def lookup_new_sibling_branch(control_dir, location, possible_transports=None):
133
"""Lookup the location for a new sibling branch.
134
135
:param control_dir: Control directory to find sibling branches from
136
:param location: Name of the new branch
137
:return: Full location to the new branch
138
"""
139
location = directory_service.directories.dereference(location)
140
if '/' not in location and '\\' not in location:
141
(colocated, this_url) = _is_colocated(control_dir, possible_transports)
142
143
if colocated:
144
return urlutils.join_segment_parameters(this_url,
145
{"branch": urlutils.escape(location)})
146
else:
147
return urlutils.join(this_url, '..', urlutils.escape(location))
148
return location
149
150
151
def open_sibling_branch(control_dir, location, possible_transports=None):
152
"""Open a branch, possibly a sibling of another.
153
154
:param control_dir: Control directory relative to which to lookup the
155
location.
156
:param location: Location to look up
157
:return: branch to open
158
"""
159
try:
160
# Perhaps it's a colocated branch?
161
return control_dir.open_branch(location,
162
possible_transports=possible_transports)
163
except (errors.NotBranchError, errors.NoColocatedBranchSupport):
164
this_url = _get_branch_location(control_dir)
165
return Branch.open(
166
urlutils.join(
167
this_url, '..', urlutils.escape(location)))
168
169
170
def open_nearby_branch(near=None, location=None, possible_transports=None):
171
"""Open a nearby branch.
172
173
:param near: Optional location of container from which to open branch
174
:param location: Location of the branch
175
:return: Branch instance
176
"""
177
if near is None:
178
if location is None:
179
location = "."
180
try:
181
return Branch.open(location,
182
possible_transports=possible_transports)
183
except errors.NotBranchError:
184
near = "."
185
cdir = controldir.ControlDir.open(near,
186
possible_transports=possible_transports)
187
return open_sibling_branch(cdir, location,
188
possible_transports=possible_transports)
189
190
191
def iter_sibling_branches(control_dir, possible_transports=None):
192
"""Iterate over the siblings of a branch.
193
194
:param control_dir: Control directory for which to look up the siblings
195
:return: Iterator over tuples with branch name and branch object
196
"""
197
seen_urls = set()
198
try:
199
reference = control_dir.get_branch_reference()
200
except errors.NotBranchError:
201
# There is no active branch, just return the colocated branches.
202
for name, branch in control_dir.get_branches().iteritems():
203
yield name, branch
204
return
205
if reference is not None:
206
ref_branch = Branch.open(reference,
207
possible_transports=possible_transports)
208
else:
209
ref_branch = None
210
if ref_branch is None or ref_branch.name:
211
if ref_branch is not None:
212
control_dir = ref_branch.bzrdir
213
for name, branch in control_dir.get_branches().iteritems():
214
yield name, branch
215
else:
216
repo = ref_branch.bzrdir.find_repository()
217
for branch in repo.find_branches(using=True):
218
name = urlutils.relative_url(repo.user_url,
219
branch.user_url).rstrip("/")
220
yield name, branch
76
77
78
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
apply_view=True):
80
try:
81
return internal_tree_files(file_list, default_branch, canonicalize,
82
apply_view)
83
except errors.FileInWrongBranch, e:
84
raise errors.BzrCommandError("%s is not in the same branch as %s" %
85
(e.path, file_list[0]))
221
86
222
87
223
88
def tree_files_for_add(file_list):
248
113
if view_files:
249
114
file_list = view_files
250
115
view_str = views.view_display_str(view_files)
251
note(gettext("Ignoring files outside view. View is %s") % view_str)
116
note("Ignoring files outside view. View is %s" % view_str)
252
117
return tree, file_list
253
118
254
119
256
121
if revisions is None:
257
122
return None
258
123
if len(revisions) != 1:
259
raise errors.BzrCommandError(gettext(
260
'bzr %s --revision takes exactly one revision identifier') % (
124
raise errors.BzrCommandError(
125
'bzr %s --revision takes exactly one revision identifier' % (
261
126
command_name,))
262
127
return revisions[0]
263
128
285
150
return rev_tree
286
151
287
152
153
# XXX: Bad function name; should possibly also be a class method of
154
# WorkingTree rather than a function.
155
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
apply_view=True):
157
"""Convert command-line paths to a WorkingTree and relative paths.
158
159
This is typically used for command-line processors that take one or
160
more filenames, and infer the workingtree that contains them.
161
162
The filenames given are not required to exist.
163
164
:param file_list: Filenames to convert.
165
166
:param default_branch: Fallback tree path to use if file_list is empty or
167
None.
168
169
:param apply_view: if True and a view is set, apply it or check that
170
specified files are within it
171
172
:return: workingtree, [relative_paths]
173
"""
174
if file_list is None or len(file_list) == 0:
175
tree = WorkingTree.open_containing(default_branch)[0]
176
if tree.supports_views() and apply_view:
177
view_files = tree.views.lookup_view()
178
if view_files:
179
file_list = view_files
180
view_str = views.view_display_str(view_files)
181
note("Ignoring files outside view. View is %s" % view_str)
182
return tree, file_list
183
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
return tree, safe_relpath_files(tree, file_list, canonicalize,
185
apply_view=apply_view)
186
187
188
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
189
"""Convert file_list into a list of relpaths in tree.
190
191
:param tree: A tree to operate on.
192
:param file_list: A list of user provided paths or None.
193
:param apply_view: if True and a view is set, apply it or check that
194
specified files are within it
195
:return: A list of relative paths.
196
:raises errors.PathNotChild: When a provided path is in a different tree
197
than tree.
198
"""
199
if file_list is None:
200
return None
201
if tree.supports_views() and apply_view:
202
view_files = tree.views.lookup_view()
203
else:
204
view_files = []
205
new_list = []
206
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
207
# doesn't - fix that up here before we enter the loop.
208
if canonicalize:
209
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
210
else:
211
fixer = tree.relpath
212
for filename in file_list:
213
try:
214
relpath = fixer(osutils.dereference_path(filename))
215
if view_files and not osutils.is_inside_any(view_files, relpath):
216
raise errors.FileOutsideView(filename, view_files)
217
new_list.append(relpath)
218
except errors.PathNotChild:
219
raise errors.FileInWrongBranch(tree.branch, filename)
220
return new_list
221
222
288
223
def _get_view_info_for_change_reporter(tree):
289
224
"""Get the view information from a tree for change reporting."""
290
225
view_info = None
297
232
return view_info
298
233
299
234
300
def _open_directory_or_containing_tree_or_branch(filename, directory):
301
"""Open the tree or branch containing the specified file, unless
302
the --directory option is used to specify a different branch."""
303
if directory is not None:
304
return (None, Branch.open(directory), filename)
305
return controldir.ControlDir.open_containing_tree_or_branch(filename)
306
307
308
235
# TODO: Make sure no commands unconditionally use the working directory as a
309
236
# branch. If a filename argument is used, the first of them should be used to
310
237
# specify the branch. (Perhaps this can be factored out into some kind of
338
265
unknown
339
266
Not versioned and not matching an ignore pattern.
340
267
341
Additionally for directories, symlinks and files with a changed
342
executable bit, Bazaar indicates their type using a trailing
343
character: '/', '@' or '*' respectively. These decorations can be
344
disabled using the '--no-classify' option.
268
Additionally for directories, symlinks and files with an executable
269
bit, Bazaar indicates their type using a trailing character: '/', '@'
270
or '*' respectively.
345
271
346
272
To see ignored files use 'bzr ignored'. For details on the
347
273
changes to file texts, use 'bzr diff'.
360
286
To skip the display of pending merge information altogether, use
361
287
the no-pending option or specify a file/directory.
362
288
363
To compare the working directory to a specific revision, pass a
364
single revision to the revision argument.
365
366
To see which files have changed in a specific revision, or between
367
two revisions, pass a revision range to the revision argument.
368
This will produce the same results as calling 'bzr diff --summarize'.
289
If a revision argument is given, the status is calculated against
290
that revision, or between two revisions if two are provided.
369
291
"""
370
292
371
# TODO: --no-recurse/-N, --recurse options
293
# TODO: --no-recurse, --recurse options
372
294
373
295
takes_args = ['file*']
374
296
takes_options = ['show-ids', 'revision', 'change', 'verbose',
378
300
short_name='V'),
379
301
Option('no-pending', help='Don\'t show pending merges.',
380
302
),
381
Option('no-classify',
382
help='Do not mark object type using indicator.',
383
),
384
303
]
385
304
aliases = ['st', 'stat']
386
305
389
308
390
309
@display_command
391
310
def run(self, show_ids=False, file_list=None, revision=None, short=False,
392
versioned=False, no_pending=False, verbose=False,
393
no_classify=False):
311
versioned=False, no_pending=False, verbose=False):
394
312
from bzrlib.status import show_tree_status
395
313
396
314
if revision and len(revision) > 2:
397
raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
398
' one or two revision specifiers'))
315
raise errors.BzrCommandError('bzr status --revision takes exactly'
316
' one or two revision specifiers')
399
317
400
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
318
tree, relfile_list = tree_files(file_list)
401
319
# Avoid asking for specific files when that is not needed.
402
320
if relfile_list == ['']:
403
321
relfile_list = None
410
328
show_tree_status(tree, show_ids=show_ids,
411
329
specific_files=relfile_list, revision=revision,
412
330
to_file=self.outf, short=short, versioned=versioned,
413
show_pending=(not no_pending), verbose=verbose,
414
classify=not no_classify)
331
show_pending=(not no_pending), verbose=verbose)
415
332
416
333
417
334
class cmd_cat_revision(Command):
423
340
424
341
hidden = True
425
342
takes_args = ['revision_id?']
426
takes_options = ['directory', 'revision']
343
takes_options = ['revision']
427
344
# cat-revision is more for frontends so should be exact
428
345
encoding = 'strict'
429
346
436
353
self.outf.write(revtext.decode('utf-8'))
437
354
438
355
@display_command
439
def run(self, revision_id=None, revision=None, directory=u'.'):
356
def run(self, revision_id=None, revision=None):
440
357
if revision_id is not None and revision is not None:
441
raise errors.BzrCommandError(gettext('You can only supply one of'
442
' revision_id or --revision'))
358
raise errors.BzrCommandError('You can only supply one of'
359
' revision_id or --revision')
443
360
if revision_id is None and revision is None:
444
raise errors.BzrCommandError(gettext('You must supply either'
445
' --revision or a revision_id'))
446
447
b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]
361
raise errors.BzrCommandError('You must supply either'
362
' --revision or a revision_id')
363
b = WorkingTree.open_containing(u'.')[0].branch
448
364
449
365
revisions = b.repository.revisions
450
366
if revisions is None:
451
raise errors.BzrCommandError(gettext('Repository %r does not support '
452
'access to raw revision texts'))
367
raise errors.BzrCommandError('Repository %r does not support '
368
'access to raw revision texts')
453
369
454
370
b.repository.lock_read()
455
371
try:
459
375
try:
460
376
self.print_revision(revisions, revision_id)
461
377
except errors.NoSuchRevision:
462
msg = gettext("The repository {0} contains no revision {1}.").format(
378
msg = "The repository %s contains no revision %s." % (
463
379
b.repository.base, revision_id)
464
380
raise errors.BzrCommandError(msg)
465
381
elif revision is not None:
466
382
for rev in revision:
467
383
if rev is None:
468
384
raise errors.BzrCommandError(
469
gettext('You cannot specify a NULL revision.'))
385
'You cannot specify a NULL revision.')
470
386
rev_id = rev.as_revision_id(b)
471
387
self.print_revision(revisions, rev_id)
472
388
finally:
528
444
self.outf.write(page_bytes[:header_end])
529
445
page_bytes = data
530
446
self.outf.write('\nPage %d\n' % (page_idx,))
531
if len(page_bytes) == 0:
532
self.outf.write('(empty)\n');
533
else:
534
decomp_bytes = zlib.decompress(page_bytes)
535
self.outf.write(decomp_bytes)
536
self.outf.write('\n')
447
decomp_bytes = zlib.decompress(page_bytes)
448
self.outf.write(decomp_bytes)
449
self.outf.write('\n')
537
450
538
451
def _dump_entries(self, trans, basename):
539
452
try:
570
483
takes_options = [
571
484
Option('force',
572
485
help='Remove the working tree even if it has '
573
'uncommitted or shelved changes.'),
486
'uncommitted changes.'),
574
487
]
575
488
576
489
def run(self, location_list, force=False):
578
491
location_list=['.']
579
492
580
493
for location in location_list:
581
d = controldir.ControlDir.open(location)
582
494
d = bzrdir.BzrDir.open(location)
495
583
496
try:
584
497
working = d.open_workingtree()
585
498
except errors.NoWorkingTree:
586
raise errors.BzrCommandError(gettext("No working tree to remove"))
499
raise errors.BzrCommandError("No working tree to remove")
587
500
except errors.NotLocalUrl:
588
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
589
" of a remote path"))
501
raise errors.BzrCommandError("You cannot remove the working tree"
502
" of a remote path")
590
503
if not force:
591
504
if (working.has_changes()):
592
505
raise errors.UncommittedChanges(working)
593
if working.get_shelf_manager().last_shelf() is not None:
594
raise errors.ShelvedChanges(working)
595
506
596
507
if working.user_url != working.branch.user_url:
597
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
598
" from a lightweight checkout"))
508
raise errors.BzrCommandError("You cannot remove the working tree"
509
" from a lightweight checkout")
599
510
600
511
d.destroy_workingtree()
601
512
602
513
603
class cmd_repair_workingtree(Command):
604
__doc__ = """Reset the working tree state file.
605
606
This is not meant to be used normally, but more as a way to recover from
607
filesystem corruption, etc. This rebuilds the working inventory back to a
608
'known good' state. Any new modifications (adding a file, renaming, etc)
609
will be lost, though modified files will still be detected as such.
610
611
Most users will want something more like "bzr revert" or "bzr update"
612
unless the state file has become corrupted.
613
614
By default this attempts to recover the current state by looking at the
615
headers of the state file. If the state file is too corrupted to even do
616
that, you can supply --revision to force the state of the tree.
617
"""
618
619
takes_options = ['revision', 'directory',
620
Option('force',
621
help='Reset the tree even if it doesn\'t appear to be'
622
' corrupted.'),
623
]
624
hidden = True
625
626
def run(self, revision=None, directory='.', force=False):
627
tree, _ = WorkingTree.open_containing(directory)
628
self.add_cleanup(tree.lock_tree_write().unlock)
629
if not force:
630
try:
631
tree.check_state()
632
except errors.BzrError:
633
pass # There seems to be a real error here, so we'll reset
634
else:
635
# Refuse
636
raise errors.BzrCommandError(gettext(
637
'The tree does not appear to be corrupt. You probably'
638
' want "bzr revert" instead. Use "--force" if you are'
639
' sure you want to reset the working tree.'))
640
if revision is None:
641
revision_ids = None
642
else:
643
revision_ids = [r.as_revision_id(tree.branch) for r in revision]
644
try:
645
tree.reset_state(revision_ids)
646
except errors.BzrError, e:
647
if revision_ids is None:
648
extra = (gettext(', the header appears corrupt, try passing -r -1'
649
' to set the state to the last commit'))
650
else:
651
extra = ''
652
raise errors.BzrCommandError(gettext('failed to reset the tree state{0}').format(extra))
653
654
655
514
class cmd_revno(Command):
656
515
__doc__ = """Show current revision number.
657
516
661
520
_see_also = ['info']
662
521
takes_args = ['location?']
663
522
takes_options = [
664
Option('tree', help='Show revno of working tree.'),
665
'revision',
523
Option('tree', help='Show revno of working tree'),
666
524
]
667
525
668
526
@display_command
669
def run(self, tree=False, location=u'.', revision=None):
670
if revision is not None and tree:
671
raise errors.BzrCommandError(gettext("--tree and --revision can "
672
"not be used together"))
673
527
def run(self, tree=False, location=u'.'):
674
528
if tree:
675
529
try:
676
530
wt = WorkingTree.open_containing(location)[0]
677
self.add_cleanup(wt.lock_read().unlock)
531
wt.lock_read()
678
532
except (errors.NoWorkingTree, errors.NotLocalUrl):
679
533
raise errors.NoWorkingTree(location)
680
b = wt.branch
534
self.add_cleanup(wt.unlock)
681
535
revid = wt.last_revision()
536
try:
537
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
538
except errors.NoSuchRevision:
539
revno_t = ('???',)
540
revno = ".".join(str(n) for n in revno_t)
682
541
else:
683
542
b = Branch.open_containing(location)[0]
684
self.add_cleanup(b.lock_read().unlock)
685
if revision:
686
if len(revision) != 1:
687
raise errors.BzrCommandError(gettext(
688
"Tags can only be placed on a single revision, "
689
"not on a range"))
690
revid = revision[0].as_revision_id(b)
691
else:
692
revid = b.last_revision()
693
try:
694
revno_t = b.revision_id_to_dotted_revno(revid)
695
except errors.NoSuchRevision:
696
revno_t = ('???',)
697
revno = ".".join(str(n) for n in revno_t)
543
b.lock_read()
544
self.add_cleanup(b.unlock)
545
revno = b.revno()
698
546
self.cleanup_now()
699
self.outf.write(revno + '\n')
547
self.outf.write(str(revno) + '\n')
700
548
701
549
702
550
class cmd_revision_info(Command):
706
554
takes_args = ['revision_info*']
707
555
takes_options = [
708
556
'revision',
709
custom_help('directory',
557
Option('directory',
710
558
help='Branch to examine, '
711
'rather than the one containing the working directory.'),
712
Option('tree', help='Show revno of working tree.'),
559
'rather than the one containing the working directory.',
560
short_name='d',
561
type=unicode,
562
),
563
Option('tree', help='Show revno of working tree'),
713
564
]
714
565
715
566
@display_command
719
570
try:
720
571
wt = WorkingTree.open_containing(directory)[0]
721
572
b = wt.branch
722
self.add_cleanup(wt.lock_read().unlock)
573
wt.lock_read()
574
self.add_cleanup(wt.unlock)
723
575
except (errors.NoWorkingTree, errors.NotLocalUrl):
724
576
wt = None
725
577
b = Branch.open_containing(directory)[0]
726
self.add_cleanup(b.lock_read().unlock)
578
b.lock_read()
579
self.add_cleanup(b.unlock)
727
580
revision_ids = []
728
581
if revision is not None:
729
582
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
771
624
are added. This search proceeds recursively into versioned
772
625
directories. If no names are given '.' is assumed.
773
626
774
A warning will be printed when nested trees are encountered,
775
unless they are explicitly ignored.
776
777
627
Therefore simply saying 'bzr add' will version all files that
778
628
are currently unknown.
779
629
795
645
796
646
Any files matching patterns in the ignore list will not be added
797
647
unless they are explicitly mentioned.
798
799
In recursive mode, files larger than the configuration option
800
add.maximum_file_size will be skipped. Named items are never skipped due
801
to file size.
802
648
"""
803
649
takes_args = ['file*']
804
650
takes_options = [
805
651
Option('no-recurse',
806
help="Don't recursively add the contents of directories.",
807
short_name='N'),
652
help="Don't recursively add the contents of directories."),
808
653
Option('dry-run',
809
654
help="Show what would be done, but don't actually do anything."),
810
655
'verbose',
832
677
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
833
678
to_file=self.outf, should_print=(not is_quiet()))
834
679
else:
835
action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
680
action = bzrlib.add.AddAction(to_file=self.outf,
836
681
should_print=(not is_quiet()))
837
682
838
683
if base_tree:
839
self.add_cleanup(base_tree.lock_read().unlock)
684
base_tree.lock_read()
685
self.add_cleanup(base_tree.unlock)
840
686
tree, file_list = tree_files_for_add(file_list)
841
687
added, ignored = tree.smart_add(file_list, not
842
688
no_recurse, action=action, save=not dry_run)
845
691
if verbose:
846
692
for glob in sorted(ignored.keys()):
847
693
for path in ignored[glob]:
848
self.outf.write(
849
gettext("ignored {0} matching \"{1}\"\n").format(
850
path, glob))
694
self.outf.write("ignored %s matching \"%s\"\n"
695
% (path, glob))
851
696
852
697
853
698
class cmd_mkdir(Command):
857
702
"""
858
703
859
704
takes_args = ['dir+']
860
takes_options = [
861
Option(
862
'parents',
863
help='No error if existing, make parent directories as needed.',
864
short_name='p'
865
)
866
]
867
705
encoding_type = 'replace'
868
706
869
@classmethod
870
def add_file_with_parents(cls, wt, relpath):
871
if wt.path2id(relpath) is not None:
872
return
873
cls.add_file_with_parents(wt, osutils.dirname(relpath))
874
wt.add([relpath])
875
876
@classmethod
877
def add_file_single(cls, wt, relpath):
878
wt.add([relpath])
879
880
def run(self, dir_list, parents=False):
881
if parents:
882
add_file = self.add_file_with_parents
883
else:
884
add_file = self.add_file_single
885
for dir in dir_list:
886
wt, relpath = WorkingTree.open_containing(dir)
887
if parents:
888
try:
889
os.makedirs(dir)
890
except OSError, e:
891
if e.errno != errno.EEXIST:
892
raise
707
def run(self, dir_list):
708
for d in dir_list:
709
wt, dd = WorkingTree.open_containing(d)
710
base = os.path.dirname(dd)
711
id = wt.path2id(base)
712
if id != None:
713
os.mkdir(d)
714
wt.add([dd])
715
self.outf.write('added %s\n' % d)
893
716
else:
894
os.mkdir(dir)
895
add_file(wt, relpath)
896
if not is_quiet():
897
self.outf.write(gettext('added %s\n') % dir)
717
raise errors.NotVersionedError(path=base)
898
718
899
719
900
720
class cmd_relpath(Command):
936
756
@display_command
937
757
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
938
758
if kind and kind not in ['file', 'directory', 'symlink']:
939
raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
759
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
940
760
941
761
revision = _get_one_revision('inventory', revision)
942
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
943
self.add_cleanup(work_tree.lock_read().unlock)
762
work_tree, file_list = tree_files(file_list)
763
work_tree.lock_read()
764
self.add_cleanup(work_tree.unlock)
944
765
if revision is not None:
945
766
tree = revision.as_tree(work_tree.branch)
946
767
947
768
extra_trees = [work_tree]
948
self.add_cleanup(tree.lock_read().unlock)
769
tree.lock_read()
770
self.add_cleanup(tree.unlock)
949
771
else:
950
772
tree = work_tree
951
773
extra_trees = []
952
774
953
self.add_cleanup(tree.lock_read().unlock)
954
775
if file_list is not None:
955
776
file_ids = tree.paths2ids(file_list, trees=extra_trees,
956
777
require_versioned=True)
957
778
# find_ids_across_trees may include some paths that don't
958
779
# exist in 'tree'.
959
entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
780
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
781
for file_id in file_ids if file_id in tree)
960
782
else:
961
entries = tree.iter_entries_by_dir()
783
entries = tree.inventory.entries()
962
784
963
for path, entry in sorted(entries):
785
self.cleanup_now()
786
for path, entry in entries:
964
787
if kind and kind != entry.kind:
965
788
continue
966
if path == "":
967
continue
968
789
if show_ids:
969
790
self.outf.write('%-50s %s\n' % (path, entry.file_id))
970
791
else:
1006
827
if auto:
1007
828
return self.run_auto(names_list, after, dry_run)
1008
829
elif dry_run:
1009
raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
830
raise errors.BzrCommandError('--dry-run requires --auto.')
1010
831
if names_list is None:
1011
832
names_list = []
1012
833
if len(names_list) < 2:
1013
raise errors.BzrCommandError(gettext("missing file argument"))
1014
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
1015
for file_name in rel_names[0:-1]:
1016
if file_name == '':
1017
raise errors.BzrCommandError(gettext("can not move root of branch"))
1018
self.add_cleanup(tree.lock_tree_write().unlock)
834
raise errors.BzrCommandError("missing file argument")
835
tree, rel_names = tree_files(names_list, canonicalize=False)
836
tree.lock_tree_write()
837
self.add_cleanup(tree.unlock)
1019
838
self._run(tree, names_list, rel_names, after)
1020
839
1021
840
def run_auto(self, names_list, after, dry_run):
1022
841
if names_list is not None and len(names_list) > 1:
1023
raise errors.BzrCommandError(gettext('Only one path may be specified to'
1024
' --auto.'))
842
raise errors.BzrCommandError('Only one path may be specified to'
843
' --auto.')
1025
844
if after:
1026
raise errors.BzrCommandError(gettext('--after cannot be specified with'
1027
' --auto.'))
1028
work_tree, file_list = WorkingTree.open_containing_paths(
1029
names_list, default_directory='.')
1030
self.add_cleanup(work_tree.lock_tree_write().unlock)
845
raise errors.BzrCommandError('--after cannot be specified with'
846
' --auto.')
847
work_tree, file_list = tree_files(names_list, default_branch='.')
848
work_tree.lock_tree_write()
849
self.add_cleanup(work_tree.unlock)
1031
850
rename_map.RenameMap.guess_renames(work_tree, dry_run)
1032
851
1033
852
def _run(self, tree, names_list, rel_names, after):
1042
861
and rel_names[0].lower() == rel_names[1].lower()):
1043
862
into_existing = False
1044
863
else:
864
inv = tree.inventory
1045
865
# 'fix' the case of a potential 'from'
1046
866
from_id = tree.path2id(
1047
867
tree.get_canonical_inventory_path(rel_names[0]))
1048
868
if (not osutils.lexists(names_list[0]) and
1049
from_id and tree.stored_kind(from_id) == "directory"):
869
from_id and inv.get_file_kind(from_id) == "directory"):
1050
870
into_existing = False
1051
871
# move/rename
1052
872
if into_existing:
1059
879
self.outf.write("%s => %s\n" % (src, dest))
1060
880
else:
1061
881
if len(names_list) != 2:
1062
raise errors.BzrCommandError(gettext('to mv multiple files the'
882
raise errors.BzrCommandError('to mv multiple files the'
1063
883
' destination must be a versioned'
1064
' directory'))
884
' directory')
1065
885
1066
886
# for cicp file-systems: the src references an existing inventory
1067
887
# item:
1126
946
match the remote one, use pull --overwrite. This will work even if the two
1127
947
branches have diverged.
1128
948
1129
If there is no default location set, the first pull will set it (use
1130
--no-remember to avoid setting it). After that, you can omit the
1131
location to use the default. To change the default, use --remember. The
1132
value will only be saved if the remote location can be accessed.
1133
1134
The --verbose option will display the revisions pulled using the log_format
1135
configuration option. You can use a different format by overriding it with
1136
-Olog_format=<other_format>.
949
If there is no default location set, the first pull will set it. After
950
that, you can omit the location to use the default. To change the
951
default, use --remember. The value will only be saved if the remote
952
location can be accessed.
1137
953
1138
954
Note: The location can be specified either in the form of a branch,
1139
955
or in the form of a path to a file containing a merge directive generated
1144
960
takes_options = ['remember', 'overwrite', 'revision',
1145
961
custom_help('verbose',
1146
962
help='Show logs of pulled revisions.'),
1147
custom_help('directory',
963
Option('directory',
1148
964
help='Branch to pull into, '
1149
'rather than the one containing the working directory.'),
965
'rather than the one containing the working directory.',
966
short_name='d',
967
type=unicode,
968
),
1150
969
Option('local',
1151
970
help="Perform a local pull in a bound "
1152
971
"branch. Local pulls are not applied to "
1153
972
"the master branch."
1154
973
),
1155
Option('show-base',
1156
help="Show base revision text in conflicts."),
1157
Option('overwrite-tags',
1158
help="Overwrite tags only."),
1159
974
]
1160
975
takes_args = ['location?']
1161
976
encoding_type = 'replace'
1162
977
1163
def run(self, location=None, remember=None, overwrite=False,
978
def run(self, location=None, remember=False, overwrite=False,
1164
979
revision=None, verbose=False,
1165
directory=None, local=False,
1166
show_base=False, overwrite_tags=False):
1167
1168
if overwrite:
1169
overwrite = ["history", "tags"]
1170
elif overwrite_tags:
1171
overwrite = ["tags"]
1172
else:
1173
overwrite = []
980
directory=None, local=False):
1174
981
# FIXME: too much stuff is in the command class
1175
982
revision_id = None
1176
983
mergeable = None
1179
986
try:
1180
987
tree_to = WorkingTree.open_containing(directory)[0]
1181
988
branch_to = tree_to.branch
1182
self.add_cleanup(tree_to.lock_write().unlock)
989
tree_to.lock_write()
990
self.add_cleanup(tree_to.unlock)
1183
991
except errors.NoWorkingTree:
1184
992
tree_to = None
1185
993
branch_to = Branch.open_containing(directory)[0]
1186
self.add_cleanup(branch_to.lock_write().unlock)
1187
1188
if tree_to is None and show_base:
1189
raise errors.BzrCommandError(gettext("Need working tree for --show-base."))
994
branch_to.lock_write()
995
self.add_cleanup(branch_to.unlock)
1190
996
1191
997
if local and not branch_to.get_bound_location():
1192
998
raise errors.LocalRequiresBoundBranch()
1202
1008
stored_loc = branch_to.get_parent()
1203
1009
if location is None:
1204
1010
if stored_loc is None:
1205
raise errors.BzrCommandError(gettext("No pull location known or"
1206
" specified."))
1011
raise errors.BzrCommandError("No pull location known or"
1012
" specified.")
1207
1013
else:
1208
1014
display_url = urlutils.unescape_for_display(stored_loc,
1209
1015
self.outf.encoding)
1210
1016
if not is_quiet():
1211
self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
1017
self.outf.write("Using saved parent location: %s\n" % display_url)
1212
1018
location = stored_loc
1213
1019
1214
1020
revision = _get_one_revision('pull', revision)
1215
1021
if mergeable is not None:
1216
1022
if revision is not None:
1217
raise errors.BzrCommandError(gettext(
1218
'Cannot use -r with merge directives or bundles'))
1023
raise errors.BzrCommandError(
1024
'Cannot use -r with merge directives or bundles')
1219
1025
mergeable.install_revisions(branch_to.repository)
1220
1026
base_revision_id, revision_id, verified = \
1221
1027
mergeable.get_merge_request(branch_to.repository)
1223
1029
else:
1224
1030
branch_from = Branch.open(location,
1225
1031
possible_transports=possible_transports)
1226
self.add_cleanup(branch_from.lock_read().unlock)
1227
# Remembers if asked explicitly or no previous location is set
1228
if (remember
1229
or (remember is None and branch_to.get_parent() is None)):
1230
# FIXME: This shouldn't be done before the pull
1231
# succeeds... -- vila 2012-01-02
1032
branch_from.lock_read()
1033
self.add_cleanup(branch_from.unlock)
1034
1035
if branch_to.get_parent() is None or remember:
1232
1036
branch_to.set_parent(branch_from.base)
1233
1037
1234
1038
if revision is not None:
1241
1045
view_info=view_info)
1242
1046
result = tree_to.pull(
1243
1047
branch_from, overwrite, revision_id, change_reporter,
1244
local=local, show_base=show_base)
1048
possible_transports=possible_transports, local=local)
1245
1049
else:
1246
1050
result = branch_to.pull(
1247
1051
branch_from, overwrite, revision_id, local=local)
1251
1055
log.show_branch_change(
1252
1056
branch_to, self.outf, result.old_revno,
1253
1057
result.old_revid)
1254
if getattr(result, 'tag_conflicts', None):
1255
return 1
1256
else:
1257
return 0
1258
1058
1259
1059
1260
1060
class cmd_push(Command):
1277
1077
do a merge (see bzr help merge) from the other branch, and commit that.
1278
1078
After that you will be able to do a push without '--overwrite'.
1279
1079
1280
If there is no default push location set, the first push will set it (use
1281
--no-remember to avoid setting it). After that, you can omit the
1282
location to use the default. To change the default, use --remember. The
1283
value will only be saved if the remote location can be accessed.
1284
1285
The --verbose option will display the revisions pushed using the log_format
1286
configuration option. You can use a different format by overriding it with
1287
-Olog_format=<other_format>.
1080
If there is no default push location set, the first push will set it.
1081
After that, you can omit the location to use the default. To change the
1082
default, use --remember. The value will only be saved if the remote
1083
location can be accessed.
1288
1084
"""
1289
1085
1290
1086
_see_also = ['pull', 'update', 'working-trees']
1292
1088
Option('create-prefix',
1293
1089
help='Create the path leading up to the branch '
1294
1090
'if it does not already exist.'),
1295
custom_help('directory',
1091
Option('directory',
1296
1092
help='Branch to push from, '
1297
'rather than the one containing the working directory.'),
1093
'rather than the one containing the working directory.',
1094
short_name='d',
1095
type=unicode,
1096
),
1298
1097
Option('use-existing-dir',
1299
1098
help='By default push will fail if the target'
1300
1099
' directory exists, but does not already'
1311
1110
Option('strict',
1312
1111
help='Refuse to push if there are uncommitted changes in'
1313
1112
' the working tree, --no-strict disables the check.'),
1314
Option('no-tree',
1315
help="Don't populate the working tree, even for protocols"
1316
" that support it."),
1317
Option('overwrite-tags',
1318
help="Overwrite tags only."),
1319
1113
]
1320
1114
takes_args = ['location?']
1321
1115
encoding_type = 'replace'
1322
1116
1323
def run(self, location=None, remember=None, overwrite=False,
1117
def run(self, location=None, remember=False, overwrite=False,
1324
1118
create_prefix=False, verbose=False, revision=None,
1325
1119
use_existing_dir=False, directory=None, stacked_on=None,
1326
stacked=False, strict=None, no_tree=False,
1327
overwrite_tags=False):
1120
stacked=False, strict=None):
1328
1121
from bzrlib.push import _show_push_branch
1329
1122
1330
if overwrite:
1331
overwrite = ["history", "tags"]
1332
elif overwrite_tags:
1333
overwrite = ["tags"]
1334
else:
1335
overwrite = []
1336
1337
1123
if directory is None:
1338
1124
directory = '.'
1339
1125
# Get the source branch
1340
1126
(tree, br_from,
1341
_unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1127
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1342
1128
# Get the tip's revision_id
1343
1129
revision = _get_one_revision('push', revision)
1344
1130
if revision is not None:
1365
1151
# error by the feedback given to them. RBC 20080227.
1366
1152
stacked_on = parent_url
1367
1153
if not stacked_on:
1368
raise errors.BzrCommandError(gettext(
1369
"Could not determine branch to refer to."))
1154
raise errors.BzrCommandError(
1155
"Could not determine branch to refer to.")
1370
1156
1371
1157
# Get the destination location
1372
1158
if location is None:
1373
1159
stored_loc = br_from.get_push_location()
1374
1160
if stored_loc is None:
1375
parent_loc = br_from.get_parent()
1376
if parent_loc:
1377
raise errors.BzrCommandError(gettext(
1378
"No push location known or specified. To push to the "
1379
"parent branch (at %s), use 'bzr push :parent'." %
1380
urlutils.unescape_for_display(parent_loc,
1381
self.outf.encoding)))
1382
else:
1383
raise errors.BzrCommandError(gettext(
1384
"No push location known or specified."))
1161
raise errors.BzrCommandError(
1162
"No push location known or specified.")
1385
1163
else:
1386
1164
display_url = urlutils.unescape_for_display(stored_loc,
1387
1165
self.outf.encoding)
1388
note(gettext("Using saved push location: %s") % display_url)
1166
self.outf.write("Using saved push location: %s\n" % display_url)
1389
1167
location = stored_loc
1390
1168
1391
1169
_show_push_branch(br_from, revision_id, location, self.outf,
1392
1170
verbose=verbose, overwrite=overwrite, remember=remember,
1393
1171
stacked_on=stacked_on, create_prefix=create_prefix,
1394
use_existing_dir=use_existing_dir, no_tree=no_tree)
1172
use_existing_dir=use_existing_dir)
1395
1173
1396
1174
1397
1175
class cmd_branch(Command):
1406
1184
1407
1185
To retrieve the branch as of a particular revision, supply the --revision
1408
1186
parameter, as in "branch foo/bar -r 5".
1409
1410
The synonyms 'clone' and 'get' for this command are deprecated.
1411
1187
"""
1412
1188
1413
1189
_see_also = ['checkout']
1414
1190
takes_args = ['from_location', 'to_location?']
1415
takes_options = ['revision',
1416
Option('hardlink', help='Hard-link working tree files where possible.'),
1417
Option('files-from', type=str,
1418
help="Get file contents from this tree."),
1191
takes_options = ['revision', Option('hardlink',
1192
help='Hard-link working tree files where possible.'),
1419
1193
Option('no-tree',
1420
1194
help="Create a branch without a working-tree."),
1421
1195
Option('switch',
1439
1213
1440
1214
def run(self, from_location, to_location=None, revision=None,
1441
1215
hardlink=False, stacked=False, standalone=False, no_tree=False,
1442
use_existing_dir=False, switch=False, bind=False,
1443
files_from=None):
1216
use_existing_dir=False, switch=False, bind=False):
1444
1217
from bzrlib import switch as _mod_switch
1445
1218
from bzrlib.tag import _merge_tags_if_possible
1446
if self.invoked_as in ['get', 'clone']:
1447
ui.ui_factory.show_user_warning(
1448
'deprecated_command',
1449
deprecated_name=self.invoked_as,
1450
recommended_name='branch',
1451
deprecated_in_version='2.4')
1452
accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
1219
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1453
1220
from_location)
1454
if not (hardlink or files_from):
1455
# accelerator_tree is usually slower because you have to read N
1456
# files (no readahead, lots of seeks, etc), but allow the user to
1457
# explicitly request it
1458
accelerator_tree = None
1459
if files_from is not None and files_from != from_location:
1460
accelerator_tree = WorkingTree.open(files_from)
1461
1221
revision = _get_one_revision('branch', revision)
1462
self.add_cleanup(br_from.lock_read().unlock)
1222
br_from.lock_read()
1223
self.add_cleanup(br_from.unlock)
1463
1224
if revision is not None:
1464
1225
revision_id = revision.as_revision_id(br_from)
1465
1226
else:
1468
1229
# RBC 20060209
1469
1230
revision_id = br_from.last_revision()
1470
1231
if to_location is None:
1471
to_location = getattr(br_from, "name", None)
1472
if not to_location:
1473
to_location = urlutils.derive_to_location(from_location)
1232
to_location = urlutils.derive_to_location(from_location)
1474
1233
to_transport = transport.get_transport(to_location)
1475
1234
try:
1476
1235
to_transport.mkdir('.')
1477
1236
except errors.FileExists:
1478
try:
1479
to_dir = controldir.ControlDir.open_from_transport(
1480
to_transport)
1481
except errors.NotBranchError:
1482
if not use_existing_dir:
1483
raise errors.BzrCommandError(gettext('Target directory "%s" '
1484
'already exists.') % to_location)
1485
else:
1486
to_dir = None
1237
if not use_existing_dir:
1238
raise errors.BzrCommandError('Target directory "%s" '
1239
'already exists.' % to_location)
1487
1240
else:
1488
1241
try:
1489
to_dir.open_branch()
1242
bzrdir.BzrDir.open_from_transport(to_transport)
1490
1243
except errors.NotBranchError:
1491
1244
pass
1492
1245
else:
1493
1246
raise errors.AlreadyBranchError(to_location)
1494
1247
except errors.NoSuchFile:
1495
raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
1248
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1496
1249
% to_location)
1497
else:
1498
to_dir = None
1499
if to_dir is None:
1500
try:
1501
# preserve whatever source format we have.
1502
to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1503
possible_transports=[to_transport],
1504
accelerator_tree=accelerator_tree,
1505
hardlink=hardlink, stacked=stacked,
1506
force_new_repo=standalone,
1507
create_tree_if_local=not no_tree,
1508
source_branch=br_from)
1509
branch = to_dir.open_branch(
1510
possible_transports=[
1511
br_from.bzrdir.root_transport, to_transport])
1512
except errors.NoSuchRevision:
1513
to_transport.delete_tree('.')
1514
msg = gettext("The branch {0} has no revision {1}.").format(
1515
from_location, revision)
1516
raise errors.BzrCommandError(msg)
1517
else:
1518
try:
1519
to_repo = to_dir.open_repository()
1520
except errors.NoRepositoryPresent:
1521
to_repo = to_dir.create_repository()
1522
to_repo.fetch(br_from.repository, revision_id=revision_id)
1523
branch = br_from.sprout(to_dir, revision_id=revision_id)
1250
try:
1251
# preserve whatever source format we have.
1252
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1253
possible_transports=[to_transport],
1254
accelerator_tree=accelerator_tree,
1255
hardlink=hardlink, stacked=stacked,
1256
force_new_repo=standalone,
1257
create_tree_if_local=not no_tree,
1258
source_branch=br_from)
1259
branch = dir.open_branch()
1260
except errors.NoSuchRevision:
1261
to_transport.delete_tree('.')
1262
msg = "The branch %s has no revision %s." % (from_location,
1263
revision)
1264
raise errors.BzrCommandError(msg)
1524
1265
_merge_tags_if_possible(br_from, branch)
1525
1266
# If the source branch is stacked, the new branch may
1526
1267
# be stacked whether we asked for that explicitly or not.
1527
1268
# We therefore need a try/except here and not just 'if stacked:'
1528
1269
try:
1529
note(gettext('Created new stacked branch referring to %s.') %
1270
note('Created new stacked branch referring to %s.' %
1530
1271
branch.get_stacked_on_url())
1531
1272
except (errors.NotStacked, errors.UnstackableBranchFormat,
1532
1273
errors.UnstackableRepositoryFormat), e:
1533
note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1274
note('Branched %d revision(s).' % branch.revno())
1534
1275
if bind:
1535
1276
# Bind to the parent
1536
1277
parent_branch = Branch.open(from_location)
1537
1278
branch.bind(parent_branch)
1538
note(gettext('New branch bound to %s') % from_location)
1279
note('New branch bound to %s' % from_location)
1539
1280
if switch:
1540
1281
# Switch to the new branch
1541
1282
wt, _ = WorkingTree.open_containing('.')
1542
1283
_mod_switch.switch(wt.bzrdir, branch)
1543
note(gettext('Switched to branch: %s'),
1284
note('Switched to branch: %s',
1544
1285
urlutils.unescape_for_display(branch.base, 'utf-8'))
1545
1286
1546
1287
1547
class cmd_branches(Command):
1548
__doc__ = """List the branches available at the current location.
1549
1550
This command will print the names of all the branches at the current
1551
location.
1552
"""
1553
1554
takes_args = ['location?']
1555
takes_options = [
1556
Option('recursive', short_name='R',
1557
help='Recursively scan for branches rather than '
1558
'just looking in the specified location.')]
1559
1560
def run(self, location=".", recursive=False):
1561
if recursive:
1562
t = transport.get_transport(location)
1563
if not t.listable():
1564
raise errors.BzrCommandError(
1565
"Can't scan this type of location.")
1566
for b in controldir.ControlDir.find_branches(t):
1567
self.outf.write("%s\n" % urlutils.unescape_for_display(
1568
urlutils.relative_url(t.base, b.base),
1569
self.outf.encoding).rstrip("/"))
1570
else:
1571
dir = controldir.ControlDir.open_containing(location)[0]
1572
try:
1573
active_branch = dir.open_branch(name="")
1574
except errors.NotBranchError:
1575
active_branch = None
1576
names = {}
1577
for name, branch in iter_sibling_branches(dir):
1578
if name == "":
1579
continue
1580
active = (active_branch is not None and
1581
active_branch.base == branch.base)
1582
names[name] = active
1583
# Only mention the current branch explicitly if it's not
1584
# one of the colocated branches
1585
if not any(names.values()) and active_branch is not None:
1586
self.outf.write("* %s\n" % gettext("(default)"))
1587
for name in sorted(names.keys()):
1588
active = names[name]
1589
if active:
1590
prefix = "*"
1591
else:
1592
prefix = " "
1593
self.outf.write("%s %s\n" % (
1594
prefix, name.encode(self.outf.encoding)))
1595
1596
1597
1288
class cmd_checkout(Command):
1598
1289
__doc__ = """Create a new checkout of an existing branch.
1599
1290
1615
1306
code.)
1616
1307
"""
1617
1308
1618
_see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1309
_see_also = ['checkouts', 'branch']
1619
1310
takes_args = ['branch_location?', 'to_location?']
1620
1311
takes_options = ['revision',
1621
1312
Option('lightweight',
1638
1329
if branch_location is None:
1639
1330
branch_location = osutils.getcwd()
1640
1331
to_location = branch_location
1641
accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1332
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1642
1333
branch_location)
1643
if not (hardlink or files_from):
1644
# accelerator_tree is usually slower because you have to read N
1645
# files (no readahead, lots of seeks, etc), but allow the user to
1646
# explicitly request it
1647
accelerator_tree = None
1648
1334
revision = _get_one_revision('checkout', revision)
1649
if files_from is not None and files_from != branch_location:
1335
if files_from is not None:
1650
1336
accelerator_tree = WorkingTree.open(files_from)
1651
1337
if revision is not None:
1652
1338
revision_id = revision.as_revision_id(source)
1680
1366
@display_command
1681
1367
def run(self, dir=u'.'):
1682
1368
tree = WorkingTree.open_containing(dir)[0]
1683
self.add_cleanup(tree.lock_read().unlock)
1369
tree.lock_read()
1370
self.add_cleanup(tree.unlock)
1371
new_inv = tree.inventory
1684
1372
old_tree = tree.basis_tree()
1685
self.add_cleanup(old_tree.lock_read().unlock)
1373
old_tree.lock_read()
1374
self.add_cleanup(old_tree.unlock)
1375
old_inv = old_tree.inventory
1686
1376
renames = []
1687
1377
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1688
1378
for f, paths, c, v, p, n, k, e in iterator:
1697
1387
1698
1388
1699
1389
class cmd_update(Command):
1700
__doc__ = """Update a working tree to a new revision.
1701
1702
This will perform a merge of the destination revision (the tip of the
1703
branch, or the specified revision) into the working tree, and then make
1704
that revision the basis revision for the working tree.
1705
1706
You can use this to visit an older revision, or to update a working tree
1707
that is out of date from its branch.
1708
1709
If there are any uncommitted changes in the tree, they will be carried
1710
across and remain as uncommitted changes after the update. To discard
1711
these changes, use 'bzr revert'. The uncommitted changes may conflict
1712
with the changes brought in by the change in basis revision.
1713
1714
If the tree's branch is bound to a master branch, bzr will also update
1390
__doc__ = """Update a tree to have the latest code committed to its branch.
1391
1392
This will perform a merge into the working tree, and may generate
1393
conflicts. If you have any local changes, you will still
1394
need to commit them after the update for the update to be complete.
1395
1396
If you want to discard your local changes, you can just do a
1397
'bzr revert' instead of 'bzr commit' after the update.
1398
1399
If the tree's branch is bound to a master branch, it will also update
1715
1400
the branch from the master.
1716
1717
You cannot update just a single file or directory, because each Bazaar
1718
working tree has just a single basis revision. If you want to restore a
1719
file that has been removed locally, use 'bzr revert' instead of 'bzr
1720
update'. If you want to restore a file to its state in a previous
1721
revision, use 'bzr revert' with a '-r' option, or use 'bzr cat' to write
1722
out the old content of that file to a new location.
1723
1724
The 'dir' argument, if given, must be the location of the root of a
1725
working tree to update. By default, the working tree that contains the
1726
current working directory is used.
1727
1401
"""
1728
1402
1729
1403
_see_also = ['pull', 'working-trees', 'status-flags']
1730
1404
takes_args = ['dir?']
1731
takes_options = ['revision',
1732
Option('show-base',
1733
help="Show base revision text in conflicts."),
1734
]
1405
takes_options = ['revision']
1735
1406
aliases = ['up']
1736
1407
1737
def run(self, dir=None, revision=None, show_base=None):
1408
def run(self, dir='.', revision=None):
1738
1409
if revision is not None and len(revision) != 1:
1739
raise errors.BzrCommandError(gettext(
1740
"bzr update --revision takes exactly one revision"))
1741
if dir is None:
1742
tree = WorkingTree.open_containing('.')[0]
1743
else:
1744
tree, relpath = WorkingTree.open_containing(dir)
1745
if relpath:
1746
# See bug 557886.
1747
raise errors.BzrCommandError(gettext(
1748
"bzr update can only update a whole tree, "
1749
"not a file or subdirectory"))
1410
raise errors.BzrCommandError(
1411
"bzr update --revision takes exactly one revision")
1412
tree = WorkingTree.open_containing(dir)[0]
1750
1413
branch = tree.branch
1751
1414
possible_transports = []
1752
1415
master = branch.get_master_branch(
1753
1416
possible_transports=possible_transports)
1754
1417
if master is not None:
1418
tree.lock_write()
1755
1419
branch_location = master.base
1756
tree.lock_write()
1757
1420
else:
1421
tree.lock_tree_write()
1758
1422
branch_location = tree.branch.base
1759
tree.lock_tree_write()
1760
1423
self.add_cleanup(tree.unlock)
1761
1424
# get rid of the final '/' and be ready for display
1762
1425
branch_location = urlutils.unescape_for_display(
1776
1439
revision_id = branch.last_revision()
1777
1440
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1778
1441
revno = branch.revision_id_to_dotted_revno(revision_id)
1779
note(gettext("Tree is up to date at revision {0} of branch {1}"
1780
).format('.'.join(map(str, revno)), branch_location))
1442
note("Tree is up to date at revision %s of branch %s" %
1443
('.'.join(map(str, revno)), branch_location))
1781
1444
return 0
1782
1445
view_info = _get_view_info_for_change_reporter(tree)
1783
1446
change_reporter = delta._ChangeReporter(
1788
1451
change_reporter,
1789
1452
possible_transports=possible_transports,
1790
1453
revision=revision_id,
1791
old_tip=old_tip,
1792
show_base=show_base)
1454
old_tip=old_tip)
1793
1455
except errors.NoSuchRevision, e:
1794
raise errors.BzrCommandError(gettext(
1456
raise errors.BzrCommandError(
1795
1457
"branch has no revision %s\n"
1796
1458
"bzr update --revision only works"
1797
" for a revision in the branch history")
1459
" for a revision in the branch history"
1798
1460
% (e.revision))
1799
1461
revno = tree.branch.revision_id_to_dotted_revno(
1800
1462
_mod_revision.ensure_null(tree.last_revision()))
1801
note(gettext('Updated to revision {0} of branch {1}').format(
1802
'.'.join(map(str, revno)), branch_location))
1463
note('Updated to revision %s of branch %s' %
1464
('.'.join(map(str, revno)), branch_location))
1803
1465
parent_ids = tree.get_parent_ids()
1804
1466
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1805
note(gettext('Your local commits will now show as pending merges with '
1806
"'bzr status', and can be committed with 'bzr commit'."))
1467
note('Your local commits will now show as pending merges with '
1468
"'bzr status', and can be committed with 'bzr commit'.")
1807
1469
if conflicts != 0:
1808
1470
return 1
1809
1471
else:
1850
1512
else:
1851
1513
noise_level = 0
1852
1514
from bzrlib.info import show_bzrdir_info
1853
show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1515
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1854
1516
verbose=noise_level, outfile=self.outf)
1855
1517
1856
1518
1857
1519
class cmd_remove(Command):
1858
1520
__doc__ = """Remove files or directories.
1859
1521
1860
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1861
delete them if they can easily be recovered using revert otherwise they
1862
will be backed up (adding an extension of the form .~#~). If no options or
1863
parameters are given Bazaar will scan for files that are being tracked by
1864
Bazaar but missing in your tree and stop tracking them for you.
1522
This makes bzr stop tracking changes to the specified files. bzr will delete
1523
them if they can easily be recovered using revert. If no options or
1524
parameters are given bzr will scan for files that are being tracked by bzr
1525
but missing in your tree and stop tracking them for you.
1865
1526
"""
1866
1527
takes_args = ['file*']
1867
1528
takes_options = ['verbose',
1869
1530
RegistryOption.from_kwargs('file-deletion-strategy',
1870
1531
'The file deletion mode to be used.',
1871
1532
title='Deletion Strategy', value_switches=True, enum_switch=False,
1872
safe='Backup changed files (default).',
1533
safe='Only delete files if they can be'
1534
' safely recovered (default).',
1873
1535
keep='Delete from bzr but leave the working copy.',
1874
no_backup='Don\'t backup changed files.'),
1875
]
1536
force='Delete all the specified files, even if they can not be '
1537
'recovered and even if they are non-empty directories.')]
1876
1538
aliases = ['rm', 'del']
1877
1539
encoding_type = 'replace'
1878
1540
1879
1541
def run(self, file_list, verbose=False, new=False,
1880
1542
file_deletion_strategy='safe'):
1881
1882
tree, file_list = WorkingTree.open_containing_paths(file_list)
1543
tree, file_list = tree_files(file_list)
1883
1544
1884
1545
if file_list is not None:
1885
1546
file_list = [f for f in file_list]
1886
1547
1887
self.add_cleanup(tree.lock_write().unlock)
1548
tree.lock_write()
1549
self.add_cleanup(tree.unlock)
1888
1550
# Heuristics should probably all move into tree.remove_smart or
1889
1551
# some such?
1890
1552
if new:
1892
1554
specific_files=file_list).added
1893
1555
file_list = sorted([f[0] for f in added], reverse=True)
1894
1556
if len(file_list) == 0:
1895
raise errors.BzrCommandError(gettext('No matching files.'))
1557
raise errors.BzrCommandError('No matching files.')
1896
1558
elif file_list is None:
1897
1559
# missing files show up in iter_changes(basis) as
1898
1560
# versioned-with-no-kind.
1905
1567
file_deletion_strategy = 'keep'
1906
1568
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1907
1569
keep_files=file_deletion_strategy=='keep',
1908
force=(file_deletion_strategy=='no-backup'))
1570
force=file_deletion_strategy=='force')
1909
1571
1910
1572
1911
1573
class cmd_file_id(Command):
1973
1635
1974
1636
_see_also = ['check']
1975
1637
takes_args = ['branch?']
1976
takes_options = [
1977
Option('canonicalize-chks',
1978
help='Make sure CHKs are in canonical form (repairs '
1979
'bug 522637).',
1980
hidden=True),
1981
]
1982
1638
1983
def run(self, branch=".", canonicalize_chks=False):
1639
def run(self, branch="."):
1984
1640
from bzrlib.reconcile import reconcile
1985
dir = controldir.ControlDir.open(branch)
1986
reconcile(dir, canonicalize_chks=canonicalize_chks)
1641
dir = bzrdir.BzrDir.open(branch)
1642
reconcile(dir)
1987
1643
1988
1644
1989
1645
class cmd_revision_history(Command):
1997
1653
@display_command
1998
1654
def run(self, location="."):
1999
1655
branch = Branch.open_containing(location)[0]
2000
self.add_cleanup(branch.lock_read().unlock)
2001
graph = branch.repository.get_graph()
2002
history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
2003
[_mod_revision.NULL_REVISION]))
2004
for revid in reversed(history):
1656
for revid in branch.revision_history():
2005
1657
self.outf.write(revid)
2006
1658
self.outf.write('\n')
2007
1659
2025
1677
b = wt.branch
2026
1678
last_revision = wt.last_revision()
2027
1679
2028
self.add_cleanup(b.repository.lock_read().unlock)
2029
graph = b.repository.get_graph()
2030
revisions = [revid for revid, parents in
2031
graph.iter_ancestry([last_revision])]
2032
for revision_id in reversed(revisions):
2033
if _mod_revision.is_null(revision_id):
2034
continue
1680
revision_ids = b.repository.get_ancestry(last_revision)
1681
revision_ids.pop(0)
1682
for revision_id in revision_ids:
2035
1683
self.outf.write(revision_id + '\n')
2036
1684
2037
1685
2067
1715
RegistryOption('format',
2068
1716
help='Specify a format for this branch. '
2069
1717
'See "help formats".',
2070
lazy_registry=('bzrlib.controldir', 'format_registry'),
2071
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1718
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1719
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2072
1720
value_switches=True,
2073
1721
title="Branch format",
2074
1722
),
2075
1723
Option('append-revisions-only',
2076
1724
help='Never change revnos or the existing log.'
2077
' Append revisions to it only.'),
2078
Option('no-tree',
2079
'Create a branch without a working tree.')
1725
' Append revisions to it only.')
2080
1726
]
2081
1727
def run(self, location=None, format=None, append_revisions_only=False,
2082
create_prefix=False, no_tree=False):
1728
create_prefix=False):
2083
1729
if format is None:
2084
format = controldir.format_registry.make_bzrdir('default')
1730
format = bzrdir.format_registry.make_bzrdir('default')
2085
1731
if location is None:
2086
1732
location = u'.'
2087
1733
2096
1742
to_transport.ensure_base()
2097
1743
except errors.NoSuchFile:
2098
1744
if not create_prefix:
2099
raise errors.BzrCommandError(gettext("Parent directory of %s"
1745
raise errors.BzrCommandError("Parent directory of %s"
2100
1746
" does not exist."
2101
1747
"\nYou may supply --create-prefix to create all"
2102
" leading parent directories.")
1748
" leading parent directories."
2103
1749
% location)
2104
1750
to_transport.create_prefix()
2105
1751
2106
1752
try:
2107
a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1753
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
2108
1754
except errors.NotBranchError:
2109
1755
# really a NotBzrDir error...
2110
create_branch = controldir.ControlDir.create_branch_convenience
2111
if no_tree:
2112
force_new_tree = False
2113
else:
2114
force_new_tree = None
1756
create_branch = bzrdir.BzrDir.create_branch_convenience
2115
1757
branch = create_branch(to_transport.base, format=format,
2116
possible_transports=[to_transport],
2117
force_new_tree=force_new_tree)
1758
possible_transports=[to_transport])
2118
1759
a_bzrdir = branch.bzrdir
2119
1760
else:
2120
1761
from bzrlib.transport.local import LocalTransport
2124
1765
raise errors.BranchExistsWithoutWorkingTree(location)
2125
1766
raise errors.AlreadyBranchError(location)
2126
1767
branch = a_bzrdir.create_branch()
2127
if not no_tree and not a_bzrdir.has_workingtree():
2128
a_bzrdir.create_workingtree()
1768
a_bzrdir.create_workingtree()
2129
1769
if append_revisions_only:
2130
1770
try:
2131
1771
branch.set_append_revisions_only(True)
2132
1772
except errors.UpgradeRequired:
2133
raise errors.BzrCommandError(gettext('This branch format cannot be set'
2134
' to append-revisions-only. Try --default.'))
1773
raise errors.BzrCommandError('This branch format cannot be set'
1774
' to append-revisions-only. Try --default.')
2135
1775
if not is_quiet():
2136
1776
from bzrlib.info import describe_layout, describe_format
2137
1777
try:
2141
1781
repository = branch.repository
2142
1782
layout = describe_layout(repository, branch, tree).lower()
2143
1783
format = describe_format(a_bzrdir, repository, branch, tree)
2144
self.outf.write(gettext("Created a {0} (format: {1})\n").format(
2145
layout, format))
1784
self.outf.write("Created a %s (format: %s)\n" % (layout, format))
2146
1785
if repository.is_shared():
2147
1786
#XXX: maybe this can be refactored into transport.path_or_url()
2148
1787
url = repository.bzrdir.root_transport.external_url()
2150
1789
url = urlutils.local_path_from_url(url)
2151
1790
except errors.InvalidURL:
2152
1791
pass
2153
self.outf.write(gettext("Using shared repository: %s\n") % url)
1792
self.outf.write("Using shared repository: %s\n" % url)
2154
1793
2155
1794
2156
1795
class cmd_init_repository(Command):
2186
1825
takes_options = [RegistryOption('format',
2187
1826
help='Specify a format for this repository. See'
2188
1827
' "bzr help formats" for details.',
2189
lazy_registry=('bzrlib.controldir', 'format_registry'),
2190
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1828
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1829
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2191
1830
value_switches=True, title='Repository format'),
2192
1831
Option('no-trees',
2193
1832
help='Branches in the repository will default to'
2197
1836
2198
1837
def run(self, location, format=None, no_trees=False):
2199
1838
if format is None:
2200
format = controldir.format_registry.make_bzrdir('default')
1839
format = bzrdir.format_registry.make_bzrdir('default')
2201
1840
2202
1841
if location is None:
2203
1842
location = '.'
2204
1843
2205
1844
to_transport = transport.get_transport(location)
1845
to_transport.ensure_base()
2206
1846
2207
(repo, newdir, require_stacking, repository_policy) = (
2208
format.initialize_on_transport_ex(to_transport,
2209
create_prefix=True, make_working_trees=not no_trees,
2210
shared_repo=True, force_new_repo=True,
2211
use_existing_dir=True,
2212
repo_format_name=format.repository_format.get_format_string()))
1847
newdir = format.initialize_on_transport(to_transport)
1848
repo = newdir.create_repository(shared=True)
1849
repo.set_make_working_trees(not no_trees)
2213
1850
if not is_quiet():
2214
1851
from bzrlib.info import show_bzrdir_info
2215
show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1852
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
2216
1853
2217
1854
2218
1855
class cmd_diff(Command):
2228
1865
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
2229
1866
produces patches suitable for "patch -p1".
2230
1867
2231
Note that when using the -r argument with a range of revisions, the
2232
differences are computed between the two specified revisions. That
2233
is, the command does not show the changes introduced by the first
2234
revision in the range. This differs from the interpretation of
2235
revision ranges used by "bzr log" which includes the first revision
2236
in the range.
2237
2238
1868
:Exit values:
2239
1869
1 - changed
2240
1870
2 - unrepresentable changes
2258
1888
2259
1889
bzr diff -r1..3 xxx
2260
1890
2261
The changes introduced by revision 2 (equivalent to -r1..2)::
2262
2263
bzr diff -c2
2264
2265
To see the changes introduced by revision X::
1891
To see the changes introduced in revision X::
2266
1892
2267
1893
bzr diff -cX
2268
1894
2272
1898
2273
1899
bzr diff -r<chosen_parent>..X
2274
1900
2275
The changes between the current revision and the previous revision
2276
(equivalent to -c-1 and -r-2..-1)
1901
The changes introduced by revision 2 (equivalent to -r1..2)::
2277
1902
2278
bzr diff -r-2..
1903
bzr diff -c2
2279
1904
2280
1905
Show just the differences for file NEWS::
2281
1906
2296
1921
Same as 'bzr diff' but prefix paths with old/ and new/::
2297
1922
2298
1923
bzr diff --prefix old/:new/
2299
2300
Show the differences using a custom diff program with options::
2301
2302
bzr diff --using /usr/bin/diff --diff-options -wu
2303
1924
"""
2304
1925
_see_also = ['status']
2305
1926
takes_args = ['file*']
2325
1946
type=unicode,
2326
1947
),
2327
1948
RegistryOption('format',
2328
short_name='F',
2329
1949
help='Diff format to use.',
2330
1950
lazy_registry=('bzrlib.diff', 'format_registry'),
2331
title='Diff format'),
2332
Option('context',
2333
help='How many lines of context to show.',
2334
type=int,
2335
),
1951
value_switches=False, title='Diff format'),
2336
1952
]
2337
1953
aliases = ['di', 'dif']
2338
1954
encoding_type = 'exact'
2339
1955
2340
1956
@display_command
2341
1957
def run(self, revision=None, file_list=None, diff_options=None,
2342
prefix=None, old=None, new=None, using=None, format=None,
2343
context=None):
1958
prefix=None, old=None, new=None, using=None, format=None):
2344
1959
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
2345
1960
show_diff_trees)
2346
1961
2354
1969
elif ':' in prefix:
2355
1970
old_label, new_label = prefix.split(":")
2356
1971
else:
2357
raise errors.BzrCommandError(gettext(
1972
raise errors.BzrCommandError(
2358
1973
'--prefix expects two values separated by a colon'
2359
' (eg "old/:new/")'))
1974
' (eg "old/:new/")')
2360
1975
2361
1976
if revision and len(revision) > 2:
2362
raise errors.BzrCommandError(gettext('bzr diff --revision takes exactly'
2363
' one or two revision specifiers'))
1977
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1978
' one or two revision specifiers')
2364
1979
2365
1980
if using is not None and format is not None:
2366
raise errors.BzrCommandError(gettext(
2367
'{0} and {1} are mutually exclusive').format(
2368
'--using', '--format'))
1981
raise errors.BzrCommandError('--using and --format are mutually '
1982
'exclusive.')
2369
1983
2370
1984
(old_tree, new_tree,
2371
1985
old_branch, new_branch,
2372
1986
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
2373
1987
file_list, revision, old, new, self.add_cleanup, apply_view=True)
2374
# GNU diff on Windows uses ANSI encoding for filenames
2375
path_encoding = osutils.get_diff_header_encoding()
2376
1988
return show_diff_trees(old_tree, new_tree, sys.stdout,
2377
1989
specific_files=specific_files,
2378
1990
external_diff_options=diff_options,
2379
1991
old_label=old_label, new_label=new_label,
2380
extra_trees=extra_trees,
2381
path_encoding=path_encoding,
2382
using=using, context=context,
1992
extra_trees=extra_trees, using=using,
2383
1993
format_cls=format)
2384
1994
2385
1995
2393
2003
# level of effort but possibly much less IO. (Or possibly not,
2394
2004
# if the directories are very large...)
2395
2005
_see_also = ['status', 'ls']
2396
takes_options = ['directory', 'show-ids']
2006
takes_options = ['show-ids']
2397
2007
2398
2008
@display_command
2399
def run(self, show_ids=False, directory=u'.'):
2400
tree = WorkingTree.open_containing(directory)[0]
2401
self.add_cleanup(tree.lock_read().unlock)
2009
def run(self, show_ids=False):
2010
tree = WorkingTree.open_containing(u'.')[0]
2011
tree.lock_read()
2012
self.add_cleanup(tree.unlock)
2402
2013
old = tree.basis_tree()
2403
self.add_cleanup(old.lock_read().unlock)
2404
for path, ie in old.iter_entries_by_dir():
2014
old.lock_read()
2015
self.add_cleanup(old.unlock)
2016
for path, ie in old.inventory.iter_entries():
2405
2017
if not tree.has_id(ie.file_id):
2406
2018
self.outf.write(path)
2407
2019
if show_ids:
2416
2028
2417
2029
hidden = True
2418
2030
_see_also = ['status', 'ls']
2419
takes_options = ['directory', 'null']
2031
takes_options = [
2032
Option('null',
2033
help='Write an ascii NUL (\\0) separator '
2034
'between files rather than a newline.')
2035
]
2420
2036
2421
2037
@display_command
2422
def run(self, null=False, directory=u'.'):
2423
tree = WorkingTree.open_containing(directory)[0]
2424
self.add_cleanup(tree.lock_read().unlock)
2038
def run(self, null=False):
2039
tree = WorkingTree.open_containing(u'.')[0]
2425
2040
td = tree.changes_from(tree.basis_tree())
2426
self.cleanup_now()
2427
2041
for path, id, kind, text_modified, meta_modified in td.modified:
2428
2042
if null:
2429
2043
self.outf.write(path + '\0')
2437
2051
2438
2052
hidden = True
2439
2053
_see_also = ['status', 'ls']
2440
takes_options = ['directory', 'null']
2054
takes_options = [
2055
Option('null',
2056
help='Write an ascii NUL (\\0) separator '
2057
'between files rather than a newline.')
2058
]
2441
2059
2442
2060
@display_command
2443
def run(self, null=False, directory=u'.'):
2444
wt = WorkingTree.open_containing(directory)[0]
2445
self.add_cleanup(wt.lock_read().unlock)
2061
def run(self, null=False):
2062
wt = WorkingTree.open_containing(u'.')[0]
2063
wt.lock_read()
2064
self.add_cleanup(wt.unlock)
2446
2065
basis = wt.basis_tree()
2447
self.add_cleanup(basis.lock_read().unlock)
2448
root_id = wt.get_root_id()
2449
for file_id in wt.all_file_ids():
2450
if basis.has_id(file_id):
2451
continue
2452
if root_id == file_id:
2453
continue
2454
path = wt.id2path(file_id)
2455
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2066
basis.lock_read()
2067
self.add_cleanup(basis.unlock)
2068
basis_inv = basis.inventory
2069
inv = wt.inventory
2070
for file_id in inv:
2071
if file_id in basis_inv:
2072
continue
2073
if inv.is_root(file_id) and len(basis_inv) == 0:
2074
continue
2075
path = inv.id2path(file_id)
2076
if not os.access(osutils.abspath(path), os.F_OK):
2456
2077
continue
2457
2078
if null:
2458
2079
self.outf.write(path + '\0')
2478
2099
try:
2479
2100
return int(limitstring)
2480
2101
except ValueError:
2481
msg = gettext("The limit argument must be an integer.")
2102
msg = "The limit argument must be an integer."
2482
2103
raise errors.BzrCommandError(msg)
2483
2104
2484
2105
2486
2107
try:
2487
2108
return int(s)
2488
2109
except ValueError:
2489
msg = gettext("The levels argument must be an integer.")
2110
msg = "The levels argument must be an integer."
2490
2111
raise errors.BzrCommandError(msg)
2491
2112
2492
2113
2602
2223
2603
2224
:Other filtering:
2604
2225
2605
The --match option can be used for finding revisions that match a
2606
regular expression in a commit message, committer, author or bug.
2607
Specifying the option several times will match any of the supplied
2608
expressions. --match-author, --match-bugs, --match-committer and
2609
--match-message can be used to only match a specific field.
2226
The --message option can be used for finding revisions that match a
2227
regular expression in a commit message.
2610
2228
2611
2229
:Tips & tricks:
2612
2230
2661
2279
help='Show just the specified revision.'
2662
2280
' See also "help revisionspec".'),
2663
2281
'log-format',
2664
RegistryOption('authors',
2665
'What names to list as authors - first, all or committer.',
2666
title='Authors',
2667
lazy_registry=('bzrlib.log', 'author_list_registry'),
2668
),
2669
2282
Option('levels',
2670
2283
short_name='n',
2671
2284
help='Number of levels to display - 0 for all, 1 for flat.',
2672
2285
argname='N',
2673
2286
type=_parse_levels),
2674
2287
Option('message',
2288
short_name='m',
2675
2289
help='Show revisions whose message matches this '
2676
2290
'regular expression.',
2677
type=str,
2678
hidden=True),
2291
type=str),
2679
2292
Option('limit',
2680
2293
short_name='l',
2681
2294
help='Limit the output to the first N revisions.',
2684
2297
Option('show-diff',
2685
2298
short_name='p',
2686
2299
help='Show changes made in each revision as a patch.'),
2687
Option('include-merged',
2300
Option('include-merges',
2688
2301
help='Show merged revisions like --levels 0 does.'),
2689
Option('include-merges', hidden=True,
2690
help='Historical alias for --include-merged.'),
2691
Option('omit-merges',
2692
help='Do not report commits with more than one parent.'),
2693
2302
Option('exclude-common-ancestry',
2694
2303
help='Display only the revisions that are not part'
2695
' of both ancestries (require -rX..Y).'
2696
),
2697
Option('signatures',
2698
help='Show digital signature validity.'),
2699
ListOption('match',
2700
short_name='m',
2701
help='Show revisions whose properties match this '
2702
'expression.',
2703
type=str),
2704
ListOption('match-message',
2705
help='Show revisions whose message matches this '
2706
'expression.',
2707
type=str),
2708
ListOption('match-committer',
2709
help='Show revisions whose committer matches this '
2710
'expression.',
2711
type=str),
2712
ListOption('match-author',
2713
help='Show revisions whose authors match this '
2714
'expression.',
2715
type=str),
2716
ListOption('match-bugs',
2717
help='Show revisions whose bugs match this '
2718
'expression.',
2719
type=str)
2304
' of both ancestries (require -rX..Y)'
2305
)
2720
2306
]
2721
2307
encoding_type = 'replace'
2722
2308
2732
2318
message=None,
2733
2319
limit=None,
2734
2320
show_diff=False,
2735
include_merged=None,
2736
authors=None,
2321
include_merges=False,
2737
2322
exclude_common_ancestry=False,
2738
signatures=False,
2739
match=None,
2740
match_message=None,
2741
match_committer=None,
2742
match_author=None,
2743
match_bugs=None,
2744
omit_merges=False,
2745
include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2746
2323
):
2747
2324
from bzrlib.log import (
2748
2325
Logger,
2750
2327
_get_info_for_log_files,
2751
2328
)
2752
2329
direction = (forward and 'forward') or 'reverse'
2753
if symbol_versioning.deprecated_passed(include_merges):
2754
ui.ui_factory.show_user_warning(
2755
'deprecated_command_option',
2756
deprecated_name='--include-merges',
2757
recommended_name='--include-merged',
2758
deprecated_in_version='2.5',
2759
command=self.invoked_as)
2760
if include_merged is None:
2761
include_merged = include_merges
2762
else:
2763
raise errors.BzrCommandError(gettext(
2764
'{0} and {1} are mutually exclusive').format(
2765
'--include-merges', '--include-merged'))
2766
if include_merged is None:
2767
include_merged = False
2768
2330
if (exclude_common_ancestry
2769
2331
and (revision is None or len(revision) != 2)):
2770
raise errors.BzrCommandError(gettext(
2771
'--exclude-common-ancestry requires -r with two revisions'))
2772
if include_merged:
2332
raise errors.BzrCommandError(
2333
'--exclude-common-ancestry requires -r with two revisions')
2334
if include_merges:
2773
2335
if levels is None:
2774
2336
levels = 0
2775
2337
else:
2776
raise errors.BzrCommandError(gettext(
2777
'{0} and {1} are mutually exclusive').format(
2778
'--levels', '--include-merged'))
2338
raise errors.BzrCommandError(
2339
'--levels and --include-merges are mutually exclusive')
2779
2340
2780
2341
if change is not None:
2781
2342
if len(change) > 1:
2782
2343
raise errors.RangeInChangeOption()
2783
2344
if revision is not None:
2784
raise errors.BzrCommandError(gettext(
2785
'{0} and {1} are mutually exclusive').format(
2786
'--revision', '--change'))
2345
raise errors.BzrCommandError(
2346
'--revision and --change are mutually exclusive')
2787
2347
else:
2788
2348
revision = change
2789
2349
2792
2352
if file_list:
2793
2353
# find the file ids to log and check for directory filtering
2794
2354
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2795
revision, file_list, self.add_cleanup)
2355
revision, file_list)
2356
self.add_cleanup(b.unlock)
2796
2357
for relpath, file_id, kind in file_info_list:
2797
2358
if file_id is None:
2798
raise errors.BzrCommandError(gettext(
2799
"Path unknown at end or start of revision range: %s") %
2359
raise errors.BzrCommandError(
2360
"Path unknown at end or start of revision range: %s" %
2800
2361
relpath)
2801
2362
# If the relpath is the top of the tree, we log everything
2802
2363
if relpath == '':
2814
2375
location = revision[0].get_branch()
2815
2376
else:
2816
2377
location = '.'
2817
dir, relpath = controldir.ControlDir.open_containing(location)
2378
dir, relpath = bzrdir.BzrDir.open_containing(location)
2818
2379
b = dir.open_branch()
2819
self.add_cleanup(b.lock_read().unlock)
2380
b.lock_read()
2381
self.add_cleanup(b.unlock)
2820
2382
rev1, rev2 = _get_revision_range(revision, b, self.name())
2821
2383
2822
if b.get_config_stack().get('validate_signatures_in_log'):
2823
signatures = True
2824
2825
if signatures:
2826
if not gpg.GPGStrategy.verify_signatures_available():
2827
raise errors.GpgmeNotInstalled(None)
2828
2829
2384
# Decide on the type of delta & diff filtering to use
2830
2385
# TODO: add an --all-files option to make this configurable & consistent
2831
2386
if not verbose:
2849
2404
show_timezone=timezone,
2850
2405
delta_format=get_verbosity_level(),
2851
2406
levels=levels,
2852
show_advice=levels is None,
2853
author_list_handler=authors)
2407
show_advice=levels is None)
2854
2408
2855
2409
# Choose the algorithm for doing the logging. It's annoying
2856
2410
# having multiple code paths like this but necessary until
2868
2422
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2869
2423
or delta_type or partial_history)
2870
2424
2871
match_dict = {}
2872
if match:
2873
match_dict[''] = match
2874
if match_message:
2875
match_dict['message'] = match_message
2876
if match_committer:
2877
match_dict['committer'] = match_committer
2878
if match_author:
2879
match_dict['author'] = match_author
2880
if match_bugs:
2881
match_dict['bugs'] = match_bugs
2882
2883
2425
# Build the LogRequest and execute it
2884
2426
if len(file_ids) == 0:
2885
2427
file_ids = None
2888
2430
start_revision=rev1, end_revision=rev2, limit=limit,
2889
2431
message_search=message, delta_type=delta_type,
2890
2432
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2891
exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
2892
signature=signatures, omit_merges=omit_merges,
2433
exclude_common_ancestry=exclude_common_ancestry,
2893
2434
)
2894
2435
Logger(b, rqst).show(lf)
2895
2436
2912
2453
# b is taken from revision[0].get_branch(), and
2913
2454
# show_log will use its revision_history. Having
2914
2455
# different branches will lead to weird behaviors.
2915
raise errors.BzrCommandError(gettext(
2456
raise errors.BzrCommandError(
2916
2457
"bzr %s doesn't accept two revisions in different"
2917
" branches.") % command_name)
2458
" branches." % command_name)
2918
2459
if start_spec.spec is None:
2919
2460
# Avoid loading all the history.
2920
2461
rev1 = RevisionInfo(branch, None, None)
2928
2469
else:
2929
2470
rev2 = end_spec.in_history(branch)
2930
2471
else:
2931
raise errors.BzrCommandError(gettext(
2932
'bzr %s --revision takes one or two values.') % command_name)
2472
raise errors.BzrCommandError(
2473
'bzr %s --revision takes one or two values.' % command_name)
2933
2474
return rev1, rev2
2934
2475
2935
2476
2967
2508
tree, relpath = WorkingTree.open_containing(filename)
2968
2509
file_id = tree.path2id(relpath)
2969
2510
b = tree.branch
2970
self.add_cleanup(b.lock_read().unlock)
2511
b.lock_read()
2512
self.add_cleanup(b.unlock)
2971
2513
touching_revs = log.find_touching_revisions(b, file_id)
2972
2514
for revno, revision_id, what in touching_revs:
2973
2515
self.outf.write("%6d %s\n" % (revno, what))
2986
2528
help='Recurse into subdirectories.'),
2987
2529
Option('from-root',
2988
2530
help='Print paths relative to the root of the branch.'),
2989
Option('unknown', short_name='u',
2990
help='Print unknown files.'),
2531
Option('unknown', help='Print unknown files.'),
2991
2532
Option('versioned', help='Print versioned files.',
2992
2533
short_name='V'),
2993
Option('ignored', short_name='i',
2994
help='Print ignored files.'),
2995
Option('kind', short_name='k',
2534
Option('ignored', help='Print ignored files.'),
2535
Option('null',
2536
help='Write an ascii NUL (\\0) separator '
2537
'between files rather than a newline.'),
2538
Option('kind',
2996
2539
help='List entries of a particular kind: file, directory, symlink.',
2997
2540
type=unicode),
2998
'null',
2999
2541
'show-ids',
3000
'directory',
3001
2542
]
3002
2543
@display_command
3003
2544
def run(self, revision=None, verbose=False,
3004
2545
recursive=False, from_root=False,
3005
2546
unknown=False, versioned=False, ignored=False,
3006
null=False, kind=None, show_ids=False, path=None, directory=None):
2547
null=False, kind=None, show_ids=False, path=None):
3007
2548
3008
2549
if kind and kind not in ('file', 'directory', 'symlink'):
3009
raise errors.BzrCommandError(gettext('invalid kind specified'))
2550
raise errors.BzrCommandError('invalid kind specified')
3010
2551
3011
2552
if verbose and null:
3012
raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2553
raise errors.BzrCommandError('Cannot set both --verbose and --null')
3013
2554
all = not (unknown or versioned or ignored)
3014
2555
3015
2556
selection = {'I':ignored, '?':unknown, 'V':versioned}
3018
2559
fs_path = '.'
3019
2560
else:
3020
2561
if from_root:
3021
raise errors.BzrCommandError(gettext('cannot specify both --from-root'
3022
' and PATH'))
2562
raise errors.BzrCommandError('cannot specify both --from-root'
2563
' and PATH')
3023
2564
fs_path = path
3024
tree, branch, relpath = \
3025
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2565
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2566
fs_path)
3026
2567
3027
2568
# Calculate the prefix to use
3028
2569
prefix = None
3041
2582
if view_files:
3042
2583
apply_view = True
3043
2584
view_str = views.view_display_str(view_files)
3044
note(gettext("Ignoring files outside view. View is %s") % view_str)
2585
note("Ignoring files outside view. View is %s" % view_str)
3045
2586
3046
self.add_cleanup(tree.lock_read().unlock)
2587
tree.lock_read()
2588
self.add_cleanup(tree.unlock)
3047
2589
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
3048
2590
from_dir=relpath, recursive=recursive):
3049
2591
# Apply additional masking
3096
2638
3097
2639
hidden = True
3098
2640
_see_also = ['ls']
3099
takes_options = ['directory']
3100
2641
3101
2642
@display_command
3102
def run(self, directory=u'.'):
3103
for f in WorkingTree.open_containing(directory)[0].unknowns():
2643
def run(self):
2644
for f in WorkingTree.open_containing(u'.')[0].unknowns():
3104
2645
self.outf.write(osutils.quotefn(f) + '\n')
3105
2646
3106
2647
3133
2674
Patterns prefixed with '!!' act as regular ignore patterns, but have
3134
2675
precedence over the '!' exception patterns.
3135
2676
3136
:Notes:
3137
3138
* Ignore patterns containing shell wildcards must be quoted from
3139
the shell on Unix.
3140
3141
* Ignore patterns starting with "#" act as comments in the ignore file.
3142
To ignore patterns that begin with that character, use the "RE:" prefix.
2677
Note: ignore patterns containing shell wildcards must be quoted from
2678
the shell on Unix.
3143
2679
3144
2680
:Examples:
3145
2681
Ignore the top level Makefile::
3154
2690
3155
2691
bzr ignore "!special.class"
3156
2692
3157
Ignore files whose name begins with the "#" character::
3158
3159
bzr ignore "RE:^#"
3160
3161
2693
Ignore .o files under the lib directory::
3162
2694
3163
2695
bzr ignore "lib/**/*.o"
3171
2703
bzr ignore "RE:(?!debian/).*"
3172
2704
3173
2705
Ignore everything except the "local" toplevel directory,
3174
but always ignore autosave files ending in ~, even under local/::
2706
but always ignore "*~" autosave files, even under local/::
3175
2707
3176
2708
bzr ignore "*"
3177
2709
bzr ignore "!./local"
3180
2712
3181
2713
_see_also = ['status', 'ignored', 'patterns']
3182
2714
takes_args = ['name_pattern*']
3183
takes_options = ['directory',
2715
takes_options = [
3184
2716
Option('default-rules',
3185
2717
help='Display the default ignore rules that bzr uses.')
3186
2718
]
3187
2719
3188
def run(self, name_pattern_list=None, default_rules=None,
3189
directory=u'.'):
2720
def run(self, name_pattern_list=None, default_rules=None):
3190
2721
from bzrlib import ignores
3191
2722
if default_rules is not None:
3192
2723
# dump the default rules and exit
3194
2725
self.outf.write("%s\n" % pattern)
3195
2726
return
3196
2727
if not name_pattern_list:
3197
raise errors.BzrCommandError(gettext("ignore requires at least one "
3198
"NAME_PATTERN or --default-rules."))
2728
raise errors.BzrCommandError("ignore requires at least one "
2729
"NAME_PATTERN or --default-rules.")
3199
2730
name_pattern_list = [globbing.normalize_pattern(p)
3200
2731
for p in name_pattern_list]
3201
bad_patterns = ''
3202
bad_patterns_count = 0
3203
for p in name_pattern_list:
3204
if not globbing.Globster.is_pattern_valid(p):
3205
bad_patterns_count += 1
3206
bad_patterns += ('\n %s' % p)
3207
if bad_patterns:
3208
msg = (ngettext('Invalid ignore pattern found. %s',
3209
'Invalid ignore patterns found. %s',
3210
bad_patterns_count) % bad_patterns)
3211
ui.ui_factory.show_error(msg)
3212
raise errors.InvalidPattern('')
3213
2732
for name_pattern in name_pattern_list:
3214
2733
if (name_pattern[0] == '/' or
3215
2734
(len(name_pattern) > 1 and name_pattern[1] == ':')):
3216
raise errors.BzrCommandError(gettext(
3217
"NAME_PATTERN should not be an absolute path"))
3218
tree, relpath = WorkingTree.open_containing(directory)
2735
raise errors.BzrCommandError(
2736
"NAME_PATTERN should not be an absolute path")
2737
tree, relpath = WorkingTree.open_containing(u'.')
3219
2738
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
3220
2739
ignored = globbing.Globster(name_pattern_list)
3221
2740
matches = []
3222
self.add_cleanup(tree.lock_read().unlock)
2741
tree.lock_read()
3223
2742
for entry in tree.list_files():
3224
2743
id = entry[3]
3225
2744
if id is not None:
3226
2745
filename = entry[0]
3227
2746
if ignored.match(filename):
3228
2747
matches.append(filename)
2748
tree.unlock()
3229
2749
if len(matches) > 0:
3230
self.outf.write(gettext("Warning: the following files are version "
3231
"controlled and match your ignore pattern:\n%s"
2750
self.outf.write("Warning: the following files are version controlled and"
2751
" match your ignore pattern:\n%s"
3232
2752
"\nThese files will continue to be version controlled"
3233
" unless you 'bzr remove' them.\n") % ("\n".join(matches),))
2753
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
3234
2754
3235
2755
3236
2756
class cmd_ignored(Command):
3246
2766
3247
2767
encoding_type = 'replace'
3248
2768
_see_also = ['ignore', 'ls']
3249
takes_options = ['directory']
3250
2769
3251
2770
@display_command
3252
def run(self, directory=u'.'):
3253
tree = WorkingTree.open_containing(directory)[0]
3254
self.add_cleanup(tree.lock_read().unlock)
2771
def run(self):
2772
tree = WorkingTree.open_containing(u'.')[0]
2773
tree.lock_read()
2774
self.add_cleanup(tree.unlock)
3255
2775
for path, file_class, kind, file_id, entry in tree.list_files():
3256
2776
if file_class != 'I':
3257
2777
continue
3268
2788
"""
3269
2789
hidden = True
3270
2790
takes_args = ['revno']
3271
takes_options = ['directory']
3272
2791
3273
2792
@display_command
3274
def run(self, revno, directory=u'.'):
2793
def run(self, revno):
3275
2794
try:
3276
2795
revno = int(revno)
3277
2796
except ValueError:
3278
raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
2797
raise errors.BzrCommandError("not a valid revision-number: %r"
3279
2798
% revno)
3280
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2799
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
3281
2800
self.outf.write("%s\n" % revid)
3282
2801
3283
2802
3309
2828
zip .zip
3310
2829
================= =========================
3311
2830
"""
3312
encoding = 'exact'
3313
2831
takes_args = ['dest', 'branch_or_subdir?']
3314
takes_options = ['directory',
2832
takes_options = [
3315
2833
Option('format',
3316
2834
help="Type of file to export to.",
3317
2835
type=unicode),
3324
2842
Option('per-file-timestamps',
3325
2843
help='Set modification time of files to that of the last '
3326
2844
'revision in which it was changed.'),
3327
Option('uncommitted',
3328
help='Export the working tree contents rather than that of the '
3329
'last revision.'),
3330
2845
]
3331
2846
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
3332
root=None, filters=False, per_file_timestamps=False, uncommitted=False,
3333
directory=u'.'):
2847
root=None, filters=False, per_file_timestamps=False):
3334
2848
from bzrlib.export import export
3335
2849
3336
2850
if branch_or_subdir is None:
3337
branch_or_subdir = directory
3338
3339
(tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
3340
branch_or_subdir)
3341
if tree is not None:
3342
self.add_cleanup(tree.lock_read().unlock)
3343
3344
if uncommitted:
3345
if tree is None:
3346
raise errors.BzrCommandError(
3347
gettext("--uncommitted requires a working tree"))
3348
export_tree = tree
2851
tree = WorkingTree.open_containing(u'.')[0]
2852
b = tree.branch
2853
subdir = None
3349
2854
else:
3350
export_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2855
b, subdir = Branch.open_containing(branch_or_subdir)
2856
tree = None
2857
2858
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
3351
2859
try:
3352
export(export_tree, dest, format, root, subdir, filtered=filters,
2860
export(rev_tree, dest, format, root, subdir, filtered=filters,
3353
2861
per_file_timestamps=per_file_timestamps)
3354
2862
except errors.NoSuchExportFormat, e:
3355
raise errors.BzrCommandError(
3356
gettext('Unsupported export format: %s') % e.format)
2863
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3357
2864
3358
2865
3359
2866
class cmd_cat(Command):
3366
2873
"""
3367
2874
3368
2875
_see_also = ['ls']
3369
takes_options = ['directory',
2876
takes_options = [
3370
2877
Option('name-from-revision', help='The path name in the old tree.'),
3371
2878
Option('filters', help='Apply content filters to display the '
3372
2879
'convenience form.'),
3377
2884
3378
2885
@display_command
3379
2886
def run(self, filename, revision=None, name_from_revision=False,
3380
filters=False, directory=None):
2887
filters=False):
3381
2888
if revision is not None and len(revision) != 1:
3382
raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
3383
" one revision specifier"))
2889
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
" one revision specifier")
3384
2891
tree, branch, relpath = \
3385
_open_directory_or_containing_tree_or_branch(filename, directory)
3386
self.add_cleanup(branch.lock_read().unlock)
2892
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2893
branch.lock_read()
2894
self.add_cleanup(branch.unlock)
3387
2895
return self._run(tree, branch, relpath, filename, revision,
3388
2896
name_from_revision, filters)
3389
2897
3392
2900
if tree is None:
3393
2901
tree = b.basis_tree()
3394
2902
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
3395
self.add_cleanup(rev_tree.lock_read().unlock)
2903
rev_tree.lock_read()
2904
self.add_cleanup(rev_tree.unlock)
3396
2905
3397
2906
old_file_id = rev_tree.path2id(relpath)
3398
2907
3399
# TODO: Split out this code to something that generically finds the
3400
# best id for a path across one or more trees; it's like
3401
# find_ids_across_trees but restricted to find just one. -- mbp
3402
# 20110705.
3403
2908
if name_from_revision:
3404
2909
# Try in revision if requested
3405
2910
if old_file_id is None:
3406
raise errors.BzrCommandError(gettext(
3407
"{0!r} is not present in revision {1}").format(
2911
raise errors.BzrCommandError(
2912
"%r is not present in revision %s" % (
3408
2913
filename, rev_tree.get_revision_id()))
3409
2914
else:
3410
actual_file_id = old_file_id
2915
content = rev_tree.get_file_text(old_file_id)
3411
2916
else:
3412
2917
cur_file_id = tree.path2id(relpath)
3413
if cur_file_id is not None and rev_tree.has_id(cur_file_id):
3414
actual_file_id = cur_file_id
3415
elif old_file_id is not None:
3416
actual_file_id = old_file_id
3417
else:
3418
raise errors.BzrCommandError(gettext(
3419
"{0!r} is not present in revision {1}").format(
2918
found = False
2919
if cur_file_id is not None:
2920
# Then try with the actual file id
2921
try:
2922
content = rev_tree.get_file_text(cur_file_id)
2923
found = True
2924
except errors.NoSuchId:
2925
# The actual file id didn't exist at that time
2926
pass
2927
if not found and old_file_id is not None:
2928
# Finally try with the old file id
2929
content = rev_tree.get_file_text(old_file_id)
2930
found = True
2931
if not found:
2932
# Can't be found anywhere
2933
raise errors.BzrCommandError(
2934
"%r is not present in revision %s" % (
3420
2935
filename, rev_tree.get_revision_id()))
3421
2936
if filtered:
3422
from bzrlib.filter_tree import ContentFilterTree
3423
filter_tree = ContentFilterTree(rev_tree,
3424
rev_tree._content_filter_stack)
3425
content = filter_tree.get_file_text(actual_file_id)
2937
from bzrlib.filters import (
2938
ContentFilterContext,
2939
filtered_output_bytes,
2940
)
2941
filters = rev_tree._content_filter_stack(relpath)
2942
chunks = content.splitlines(True)
2943
content = filtered_output_bytes(chunks, filters,
2944
ContentFilterContext(relpath, rev_tree))
2945
self.cleanup_now()
2946
self.outf.writelines(content)
3426
2947
else:
3427
content = rev_tree.get_file_text(actual_file_id)
3428
self.cleanup_now()
3429
self.outf.write(content)
2948
self.cleanup_now()
2949
self.outf.write(content)
3430
2950
3431
2951
3432
2952
class cmd_local_time_offset(Command):
3493
3013
to trigger updates to external systems like bug trackers. The --fixes
3494
3014
option can be used to record the association between a revision and
3495
3015
one or more bugs. See ``bzr help bugs`` for details.
3016
3017
A selective commit may fail in some cases where the committed
3018
tree would be invalid. Consider::
3019
3020
bzr init foo
3021
mkdir foo/bar
3022
bzr add foo/bar
3023
bzr commit foo -m "committing foo"
3024
bzr mv foo/bar foo/baz
3025
mkdir foo/bar
3026
bzr add foo/bar
3027
bzr commit foo/bar -m "committing bar but not baz"
3028
3029
In the example above, the last commit will fail by design. This gives
3030
the user the opportunity to decide whether they want to commit the
3031
rename at the same time, separately first, or not at all. (As a general
3032
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3496
3033
"""
3034
# TODO: Run hooks on tree to-be-committed, and after commit.
3035
3036
# TODO: Strict commit that fails if there are deleted files.
3037
# (what does "deleted files" mean ??)
3038
3039
# TODO: Give better message for -s, --summary, used by tla people
3040
3041
# XXX: verbose currently does nothing
3497
3042
3498
3043
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
3499
3044
takes_args = ['selected*']
3531
3076
Option('show-diff', short_name='p',
3532
3077
help='When no message is supplied, show the diff along'
3533
3078
' with the status summary in the message editor.'),
3534
Option('lossy',
3535
help='When committing to a foreign version control '
3536
'system do not push data that can not be natively '
3537
'represented.'),
3538
3079
]
3539
3080
aliases = ['ci', 'checkin']
3540
3081
3541
3082
def _iter_bug_fix_urls(self, fixes, branch):
3542
default_bugtracker = None
3543
3083
# Configure the properties for bug fixing attributes.
3544
3084
for fixed_bug in fixes:
3545
3085
tokens = fixed_bug.split(':')
3546
if len(tokens) == 1:
3547
if default_bugtracker is None:
3548
branch_config = branch.get_config_stack()
3549
default_bugtracker = branch_config.get(
3550
"bugtracker")
3551
if default_bugtracker is None:
3552
raise errors.BzrCommandError(gettext(
3553
"No tracker specified for bug %s. Use the form "
3554
"'tracker:id' or specify a default bug tracker "
3555
"using the `bugtracker` option.\nSee "
3556
"\"bzr help bugs\" for more information on this "
3557
"feature. Commit refused.") % fixed_bug)
3558
tag = default_bugtracker
3559
bug_id = tokens[0]
3560
elif len(tokens) != 2:
3561
raise errors.BzrCommandError(gettext(
3086
if len(tokens) != 2:
3087
raise errors.BzrCommandError(
3562
3088
"Invalid bug %s. Must be in the form of 'tracker:id'. "
3563
3089
"See \"bzr help bugs\" for more information on this "
3564
"feature.\nCommit refused.") % fixed_bug)
3565
else:
3566
tag, bug_id = tokens
3090
"feature.\nCommit refused." % fixed_bug)
3091
tag, bug_id = tokens
3567
3092
try:
3568
3093
yield bugtracker.get_bug_url(tag, branch, bug_id)
3569
3094
except errors.UnknownBugTrackerAbbreviation:
3570
raise errors.BzrCommandError(gettext(
3571
'Unrecognized bug %s. Commit refused.') % fixed_bug)
3095
raise errors.BzrCommandError(
3096
'Unrecognized bug %s. Commit refused.' % fixed_bug)
3572
3097
except errors.MalformedBugIdentifier, e:
3573
raise errors.BzrCommandError(gettext(
3574
"%s\nCommit refused.") % (str(e),))
3098
raise errors.BzrCommandError(
3099
"%s\nCommit refused." % (str(e),))
3575
3100
3576
3101
def run(self, message=None, file=None, verbose=False, selected_list=None,
3577
3102
unchanged=False, strict=False, local=False, fixes=None,
3578
author=None, show_diff=False, exclude=None, commit_time=None,
3579
lossy=False):
3103
author=None, show_diff=False, exclude=None, commit_time=None):
3580
3104
from bzrlib.errors import (
3581
3105
PointlessCommit,
3582
3106
ConflictsInTree,
3585
3109
from bzrlib.msgeditor import (
3586
3110
edit_commit_message_encoded,
3587
3111
generate_commit_message_template,
3588
make_commit_message_template_encoded,
3589
set_commit_message,
3112
make_commit_message_template_encoded
3590
3113
)
3591
3114
3592
3115
commit_stamp = offset = None
3594
3117
try:
3595
3118
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3596
3119
except ValueError, e:
3597
raise errors.BzrCommandError(gettext(
3598
"Could not parse --commit-time: " + str(e)))
3120
raise errors.BzrCommandError(
3121
"Could not parse --commit-time: " + str(e))
3122
3123
# TODO: Need a blackbox test for invoking the external editor; may be
3124
# slightly problematic to run this cross-platform.
3125
3126
# TODO: do more checks that the commit will succeed before
3127
# spending the user's valuable time typing a commit message.
3599
3128
3600
3129
properties = {}
3601
3130
3602
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3131
tree, selected_list = tree_files(selected_list)
3603
3132
if selected_list == ['']:
3604
3133
# workaround - commit of root of tree should be exactly the same
3605
3134
# as just default commit in that tree, and succeed even though
3634
3163
message = message.replace('\r\n', '\n')
3635
3164
message = message.replace('\r', '\n')
3636
3165
if file:
3637
raise errors.BzrCommandError(gettext(
3638
"please specify either --message or --file"))
3166
raise errors.BzrCommandError(
3167
"please specify either --message or --file")
3639
3168
3640
3169
def get_message(commit_obj):
3641
3170
"""Callback to get commit message"""
3642
3171
if file:
3643
f = open(file)
3644
try:
3645
my_message = f.read().decode(osutils.get_user_encoding())
3646
finally:
3647
f.close()
3172
my_message = codecs.open(
3173
file, 'rt', osutils.get_user_encoding()).read()
3648
3174
elif message is not None:
3649
3175
my_message = message
3650
3176
else:
3658
3184
# make_commit_message_template_encoded returns user encoding.
3659
3185
# We probably want to be using edit_commit_message instead to
3660
3186
# avoid this.
3661
my_message = set_commit_message(commit_obj)
3662
if my_message is None:
3663
start_message = generate_commit_message_template(commit_obj)
3664
my_message = edit_commit_message_encoded(text,
3665
start_message=start_message)
3666
if my_message is None:
3667
raise errors.BzrCommandError(gettext("please specify a commit"
3668
" message with either --message or --file"))
3669
if my_message == "":
3670
raise errors.BzrCommandError(gettext("Empty commit message specified."
3671
" Please specify a commit message with either"
3672
" --message or --file or leave a blank message"
3673
" with --message \"\"."))
3187
start_message = generate_commit_message_template(commit_obj)
3188
my_message = edit_commit_message_encoded(text,
3189
start_message=start_message)
3190
if my_message is None:
3191
raise errors.BzrCommandError("please specify a commit"
3192
" message with either --message or --file")
3193
if my_message == "":
3194
raise errors.BzrCommandError("empty commit message specified")
3674
3195
return my_message
3675
3196
3676
3197
# The API permits a commit with a filter of [] to mean 'select nothing'
3684
3205
reporter=None, verbose=verbose, revprops=properties,
3685
3206
authors=author, timestamp=commit_stamp,
3686
3207
timezone=offset,
3687
exclude=tree.safe_relpath_files(exclude),
3688
lossy=lossy)
3208
exclude=safe_relpath_files(tree, exclude))
3689
3209
except PointlessCommit:
3690
raise errors.BzrCommandError(gettext("No changes to commit."
3691
" Please 'bzr add' the files you want to commit, or use"
3692
" --unchanged to force an empty commit."))
3210
raise errors.BzrCommandError("No changes to commit."
3211
" Use --unchanged to commit anyhow.")
3693
3212
except ConflictsInTree:
3694
raise errors.BzrCommandError(gettext('Conflicts detected in working '
3213
raise errors.BzrCommandError('Conflicts detected in working '
3695
3214
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3696
' resolve.'))
3215
' resolve.')
3697
3216
except StrictCommitFailed:
3698
raise errors.BzrCommandError(gettext("Commit refused because there are"
3699
" unknown files in the working tree."))
3217
raise errors.BzrCommandError("Commit refused because there are"
3218
" unknown files in the working tree.")
3700
3219
except errors.BoundBranchOutOfDate, e:
3701
e.extra_help = (gettext("\n"
3220
e.extra_help = ("\n"
3702
3221
'To commit to master branch, run update and then commit.\n'
3703
3222
'You can also pass --local to commit to continue working '
3704
'disconnected.'))
3223
'disconnected.')
3705
3224
raise
3706
3225
3707
3226
3776
3295
3777
3296
3778
3297
class cmd_upgrade(Command):
3779
__doc__ = """Upgrade a repository, branch or working tree to a newer format.
3780
3781
When the default format has changed after a major new release of
3782
Bazaar, you may be informed during certain operations that you
3783
should upgrade. Upgrading to a newer format may improve performance
3784
or make new features available. It may however limit interoperability
3785
with older repositories or with older versions of Bazaar.
3786
3787
If you wish to upgrade to a particular format rather than the
3788
current default, that can be specified using the --format option.
3789
As a consequence, you can use the upgrade command this way to
3790
"downgrade" to an earlier format, though some conversions are
3791
a one way process (e.g. changing from the 1.x default to the
3792
2.x default) so downgrading is not always possible.
3793
3794
A backup.bzr.~#~ directory is created at the start of the conversion
3795
process (where # is a number). By default, this is left there on
3796
completion. If the conversion fails, delete the new .bzr directory
3797
and rename this one back in its place. Use the --clean option to ask
3798
for the backup.bzr directory to be removed on successful conversion.
3799
Alternatively, you can delete it by hand if everything looks good
3800
afterwards.
3801
3802
If the location given is a shared repository, dependent branches
3803
are also converted provided the repository converts successfully.
3804
If the conversion of a branch fails, remaining branches are still
3805
tried.
3806
3807
For more information on upgrades, see the Bazaar Upgrade Guide,
3808
http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3298
__doc__ = """Upgrade branch storage to current format.
3299
3300
The check command or bzr developers may sometimes advise you to run
3301
this command. When the default format has changed you may also be warned
3302
during other operations to upgrade.
3809
3303
"""
3810
3304
3811
_see_also = ['check', 'reconcile', 'formats']
3305
_see_also = ['check']
3812
3306
takes_args = ['url?']
3813
3307
takes_options = [
3814
RegistryOption('format',
3815
help='Upgrade to a specific format. See "bzr help'
3816
' formats" for details.',
3817
lazy_registry=('bzrlib.controldir', 'format_registry'),
3818
converter=lambda name: controldir.format_registry.make_bzrdir(name),
3819
value_switches=True, title='Branch format'),
3820
Option('clean',
3821
help='Remove the backup.bzr directory if successful.'),
3822
Option('dry-run',
3823
help="Show what would be done, but don't actually do anything."),
3824
]
3308
RegistryOption('format',
3309
help='Upgrade to a specific format. See "bzr help'
3310
' formats" for details.',
3311
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3312
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3313
value_switches=True, title='Branch format'),
3314
]
3825
3315
3826
def run(self, url='.', format=None, clean=False, dry_run=False):
3316
def run(self, url='.', format=None):
3827
3317
from bzrlib.upgrade import upgrade
3828
exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3829
if exceptions:
3830
if len(exceptions) == 1:
3831
# Compatibility with historical behavior
3832
raise exceptions[0]
3833
else:
3834
return 3
3318
upgrade(url, format)
3835
3319
3836
3320
3837
3321
class cmd_whoami(Command):
3846
3330
3847
3331
bzr whoami "Frank Chu <fchu@example.com>"
3848
3332
"""
3849
takes_options = [ 'directory',
3850
Option('email',
3333
takes_options = [ Option('email',
3851
3334
help='Display email address only.'),
3852
3335
Option('branch',
3853
3336
help='Set identity for the current branch instead of '
3857
3340
encoding_type = 'replace'
3858
3341
3859
3342
@display_command
3860
def run(self, email=False, branch=False, name=None, directory=None):
3343
def run(self, email=False, branch=False, name=None):
3861
3344
if name is None:
3862
if directory is None:
3863
# use branch if we're inside one; otherwise global config
3864
try:
3865
c = Branch.open_containing(u'.')[0].get_config_stack()
3866
except errors.NotBranchError:
3867
c = _mod_config.GlobalStack()
3868
else:
3869
c = Branch.open(directory).get_config_stack()
3870
identity = c.get('email')
3345
# use branch if we're inside one; otherwise global config
3346
try:
3347
c = Branch.open_containing('.')[0].get_config()
3348
except errors.NotBranchError:
3349
c = config.GlobalConfig()
3871
3350
if email:
3872
self.outf.write(_mod_config.extract_email_address(identity)
3873
+ '\n')
3351
self.outf.write(c.user_email() + '\n')
3874
3352
else:
3875
self.outf.write(identity + '\n')
3353
self.outf.write(c.username() + '\n')
3876
3354
return
3877
3355
3878
if email:
3879
raise errors.BzrCommandError(gettext("--email can only be used to display existing "
3880
"identity"))
3881
3882
3356
# display a warning if an email address isn't included in the given name.
3883
3357
try:
3884
_mod_config.extract_email_address(name)
3358
config.extract_email_address(name)
3885
3359
except errors.NoEmailInUsername, e:
3886
3360
warning('"%s" does not seem to contain an email address. '
3887
3361
'This is allowed, but not recommended.', name)
3888
3362
3889
3363
# use global config unless --branch given
3890
3364
if branch:
3891
if directory is None:
3892
c = Branch.open_containing(u'.')[0].get_config_stack()
3893
else:
3894
b = Branch.open(directory)
3895
self.add_cleanup(b.lock_write().unlock)
3896
c = b.get_config_stack()
3365
c = Branch.open_containing('.')[0].get_config()
3897
3366
else:
3898
c = _mod_config.GlobalStack()
3899
c.set('email', name)
3367
c = config.GlobalConfig()
3368
c.set_user_option('email', name)
3900
3369
3901
3370
3902
3371
class cmd_nick(Command):
3903
3372
__doc__ = """Print or set the branch nickname.
3904
3373
3905
If unset, the colocated branch name is used for colocated branches, and
3906
the branch directory name is used for other branches. To print the
3907
current nickname, execute with no argument.
3374
If unset, the tree root directory name is used as the nickname.
3375
To print the current nickname, execute with no argument.
3908
3376
3909
3377
Bound branches use the nickname of its master branch unless it is set
3910
3378
locally.
3912
3380
3913
3381
_see_also = ['info']
3914
3382
takes_args = ['nickname?']
3915
takes_options = ['directory']
3916
def run(self, nickname=None, directory=u'.'):
3917
branch = Branch.open_containing(directory)[0]
3383
def run(self, nickname=None):
3384
branch = Branch.open_containing(u'.')[0]
3918
3385
if nickname is None:
3919
3386
self.printme(branch)
3920
3387
else:
3965
3432
3966
3433
def remove_alias(self, alias_name):
3967
3434
if alias_name is None:
3968
raise errors.BzrCommandError(gettext(
3969
'bzr alias --remove expects an alias to remove.'))
3435
raise errors.BzrCommandError(
3436
'bzr alias --remove expects an alias to remove.')
3970
3437
# If alias is not found, print something like:
3971
3438
# unalias: foo: not found
3972
c = _mod_config.GlobalConfig()
3439
c = config.GlobalConfig()
3973
3440
c.unset_alias(alias_name)
3974
3441
3975
3442
@display_command
3976
3443
def print_aliases(self):
3977
3444
"""Print out the defined aliases in a similar format to bash."""
3978
aliases = _mod_config.GlobalConfig().get_aliases()
3445
aliases = config.GlobalConfig().get_aliases()
3979
3446
for key, value in sorted(aliases.iteritems()):
3980
3447
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3981
3448
3991
3458
3992
3459
def set_alias(self, alias_name, alias_command):
3993
3460
"""Save the alias in the global config."""
3994
c = _mod_config.GlobalConfig()
3461
c = config.GlobalConfig()
3995
3462
c.set_alias(alias_name, alias_command)
3996
3463
3997
3464
4032
3499
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
4033
3500
into a pdb postmortem session.
4034
3501
4035
The --coverage=DIRNAME global option produces a report with covered code
4036
indicated.
4037
4038
3502
:Examples:
4039
3503
Run only tests relating to 'ignore'::
4040
3504
4051
3515
if typestring == "sftp":
4052
3516
from bzrlib.tests import stub_sftp
4053
3517
return stub_sftp.SFTPAbsoluteServer
4054
elif typestring == "memory":
3518
if typestring == "memory":
4055
3519
from bzrlib.tests import test_server
4056
3520
return memory.MemoryServer
4057
elif typestring == "fakenfs":
3521
if typestring == "fakenfs":
4058
3522
from bzrlib.tests import test_server
4059
3523
return test_server.FakeNFSServer
4060
3524
msg = "No known transport type %s. Supported types are: sftp\n" %\
4073
3537
'throughout the test suite.',
4074
3538
type=get_transport_type),
4075
3539
Option('benchmark',
4076
help='Run the benchmarks rather than selftests.',
4077
hidden=True),
3540
help='Run the benchmarks rather than selftests.'),
4078
3541
Option('lsprof-timed',
4079
3542
help='Generate lsprof output for benchmarked'
4080
3543
' sections of code.'),
4081
3544
Option('lsprof-tests',
4082
3545
help='Generate lsprof output for each test.'),
3546
Option('cache-dir', type=str,
3547
help='Cache intermediate benchmark output in this '
3548
'directory.'),
4083
3549
Option('first',
4084
3550
help='Run all tests, but run specified tests first.',
4085
3551
short_name='f',
4094
3560
Option('randomize', type=str, argname="SEED",
4095
3561
help='Randomize the order of tests using the given'
4096
3562
' seed or "now" for the current time.'),
4097
ListOption('exclude', type=str, argname="PATTERN",
4098
short_name='x',
4099
help='Exclude tests that match this regular'
4100
' expression.'),
3563
Option('exclude', type=str, argname="PATTERN",
3564
short_name='x',
3565
help='Exclude tests that match this regular'
3566
' expression.'),
4101
3567
Option('subunit',
4102
3568
help='Output test progress via subunit.'),
4103
3569
Option('strict', help='Fail on missing dependencies or '
4110
3576
param_name='starting_with', short_name='s',
4111
3577
help=
4112
3578
'Load only the tests starting with TESTID.'),
4113
Option('sync',
4114
help="By default we disable fsync and fdatasync"
4115
" while running the test suite.")
4116
3579
]
4117
3580
encoding_type = 'replace'
4118
3581
4122
3585
4123
3586
def run(self, testspecs_list=None, verbose=False, one=False,
4124
3587
transport=None, benchmark=None,
4125
lsprof_timed=None,
3588
lsprof_timed=None, cache_dir=None,
4126
3589
first=False, list_only=False,
4127
3590
randomize=None, exclude=None, strict=False,
4128
3591
load_list=None, debugflag=None, starting_with=None, subunit=False,
4129
parallel=None, lsprof_tests=False,
4130
sync=False):
4131
4132
# During selftest, disallow proxying, as it can cause severe
4133
# performance penalties and is only needed for thread
4134
# safety. The selftest command is assumed to not use threads
4135
# too heavily. The call should be as early as possible, as
4136
# error reporting for past duplicate imports won't have useful
4137
# backtraces.
4138
lazy_import.disallow_proxying()
4139
4140
from bzrlib import tests
4141
3592
parallel=None, lsprof_tests=False):
3593
from bzrlib.tests import selftest
3594
import bzrlib.benchmarks as benchmarks
3595
from bzrlib.benchmarks import tree_creator
3596
3597
# Make deprecation warnings visible, unless -Werror is set
3598
symbol_versioning.activate_deprecation_warnings(override=False)
3599
3600
if cache_dir is not None:
3601
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
4142
3602
if testspecs_list is not None:
4143
3603
pattern = '|'.join(testspecs_list)
4144
3604
else:
4147
3607
try:
4148
3608
from bzrlib.tests import SubUnitBzrRunner
4149
3609
except ImportError:
4150
raise errors.BzrCommandError(gettext("subunit not available. subunit "
4151
"needs to be installed to use --subunit."))
3610
raise errors.BzrCommandError("subunit not available. subunit "
3611
"needs to be installed to use --subunit.")
4152
3612
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
4153
3613
# On Windows, disable automatic conversion of '\n' to '\r\n' in
4154
3614
# stdout, which would corrupt the subunit stream.
4155
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
4156
# following code can be deleted when it's sufficiently deployed
4157
# -- vila/mgz 20100514
4158
if (sys.platform == "win32"
4159
and getattr(sys.stdout, 'fileno', None) is not None):
3615
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
4160
3616
import msvcrt
4161
3617
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
4162
3618
if parallel:
4163
3619
self.additional_selftest_args.setdefault(
4164
3620
'suite_decorators', []).append(parallel)
4165
3621
if benchmark:
4166
raise errors.BzrCommandError(gettext(
4167
"--benchmark is no longer supported from bzr 2.2; "
4168
"use bzr-usertest instead"))
4169
test_suite_factory = None
4170
if not exclude:
4171
exclude_pattern = None
3622
test_suite_factory = benchmarks.test_suite
3623
# Unless user explicitly asks for quiet, be verbose in benchmarks
3624
verbose = not is_quiet()
3625
# TODO: should possibly lock the history file...
3626
benchfile = open(".perf_history", "at", buffering=1)
3627
self.add_cleanup(benchfile.close)
4172
3628
else:
4173
exclude_pattern = '(' + '|'.join(exclude) + ')'
4174
if not sync:
4175
self._disable_fsync()
3629
test_suite_factory = None
3630
benchfile = None
4176
3631
selftest_kwargs = {"verbose": verbose,
4177
3632
"pattern": pattern,
4178
3633
"stop_on_failure": one,
4180
3635
"test_suite_factory": test_suite_factory,
4181
3636
"lsprof_timed": lsprof_timed,
4182
3637
"lsprof_tests": lsprof_tests,
3638
"bench_history": benchfile,
4183
3639
"matching_tests_first": first,
4184
3640
"list_only": list_only,
4185
3641
"random_seed": randomize,
4186
"exclude_pattern": exclude_pattern,
3642
"exclude_pattern": exclude,
4187
3643
"strict": strict,
4188
3644
"load_list": load_list,
4189
3645
"debug_flags": debugflag,
4190
3646
"starting_with": starting_with
4191
3647
}
4192
3648
selftest_kwargs.update(self.additional_selftest_args)
4193
4194
# Make deprecation warnings visible, unless -Werror is set
4195
cleanup = symbol_versioning.activate_deprecation_warnings(
4196
override=False)
4197
try:
4198
result = tests.selftest(**selftest_kwargs)
4199
finally:
4200
cleanup()
3649
result = selftest(**selftest_kwargs)
4201
3650
return int(not result)
4202
3651
4203
def _disable_fsync(self):
4204
"""Change the 'os' functionality to not synchronize."""
4205
self._orig_fsync = getattr(os, 'fsync', None)
4206
if self._orig_fsync is not None:
4207
os.fsync = lambda filedes: None
4208
self._orig_fdatasync = getattr(os, 'fdatasync', None)
4209
if self._orig_fdatasync is not None:
4210
os.fdatasync = lambda filedes: None
4211
4212
3652
4213
3653
class cmd_version(Command):
4214
3654
__doc__ = """Show version of bzr."""
4234
3674
4235
3675
@display_command
4236
3676
def run(self):
4237
self.outf.write(gettext("It sure does!\n"))
3677
self.outf.write("It sure does!\n")
4238
3678
4239
3679
4240
3680
class cmd_find_merge_base(Command):
4250
3690
4251
3691
branch1 = Branch.open_containing(branch)[0]
4252
3692
branch2 = Branch.open_containing(other)[0]
4253
self.add_cleanup(branch1.lock_read().unlock)
4254
self.add_cleanup(branch2.lock_read().unlock)
3693
branch1.lock_read()
3694
self.add_cleanup(branch1.unlock)
3695
branch2.lock_read()
3696
self.add_cleanup(branch2.unlock)
4255
3697
last1 = ensure_null(branch1.last_revision())
4256
3698
last2 = ensure_null(branch2.last_revision())
4257
3699
4258
3700
graph = branch1.repository.get_graph(branch2.repository)
4259
3701
base_rev_id = graph.find_unique_lca(last1, last2)
4260
3702
4261
self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
3703
self.outf.write('merge base is revision %s\n' % base_rev_id)
4262
3704
4263
3705
4264
3706
class cmd_merge(Command):
4267
3709
The source of the merge can be specified either in the form of a branch,
4268
3710
or in the form of a path to a file containing a merge directive generated
4269
3711
with bzr send. If neither is specified, the default is the upstream branch
4270
or the branch most recently merged using --remember. The source of the
4271
merge may also be specified in the form of a path to a file in another
4272
branch: in this case, only the modifications to that file are merged into
4273
the current working tree.
4274
4275
When merging from a branch, by default bzr will try to merge in all new
4276
work from the other branch, automatically determining an appropriate base
4277
revision. If this fails, you may need to give an explicit base.
4278
4279
To pick a different ending revision, pass "--revision OTHER". bzr will
4280
try to merge in all new work up to and including revision OTHER.
4281
4282
If you specify two values, "--revision BASE..OTHER", only revisions BASE
4283
through OTHER, excluding BASE but including OTHER, will be merged. If this
4284
causes some revisions to be skipped, i.e. if the destination branch does
4285
not already contain revision BASE, such a merge is commonly referred to as
4286
a "cherrypick". Unlike a normal merge, Bazaar does not currently track
4287
cherrypicks. The changes look like a normal commit, and the history of the
4288
changes from the other branch is not stored in the commit.
4289
4290
Revision numbers are always relative to the source branch.
3712
or the branch most recently merged using --remember.
3713
3714
When merging a branch, by default the tip will be merged. To pick a different
3715
revision, pass --revision. If you specify two values, the first will be used as
3716
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3717
available revisions, like this is commonly referred to as "cherrypicking".
3718
3719
Revision numbers are always relative to the branch being merged.
3720
3721
By default, bzr will try to merge in all new work from the other
3722
branch, automatically determining an appropriate base. If this
3723
fails, you may need to give an explicit base.
4291
3724
4292
3725
Merge will do its best to combine the changes in two branches, but there
4293
3726
are some kinds of problems only a human can fix. When it encounters those,
4294
3727
it will mark a conflict. A conflict means that you need to fix something,
4295
before you can commit.
3728
before you should commit.
4296
3729
4297
3730
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
4298
3731
4299
If there is no default branch set, the first merge will set it (use
4300
--no-remember to avoid setting it). After that, you can omit the branch
4301
to use the default. To change the default, use --remember. The value will
4302
only be saved if the remote location can be accessed.
3732
If there is no default branch set, the first merge will set it. After
3733
that, you can omit the branch to use the default. To change the
3734
default, use --remember. The value will only be saved if the remote
3735
location can be accessed.
4303
3736
4304
3737
The results of the merge are placed into the destination working
4305
3738
directory, where they can be reviewed (with bzr diff), tested, and then
4306
3739
committed to record the result of the merge.
4307
3740
4308
3741
merge refuses to run if there are any uncommitted changes, unless
4309
--force is given. If --force is given, then the changes from the source
4310
will be merged with the current working tree, including any uncommitted
4311
changes in the tree. The --force option can also be used to create a
3742
--force is given. The --force option can also be used to create a
4312
3743
merge revision which has more than two parents.
4313
3744
4314
3745
If one would like to merge changes from the working tree of the other
4319
3750
you to apply each diff hunk and file change, similar to "shelve".
4320
3751
4321
3752
:Examples:
4322
To merge all new revisions from bzr.dev::
3753
To merge the latest revision from bzr.dev::
4323
3754
4324
3755
bzr merge ../bzr.dev
4325
3756
4362
3793
' completely merged into the source, pull from the'
4363
3794
' source rather than merging. When this happens,'
4364
3795
' you do not need to commit the result.'),
4365
custom_help('directory',
3796
Option('directory',
4366
3797
help='Branch to merge into, '
4367
'rather than the one containing the working directory.'),
3798
'rather than the one containing the working directory.',
3799
short_name='d',
3800
type=unicode,
3801
),
4368
3802
Option('preview', help='Instead of merging, show a diff of the'
4369
3803
' merge.'),
4370
3804
Option('interactive', help='Select changes interactively.',
4372
3806
]
4373
3807
4374
3808
def run(self, location=None, revision=None, force=False,
4375
merge_type=None, show_base=False, reprocess=None, remember=None,
3809
merge_type=None, show_base=False, reprocess=None, remember=False,
4376
3810
uncommitted=False, pull=False,
4377
3811
directory=None,
4378
3812
preview=False,
4386
3820
merger = None
4387
3821
allow_pending = True
4388
3822
verified = 'inapplicable'
4389
4390
3823
tree = WorkingTree.open_containing(directory)[0]
4391
if tree.branch.revno() == 0:
4392
raise errors.BzrCommandError(gettext('Merging into empty branches not currently supported, '
4393
'https://bugs.launchpad.net/bzr/+bug/308562'))
4394
3824
4395
3825
try:
4396
3826
basis_tree = tree.revision_tree(tree.last_revision())
4407
3837
unversioned_filter=tree.is_ignored, view_info=view_info)
4408
3838
pb = ui.ui_factory.nested_progress_bar()
4409
3839
self.add_cleanup(pb.finished)
4410
self.add_cleanup(tree.lock_write().unlock)
3840
tree.lock_write()
3841
self.add_cleanup(tree.unlock)
4411
3842
if location is not None:
4412
3843
try:
4413
3844
mergeable = bundle.read_mergeable_from_url(location,
4416
3847
mergeable = None
4417
3848
else:
4418
3849
if uncommitted:
4419
raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
4420
' with bundles or merge directives.'))
3850
raise errors.BzrCommandError('Cannot use --uncommitted'
3851
' with bundles or merge directives.')
4421
3852
4422
3853
if revision is not None:
4423
raise errors.BzrCommandError(gettext(
4424
'Cannot use -r with merge directives or bundles'))
3854
raise errors.BzrCommandError(
3855
'Cannot use -r with merge directives or bundles')
4425
3856
merger, verified = _mod_merge.Merger.from_mergeable(tree,
4426
3857
mergeable, None)
4427
3858
4428
3859
if merger is None and uncommitted:
4429
3860
if revision is not None and len(revision) > 0:
4430
raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
4431
' --revision at the same time.'))
3861
raise errors.BzrCommandError('Cannot use --uncommitted and'
3862
' --revision at the same time.')
4432
3863
merger = self.get_merger_from_uncommitted(tree, location, None)
4433
3864
allow_pending = False
4434
3865
4442
3873
self.sanity_check_merger(merger)
4443
3874
if (merger.base_rev_id == merger.other_rev_id and
4444
3875
merger.other_rev_id is not None):
4445
# check if location is a nonexistent file (and not a branch) to
4446
# disambiguate the 'Nothing to do'
4447
if merger.interesting_files:
4448
if not merger.other_tree.has_filename(
4449
merger.interesting_files[0]):
4450
note(gettext("merger: ") + str(merger))
4451
raise errors.PathsDoNotExist([location])
4452
note(gettext('Nothing to do.'))
3876
note('Nothing to do.')
4453
3877
return 0
4454
if pull and not preview:
3878
if pull:
4455
3879
if merger.interesting_files is not None:
4456
raise errors.BzrCommandError(gettext('Cannot pull individual files'))
3880
raise errors.BzrCommandError('Cannot pull individual files')
4457
3881
if (merger.base_rev_id == tree.last_revision()):
4458
3882
result = tree.pull(merger.other_branch, False,
4459
3883
merger.other_rev_id)
4460
3884
result.report(self.outf)
4461
3885
return 0
4462
3886
if merger.this_basis is None:
4463
raise errors.BzrCommandError(gettext(
3887
raise errors.BzrCommandError(
4464
3888
"This branch has no commits."
4465
" (perhaps you would prefer 'bzr pull')"))
3889
" (perhaps you would prefer 'bzr pull')")
4466
3890
if preview:
4467
3891
return self._do_preview(merger)
4468
3892
elif interactive:
4481
3905
def _do_preview(self, merger):
4482
3906
from bzrlib.diff import show_diff_trees
4483
3907
result_tree = self._get_preview(merger)
4484
path_encoding = osutils.get_diff_header_encoding()
4485
3908
show_diff_trees(merger.this_tree, result_tree, self.outf,
4486
old_label='', new_label='',
4487
path_encoding=path_encoding)
3909
old_label='', new_label='')
4488
3910
4489
3911
def _do_merge(self, merger, change_reporter, allow_pending, verified):
4490
3912
merger.change_reporter = change_reporter
4519
3941
def sanity_check_merger(self, merger):
4520
3942
if (merger.show_base and
4521
3943
not merger.merge_type is _mod_merge.Merge3Merger):
4522
raise errors.BzrCommandError(gettext("Show-base is not supported for this"
4523
" merge type. %s") % merger.merge_type)
3944
raise errors.BzrCommandError("Show-base is not supported for this"
3945
" merge type. %s" % merger.merge_type)
4524
3946
if merger.reprocess is None:
4525
3947
if merger.show_base:
4526
3948
merger.reprocess = False
4528
3950
# Use reprocess if the merger supports it
4529
3951
merger.reprocess = merger.merge_type.supports_reprocess
4530
3952
if merger.reprocess and not merger.merge_type.supports_reprocess:
4531
raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
4532
" for merge type %s.") %
3953
raise errors.BzrCommandError("Conflict reduction is not supported"
3954
" for merge type %s." %
4533
3955
merger.merge_type)
4534
3956
if merger.reprocess and merger.show_base:
4535
raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
4536
" show base."))
3957
raise errors.BzrCommandError("Cannot do conflict reduction and"
3958
" show base.")
4537
3959
4538
3960
def _get_merger_from_branch(self, tree, location, revision, remember,
4539
3961
possible_transports, pb):
4566
3988
if other_revision_id is None:
4567
3989
other_revision_id = _mod_revision.ensure_null(
4568
3990
other_branch.last_revision())
4569
# Remember where we merge from. We need to remember if:
4570
# - user specify a location (and we don't merge from the parent
4571
# branch)
4572
# - user ask to remember or there is no previous location set to merge
4573
# from and user didn't ask to *not* remember
4574
if (user_location is not None
4575
and ((remember
4576
or (remember is None
4577
and tree.branch.get_submit_branch() is None)))):
3991
# Remember where we merge from
3992
if ((remember or tree.branch.get_submit_branch() is None) and
3993
user_location is not None):
4578
3994
tree.branch.set_submit_branch(other_branch.base)
4579
# Merge tags (but don't set them in the master branch yet, the user
4580
# might revert this merge). Commit will propagate them.
4581
_merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3995
_merge_tags_if_possible(other_branch, tree.branch)
4582
3996
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4583
3997
other_revision_id, base_revision_id, other_branch, base_branch)
4584
3998
if other_path != '':
4643
4057
stored_location_type = "parent"
4644
4058
mutter("%s", stored_location)
4645
4059
if stored_location is None:
4646
raise errors.BzrCommandError(gettext("No location specified or remembered"))
4060
raise errors.BzrCommandError("No location specified or remembered")
4647
4061
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4648
note(gettext("{0} remembered {1} location {2}").format(verb_string,
4649
stored_location_type, display_url))
4062
note(u"%s remembered %s location %s", verb_string,
4063
stored_location_type, display_url)
4650
4064
return stored_location
4651
4065
4652
4066
4685
4099
from bzrlib.conflicts import restore
4686
4100
if merge_type is None:
4687
4101
merge_type = _mod_merge.Merge3Merger
4688
tree, file_list = WorkingTree.open_containing_paths(file_list)
4689
self.add_cleanup(tree.lock_write().unlock)
4102
tree, file_list = tree_files(file_list)
4103
tree.lock_write()
4104
self.add_cleanup(tree.unlock)
4690
4105
parents = tree.get_parent_ids()
4691
4106
if len(parents) != 2:
4692
raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4107
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4693
4108
" merges. Not cherrypicking or"
4694
" multi-merges."))
4109
" multi-merges.")
4695
4110
repository = tree.branch.repository
4696
4111
interesting_ids = None
4697
4112
new_conflicts = []
4706
4121
if tree.kind(file_id) != "directory":
4707
4122
continue
4708
4123
4709
# FIXME: Support nested trees
4710
for name, ie in tree.root_inventory.iter_entries(file_id):
4124
for name, ie in tree.inventory.iter_entries(file_id):
4711
4125
interesting_ids.add(ie.file_id)
4712
4126
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4713
4127
else:
4746
4160
4747
4161
4748
4162
class cmd_revert(Command):
4749
__doc__ = """\
4750
Set files in the working tree back to the contents of a previous revision.
4163
__doc__ = """Revert files to a previous revision.
4751
4164
4752
4165
Giving a list of files will revert only those files. Otherwise, all files
4753
4166
will be reverted. If the revision is not specified with '--revision', the
4754
working tree basis revision is used. A revert operation affects only the
4755
working tree, not any revision history like the branch and repository or
4756
the working tree basis revision.
4167
last committed revision is used.
4757
4168
4758
4169
To remove only some changes, without reverting to a prior version, use
4759
merge instead. For example, "merge . -r -2..-3" (don't forget the ".")
4760
will remove the changes introduced by the second last commit (-2), without
4761
affecting the changes introduced by the last commit (-1). To remove
4762
certain changes on a hunk-by-hunk basis, see the shelve command.
4763
To update the branch to a specific revision or the latest revision and
4764
update the working tree accordingly while preserving local changes, see the
4765
update command.
4170
merge instead. For example, "merge . --revision -2..-3" will remove the
4171
changes introduced by -2, without affecting the changes introduced by -1.
4172
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4766
4173
4767
Uncommitted changes to files that are reverted will be discarded.
4768
Howver, by default, any files that have been manually changed will be
4769
backed up first. (Files changed only by merge are not backed up.) Backup
4770
files have '.~#~' appended to their name, where # is a number.
4174
By default, any files that have been manually changed will be backed up
4175
first. (Files changed only by merge are not backed up.) Backup files have
4176
'.~#~' appended to their name, where # is a number.
4771
4177
4772
4178
When you provide files, you can use their current pathname or the pathname
4773
4179
from the target revision. So you can use revert to "undelete" a file by
4799
4205
target branches.
4800
4206
"""
4801
4207
4802
_see_also = ['cat', 'export', 'merge', 'shelve']
4208
_see_also = ['cat', 'export']
4803
4209
takes_options = [
4804
4210
'revision',
4805
4211
Option('no-backup', "Do not save backups of reverted files."),
4810
4216
4811
4217
def run(self, revision=None, no_backup=False, file_list=None,
4812
4218
forget_merges=None):
4813
tree, file_list = WorkingTree.open_containing_paths(file_list)
4814
self.add_cleanup(tree.lock_tree_write().unlock)
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4815
4222
if forget_merges:
4816
4223
tree.set_parent_ids(tree.get_parent_ids()[:1])
4817
4224
else:
4864
4271
4865
4272
@display_command
4866
4273
def run(self, context=None):
4867
from bzrlib import shellcomplete
4274
import shellcomplete
4868
4275
shellcomplete.shellcomplete(context)
4869
4276
4870
4277
4906
4313
_see_also = ['merge', 'pull']
4907
4314
takes_args = ['other_branch?']
4908
4315
takes_options = [
4909
'directory',
4910
4316
Option('reverse', 'Reverse the order of revisions.'),
4911
4317
Option('mine-only',
4912
4318
'Display changes in the local branch only.'),
4924
4330
type=_parse_revision_str,
4925
4331
help='Filter on local branch revisions (inclusive). '
4926
4332
'See "help revisionspec" for details.'),
4927
Option('include-merged',
4333
Option('include-merges',
4928
4334
'Show all revisions in addition to the mainline ones.'),
4929
Option('include-merges', hidden=True,
4930
help='Historical alias for --include-merged.'),
4931
4335
]
4932
4336
encoding_type = 'replace'
4933
4337
4936
4340
theirs_only=False,
4937
4341
log_format=None, long=False, short=False, line=False,
4938
4342
show_ids=False, verbose=False, this=False, other=False,
4939
include_merged=None, revision=None, my_revision=None,
4940
directory=u'.',
4941
include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4343
include_merges=False, revision=None, my_revision=None):
4942
4344
from bzrlib.missing import find_unmerged, iter_log_revisions
4943
4345
def message(s):
4944
4346
if not is_quiet():
4945
4347
self.outf.write(s)
4946
4348
4947
if symbol_versioning.deprecated_passed(include_merges):
4948
ui.ui_factory.show_user_warning(
4949
'deprecated_command_option',
4950
deprecated_name='--include-merges',
4951
recommended_name='--include-merged',
4952
deprecated_in_version='2.5',
4953
command=self.invoked_as)
4954
if include_merged is None:
4955
include_merged = include_merges
4956
else:
4957
raise errors.BzrCommandError(gettext(
4958
'{0} and {1} are mutually exclusive').format(
4959
'--include-merges', '--include-merged'))
4960
if include_merged is None:
4961
include_merged = False
4962
4349
if this:
4963
4350
mine_only = this
4964
4351
if other:
4972
4359
elif theirs_only:
4973
4360
restrict = 'remote'
4974
4361
4975
local_branch = Branch.open_containing(directory)[0]
4976
self.add_cleanup(local_branch.lock_read().unlock)
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4977
4365
4978
4366
parent = local_branch.get_parent()
4979
4367
if other_branch is None:
4980
4368
other_branch = parent
4981
4369
if other_branch is None:
4982
raise errors.BzrCommandError(gettext("No peer location known"
4983
" or specified."))
4370
raise errors.BzrCommandError("No peer location known"
4371
" or specified.")
4984
4372
display_url = urlutils.unescape_for_display(parent,
4985
4373
self.outf.encoding)
4986
message(gettext("Using saved parent location: {0}\n").format(
4987
display_url))
4374
message("Using saved parent location: "
4375
+ display_url + "\n")
4988
4376
4989
4377
remote_branch = Branch.open(other_branch)
4990
4378
if remote_branch.base == local_branch.base:
4991
4379
remote_branch = local_branch
4992
4380
else:
4993
self.add_cleanup(remote_branch.lock_read().unlock)
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4994
4383
4995
4384
local_revid_range = _revision_range_to_revid_range(
4996
4385
_get_revision_range(my_revision, local_branch,
5003
4392
local_extra, remote_extra = find_unmerged(
5004
4393
local_branch, remote_branch, restrict,
5005
4394
backward=not reverse,
5006
include_merged=include_merged,
4395
include_merges=include_merges,
5007
4396
local_revid_range=local_revid_range,
5008
4397
remote_revid_range=remote_revid_range)
5009
4398
5016
4405
5017
4406
status_code = 0
5018
4407
if local_extra and not theirs_only:
5019
message(ngettext("You have %d extra revision:\n",
5020
"You have %d extra revisions:\n",
5021
len(local_extra)) %
4408
message("You have %d extra revision(s):\n" %
5022
4409
len(local_extra))
5023
rev_tag_dict = {}
5024
if local_branch.supports_tags():
5025
rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
5026
4410
for revision in iter_log_revisions(local_extra,
5027
4411
local_branch.repository,
5028
verbose,
5029
rev_tag_dict):
4412
verbose):
5030
4413
lf.log_revision(revision)
5031
4414
printed_local = True
5032
4415
status_code = 1
5036
4419
if remote_extra and not mine_only:
5037
4420
if printed_local is True:
5038
4421
message("\n\n\n")
5039
message(ngettext("You are missing %d revision:\n",
5040
"You are missing %d revisions:\n",
5041
len(remote_extra)) %
4422
message("You are missing %d revision(s):\n" %
5042
4423
len(remote_extra))
5043
if remote_branch.supports_tags():
5044
rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
5045
4424
for revision in iter_log_revisions(remote_extra,
5046
4425
remote_branch.repository,
5047
verbose,
5048
rev_tag_dict):
4426
verbose):
5049
4427
lf.log_revision(revision)
5050
4428
status_code = 1
5051
4429
5052
4430
if mine_only and not local_extra:
5053
4431
# We checked local, and found nothing extra
5054
message(gettext('This branch has no new revisions.\n'))
4432
message('This branch is up to date.\n')
5055
4433
elif theirs_only and not remote_extra:
5056
4434
# We checked remote, and found nothing extra
5057
message(gettext('Other branch has no new revisions.\n'))
4435
message('Other branch is up to date.\n')
5058
4436
elif not (mine_only or theirs_only or local_extra or
5059
4437
remote_extra):
5060
4438
# We checked both branches, and neither one had extra
5061
4439
# revisions
5062
message(gettext("Branches are up to date.\n"))
4440
message("Branches are up to date.\n")
5063
4441
self.cleanup_now()
5064
4442
if not status_code and parent is None and other_branch is not None:
5065
self.add_cleanup(local_branch.lock_write().unlock)
4443
local_branch.lock_write()
4444
self.add_cleanup(local_branch.unlock)
5066
4445
# handle race conditions - a parent might be set while we run.
5067
4446
if local_branch.get_parent() is None:
5068
4447
local_branch.set_parent(remote_branch.base)
5095
4474
]
5096
4475
5097
4476
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
5098
dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
4477
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
5099
4478
try:
5100
4479
branch = dir.open_branch()
5101
4480
repository = branch.repository
5127
4506
5128
4507
@display_command
5129
4508
def run(self, verbose=False):
5130
from bzrlib import plugin
5131
# Don't give writelines a generator as some codecs don't like that
5132
self.outf.writelines(
5133
list(plugin.describe_plugins(show_paths=verbose)))
4509
import bzrlib.plugin
4510
from inspect import getdoc
4511
result = []
4512
for name, plugin in bzrlib.plugin.plugins().items():
4513
version = plugin.__version__
4514
if version == 'unknown':
4515
version = ''
4516
name_ver = '%s %s' % (name, version)
4517
d = getdoc(plugin.module)
4518
if d:
4519
doc = d.split('\n')[0]
4520
else:
4521
doc = '(no description)'
4522
result.append((name_ver, doc, plugin.path()))
4523
for name_ver, doc, path in sorted(result):
4524
self.outf.write("%s\n" % name_ver)
4525
self.outf.write(" %s\n" % doc)
4526
if verbose:
4527
self.outf.write(" %s\n" % path)
4528
self.outf.write("\n")
5134
4529
5135
4530
5136
4531
class cmd_testament(Command):
5152
4547
b = Branch.open_containing(branch)[0]
5153
4548
else:
5154
4549
b = Branch.open(branch)
5155
self.add_cleanup(b.lock_read().unlock)
4550
b.lock_read()
4551
self.add_cleanup(b.unlock)
5156
4552
if revision is None:
5157
4553
rev_id = b.last_revision()
5158
4554
else:
5182
4578
Option('long', help='Show commit date in annotations.'),
5183
4579
'revision',
5184
4580
'show-ids',
5185
'directory',
5186
4581
]
5187
4582
encoding_type = 'exact'
5188
4583
5189
4584
@display_command
5190
4585
def run(self, filename, all=False, long=False, revision=None,
5191
show_ids=False, directory=None):
5192
from bzrlib.annotate import (
5193
annotate_file_tree,
5194
)
4586
show_ids=False):
4587
from bzrlib.annotate import annotate_file, annotate_file_tree
5195
4588
wt, branch, relpath = \
5196
_open_directory_or_containing_tree_or_branch(filename, directory)
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
5197
4590
if wt is not None:
5198
self.add_cleanup(wt.lock_read().unlock)
4591
wt.lock_read()
4592
self.add_cleanup(wt.unlock)
5199
4593
else:
5200
self.add_cleanup(branch.lock_read().unlock)
4594
branch.lock_read()
4595
self.add_cleanup(branch.unlock)
5201
4596
tree = _get_one_revision_tree('annotate', revision, branch=branch)
5202
self.add_cleanup(tree.lock_read().unlock)
5203
if wt is not None and revision is None:
4597
tree.lock_read()
4598
self.add_cleanup(tree.unlock)
4599
if wt is not None:
5204
4600
file_id = wt.path2id(relpath)
5205
4601
else:
5206
4602
file_id = tree.path2id(relpath)
5207
4603
if file_id is None:
5208
4604
raise errors.NotVersionedError(filename)
4605
file_version = tree.inventory[file_id].revision
5209
4606
if wt is not None and revision is None:
5210
4607
# If there is a tree and we're not annotating historical
5211
4608
# versions, annotate the working tree's content.
5212
4609
annotate_file_tree(wt, file_id, self.outf, long, all,
5213
4610
show_ids=show_ids)
5214
4611
else:
5215
annotate_file_tree(tree, file_id, self.outf, long, all,
5216
show_ids=show_ids, branch=branch)
4612
annotate_file(branch, file_version, file_id, long, all, self.outf,
4613
show_ids=show_ids)
5217
4614
5218
4615
5219
4616
class cmd_re_sign(Command):
5222
4619
5223
4620
hidden = True # is this right ?
5224
4621
takes_args = ['revision_id*']
5225
takes_options = ['directory', 'revision']
4622
takes_options = ['revision']
5226
4623
5227
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4624
def run(self, revision_id_list=None, revision=None):
5228
4625
if revision_id_list is not None and revision is not None:
5229
raise errors.BzrCommandError(gettext('You can only supply one of revision_id or --revision'))
4626
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
5230
4627
if revision_id_list is None and revision is None:
5231
raise errors.BzrCommandError(gettext('You must supply either --revision or a revision_id'))
5232
b = WorkingTree.open_containing(directory)[0].branch
5233
self.add_cleanup(b.lock_write().unlock)
4628
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4629
b = WorkingTree.open_containing(u'.')[0].branch
4630
b.lock_write()
4631
self.add_cleanup(b.unlock)
5234
4632
return self._run(b, revision_id_list, revision)
5235
4633
5236
4634
def _run(self, b, revision_id_list, revision):
5237
4635
import bzrlib.gpg as gpg
5238
gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4636
gpg_strategy = gpg.GPGStrategy(b.get_config())
5239
4637
if revision_id_list is not None:
5240
4638
b.repository.start_write_group()
5241
4639
try:
5266
4664
if to_revid is None:
5267
4665
to_revno = b.revno()
5268
4666
if from_revno is None or to_revno is None:
5269
raise errors.BzrCommandError(gettext('Cannot sign a range of non-revision-history revisions'))
4667
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
5270
4668
b.repository.start_write_group()
5271
4669
try:
5272
4670
for revno in range(from_revno, to_revno + 1):
5278
4676
else:
5279
4677
b.repository.commit_write_group()
5280
4678
else:
5281
raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4679
raise errors.BzrCommandError('Please supply either one revision, or a range.')
5282
4680
5283
4681
5284
4682
class cmd_bind(Command):
5295
4693
5296
4694
_see_also = ['checkouts', 'unbind']
5297
4695
takes_args = ['location?']
5298
takes_options = ['directory']
4696
takes_options = []
5299
4697
5300
def run(self, location=None, directory=u'.'):
5301
b, relpath = Branch.open_containing(directory)
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
5302
4700
if location is None:
5303
4701
try:
5304
4702
location = b.get_old_bound_location()
5305
4703
except errors.UpgradeRequired:
5306
raise errors.BzrCommandError(gettext('No location supplied. '
5307
'This format does not remember old locations.'))
4704
raise errors.BzrCommandError('No location supplied. '
4705
'This format does not remember old locations.')
5308
4706
else:
5309
4707
if location is None:
5310
4708
if b.get_bound_location() is not None:
5311
raise errors.BzrCommandError(
5312
gettext('Branch is already bound'))
4709
raise errors.BzrCommandError('Branch is already bound')
5313
4710
else:
5314
raise errors.BzrCommandError(
5315
gettext('No location supplied'
5316
' and no previous location known'))
4711
raise errors.BzrCommandError('No location supplied '
4712
'and no previous location known')
5317
4713
b_other = Branch.open(location)
5318
4714
try:
5319
4715
b.bind(b_other)
5320
4716
except errors.DivergedBranches:
5321
raise errors.BzrCommandError(gettext('These branches have diverged.'
5322
' Try merging, and then bind again.'))
4717
raise errors.BzrCommandError('These branches have diverged.'
4718
' Try merging, and then bind again.')
5323
4719
if b.get_config().has_explicit_nickname():
5324
4720
b.nick = b_other.nick
5325
4721
5333
4729
5334
4730
_see_also = ['checkouts', 'bind']
5335
4731
takes_args = []
5336
takes_options = ['directory']
4732
takes_options = []
5337
4733
5338
def run(self, directory=u'.'):
5339
b, relpath = Branch.open_containing(directory)
4734
def run(self):
4735
b, relpath = Branch.open_containing(u'.')
5340
4736
if not b.unbind():
5341
raise errors.BzrCommandError(gettext('Local branch is not bound'))
4737
raise errors.BzrCommandError('Local branch is not bound')
5342
4738
5343
4739
5344
4740
class cmd_uncommit(Command):
5365
4761
takes_options = ['verbose', 'revision',
5366
4762
Option('dry-run', help='Don\'t actually make changes.'),
5367
4763
Option('force', help='Say yes to all questions.'),
5368
Option('keep-tags',
5369
help='Keep tags that point to removed revisions.'),
5370
4764
Option('local',
5371
4765
help="Only remove the commits from the local branch"
5372
4766
" when in a checkout."
5376
4770
aliases = []
5377
4771
encoding_type = 'replace'
5378
4772
5379
def run(self, location=None, dry_run=False, verbose=False,
5380
revision=None, force=False, local=False, keep_tags=False):
4773
def run(self, location=None,
4774
dry_run=False, verbose=False,
4775
revision=None, force=False, local=False):
5381
4776
if location is None:
5382
4777
location = u'.'
5383
control, relpath = controldir.ControlDir.open_containing(location)
4778
control, relpath = bzrdir.BzrDir.open_containing(location)
5384
4779
try:
5385
4780
tree = control.open_workingtree()
5386
4781
b = tree.branch
5389
4784
b = control.open_branch()
5390
4785
5391
4786
if tree is not None:
5392
self.add_cleanup(tree.lock_write().unlock)
4787
tree.lock_write()
4788
self.add_cleanup(tree.unlock)
5393
4789
else:
5394
self.add_cleanup(b.lock_write().unlock)
5395
return self._run(b, tree, dry_run, verbose, revision, force,
5396
local, keep_tags)
4790
b.lock_write()
4791
self.add_cleanup(b.unlock)
4792
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
5397
4793
5398
def _run(self, b, tree, dry_run, verbose, revision, force, local,
5399
keep_tags):
4794
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
5400
4795
from bzrlib.log import log_formatter, show_log
5401
4796
from bzrlib.uncommit import uncommit
5402
4797
5417
4812
rev_id = b.get_rev_id(revno)
5418
4813
5419
4814
if rev_id is None or _mod_revision.is_null(rev_id):
5420
self.outf.write(gettext('No revisions to uncommit.\n'))
4815
self.outf.write('No revisions to uncommit.\n')
5421
4816
return 1
5422
4817
5423
4818
lf = log_formatter('short',
5432
4827
end_revision=last_revno)
5433
4828
5434
4829
if dry_run:
5435
self.outf.write(gettext('Dry-run, pretending to remove'
5436
' the above revisions.\n'))
4830
self.outf.write('Dry-run, pretending to remove'
4831
' the above revisions.\n')
5437
4832
else:
5438
self.outf.write(gettext('The above revision(s) will be removed.\n'))
4833
self.outf.write('The above revision(s) will be removed.\n')
5439
4834
5440
4835
if not force:
5441
if not ui.ui_factory.confirm_action(
5442
gettext(u'Uncommit these revisions'),
5443
'bzrlib.builtins.uncommit',
5444
{}):
5445
self.outf.write(gettext('Canceled\n'))
4836
if not ui.ui_factory.get_boolean('Are you sure'):
4837
self.outf.write('Canceled')
5446
4838
return 0
5447
4839
5448
4840
mutter('Uncommitting from {%s} to {%s}',
5449
4841
last_rev_id, rev_id)
5450
4842
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
5451
revno=revno, local=local, keep_tags=keep_tags)
5452
self.outf.write(gettext('You can restore the old tip by running:\n'
5453
' bzr pull . -r revid:%s\n') % last_rev_id)
4843
revno=revno, local=local)
4844
self.outf.write('You can restore the old tip by running:\n'
4845
' bzr pull . -r revid:%s\n' % last_rev_id)
5454
4846
5455
4847
5456
4848
class cmd_break_lock(Command):
5457
__doc__ = """Break a dead lock.
5458
5459
This command breaks a lock on a repository, branch, working directory or
5460
config file.
4849
__doc__ = """Break a dead lock on a repository, branch or working directory.
5461
4850
5462
4851
CAUTION: Locks should only be broken when you are sure that the process
5463
4852
holding the lock has been stopped.
5468
4857
:Examples:
5469
4858
bzr break-lock
5470
4859
bzr break-lock bzr+ssh://example.com/bzr/foo
5471
bzr break-lock --conf ~/.bazaar
5472
4860
"""
5473
5474
4861
takes_args = ['location?']
5475
takes_options = [
5476
Option('config',
5477
help='LOCATION is the directory where the config lock is.'),
5478
Option('force',
5479
help='Do not ask for confirmation before breaking the lock.'),
5480
]
5481
4862
5482
def run(self, location=None, config=False, force=False):
4863
def run(self, location=None, show=False):
5483
4864
if location is None:
5484
4865
location = u'.'
5485
if force:
5486
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
5487
None,
5488
{'bzrlib.lockdir.break': True})
5489
if config:
5490
conf = _mod_config.LockableConfig(file_name=location)
5491
conf.break_lock()
5492
else:
5493
control, relpath = controldir.ControlDir.open_containing(location)
5494
try:
5495
control.break_lock()
5496
except NotImplementedError:
5497
pass
4866
control, relpath = bzrdir.BzrDir.open_containing(location)
4867
try:
4868
control.break_lock()
4869
except NotImplementedError:
4870
pass
5498
4871
5499
4872
5500
4873
class cmd_wait_until_signalled(Command):
5523
4896
help="Protocol to serve.",
5524
4897
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
5525
4898
value_switches=True),
5526
Option('listen',
5527
help='Listen for connections on nominated address.', type=str),
5528
4899
Option('port',
5529
help='Listen for connections on nominated port. Passing 0 as '
5530
'the port number will result in a dynamically allocated '
5531
'port. The default port depends on the protocol.',
5532
type=int),
5533
custom_help('directory',
5534
help='Serve contents of this directory.'),
4900
help='Listen for connections on nominated port of the form '
4901
'[hostname:]portnumber. Passing 0 as the port number will '
4902
'result in a dynamically allocated port. The default port '
4903
'depends on the protocol.',
4904
type=str),
4905
Option('directory',
4906
help='Serve contents of this directory.',
4907
type=unicode),
5535
4908
Option('allow-writes',
5536
4909
help='By default the server is a readonly server. Supplying '
5537
4910
'--allow-writes enables write access to the contents of '
5541
4914
'option leads to global uncontrolled write access to your '
5542
4915
'file system.'
5543
4916
),
5544
Option('client-timeout', type=float,
5545
help='Override the default idle client timeout (5min).'),
5546
4917
]
5547
4918
5548
def run(self, listen=None, port=None, inet=False, directory=None,
5549
allow_writes=False, protocol=None, client_timeout=None):
5550
from bzrlib import transport
4919
def get_host_and_port(self, port):
4920
"""Return the host and port to run the smart server on.
4921
4922
If 'port' is None, None will be returned for the host and port.
4923
4924
If 'port' has a colon in it, the string before the colon will be
4925
interpreted as the host.
4926
4927
:param port: A string of the port to run the server on.
4928
:return: A tuple of (host, port), where 'host' is a host name or IP,
4929
and port is an integer TCP/IP port.
4930
"""
4931
host = None
4932
if port is not None:
4933
if ':' in port:
4934
host, port = port.split(':')
4935
port = int(port)
4936
return host, port
4937
4938
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
5551
4941
if directory is None:
5552
4942
directory = os.getcwd()
5553
4943
if protocol is None:
5554
protocol = transport.transport_server_registry.get()
5555
url = transport.location_to_url(directory)
4944
protocol = transport_server_registry.get()
4945
host, port = self.get_host_and_port(port)
4946
url = urlutils.local_path_to_url(directory)
5556
4947
if not allow_writes:
5557
4948
url = 'readonly+' + url
5558
t = transport.get_transport_from_url(url)
5559
protocol(t, listen, port, inet, client_timeout)
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
5560
4951
5561
4952
5562
4953
class cmd_join(Command):
5568
4959
not part of it. (Such trees can be produced by "bzr split", but also by
5569
4960
running "bzr branch" with the target inside a tree.)
5570
4961
5571
The result is a combined tree, with the subtree no longer an independent
4962
The result is a combined tree, with the subtree no longer an independant
5572
4963
part. This is marked as a merge of the subtree into the containing tree,
5573
4964
and all history is preserved.
5574
4965
"""
5585
4976
containing_tree = WorkingTree.open_containing(parent_dir)[0]
5586
4977
repo = containing_tree.branch.repository
5587
4978
if not repo.supports_rich_root():
5588
raise errors.BzrCommandError(gettext(
4979
raise errors.BzrCommandError(
5589
4980
"Can't join trees because %s doesn't support rich root data.\n"
5590
"You can use bzr upgrade on the repository.")
4981
"You can use bzr upgrade on the repository."
5591
4982
% (repo,))
5592
4983
if reference:
5593
4984
try:
5595
4986
except errors.BadReferenceTarget, e:
5596
4987
# XXX: Would be better to just raise a nicely printable
5597
4988
# exception from the real origin. Also below. mbp 20070306
5598
raise errors.BzrCommandError(
5599
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4989
raise errors.BzrCommandError("Cannot join %s. %s" %
4990
(tree, e.reason))
5600
4991
else:
5601
4992
try:
5602
4993
containing_tree.subsume(sub_tree)
5603
4994
except errors.BadSubsumeSource, e:
5604
raise errors.BzrCommandError(
5605
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4995
raise errors.BzrCommandError("Cannot join %s. %s" %
4996
(tree, e.reason))
5606
4997
5607
4998
5608
4999
class cmd_split(Command):
5655
5046
_see_also = ['send']
5656
5047
5657
5048
takes_options = [
5658
'directory',
5659
5049
RegistryOption.from_kwargs('patch-type',
5660
5050
'The type of patch to include in the directive.',
5661
5051
title='Patch type',
5674
5064
encoding_type = 'exact'
5675
5065
5676
5066
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5677
sign=False, revision=None, mail_to=None, message=None,
5678
directory=u'.'):
5067
sign=False, revision=None, mail_to=None, message=None):
5679
5068
from bzrlib.revision import ensure_null, NULL_REVISION
5680
5069
include_patch, include_bundle = {
5681
5070
'plain': (False, False),
5682
5071
'diff': (True, False),
5683
5072
'bundle': (True, True),
5684
5073
}[patch_type]
5685
branch = Branch.open(directory)
5074
branch = Branch.open('.')
5686
5075
stored_submit_branch = branch.get_submit_branch()
5687
5076
if submit_branch is None:
5688
5077
submit_branch = stored_submit_branch
5692
5081
if submit_branch is None:
5693
5082
submit_branch = branch.get_parent()
5694
5083
if submit_branch is None:
5695
raise errors.BzrCommandError(gettext('No submit branch specified or known'))
5084
raise errors.BzrCommandError('No submit branch specified or known')
5696
5085
5697
5086
stored_public_branch = branch.get_public_branch()
5698
5087
if public_branch is None:
5699
5088
public_branch = stored_public_branch
5700
5089
elif stored_public_branch is None:
5701
# FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5702
5090
branch.set_public_branch(public_branch)
5703
5091
if not include_bundle and public_branch is None:
5704
raise errors.BzrCommandError(gettext('No public branch specified or'
5705
' known'))
5092
raise errors.BzrCommandError('No public branch specified or'
5093
' known')
5706
5094
base_revision_id = None
5707
5095
if revision is not None:
5708
5096
if len(revision) > 2:
5709
raise errors.BzrCommandError(gettext('bzr merge-directive takes '
5710
'at most two one revision identifiers'))
5097
raise errors.BzrCommandError('bzr merge-directive takes '
5098
'at most two one revision identifiers')
5711
5099
revision_id = revision[-1].as_revision_id(branch)
5712
5100
if len(revision) == 2:
5713
5101
base_revision_id = revision[0].as_revision_id(branch)
5715
5103
revision_id = branch.last_revision()
5716
5104
revision_id = ensure_null(revision_id)
5717
5105
if revision_id == NULL_REVISION:
5718
raise errors.BzrCommandError(gettext('No revisions to bundle.'))
5106
raise errors.BzrCommandError('No revisions to bundle.')
5719
5107
directive = merge_directive.MergeDirective2.from_objects(
5720
5108
branch.repository, revision_id, time.time(),
5721
5109
osutils.local_time_offset(), submit_branch,
5729
5117
self.outf.writelines(directive.to_lines())
5730
5118
else:
5731
5119
message = directive.to_email(mail_to, branch, sign)
5732
s = SMTPConnection(branch.get_config_stack())
5120
s = SMTPConnection(branch.get_config())
5733
5121
s.send_email(message)
5734
5122
5735
5123
5765
5153
source branch defaults to that containing the working directory, but can
5766
5154
be changed using --from.
5767
5155
5768
Both the submit branch and the public branch follow the usual behavior with
5769
respect to --remember: If there is no default location set, the first send
5770
will set it (use --no-remember to avoid setting it). After that, you can
5771
omit the location to use the default. To change the default, use
5772
--remember. The value will only be saved if the location can be accessed.
5773
5774
5156
In order to calculate those changes, bzr must analyse the submit branch.
5775
5157
Therefore it is most efficient for the submit branch to be a local mirror.
5776
5158
If a public location is known for the submit_branch, that location is used
5780
5162
given, in which case it is sent to a file.
5781
5163
5782
5164
Mail is sent using your preferred mail program. This should be transparent
5783
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5165
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5784
5166
If the preferred client can't be found (or used), your editor will be used.
5785
5167
5786
5168
To use a specific mail program, set the mail_client configuration option.
5845
5227
]
5846
5228
5847
5229
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5848
no_patch=False, revision=None, remember=None, output=None,
5230
no_patch=False, revision=None, remember=False, output=None,
5849
5231
format=None, mail_to=None, message=None, body=None,
5850
5232
strict=None, **kwargs):
5851
5233
from bzrlib.send import send
5957
5339
Option('delete',
5958
5340
help='Delete this tag rather than placing it.',
5959
5341
),
5960
custom_help('directory',
5961
help='Branch in which to place the tag.'),
5342
Option('directory',
5343
help='Branch in which to place the tag.',
5344
short_name='d',
5345
type=unicode,
5346
),
5962
5347
Option('force',
5963
5348
help='Replace existing tags.',
5964
5349
),
5972
5357
revision=None,
5973
5358
):
5974
5359
branch, relpath = Branch.open_containing(directory)
5975
self.add_cleanup(branch.lock_write().unlock)
5360
branch.lock_write()
5361
self.add_cleanup(branch.unlock)
5976
5362
if delete:
5977
5363
if tag_name is None:
5978
raise errors.BzrCommandError(gettext("No tag specified to delete."))
5364
raise errors.BzrCommandError("No tag specified to delete.")
5979
5365
branch.tags.delete_tag(tag_name)
5980
note(gettext('Deleted tag %s.') % tag_name)
5366
self.outf.write('Deleted tag %s.\n' % tag_name)
5981
5367
else:
5982
5368
if revision:
5983
5369
if len(revision) != 1:
5984
raise errors.BzrCommandError(gettext(
5370
raise errors.BzrCommandError(
5985
5371
"Tags can only be placed on a single revision, "
5986
"not on a range"))
5372
"not on a range")
5987
5373
revision_id = revision[0].as_revision_id(branch)
5988
5374
else:
5989
5375
revision_id = branch.last_revision()
5990
5376
if tag_name is None:
5991
5377
tag_name = branch.automatic_tag_name(revision_id)
5992
5378
if tag_name is None:
5993
raise errors.BzrCommandError(gettext(
5994
"Please specify a tag name."))
5995
try:
5996
existing_target = branch.tags.lookup_tag(tag_name)
5997
except errors.NoSuchTag:
5998
existing_target = None
5999
if not force and existing_target not in (None, revision_id):
5379
raise errors.BzrCommandError(
5380
"Please specify a tag name.")
5381
if (not force) and branch.tags.has_tag(tag_name):
6000
5382
raise errors.TagAlreadyExists(tag_name)
6001
if existing_target == revision_id:
6002
note(gettext('Tag %s already exists for that revision.') % tag_name)
6003
else:
6004
branch.tags.set_tag(tag_name, revision_id)
6005
if existing_target is None:
6006
note(gettext('Created tag %s.') % tag_name)
6007
else:
6008
note(gettext('Updated tag %s.') % tag_name)
5383
branch.tags.set_tag(tag_name, revision_id)
5384
self.outf.write('Created tag %s.\n' % tag_name)
6009
5385
6010
5386
6011
5387
class cmd_tags(Command):
6016
5392
6017
5393
_see_also = ['tag']
6018
5394
takes_options = [
6019
custom_help('directory',
6020
help='Branch whose tags should be displayed.'),
6021
RegistryOption('sort',
5395
Option('directory',
5396
help='Branch whose tags should be displayed.',
5397
short_name='d',
5398
type=unicode,
5399
),
5400
RegistryOption.from_kwargs('sort',
6022
5401
'Sort tags by different criteria.', title='Sorting',
6023
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5402
alpha='Sort tags lexicographically (default).',
5403
time='Sort tags chronologically.',
6024
5404
),
6025
5405
'show-ids',
6026
5406
'revision',
6027
5407
]
6028
5408
6029
5409
@display_command
6030
def run(self, directory='.', sort=None, show_ids=False, revision=None):
6031
from bzrlib.tag import tag_sort_methods
5410
def run(self,
5411
directory='.',
5412
sort='alpha',
5413
show_ids=False,
5414
revision=None,
5415
):
6032
5416
branch, relpath = Branch.open_containing(directory)
6033
5417
6034
5418
tags = branch.tags.get_tag_dict().items()
6035
5419
if not tags:
6036
5420
return
6037
5421
6038
self.add_cleanup(branch.lock_read().unlock)
5422
branch.lock_read()
5423
self.add_cleanup(branch.unlock)
6039
5424
if revision:
6040
# Restrict to the specified range
6041
tags = self._tags_for_range(branch, revision)
6042
if sort is None:
6043
sort = tag_sort_methods.get()
6044
sort(branch, tags)
5425
graph = branch.repository.get_graph()
5426
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5427
revid1, revid2 = rev1.rev_id, rev2.rev_id
5428
# only show revisions between revid1 and revid2 (inclusive)
5429
tags = [(tag, revid) for tag, revid in tags if
5430
graph.is_between(revid, revid1, revid2)]
5431
if sort == 'alpha':
5432
tags.sort()
5433
elif sort == 'time':
5434
timestamps = {}
5435
for tag, revid in tags:
5436
try:
5437
revobj = branch.repository.get_revision(revid)
5438
except errors.NoSuchRevision:
5439
timestamp = sys.maxint # place them at the end
5440
else:
5441
timestamp = revobj.timestamp
5442
timestamps[revid] = timestamp
5443
tags.sort(key=lambda x: timestamps[x[1]])
6045
5444
if not show_ids:
6046
5445
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
6047
5446
for index, (tag, revid) in enumerate(tags):
6049
5448
revno = branch.revision_id_to_dotted_revno(revid)
6050
5449
if isinstance(revno, tuple):
6051
5450
revno = '.'.join(map(str, revno))
6052
except (errors.NoSuchRevision,
6053
errors.GhostRevisionsHaveNoRevno,
6054
errors.UnsupportedOperation):
5451
except errors.NoSuchRevision:
6055
5452
# Bad tag data/merges can lead to tagged revisions
6056
5453
# which are not in this branch. Fail gracefully ...
6057
5454
revno = '?'
6060
5457
for tag, revspec in tags:
6061
5458
self.outf.write('%-20s %s\n' % (tag, revspec))
6062
5459
6063
def _tags_for_range(self, branch, revision):
6064
range_valid = True
6065
rev1, rev2 = _get_revision_range(revision, branch, self.name())
6066
revid1, revid2 = rev1.rev_id, rev2.rev_id
6067
# _get_revision_range will always set revid2 if it's not specified.
6068
# If revid1 is None, it means we want to start from the branch
6069
# origin which is always a valid ancestor. If revid1 == revid2, the
6070
# ancestry check is useless.
6071
if revid1 and revid1 != revid2:
6072
# FIXME: We really want to use the same graph than
6073
# branch.iter_merge_sorted_revisions below, but this is not
6074
# easily available -- vila 2011-09-23
6075
if branch.repository.get_graph().is_ancestor(revid2, revid1):
6076
# We don't want to output anything in this case...
6077
return []
6078
# only show revisions between revid1 and revid2 (inclusive)
6079
tagged_revids = branch.tags.get_reverse_tag_dict()
6080
found = []
6081
for r in branch.iter_merge_sorted_revisions(
6082
start_revision_id=revid2, stop_revision_id=revid1,
6083
stop_rule='include'):
6084
revid_tags = tagged_revids.get(r[0], None)
6085
if revid_tags:
6086
found.extend([(tag, r[0]) for tag in revid_tags])
6087
return found
6088
6089
5460
6090
5461
class cmd_reconfigure(Command):
6091
5462
__doc__ = """Reconfigure the type of a bzr directory.
6105
5476
takes_args = ['location?']
6106
5477
takes_options = [
6107
5478
RegistryOption.from_kwargs(
6108
'tree_type',
6109
title='Tree type',
6110
help='The relation between branch and tree.',
5479
'target_type',
5480
title='Target type',
5481
help='The type to reconfigure the directory to.',
6111
5482
value_switches=True, enum_switch=False,
6112
5483
branch='Reconfigure to be an unbound branch with no working tree.',
6113
5484
tree='Reconfigure to be an unbound branch with a working tree.',
6114
5485
checkout='Reconfigure to be a bound branch with a working tree.',
6115
5486
lightweight_checkout='Reconfigure to be a lightweight'
6116
5487
' checkout (with no local history).',
6117
),
6118
RegistryOption.from_kwargs(
6119
'repository_type',
6120
title='Repository type',
6121
help='Location fo the repository.',
6122
value_switches=True, enum_switch=False,
6123
5488
standalone='Reconfigure to be a standalone branch '
6124
5489
'(i.e. stop using shared repository).',
6125
5490
use_shared='Reconfigure to use a shared repository.',
6126
),
6127
RegistryOption.from_kwargs(
6128
'repository_trees',
6129
title='Trees in Repository',
6130
help='Whether new branches in the repository have trees.',
6131
value_switches=True, enum_switch=False,
6132
5491
with_trees='Reconfigure repository to create '
6133
5492
'working trees on branches by default.',
6134
5493
with_no_trees='Reconfigure repository to not create '
6148
5507
),
6149
5508
]
6150
5509
6151
def run(self, location=None, bind_to=None, force=False,
6152
tree_type=None, repository_type=None, repository_trees=None,
6153
stacked_on=None, unstacked=None):
6154
directory = controldir.ControlDir.open(location)
5510
def run(self, location=None, target_type=None, bind_to=None, force=False,
5511
stacked_on=None,
5512
unstacked=None):
5513
directory = bzrdir.BzrDir.open(location)
6155
5514
if stacked_on and unstacked:
6156
raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5515
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
6157
5516
elif stacked_on is not None:
6158
5517
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
6159
5518
elif unstacked:
6161
5520
# At the moment you can use --stacked-on and a different
6162
5521
# reconfiguration shape at the same time; there seems no good reason
6163
5522
# to ban it.
6164
if (tree_type is None and
6165
repository_type is None and
6166
repository_trees is None):
5523
if target_type is None:
6167
5524
if stacked_on or unstacked:
6168
5525
return
6169
5526
else:
6170
raise errors.BzrCommandError(gettext('No target configuration '
6171
'specified'))
6172
reconfiguration = None
6173
if tree_type == 'branch':
5527
raise errors.BzrCommandError('No target configuration '
5528
'specified')
5529
elif target_type == 'branch':
6174
5530
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
6175
elif tree_type == 'tree':
5531
elif target_type == 'tree':
6176
5532
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
6177
elif tree_type == 'checkout':
5533
elif target_type == 'checkout':
6178
5534
reconfiguration = reconfigure.Reconfigure.to_checkout(
6179
5535
directory, bind_to)
6180
elif tree_type == 'lightweight-checkout':
5536
elif target_type == 'lightweight-checkout':
6181
5537
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
6182
5538
directory, bind_to)
6183
if reconfiguration:
6184
reconfiguration.apply(force)
6185
reconfiguration = None
6186
if repository_type == 'use-shared':
5539
elif target_type == 'use-shared':
6187
5540
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
6188
elif repository_type == 'standalone':
5541
elif target_type == 'standalone':
6189
5542
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
6190
if reconfiguration:
6191
reconfiguration.apply(force)
6192
reconfiguration = None
6193
if repository_trees == 'with-trees':
5543
elif target_type == 'with-trees':
6194
5544
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
6195
5545
directory, True)
6196
elif repository_trees == 'with-no-trees':
5546
elif target_type == 'with-no-trees':
6197
5547
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
6198
5548
directory, False)
6199
if reconfiguration:
6200
reconfiguration.apply(force)
6201
reconfiguration = None
5549
reconfiguration.apply(force)
6202
5550
6203
5551
6204
5552
class cmd_switch(Command):
6225
5573
"""
6226
5574
6227
5575
takes_args = ['to_location?']
6228
takes_options = ['directory',
6229
Option('force',
5576
takes_options = [Option('force',
6230
5577
help='Switch even if local commits will be lost.'),
6231
5578
'revision',
6232
5579
Option('create-branch', short_name='b',
6233
5580
help='Create the target branch from this one before'
6234
5581
' switching to it.'),
6235
Option('store',
6236
help='Store and restore uncommitted changes in the'
6237
' branch.'),
6238
5582
]
6239
5583
6240
5584
def run(self, to_location=None, force=False, create_branch=False,
6241
revision=None, directory=u'.', store=False):
5585
revision=None):
6242
5586
from bzrlib import switch
6243
tree_location = directory
5587
tree_location = '.'
6244
5588
revision = _get_one_revision('switch', revision)
6245
possible_transports = []
6246
control_dir = controldir.ControlDir.open_containing(tree_location,
6247
possible_transports=possible_transports)[0]
5589
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
6248
5590
if to_location is None:
6249
5591
if revision is None:
6250
raise errors.BzrCommandError(gettext('You must supply either a'
6251
' revision or a location'))
6252
to_location = tree_location
5592
raise errors.BzrCommandError('You must supply either a'
5593
' revision or a location')
5594
to_location = '.'
6253
5595
try:
6254
branch = control_dir.open_branch(
6255
possible_transports=possible_transports)
5596
branch = control_dir.open_branch()
6256
5597
had_explicit_nick = branch.get_config().has_explicit_nickname()
6257
5598
except errors.NotBranchError:
6258
5599
branch = None
6259
5600
had_explicit_nick = False
6260
5601
if create_branch:
6261
5602
if branch is None:
6262
raise errors.BzrCommandError(
6263
gettext('cannot create branch without source branch'))
6264
to_location = lookup_new_sibling_branch(control_dir, to_location,
6265
possible_transports=possible_transports)
5603
raise errors.BzrCommandError('cannot create branch without'
5604
' source branch')
5605
to_location = directory_service.directories.dereference(
5606
to_location)
5607
if '/' not in to_location and '\\' not in to_location:
5608
# This path is meant to be relative to the existing branch
5609
this_url = self._get_branch_location(control_dir)
5610
to_location = urlutils.join(this_url, '..', to_location)
6266
5611
to_branch = branch.bzrdir.sprout(to_location,
6267
possible_transports=possible_transports,
6268
source_branch=branch).open_branch()
5612
possible_transports=[branch.bzrdir.root_transport],
5613
source_branch=branch).open_branch()
6269
5614
else:
6270
5615
try:
6271
to_branch = Branch.open(to_location,
6272
possible_transports=possible_transports)
5616
to_branch = Branch.open(to_location)
6273
5617
except errors.NotBranchError:
6274
to_branch = open_sibling_branch(control_dir, to_location,
6275
possible_transports=possible_transports)
5618
this_url = self._get_branch_location(control_dir)
5619
to_branch = Branch.open(
5620
urlutils.join(this_url, '..', to_location))
6276
5621
if revision is not None:
6277
5622
revision = revision.as_revision_id(to_branch)
6278
switch.switch(control_dir, to_branch, force, revision_id=revision,
6279
store_uncommitted=store)
5623
switch.switch(control_dir, to_branch, force, revision_id=revision)
6280
5624
if had_explicit_nick:
6281
5625
branch = control_dir.open_branch() #get the new branch!
6282
5626
branch.nick = to_branch.nick
6283
note(gettext('Switched to branch: %s'),
5627
note('Switched to branch: %s',
6284
5628
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
6285
5629
5630
def _get_branch_location(self, control_dir):
5631
"""Return location of branch for this control dir."""
5632
try:
5633
this_branch = control_dir.open_branch()
5634
# This may be a heavy checkout, where we want the master branch
5635
master_location = this_branch.get_bound_location()
5636
if master_location is not None:
5637
return master_location
5638
# If not, use a local sibling
5639
return this_branch.base
5640
except errors.NotBranchError:
5641
format = control_dir.find_branch_format()
5642
if getattr(format, 'get_reference', None) is not None:
5643
return format.get_reference(control_dir)
5644
else:
5645
return control_dir.root_transport.base
6286
5646
6287
5647
6288
5648
class cmd_view(Command):
6372
5732
name=None,
6373
5733
switch=None,
6374
5734
):
6375
tree, file_list = WorkingTree.open_containing_paths(file_list,
6376
apply_view=False)
5735
tree, file_list = tree_files(file_list, apply_view=False)
6377
5736
current_view, view_dict = tree.views.get_view_info()
6378
5737
if name is None:
6379
5738
name = current_view
6380
5739
if delete:
6381
5740
if file_list:
6382
raise errors.BzrCommandError(gettext(
6383
"Both --delete and a file list specified"))
5741
raise errors.BzrCommandError(
5742
"Both --delete and a file list specified")
6384
5743
elif switch:
6385
raise errors.BzrCommandError(gettext(
6386
"Both --delete and --switch specified"))
5744
raise errors.BzrCommandError(
5745
"Both --delete and --switch specified")
6387
5746
elif all:
6388
5747
tree.views.set_view_info(None, {})
6389
self.outf.write(gettext("Deleted all views.\n"))
5748
self.outf.write("Deleted all views.\n")
6390
5749
elif name is None:
6391
raise errors.BzrCommandError(gettext("No current view to delete"))
5750
raise errors.BzrCommandError("No current view to delete")
6392
5751
else:
6393
5752
tree.views.delete_view(name)
6394
self.outf.write(gettext("Deleted '%s' view.\n") % name)
5753
self.outf.write("Deleted '%s' view.\n" % name)
6395
5754
elif switch:
6396
5755
if file_list:
6397
raise errors.BzrCommandError(gettext(
6398
"Both --switch and a file list specified"))
5756
raise errors.BzrCommandError(
5757
"Both --switch and a file list specified")
6399
5758
elif all:
6400
raise errors.BzrCommandError(gettext(
6401
"Both --switch and --all specified"))
5759
raise errors.BzrCommandError(
5760
"Both --switch and --all specified")
6402
5761
elif switch == 'off':
6403
5762
if current_view is None:
6404
raise errors.BzrCommandError(gettext("No current view to disable"))
5763
raise errors.BzrCommandError("No current view to disable")
6405
5764
tree.views.set_view_info(None, view_dict)
6406
self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5765
self.outf.write("Disabled '%s' view.\n" % (current_view))
6407
5766
else:
6408
5767
tree.views.set_view_info(switch, view_dict)
6409
5768
view_str = views.view_display_str(tree.views.lookup_view())
6410
self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
5769
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
6411
5770
elif all:
6412
5771
if view_dict:
6413
self.outf.write(gettext('Views defined:\n'))
5772
self.outf.write('Views defined:\n')
6414
5773
for view in sorted(view_dict):
6415
5774
if view == current_view:
6416
5775
active = "=>"
6419
5778
view_str = views.view_display_str(view_dict[view])
6420
5779
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
6421
5780
else:
6422
self.outf.write(gettext('No views defined.\n'))
5781
self.outf.write('No views defined.\n')
6423
5782
elif file_list:
6424
5783
if name is None:
6425
5784
# No name given and no current view set
6426
5785
name = 'my'
6427
5786
elif name == 'off':
6428
raise errors.BzrCommandError(gettext(
6429
"Cannot change the 'off' pseudo view"))
5787
raise errors.BzrCommandError(
5788
"Cannot change the 'off' pseudo view")
6430
5789
tree.views.set_view(name, sorted(file_list))
6431
5790
view_str = views.view_display_str(tree.views.lookup_view())
6432
self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
5791
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
6433
5792
else:
6434
5793
# list the files
6435
5794
if name is None:
6436
5795
# No name given and no current view set
6437
self.outf.write(gettext('No current view.\n'))
5796
self.outf.write('No current view.\n')
6438
5797
else:
6439
5798
view_str = views.view_display_str(tree.views.lookup_view(name))
6440
self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
5799
self.outf.write("'%s' view is: %s\n" % (name, view_str))
6441
5800
6442
5801
6443
5802
class cmd_hooks(Command):
6457
5816
self.outf.write(" %s\n" %
6458
5817
(some_hooks.get_hook_name(hook),))
6459
5818
else:
6460
self.outf.write(gettext(" <no hooks installed>\n"))
5819
self.outf.write(" <no hooks installed>\n")
6461
5820
6462
5821
6463
5822
class cmd_remove_branch(Command):
6476
5835
6477
5836
takes_args = ["location?"]
6478
5837
6479
takes_options = ['directory',
6480
Option('force', help='Remove branch even if it is the active branch.')]
6481
6482
5838
aliases = ["rmbranch"]
6483
5839
6484
def run(self, directory=None, location=None, force=False):
6485
br = open_nearby_branch(near=directory, location=location)
6486
if not force and br.bzrdir.has_workingtree():
6487
try:
6488
active_branch = br.bzrdir.open_branch(name="")
6489
except errors.NotBranchError:
6490
active_branch = None
6491
if (active_branch is not None and
6492
br.control_url == active_branch.control_url):
6493
raise errors.BzrCommandError(
6494
gettext("Branch is active. Use --force to remove it."))
6495
br.bzrdir.destroy_branch(br.name)
6496
5840
def run(self, location=None):
5841
if location is None:
5842
location = "."
5843
branch = Branch.open_containing(location)[0]
5844
branch.bzrdir.destroy_branch()
5845
6497
5846
6498
5847
class cmd_shelve(Command):
6499
5848
__doc__ = """Temporarily set aside some changes from the current tree.
6518
5867
6519
5868
You can put multiple items on the shelf, and by default, 'unshelve' will
6520
5869
restore the most recently shelved changes.
6521
6522
For complicated changes, it is possible to edit the changes in a separate
6523
editor program to decide what the file remaining in the working copy
6524
should look like. To do this, add the configuration option
6525
6526
change_editor = PROGRAM @new_path @old_path
6527
6528
where @new_path is replaced with the path of the new version of the
6529
file and @old_path is replaced with the path of the old version of
6530
the file. The PROGRAM should save the new file with the desired
6531
contents of the file in the working tree.
6532
6533
5870
"""
6534
5871
6535
5872
takes_args = ['file*']
6536
5873
6537
5874
takes_options = [
6538
'directory',
6539
5875
'revision',
6540
5876
Option('all', help='Shelve all changes.'),
6541
5877
'message',
6547
5883
Option('destroy',
6548
5884
help='Destroy removed changes instead of shelving them.'),
6549
5885
]
6550
_see_also = ['unshelve', 'configuration']
5886
_see_also = ['unshelve']
6551
5887
6552
5888
def run(self, revision=None, all=False, file_list=None, message=None,
6553
writer=None, list=False, destroy=False, directory=None):
5889
writer=None, list=False, destroy=False):
6554
5890
if list:
6555
return self.run_for_list(directory=directory)
5891
return self.run_for_list()
6556
5892
from bzrlib.shelf_ui import Shelver
6557
5893
if writer is None:
6558
5894
writer = bzrlib.option.diff_writer_registry.get()
6559
5895
try:
6560
5896
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6561
file_list, message, destroy=destroy, directory=directory)
5897
file_list, message, destroy=destroy)
6562
5898
try:
6563
5899
shelver.run()
6564
5900
finally:
6566
5902
except errors.UserAbort:
6567
5903
return 0
6568
5904
6569
def run_for_list(self, directory=None):
6570
if directory is None:
6571
directory = u'.'
6572
tree = WorkingTree.open_containing(directory)[0]
6573
self.add_cleanup(tree.lock_read().unlock)
5905
def run_for_list(self):
5906
tree = WorkingTree.open_containing('.')[0]
5907
tree.lock_read()
5908
self.add_cleanup(tree.unlock)
6574
5909
manager = tree.get_shelf_manager()
6575
5910
shelves = manager.active_shelves()
6576
5911
if len(shelves) == 0:
6577
note(gettext('No shelved changes.'))
5912
note('No shelved changes.')
6578
5913
return 0
6579
5914
for shelf_id in reversed(shelves):
6580
5915
message = manager.get_metadata(shelf_id).get('message')
6594
5929
6595
5930
takes_args = ['shelf_id?']
6596
5931
takes_options = [
6597
'directory',
6598
5932
RegistryOption.from_kwargs(
6599
5933
'action', help="The action to perform.",
6600
5934
enum_switch=False, value_switches=True,
6608
5942
]
6609
5943
_see_also = ['shelve']
6610
5944
6611
def run(self, shelf_id=None, action='apply', directory=u'.'):
5945
def run(self, shelf_id=None, action='apply'):
6612
5946
from bzrlib.shelf_ui import Unshelver
6613
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5947
unshelver = Unshelver.from_args(shelf_id, action)
6614
5948
try:
6615
5949
unshelver.run()
6616
5950
finally:
6632
5966
6633
5967
To check what clean-tree will do, use --dry-run.
6634
5968
"""
6635
takes_options = ['directory',
6636
Option('ignored', help='Delete all ignored files.'),
6637
Option('detritus', help='Delete conflict files, merge and revert'
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5970
Option('detritus', help='Delete conflict files, merge'
6638
5971
' backups, and failed selftest dirs.'),
6639
5972
Option('unknown',
6640
5973
help='Delete files unknown to bzr (default).'),
6642
5975
' deleting them.'),
6643
5976
Option('force', help='Do not prompt before deleting.')]
6644
5977
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6645
force=False, directory=u'.'):
5978
force=False):
6646
5979
from bzrlib.clean_tree import clean_tree
6647
5980
if not (unknown or ignored or detritus):
6648
5981
unknown = True
6649
5982
if dry_run:
6650
5983
force = True
6651
clean_tree(directory, unknown=unknown, ignored=ignored,
6652
detritus=detritus, dry_run=dry_run, no_prompt=force)
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
6653
5986
6654
5987
6655
5988
class cmd_reference(Command):
6669
6002
if path is not None:
6670
6003
branchdir = path
6671
6004
tree, branch, relpath =(
6672
controldir.ControlDir.open_containing_tree_or_branch(branchdir))
6005
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
6673
6006
if path is not None:
6674
6007
path = relpath
6675
6008
if tree is None:
6699
6032
self.outf.write('%s %s\n' % (path, location))
6700
6033
6701
6034
6702
class cmd_export_pot(Command):
6703
__doc__ = """Export command helps and error messages in po format."""
6704
6705
hidden = True
6706
takes_options = [Option('plugin',
6707
help='Export help text from named command '\
6708
'(defaults to all built in commands).',
6709
type=str),
6710
Option('include-duplicates',
6711
help='Output multiple copies of the same msgid '
6712
'string if it appears more than once.'),
6713
]
6714
6715
def run(self, plugin=None, include_duplicates=False):
6716
from bzrlib.export_pot import export_pot
6717
export_pot(self.outf, plugin, include_duplicates)
6718
6719
6720
6035
def _register_lazy_builtins():
6721
6036
# register lazy builtins from other modules; called at startup and should
6722
6037
# be only called once.
6723
6038
for (name, aliases, module_name) in [
6724
6039
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6725
('cmd_config', [], 'bzrlib.config'),
6726
6040
('cmd_dpush', [], 'bzrlib.foreign'),
6727
6041
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6728
6042
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6729
6043
('cmd_conflicts', [], 'bzrlib.conflicts'),
6730
('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6731
('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
6732
('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6044
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6733
6045
]:
6734
6046
builtin_command_registry.register_lazy(name, aliases, module_name)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0