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