« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 6605
- compare with another revision
- download diff
- download tarball
- view history from revision 6605
- Committer: Patch Queue Manager
- Date: 2015-09-30 16:43:21 UTC
- mfrom: (6603.2.2 fix-keep-dirty)
- Revision ID: pqm@pqm.ubuntu.com-20150930164321-ct2v2qnmvimqt8qf
(vila) Avoid associating dirty patch headers with the previous file in the
patch. (Colin Watson)
patch. (Colin Watson)
- files added:
- NEWS
- bzrlib/branchfmt
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/grep
- 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
239
312
# opens the branch?)
240
313
241
314
class cmd_status(Command):
242
"""Display status summary.
315
__doc__ = """Display status summary.
243
316
244
317
This reports on versioned and unknown files, reporting them
245
318
grouped by state. Possible states are:
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):
335
"""Write out metadata for a revision.
418
__doc__ = """Write out metadata for a revision.
336
419
337
420
The revision to print can either be specified by a specific
338
421
revision identifier, or you can use --revision.
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:
390
474
391
475
392
476
class cmd_dump_btree(Command):
393
"""Dump the contents of a btree index file to stdout.
477
__doc__ = """Dump the contents of a btree index file to stdout.
394
478
395
479
PATH is a btree index file, it can be any URL. This includes things like
396
480
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
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:
471
558
472
559
473
560
class cmd_remove_tree(Command):
474
"""Remove the working tree from a given branch/checkout.
561
__doc__ = """Remove the working tree from a given branch/checkout.
475
562
476
563
Since a lightweight checkout is little more than a working tree
477
564
this will refuse to run against one.
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
working_path = working.bzrdir.root_transport.base
508
branch_path = working.branch.bzrdir.root_transport.base
509
if working_path != branch_path:
510
raise errors.BzrCommandError("You cannot remove the working tree"
511
" from a lightweight checkout")
596
if working.user_url != working.branch.user_url:
597
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
598
" from a lightweight checkout"))
512
599
513
600
d.destroy_workingtree()
514
601
515
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
516
655
class cmd_revno(Command):
517
"""Show current revision number.
656
__doc__ = """Show current revision number.
518
657
519
658
This is equal to the number of revisions on this branch.
520
659
"""
522
661
_see_also = ['info']
523
662
takes_args = ['location?']
524
663
takes_options = [
525
Option('tree', help='Show revno of working tree'),
664
Option('tree', help='Show revno of working tree.'),
665
'revision',
526
666
]
527
667
528
668
@display_command
529
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
530
674
if tree:
531
675
try:
532
676
wt = WorkingTree.open_containing(location)[0]
533
wt.lock_read()
677
self.add_cleanup(wt.lock_read().unlock)
534
678
except (errors.NoWorkingTree, errors.NotLocalUrl):
535
679
raise errors.NoWorkingTree(location)
536
self.add_cleanup(wt.unlock)
680
b = wt.branch
537
681
revid = wt.last_revision()
538
try:
539
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
540
except errors.NoSuchRevision:
541
revno_t = ('???',)
542
revno = ".".join(str(n) for n in revno_t)
543
682
else:
544
683
b = Branch.open_containing(location)[0]
545
b.lock_read()
546
self.add_cleanup(b.unlock)
547
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
"Revision numbers only make sense for single "
689
"revisions, not ranges"))
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)
548
698
self.cleanup_now()
549
self.outf.write(str(revno) + '\n')
699
self.outf.write(revno + '\n')
550
700
551
701
552
702
class cmd_revision_info(Command):
553
"""Show revision number and revision id for a given revision identifier.
703
__doc__ = """Show revision number and revision id for a given revision identifier.
554
704
"""
555
705
hidden = True
556
706
takes_args = ['revision_info*']
557
707
takes_options = [
558
708
'revision',
559
Option('directory',
709
custom_help('directory',
560
710
help='Branch to examine, '
561
'rather than the one containing the working directory.',
562
short_name='d',
563
type=unicode,
564
),
565
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.'),
566
713
]
567
714
568
715
@display_command
572
719
try:
573
720
wt = WorkingTree.open_containing(directory)[0]
574
721
b = wt.branch
575
wt.lock_read()
576
self.add_cleanup(wt.unlock)
722
self.add_cleanup(wt.lock_read().unlock)
577
723
except (errors.NoWorkingTree, errors.NotLocalUrl):
578
724
wt = None
579
725
b = Branch.open_containing(directory)[0]
580
b.lock_read()
581
self.add_cleanup(b.unlock)
726
self.add_cleanup(b.lock_read().unlock)
582
727
revision_ids = []
583
728
if revision is not None:
584
729
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
612
757
613
758
614
759
class cmd_add(Command):
615
"""Add specified files or directories.
760
__doc__ = """Add specified files or directories.
616
761
617
762
In non-recursive mode, all the named items are added, regardless
618
763
of whether they were previously ignored. A warning is given if
626
771
are added. This search proceeds recursively into versioned
627
772
directories. If no names are given '.' is assumed.
628
773
774
A warning will be printed when nested trees are encountered,
775
unless they are explicitly ignored.
776
629
777
Therefore simply saying 'bzr add' will version all files that
630
778
are currently unknown.
631
779
647
795
648
796
Any files matching patterns in the ignore list will not be added
649
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.
650
802
"""
651
803
takes_args = ['file*']
652
804
takes_options = [
653
805
Option('no-recurse',
654
help="Don't recursively add the contents of directories."),
806
help="Don't recursively add the contents of directories.",
807
short_name='N'),
655
808
Option('dry-run',
656
809
help="Show what would be done, but don't actually do anything."),
657
810
'verbose',
679
832
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
680
833
to_file=self.outf, should_print=(not is_quiet()))
681
834
else:
682
action = bzrlib.add.AddAction(to_file=self.outf,
835
action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
683
836
should_print=(not is_quiet()))
684
837
685
838
if base_tree:
686
base_tree.lock_read()
687
self.add_cleanup(base_tree.unlock)
839
self.add_cleanup(base_tree.lock_read().unlock)
688
840
tree, file_list = tree_files_for_add(file_list)
689
841
added, ignored = tree.smart_add(file_list, not
690
842
no_recurse, action=action, save=not dry_run)
693
845
if verbose:
694
846
for glob in sorted(ignored.keys()):
695
847
for path in ignored[glob]:
696
self.outf.write("ignored %s matching \"%s\"\n"
697
% (path, glob))
848
self.outf.write(
849
gettext("ignored {0} matching \"{1}\"\n").format(
850
path, glob))
698
851
699
852
700
853
class cmd_mkdir(Command):
701
"""Create a new versioned directory.
854
__doc__ = """Create a new versioned directory.
702
855
703
856
This is equivalent to creating the directory and then adding it.
704
857
"""
705
858
706
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
]
707
867
encoding_type = 'replace'
708
868
709
def run(self, dir_list):
710
for d in dir_list:
711
wt, dd = WorkingTree.open_containing(d)
712
base = os.path.dirname(dd)
713
id = wt.path2id(base)
714
if id != None:
715
os.mkdir(d)
716
wt.add([dd])
717
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
718
893
else:
719
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)
720
898
721
899
722
900
class cmd_relpath(Command):
723
"""Show path of a file relative to root"""
901
__doc__ = """Show path of a file relative to root"""
724
902
725
903
takes_args = ['filename']
726
904
hidden = True
735
913
736
914
737
915
class cmd_inventory(Command):
738
"""Show inventory of the current working copy or a revision.
916
__doc__ = """Show inventory of the current working copy or a revision.
739
917
740
918
It is possible to limit the output to a particular entry
741
919
type using the --kind option. For example: --kind file.
758
936
@display_command
759
937
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
760
938
if kind and kind not in ['file', 'directory', 'symlink']:
761
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
939
raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
762
940
763
941
revision = _get_one_revision('inventory', revision)
764
work_tree, file_list = tree_files(file_list)
765
work_tree.lock_read()
766
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)
767
944
if revision is not None:
768
945
tree = revision.as_tree(work_tree.branch)
769
946
770
947
extra_trees = [work_tree]
771
tree.lock_read()
772
self.add_cleanup(tree.unlock)
948
self.add_cleanup(tree.lock_read().unlock)
773
949
else:
774
950
tree = work_tree
775
951
extra_trees = []
776
952
953
self.add_cleanup(tree.lock_read().unlock)
777
954
if file_list is not None:
778
955
file_ids = tree.paths2ids(file_list, trees=extra_trees,
779
956
require_versioned=True)
780
957
# find_ids_across_trees may include some paths that don't
781
958
# exist in 'tree'.
782
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
783
for file_id in file_ids if file_id in tree)
959
entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
784
960
else:
785
entries = tree.inventory.entries()
961
entries = tree.iter_entries_by_dir()
786
962
787
self.cleanup_now()
788
for path, entry in entries:
963
for path, entry in sorted(entries):
789
964
if kind and kind != entry.kind:
790
965
continue
966
if path == "":
967
continue
791
968
if show_ids:
792
969
self.outf.write('%-50s %s\n' % (path, entry.file_id))
793
970
else:
796
973
797
974
798
975
class cmd_mv(Command):
799
"""Move or rename a file.
976
__doc__ = """Move or rename a file.
800
977
801
978
:Usage:
802
979
bzr mv OLDNAME NEWNAME
829
1006
if auto:
830
1007
return self.run_auto(names_list, after, dry_run)
831
1008
elif dry_run:
832
raise errors.BzrCommandError('--dry-run requires --auto.')
1009
raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
833
1010
if names_list is None:
834
1011
names_list = []
835
1012
if len(names_list) < 2:
836
raise errors.BzrCommandError("missing file argument")
837
tree, rel_names = tree_files(names_list, canonicalize=False)
838
tree.lock_tree_write()
839
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)
840
1019
self._run(tree, names_list, rel_names, after)
841
1020
842
1021
def run_auto(self, names_list, after, dry_run):
843
1022
if names_list is not None and len(names_list) > 1:
844
raise errors.BzrCommandError('Only one path may be specified to'
845
' --auto.')
1023
raise errors.BzrCommandError(gettext('Only one path may be specified to'
1024
' --auto.'))
846
1025
if after:
847
raise errors.BzrCommandError('--after cannot be specified with'
848
' --auto.')
849
work_tree, file_list = tree_files(names_list, default_branch='.')
850
work_tree.lock_tree_write()
851
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)
852
1031
rename_map.RenameMap.guess_renames(work_tree, dry_run)
853
1032
854
1033
def _run(self, tree, names_list, rel_names, after):
863
1042
and rel_names[0].lower() == rel_names[1].lower()):
864
1043
into_existing = False
865
1044
else:
866
inv = tree.inventory
867
1045
# 'fix' the case of a potential 'from'
868
1046
from_id = tree.path2id(
869
1047
tree.get_canonical_inventory_path(rel_names[0]))
870
1048
if (not osutils.lexists(names_list[0]) and
871
from_id and inv.get_file_kind(from_id) == "directory"):
1049
from_id and tree.stored_kind(from_id) == "directory"):
872
1050
into_existing = False
873
1051
# move/rename
874
1052
if into_existing:
881
1059
self.outf.write("%s => %s\n" % (src, dest))
882
1060
else:
883
1061
if len(names_list) != 2:
884
raise errors.BzrCommandError('to mv multiple files the'
1062
raise errors.BzrCommandError(gettext('to mv multiple files the'
885
1063
' destination must be a versioned'
886
' directory')
1064
' directory'))
887
1065
888
1066
# for cicp file-systems: the src references an existing inventory
889
1067
# item:
933
1111
934
1112
935
1113
class cmd_pull(Command):
936
"""Turn this branch into a mirror of another branch.
1114
__doc__ = """Turn this branch into a mirror of another branch.
937
1115
938
1116
By default, this command only works on branches that have not diverged.
939
1117
Branches are considered diverged if the destination branch's most recent
948
1126
match the remote one, use pull --overwrite. This will work even if the two
949
1127
branches have diverged.
950
1128
951
If there is no default location set, the first pull will set it. After
952
that, you can omit the location to use the default. To change the
953
default, use --remember. The value will only be saved if the remote
954
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>.
955
1137
956
1138
Note: The location can be specified either in the form of a branch,
957
1139
or in the form of a path to a file containing a merge directive generated
962
1144
takes_options = ['remember', 'overwrite', 'revision',
963
1145
custom_help('verbose',
964
1146
help='Show logs of pulled revisions.'),
965
Option('directory',
1147
custom_help('directory',
966
1148
help='Branch to pull into, '
967
'rather than the one containing the working directory.',
968
short_name='d',
969
type=unicode,
970
),
1149
'rather than the one containing the working directory.'),
971
1150
Option('local',
972
1151
help="Perform a local pull in a bound "
973
1152
"branch. Local pulls are not applied to "
974
1153
"the master branch."
975
1154
),
1155
Option('show-base',
1156
help="Show base revision text in conflicts."),
1157
Option('overwrite-tags',
1158
help="Overwrite tags only."),
976
1159
]
977
1160
takes_args = ['location?']
978
1161
encoding_type = 'replace'
979
1162
980
def run(self, location=None, remember=False, overwrite=False,
1163
def run(self, location=None, remember=None, overwrite=False,
981
1164
revision=None, verbose=False,
982
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 = []
983
1174
# FIXME: too much stuff is in the command class
984
1175
revision_id = None
985
1176
mergeable = None
988
1179
try:
989
1180
tree_to = WorkingTree.open_containing(directory)[0]
990
1181
branch_to = tree_to.branch
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
1186
self.add_cleanup(branch_to.lock_write().unlock)
1187
if show_base:
1188
warning(gettext("No working tree, ignoring --show-base"))
1189
995
1190
if local and not branch_to.get_bound_location():
996
1191
raise errors.LocalRequiresBoundBranch()
997
1192
1006
1201
stored_loc = branch_to.get_parent()
1007
1202
if location is None:
1008
1203
if stored_loc is None:
1009
raise errors.BzrCommandError("No pull location known or"
1010
" specified.")
1204
raise errors.BzrCommandError(gettext("No pull location known or"
1205
" specified."))
1011
1206
else:
1012
1207
display_url = urlutils.unescape_for_display(stored_loc,
1013
1208
self.outf.encoding)
1014
1209
if not is_quiet():
1015
self.outf.write("Using saved parent location: %s\n" % display_url)
1210
self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
1016
1211
location = stored_loc
1017
1212
1018
1213
revision = _get_one_revision('pull', revision)
1019
1214
if mergeable is not None:
1020
1215
if revision is not None:
1021
raise errors.BzrCommandError(
1022
'Cannot use -r with merge directives or bundles')
1216
raise errors.BzrCommandError(gettext(
1217
'Cannot use -r with merge directives or bundles'))
1023
1218
mergeable.install_revisions(branch_to.repository)
1024
1219
base_revision_id, revision_id, verified = \
1025
1220
mergeable.get_merge_request(branch_to.repository)
1027
1222
else:
1028
1223
branch_from = Branch.open(location,
1029
1224
possible_transports=possible_transports)
1030
1031
if branch_to.get_parent() is None or remember:
1225
self.add_cleanup(branch_from.lock_read().unlock)
1226
# Remembers if asked explicitly or no previous location is set
1227
if (remember
1228
or (remember is None and branch_to.get_parent() is None)):
1229
# FIXME: This shouldn't be done before the pull
1230
# succeeds... -- vila 2012-01-02
1032
1231
branch_to.set_parent(branch_from.base)
1033
1232
1034
if branch_from is not branch_to:
1035
branch_from.lock_read()
1036
self.add_cleanup(branch_from.unlock)
1037
1233
if revision is not None:
1038
1234
revision_id = revision.as_revision_id(branch_from)
1039
1235
1040
branch_to.lock_write()
1041
self.add_cleanup(branch_to.unlock)
1042
1236
if tree_to is not None:
1043
1237
view_info = _get_view_info_for_change_reporter(tree_to)
1044
1238
change_reporter = delta._ChangeReporter(
1046
1240
view_info=view_info)
1047
1241
result = tree_to.pull(
1048
1242
branch_from, overwrite, revision_id, change_reporter,
1049
possible_transports=possible_transports, local=local)
1243
local=local, show_base=show_base)
1050
1244
else:
1051
1245
result = branch_to.pull(
1052
1246
branch_from, overwrite, revision_id, local=local)
1056
1250
log.show_branch_change(
1057
1251
branch_to, self.outf, result.old_revno,
1058
1252
result.old_revid)
1253
if getattr(result, 'tag_conflicts', None):
1254
return 1
1255
else:
1256
return 0
1059
1257
1060
1258
1061
1259
class cmd_push(Command):
1062
"""Update a mirror of this branch.
1260
__doc__ = """Update a mirror of this branch.
1063
1261
1064
1262
The target branch will not have its working tree populated because this
1065
1263
is both expensive, and is not supported on remote file systems.
1078
1276
do a merge (see bzr help merge) from the other branch, and commit that.
1079
1277
After that you will be able to do a push without '--overwrite'.
1080
1278
1081
If there is no default push location set, the first push will set it.
1082
After that, you can omit the location to use the default. To change the
1083
default, use --remember. The value will only be saved if the remote
1084
location can be accessed.
1279
If there is no default push location set, the first push will set it (use
1280
--no-remember to avoid setting it). After that, you can omit the
1281
location to use the default. To change the default, use --remember. The
1282
value will only be saved if the remote location can be accessed.
1283
1284
The --verbose option will display the revisions pushed using the log_format
1285
configuration option. You can use a different format by overriding it with
1286
-Olog_format=<other_format>.
1085
1287
"""
1086
1288
1087
1289
_see_also = ['pull', 'update', 'working-trees']
1089
1291
Option('create-prefix',
1090
1292
help='Create the path leading up to the branch '
1091
1293
'if it does not already exist.'),
1092
Option('directory',
1294
custom_help('directory',
1093
1295
help='Branch to push from, '
1094
'rather than the one containing the working directory.',
1095
short_name='d',
1096
type=unicode,
1097
),
1296
'rather than the one containing the working directory.'),
1098
1297
Option('use-existing-dir',
1099
1298
help='By default push will fail if the target'
1100
1299
' directory exists, but does not already'
1111
1310
Option('strict',
1112
1311
help='Refuse to push if there are uncommitted changes in'
1113
1312
' the working tree, --no-strict disables the check.'),
1313
Option('no-tree',
1314
help="Don't populate the working tree, even for protocols"
1315
" that support it."),
1316
Option('overwrite-tags',
1317
help="Overwrite tags only."),
1114
1318
]
1115
1319
takes_args = ['location?']
1116
1320
encoding_type = 'replace'
1117
1321
1118
def run(self, location=None, remember=False, overwrite=False,
1322
def run(self, location=None, remember=None, overwrite=False,
1119
1323
create_prefix=False, verbose=False, revision=None,
1120
1324
use_existing_dir=False, directory=None, stacked_on=None,
1121
stacked=False, strict=None):
1325
stacked=False, strict=None, no_tree=False,
1326
overwrite_tags=False):
1122
1327
from bzrlib.push import _show_push_branch
1123
1328
1329
if overwrite:
1330
overwrite = ["history", "tags"]
1331
elif overwrite_tags:
1332
overwrite = ["tags"]
1333
else:
1334
overwrite = []
1335
1124
1336
if directory is None:
1125
1337
directory = '.'
1126
1338
# Get the source branch
1127
1339
(tree, br_from,
1128
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1129
if strict is None:
1130
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1131
if strict is None: strict = True # default value
1340
_unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1132
1341
# Get the tip's revision_id
1133
1342
revision = _get_one_revision('push', revision)
1134
1343
if revision is not None:
1135
1344
revision_id = revision.in_history(br_from).rev_id
1136
1345
else:
1137
1346
revision_id = None
1138
if strict and tree is not None and revision_id is None:
1139
if (tree.has_changes()):
1140
raise errors.UncommittedChanges(
1141
tree, more='Use --no-strict to force the push.')
1142
if tree.last_revision() != tree.branch.last_revision():
1143
# The tree has lost sync with its branch, there is little
1144
# chance that the user is aware of it but he can still force
1145
# the push with --no-strict
1146
raise errors.OutOfDateTree(
1147
tree, more='Use --no-strict to force the push.')
1148
1347
if tree is not None and revision_id is None:
1348
tree.check_changed_or_out_of_date(
1349
strict, 'push_strict',
1350
more_error='Use --no-strict to force the push.',
1351
more_warning='Uncommitted changes will not be pushed.')
1149
1352
# Get the stacked_on branch, if any
1150
1353
if stacked_on is not None:
1151
1354
stacked_on = urlutils.normalize_url(stacked_on)
1161
1364
# error by the feedback given to them. RBC 20080227.
1162
1365
stacked_on = parent_url
1163
1366
if not stacked_on:
1164
raise errors.BzrCommandError(
1165
"Could not determine branch to refer to.")
1367
raise errors.BzrCommandError(gettext(
1368
"Could not determine branch to refer to."))
1166
1369
1167
1370
# Get the destination location
1168
1371
if location is None:
1169
1372
stored_loc = br_from.get_push_location()
1170
1373
if stored_loc is None:
1171
raise errors.BzrCommandError(
1172
"No push location known or specified.")
1374
parent_loc = br_from.get_parent()
1375
if parent_loc:
1376
raise errors.BzrCommandError(gettext(
1377
"No push location known or specified. To push to the "
1378
"parent branch (at %s), use 'bzr push :parent'." %
1379
urlutils.unescape_for_display(parent_loc,
1380
self.outf.encoding)))
1381
else:
1382
raise errors.BzrCommandError(gettext(
1383
"No push location known or specified."))
1173
1384
else:
1174
1385
display_url = urlutils.unescape_for_display(stored_loc,
1175
1386
self.outf.encoding)
1176
self.outf.write("Using saved push location: %s\n" % display_url)
1387
note(gettext("Using saved push location: %s") % display_url)
1177
1388
location = stored_loc
1178
1389
1179
1390
_show_push_branch(br_from, revision_id, location, self.outf,
1180
1391
verbose=verbose, overwrite=overwrite, remember=remember,
1181
1392
stacked_on=stacked_on, create_prefix=create_prefix,
1182
use_existing_dir=use_existing_dir)
1393
use_existing_dir=use_existing_dir, no_tree=no_tree)
1183
1394
1184
1395
1185
1396
class cmd_branch(Command):
1186
"""Create a new branch that is a copy of an existing branch.
1397
__doc__ = """Create a new branch that is a copy of an existing branch.
1187
1398
1188
1399
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1189
1400
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1194
1405
1195
1406
To retrieve the branch as of a particular revision, supply the --revision
1196
1407
parameter, as in "branch foo/bar -r 5".
1408
1409
The synonyms 'clone' and 'get' for this command are deprecated.
1197
1410
"""
1198
1411
1199
1412
_see_also = ['checkout']
1200
1413
takes_args = ['from_location', 'to_location?']
1201
takes_options = ['revision', Option('hardlink',
1202
help='Hard-link working tree files where possible.'),
1414
takes_options = ['revision',
1415
Option('hardlink', help='Hard-link working tree files where possible.'),
1416
Option('files-from', type=str,
1417
help="Get file contents from this tree."),
1203
1418
Option('no-tree',
1204
1419
help="Create a branch without a working-tree."),
1205
1420
Option('switch',
1223
1438
1224
1439
def run(self, from_location, to_location=None, revision=None,
1225
1440
hardlink=False, stacked=False, standalone=False, no_tree=False,
1226
use_existing_dir=False, switch=False, bind=False):
1441
use_existing_dir=False, switch=False, bind=False,
1442
files_from=None):
1227
1443
from bzrlib import switch as _mod_switch
1228
1444
from bzrlib.tag import _merge_tags_if_possible
1229
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1445
if self.invoked_as in ['get', 'clone']:
1446
ui.ui_factory.show_user_warning(
1447
'deprecated_command',
1448
deprecated_name=self.invoked_as,
1449
recommended_name='branch',
1450
deprecated_in_version='2.4')
1451
accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
1230
1452
from_location)
1453
if not (hardlink or files_from):
1454
# accelerator_tree is usually slower because you have to read N
1455
# files (no readahead, lots of seeks, etc), but allow the user to
1456
# explicitly request it
1457
accelerator_tree = None
1458
if files_from is not None and files_from != from_location:
1459
accelerator_tree = WorkingTree.open(files_from)
1231
1460
revision = _get_one_revision('branch', revision)
1232
br_from.lock_read()
1233
self.add_cleanup(br_from.unlock)
1461
self.add_cleanup(br_from.lock_read().unlock)
1234
1462
if revision is not None:
1235
1463
revision_id = revision.as_revision_id(br_from)
1236
1464
else:
1239
1467
# RBC 20060209
1240
1468
revision_id = br_from.last_revision()
1241
1469
if to_location is None:
1242
to_location = urlutils.derive_to_location(from_location)
1470
to_location = getattr(br_from, "name", None)
1471
if not to_location:
1472
to_location = urlutils.derive_to_location(from_location)
1243
1473
to_transport = transport.get_transport(to_location)
1244
1474
try:
1245
1475
to_transport.mkdir('.')
1246
1476
except errors.FileExists:
1247
if not use_existing_dir:
1248
raise errors.BzrCommandError('Target directory "%s" '
1249
'already exists.' % to_location)
1477
try:
1478
to_dir = controldir.ControlDir.open_from_transport(
1479
to_transport)
1480
except errors.NotBranchError:
1481
if not use_existing_dir:
1482
raise errors.BzrCommandError(gettext('Target directory "%s" '
1483
'already exists.') % to_location)
1484
else:
1485
to_dir = None
1250
1486
else:
1251
1487
try:
1252
bzrdir.BzrDir.open_from_transport(to_transport)
1488
to_dir.open_branch()
1253
1489
except errors.NotBranchError:
1254
1490
pass
1255
1491
else:
1256
1492
raise errors.AlreadyBranchError(to_location)
1257
1493
except errors.NoSuchFile:
1258
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1494
raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
1259
1495
% to_location)
1260
try:
1261
# preserve whatever source format we have.
1262
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1263
possible_transports=[to_transport],
1264
accelerator_tree=accelerator_tree,
1265
hardlink=hardlink, stacked=stacked,
1266
force_new_repo=standalone,
1267
create_tree_if_local=not no_tree,
1268
source_branch=br_from)
1269
branch = dir.open_branch()
1270
except errors.NoSuchRevision:
1271
to_transport.delete_tree('.')
1272
msg = "The branch %s has no revision %s." % (from_location,
1273
revision)
1274
raise errors.BzrCommandError(msg)
1496
else:
1497
to_dir = None
1498
if to_dir is None:
1499
try:
1500
# preserve whatever source format we have.
1501
to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1502
possible_transports=[to_transport],
1503
accelerator_tree=accelerator_tree,
1504
hardlink=hardlink, stacked=stacked,
1505
force_new_repo=standalone,
1506
create_tree_if_local=not no_tree,
1507
source_branch=br_from)
1508
branch = to_dir.open_branch(
1509
possible_transports=[
1510
br_from.bzrdir.root_transport, to_transport])
1511
except errors.NoSuchRevision:
1512
to_transport.delete_tree('.')
1513
msg = gettext("The branch {0} has no revision {1}.").format(
1514
from_location, revision)
1515
raise errors.BzrCommandError(msg)
1516
else:
1517
try:
1518
to_repo = to_dir.open_repository()
1519
except errors.NoRepositoryPresent:
1520
to_repo = to_dir.create_repository()
1521
to_repo.fetch(br_from.repository, revision_id=revision_id)
1522
branch = br_from.sprout(to_dir, revision_id=revision_id)
1275
1523
_merge_tags_if_possible(br_from, branch)
1276
1524
# If the source branch is stacked, the new branch may
1277
1525
# be stacked whether we asked for that explicitly or not.
1278
1526
# We therefore need a try/except here and not just 'if stacked:'
1279
1527
try:
1280
note('Created new stacked branch referring to %s.' %
1528
note(gettext('Created new stacked branch referring to %s.') %
1281
1529
branch.get_stacked_on_url())
1282
1530
except (errors.NotStacked, errors.UnstackableBranchFormat,
1283
1531
errors.UnstackableRepositoryFormat), e:
1284
note('Branched %d revision(s).' % branch.revno())
1532
note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1285
1533
if bind:
1286
1534
# Bind to the parent
1287
1535
parent_branch = Branch.open(from_location)
1288
1536
branch.bind(parent_branch)
1289
note('New branch bound to %s' % from_location)
1537
note(gettext('New branch bound to %s') % from_location)
1290
1538
if switch:
1291
1539
# Switch to the new branch
1292
1540
wt, _ = WorkingTree.open_containing('.')
1293
1541
_mod_switch.switch(wt.bzrdir, branch)
1294
note('Switched to branch: %s',
1542
note(gettext('Switched to branch: %s'),
1295
1543
urlutils.unescape_for_display(branch.base, 'utf-8'))
1296
1544
1297
1545
1546
class cmd_branches(Command):
1547
__doc__ = """List the branches available at the current location.
1548
1549
This command will print the names of all the branches at the current
1550
location.
1551
"""
1552
1553
takes_args = ['location?']
1554
takes_options = [
1555
Option('recursive', short_name='R',
1556
help='Recursively scan for branches rather than '
1557
'just looking in the specified location.')]
1558
1559
def run(self, location=".", recursive=False):
1560
if recursive:
1561
t = transport.get_transport(location)
1562
if not t.listable():
1563
raise errors.BzrCommandError(
1564
"Can't scan this type of location.")
1565
for b in controldir.ControlDir.find_branches(t):
1566
self.outf.write("%s\n" % urlutils.unescape_for_display(
1567
urlutils.relative_url(t.base, b.base),
1568
self.outf.encoding).rstrip("/"))
1569
else:
1570
dir = controldir.ControlDir.open_containing(location)[0]
1571
try:
1572
active_branch = dir.open_branch(name="")
1573
except errors.NotBranchError:
1574
active_branch = None
1575
names = {}
1576
for name, branch in iter_sibling_branches(dir):
1577
if name == "":
1578
continue
1579
active = (active_branch is not None and
1580
active_branch.base == branch.base)
1581
names[name] = active
1582
# Only mention the current branch explicitly if it's not
1583
# one of the colocated branches
1584
if not any(names.values()) and active_branch is not None:
1585
self.outf.write("* %s\n" % gettext("(default)"))
1586
for name in sorted(names.keys()):
1587
active = names[name]
1588
if active:
1589
prefix = "*"
1590
else:
1591
prefix = " "
1592
self.outf.write("%s %s\n" % (
1593
prefix, name.encode(self.outf.encoding)))
1594
1595
1298
1596
class cmd_checkout(Command):
1299
"""Create a new checkout of an existing branch.
1597
__doc__ = """Create a new checkout of an existing branch.
1300
1598
1301
1599
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1302
1600
the branch found in '.'. This is useful if you have removed the working tree
1316
1614
code.)
1317
1615
"""
1318
1616
1319
_see_also = ['checkouts', 'branch']
1617
_see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1320
1618
takes_args = ['branch_location?', 'to_location?']
1321
1619
takes_options = ['revision',
1322
1620
Option('lightweight',
1339
1637
if branch_location is None:
1340
1638
branch_location = osutils.getcwd()
1341
1639
to_location = branch_location
1342
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1640
accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1343
1641
branch_location)
1642
if not (hardlink or files_from):
1643
# accelerator_tree is usually slower because you have to read N
1644
# files (no readahead, lots of seeks, etc), but allow the user to
1645
# explicitly request it
1646
accelerator_tree = None
1344
1647
revision = _get_one_revision('checkout', revision)
1345
if files_from is not None:
1648
if files_from is not None and files_from != branch_location:
1346
1649
accelerator_tree = WorkingTree.open(files_from)
1347
1650
if revision is not None:
1348
1651
revision_id = revision.as_revision_id(source)
1365
1668
1366
1669
1367
1670
class cmd_renames(Command):
1368
"""Show list of renamed files.
1671
__doc__ = """Show list of renamed files.
1369
1672
"""
1370
1673
# TODO: Option to show renames between two historical versions.
1371
1674
1376
1679
@display_command
1377
1680
def run(self, dir=u'.'):
1378
1681
tree = WorkingTree.open_containing(dir)[0]
1379
tree.lock_read()
1380
self.add_cleanup(tree.unlock)
1381
new_inv = tree.inventory
1682
self.add_cleanup(tree.lock_read().unlock)
1382
1683
old_tree = tree.basis_tree()
1383
old_tree.lock_read()
1384
self.add_cleanup(old_tree.unlock)
1385
old_inv = old_tree.inventory
1684
self.add_cleanup(old_tree.lock_read().unlock)
1386
1685
renames = []
1387
1686
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1388
1687
for f, paths, c, v, p, n, k, e in iterator:
1397
1696
1398
1697
1399
1698
class cmd_update(Command):
1400
"""Update a tree to have the latest code committed to its branch.
1401
1402
This will perform a merge into the working tree, and may generate
1403
conflicts. If you have any local changes, you will still
1404
need to commit them after the update for the update to be complete.
1405
1406
If you want to discard your local changes, you can just do a
1407
'bzr revert' instead of 'bzr commit' after the update.
1408
1409
If the tree's branch is bound to a master branch, it will also update
1699
__doc__ = """Update a working tree to a new revision.
1700
1701
This will perform a merge of the destination revision (the tip of the
1702
branch, or the specified revision) into the working tree, and then make
1703
that revision the basis revision for the working tree.
1704
1705
You can use this to visit an older revision, or to update a working tree
1706
that is out of date from its branch.
1707
1708
If there are any uncommitted changes in the tree, they will be carried
1709
across and remain as uncommitted changes after the update. To discard
1710
these changes, use 'bzr revert'. The uncommitted changes may conflict
1711
with the changes brought in by the change in basis revision.
1712
1713
If the tree's branch is bound to a master branch, bzr will also update
1410
1714
the branch from the master.
1715
1716
You cannot update just a single file or directory, because each Bazaar
1717
working tree has just a single basis revision. If you want to restore a
1718
file that has been removed locally, use 'bzr revert' instead of 'bzr
1719
update'. If you want to restore a file to its state in a previous
1720
revision, use 'bzr revert' with a '-r' option, or use 'bzr cat' to write
1721
out the old content of that file to a new location.
1722
1723
The 'dir' argument, if given, must be the location of the root of a
1724
working tree to update. By default, the working tree that contains the
1725
current working directory is used.
1411
1726
"""
1412
1727
1413
1728
_see_also = ['pull', 'working-trees', 'status-flags']
1414
1729
takes_args = ['dir?']
1415
takes_options = ['revision']
1730
takes_options = ['revision',
1731
Option('show-base',
1732
help="Show base revision text in conflicts."),
1733
]
1416
1734
aliases = ['up']
1417
1735
1418
def run(self, dir='.', revision=None):
1736
def run(self, dir=None, revision=None, show_base=None):
1419
1737
if revision is not None and len(revision) != 1:
1420
raise errors.BzrCommandError(
1421
"bzr update --revision takes exactly one revision")
1422
tree = WorkingTree.open_containing(dir)[0]
1738
raise errors.BzrCommandError(gettext(
1739
"bzr update --revision takes exactly one revision"))
1740
if dir is None:
1741
tree = WorkingTree.open_containing('.')[0]
1742
else:
1743
tree, relpath = WorkingTree.open_containing(dir)
1744
if relpath:
1745
# See bug 557886.
1746
raise errors.BzrCommandError(gettext(
1747
"bzr update can only update a whole tree, "
1748
"not a file or subdirectory"))
1423
1749
branch = tree.branch
1424
1750
possible_transports = []
1425
1751
master = branch.get_master_branch(
1426
1752
possible_transports=possible_transports)
1427
1753
if master is not None:
1428
tree.lock_write()
1429
1754
branch_location = master.base
1755
tree.lock_write()
1430
1756
else:
1757
branch_location = tree.branch.base
1431
1758
tree.lock_tree_write()
1432
branch_location = tree.branch.base
1433
1759
self.add_cleanup(tree.unlock)
1434
1760
# get rid of the final '/' and be ready for display
1435
1761
branch_location = urlutils.unescape_for_display(
1449
1775
revision_id = branch.last_revision()
1450
1776
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1451
1777
revno = branch.revision_id_to_dotted_revno(revision_id)
1452
note("Tree is up to date at revision %s of branch %s" %
1453
('.'.join(map(str, revno)), branch_location))
1778
note(gettext("Tree is up to date at revision {0} of branch {1}"
1779
).format('.'.join(map(str, revno)), branch_location))
1454
1780
return 0
1455
1781
view_info = _get_view_info_for_change_reporter(tree)
1456
1782
change_reporter = delta._ChangeReporter(
1461
1787
change_reporter,
1462
1788
possible_transports=possible_transports,
1463
1789
revision=revision_id,
1464
old_tip=old_tip)
1790
old_tip=old_tip,
1791
show_base=show_base)
1465
1792
except errors.NoSuchRevision, e:
1466
raise errors.BzrCommandError(
1793
raise errors.BzrCommandError(gettext(
1467
1794
"branch has no revision %s\n"
1468
1795
"bzr update --revision only works"
1469
" for a revision in the branch history"
1796
" for a revision in the branch history")
1470
1797
% (e.revision))
1471
1798
revno = tree.branch.revision_id_to_dotted_revno(
1472
1799
_mod_revision.ensure_null(tree.last_revision()))
1473
note('Updated to revision %s of branch %s' %
1474
('.'.join(map(str, revno)), branch_location))
1475
if tree.get_parent_ids()[1:] != existing_pending_merges:
1476
note('Your local commits will now show as pending merges with '
1477
"'bzr status', and can be committed with 'bzr commit'.")
1800
note(gettext('Updated to revision {0} of branch {1}').format(
1801
'.'.join(map(str, revno)), branch_location))
1802
parent_ids = tree.get_parent_ids()
1803
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1804
note(gettext('Your local commits will now show as pending merges with '
1805
"'bzr status', and can be committed with 'bzr commit'."))
1478
1806
if conflicts != 0:
1479
1807
return 1
1480
1808
else:
1482
1810
1483
1811
1484
1812
class cmd_info(Command):
1485
"""Show information about a working tree, branch or repository.
1813
__doc__ = """Show information about a working tree, branch or repository.
1486
1814
1487
1815
This command will show all known locations and formats associated to the
1488
1816
tree, branch or repository.
1521
1849
else:
1522
1850
noise_level = 0
1523
1851
from bzrlib.info import show_bzrdir_info
1524
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1852
show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1525
1853
verbose=noise_level, outfile=self.outf)
1526
1854
1527
1855
1528
1856
class cmd_remove(Command):
1529
"""Remove files or directories.
1857
__doc__ = """Remove files or directories.
1530
1858
1531
This makes bzr stop tracking changes to the specified files. bzr will delete
1532
them if they can easily be recovered using revert. If no options or
1533
parameters are given bzr will scan for files that are being tracked by bzr
1534
but missing in your tree and stop tracking them for you.
1859
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1860
delete them if they can easily be recovered using revert otherwise they
1861
will be backed up (adding an extension of the form .~#~). If no options or
1862
parameters are given Bazaar will scan for files that are being tracked by
1863
Bazaar but missing in your tree and stop tracking them for you.
1535
1864
"""
1536
1865
takes_args = ['file*']
1537
1866
takes_options = ['verbose',
1539
1868
RegistryOption.from_kwargs('file-deletion-strategy',
1540
1869
'The file deletion mode to be used.',
1541
1870
title='Deletion Strategy', value_switches=True, enum_switch=False,
1542
safe='Only delete files if they can be'
1543
' safely recovered (default).',
1871
safe='Backup changed files (default).',
1544
1872
keep='Delete from bzr but leave the working copy.',
1545
force='Delete all the specified files, even if they can not be '
1546
'recovered and even if they are non-empty directories.')]
1873
no_backup='Don\'t backup changed files.'),
1874
]
1547
1875
aliases = ['rm', 'del']
1548
1876
encoding_type = 'replace'
1549
1877
1550
1878
def run(self, file_list, verbose=False, new=False,
1551
1879
file_deletion_strategy='safe'):
1552
tree, file_list = tree_files(file_list)
1880
1881
tree, file_list = WorkingTree.open_containing_paths(file_list)
1553
1882
1554
1883
if file_list is not None:
1555
1884
file_list = [f for f in file_list]
1556
1885
1557
tree.lock_write()
1558
self.add_cleanup(tree.unlock)
1886
self.add_cleanup(tree.lock_write().unlock)
1559
1887
# Heuristics should probably all move into tree.remove_smart or
1560
1888
# some such?
1561
1889
if new:
1563
1891
specific_files=file_list).added
1564
1892
file_list = sorted([f[0] for f in added], reverse=True)
1565
1893
if len(file_list) == 0:
1566
raise errors.BzrCommandError('No matching files.')
1894
raise errors.BzrCommandError(gettext('No matching files.'))
1567
1895
elif file_list is None:
1568
1896
# missing files show up in iter_changes(basis) as
1569
1897
# versioned-with-no-kind.
1576
1904
file_deletion_strategy = 'keep'
1577
1905
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1578
1906
keep_files=file_deletion_strategy=='keep',
1579
force=file_deletion_strategy=='force')
1907
force=(file_deletion_strategy=='no-backup'))
1580
1908
1581
1909
1582
1910
class cmd_file_id(Command):
1583
"""Print file_id of a particular file or directory.
1911
__doc__ = """Print file_id of a particular file or directory.
1584
1912
1585
1913
The file_id is assigned when the file is first added and remains the
1586
1914
same through all revisions where the file exists, even when it is
1602
1930
1603
1931
1604
1932
class cmd_file_path(Command):
1605
"""Print path of file_ids to a file or directory.
1933
__doc__ = """Print path of file_ids to a file or directory.
1606
1934
1607
1935
This prints one line for each directory down to the target,
1608
1936
starting at the branch root.
1624
1952
1625
1953
1626
1954
class cmd_reconcile(Command):
1627
"""Reconcile bzr metadata in a branch.
1955
__doc__ = """Reconcile bzr metadata in a branch.
1628
1956
1629
1957
This can correct data mismatches that may have been caused by
1630
1958
previous ghost operations or bzr upgrades. You should only
1644
1972
1645
1973
_see_also = ['check']
1646
1974
takes_args = ['branch?']
1975
takes_options = [
1976
Option('canonicalize-chks',
1977
help='Make sure CHKs are in canonical form (repairs '
1978
'bug 522637).',
1979
hidden=True),
1980
]
1647
1981
1648
def run(self, branch="."):
1982
def run(self, branch=".", canonicalize_chks=False):
1649
1983
from bzrlib.reconcile import reconcile
1650
dir = bzrdir.BzrDir.open(branch)
1651
reconcile(dir)
1984
dir = controldir.ControlDir.open(branch)
1985
reconcile(dir, canonicalize_chks=canonicalize_chks)
1652
1986
1653
1987
1654
1988
class cmd_revision_history(Command):
1655
"""Display the list of revision ids on a branch."""
1989
__doc__ = """Display the list of revision ids on a branch."""
1656
1990
1657
1991
_see_also = ['log']
1658
1992
takes_args = ['location?']
1662
1996
@display_command
1663
1997
def run(self, location="."):
1664
1998
branch = Branch.open_containing(location)[0]
1665
for revid in branch.revision_history():
1999
self.add_cleanup(branch.lock_read().unlock)
2000
graph = branch.repository.get_graph()
2001
history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
2002
[_mod_revision.NULL_REVISION]))
2003
for revid in reversed(history):
1666
2004
self.outf.write(revid)
1667
2005
self.outf.write('\n')
1668
2006
1669
2007
1670
2008
class cmd_ancestry(Command):
1671
"""List all revisions merged into this branch."""
2009
__doc__ = """List all revisions merged into this branch."""
1672
2010
1673
2011
_see_also = ['log', 'revision-history']
1674
2012
takes_args = ['location?']
1686
2024
b = wt.branch
1687
2025
last_revision = wt.last_revision()
1688
2026
1689
revision_ids = b.repository.get_ancestry(last_revision)
1690
revision_ids.pop(0)
1691
for revision_id in revision_ids:
2027
self.add_cleanup(b.repository.lock_read().unlock)
2028
graph = b.repository.get_graph()
2029
revisions = [revid for revid, parents in
2030
graph.iter_ancestry([last_revision])]
2031
for revision_id in reversed(revisions):
2032
if _mod_revision.is_null(revision_id):
2033
continue
1692
2034
self.outf.write(revision_id + '\n')
1693
2035
1694
2036
1695
2037
class cmd_init(Command):
1696
"""Make a directory into a versioned branch.
2038
__doc__ = """Make a directory into a versioned branch.
1697
2039
1698
2040
Use this to create an empty branch, or before importing an
1699
2041
existing project.
1724
2066
RegistryOption('format',
1725
2067
help='Specify a format for this branch. '
1726
2068
'See "help formats".',
1727
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1728
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2069
lazy_registry=('bzrlib.controldir', 'format_registry'),
2070
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1729
2071
value_switches=True,
1730
2072
title="Branch format",
1731
2073
),
1732
2074
Option('append-revisions-only',
1733
2075
help='Never change revnos or the existing log.'
1734
' Append revisions to it only.')
2076
' Append revisions to it only.'),
2077
Option('no-tree',
2078
'Create a branch without a working tree.')
1735
2079
]
1736
2080
def run(self, location=None, format=None, append_revisions_only=False,
1737
create_prefix=False):
2081
create_prefix=False, no_tree=False):
1738
2082
if format is None:
1739
format = bzrdir.format_registry.make_bzrdir('default')
2083
format = controldir.format_registry.make_bzrdir('default')
1740
2084
if location is None:
1741
2085
location = u'.'
1742
2086
1751
2095
to_transport.ensure_base()
1752
2096
except errors.NoSuchFile:
1753
2097
if not create_prefix:
1754
raise errors.BzrCommandError("Parent directory of %s"
2098
raise errors.BzrCommandError(gettext("Parent directory of %s"
1755
2099
" does not exist."
1756
2100
"\nYou may supply --create-prefix to create all"
1757
" leading parent directories."
2101
" leading parent directories.")
1758
2102
% location)
1759
2103
to_transport.create_prefix()
1760
2104
1761
2105
try:
1762
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
2106
a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1763
2107
except errors.NotBranchError:
1764
2108
# really a NotBzrDir error...
1765
create_branch = bzrdir.BzrDir.create_branch_convenience
2109
create_branch = controldir.ControlDir.create_branch_convenience
2110
if no_tree:
2111
force_new_tree = False
2112
else:
2113
force_new_tree = None
1766
2114
branch = create_branch(to_transport.base, format=format,
1767
possible_transports=[to_transport])
2115
possible_transports=[to_transport],
2116
force_new_tree=force_new_tree)
1768
2117
a_bzrdir = branch.bzrdir
1769
2118
else:
1770
2119
from bzrlib.transport.local import LocalTransport
1774
2123
raise errors.BranchExistsWithoutWorkingTree(location)
1775
2124
raise errors.AlreadyBranchError(location)
1776
2125
branch = a_bzrdir.create_branch()
1777
a_bzrdir.create_workingtree()
2126
if not no_tree and not a_bzrdir.has_workingtree():
2127
a_bzrdir.create_workingtree()
1778
2128
if append_revisions_only:
1779
2129
try:
1780
2130
branch.set_append_revisions_only(True)
1781
2131
except errors.UpgradeRequired:
1782
raise errors.BzrCommandError('This branch format cannot be set'
1783
' to append-revisions-only. Try --default.')
2132
raise errors.BzrCommandError(gettext('This branch format cannot be set'
2133
' to append-revisions-only. Try --default.'))
1784
2134
if not is_quiet():
1785
2135
from bzrlib.info import describe_layout, describe_format
1786
2136
try:
1790
2140
repository = branch.repository
1791
2141
layout = describe_layout(repository, branch, tree).lower()
1792
2142
format = describe_format(a_bzrdir, repository, branch, tree)
1793
self.outf.write("Created a %s (format: %s)\n" % (layout, format))
2143
self.outf.write(gettext("Created a {0} (format: {1})\n").format(
2144
layout, format))
1794
2145
if repository.is_shared():
1795
2146
#XXX: maybe this can be refactored into transport.path_or_url()
1796
2147
url = repository.bzrdir.root_transport.external_url()
1798
2149
url = urlutils.local_path_from_url(url)
1799
2150
except errors.InvalidURL:
1800
2151
pass
1801
self.outf.write("Using shared repository: %s\n" % url)
2152
self.outf.write(gettext("Using shared repository: %s\n") % url)
1802
2153
1803
2154
1804
2155
class cmd_init_repository(Command):
1805
"""Create a shared repository for branches to share storage space.
2156
__doc__ = """Create a shared repository for branches to share storage space.
1806
2157
1807
2158
New branches created under the repository directory will store their
1808
2159
revisions in the repository, not in the branch directory. For branches
1834
2185
takes_options = [RegistryOption('format',
1835
2186
help='Specify a format for this repository. See'
1836
2187
' "bzr help formats" for details.',
1837
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1838
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2188
lazy_registry=('bzrlib.controldir', 'format_registry'),
2189
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1839
2190
value_switches=True, title='Repository format'),
1840
2191
Option('no-trees',
1841
2192
help='Branches in the repository will default to'
1845
2196
1846
2197
def run(self, location, format=None, no_trees=False):
1847
2198
if format is None:
1848
format = bzrdir.format_registry.make_bzrdir('default')
2199
format = controldir.format_registry.make_bzrdir('default')
1849
2200
1850
2201
if location is None:
1851
2202
location = '.'
1852
2203
1853
2204
to_transport = transport.get_transport(location)
1854
to_transport.ensure_base()
1855
2205
1856
newdir = format.initialize_on_transport(to_transport)
1857
repo = newdir.create_repository(shared=True)
1858
repo.set_make_working_trees(not no_trees)
2206
(repo, newdir, require_stacking, repository_policy) = (
2207
format.initialize_on_transport_ex(to_transport,
2208
create_prefix=True, make_working_trees=not no_trees,
2209
shared_repo=True, force_new_repo=True,
2210
use_existing_dir=True,
2211
repo_format_name=format.repository_format.get_format_string()))
1859
2212
if not is_quiet():
1860
2213
from bzrlib.info import show_bzrdir_info
1861
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
2214
show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1862
2215
1863
2216
1864
2217
class cmd_diff(Command):
1865
"""Show differences in the working tree, between revisions or branches.
2218
__doc__ = """Show differences in the working tree, between revisions or branches.
1866
2219
1867
2220
If no arguments are given, all changes for the current tree are listed.
1868
2221
If files are given, only the changes in those files are listed.
1874
2227
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1875
2228
produces patches suitable for "patch -p1".
1876
2229
2230
Note that when using the -r argument with a range of revisions, the
2231
differences are computed between the two specified revisions. That
2232
is, the command does not show the changes introduced by the first
2233
revision in the range. This differs from the interpretation of
2234
revision ranges used by "bzr log" which includes the first revision
2235
in the range.
2236
1877
2237
:Exit values:
1878
2238
1 - changed
1879
2239
2 - unrepresentable changes
1897
2257
1898
2258
bzr diff -r1..3 xxx
1899
2259
1900
To see the changes introduced in revision X::
2260
The changes introduced by revision 2 (equivalent to -r1..2)::
2261
2262
bzr diff -c2
2263
2264
To see the changes introduced by revision X::
1901
2265
1902
2266
bzr diff -cX
1903
2267
1907
2271
1908
2272
bzr diff -r<chosen_parent>..X
1909
2273
1910
The changes introduced by revision 2 (equivalent to -r1..2)::
2274
The changes between the current revision and the previous revision
2275
(equivalent to -c-1 and -r-2..-1)
1911
2276
1912
bzr diff -c2
2277
bzr diff -r-2..
1913
2278
1914
2279
Show just the differences for file NEWS::
1915
2280
1930
2295
Same as 'bzr diff' but prefix paths with old/ and new/::
1931
2296
1932
2297
bzr diff --prefix old/:new/
2298
2299
Show the differences using a custom diff program with options::
2300
2301
bzr diff --using /usr/bin/diff --diff-options -wu
1933
2302
"""
1934
2303
_see_also = ['status']
1935
2304
takes_args = ['file*']
1955
2324
type=unicode,
1956
2325
),
1957
2326
RegistryOption('format',
2327
short_name='F',
1958
2328
help='Diff format to use.',
1959
2329
lazy_registry=('bzrlib.diff', 'format_registry'),
1960
value_switches=False, title='Diff format'),
2330
title='Diff format'),
2331
Option('context',
2332
help='How many lines of context to show.',
2333
type=int,
2334
),
1961
2335
]
1962
2336
aliases = ['di', 'dif']
1963
2337
encoding_type = 'exact'
1964
2338
1965
2339
@display_command
1966
2340
def run(self, revision=None, file_list=None, diff_options=None,
1967
prefix=None, old=None, new=None, using=None, format=None):
1968
from bzrlib.diff import (get_trees_and_branches_to_diff,
2341
prefix=None, old=None, new=None, using=None, format=None,
2342
context=None):
2343
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1969
2344
show_diff_trees)
1970
2345
1971
2346
if (prefix is None) or (prefix == '0'):
1978
2353
elif ':' in prefix:
1979
2354
old_label, new_label = prefix.split(":")
1980
2355
else:
1981
raise errors.BzrCommandError(
2356
raise errors.BzrCommandError(gettext(
1982
2357
'--prefix expects two values separated by a colon'
1983
' (eg "old/:new/")')
2358
' (eg "old/:new/")'))
1984
2359
1985
2360
if revision and len(revision) > 2:
1986
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1987
' one or two revision specifiers')
2361
raise errors.BzrCommandError(gettext('bzr diff --revision takes exactly'
2362
' one or two revision specifiers'))
1988
2363
1989
2364
if using is not None and format is not None:
1990
raise errors.BzrCommandError('--using and --format are mutually '
1991
'exclusive.')
2365
raise errors.BzrCommandError(gettext(
2366
'{0} and {1} are mutually exclusive').format(
2367
'--using', '--format'))
1992
2368
1993
2369
(old_tree, new_tree,
1994
2370
old_branch, new_branch,
1995
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1996
file_list, revision, old, new, apply_view=True)
2371
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
2372
file_list, revision, old, new, self.add_cleanup, apply_view=True)
2373
# GNU diff on Windows uses ANSI encoding for filenames
2374
path_encoding = osutils.get_diff_header_encoding()
1997
2375
return show_diff_trees(old_tree, new_tree, sys.stdout,
1998
2376
specific_files=specific_files,
1999
2377
external_diff_options=diff_options,
2000
2378
old_label=old_label, new_label=new_label,
2001
extra_trees=extra_trees, using=using,
2379
extra_trees=extra_trees,
2380
path_encoding=path_encoding,
2381
using=using, context=context,
2002
2382
format_cls=format)
2003
2383
2004
2384
2005
2385
class cmd_deleted(Command):
2006
"""List files deleted in the working tree.
2386
__doc__ = """List files deleted in the working tree.
2007
2387
"""
2008
2388
# TODO: Show files deleted since a previous revision, or
2009
2389
# between two revisions.
2012
2392
# level of effort but possibly much less IO. (Or possibly not,
2013
2393
# if the directories are very large...)
2014
2394
_see_also = ['status', 'ls']
2015
takes_options = ['show-ids']
2395
takes_options = ['directory', 'show-ids']
2016
2396
2017
2397
@display_command
2018
def run(self, show_ids=False):
2019
tree = WorkingTree.open_containing(u'.')[0]
2020
tree.lock_read()
2021
self.add_cleanup(tree.unlock)
2398
def run(self, show_ids=False, directory=u'.'):
2399
tree = WorkingTree.open_containing(directory)[0]
2400
self.add_cleanup(tree.lock_read().unlock)
2022
2401
old = tree.basis_tree()
2023
old.lock_read()
2024
self.add_cleanup(old.unlock)
2025
for path, ie in old.inventory.iter_entries():
2402
self.add_cleanup(old.lock_read().unlock)
2403
for path, ie in old.iter_entries_by_dir():
2026
2404
if not tree.has_id(ie.file_id):
2027
2405
self.outf.write(path)
2028
2406
if show_ids:
2032
2410
2033
2411
2034
2412
class cmd_modified(Command):
2035
"""List files modified in working tree.
2413
__doc__ = """List files modified in working tree.
2036
2414
"""
2037
2415
2038
2416
hidden = True
2039
2417
_see_also = ['status', 'ls']
2040
takes_options = [
2041
Option('null',
2042
help='Write an ascii NUL (\\0) separator '
2043
'between files rather than a newline.')
2044
]
2418
takes_options = ['directory', 'null']
2045
2419
2046
2420
@display_command
2047
def run(self, null=False):
2048
tree = WorkingTree.open_containing(u'.')[0]
2421
def run(self, null=False, directory=u'.'):
2422
tree = WorkingTree.open_containing(directory)[0]
2423
self.add_cleanup(tree.lock_read().unlock)
2049
2424
td = tree.changes_from(tree.basis_tree())
2425
self.cleanup_now()
2050
2426
for path, id, kind, text_modified, meta_modified in td.modified:
2051
2427
if null:
2052
2428
self.outf.write(path + '\0')
2055
2431
2056
2432
2057
2433
class cmd_added(Command):
2058
"""List files added in working tree.
2434
__doc__ = """List files added in working tree.
2059
2435
"""
2060
2436
2061
2437
hidden = True
2062
2438
_see_also = ['status', 'ls']
2063
takes_options = [
2064
Option('null',
2065
help='Write an ascii NUL (\\0) separator '
2066
'between files rather than a newline.')
2067
]
2439
takes_options = ['directory', 'null']
2068
2440
2069
2441
@display_command
2070
def run(self, null=False):
2071
wt = WorkingTree.open_containing(u'.')[0]
2072
wt.lock_read()
2073
self.add_cleanup(wt.unlock)
2442
def run(self, null=False, directory=u'.'):
2443
wt = WorkingTree.open_containing(directory)[0]
2444
self.add_cleanup(wt.lock_read().unlock)
2074
2445
basis = wt.basis_tree()
2075
basis.lock_read()
2076
self.add_cleanup(basis.unlock)
2077
basis_inv = basis.inventory
2078
inv = wt.inventory
2079
for file_id in inv:
2080
if file_id in basis_inv:
2081
continue
2082
if inv.is_root(file_id) and len(basis_inv) == 0:
2083
continue
2084
path = inv.id2path(file_id)
2085
if not os.access(osutils.abspath(path), os.F_OK):
2446
self.add_cleanup(basis.lock_read().unlock)
2447
root_id = wt.get_root_id()
2448
for file_id in wt.all_file_ids():
2449
if basis.has_id(file_id):
2450
continue
2451
if root_id == file_id:
2452
continue
2453
path = wt.id2path(file_id)
2454
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2086
2455
continue
2087
2456
if null:
2088
2457
self.outf.write(path + '\0')
2091
2460
2092
2461
2093
2462
class cmd_root(Command):
2094
"""Show the tree root directory.
2463
__doc__ = """Show the tree root directory.
2095
2464
2096
2465
The root is the nearest enclosing directory with a .bzr control
2097
2466
directory."""
2108
2477
try:
2109
2478
return int(limitstring)
2110
2479
except ValueError:
2111
msg = "The limit argument must be an integer."
2480
msg = gettext("The limit argument must be an integer.")
2112
2481
raise errors.BzrCommandError(msg)
2113
2482
2114
2483
2116
2485
try:
2117
2486
return int(s)
2118
2487
except ValueError:
2119
msg = "The levels argument must be an integer."
2488
msg = gettext("The levels argument must be an integer.")
2120
2489
raise errors.BzrCommandError(msg)
2121
2490
2122
2491
2123
2492
class cmd_log(Command):
2124
"""Show historical log for a branch or subset of a branch.
2493
__doc__ = """Show historical log for a branch or subset of a branch.
2125
2494
2126
2495
log is bzr's default tool for exploring the history of a branch.
2127
2496
The branch to use is taken from the first parameter. If no parameters
2232
2601
2233
2602
:Other filtering:
2234
2603
2235
The --message option can be used for finding revisions that match a
2236
regular expression in a commit message.
2604
The --match option can be used for finding revisions that match a
2605
regular expression in a commit message, committer, author or bug.
2606
Specifying the option several times will match any of the supplied
2607
expressions. --match-author, --match-bugs, --match-committer and
2608
--match-message can be used to only match a specific field.
2237
2609
2238
2610
:Tips & tricks:
2239
2611
2288
2660
help='Show just the specified revision.'
2289
2661
' See also "help revisionspec".'),
2290
2662
'log-format',
2663
RegistryOption('authors',
2664
'What names to list as authors - first, all or committer.',
2665
title='Authors',
2666
lazy_registry=('bzrlib.log', 'author_list_registry'),
2667
),
2291
2668
Option('levels',
2292
2669
short_name='n',
2293
2670
help='Number of levels to display - 0 for all, 1 for flat.',
2294
2671
argname='N',
2295
2672
type=_parse_levels),
2296
2673
Option('message',
2297
short_name='m',
2298
2674
help='Show revisions whose message matches this '
2299
2675
'regular expression.',
2300
type=str),
2676
type=str,
2677
hidden=True),
2301
2678
Option('limit',
2302
2679
short_name='l',
2303
2680
help='Limit the output to the first N revisions.',
2306
2683
Option('show-diff',
2307
2684
short_name='p',
2308
2685
help='Show changes made in each revision as a patch.'),
2309
Option('include-merges',
2686
Option('include-merged',
2310
2687
help='Show merged revisions like --levels 0 does.'),
2688
Option('include-merges', hidden=True,
2689
help='Historical alias for --include-merged.'),
2690
Option('omit-merges',
2691
help='Do not report commits with more than one parent.'),
2692
Option('exclude-common-ancestry',
2693
help='Display only the revisions that are not part'
2694
' of both ancestries (require -rX..Y).'
2695
),
2696
Option('signatures',
2697
help='Show digital signature validity.'),
2698
ListOption('match',
2699
short_name='m',
2700
help='Show revisions whose properties match this '
2701
'expression.',
2702
type=str),
2703
ListOption('match-message',
2704
help='Show revisions whose message matches this '
2705
'expression.',
2706
type=str),
2707
ListOption('match-committer',
2708
help='Show revisions whose committer matches this '
2709
'expression.',
2710
type=str),
2711
ListOption('match-author',
2712
help='Show revisions whose authors match this '
2713
'expression.',
2714
type=str),
2715
ListOption('match-bugs',
2716
help='Show revisions whose bugs match this '
2717
'expression.',
2718
type=str)
2311
2719
]
2312
2720
encoding_type = 'replace'
2313
2721
2323
2731
message=None,
2324
2732
limit=None,
2325
2733
show_diff=False,
2326
include_merges=False):
2734
include_merged=None,
2735
authors=None,
2736
exclude_common_ancestry=False,
2737
signatures=False,
2738
match=None,
2739
match_message=None,
2740
match_committer=None,
2741
match_author=None,
2742
match_bugs=None,
2743
omit_merges=False,
2744
include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2745
):
2327
2746
from bzrlib.log import (
2328
2747
Logger,
2329
2748
make_log_request_dict,
2330
2749
_get_info_for_log_files,
2331
2750
)
2332
2751
direction = (forward and 'forward') or 'reverse'
2333
if include_merges:
2752
if symbol_versioning.deprecated_passed(include_merges):
2753
ui.ui_factory.show_user_warning(
2754
'deprecated_command_option',
2755
deprecated_name='--include-merges',
2756
recommended_name='--include-merged',
2757
deprecated_in_version='2.5',
2758
command=self.invoked_as)
2759
if include_merged is None:
2760
include_merged = include_merges
2761
else:
2762
raise errors.BzrCommandError(gettext(
2763
'{0} and {1} are mutually exclusive').format(
2764
'--include-merges', '--include-merged'))
2765
if include_merged is None:
2766
include_merged = False
2767
if (exclude_common_ancestry
2768
and (revision is None or len(revision) != 2)):
2769
raise errors.BzrCommandError(gettext(
2770
'--exclude-common-ancestry requires -r with two revisions'))
2771
if include_merged:
2334
2772
if levels is None:
2335
2773
levels = 0
2336
2774
else:
2337
raise errors.BzrCommandError(
2338
'--levels and --include-merges are mutually exclusive')
2775
raise errors.BzrCommandError(gettext(
2776
'{0} and {1} are mutually exclusive').format(
2777
'--levels', '--include-merged'))
2339
2778
2340
2779
if change is not None:
2341
2780
if len(change) > 1:
2342
2781
raise errors.RangeInChangeOption()
2343
2782
if revision is not None:
2344
raise errors.BzrCommandError(
2345
'--revision and --change are mutually exclusive')
2783
raise errors.BzrCommandError(gettext(
2784
'{0} and {1} are mutually exclusive').format(
2785
'--revision', '--change'))
2346
2786
else:
2347
2787
revision = change
2348
2788
2351
2791
if file_list:
2352
2792
# find the file ids to log and check for directory filtering
2353
2793
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2354
revision, file_list)
2355
self.add_cleanup(b.unlock)
2794
revision, file_list, self.add_cleanup)
2356
2795
for relpath, file_id, kind in file_info_list:
2357
2796
if file_id is None:
2358
raise errors.BzrCommandError(
2359
"Path unknown at end or start of revision range: %s" %
2797
raise errors.BzrCommandError(gettext(
2798
"Path unknown at end or start of revision range: %s") %
2360
2799
relpath)
2361
2800
# If the relpath is the top of the tree, we log everything
2362
2801
if relpath == '':
2374
2813
location = revision[0].get_branch()
2375
2814
else:
2376
2815
location = '.'
2377
dir, relpath = bzrdir.BzrDir.open_containing(location)
2816
dir, relpath = controldir.ControlDir.open_containing(location)
2378
2817
b = dir.open_branch()
2379
b.lock_read()
2380
self.add_cleanup(b.unlock)
2818
self.add_cleanup(b.lock_read().unlock)
2381
2819
rev1, rev2 = _get_revision_range(revision, b, self.name())
2382
2820
2821
if b.get_config_stack().get('validate_signatures_in_log'):
2822
signatures = True
2823
2824
if signatures:
2825
if not gpg.GPGStrategy.verify_signatures_available():
2826
raise errors.GpgmeNotInstalled(None)
2827
2383
2828
# Decide on the type of delta & diff filtering to use
2384
2829
# TODO: add an --all-files option to make this configurable & consistent
2385
2830
if not verbose:
2403
2848
show_timezone=timezone,
2404
2849
delta_format=get_verbosity_level(),
2405
2850
levels=levels,
2406
show_advice=levels is None)
2851
show_advice=levels is None,
2852
author_list_handler=authors)
2407
2853
2408
2854
# Choose the algorithm for doing the logging. It's annoying
2409
2855
# having multiple code paths like this but necessary until
2421
2867
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2422
2868
or delta_type or partial_history)
2423
2869
2870
match_dict = {}
2871
if match:
2872
match_dict[''] = match
2873
if match_message:
2874
match_dict['message'] = match_message
2875
if match_committer:
2876
match_dict['committer'] = match_committer
2877
if match_author:
2878
match_dict['author'] = match_author
2879
if match_bugs:
2880
match_dict['bugs'] = match_bugs
2881
2424
2882
# Build the LogRequest and execute it
2425
2883
if len(file_ids) == 0:
2426
2884
file_ids = None
2428
2886
direction=direction, specific_fileids=file_ids,
2429
2887
start_revision=rev1, end_revision=rev2, limit=limit,
2430
2888
message_search=message, delta_type=delta_type,
2431
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2889
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2890
exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
2891
signature=signatures, omit_merges=omit_merges,
2892
)
2432
2893
Logger(b, rqst).show(lf)
2433
2894
2434
2895
2450
2911
# b is taken from revision[0].get_branch(), and
2451
2912
# show_log will use its revision_history. Having
2452
2913
# different branches will lead to weird behaviors.
2453
raise errors.BzrCommandError(
2914
raise errors.BzrCommandError(gettext(
2454
2915
"bzr %s doesn't accept two revisions in different"
2455
" branches." % command_name)
2916
" branches.") % command_name)
2456
2917
if start_spec.spec is None:
2457
2918
# Avoid loading all the history.
2458
2919
rev1 = RevisionInfo(branch, None, None)
2466
2927
else:
2467
2928
rev2 = end_spec.in_history(branch)
2468
2929
else:
2469
raise errors.BzrCommandError(
2470
'bzr %s --revision takes one or two values.' % command_name)
2930
raise errors.BzrCommandError(gettext(
2931
'bzr %s --revision takes one or two values.') % command_name)
2471
2932
return rev1, rev2
2472
2933
2473
2934
2492
2953
2493
2954
2494
2955
class cmd_touching_revisions(Command):
2495
"""Return revision-ids which affected a particular file.
2956
__doc__ = """Return revision-ids which affected a particular file.
2496
2957
2497
2958
A more user-friendly interface is "bzr log FILE".
2498
2959
"""
2505
2966
tree, relpath = WorkingTree.open_containing(filename)
2506
2967
file_id = tree.path2id(relpath)
2507
2968
b = tree.branch
2508
b.lock_read()
2509
self.add_cleanup(b.unlock)
2969
self.add_cleanup(b.lock_read().unlock)
2510
2970
touching_revs = log.find_touching_revisions(b, file_id)
2511
2971
for revno, revision_id, what in touching_revs:
2512
2972
self.outf.write("%6d %s\n" % (revno, what))
2513
2973
2514
2974
2515
2975
class cmd_ls(Command):
2516
"""List files in a tree.
2976
__doc__ = """List files in a tree.
2517
2977
"""
2518
2978
2519
2979
_see_also = ['status', 'cat']
2525
2985
help='Recurse into subdirectories.'),
2526
2986
Option('from-root',
2527
2987
help='Print paths relative to the root of the branch.'),
2528
Option('unknown', help='Print unknown files.'),
2988
Option('unknown', short_name='u',
2989
help='Print unknown files.'),
2529
2990
Option('versioned', help='Print versioned files.',
2530
2991
short_name='V'),
2531
Option('ignored', help='Print ignored files.'),
2532
Option('null',
2533
help='Write an ascii NUL (\\0) separator '
2534
'between files rather than a newline.'),
2535
Option('kind',
2992
Option('ignored', short_name='i',
2993
help='Print ignored files.'),
2994
Option('kind', short_name='k',
2536
2995
help='List entries of a particular kind: file, directory, symlink.',
2537
2996
type=unicode),
2997
'null',
2538
2998
'show-ids',
2999
'directory',
2539
3000
]
2540
3001
@display_command
2541
3002
def run(self, revision=None, verbose=False,
2542
3003
recursive=False, from_root=False,
2543
3004
unknown=False, versioned=False, ignored=False,
2544
null=False, kind=None, show_ids=False, path=None):
3005
null=False, kind=None, show_ids=False, path=None, directory=None):
2545
3006
2546
3007
if kind and kind not in ('file', 'directory', 'symlink'):
2547
raise errors.BzrCommandError('invalid kind specified')
3008
raise errors.BzrCommandError(gettext('invalid kind specified'))
2548
3009
2549
3010
if verbose and null:
2550
raise errors.BzrCommandError('Cannot set both --verbose and --null')
3011
raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2551
3012
all = not (unknown or versioned or ignored)
2552
3013
2553
3014
selection = {'I':ignored, '?':unknown, 'V':versioned}
2556
3017
fs_path = '.'
2557
3018
else:
2558
3019
if from_root:
2559
raise errors.BzrCommandError('cannot specify both --from-root'
2560
' and PATH')
3020
raise errors.BzrCommandError(gettext('cannot specify both --from-root'
3021
' and PATH'))
2561
3022
fs_path = path
2562
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2563
fs_path)
3023
tree, branch, relpath = \
3024
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2564
3025
2565
3026
# Calculate the prefix to use
2566
3027
prefix = None
2579
3040
if view_files:
2580
3041
apply_view = True
2581
3042
view_str = views.view_display_str(view_files)
2582
note("Ignoring files outside view. View is %s" % view_str)
3043
note(gettext("Ignoring files outside view. View is %s") % view_str)
2583
3044
2584
tree.lock_read()
2585
self.add_cleanup(tree.unlock)
3045
self.add_cleanup(tree.lock_read().unlock)
2586
3046
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2587
3047
from_dir=relpath, recursive=recursive):
2588
3048
# Apply additional masking
2630
3090
2631
3091
2632
3092
class cmd_unknowns(Command):
2633
"""List unknown files.
3093
__doc__ = """List unknown files.
2634
3094
"""
2635
3095
2636
3096
hidden = True
2637
3097
_see_also = ['ls']
3098
takes_options = ['directory']
2638
3099
2639
3100
@display_command
2640
def run(self):
2641
for f in WorkingTree.open_containing(u'.')[0].unknowns():
3101
def run(self, directory=u'.'):
3102
for f in WorkingTree.open_containing(directory)[0].unknowns():
2642
3103
self.outf.write(osutils.quotefn(f) + '\n')
2643
3104
2644
3105
2645
3106
class cmd_ignore(Command):
2646
"""Ignore specified files or patterns.
3107
__doc__ = """Ignore specified files or patterns.
2647
3108
2648
3109
See ``bzr help patterns`` for details on the syntax of patterns.
2649
3110
2658
3119
using this command or directly by using an editor, be sure to commit
2659
3120
it.
2660
3121
3122
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
3123
the global ignore file can be found in the application data directory as
3124
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
3125
Global ignores are not touched by this command. The global ignore file
3126
can be edited directly using an editor.
3127
2661
3128
Patterns prefixed with '!' are exceptions to ignore patterns and take
2662
3129
precedence over regular ignores. Such exceptions are used to specify
2663
3130
files that should be versioned which would otherwise be ignored.
2665
3132
Patterns prefixed with '!!' act as regular ignore patterns, but have
2666
3133
precedence over the '!' exception patterns.
2667
3134
2668
Note: ignore patterns containing shell wildcards must be quoted from
2669
the shell on Unix.
3135
:Notes:
3136
3137
* Ignore patterns containing shell wildcards must be quoted from
3138
the shell on Unix.
3139
3140
* Ignore patterns starting with "#" act as comments in the ignore file.
3141
To ignore patterns that begin with that character, use the "RE:" prefix.
2670
3142
2671
3143
:Examples:
2672
3144
Ignore the top level Makefile::
2681
3153
2682
3154
bzr ignore "!special.class"
2683
3155
3156
Ignore files whose name begins with the "#" character::
3157
3158
bzr ignore "RE:^#"
3159
2684
3160
Ignore .o files under the lib directory::
2685
3161
2686
3162
bzr ignore "lib/**/*.o"
2694
3170
bzr ignore "RE:(?!debian/).*"
2695
3171
2696
3172
Ignore everything except the "local" toplevel directory,
2697
but always ignore "*~" autosave files, even under local/::
3173
but always ignore autosave files ending in ~, even under local/::
2698
3174
2699
3175
bzr ignore "*"
2700
3176
bzr ignore "!./local"
2703
3179
2704
3180
_see_also = ['status', 'ignored', 'patterns']
2705
3181
takes_args = ['name_pattern*']
2706
takes_options = [
2707
Option('old-default-rules',
2708
help='Write out the ignore rules bzr < 0.9 always used.')
3182
takes_options = ['directory',
3183
Option('default-rules',
3184
help='Display the default ignore rules that bzr uses.')
2709
3185
]
2710
3186
2711
def run(self, name_pattern_list=None, old_default_rules=None):
3187
def run(self, name_pattern_list=None, default_rules=None,
3188
directory=u'.'):
2712
3189
from bzrlib import ignores
2713
if old_default_rules is not None:
2714
# dump the rules and exit
2715
for pattern in ignores.OLD_DEFAULTS:
3190
if default_rules is not None:
3191
# dump the default rules and exit
3192
for pattern in ignores.USER_DEFAULTS:
2716
3193
self.outf.write("%s\n" % pattern)
2717
3194
return
2718
3195
if not name_pattern_list:
2719
raise errors.BzrCommandError("ignore requires at least one "
2720
"NAME_PATTERN or --old-default-rules")
3196
raise errors.BzrCommandError(gettext("ignore requires at least one "
3197
"NAME_PATTERN or --default-rules."))
2721
3198
name_pattern_list = [globbing.normalize_pattern(p)
2722
3199
for p in name_pattern_list]
3200
bad_patterns = ''
3201
bad_patterns_count = 0
3202
for p in name_pattern_list:
3203
if not globbing.Globster.is_pattern_valid(p):
3204
bad_patterns_count += 1
3205
bad_patterns += ('\n %s' % p)
3206
if bad_patterns:
3207
msg = (ngettext('Invalid ignore pattern found. %s',
3208
'Invalid ignore patterns found. %s',
3209
bad_patterns_count) % bad_patterns)
3210
ui.ui_factory.show_error(msg)
3211
raise errors.InvalidPattern('')
2723
3212
for name_pattern in name_pattern_list:
2724
3213
if (name_pattern[0] == '/' or
2725
3214
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2726
raise errors.BzrCommandError(
2727
"NAME_PATTERN should not be an absolute path")
2728
tree, relpath = WorkingTree.open_containing(u'.')
3215
raise errors.BzrCommandError(gettext(
3216
"NAME_PATTERN should not be an absolute path"))
3217
tree, relpath = WorkingTree.open_containing(directory)
2729
3218
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2730
3219
ignored = globbing.Globster(name_pattern_list)
2731
3220
matches = []
2732
tree.lock_read()
3221
self.add_cleanup(tree.lock_read().unlock)
2733
3222
for entry in tree.list_files():
2734
3223
id = entry[3]
2735
3224
if id is not None:
2736
3225
filename = entry[0]
2737
3226
if ignored.match(filename):
2738
3227
matches.append(filename)
2739
tree.unlock()
2740
3228
if len(matches) > 0:
2741
self.outf.write("Warning: the following files are version controlled and"
2742
" match your ignore pattern:\n%s"
3229
self.outf.write(gettext("Warning: the following files are version "
3230
"controlled and match your ignore pattern:\n%s"
2743
3231
"\nThese files will continue to be version controlled"
2744
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
3232
" unless you 'bzr remove' them.\n") % ("\n".join(matches),))
2745
3233
2746
3234
2747
3235
class cmd_ignored(Command):
2748
"""List ignored files and the patterns that matched them.
3236
__doc__ = """List ignored files and the patterns that matched them.
2749
3237
2750
3238
List all the ignored files and the ignore pattern that caused the file to
2751
3239
be ignored.
2757
3245
2758
3246
encoding_type = 'replace'
2759
3247
_see_also = ['ignore', 'ls']
3248
takes_options = ['directory']
2760
3249
2761
3250
@display_command
2762
def run(self):
2763
tree = WorkingTree.open_containing(u'.')[0]
2764
tree.lock_read()
2765
self.add_cleanup(tree.unlock)
3251
def run(self, directory=u'.'):
3252
tree = WorkingTree.open_containing(directory)[0]
3253
self.add_cleanup(tree.lock_read().unlock)
2766
3254
for path, file_class, kind, file_id, entry in tree.list_files():
2767
3255
if file_class != 'I':
2768
3256
continue
2772
3260
2773
3261
2774
3262
class cmd_lookup_revision(Command):
2775
"""Lookup the revision-id from a revision-number
3263
__doc__ = """Lookup the revision-id from a revision-number
2776
3264
2777
3265
:Examples:
2778
3266
bzr lookup-revision 33
2779
3267
"""
2780
3268
hidden = True
2781
3269
takes_args = ['revno']
3270
takes_options = ['directory']
2782
3271
2783
3272
@display_command
2784
def run(self, revno):
3273
def run(self, revno, directory=u'.'):
2785
3274
try:
2786
3275
revno = int(revno)
2787
3276
except ValueError:
2788
raise errors.BzrCommandError("not a valid revision-number: %r"
3277
raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
2789
3278
% revno)
2790
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
3279
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2791
3280
self.outf.write("%s\n" % revid)
2792
3281
2793
3282
2794
3283
class cmd_export(Command):
2795
"""Export current or past revision to a destination directory or archive.
3284
__doc__ = """Export current or past revision to a destination directory or archive.
2796
3285
2797
3286
If no revision is specified this exports the last committed revision.
2798
3287
2819
3308
zip .zip
2820
3309
================= =========================
2821
3310
"""
3311
encoding = 'exact'
2822
3312
takes_args = ['dest', 'branch_or_subdir?']
2823
takes_options = [
3313
takes_options = ['directory',
2824
3314
Option('format',
2825
3315
help="Type of file to export to.",
2826
3316
type=unicode),
2833
3323
Option('per-file-timestamps',
2834
3324
help='Set modification time of files to that of the last '
2835
3325
'revision in which it was changed.'),
3326
Option('uncommitted',
3327
help='Export the working tree contents rather than that of the '
3328
'last revision.'),
2836
3329
]
2837
3330
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2838
root=None, filters=False, per_file_timestamps=False):
3331
root=None, filters=False, per_file_timestamps=False, uncommitted=False,
3332
directory=u'.'):
2839
3333
from bzrlib.export import export
2840
3334
2841
3335
if branch_or_subdir is None:
2842
tree = WorkingTree.open_containing(u'.')[0]
2843
b = tree.branch
2844
subdir = None
3336
branch_or_subdir = directory
3337
3338
(tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
3339
branch_or_subdir)
3340
if tree is not None:
3341
self.add_cleanup(tree.lock_read().unlock)
3342
3343
if uncommitted:
3344
if tree is None:
3345
raise errors.BzrCommandError(
3346
gettext("--uncommitted requires a working tree"))
3347
export_tree = tree
2845
3348
else:
2846
b, subdir = Branch.open_containing(branch_or_subdir)
2847
tree = None
2848
2849
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
3349
export_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2850
3350
try:
2851
export(rev_tree, dest, format, root, subdir, filtered=filters,
3351
export(export_tree, dest, format, root, subdir, filtered=filters,
2852
3352
per_file_timestamps=per_file_timestamps)
2853
3353
except errors.NoSuchExportFormat, e:
2854
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3354
raise errors.BzrCommandError(
3355
gettext('Unsupported export format: %s') % e.format)
2855
3356
2856
3357
2857
3358
class cmd_cat(Command):
2858
"""Write the contents of a file as of a given revision to standard output.
3359
__doc__ = """Write the contents of a file as of a given revision to standard output.
2859
3360
2860
3361
If no revision is nominated, the last revision is used.
2861
3362
2864
3365
"""
2865
3366
2866
3367
_see_also = ['ls']
2867
takes_options = [
3368
takes_options = ['directory',
2868
3369
Option('name-from-revision', help='The path name in the old tree.'),
2869
3370
Option('filters', help='Apply content filters to display the '
2870
3371
'convenience form.'),
2875
3376
2876
3377
@display_command
2877
3378
def run(self, filename, revision=None, name_from_revision=False,
2878
filters=False):
3379
filters=False, directory=None):
2879
3380
if revision is not None and len(revision) != 1:
2880
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2881
" one revision specifier")
3381
raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
3382
" one revision specifier"))
2882
3383
tree, branch, relpath = \
2883
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2884
branch.lock_read()
2885
self.add_cleanup(branch.unlock)
3384
_open_directory_or_containing_tree_or_branch(filename, directory)
3385
self.add_cleanup(branch.lock_read().unlock)
2886
3386
return self._run(tree, branch, relpath, filename, revision,
2887
3387
name_from_revision, filters)
2888
3388
2891
3391
if tree is None:
2892
3392
tree = b.basis_tree()
2893
3393
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2894
rev_tree.lock_read()
2895
self.add_cleanup(rev_tree.unlock)
3394
self.add_cleanup(rev_tree.lock_read().unlock)
2896
3395
2897
3396
old_file_id = rev_tree.path2id(relpath)
2898
3397
3398
# TODO: Split out this code to something that generically finds the
3399
# best id for a path across one or more trees; it's like
3400
# find_ids_across_trees but restricted to find just one. -- mbp
3401
# 20110705.
2899
3402
if name_from_revision:
2900
3403
# Try in revision if requested
2901
3404
if old_file_id is None:
2902
raise errors.BzrCommandError(
2903
"%r is not present in revision %s" % (
3405
raise errors.BzrCommandError(gettext(
3406
"{0!r} is not present in revision {1}").format(
2904
3407
filename, rev_tree.get_revision_id()))
2905
3408
else:
2906
content = rev_tree.get_file_text(old_file_id)
3409
actual_file_id = old_file_id
2907
3410
else:
2908
3411
cur_file_id = tree.path2id(relpath)
2909
found = False
2910
if cur_file_id is not None:
2911
# Then try with the actual file id
2912
try:
2913
content = rev_tree.get_file_text(cur_file_id)
2914
found = True
2915
except errors.NoSuchId:
2916
# The actual file id didn't exist at that time
2917
pass
2918
if not found and old_file_id is not None:
2919
# Finally try with the old file id
2920
content = rev_tree.get_file_text(old_file_id)
2921
found = True
2922
if not found:
2923
# Can't be found anywhere
2924
raise errors.BzrCommandError(
2925
"%r is not present in revision %s" % (
3412
if cur_file_id is not None and rev_tree.has_id(cur_file_id):
3413
actual_file_id = cur_file_id
3414
elif old_file_id is not None:
3415
actual_file_id = old_file_id
3416
else:
3417
raise errors.BzrCommandError(gettext(
3418
"{0!r} is not present in revision {1}").format(
2926
3419
filename, rev_tree.get_revision_id()))
2927
3420
if filtered:
2928
from bzrlib.filters import (
2929
ContentFilterContext,
2930
filtered_output_bytes,
2931
)
2932
filters = rev_tree._content_filter_stack(relpath)
2933
chunks = content.splitlines(True)
2934
content = filtered_output_bytes(chunks, filters,
2935
ContentFilterContext(relpath, rev_tree))
2936
self.cleanup_now()
2937
self.outf.writelines(content)
3421
from bzrlib.filter_tree import ContentFilterTree
3422
filter_tree = ContentFilterTree(rev_tree,
3423
rev_tree._content_filter_stack)
3424
content = filter_tree.get_file_text(actual_file_id)
2938
3425
else:
2939
self.cleanup_now()
2940
self.outf.write(content)
3426
content = rev_tree.get_file_text(actual_file_id)
3427
self.cleanup_now()
3428
self.outf.write(content)
2941
3429
2942
3430
2943
3431
class cmd_local_time_offset(Command):
2944
"""Show the offset in seconds from GMT to local time."""
3432
__doc__ = """Show the offset in seconds from GMT to local time."""
2945
3433
hidden = True
2946
3434
@display_command
2947
3435
def run(self):
2950
3438
2951
3439
2952
3440
class cmd_commit(Command):
2953
"""Commit changes into a new revision.
3441
__doc__ = """Commit changes into a new revision.
2954
3442
2955
3443
An explanatory message needs to be given for each commit. This is
2956
3444
often done by using the --message option (getting the message from the
3004
3492
to trigger updates to external systems like bug trackers. The --fixes
3005
3493
option can be used to record the association between a revision and
3006
3494
one or more bugs. See ``bzr help bugs`` for details.
3007
3008
A selective commit may fail in some cases where the committed
3009
tree would be invalid. Consider::
3010
3011
bzr init foo
3012
mkdir foo/bar
3013
bzr add foo/bar
3014
bzr commit foo -m "committing foo"
3015
bzr mv foo/bar foo/baz
3016
mkdir foo/bar
3017
bzr add foo/bar
3018
bzr commit foo/bar -m "committing bar but not baz"
3019
3020
In the example above, the last commit will fail by design. This gives
3021
the user the opportunity to decide whether they want to commit the
3022
rename at the same time, separately first, or not at all. (As a general
3023
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3024
3495
"""
3025
# TODO: Run hooks on tree to-be-committed, and after commit.
3026
3027
# TODO: Strict commit that fails if there are deleted files.
3028
# (what does "deleted files" mean ??)
3029
3030
# TODO: Give better message for -s, --summary, used by tla people
3031
3032
# XXX: verbose currently does nothing
3033
3496
3034
3497
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
3035
3498
takes_args = ['selected*']
3064
3527
"the master branch until a normal commit "
3065
3528
"is performed."
3066
3529
),
3067
Option('show-diff',
3530
Option('show-diff', short_name='p',
3068
3531
help='When no message is supplied, show the diff along'
3069
3532
' with the status summary in the message editor.'),
3533
Option('lossy',
3534
help='When committing to a foreign version control '
3535
'system do not push data that can not be natively '
3536
'represented.'),
3070
3537
]
3071
3538
aliases = ['ci', 'checkin']
3072
3539
3073
3540
def _iter_bug_fix_urls(self, fixes, branch):
3541
default_bugtracker = None
3074
3542
# Configure the properties for bug fixing attributes.
3075
3543
for fixed_bug in fixes:
3076
3544
tokens = fixed_bug.split(':')
3077
if len(tokens) != 2:
3078
raise errors.BzrCommandError(
3545
if len(tokens) == 1:
3546
if default_bugtracker is None:
3547
branch_config = branch.get_config_stack()
3548
default_bugtracker = branch_config.get(
3549
"bugtracker")
3550
if default_bugtracker is None:
3551
raise errors.BzrCommandError(gettext(
3552
"No tracker specified for bug %s. Use the form "
3553
"'tracker:id' or specify a default bug tracker "
3554
"using the `bugtracker` option.\nSee "
3555
"\"bzr help bugs\" for more information on this "
3556
"feature. Commit refused.") % fixed_bug)
3557
tag = default_bugtracker
3558
bug_id = tokens[0]
3559
elif len(tokens) != 2:
3560
raise errors.BzrCommandError(gettext(
3079
3561
"Invalid bug %s. Must be in the form of 'tracker:id'. "
3080
3562
"See \"bzr help bugs\" for more information on this "
3081
"feature.\nCommit refused." % fixed_bug)
3082
tag, bug_id = tokens
3563
"feature.\nCommit refused.") % fixed_bug)
3564
else:
3565
tag, bug_id = tokens
3083
3566
try:
3084
3567
yield bugtracker.get_bug_url(tag, branch, bug_id)
3085
3568
except errors.UnknownBugTrackerAbbreviation:
3086
raise errors.BzrCommandError(
3087
'Unrecognized bug %s. Commit refused.' % fixed_bug)
3569
raise errors.BzrCommandError(gettext(
3570
'Unrecognized bug %s. Commit refused.') % fixed_bug)
3088
3571
except errors.MalformedBugIdentifier, e:
3089
raise errors.BzrCommandError(
3090
"%s\nCommit refused." % (str(e),))
3572
raise errors.BzrCommandError(gettext(
3573
"%s\nCommit refused.") % (str(e),))
3091
3574
3092
3575
def run(self, message=None, file=None, verbose=False, selected_list=None,
3093
3576
unchanged=False, strict=False, local=False, fixes=None,
3094
author=None, show_diff=False, exclude=None, commit_time=None):
3577
author=None, show_diff=False, exclude=None, commit_time=None,
3578
lossy=False):
3095
3579
from bzrlib.errors import (
3096
3580
PointlessCommit,
3097
3581
ConflictsInTree,
3100
3584
from bzrlib.msgeditor import (
3101
3585
edit_commit_message_encoded,
3102
3586
generate_commit_message_template,
3103
make_commit_message_template_encoded
3587
make_commit_message_template_encoded,
3588
set_commit_message,
3104
3589
)
3105
3590
3106
3591
commit_stamp = offset = None
3108
3593
try:
3109
3594
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3110
3595
except ValueError, e:
3111
raise errors.BzrCommandError(
3112
"Could not parse --commit-time: " + str(e))
3113
3114
# TODO: Need a blackbox test for invoking the external editor; may be
3115
# slightly problematic to run this cross-platform.
3116
3117
# TODO: do more checks that the commit will succeed before
3118
# spending the user's valuable time typing a commit message.
3596
raise errors.BzrCommandError(gettext(
3597
"Could not parse --commit-time: " + str(e)))
3119
3598
3120
3599
properties = {}
3121
3600
3122
tree, selected_list = tree_files(selected_list)
3601
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3123
3602
if selected_list == ['']:
3124
3603
# workaround - commit of root of tree should be exactly the same
3125
3604
# as just default commit in that tree, and succeed even though
3154
3633
message = message.replace('\r\n', '\n')
3155
3634
message = message.replace('\r', '\n')
3156
3635
if file:
3157
raise errors.BzrCommandError(
3158
"please specify either --message or --file")
3636
raise errors.BzrCommandError(gettext(
3637
"please specify either --message or --file"))
3159
3638
3160
3639
def get_message(commit_obj):
3161
3640
"""Callback to get commit message"""
3162
3641
if file:
3163
my_message = codecs.open(
3164
file, 'rt', osutils.get_user_encoding()).read()
3642
f = open(file)
3643
try:
3644
my_message = f.read().decode(osutils.get_user_encoding())
3645
finally:
3646
f.close()
3165
3647
elif message is not None:
3166
3648
my_message = message
3167
3649
else:
3175
3657
# make_commit_message_template_encoded returns user encoding.
3176
3658
# We probably want to be using edit_commit_message instead to
3177
3659
# avoid this.
3178
start_message = generate_commit_message_template(commit_obj)
3179
my_message = edit_commit_message_encoded(text,
3180
start_message=start_message)
3181
if my_message is None:
3182
raise errors.BzrCommandError("please specify a commit"
3183
" message with either --message or --file")
3184
if my_message == "":
3185
raise errors.BzrCommandError("empty commit message specified")
3660
my_message = set_commit_message(commit_obj)
3661
if my_message is None:
3662
start_message = generate_commit_message_template(commit_obj)
3663
my_message = edit_commit_message_encoded(text,
3664
start_message=start_message)
3665
if my_message is None:
3666
raise errors.BzrCommandError(gettext("please specify a commit"
3667
" message with either --message or --file"))
3668
if my_message == "":
3669
raise errors.BzrCommandError(gettext("Empty commit message specified."
3670
" Please specify a commit message with either"
3671
" --message or --file or leave a blank message"
3672
" with --message \"\"."))
3186
3673
return my_message
3187
3674
3188
3675
# The API permits a commit with a filter of [] to mean 'select nothing'
3196
3683
reporter=None, verbose=verbose, revprops=properties,
3197
3684
authors=author, timestamp=commit_stamp,
3198
3685
timezone=offset,
3199
exclude=safe_relpath_files(tree, exclude))
3686
exclude=tree.safe_relpath_files(exclude),
3687
lossy=lossy)
3200
3688
except PointlessCommit:
3201
raise errors.BzrCommandError("No changes to commit."
3202
" Use --unchanged to commit anyhow.")
3689
raise errors.BzrCommandError(gettext("No changes to commit."
3690
" Please 'bzr add' the files you want to commit, or use"
3691
" --unchanged to force an empty commit."))
3203
3692
except ConflictsInTree:
3204
raise errors.BzrCommandError('Conflicts detected in working '
3693
raise errors.BzrCommandError(gettext('Conflicts detected in working '
3205
3694
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3206
' resolve.')
3695
' resolve.'))
3207
3696
except StrictCommitFailed:
3208
raise errors.BzrCommandError("Commit refused because there are"
3209
" unknown files in the working tree.")
3697
raise errors.BzrCommandError(gettext("Commit refused because there are"
3698
" unknown files in the working tree."))
3210
3699
except errors.BoundBranchOutOfDate, e:
3211
e.extra_help = ("\n"
3700
e.extra_help = (gettext("\n"
3212
3701
'To commit to master branch, run update and then commit.\n'
3213
3702
'You can also pass --local to commit to continue working '
3214
'disconnected.')
3703
'disconnected.'))
3215
3704
raise
3216
3705
3217
3706
3218
3707
class cmd_check(Command):
3219
"""Validate working tree structure, branch consistency and repository history.
3708
__doc__ = """Validate working tree structure, branch consistency and repository history.
3220
3709
3221
3710
This command checks various invariants about branch and repository storage
3222
3711
to detect data corruption or bzr bugs.
3286
3775
3287
3776
3288
3777
class cmd_upgrade(Command):
3289
"""Upgrade branch storage to current format.
3290
3291
The check command or bzr developers may sometimes advise you to run
3292
this command. When the default format has changed you may also be warned
3293
during other operations to upgrade.
3778
__doc__ = """Upgrade a repository, branch or working tree to a newer format.
3779
3780
When the default format has changed after a major new release of
3781
Bazaar, you may be informed during certain operations that you
3782
should upgrade. Upgrading to a newer format may improve performance
3783
or make new features available. It may however limit interoperability
3784
with older repositories or with older versions of Bazaar.
3785
3786
If you wish to upgrade to a particular format rather than the
3787
current default, that can be specified using the --format option.
3788
As a consequence, you can use the upgrade command this way to
3789
"downgrade" to an earlier format, though some conversions are
3790
a one way process (e.g. changing from the 1.x default to the
3791
2.x default) so downgrading is not always possible.
3792
3793
A backup.bzr.~#~ directory is created at the start of the conversion
3794
process (where # is a number). By default, this is left there on
3795
completion. If the conversion fails, delete the new .bzr directory
3796
and rename this one back in its place. Use the --clean option to ask
3797
for the backup.bzr directory to be removed on successful conversion.
3798
Alternatively, you can delete it by hand if everything looks good
3799
afterwards.
3800
3801
If the location given is a shared repository, dependent branches
3802
are also converted provided the repository converts successfully.
3803
If the conversion of a branch fails, remaining branches are still
3804
tried.
3805
3806
For more information on upgrades, see the Bazaar Upgrade Guide,
3807
http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3294
3808
"""
3295
3809
3296
_see_also = ['check']
3810
_see_also = ['check', 'reconcile', 'formats']
3297
3811
takes_args = ['url?']
3298
3812
takes_options = [
3299
RegistryOption('format',
3300
help='Upgrade to a specific format. See "bzr help'
3301
' formats" for details.',
3302
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3303
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3304
value_switches=True, title='Branch format'),
3305
]
3813
RegistryOption('format',
3814
help='Upgrade to a specific format. See "bzr help'
3815
' formats" for details.',
3816
lazy_registry=('bzrlib.controldir', 'format_registry'),
3817
converter=lambda name: controldir.format_registry.make_bzrdir(name),
3818
value_switches=True, title='Branch format'),
3819
Option('clean',
3820
help='Remove the backup.bzr directory if successful.'),
3821
Option('dry-run',
3822
help="Show what would be done, but don't actually do anything."),
3823
]
3306
3824
3307
def run(self, url='.', format=None):
3825
def run(self, url='.', format=None, clean=False, dry_run=False):
3308
3826
from bzrlib.upgrade import upgrade
3309
upgrade(url, format)
3827
exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3828
if exceptions:
3829
if len(exceptions) == 1:
3830
# Compatibility with historical behavior
3831
raise exceptions[0]
3832
else:
3833
return 3
3310
3834
3311
3835
3312
3836
class cmd_whoami(Command):
3313
"""Show or set bzr user id.
3837
__doc__ = """Show or set bzr user id.
3314
3838
3315
3839
:Examples:
3316
3840
Show the email of the current user::
3321
3845
3322
3846
bzr whoami "Frank Chu <fchu@example.com>"
3323
3847
"""
3324
takes_options = [ Option('email',
3848
takes_options = [ 'directory',
3849
Option('email',
3325
3850
help='Display email address only.'),
3326
3851
Option('branch',
3327
3852
help='Set identity for the current branch instead of '
3331
3856
encoding_type = 'replace'
3332
3857
3333
3858
@display_command
3334
def run(self, email=False, branch=False, name=None):
3859
def run(self, email=False, branch=False, name=None, directory=None):
3335
3860
if name is None:
3336
# use branch if we're inside one; otherwise global config
3337
try:
3338
c = Branch.open_containing('.')[0].get_config()
3339
except errors.NotBranchError:
3340
c = config.GlobalConfig()
3861
if directory is None:
3862
# use branch if we're inside one; otherwise global config
3863
try:
3864
c = Branch.open_containing(u'.')[0].get_config_stack()
3865
except errors.NotBranchError:
3866
c = _mod_config.GlobalStack()
3867
else:
3868
c = Branch.open(directory).get_config_stack()
3869
identity = c.get('email')
3341
3870
if email:
3342
self.outf.write(c.user_email() + '\n')
3871
self.outf.write(_mod_config.extract_email_address(identity)
3872
+ '\n')
3343
3873
else:
3344
self.outf.write(c.username() + '\n')
3874
self.outf.write(identity + '\n')
3345
3875
return
3346
3876
3877
if email:
3878
raise errors.BzrCommandError(gettext("--email can only be used to display existing "
3879
"identity"))
3880
3347
3881
# display a warning if an email address isn't included in the given name.
3348
3882
try:
3349
config.extract_email_address(name)
3883
_mod_config.extract_email_address(name)
3350
3884
except errors.NoEmailInUsername, e:
3351
3885
warning('"%s" does not seem to contain an email address. '
3352
3886
'This is allowed, but not recommended.', name)
3353
3887
3354
3888
# use global config unless --branch given
3355
3889
if branch:
3356
c = Branch.open_containing('.')[0].get_config()
3890
if directory is None:
3891
c = Branch.open_containing(u'.')[0].get_config_stack()
3892
else:
3893
b = Branch.open(directory)
3894
self.add_cleanup(b.lock_write().unlock)
3895
c = b.get_config_stack()
3357
3896
else:
3358
c = config.GlobalConfig()
3359
c.set_user_option('email', name)
3897
c = _mod_config.GlobalStack()
3898
c.set('email', name)
3360
3899
3361
3900
3362
3901
class cmd_nick(Command):
3363
"""Print or set the branch nickname.
3902
__doc__ = """Print or set the branch nickname.
3364
3903
3365
If unset, the tree root directory name is used as the nickname.
3366
To print the current nickname, execute with no argument.
3904
If unset, the colocated branch name is used for colocated branches, and
3905
the branch directory name is used for other branches. To print the
3906
current nickname, execute with no argument.
3367
3907
3368
3908
Bound branches use the nickname of its master branch unless it is set
3369
3909
locally.
3371
3911
3372
3912
_see_also = ['info']
3373
3913
takes_args = ['nickname?']
3374
def run(self, nickname=None):
3375
branch = Branch.open_containing(u'.')[0]
3914
takes_options = ['directory']
3915
def run(self, nickname=None, directory=u'.'):
3916
branch = Branch.open_containing(directory)[0]
3376
3917
if nickname is None:
3377
3918
self.printme(branch)
3378
3919
else:
3384
3925
3385
3926
3386
3927
class cmd_alias(Command):
3387
"""Set/unset and display aliases.
3928
__doc__ = """Set/unset and display aliases.
3388
3929
3389
3930
:Examples:
3390
3931
Show the current aliases::
3423
3964
3424
3965
def remove_alias(self, alias_name):
3425
3966
if alias_name is None:
3426
raise errors.BzrCommandError(
3427
'bzr alias --remove expects an alias to remove.')
3967
raise errors.BzrCommandError(gettext(
3968
'bzr alias --remove expects an alias to remove.'))
3428
3969
# If alias is not found, print something like:
3429
3970
# unalias: foo: not found
3430
c = config.GlobalConfig()
3971
c = _mod_config.GlobalConfig()
3431
3972
c.unset_alias(alias_name)
3432
3973
3433
3974
@display_command
3434
3975
def print_aliases(self):
3435
3976
"""Print out the defined aliases in a similar format to bash."""
3436
aliases = config.GlobalConfig().get_aliases()
3977
aliases = _mod_config.GlobalConfig().get_aliases()
3437
3978
for key, value in sorted(aliases.iteritems()):
3438
3979
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3439
3980
3449
3990
3450
3991
def set_alias(self, alias_name, alias_command):
3451
3992
"""Save the alias in the global config."""
3452
c = config.GlobalConfig()
3993
c = _mod_config.GlobalConfig()
3453
3994
c.set_alias(alias_name, alias_command)
3454
3995
3455
3996
3456
3997
class cmd_selftest(Command):
3457
"""Run internal test suite.
3998
__doc__ = """Run internal test suite.
3458
3999
3459
4000
If arguments are given, they are regular expressions that say which tests
3460
4001
should run. Tests matching any expression are run, and other tests are
3490
4031
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3491
4032
into a pdb postmortem session.
3492
4033
4034
The --coverage=DIRNAME global option produces a report with covered code
4035
indicated.
4036
3493
4037
:Examples:
3494
4038
Run only tests relating to 'ignore'::
3495
4039
3506
4050
if typestring == "sftp":
3507
4051
from bzrlib.tests import stub_sftp
3508
4052
return stub_sftp.SFTPAbsoluteServer
3509
if typestring == "memory":
4053
elif typestring == "memory":
3510
4054
from bzrlib.tests import test_server
3511
4055
return memory.MemoryServer
3512
if typestring == "fakenfs":
4056
elif typestring == "fakenfs":
3513
4057
from bzrlib.tests import test_server
3514
4058
return test_server.FakeNFSServer
3515
4059
msg = "No known transport type %s. Supported types are: sftp\n" %\
3528
4072
'throughout the test suite.',
3529
4073
type=get_transport_type),
3530
4074
Option('benchmark',
3531
help='Run the benchmarks rather than selftests.'),
4075
help='Run the benchmarks rather than selftests.',
4076
hidden=True),
3532
4077
Option('lsprof-timed',
3533
4078
help='Generate lsprof output for benchmarked'
3534
4079
' sections of code.'),
3535
4080
Option('lsprof-tests',
3536
4081
help='Generate lsprof output for each test.'),
3537
Option('cache-dir', type=str,
3538
help='Cache intermediate benchmark output in this '
3539
'directory.'),
3540
4082
Option('first',
3541
4083
help='Run all tests, but run specified tests first.',
3542
4084
short_name='f',
3551
4093
Option('randomize', type=str, argname="SEED",
3552
4094
help='Randomize the order of tests using the given'
3553
4095
' seed or "now" for the current time.'),
3554
Option('exclude', type=str, argname="PATTERN",
3555
short_name='x',
3556
help='Exclude tests that match this regular'
3557
' expression.'),
4096
ListOption('exclude', type=str, argname="PATTERN",
4097
short_name='x',
4098
help='Exclude tests that match this regular'
4099
' expression.'),
3558
4100
Option('subunit',
3559
4101
help='Output test progress via subunit.'),
3560
4102
Option('strict', help='Fail on missing dependencies or '
3567
4109
param_name='starting_with', short_name='s',
3568
4110
help=
3569
4111
'Load only the tests starting with TESTID.'),
4112
Option('sync',
4113
help="By default we disable fsync and fdatasync"
4114
" while running the test suite.")
3570
4115
]
3571
4116
encoding_type = 'replace'
3572
4117
3576
4121
3577
4122
def run(self, testspecs_list=None, verbose=False, one=False,
3578
4123
transport=None, benchmark=None,
3579
lsprof_timed=None, cache_dir=None,
4124
lsprof_timed=None,
3580
4125
first=False, list_only=False,
3581
4126
randomize=None, exclude=None, strict=False,
3582
4127
load_list=None, debugflag=None, starting_with=None, subunit=False,
3583
parallel=None, lsprof_tests=False):
3584
from bzrlib.tests import selftest
3585
import bzrlib.benchmarks as benchmarks
3586
from bzrlib.benchmarks import tree_creator
3587
3588
# Make deprecation warnings visible, unless -Werror is set
3589
symbol_versioning.activate_deprecation_warnings(override=False)
3590
3591
if cache_dir is not None:
3592
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
4128
parallel=None, lsprof_tests=False,
4129
sync=False):
4130
4131
# During selftest, disallow proxying, as it can cause severe
4132
# performance penalties and is only needed for thread
4133
# safety. The selftest command is assumed to not use threads
4134
# too heavily. The call should be as early as possible, as
4135
# error reporting for past duplicate imports won't have useful
4136
# backtraces.
4137
lazy_import.disallow_proxying()
4138
4139
from bzrlib import tests
4140
3593
4141
if testspecs_list is not None:
3594
4142
pattern = '|'.join(testspecs_list)
3595
4143
else:
3598
4146
try:
3599
4147
from bzrlib.tests import SubUnitBzrRunner
3600
4148
except ImportError:
3601
raise errors.BzrCommandError("subunit not available. subunit "
3602
"needs to be installed to use --subunit.")
4149
raise errors.BzrCommandError(gettext("subunit not available. subunit "
4150
"needs to be installed to use --subunit."))
3603
4151
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
4152
# On Windows, disable automatic conversion of '\n' to '\r\n' in
4153
# stdout, which would corrupt the subunit stream.
4154
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
4155
# following code can be deleted when it's sufficiently deployed
4156
# -- vila/mgz 20100514
4157
if (sys.platform == "win32"
4158
and getattr(sys.stdout, 'fileno', None) is not None):
4159
import msvcrt
4160
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3604
4161
if parallel:
3605
4162
self.additional_selftest_args.setdefault(
3606
4163
'suite_decorators', []).append(parallel)
3607
4164
if benchmark:
3608
test_suite_factory = benchmarks.test_suite
3609
# Unless user explicitly asks for quiet, be verbose in benchmarks
3610
verbose = not is_quiet()
3611
# TODO: should possibly lock the history file...
3612
benchfile = open(".perf_history", "at", buffering=1)
3613
self.add_cleanup(benchfile.close)
4165
raise errors.BzrCommandError(gettext(
4166
"--benchmark is no longer supported from bzr 2.2; "
4167
"use bzr-usertest instead"))
4168
test_suite_factory = None
4169
if not exclude:
4170
exclude_pattern = None
3614
4171
else:
3615
test_suite_factory = None
3616
benchfile = None
4172
exclude_pattern = '(' + '|'.join(exclude) + ')'
4173
if not sync:
4174
self._disable_fsync()
3617
4175
selftest_kwargs = {"verbose": verbose,
3618
4176
"pattern": pattern,
3619
4177
"stop_on_failure": one,
3621
4179
"test_suite_factory": test_suite_factory,
3622
4180
"lsprof_timed": lsprof_timed,
3623
4181
"lsprof_tests": lsprof_tests,
3624
"bench_history": benchfile,
3625
4182
"matching_tests_first": first,
3626
4183
"list_only": list_only,
3627
4184
"random_seed": randomize,
3628
"exclude_pattern": exclude,
4185
"exclude_pattern": exclude_pattern,
3629
4186
"strict": strict,
3630
4187
"load_list": load_list,
3631
4188
"debug_flags": debugflag,
3632
4189
"starting_with": starting_with
3633
4190
}
3634
4191
selftest_kwargs.update(self.additional_selftest_args)
3635
result = selftest(**selftest_kwargs)
4192
4193
# Make deprecation warnings visible, unless -Werror is set
4194
cleanup = symbol_versioning.activate_deprecation_warnings(
4195
override=False)
4196
try:
4197
result = tests.selftest(**selftest_kwargs)
4198
finally:
4199
cleanup()
3636
4200
return int(not result)
3637
4201
4202
def _disable_fsync(self):
4203
"""Change the 'os' functionality to not synchronize."""
4204
self._orig_fsync = getattr(os, 'fsync', None)
4205
if self._orig_fsync is not None:
4206
os.fsync = lambda filedes: None
4207
self._orig_fdatasync = getattr(os, 'fdatasync', None)
4208
if self._orig_fdatasync is not None:
4209
os.fdatasync = lambda filedes: None
4210
3638
4211
3639
4212
class cmd_version(Command):
3640
"""Show version of bzr."""
4213
__doc__ = """Show version of bzr."""
3641
4214
3642
4215
encoding_type = 'replace'
3643
4216
takes_options = [
3654
4227
3655
4228
3656
4229
class cmd_rocks(Command):
3657
"""Statement of optimism."""
4230
__doc__ = """Statement of optimism."""
3658
4231
3659
4232
hidden = True
3660
4233
3661
4234
@display_command
3662
4235
def run(self):
3663
self.outf.write("It sure does!\n")
4236
self.outf.write(gettext("It sure does!\n"))
3664
4237
3665
4238
3666
4239
class cmd_find_merge_base(Command):
3667
"""Find and print a base revision for merging two branches."""
4240
__doc__ = """Find and print a base revision for merging two branches."""
3668
4241
# TODO: Options to specify revisions on either side, as if
3669
4242
# merging only part of the history.
3670
4243
takes_args = ['branch', 'other']
3676
4249
3677
4250
branch1 = Branch.open_containing(branch)[0]
3678
4251
branch2 = Branch.open_containing(other)[0]
3679
branch1.lock_read()
3680
self.add_cleanup(branch1.unlock)
3681
branch2.lock_read()
3682
self.add_cleanup(branch2.unlock)
4252
self.add_cleanup(branch1.lock_read().unlock)
4253
self.add_cleanup(branch2.lock_read().unlock)
3683
4254
last1 = ensure_null(branch1.last_revision())
3684
4255
last2 = ensure_null(branch2.last_revision())
3685
4256
3686
4257
graph = branch1.repository.get_graph(branch2.repository)
3687
4258
base_rev_id = graph.find_unique_lca(last1, last2)
3688
4259
3689
self.outf.write('merge base is revision %s\n' % base_rev_id)
4260
self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
3690
4261
3691
4262
3692
4263
class cmd_merge(Command):
3693
"""Perform a three-way merge.
4264
__doc__ = """Perform a three-way merge.
3694
4265
3695
4266
The source of the merge can be specified either in the form of a branch,
3696
4267
or in the form of a path to a file containing a merge directive generated
3697
4268
with bzr send. If neither is specified, the default is the upstream branch
3698
or the branch most recently merged using --remember.
3699
3700
When merging a branch, by default the tip will be merged. To pick a different
3701
revision, pass --revision. If you specify two values, the first will be used as
3702
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3703
available revisions, like this is commonly referred to as "cherrypicking".
3704
3705
Revision numbers are always relative to the branch being merged.
3706
3707
By default, bzr will try to merge in all new work from the other
3708
branch, automatically determining an appropriate base. If this
3709
fails, you may need to give an explicit base.
4269
or the branch most recently merged using --remember. The source of the
4270
merge may also be specified in the form of a path to a file in another
4271
branch: in this case, only the modifications to that file are merged into
4272
the current working tree.
4273
4274
When merging from a branch, by default bzr will try to merge in all new
4275
work from the other branch, automatically determining an appropriate base
4276
revision. If this fails, you may need to give an explicit base.
4277
4278
To pick a different ending revision, pass "--revision OTHER". bzr will
4279
try to merge in all new work up to and including revision OTHER.
4280
4281
If you specify two values, "--revision BASE..OTHER", only revisions BASE
4282
through OTHER, excluding BASE but including OTHER, will be merged. If this
4283
causes some revisions to be skipped, i.e. if the destination branch does
4284
not already contain revision BASE, such a merge is commonly referred to as
4285
a "cherrypick". Unlike a normal merge, Bazaar does not currently track
4286
cherrypicks. The changes look like a normal commit, and the history of the
4287
changes from the other branch is not stored in the commit.
4288
4289
Revision numbers are always relative to the source branch.
3710
4290
3711
4291
Merge will do its best to combine the changes in two branches, but there
3712
4292
are some kinds of problems only a human can fix. When it encounters those,
3713
4293
it will mark a conflict. A conflict means that you need to fix something,
3714
before you should commit.
4294
before you can commit.
3715
4295
3716
4296
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3717
4297
3718
If there is no default branch set, the first merge will set it. After
3719
that, you can omit the branch to use the default. To change the
3720
default, use --remember. The value will only be saved if the remote
3721
location can be accessed.
4298
If there is no default branch set, the first merge will set it (use
4299
--no-remember to avoid setting it). After that, you can omit the branch
4300
to use the default. To change the default, use --remember. The value will
4301
only be saved if the remote location can be accessed.
3722
4302
3723
4303
The results of the merge are placed into the destination working
3724
4304
directory, where they can be reviewed (with bzr diff), tested, and then
3725
4305
committed to record the result of the merge.
3726
4306
3727
4307
merge refuses to run if there are any uncommitted changes, unless
3728
--force is given. The --force option can also be used to create a
4308
--force is given. If --force is given, then the changes from the source
4309
will be merged with the current working tree, including any uncommitted
4310
changes in the tree. The --force option can also be used to create a
3729
4311
merge revision which has more than two parents.
3730
4312
3731
4313
If one would like to merge changes from the working tree of the other
3736
4318
you to apply each diff hunk and file change, similar to "shelve".
3737
4319
3738
4320
:Examples:
3739
To merge the latest revision from bzr.dev::
4321
To merge all new revisions from bzr.dev::
3740
4322
3741
4323
bzr merge ../bzr.dev
3742
4324
3779
4361
' completely merged into the source, pull from the'
3780
4362
' source rather than merging. When this happens,'
3781
4363
' you do not need to commit the result.'),
3782
Option('directory',
4364
custom_help('directory',
3783
4365
help='Branch to merge into, '
3784
'rather than the one containing the working directory.',
3785
short_name='d',
3786
type=unicode,
3787
),
4366
'rather than the one containing the working directory.'),
3788
4367
Option('preview', help='Instead of merging, show a diff of the'
3789
4368
' merge.'),
3790
4369
Option('interactive', help='Select changes interactively.',
3792
4371
]
3793
4372
3794
4373
def run(self, location=None, revision=None, force=False,
3795
merge_type=None, show_base=False, reprocess=None, remember=False,
4374
merge_type=None, show_base=False, reprocess=None, remember=None,
3796
4375
uncommitted=False, pull=False,
3797
4376
directory=None,
3798
4377
preview=False,
3806
4385
merger = None
3807
4386
allow_pending = True
3808
4387
verified = 'inapplicable'
4388
3809
4389
tree = WorkingTree.open_containing(directory)[0]
4390
if tree.branch.revno() == 0:
4391
raise errors.BzrCommandError(gettext('Merging into empty branches not currently supported, '
4392
'https://bugs.launchpad.net/bzr/+bug/308562'))
3810
4393
3811
4394
try:
3812
4395
basis_tree = tree.revision_tree(tree.last_revision())
3823
4406
unversioned_filter=tree.is_ignored, view_info=view_info)
3824
4407
pb = ui.ui_factory.nested_progress_bar()
3825
4408
self.add_cleanup(pb.finished)
3826
tree.lock_write()
3827
self.add_cleanup(tree.unlock)
4409
self.add_cleanup(tree.lock_write().unlock)
3828
4410
if location is not None:
3829
4411
try:
3830
4412
mergeable = bundle.read_mergeable_from_url(location,
3833
4415
mergeable = None
3834
4416
else:
3835
4417
if uncommitted:
3836
raise errors.BzrCommandError('Cannot use --uncommitted'
3837
' with bundles or merge directives.')
4418
raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
4419
' with bundles or merge directives.'))
3838
4420
3839
4421
if revision is not None:
3840
raise errors.BzrCommandError(
3841
'Cannot use -r with merge directives or bundles')
4422
raise errors.BzrCommandError(gettext(
4423
'Cannot use -r with merge directives or bundles'))
3842
4424
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3843
4425
mergeable, None)
3844
4426
3845
4427
if merger is None and uncommitted:
3846
4428
if revision is not None and len(revision) > 0:
3847
raise errors.BzrCommandError('Cannot use --uncommitted and'
3848
' --revision at the same time.')
4429
raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
4430
' --revision at the same time.'))
3849
4431
merger = self.get_merger_from_uncommitted(tree, location, None)
3850
4432
allow_pending = False
3851
4433
3859
4441
self.sanity_check_merger(merger)
3860
4442
if (merger.base_rev_id == merger.other_rev_id and
3861
4443
merger.other_rev_id is not None):
3862
note('Nothing to do.')
4444
# check if location is a nonexistent file (and not a branch) to
4445
# disambiguate the 'Nothing to do'
4446
if merger.interesting_files:
4447
if not merger.other_tree.has_filename(
4448
merger.interesting_files[0]):
4449
note(gettext("merger: ") + str(merger))
4450
raise errors.PathsDoNotExist([location])
4451
note(gettext('Nothing to do.'))
3863
4452
return 0
3864
if pull:
4453
if pull and not preview:
3865
4454
if merger.interesting_files is not None:
3866
raise errors.BzrCommandError('Cannot pull individual files')
4455
raise errors.BzrCommandError(gettext('Cannot pull individual files'))
3867
4456
if (merger.base_rev_id == tree.last_revision()):
3868
4457
result = tree.pull(merger.other_branch, False,
3869
4458
merger.other_rev_id)
3870
4459
result.report(self.outf)
3871
4460
return 0
3872
4461
if merger.this_basis is None:
3873
raise errors.BzrCommandError(
4462
raise errors.BzrCommandError(gettext(
3874
4463
"This branch has no commits."
3875
" (perhaps you would prefer 'bzr pull')")
4464
" (perhaps you would prefer 'bzr pull')"))
3876
4465
if preview:
3877
4466
return self._do_preview(merger)
3878
4467
elif interactive:
3891
4480
def _do_preview(self, merger):
3892
4481
from bzrlib.diff import show_diff_trees
3893
4482
result_tree = self._get_preview(merger)
4483
path_encoding = osutils.get_diff_header_encoding()
3894
4484
show_diff_trees(merger.this_tree, result_tree, self.outf,
3895
old_label='', new_label='')
4485
old_label='', new_label='',
4486
path_encoding=path_encoding)
3896
4487
3897
4488
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3898
4489
merger.change_reporter = change_reporter
3927
4518
def sanity_check_merger(self, merger):
3928
4519
if (merger.show_base and
3929
4520
not merger.merge_type is _mod_merge.Merge3Merger):
3930
raise errors.BzrCommandError("Show-base is not supported for this"
3931
" merge type. %s" % merger.merge_type)
4521
raise errors.BzrCommandError(gettext("Show-base is not supported for this"
4522
" merge type. %s") % merger.merge_type)
3932
4523
if merger.reprocess is None:
3933
4524
if merger.show_base:
3934
4525
merger.reprocess = False
3936
4527
# Use reprocess if the merger supports it
3937
4528
merger.reprocess = merger.merge_type.supports_reprocess
3938
4529
if merger.reprocess and not merger.merge_type.supports_reprocess:
3939
raise errors.BzrCommandError("Conflict reduction is not supported"
3940
" for merge type %s." %
4530
raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
4531
" for merge type %s.") %
3941
4532
merger.merge_type)
3942
4533
if merger.reprocess and merger.show_base:
3943
raise errors.BzrCommandError("Cannot do conflict reduction and"
3944
" show base.")
4534
raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
4535
" show base."))
3945
4536
3946
4537
def _get_merger_from_branch(self, tree, location, revision, remember,
3947
4538
possible_transports, pb):
3974
4565
if other_revision_id is None:
3975
4566
other_revision_id = _mod_revision.ensure_null(
3976
4567
other_branch.last_revision())
3977
# Remember where we merge from
3978
if ((remember or tree.branch.get_submit_branch() is None) and
3979
user_location is not None):
4568
# Remember where we merge from. We need to remember if:
4569
# - user specify a location (and we don't merge from the parent
4570
# branch)
4571
# - user ask to remember or there is no previous location set to merge
4572
# from and user didn't ask to *not* remember
4573
if (user_location is not None
4574
and ((remember
4575
or (remember is None
4576
and tree.branch.get_submit_branch() is None)))):
3980
4577
tree.branch.set_submit_branch(other_branch.base)
3981
_merge_tags_if_possible(other_branch, tree.branch)
4578
# Merge tags (but don't set them in the master branch yet, the user
4579
# might revert this merge). Commit will propagate them.
4580
_merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3982
4581
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3983
4582
other_revision_id, base_revision_id, other_branch, base_branch)
3984
4583
if other_path != '':
4043
4642
stored_location_type = "parent"
4044
4643
mutter("%s", stored_location)
4045
4644
if stored_location is None:
4046
raise errors.BzrCommandError("No location specified or remembered")
4645
raise errors.BzrCommandError(gettext("No location specified or remembered"))
4047
4646
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4048
note(u"%s remembered %s location %s", verb_string,
4049
stored_location_type, display_url)
4647
note(gettext("{0} remembered {1} location {2}").format(verb_string,
4648
stored_location_type, display_url))
4050
4649
return stored_location
4051
4650
4052
4651
4053
4652
class cmd_remerge(Command):
4054
"""Redo a merge.
4653
__doc__ = """Redo a merge.
4055
4654
4056
4655
Use this if you want to try a different merge technique while resolving
4057
4656
conflicts. Some merge techniques are better than others, and remerge
4085
4684
from bzrlib.conflicts import restore
4086
4685
if merge_type is None:
4087
4686
merge_type = _mod_merge.Merge3Merger
4088
tree, file_list = tree_files(file_list)
4089
tree.lock_write()
4090
self.add_cleanup(tree.unlock)
4687
tree, file_list = WorkingTree.open_containing_paths(file_list)
4688
self.add_cleanup(tree.lock_write().unlock)
4091
4689
parents = tree.get_parent_ids()
4092
4690
if len(parents) != 2:
4093
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4691
raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4094
4692
" merges. Not cherrypicking or"
4095
" multi-merges.")
4693
" multi-merges."))
4096
4694
repository = tree.branch.repository
4097
4695
interesting_ids = None
4098
4696
new_conflicts = []
4107
4705
if tree.kind(file_id) != "directory":
4108
4706
continue
4109
4707
4110
for name, ie in tree.inventory.iter_entries(file_id):
4708
# FIXME: Support nested trees
4709
for name, ie in tree.root_inventory.iter_entries(file_id):
4111
4710
interesting_ids.add(ie.file_id)
4112
4711
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4113
4712
else:
4146
4745
4147
4746
4148
4747
class cmd_revert(Command):
4149
"""Revert files to a previous revision.
4748
__doc__ = """\
4749
Set files in the working tree back to the contents of a previous revision.
4150
4750
4151
4751
Giving a list of files will revert only those files. Otherwise, all files
4152
4752
will be reverted. If the revision is not specified with '--revision', the
4153
last committed revision is used.
4753
working tree basis revision is used. A revert operation affects only the
4754
working tree, not any revision history like the branch and repository or
4755
the working tree basis revision.
4154
4756
4155
4757
To remove only some changes, without reverting to a prior version, use
4156
merge instead. For example, "merge . --revision -2..-3" will remove the
4157
changes introduced by -2, without affecting the changes introduced by -1.
4158
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4758
merge instead. For example, "merge . -r -2..-3" (don't forget the ".")
4759
will remove the changes introduced by the second last commit (-2), without
4760
affecting the changes introduced by the last commit (-1). To remove
4761
certain changes on a hunk-by-hunk basis, see the shelve command.
4762
To update the branch to a specific revision or the latest revision and
4763
update the working tree accordingly while preserving local changes, see the
4764
update command.
4159
4765
4160
By default, any files that have been manually changed will be backed up
4161
first. (Files changed only by merge are not backed up.) Backup files have
4162
'.~#~' appended to their name, where # is a number.
4766
Uncommitted changes to files that are reverted will be discarded.
4767
Howver, by default, any files that have been manually changed will be
4768
backed up first. (Files changed only by merge are not backed up.) Backup
4769
files have '.~#~' appended to their name, where # is a number.
4163
4770
4164
4771
When you provide files, you can use their current pathname or the pathname
4165
4772
from the target revision. So you can use revert to "undelete" a file by
4191
4798
target branches.
4192
4799
"""
4193
4800
4194
_see_also = ['cat', 'export']
4801
_see_also = ['cat', 'export', 'merge', 'shelve']
4195
4802
takes_options = [
4196
4803
'revision',
4197
4804
Option('no-backup', "Do not save backups of reverted files."),
4202
4809
4203
4810
def run(self, revision=None, no_backup=False, file_list=None,
4204
4811
forget_merges=None):
4205
tree, file_list = tree_files(file_list)
4206
tree.lock_write()
4207
self.add_cleanup(tree.unlock)
4812
tree, file_list = WorkingTree.open_containing_paths(file_list)
4813
self.add_cleanup(tree.lock_tree_write().unlock)
4208
4814
if forget_merges:
4209
4815
tree.set_parent_ids(tree.get_parent_ids()[:1])
4210
4816
else:
4218
4824
4219
4825
4220
4826
class cmd_assert_fail(Command):
4221
"""Test reporting of assertion failures"""
4827
__doc__ = """Test reporting of assertion failures"""
4222
4828
# intended just for use in testing
4223
4829
4224
4830
hidden = True
4228
4834
4229
4835
4230
4836
class cmd_help(Command):
4231
"""Show help on a command or other topic.
4837
__doc__ = """Show help on a command or other topic.
4232
4838
"""
4233
4839
4234
4840
_see_also = ['topics']
4247
4853
4248
4854
4249
4855
class cmd_shell_complete(Command):
4250
"""Show appropriate completions for context.
4856
__doc__ = """Show appropriate completions for context.
4251
4857
4252
4858
For a list of all available commands, say 'bzr shell-complete'.
4253
4859
"""
4257
4863
4258
4864
@display_command
4259
4865
def run(self, context=None):
4260
import shellcomplete
4866
from bzrlib import shellcomplete
4261
4867
shellcomplete.shellcomplete(context)
4262
4868
4263
4869
4264
4870
class cmd_missing(Command):
4265
"""Show unmerged/unpulled revisions between two branches.
4871
__doc__ = """Show unmerged/unpulled revisions between two branches.
4266
4872
4267
4873
OTHER_BRANCH may be local or remote.
4268
4874
4299
4905
_see_also = ['merge', 'pull']
4300
4906
takes_args = ['other_branch?']
4301
4907
takes_options = [
4908
'directory',
4302
4909
Option('reverse', 'Reverse the order of revisions.'),
4303
4910
Option('mine-only',
4304
4911
'Display changes in the local branch only.'),
4316
4923
type=_parse_revision_str,
4317
4924
help='Filter on local branch revisions (inclusive). '
4318
4925
'See "help revisionspec" for details.'),
4319
Option('include-merges',
4926
Option('include-merged',
4320
4927
'Show all revisions in addition to the mainline ones.'),
4928
Option('include-merges', hidden=True,
4929
help='Historical alias for --include-merged.'),
4321
4930
]
4322
4931
encoding_type = 'replace'
4323
4932
4326
4935
theirs_only=False,
4327
4936
log_format=None, long=False, short=False, line=False,
4328
4937
show_ids=False, verbose=False, this=False, other=False,
4329
include_merges=False, revision=None, my_revision=None):
4938
include_merged=None, revision=None, my_revision=None,
4939
directory=u'.',
4940
include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4330
4941
from bzrlib.missing import find_unmerged, iter_log_revisions
4331
4942
def message(s):
4332
4943
if not is_quiet():
4333
4944
self.outf.write(s)
4334
4945
4946
if symbol_versioning.deprecated_passed(include_merges):
4947
ui.ui_factory.show_user_warning(
4948
'deprecated_command_option',
4949
deprecated_name='--include-merges',
4950
recommended_name='--include-merged',
4951
deprecated_in_version='2.5',
4952
command=self.invoked_as)
4953
if include_merged is None:
4954
include_merged = include_merges
4955
else:
4956
raise errors.BzrCommandError(gettext(
4957
'{0} and {1} are mutually exclusive').format(
4958
'--include-merges', '--include-merged'))
4959
if include_merged is None:
4960
include_merged = False
4335
4961
if this:
4336
4962
mine_only = this
4337
4963
if other:
4345
4971
elif theirs_only:
4346
4972
restrict = 'remote'
4347
4973
4348
local_branch = Branch.open_containing(u".")[0]
4349
local_branch.lock_read()
4350
self.add_cleanup(local_branch.unlock)
4974
local_branch = Branch.open_containing(directory)[0]
4975
self.add_cleanup(local_branch.lock_read().unlock)
4351
4976
4352
4977
parent = local_branch.get_parent()
4353
4978
if other_branch is None:
4354
4979
other_branch = parent
4355
4980
if other_branch is None:
4356
raise errors.BzrCommandError("No peer location known"
4357
" or specified.")
4981
raise errors.BzrCommandError(gettext("No peer location known"
4982
" or specified."))
4358
4983
display_url = urlutils.unescape_for_display(parent,
4359
4984
self.outf.encoding)
4360
message("Using saved parent location: "
4361
+ display_url + "\n")
4985
message(gettext("Using saved parent location: {0}\n").format(
4986
display_url))
4362
4987
4363
4988
remote_branch = Branch.open(other_branch)
4364
4989
if remote_branch.base == local_branch.base:
4365
4990
remote_branch = local_branch
4366
4991
else:
4367
remote_branch.lock_read()
4368
self.add_cleanup(remote_branch.unlock)
4992
self.add_cleanup(remote_branch.lock_read().unlock)
4369
4993
4370
4994
local_revid_range = _revision_range_to_revid_range(
4371
4995
_get_revision_range(my_revision, local_branch,
4378
5002
local_extra, remote_extra = find_unmerged(
4379
5003
local_branch, remote_branch, restrict,
4380
5004
backward=not reverse,
4381
include_merges=include_merges,
5005
include_merged=include_merged,
4382
5006
local_revid_range=local_revid_range,
4383
5007
remote_revid_range=remote_revid_range)
4384
5008
4391
5015
4392
5016
status_code = 0
4393
5017
if local_extra and not theirs_only:
4394
message("You have %d extra revision(s):\n" %
5018
message(ngettext("You have %d extra revision:\n",
5019
"You have %d extra revisions:\n",
5020
len(local_extra)) %
4395
5021
len(local_extra))
5022
rev_tag_dict = {}
5023
if local_branch.supports_tags():
5024
rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
4396
5025
for revision in iter_log_revisions(local_extra,
4397
5026
local_branch.repository,
4398
verbose):
5027
verbose,
5028
rev_tag_dict):
4399
5029
lf.log_revision(revision)
4400
5030
printed_local = True
4401
5031
status_code = 1
4405
5035
if remote_extra and not mine_only:
4406
5036
if printed_local is True:
4407
5037
message("\n\n\n")
4408
message("You are missing %d revision(s):\n" %
5038
message(ngettext("You are missing %d revision:\n",
5039
"You are missing %d revisions:\n",
5040
len(remote_extra)) %
4409
5041
len(remote_extra))
5042
if remote_branch.supports_tags():
5043
rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
4410
5044
for revision in iter_log_revisions(remote_extra,
4411
5045
remote_branch.repository,
4412
verbose):
5046
verbose,
5047
rev_tag_dict):
4413
5048
lf.log_revision(revision)
4414
5049
status_code = 1
4415
5050
4416
5051
if mine_only and not local_extra:
4417
5052
# We checked local, and found nothing extra
4418
message('This branch is up to date.\n')
5053
message(gettext('This branch has no new revisions.\n'))
4419
5054
elif theirs_only and not remote_extra:
4420
5055
# We checked remote, and found nothing extra
4421
message('Other branch is up to date.\n')
5056
message(gettext('Other branch has no new revisions.\n'))
4422
5057
elif not (mine_only or theirs_only or local_extra or
4423
5058
remote_extra):
4424
5059
# We checked both branches, and neither one had extra
4425
5060
# revisions
4426
message("Branches are up to date.\n")
5061
message(gettext("Branches are up to date.\n"))
4427
5062
self.cleanup_now()
4428
5063
if not status_code and parent is None and other_branch is not None:
4429
local_branch.lock_write()
4430
self.add_cleanup(local_branch.unlock)
5064
self.add_cleanup(local_branch.lock_write().unlock)
4431
5065
# handle race conditions - a parent might be set while we run.
4432
5066
if local_branch.get_parent() is None:
4433
5067
local_branch.set_parent(remote_branch.base)
4435
5069
4436
5070
4437
5071
class cmd_pack(Command):
4438
"""Compress the data within a repository."""
5072
__doc__ = """Compress the data within a repository.
5073
5074
This operation compresses the data within a bazaar repository. As
5075
bazaar supports automatic packing of repository, this operation is
5076
normally not required to be done manually.
5077
5078
During the pack operation, bazaar takes a backup of existing repository
5079
data, i.e. pack files. This backup is eventually removed by bazaar
5080
automatically when it is safe to do so. To save disk space by removing
5081
the backed up pack files, the --clean-obsolete-packs option may be
5082
used.
5083
5084
Warning: If you use --clean-obsolete-packs and your machine crashes
5085
during or immediately after repacking, you may be left with a state
5086
where the deletion has been written to disk but the new packs have not
5087
been. In this case the repository may be unusable.
5088
"""
4439
5089
4440
5090
_see_also = ['repositories']
4441
5091
takes_args = ['branch_or_repo?']
5092
takes_options = [
5093
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
5094
]
4442
5095
4443
def run(self, branch_or_repo='.'):
4444
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
5096
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
5097
dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
4445
5098
try:
4446
5099
branch = dir.open_branch()
4447
5100
repository = branch.repository
4448
5101
except errors.NotBranchError:
4449
5102
repository = dir.open_repository()
4450
repository.pack()
5103
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4451
5104
4452
5105
4453
5106
class cmd_plugins(Command):
4454
"""List the installed plugins.
5107
__doc__ = """List the installed plugins.
4455
5108
4456
5109
This command displays the list of installed plugins including
4457
5110
version of plugin and a short description of each.
4473
5126
4474
5127
@display_command
4475
5128
def run(self, verbose=False):
4476
import bzrlib.plugin
4477
from inspect import getdoc
4478
result = []
4479
for name, plugin in bzrlib.plugin.plugins().items():
4480
version = plugin.__version__
4481
if version == 'unknown':
4482
version = ''
4483
name_ver = '%s %s' % (name, version)
4484
d = getdoc(plugin.module)
4485
if d:
4486
doc = d.split('\n')[0]
4487
else:
4488
doc = '(no description)'
4489
result.append((name_ver, doc, plugin.path()))
4490
for name_ver, doc, path in sorted(result):
4491
self.outf.write("%s\n" % name_ver)
4492
self.outf.write(" %s\n" % doc)
4493
if verbose:
4494
self.outf.write(" %s\n" % path)
4495
self.outf.write("\n")
5129
from bzrlib import plugin
5130
# Don't give writelines a generator as some codecs don't like that
5131
self.outf.writelines(
5132
list(plugin.describe_plugins(show_paths=verbose)))
4496
5133
4497
5134
4498
5135
class cmd_testament(Command):
4499
"""Show testament (signing-form) of a revision."""
5136
__doc__ = """Show testament (signing-form) of a revision."""
4500
5137
takes_options = [
4501
5138
'revision',
4502
5139
Option('long', help='Produce long-format testament.'),
4503
5140
Option('strict',
4504
5141
help='Produce a strict-format testament.')]
4505
5142
takes_args = ['branch?']
5143
encoding_type = 'exact'
4506
5144
@display_command
4507
5145
def run(self, branch=u'.', revision=None, long=False, strict=False):
4508
5146
from bzrlib.testament import Testament, StrictTestament
4514
5152
b = Branch.open_containing(branch)[0]
4515
5153
else:
4516
5154
b = Branch.open(branch)
4517
b.lock_read()
4518
self.add_cleanup(b.unlock)
5155
self.add_cleanup(b.lock_read().unlock)
4519
5156
if revision is None:
4520
5157
rev_id = b.last_revision()
4521
5158
else:
4522
5159
rev_id = revision[0].as_revision_id(b)
4523
5160
t = testament_class.from_revision(b.repository, rev_id)
4524
5161
if long:
4525
sys.stdout.writelines(t.as_text_lines())
5162
self.outf.writelines(t.as_text_lines())
4526
5163
else:
4527
sys.stdout.write(t.as_short_text())
5164
self.outf.write(t.as_short_text())
4528
5165
4529
5166
4530
5167
class cmd_annotate(Command):
4531
"""Show the origin of each line in a file.
5168
__doc__ = """Show the origin of each line in a file.
4532
5169
4533
5170
This prints out the given file with an annotation on the left side
4534
5171
indicating which revision, author and date introduced the change.
4545
5182
Option('long', help='Show commit date in annotations.'),
4546
5183
'revision',
4547
5184
'show-ids',
5185
'directory',
4548
5186
]
4549
5187
encoding_type = 'exact'
4550
5188
4551
5189
@display_command
4552
5190
def run(self, filename, all=False, long=False, revision=None,
4553
show_ids=False):
4554
from bzrlib.annotate import annotate_file, annotate_file_tree
5191
show_ids=False, directory=None):
5192
from bzrlib.annotate import (
5193
annotate_file_tree,
5194
)
4555
5195
wt, branch, relpath = \
4556
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
5196
_open_directory_or_containing_tree_or_branch(filename, directory)
4557
5197
if wt is not None:
4558
wt.lock_read()
4559
self.add_cleanup(wt.unlock)
5198
self.add_cleanup(wt.lock_read().unlock)
4560
5199
else:
4561
branch.lock_read()
4562
self.add_cleanup(branch.unlock)
5200
self.add_cleanup(branch.lock_read().unlock)
4563
5201
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4564
tree.lock_read()
4565
self.add_cleanup(tree.unlock)
4566
if wt is not None:
5202
self.add_cleanup(tree.lock_read().unlock)
5203
if wt is not None and revision is None:
4567
5204
file_id = wt.path2id(relpath)
4568
5205
else:
4569
5206
file_id = tree.path2id(relpath)
4570
5207
if file_id is None:
4571
5208
raise errors.NotVersionedError(filename)
4572
file_version = tree.inventory[file_id].revision
4573
5209
if wt is not None and revision is None:
4574
5210
# If there is a tree and we're not annotating historical
4575
5211
# versions, annotate the working tree's content.
4576
5212
annotate_file_tree(wt, file_id, self.outf, long, all,
4577
5213
show_ids=show_ids)
4578
5214
else:
4579
annotate_file(branch, file_version, file_id, long, all, self.outf,
4580
show_ids=show_ids)
5215
annotate_file_tree(tree, file_id, self.outf, long, all,
5216
show_ids=show_ids, branch=branch)
4581
5217
4582
5218
4583
5219
class cmd_re_sign(Command):
4584
"""Create a digital signature for an existing revision."""
5220
__doc__ = """Create a digital signature for an existing revision."""
4585
5221
# TODO be able to replace existing ones.
4586
5222
4587
5223
hidden = True # is this right ?
4588
5224
takes_args = ['revision_id*']
4589
takes_options = ['revision']
5225
takes_options = ['directory', 'revision']
4590
5226
4591
def run(self, revision_id_list=None, revision=None):
5227
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4592
5228
if revision_id_list is not None and revision is not None:
4593
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
5229
raise errors.BzrCommandError(gettext('You can only supply one of revision_id or --revision'))
4594
5230
if revision_id_list is None and revision is None:
4595
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4596
b = WorkingTree.open_containing(u'.')[0].branch
4597
b.lock_write()
4598
self.add_cleanup(b.unlock)
5231
raise errors.BzrCommandError(gettext('You must supply either --revision or a revision_id'))
5232
b = WorkingTree.open_containing(directory)[0].branch
5233
self.add_cleanup(b.lock_write().unlock)
4599
5234
return self._run(b, revision_id_list, revision)
4600
5235
4601
5236
def _run(self, b, revision_id_list, revision):
4602
5237
import bzrlib.gpg as gpg
4603
gpg_strategy = gpg.GPGStrategy(b.get_config())
5238
gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4604
5239
if revision_id_list is not None:
4605
5240
b.repository.start_write_group()
4606
5241
try:
4631
5266
if to_revid is None:
4632
5267
to_revno = b.revno()
4633
5268
if from_revno is None or to_revno is None:
4634
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
5269
raise errors.BzrCommandError(gettext('Cannot sign a range of non-revision-history revisions'))
4635
5270
b.repository.start_write_group()
4636
5271
try:
4637
5272
for revno in range(from_revno, to_revno + 1):
4643
5278
else:
4644
5279
b.repository.commit_write_group()
4645
5280
else:
4646
raise errors.BzrCommandError('Please supply either one revision, or a range.')
5281
raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4647
5282
4648
5283
4649
5284
class cmd_bind(Command):
4650
"""Convert the current branch into a checkout of the supplied branch.
5285
__doc__ = """Convert the current branch into a checkout of the supplied branch.
5286
If no branch is supplied, rebind to the last bound location.
4651
5287
4652
5288
Once converted into a checkout, commits must succeed on the master branch
4653
5289
before they will be applied to the local branch.
4659
5295
4660
5296
_see_also = ['checkouts', 'unbind']
4661
5297
takes_args = ['location?']
4662
takes_options = []
5298
takes_options = ['directory']
4663
5299
4664
def run(self, location=None):
4665
b, relpath = Branch.open_containing(u'.')
5300
def run(self, location=None, directory=u'.'):
5301
b, relpath = Branch.open_containing(directory)
4666
5302
if location is None:
4667
5303
try:
4668
5304
location = b.get_old_bound_location()
4669
5305
except errors.UpgradeRequired:
4670
raise errors.BzrCommandError('No location supplied. '
4671
'This format does not remember old locations.')
5306
raise errors.BzrCommandError(gettext('No location supplied. '
5307
'This format does not remember old locations.'))
4672
5308
else:
4673
5309
if location is None:
4674
5310
if b.get_bound_location() is not None:
4675
raise errors.BzrCommandError('Branch is already bound')
5311
raise errors.BzrCommandError(
5312
gettext('Branch is already bound'))
4676
5313
else:
4677
raise errors.BzrCommandError('No location supplied '
4678
'and no previous location known')
5314
raise errors.BzrCommandError(
5315
gettext('No location supplied'
5316
' and no previous location known'))
4679
5317
b_other = Branch.open(location)
4680
5318
try:
4681
5319
b.bind(b_other)
4682
5320
except errors.DivergedBranches:
4683
raise errors.BzrCommandError('These branches have diverged.'
4684
' Try merging, and then bind again.')
5321
raise errors.BzrCommandError(gettext('These branches have diverged.'
5322
' Try merging, and then bind again.'))
4685
5323
if b.get_config().has_explicit_nickname():
4686
5324
b.nick = b_other.nick
4687
5325
4688
5326
4689
5327
class cmd_unbind(Command):
4690
"""Convert the current checkout into a regular branch.
5328
__doc__ = """Convert the current checkout into a regular branch.
4691
5329
4692
5330
After unbinding, the local branch is considered independent and subsequent
4693
5331
commits will be local only.
4695
5333
4696
5334
_see_also = ['checkouts', 'bind']
4697
5335
takes_args = []
4698
takes_options = []
5336
takes_options = ['directory']
4699
5337
4700
def run(self):
4701
b, relpath = Branch.open_containing(u'.')
5338
def run(self, directory=u'.'):
5339
b, relpath = Branch.open_containing(directory)
4702
5340
if not b.unbind():
4703
raise errors.BzrCommandError('Local branch is not bound')
5341
raise errors.BzrCommandError(gettext('Local branch is not bound'))
4704
5342
4705
5343
4706
5344
class cmd_uncommit(Command):
4707
"""Remove the last committed revision.
5345
__doc__ = """Remove the last committed revision.
4708
5346
4709
5347
--verbose will print out what is being removed.
4710
5348
--dry-run will go through all the motions, but not actually
4727
5365
takes_options = ['verbose', 'revision',
4728
5366
Option('dry-run', help='Don\'t actually make changes.'),
4729
5367
Option('force', help='Say yes to all questions.'),
5368
Option('keep-tags',
5369
help='Keep tags that point to removed revisions.'),
4730
5370
Option('local',
4731
5371
help="Only remove the commits from the local branch"
4732
5372
" when in a checkout."
4736
5376
aliases = []
4737
5377
encoding_type = 'replace'
4738
5378
4739
def run(self, location=None,
4740
dry_run=False, verbose=False,
4741
revision=None, force=False, local=False):
5379
def run(self, location=None, dry_run=False, verbose=False,
5380
revision=None, force=False, local=False, keep_tags=False):
4742
5381
if location is None:
4743
5382
location = u'.'
4744
control, relpath = bzrdir.BzrDir.open_containing(location)
5383
control, relpath = controldir.ControlDir.open_containing(location)
4745
5384
try:
4746
5385
tree = control.open_workingtree()
4747
5386
b = tree.branch
4750
5389
b = control.open_branch()
4751
5390
4752
5391
if tree is not None:
4753
tree.lock_write()
4754
self.add_cleanup(tree.unlock)
5392
self.add_cleanup(tree.lock_write().unlock)
4755
5393
else:
4756
b.lock_write()
4757
self.add_cleanup(b.unlock)
4758
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
5394
self.add_cleanup(b.lock_write().unlock)
5395
return self._run(b, tree, dry_run, verbose, revision, force,
5396
local, keep_tags)
4759
5397
4760
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
5398
def _run(self, b, tree, dry_run, verbose, revision, force, local,
5399
keep_tags):
4761
5400
from bzrlib.log import log_formatter, show_log
4762
5401
from bzrlib.uncommit import uncommit
4763
5402
4778
5417
rev_id = b.get_rev_id(revno)
4779
5418
4780
5419
if rev_id is None or _mod_revision.is_null(rev_id):
4781
self.outf.write('No revisions to uncommit.\n')
5420
self.outf.write(gettext('No revisions to uncommit.\n'))
4782
5421
return 1
4783
5422
4784
5423
lf = log_formatter('short',
4793
5432
end_revision=last_revno)
4794
5433
4795
5434
if dry_run:
4796
self.outf.write('Dry-run, pretending to remove'
4797
' the above revisions.\n')
5435
self.outf.write(gettext('Dry-run, pretending to remove'
5436
' the above revisions.\n'))
4798
5437
else:
4799
self.outf.write('The above revision(s) will be removed.\n')
5438
self.outf.write(gettext('The above revision(s) will be removed.\n'))
4800
5439
4801
5440
if not force:
4802
if not ui.ui_factory.get_boolean('Are you sure'):
4803
self.outf.write('Canceled')
5441
if not ui.ui_factory.confirm_action(
5442
gettext(u'Uncommit these revisions'),
5443
'bzrlib.builtins.uncommit',
5444
{}):
5445
self.outf.write(gettext('Canceled\n'))
4804
5446
return 0
4805
5447
4806
5448
mutter('Uncommitting from {%s} to {%s}',
4807
5449
last_rev_id, rev_id)
4808
5450
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4809
revno=revno, local=local)
4810
self.outf.write('You can restore the old tip by running:\n'
4811
' bzr pull . -r revid:%s\n' % last_rev_id)
5451
revno=revno, local=local, keep_tags=keep_tags)
5452
self.outf.write(gettext('You can restore the old tip by running:\n'
5453
' bzr pull . -r revid:%s\n') % last_rev_id)
4812
5454
4813
5455
4814
5456
class cmd_break_lock(Command):
4815
"""Break a dead lock on a repository, branch or working directory.
5457
__doc__ = """Break a dead lock.
5458
5459
This command breaks a lock on a repository, branch, working directory or
5460
config file.
4816
5461
4817
5462
CAUTION: Locks should only be broken when you are sure that the process
4818
5463
holding the lock has been stopped.
4823
5468
:Examples:
4824
5469
bzr break-lock
4825
5470
bzr break-lock bzr+ssh://example.com/bzr/foo
5471
bzr break-lock --conf ~/.bazaar
4826
5472
"""
5473
4827
5474
takes_args = ['location?']
5475
takes_options = [
5476
Option('config',
5477
help='LOCATION is the directory where the config lock is.'),
5478
Option('force',
5479
help='Do not ask for confirmation before breaking the lock.'),
5480
]
4828
5481
4829
def run(self, location=None, show=False):
5482
def run(self, location=None, config=False, force=False):
4830
5483
if location is None:
4831
5484
location = u'.'
4832
control, relpath = bzrdir.BzrDir.open_containing(location)
4833
try:
4834
control.break_lock()
4835
except NotImplementedError:
4836
pass
5485
if force:
5486
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
5487
None,
5488
{'bzrlib.lockdir.break': True})
5489
if config:
5490
conf = _mod_config.LockableConfig(file_name=location)
5491
conf.break_lock()
5492
else:
5493
control, relpath = controldir.ControlDir.open_containing(location)
5494
try:
5495
control.break_lock()
5496
except NotImplementedError:
5497
pass
4837
5498
4838
5499
4839
5500
class cmd_wait_until_signalled(Command):
4840
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
5501
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4841
5502
4842
5503
This just prints a line to signal when it is ready, then blocks on stdin.
4843
5504
"""
4851
5512
4852
5513
4853
5514
class cmd_serve(Command):
4854
"""Run the bzr server."""
5515
__doc__ = """Run the bzr server."""
4855
5516
4856
5517
aliases = ['server']
4857
5518
4862
5523
help="Protocol to serve.",
4863
5524
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4864
5525
value_switches=True),
5526
Option('listen',
5527
help='Listen for connections on nominated address.', type=str),
4865
5528
Option('port',
4866
help='Listen for connections on nominated port of the form '
4867
'[hostname:]portnumber. Passing 0 as the port number will '
4868
'result in a dynamically allocated port. The default port '
4869
'depends on the protocol.',
4870
type=str),
4871
Option('directory',
4872
help='Serve contents of this directory.',
4873
type=unicode),
5529
help='Listen for connections on nominated port. Passing 0 as '
5530
'the port number will result in a dynamically allocated '
5531
'port. The default port depends on the protocol.',
5532
type=int),
5533
custom_help('directory',
5534
help='Serve contents of this directory.'),
4874
5535
Option('allow-writes',
4875
5536
help='By default the server is a readonly server. Supplying '
4876
5537
'--allow-writes enables write access to the contents of '
4880
5541
'option leads to global uncontrolled write access to your '
4881
5542
'file system.'
4882
5543
),
5544
Option('client-timeout', type=float,
5545
help='Override the default idle client timeout (5min).'),
4883
5546
]
4884
5547
4885
def get_host_and_port(self, port):
4886
"""Return the host and port to run the smart server on.
4887
4888
If 'port' is None, None will be returned for the host and port.
4889
4890
If 'port' has a colon in it, the string before the colon will be
4891
interpreted as the host.
4892
4893
:param port: A string of the port to run the server on.
4894
:return: A tuple of (host, port), where 'host' is a host name or IP,
4895
and port is an integer TCP/IP port.
4896
"""
4897
host = None
4898
if port is not None:
4899
if ':' in port:
4900
host, port = port.split(':')
4901
port = int(port)
4902
return host, port
4903
4904
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4905
protocol=None):
4906
from bzrlib.transport import get_transport, transport_server_registry
5548
def run(self, listen=None, port=None, inet=False, directory=None,
5549
allow_writes=False, protocol=None, client_timeout=None):
5550
from bzrlib import transport
4907
5551
if directory is None:
4908
5552
directory = os.getcwd()
4909
5553
if protocol is None:
4910
protocol = transport_server_registry.get()
4911
host, port = self.get_host_and_port(port)
4912
url = urlutils.local_path_to_url(directory)
5554
protocol = transport.transport_server_registry.get()
5555
url = transport.location_to_url(directory)
4913
5556
if not allow_writes:
4914
5557
url = 'readonly+' + url
4915
transport = get_transport(url)
4916
protocol(transport, host, port, inet)
5558
t = transport.get_transport_from_url(url)
5559
protocol(t, listen, port, inet, client_timeout)
4917
5560
4918
5561
4919
5562
class cmd_join(Command):
4920
"""Combine a tree into its containing tree.
5563
__doc__ = """Combine a tree into its containing tree.
4921
5564
4922
5565
This command requires the target tree to be in a rich-root format.
4923
5566
4925
5568
not part of it. (Such trees can be produced by "bzr split", but also by
4926
5569
running "bzr branch" with the target inside a tree.)
4927
5570
4928
The result is a combined tree, with the subtree no longer an independant
5571
The result is a combined tree, with the subtree no longer an independent
4929
5572
part. This is marked as a merge of the subtree into the containing tree,
4930
5573
and all history is preserved.
4931
5574
"""
4942
5585
containing_tree = WorkingTree.open_containing(parent_dir)[0]
4943
5586
repo = containing_tree.branch.repository
4944
5587
if not repo.supports_rich_root():
4945
raise errors.BzrCommandError(
5588
raise errors.BzrCommandError(gettext(
4946
5589
"Can't join trees because %s doesn't support rich root data.\n"
4947
"You can use bzr upgrade on the repository."
5590
"You can use bzr upgrade on the repository.")
4948
5591
% (repo,))
4949
5592
if reference:
4950
5593
try:
4952
5595
except errors.BadReferenceTarget, e:
4953
5596
# XXX: Would be better to just raise a nicely printable
4954
5597
# exception from the real origin. Also below. mbp 20070306
4955
raise errors.BzrCommandError("Cannot join %s. %s" %
4956
(tree, e.reason))
5598
raise errors.BzrCommandError(
5599
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4957
5600
else:
4958
5601
try:
4959
5602
containing_tree.subsume(sub_tree)
4960
5603
except errors.BadSubsumeSource, e:
4961
raise errors.BzrCommandError("Cannot join %s. %s" %
4962
(tree, e.reason))
5604
raise errors.BzrCommandError(
5605
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4963
5606
4964
5607
4965
5608
class cmd_split(Command):
4966
"""Split a subdirectory of a tree into a separate tree.
5609
__doc__ = """Split a subdirectory of a tree into a separate tree.
4967
5610
4968
5611
This command will produce a target tree in a format that supports
4969
5612
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4989
5632
4990
5633
4991
5634
class cmd_merge_directive(Command):
4992
"""Generate a merge directive for auto-merge tools.
5635
__doc__ = """Generate a merge directive for auto-merge tools.
4993
5636
4994
5637
A directive requests a merge to be performed, and also provides all the
4995
5638
information necessary to do so. This means it must either include a
5012
5655
_see_also = ['send']
5013
5656
5014
5657
takes_options = [
5658
'directory',
5015
5659
RegistryOption.from_kwargs('patch-type',
5016
5660
'The type of patch to include in the directive.',
5017
5661
title='Patch type',
5030
5674
encoding_type = 'exact'
5031
5675
5032
5676
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5033
sign=False, revision=None, mail_to=None, message=None):
5677
sign=False, revision=None, mail_to=None, message=None,
5678
directory=u'.'):
5034
5679
from bzrlib.revision import ensure_null, NULL_REVISION
5035
5680
include_patch, include_bundle = {
5036
5681
'plain': (False, False),
5037
5682
'diff': (True, False),
5038
5683
'bundle': (True, True),
5039
5684
}[patch_type]
5040
branch = Branch.open('.')
5685
branch = Branch.open(directory)
5041
5686
stored_submit_branch = branch.get_submit_branch()
5042
5687
if submit_branch is None:
5043
5688
submit_branch = stored_submit_branch
5047
5692
if submit_branch is None:
5048
5693
submit_branch = branch.get_parent()
5049
5694
if submit_branch is None:
5050
raise errors.BzrCommandError('No submit branch specified or known')
5695
raise errors.BzrCommandError(gettext('No submit branch specified or known'))
5051
5696
5052
5697
stored_public_branch = branch.get_public_branch()
5053
5698
if public_branch is None:
5054
5699
public_branch = stored_public_branch
5055
5700
elif stored_public_branch is None:
5701
# FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5056
5702
branch.set_public_branch(public_branch)
5057
5703
if not include_bundle and public_branch is None:
5058
raise errors.BzrCommandError('No public branch specified or'
5059
' known')
5704
raise errors.BzrCommandError(gettext('No public branch specified or'
5705
' known'))
5060
5706
base_revision_id = None
5061
5707
if revision is not None:
5062
5708
if len(revision) > 2:
5063
raise errors.BzrCommandError('bzr merge-directive takes '
5064
'at most two one revision identifiers')
5709
raise errors.BzrCommandError(gettext('bzr merge-directive takes '
5710
'at most two one revision identifiers'))
5065
5711
revision_id = revision[-1].as_revision_id(branch)
5066
5712
if len(revision) == 2:
5067
5713
base_revision_id = revision[0].as_revision_id(branch)
5069
5715
revision_id = branch.last_revision()
5070
5716
revision_id = ensure_null(revision_id)
5071
5717
if revision_id == NULL_REVISION:
5072
raise errors.BzrCommandError('No revisions to bundle.')
5718
raise errors.BzrCommandError(gettext('No revisions to bundle.'))
5073
5719
directive = merge_directive.MergeDirective2.from_objects(
5074
5720
branch.repository, revision_id, time.time(),
5075
5721
osutils.local_time_offset(), submit_branch,
5083
5729
self.outf.writelines(directive.to_lines())
5084
5730
else:
5085
5731
message = directive.to_email(mail_to, branch, sign)
5086
s = SMTPConnection(branch.get_config())
5732
s = SMTPConnection(branch.get_config_stack())
5087
5733
s.send_email(message)
5088
5734
5089
5735
5090
5736
class cmd_send(Command):
5091
"""Mail or create a merge-directive for submitting changes.
5737
__doc__ = """Mail or create a merge-directive for submitting changes.
5092
5738
5093
5739
A merge directive provides many things needed for requesting merges:
5094
5740
5119
5765
source branch defaults to that containing the working directory, but can
5120
5766
be changed using --from.
5121
5767
5768
Both the submit branch and the public branch follow the usual behavior with
5769
respect to --remember: If there is no default location set, the first send
5770
will set it (use --no-remember to avoid setting it). After that, you can
5771
omit the location to use the default. To change the default, use
5772
--remember. The value will only be saved if the location can be accessed.
5773
5122
5774
In order to calculate those changes, bzr must analyse the submit branch.
5123
5775
Therefore it is most efficient for the submit branch to be a local mirror.
5124
5776
If a public location is known for the submit_branch, that location is used
5128
5780
given, in which case it is sent to a file.
5129
5781
5130
5782
Mail is sent using your preferred mail program. This should be transparent
5131
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5783
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5132
5784
If the preferred client can't be found (or used), your editor will be used.
5133
5785
5134
5786
To use a specific mail program, set the mail_client configuration option.
5193
5845
]
5194
5846
5195
5847
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5196
no_patch=False, revision=None, remember=False, output=None,
5848
no_patch=False, revision=None, remember=None, output=None,
5197
5849
format=None, mail_to=None, message=None, body=None,
5198
5850
strict=None, **kwargs):
5199
5851
from bzrlib.send import send
5205
5857
5206
5858
5207
5859
class cmd_bundle_revisions(cmd_send):
5208
"""Create a merge-directive for submitting changes.
5860
__doc__ = """Create a merge-directive for submitting changes.
5209
5861
5210
5862
A merge directive provides many things needed for requesting merges:
5211
5863
5278
5930
5279
5931
5280
5932
class cmd_tag(Command):
5281
"""Create, remove or modify a tag naming a revision.
5933
__doc__ = """Create, remove or modify a tag naming a revision.
5282
5934
5283
5935
Tags give human-meaningful names to revisions. Commands that take a -r
5284
5936
(--revision) option can be given -rtag:X, where X is any previously
5305
5957
Option('delete',
5306
5958
help='Delete this tag rather than placing it.',
5307
5959
),
5308
Option('directory',
5309
help='Branch in which to place the tag.',
5310
short_name='d',
5311
type=unicode,
5312
),
5960
custom_help('directory',
5961
help='Branch in which to place the tag.'),
5313
5962
Option('force',
5314
5963
help='Replace existing tags.',
5315
5964
),
5323
5972
revision=None,
5324
5973
):
5325
5974
branch, relpath = Branch.open_containing(directory)
5326
branch.lock_write()
5327
self.add_cleanup(branch.unlock)
5975
self.add_cleanup(branch.lock_write().unlock)
5328
5976
if delete:
5329
5977
if tag_name is None:
5330
raise errors.BzrCommandError("No tag specified to delete.")
5978
raise errors.BzrCommandError(gettext("No tag specified to delete."))
5331
5979
branch.tags.delete_tag(tag_name)
5332
self.outf.write('Deleted tag %s.\n' % tag_name)
5980
note(gettext('Deleted tag %s.') % tag_name)
5333
5981
else:
5334
5982
if revision:
5335
5983
if len(revision) != 1:
5336
raise errors.BzrCommandError(
5984
raise errors.BzrCommandError(gettext(
5337
5985
"Tags can only be placed on a single revision, "
5338
"not on a range")
5986
"not on a range"))
5339
5987
revision_id = revision[0].as_revision_id(branch)
5340
5988
else:
5341
5989
revision_id = branch.last_revision()
5342
5990
if tag_name is None:
5343
5991
tag_name = branch.automatic_tag_name(revision_id)
5344
5992
if tag_name is None:
5345
raise errors.BzrCommandError(
5346
"Please specify a tag name.")
5347
if (not force) and branch.tags.has_tag(tag_name):
5993
raise errors.BzrCommandError(gettext(
5994
"Please specify a tag name."))
5995
try:
5996
existing_target = branch.tags.lookup_tag(tag_name)
5997
except errors.NoSuchTag:
5998
existing_target = None
5999
if not force and existing_target not in (None, revision_id):
5348
6000
raise errors.TagAlreadyExists(tag_name)
5349
branch.tags.set_tag(tag_name, revision_id)
5350
self.outf.write('Created tag %s.\n' % tag_name)
6001
if existing_target == revision_id:
6002
note(gettext('Tag %s already exists for that revision.') % tag_name)
6003
else:
6004
branch.tags.set_tag(tag_name, revision_id)
6005
if existing_target is None:
6006
note(gettext('Created tag %s.') % tag_name)
6007
else:
6008
note(gettext('Updated tag %s.') % tag_name)
5351
6009
5352
6010
5353
6011
class cmd_tags(Command):
5354
"""List tags.
6012
__doc__ = """List tags.
5355
6013
5356
6014
This command shows a table of tag names and the revisions they reference.
5357
6015
"""
5358
6016
5359
6017
_see_also = ['tag']
5360
6018
takes_options = [
5361
Option('directory',
5362
help='Branch whose tags should be displayed.',
5363
short_name='d',
5364
type=unicode,
5365
),
5366
RegistryOption.from_kwargs('sort',
6019
custom_help('directory',
6020
help='Branch whose tags should be displayed.'),
6021
RegistryOption('sort',
5367
6022
'Sort tags by different criteria.', title='Sorting',
5368
alpha='Sort tags lexicographically (default).',
5369
time='Sort tags chronologically.',
6023
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5370
6024
),
5371
6025
'show-ids',
5372
6026
'revision',
5373
6027
]
5374
6028
5375
6029
@display_command
5376
def run(self,
5377
directory='.',
5378
sort='alpha',
5379
show_ids=False,
5380
revision=None,
5381
):
6030
def run(self, directory='.', sort=None, show_ids=False, revision=None):
6031
from bzrlib.tag import tag_sort_methods
5382
6032
branch, relpath = Branch.open_containing(directory)
5383
6033
5384
6034
tags = branch.tags.get_tag_dict().items()
5385
6035
if not tags:
5386
6036
return
5387
6037
5388
branch.lock_read()
5389
self.add_cleanup(branch.unlock)
6038
self.add_cleanup(branch.lock_read().unlock)
5390
6039
if revision:
5391
graph = branch.repository.get_graph()
5392
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5393
revid1, revid2 = rev1.rev_id, rev2.rev_id
5394
# only show revisions between revid1 and revid2 (inclusive)
5395
tags = [(tag, revid) for tag, revid in tags if
5396
graph.is_between(revid, revid1, revid2)]
5397
if sort == 'alpha':
5398
tags.sort()
5399
elif sort == 'time':
5400
timestamps = {}
5401
for tag, revid in tags:
5402
try:
5403
revobj = branch.repository.get_revision(revid)
5404
except errors.NoSuchRevision:
5405
timestamp = sys.maxint # place them at the end
5406
else:
5407
timestamp = revobj.timestamp
5408
timestamps[revid] = timestamp
5409
tags.sort(key=lambda x: timestamps[x[1]])
6040
# Restrict to the specified range
6041
tags = self._tags_for_range(branch, revision)
6042
if sort is None:
6043
sort = tag_sort_methods.get()
6044
sort(branch, tags)
5410
6045
if not show_ids:
5411
6046
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5412
6047
for index, (tag, revid) in enumerate(tags):
5414
6049
revno = branch.revision_id_to_dotted_revno(revid)
5415
6050
if isinstance(revno, tuple):
5416
6051
revno = '.'.join(map(str, revno))
5417
except errors.NoSuchRevision:
6052
except (errors.NoSuchRevision,
6053
errors.GhostRevisionsHaveNoRevno,
6054
errors.UnsupportedOperation):
5418
6055
# Bad tag data/merges can lead to tagged revisions
5419
6056
# which are not in this branch. Fail gracefully ...
5420
6057
revno = '?'
5423
6060
for tag, revspec in tags:
5424
6061
self.outf.write('%-20s %s\n' % (tag, revspec))
5425
6062
6063
def _tags_for_range(self, branch, revision):
6064
range_valid = True
6065
rev1, rev2 = _get_revision_range(revision, branch, self.name())
6066
revid1, revid2 = rev1.rev_id, rev2.rev_id
6067
# _get_revision_range will always set revid2 if it's not specified.
6068
# If revid1 is None, it means we want to start from the branch
6069
# origin which is always a valid ancestor. If revid1 == revid2, the
6070
# ancestry check is useless.
6071
if revid1 and revid1 != revid2:
6072
# FIXME: We really want to use the same graph than
6073
# branch.iter_merge_sorted_revisions below, but this is not
6074
# easily available -- vila 2011-09-23
6075
if branch.repository.get_graph().is_ancestor(revid2, revid1):
6076
# We don't want to output anything in this case...
6077
return []
6078
# only show revisions between revid1 and revid2 (inclusive)
6079
tagged_revids = branch.tags.get_reverse_tag_dict()
6080
found = []
6081
for r in branch.iter_merge_sorted_revisions(
6082
start_revision_id=revid2, stop_revision_id=revid1,
6083
stop_rule='include'):
6084
revid_tags = tagged_revids.get(r[0], None)
6085
if revid_tags:
6086
found.extend([(tag, r[0]) for tag in revid_tags])
6087
return found
6088
5426
6089
5427
6090
class cmd_reconfigure(Command):
5428
"""Reconfigure the type of a bzr directory.
6091
__doc__ = """Reconfigure the type of a bzr directory.
5429
6092
5430
6093
A target configuration must be specified.
5431
6094
5442
6105
takes_args = ['location?']
5443
6106
takes_options = [
5444
6107
RegistryOption.from_kwargs(
5445
'target_type',
5446
title='Target type',
5447
help='The type to reconfigure the directory to.',
6108
'tree_type',
6109
title='Tree type',
6110
help='The relation between branch and tree.',
5448
6111
value_switches=True, enum_switch=False,
5449
6112
branch='Reconfigure to be an unbound branch with no working tree.',
5450
6113
tree='Reconfigure to be an unbound branch with a working tree.',
5451
6114
checkout='Reconfigure to be a bound branch with a working tree.',
5452
6115
lightweight_checkout='Reconfigure to be a lightweight'
5453
6116
' checkout (with no local history).',
6117
),
6118
RegistryOption.from_kwargs(
6119
'repository_type',
6120
title='Repository type',
6121
help='Location fo the repository.',
6122
value_switches=True, enum_switch=False,
5454
6123
standalone='Reconfigure to be a standalone branch '
5455
6124
'(i.e. stop using shared repository).',
5456
6125
use_shared='Reconfigure to use a shared repository.',
6126
),
6127
RegistryOption.from_kwargs(
6128
'repository_trees',
6129
title='Trees in Repository',
6130
help='Whether new branches in the repository have trees.',
6131
value_switches=True, enum_switch=False,
5457
6132
with_trees='Reconfigure repository to create '
5458
6133
'working trees on branches by default.',
5459
6134
with_no_trees='Reconfigure repository to not create '
5473
6148
),
5474
6149
]
5475
6150
5476
def run(self, location=None, target_type=None, bind_to=None, force=False,
5477
stacked_on=None,
5478
unstacked=None):
5479
directory = bzrdir.BzrDir.open(location)
6151
def run(self, location=None, bind_to=None, force=False,
6152
tree_type=None, repository_type=None, repository_trees=None,
6153
stacked_on=None, unstacked=None):
6154
directory = controldir.ControlDir.open(location)
5480
6155
if stacked_on and unstacked:
5481
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
6156
raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5482
6157
elif stacked_on is not None:
5483
6158
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5484
6159
elif unstacked:
5486
6161
# At the moment you can use --stacked-on and a different
5487
6162
# reconfiguration shape at the same time; there seems no good reason
5488
6163
# to ban it.
5489
if target_type is None:
6164
if (tree_type is None and
6165
repository_type is None and
6166
repository_trees is None):
5490
6167
if stacked_on or unstacked:
5491
6168
return
5492
6169
else:
5493
raise errors.BzrCommandError('No target configuration '
5494
'specified')
5495
elif target_type == 'branch':
6170
raise errors.BzrCommandError(gettext('No target configuration '
6171
'specified'))
6172
reconfiguration = None
6173
if tree_type == 'branch':
5496
6174
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5497
elif target_type == 'tree':
6175
elif tree_type == 'tree':
5498
6176
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5499
elif target_type == 'checkout':
6177
elif tree_type == 'checkout':
5500
6178
reconfiguration = reconfigure.Reconfigure.to_checkout(
5501
6179
directory, bind_to)
5502
elif target_type == 'lightweight-checkout':
6180
elif tree_type == 'lightweight-checkout':
5503
6181
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5504
6182
directory, bind_to)
5505
elif target_type == 'use-shared':
6183
if reconfiguration:
6184
reconfiguration.apply(force)
6185
reconfiguration = None
6186
if repository_type == 'use-shared':
5506
6187
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5507
elif target_type == 'standalone':
6188
elif repository_type == 'standalone':
5508
6189
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5509
elif target_type == 'with-trees':
6190
if reconfiguration:
6191
reconfiguration.apply(force)
6192
reconfiguration = None
6193
if repository_trees == 'with-trees':
5510
6194
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5511
6195
directory, True)
5512
elif target_type == 'with-no-trees':
6196
elif repository_trees == 'with-no-trees':
5513
6197
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5514
6198
directory, False)
5515
reconfiguration.apply(force)
6199
if reconfiguration:
6200
reconfiguration.apply(force)
6201
reconfiguration = None
5516
6202
5517
6203
5518
6204
class cmd_switch(Command):
5519
"""Set the branch of a checkout and update.
6205
__doc__ = """Set the branch of a checkout and update.
5520
6206
5521
6207
For lightweight checkouts, this changes the branch being referenced.
5522
6208
For heavyweight checkouts, this checks that there are no local commits
5539
6225
"""
5540
6226
5541
6227
takes_args = ['to_location?']
5542
takes_options = [Option('force',
6228
takes_options = ['directory',
6229
Option('force',
5543
6230
help='Switch even if local commits will be lost.'),
5544
6231
'revision',
5545
6232
Option('create-branch', short_name='b',
5546
6233
help='Create the target branch from this one before'
5547
6234
' switching to it.'),
6235
Option('store',
6236
help='Store and restore uncommitted changes in the'
6237
' branch.'),
5548
6238
]
5549
6239
5550
6240
def run(self, to_location=None, force=False, create_branch=False,
5551
revision=None):
6241
revision=None, directory=u'.', store=False):
5552
6242
from bzrlib import switch
5553
tree_location = '.'
6243
tree_location = directory
5554
6244
revision = _get_one_revision('switch', revision)
5555
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
6245
possible_transports = []
6246
control_dir = controldir.ControlDir.open_containing(tree_location,
6247
possible_transports=possible_transports)[0]
5556
6248
if to_location is None:
5557
6249
if revision is None:
5558
raise errors.BzrCommandError('You must supply either a'
5559
' revision or a location')
5560
to_location = '.'
6250
raise errors.BzrCommandError(gettext('You must supply either a'
6251
' revision or a location'))
6252
to_location = tree_location
5561
6253
try:
5562
branch = control_dir.open_branch()
6254
branch = control_dir.open_branch(
6255
possible_transports=possible_transports)
5563
6256
had_explicit_nick = branch.get_config().has_explicit_nickname()
5564
6257
except errors.NotBranchError:
5565
6258
branch = None
5566
6259
had_explicit_nick = False
5567
6260
if create_branch:
5568
6261
if branch is None:
5569
raise errors.BzrCommandError('cannot create branch without'
5570
' source branch')
5571
to_location = directory_service.directories.dereference(
5572
to_location)
5573
if '/' not in to_location and '\\' not in to_location:
5574
# This path is meant to be relative to the existing branch
5575
this_url = self._get_branch_location(control_dir)
5576
to_location = urlutils.join(this_url, '..', to_location)
6262
raise errors.BzrCommandError(
6263
gettext('cannot create branch without source branch'))
6264
to_location = lookup_new_sibling_branch(control_dir, to_location,
6265
possible_transports=possible_transports)
5577
6266
to_branch = branch.bzrdir.sprout(to_location,
5578
possible_transports=[branch.bzrdir.root_transport],
5579
source_branch=branch).open_branch()
6267
possible_transports=possible_transports,
6268
source_branch=branch).open_branch()
5580
6269
else:
5581
6270
try:
5582
to_branch = Branch.open(to_location)
6271
to_branch = Branch.open(to_location,
6272
possible_transports=possible_transports)
5583
6273
except errors.NotBranchError:
5584
this_url = self._get_branch_location(control_dir)
5585
to_branch = Branch.open(
5586
urlutils.join(this_url, '..', to_location))
6274
to_branch = open_sibling_branch(control_dir, to_location,
6275
possible_transports=possible_transports)
5587
6276
if revision is not None:
5588
6277
revision = revision.as_revision_id(to_branch)
5589
switch.switch(control_dir, to_branch, force, revision_id=revision)
6278
switch.switch(control_dir, to_branch, force, revision_id=revision,
6279
store_uncommitted=store)
5590
6280
if had_explicit_nick:
5591
6281
branch = control_dir.open_branch() #get the new branch!
5592
6282
branch.nick = to_branch.nick
5593
note('Switched to branch: %s',
6283
note(gettext('Switched to branch: %s'),
5594
6284
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5595
6285
5596
def _get_branch_location(self, control_dir):
5597
"""Return location of branch for this control dir."""
5598
try:
5599
this_branch = control_dir.open_branch()
5600
# This may be a heavy checkout, where we want the master branch
5601
master_location = this_branch.get_bound_location()
5602
if master_location is not None:
5603
return master_location
5604
# If not, use a local sibling
5605
return this_branch.base
5606
except errors.NotBranchError:
5607
format = control_dir.find_branch_format()
5608
if getattr(format, 'get_reference', None) is not None:
5609
return format.get_reference(control_dir)
5610
else:
5611
return control_dir.root_transport.base
5612
6286
5613
6287
5614
6288
class cmd_view(Command):
5615
"""Manage filtered views.
6289
__doc__ = """Manage filtered views.
5616
6290
5617
6291
Views provide a mask over the tree so that users can focus on
5618
6292
a subset of a tree when doing their work. After creating a view,
5698
6372
name=None,
5699
6373
switch=None,
5700
6374
):
5701
tree, file_list = tree_files(file_list, apply_view=False)
6375
tree, file_list = WorkingTree.open_containing_paths(file_list,
6376
apply_view=False)
5702
6377
current_view, view_dict = tree.views.get_view_info()
5703
6378
if name is None:
5704
6379
name = current_view
5705
6380
if delete:
5706
6381
if file_list:
5707
raise errors.BzrCommandError(
5708
"Both --delete and a file list specified")
6382
raise errors.BzrCommandError(gettext(
6383
"Both --delete and a file list specified"))
5709
6384
elif switch:
5710
raise errors.BzrCommandError(
5711
"Both --delete and --switch specified")
6385
raise errors.BzrCommandError(gettext(
6386
"Both --delete and --switch specified"))
5712
6387
elif all:
5713
6388
tree.views.set_view_info(None, {})
5714
self.outf.write("Deleted all views.\n")
6389
self.outf.write(gettext("Deleted all views.\n"))
5715
6390
elif name is None:
5716
raise errors.BzrCommandError("No current view to delete")
6391
raise errors.BzrCommandError(gettext("No current view to delete"))
5717
6392
else:
5718
6393
tree.views.delete_view(name)
5719
self.outf.write("Deleted '%s' view.\n" % name)
6394
self.outf.write(gettext("Deleted '%s' view.\n") % name)
5720
6395
elif switch:
5721
6396
if file_list:
5722
raise errors.BzrCommandError(
5723
"Both --switch and a file list specified")
6397
raise errors.BzrCommandError(gettext(
6398
"Both --switch and a file list specified"))
5724
6399
elif all:
5725
raise errors.BzrCommandError(
5726
"Both --switch and --all specified")
6400
raise errors.BzrCommandError(gettext(
6401
"Both --switch and --all specified"))
5727
6402
elif switch == 'off':
5728
6403
if current_view is None:
5729
raise errors.BzrCommandError("No current view to disable")
6404
raise errors.BzrCommandError(gettext("No current view to disable"))
5730
6405
tree.views.set_view_info(None, view_dict)
5731
self.outf.write("Disabled '%s' view.\n" % (current_view))
6406
self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5732
6407
else:
5733
6408
tree.views.set_view_info(switch, view_dict)
5734
6409
view_str = views.view_display_str(tree.views.lookup_view())
5735
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
6410
self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
5736
6411
elif all:
5737
6412
if view_dict:
5738
self.outf.write('Views defined:\n')
6413
self.outf.write(gettext('Views defined:\n'))
5739
6414
for view in sorted(view_dict):
5740
6415
if view == current_view:
5741
6416
active = "=>"
5744
6419
view_str = views.view_display_str(view_dict[view])
5745
6420
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5746
6421
else:
5747
self.outf.write('No views defined.\n')
6422
self.outf.write(gettext('No views defined.\n'))
5748
6423
elif file_list:
5749
6424
if name is None:
5750
6425
# No name given and no current view set
5751
6426
name = 'my'
5752
6427
elif name == 'off':
5753
raise errors.BzrCommandError(
5754
"Cannot change the 'off' pseudo view")
6428
raise errors.BzrCommandError(gettext(
6429
"Cannot change the 'off' pseudo view"))
5755
6430
tree.views.set_view(name, sorted(file_list))
5756
6431
view_str = views.view_display_str(tree.views.lookup_view())
5757
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
6432
self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
5758
6433
else:
5759
6434
# list the files
5760
6435
if name is None:
5761
6436
# No name given and no current view set
5762
self.outf.write('No current view.\n')
6437
self.outf.write(gettext('No current view.\n'))
5763
6438
else:
5764
6439
view_str = views.view_display_str(tree.views.lookup_view(name))
5765
self.outf.write("'%s' view is: %s\n" % (name, view_str))
6440
self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
5766
6441
5767
6442
5768
6443
class cmd_hooks(Command):
5769
"""Show hooks."""
6444
__doc__ = """Show hooks."""
5770
6445
5771
6446
hidden = True
5772
6447
5782
6457
self.outf.write(" %s\n" %
5783
6458
(some_hooks.get_hook_name(hook),))
5784
6459
else:
5785
self.outf.write(" <no hooks installed>\n")
6460
self.outf.write(gettext(" <no hooks installed>\n"))
5786
6461
5787
6462
5788
6463
class cmd_remove_branch(Command):
5789
"""Remove a branch.
6464
__doc__ = """Remove a branch.
5790
6465
5791
6466
This will remove the branch from the specified location but
5792
6467
will keep any working tree or repository in place.
5801
6476
5802
6477
takes_args = ["location?"]
5803
6478
6479
takes_options = ['directory',
6480
Option('force', help='Remove branch even if it is the active branch.')]
6481
5804
6482
aliases = ["rmbranch"]
5805
6483
5806
def run(self, location=None):
5807
if location is None:
5808
location = "."
5809
branch = Branch.open_containing(location)[0]
5810
branch.bzrdir.destroy_branch()
5811
6484
def run(self, directory=None, location=None, force=False):
6485
br = open_nearby_branch(near=directory, location=location)
6486
if not force and br.bzrdir.has_workingtree():
6487
try:
6488
active_branch = br.bzrdir.open_branch(name="")
6489
except errors.NotBranchError:
6490
active_branch = None
6491
if (active_branch is not None and
6492
br.control_url == active_branch.control_url):
6493
raise errors.BzrCommandError(
6494
gettext("Branch is active. Use --force to remove it."))
6495
br.bzrdir.destroy_branch(br.name)
6496
5812
6497
5813
6498
class cmd_shelve(Command):
5814
"""Temporarily set aside some changes from the current tree.
6499
__doc__ = """Temporarily set aside some changes from the current tree.
5815
6500
5816
6501
Shelve allows you to temporarily put changes you've made "on the shelf",
5817
6502
ie. out of the way, until a later time when you can bring them back from
5833
6518
5834
6519
You can put multiple items on the shelf, and by default, 'unshelve' will
5835
6520
restore the most recently shelved changes.
6521
6522
For complicated changes, it is possible to edit the changes in a separate
6523
editor program to decide what the file remaining in the working copy
6524
should look like. To do this, add the configuration option
6525
6526
change_editor = PROGRAM @new_path @old_path
6527
6528
where @new_path is replaced with the path of the new version of the
6529
file and @old_path is replaced with the path of the old version of
6530
the file. The PROGRAM should save the new file with the desired
6531
contents of the file in the working tree.
6532
5836
6533
"""
5837
6534
5838
6535
takes_args = ['file*']
5839
6536
5840
6537
takes_options = [
6538
'directory',
5841
6539
'revision',
5842
6540
Option('all', help='Shelve all changes.'),
5843
6541
'message',
5849
6547
Option('destroy',
5850
6548
help='Destroy removed changes instead of shelving them.'),
5851
6549
]
5852
_see_also = ['unshelve']
6550
_see_also = ['unshelve', 'configuration']
5853
6551
5854
6552
def run(self, revision=None, all=False, file_list=None, message=None,
5855
writer=None, list=False, destroy=False):
6553
writer=None, list=False, destroy=False, directory=None):
5856
6554
if list:
5857
return self.run_for_list()
6555
return self.run_for_list(directory=directory)
5858
6556
from bzrlib.shelf_ui import Shelver
5859
6557
if writer is None:
5860
6558
writer = bzrlib.option.diff_writer_registry.get()
5861
6559
try:
5862
6560
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5863
file_list, message, destroy=destroy)
6561
file_list, message, destroy=destroy, directory=directory)
5864
6562
try:
5865
6563
shelver.run()
5866
6564
finally:
5868
6566
except errors.UserAbort:
5869
6567
return 0
5870
6568
5871
def run_for_list(self):
5872
tree = WorkingTree.open_containing('.')[0]
5873
tree.lock_read()
5874
self.add_cleanup(tree.unlock)
6569
def run_for_list(self, directory=None):
6570
if directory is None:
6571
directory = u'.'
6572
tree = WorkingTree.open_containing(directory)[0]
6573
self.add_cleanup(tree.lock_read().unlock)
5875
6574
manager = tree.get_shelf_manager()
5876
6575
shelves = manager.active_shelves()
5877
6576
if len(shelves) == 0:
5878
note('No shelved changes.')
6577
note(gettext('No shelved changes.'))
5879
6578
return 0
5880
6579
for shelf_id in reversed(shelves):
5881
6580
message = manager.get_metadata(shelf_id).get('message')
5886
6585
5887
6586
5888
6587
class cmd_unshelve(Command):
5889
"""Restore shelved changes.
6588
__doc__ = """Restore shelved changes.
5890
6589
5891
6590
By default, the most recently shelved changes are restored. However if you
5892
6591
specify a shelf by id those changes will be restored instead. This works
5895
6594
5896
6595
takes_args = ['shelf_id?']
5897
6596
takes_options = [
6597
'directory',
5898
6598
RegistryOption.from_kwargs(
5899
6599
'action', help="The action to perform.",
5900
6600
enum_switch=False, value_switches=True,
5908
6608
]
5909
6609
_see_also = ['shelve']
5910
6610
5911
def run(self, shelf_id=None, action='apply'):
6611
def run(self, shelf_id=None, action='apply', directory=u'.'):
5912
6612
from bzrlib.shelf_ui import Unshelver
5913
unshelver = Unshelver.from_args(shelf_id, action)
6613
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5914
6614
try:
5915
6615
unshelver.run()
5916
6616
finally:
5918
6618
5919
6619
5920
6620
class cmd_clean_tree(Command):
5921
"""Remove unwanted files from working tree.
6621
__doc__ = """Remove unwanted files from working tree.
5922
6622
5923
6623
By default, only unknown files, not ignored files, are deleted. Versioned
5924
6624
files are never deleted.
5932
6632
5933
6633
To check what clean-tree will do, use --dry-run.
5934
6634
"""
5935
takes_options = [Option('ignored', help='Delete all ignored files.'),
5936
Option('detritus', help='Delete conflict files, merge'
6635
takes_options = ['directory',
6636
Option('ignored', help='Delete all ignored files.'),
6637
Option('detritus', help='Delete conflict files, merge and revert'
5937
6638
' backups, and failed selftest dirs.'),
5938
6639
Option('unknown',
5939
6640
help='Delete files unknown to bzr (default).'),
5941
6642
' deleting them.'),
5942
6643
Option('force', help='Do not prompt before deleting.')]
5943
6644
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5944
force=False):
6645
force=False, directory=u'.'):
5945
6646
from bzrlib.clean_tree import clean_tree
5946
6647
if not (unknown or ignored or detritus):
5947
6648
unknown = True
5948
6649
if dry_run:
5949
6650
force = True
5950
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5951
dry_run=dry_run, no_prompt=force)
6651
clean_tree(directory, unknown=unknown, ignored=ignored,
6652
detritus=detritus, dry_run=dry_run, no_prompt=force)
5952
6653
5953
6654
5954
6655
class cmd_reference(Command):
5955
"""list, view and set branch locations for nested trees.
6656
__doc__ = """list, view and set branch locations for nested trees.
5956
6657
5957
6658
If no arguments are provided, lists the branch locations for nested trees.
5958
6659
If one argument is provided, display the branch location for that tree.
5968
6669
if path is not None:
5969
6670
branchdir = path
5970
6671
tree, branch, relpath =(
5971
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
6672
controldir.ControlDir.open_containing_tree_or_branch(branchdir))
5972
6673
if path is not None:
5973
6674
path = relpath
5974
6675
if tree is None:
5998
6699
self.outf.write('%s %s\n' % (path, location))
5999
6700
6000
6701
6702
class cmd_export_pot(Command):
6703
__doc__ = """Export command helps and error messages in po format."""
6704
6705
hidden = True
6706
takes_options = [Option('plugin',
6707
help='Export help text from named command '\
6708
'(defaults to all built in commands).',
6709
type=str),
6710
Option('include-duplicates',
6711
help='Output multiple copies of the same msgid '
6712
'string if it appears more than once.'),
6713
]
6714
6715
def run(self, plugin=None, include_duplicates=False):
6716
from bzrlib.export_pot import export_pot
6717
export_pot(self.outf, plugin, include_duplicates)
6718
6719
6001
6720
def _register_lazy_builtins():
6002
6721
# register lazy builtins from other modules; called at startup and should
6003
6722
# be only called once.
6004
6723
for (name, aliases, module_name) in [
6005
6724
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6725
('cmd_config', [], 'bzrlib.config'),
6006
6726
('cmd_dpush', [], 'bzrlib.foreign'),
6007
6727
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6008
6728
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6009
6729
('cmd_conflicts', [], 'bzrlib.conflicts'),
6010
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6730
('cmd_ping', [], 'bzrlib.smart.ping'),
6731
('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6732
('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
6733
('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6011
6734
]:
6012
6735
builtin_command_registry.register_lazy(name, aliases, module_name)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1