~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Jelmer Vernooij
  • Date: 2012-06-29 08:19:21 UTC
  • mfrom: (0.40.147 trunk)
  • mto: This revision was merged to the branch mainline in revision 6555.
  • Revision ID: jelmer@samba.org-20120629081921-m3asg03n6z9fzcxn
Ship the grep plugin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 bzrlib.bzrdir
 
24
 
 
25
from bzrlib import lazy_import
 
26
lazy_import.lazy_import(globals(), """
23
27
import cStringIO
 
28
import errno
24
29
import sys
25
30
import time
26
31
 
29
34
    bugtracker,
30
35
    bundle,
31
36
    btree_index,
32
 
    bzrdir,
 
37
    controldir,
33
38
    directory_service,
34
39
    delta,
35
40
    config as _mod_config,
44
49
    rename_map,
45
50
    revision as _mod_revision,
46
51
    static_tuple,
47
 
    symbol_versioning,
48
52
    timestamp,
49
53
    transport,
50
54
    ui,
51
55
    urlutils,
52
56
    views,
 
57
    gpg,
53
58
    )
54
59
from bzrlib.branch import Branch
55
60
from bzrlib.conflicts import ConflictList
57
62
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
58
63
from bzrlib.smtp_connection import SMTPConnection
59
64
from bzrlib.workingtree import WorkingTree
 
65
from bzrlib.i18n import gettext, ngettext
60
66
""")
61
67
 
62
68
from bzrlib.commands import (
72
78
    _parse_revision_str,
73
79
    )
74
80
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
75
 
 
76
 
 
77
 
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
 
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
 
    apply_view=True):
80
 
    return internal_tree_files(file_list, default_branch, canonicalize,
81
 
        apply_view)
 
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
82
221
 
83
222
 
84
223
def tree_files_for_add(file_list):
109
248
            if view_files:
110
249
                file_list = view_files
111
250
                view_str = views.view_display_str(view_files)
112
 
                note("Ignoring files outside view. View is %s" % view_str)
 
251
                note(gettext("Ignoring files outside view. View is %s") % view_str)
113
252
    return tree, file_list
114
253
 
115
254
 
117
256
    if revisions is None:
118
257
        return None
119
258
    if len(revisions) != 1:
120
 
        raise errors.BzrCommandError(
121
 
            'bzr %s --revision takes exactly one revision identifier' % (
 
259
        raise errors.BzrCommandError(gettext(
 
260
            'bzr %s --revision takes exactly one revision identifier') % (
122
261
                command_name,))
123
262
    return revisions[0]
124
263
 
146
285
    return rev_tree
147
286
 
148
287
 
149
 
# XXX: Bad function name; should possibly also be a class method of
150
 
# WorkingTree rather than a function.
151
 
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
152
 
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
153
 
    apply_view=True):
154
 
    """Convert command-line paths to a WorkingTree and relative paths.
155
 
 
156
 
    Deprecated: use WorkingTree.open_containing_paths instead.
157
 
 
158
 
    This is typically used for command-line processors that take one or
159
 
    more filenames, and infer the workingtree that contains them.
160
 
 
161
 
    The filenames given are not required to exist.
162
 
 
163
 
    :param file_list: Filenames to convert.
164
 
 
165
 
    :param default_branch: Fallback tree path to use if file_list is empty or
166
 
        None.
167
 
 
168
 
    :param apply_view: if True and a view is set, apply it or check that
169
 
        specified files are within it
170
 
 
171
 
    :return: workingtree, [relative_paths]
172
 
    """
173
 
    return WorkingTree.open_containing_paths(
174
 
        file_list, default_directory='.',
175
 
        canonicalize=True,
176
 
        apply_view=True)
177
 
 
178
 
 
179
288
def _get_view_info_for_change_reporter(tree):
180
289
    """Get the view information from a tree for change reporting."""
181
290
    view_info = None
193
302
    the --directory option is used to specify a different branch."""
194
303
    if directory is not None:
195
304
        return (None, Branch.open(directory), filename)
196
 
    return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
305
    return controldir.ControlDir.open_containing_tree_or_branch(filename)
197
306
 
198
307
 
199
308
# TODO: Make sure no commands unconditionally use the working directory as a
229
338
    unknown
230
339
        Not versioned and not matching an ignore pattern.
231
340
 
232
 
    Additionally for directories, symlinks and files with an executable
233
 
    bit, Bazaar indicates their type using a trailing character: '/', '@'
234
 
    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.
235
345
 
236
346
    To see ignored files use 'bzr ignored'.  For details on the
237
347
    changes to file texts, use 'bzr diff'.
250
360
    To skip the display of pending merge information altogether, use
251
361
    the no-pending option or specify a file/directory.
252
362
 
253
 
    If a revision argument is given, the status is calculated against
254
 
    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'.
255
369
    """
256
370
 
257
 
    # TODO: --no-recurse, --recurse options
 
371
    # TODO: --no-recurse/-N, --recurse options
258
372
 
259
373
    takes_args = ['file*']
260
374
    takes_options = ['show-ids', 'revision', 'change', 'verbose',
264
378
                            short_name='V'),
265
379
                     Option('no-pending', help='Don\'t show pending merges.',
266
380
                           ),
 
381
                     Option('no-classify',
 
382
                            help='Do not mark object type using indicator.',
 
383
                           ),
267
384
                     ]
268
385
    aliases = ['st', 'stat']
269
386
 
272
389
 
273
390
    @display_command
274
391
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
275
 
            versioned=False, no_pending=False, verbose=False):
 
392
            versioned=False, no_pending=False, verbose=False,
 
393
            no_classify=False):
276
394
        from bzrlib.status import show_tree_status
277
395
 
278
396
        if revision and len(revision) > 2:
279
 
            raise errors.BzrCommandError('bzr status --revision takes exactly'
280
 
                                         ' one or two revision specifiers')
 
397
            raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
 
398
                                         ' one or two revision specifiers'))
281
399
 
282
400
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
283
401
        # Avoid asking for specific files when that is not needed.
292
410
        show_tree_status(tree, show_ids=show_ids,
293
411
                         specific_files=relfile_list, revision=revision,
294
412
                         to_file=self.outf, short=short, versioned=versioned,
295
 
                         show_pending=(not no_pending), verbose=verbose)
 
413
                         show_pending=(not no_pending), verbose=verbose,
 
414
                         classify=not no_classify)
296
415
 
297
416
 
298
417
class cmd_cat_revision(Command):
319
438
    @display_command
320
439
    def run(self, revision_id=None, revision=None, directory=u'.'):
321
440
        if revision_id is not None and revision is not None:
322
 
            raise errors.BzrCommandError('You can only supply one of'
323
 
                                         ' revision_id or --revision')
 
441
            raise errors.BzrCommandError(gettext('You can only supply one of'
 
442
                                         ' revision_id or --revision'))
324
443
        if revision_id is None and revision is None:
325
 
            raise errors.BzrCommandError('You must supply either'
326
 
                                         ' --revision or a revision_id')
327
 
        b = WorkingTree.open_containing(directory)[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]
328
448
 
329
449
        revisions = b.repository.revisions
330
450
        if revisions is None:
331
 
            raise errors.BzrCommandError('Repository %r does not support '
332
 
                'access to raw revision texts')
 
451
            raise errors.BzrCommandError(gettext('Repository %r does not support '
 
452
                'access to raw revision texts'))
333
453
 
334
454
        b.repository.lock_read()
335
455
        try:
339
459
                try:
340
460
                    self.print_revision(revisions, revision_id)
341
461
                except errors.NoSuchRevision:
342
 
                    msg = "The repository %s contains no revision %s." % (
 
462
                    msg = gettext("The repository {0} contains no revision {1}.").format(
343
463
                        b.repository.base, revision_id)
344
464
                    raise errors.BzrCommandError(msg)
345
465
            elif revision is not None:
346
466
                for rev in revision:
347
467
                    if rev is None:
348
468
                        raise errors.BzrCommandError(
349
 
                            'You cannot specify a NULL revision.')
 
469
                            gettext('You cannot specify a NULL revision.'))
350
470
                    rev_id = rev.as_revision_id(b)
351
471
                    self.print_revision(revisions, rev_id)
352
472
        finally:
408
528
                self.outf.write(page_bytes[:header_end])
409
529
                page_bytes = data
410
530
            self.outf.write('\nPage %d\n' % (page_idx,))
411
 
            decomp_bytes = zlib.decompress(page_bytes)
412
 
            self.outf.write(decomp_bytes)
413
 
            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')
414
537
 
415
538
    def _dump_entries(self, trans, basename):
416
539
        try:
455
578
            location_list=['.']
456
579
 
457
580
        for location in location_list:
458
 
            d = bzrdir.BzrDir.open(location)
459
 
            
 
581
            d = controldir.ControlDir.open(location)
 
582
 
460
583
            try:
461
584
                working = d.open_workingtree()
462
585
            except errors.NoWorkingTree:
463
 
                raise errors.BzrCommandError("No working tree to remove")
 
586
                raise errors.BzrCommandError(gettext("No working tree to remove"))
464
587
            except errors.NotLocalUrl:
465
 
                raise errors.BzrCommandError("You cannot remove the working tree"
466
 
                                             " of a remote path")
 
588
                raise errors.BzrCommandError(gettext("You cannot remove the working tree"
 
589
                                             " of a remote path"))
467
590
            if not force:
468
591
                if (working.has_changes()):
469
592
                    raise errors.UncommittedChanges(working)
471
594
                    raise errors.ShelvedChanges(working)
472
595
 
473
596
            if working.user_url != working.branch.user_url:
474
 
                raise errors.BzrCommandError("You cannot remove the working tree"
475
 
                                             " from a lightweight checkout")
 
597
                raise errors.BzrCommandError(gettext("You cannot remove the working tree"
 
598
                                             " from a lightweight checkout"))
476
599
 
477
600
            d.destroy_workingtree()
478
601
 
479
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
 
480
655
class cmd_revno(Command):
481
656
    __doc__ = """Show current revision number.
482
657
 
486
661
    _see_also = ['info']
487
662
    takes_args = ['location?']
488
663
    takes_options = [
489
 
        Option('tree', help='Show revno of working tree'),
 
664
        Option('tree', help='Show revno of working tree.'),
 
665
        'revision',
490
666
        ]
491
667
 
492
668
    @display_command
493
 
    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
 
494
674
        if tree:
495
675
            try:
496
676
                wt = WorkingTree.open_containing(location)[0]
497
677
                self.add_cleanup(wt.lock_read().unlock)
498
678
            except (errors.NoWorkingTree, errors.NotLocalUrl):
499
679
                raise errors.NoWorkingTree(location)
 
680
            b = wt.branch
500
681
            revid = wt.last_revision()
501
 
            try:
502
 
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
503
 
            except errors.NoSuchRevision:
504
 
                revno_t = ('???',)
505
 
            revno = ".".join(str(n) for n in revno_t)
506
682
        else:
507
683
            b = Branch.open_containing(location)[0]
508
684
            self.add_cleanup(b.lock_read().unlock)
509
 
            revno = b.revno()
 
685
            if revision:
 
686
                if len(revision) != 1:
 
687
                    raise errors.BzrCommandError(gettext(
 
688
                        "Tags can only be placed on a single revision, "
 
689
                        "not on a range"))
 
690
                revid = revision[0].as_revision_id(b)
 
691
            else:
 
692
                revid = b.last_revision()
 
693
        try:
 
694
            revno_t = b.revision_id_to_dotted_revno(revid)
 
695
        except errors.NoSuchRevision:
 
696
            revno_t = ('???',)
 
697
        revno = ".".join(str(n) for n in revno_t)
510
698
        self.cleanup_now()
511
 
        self.outf.write(str(revno) + '\n')
 
699
        self.outf.write(revno + '\n')
512
700
 
513
701
 
514
702
class cmd_revision_info(Command):
521
709
        custom_help('directory',
522
710
            help='Branch to examine, '
523
711
                 'rather than the one containing the working directory.'),
524
 
        Option('tree', help='Show revno of working tree'),
 
712
        Option('tree', help='Show revno of working tree.'),
525
713
        ]
526
714
 
527
715
    @display_command
583
771
    are added.  This search proceeds recursively into versioned
584
772
    directories.  If no names are given '.' is assumed.
585
773
 
 
774
    A warning will be printed when nested trees are encountered,
 
775
    unless they are explicitly ignored.
 
776
 
586
777
    Therefore simply saying 'bzr add' will version all files that
587
778
    are currently unknown.
588
779
 
604
795
    
605
796
    Any files matching patterns in the ignore list will not be added
606
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.
607
802
    """
608
803
    takes_args = ['file*']
609
804
    takes_options = [
610
805
        Option('no-recurse',
611
 
               help="Don't recursively add the contents of directories."),
 
806
               help="Don't recursively add the contents of directories.",
 
807
               short_name='N'),
612
808
        Option('dry-run',
613
809
               help="Show what would be done, but don't actually do anything."),
614
810
        'verbose',
636
832
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
637
833
                          to_file=self.outf, should_print=(not is_quiet()))
638
834
        else:
639
 
            action = bzrlib.add.AddAction(to_file=self.outf,
 
835
            action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
640
836
                should_print=(not is_quiet()))
641
837
 
642
838
        if base_tree:
649
845
            if verbose:
650
846
                for glob in sorted(ignored.keys()):
651
847
                    for path in ignored[glob]:
652
 
                        self.outf.write("ignored %s matching \"%s\"\n"
653
 
                                        % (path, glob))
 
848
                        self.outf.write(
 
849
                         gettext("ignored {0} matching \"{1}\"\n").format(
 
850
                         path, glob))
654
851
 
655
852
 
656
853
class cmd_mkdir(Command):
660
857
    """
661
858
 
662
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
        ]
663
867
    encoding_type = 'replace'
664
868
 
665
 
    def run(self, dir_list):
666
 
        for d in dir_list:
667
 
            wt, dd = WorkingTree.open_containing(d)
668
 
            base = os.path.dirname(dd)
669
 
            id = wt.path2id(base)
670
 
            if id != None:
671
 
                os.mkdir(d)
672
 
                wt.add([dd])
673
 
                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
674
893
            else:
675
 
                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)
676
898
 
677
899
 
678
900
class cmd_relpath(Command):
714
936
    @display_command
715
937
    def run(self, revision=None, show_ids=False, kind=None, file_list=None):
716
938
        if kind and kind not in ['file', 'directory', 'symlink']:
717
 
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
 
939
            raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
718
940
 
719
941
        revision = _get_one_revision('inventory', revision)
720
942
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
728
950
            tree = work_tree
729
951
            extra_trees = []
730
952
 
 
953
        self.add_cleanup(tree.lock_read().unlock)
731
954
        if file_list is not None:
732
955
            file_ids = tree.paths2ids(file_list, trees=extra_trees,
733
956
                                      require_versioned=True)
734
957
            # find_ids_across_trees may include some paths that don't
735
958
            # exist in 'tree'.
736
 
            entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
737
 
                             for file_id in file_ids if file_id in tree)
 
959
            entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
738
960
        else:
739
 
            entries = tree.inventory.entries()
 
961
            entries = tree.iter_entries_by_dir()
740
962
 
741
 
        self.cleanup_now()
742
 
        for path, entry in entries:
 
963
        for path, entry in sorted(entries):
743
964
            if kind and kind != entry.kind:
744
965
                continue
 
966
            if path == "":
 
967
                continue
745
968
            if show_ids:
746
969
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
747
970
            else:
783
1006
        if auto:
784
1007
            return self.run_auto(names_list, after, dry_run)
785
1008
        elif dry_run:
786
 
            raise errors.BzrCommandError('--dry-run requires --auto.')
 
1009
            raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
787
1010
        if names_list is None:
788
1011
            names_list = []
789
1012
        if len(names_list) < 2:
790
 
            raise errors.BzrCommandError("missing file argument")
 
1013
            raise errors.BzrCommandError(gettext("missing file argument"))
791
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"))
792
1018
        self.add_cleanup(tree.lock_tree_write().unlock)
793
1019
        self._run(tree, names_list, rel_names, after)
794
1020
 
795
1021
    def run_auto(self, names_list, after, dry_run):
796
1022
        if names_list is not None and len(names_list) > 1:
797
 
            raise errors.BzrCommandError('Only one path may be specified to'
798
 
                                         ' --auto.')
 
1023
            raise errors.BzrCommandError(gettext('Only one path may be specified to'
 
1024
                                         ' --auto.'))
799
1025
        if after:
800
 
            raise errors.BzrCommandError('--after cannot be specified with'
801
 
                                         ' --auto.')
 
1026
            raise errors.BzrCommandError(gettext('--after cannot be specified with'
 
1027
                                         ' --auto.'))
802
1028
        work_tree, file_list = WorkingTree.open_containing_paths(
803
1029
            names_list, default_directory='.')
804
1030
        self.add_cleanup(work_tree.lock_tree_write().unlock)
816
1042
                and rel_names[0].lower() == rel_names[1].lower()):
817
1043
                into_existing = False
818
1044
            else:
819
 
                inv = tree.inventory
820
1045
                # 'fix' the case of a potential 'from'
821
1046
                from_id = tree.path2id(
822
1047
                            tree.get_canonical_inventory_path(rel_names[0]))
823
1048
                if (not osutils.lexists(names_list[0]) and
824
 
                    from_id and inv.get_file_kind(from_id) == "directory"):
 
1049
                    from_id and tree.stored_kind(from_id) == "directory"):
825
1050
                    into_existing = False
826
1051
        # move/rename
827
1052
        if into_existing:
834
1059
                    self.outf.write("%s => %s\n" % (src, dest))
835
1060
        else:
836
1061
            if len(names_list) != 2:
837
 
                raise errors.BzrCommandError('to mv multiple files the'
 
1062
                raise errors.BzrCommandError(gettext('to mv multiple files the'
838
1063
                                             ' destination must be a versioned'
839
 
                                             ' directory')
 
1064
                                             ' directory'))
840
1065
 
841
1066
            # for cicp file-systems: the src references an existing inventory
842
1067
            # item:
901
1126
    match the remote one, use pull --overwrite. This will work even if the two
902
1127
    branches have diverged.
903
1128
 
904
 
    If there is no default location set, the first pull will set it.  After
905
 
    that, you can omit the location to use the default.  To change the
906
 
    default, use --remember. The value will only be saved if the remote
907
 
    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>.
908
1137
 
909
1138
    Note: The location can be specified either in the form of a branch,
910
1139
    or in the form of a path to a file containing a merge directive generated
923
1152
                 "branch.  Local pulls are not applied to "
924
1153
                 "the master branch."
925
1154
            ),
 
1155
        Option('show-base',
 
1156
            help="Show base revision text in conflicts."),
 
1157
        Option('overwrite-tags',
 
1158
            help="Overwrite tags only."),
926
1159
        ]
927
1160
    takes_args = ['location?']
928
1161
    encoding_type = 'replace'
929
1162
 
930
 
    def run(self, location=None, remember=False, overwrite=False,
 
1163
    def run(self, location=None, remember=None, overwrite=False,
931
1164
            revision=None, verbose=False,
932
 
            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 = []
933
1174
        # FIXME: too much stuff is in the command class
934
1175
        revision_id = None
935
1176
        mergeable = None
944
1185
            branch_to = Branch.open_containing(directory)[0]
945
1186
            self.add_cleanup(branch_to.lock_write().unlock)
946
1187
 
 
1188
        if tree_to is None and show_base:
 
1189
            raise errors.BzrCommandError(gettext("Need working tree for --show-base."))
 
1190
 
947
1191
        if local and not branch_to.get_bound_location():
948
1192
            raise errors.LocalRequiresBoundBranch()
949
1193
 
958
1202
        stored_loc = branch_to.get_parent()
959
1203
        if location is None:
960
1204
            if stored_loc is None:
961
 
                raise errors.BzrCommandError("No pull location known or"
962
 
                                             " specified.")
 
1205
                raise errors.BzrCommandError(gettext("No pull location known or"
 
1206
                                             " specified."))
963
1207
            else:
964
1208
                display_url = urlutils.unescape_for_display(stored_loc,
965
1209
                        self.outf.encoding)
966
1210
                if not is_quiet():
967
 
                    self.outf.write("Using saved parent location: %s\n" % display_url)
 
1211
                    self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
968
1212
                location = stored_loc
969
1213
 
970
1214
        revision = _get_one_revision('pull', revision)
971
1215
        if mergeable is not None:
972
1216
            if revision is not None:
973
 
                raise errors.BzrCommandError(
974
 
                    'Cannot use -r with merge directives or bundles')
 
1217
                raise errors.BzrCommandError(gettext(
 
1218
                    'Cannot use -r with merge directives or bundles'))
975
1219
            mergeable.install_revisions(branch_to.repository)
976
1220
            base_revision_id, revision_id, verified = \
977
1221
                mergeable.get_merge_request(branch_to.repository)
980
1224
            branch_from = Branch.open(location,
981
1225
                possible_transports=possible_transports)
982
1226
            self.add_cleanup(branch_from.lock_read().unlock)
983
 
 
984
 
            if branch_to.get_parent() is None or remember:
 
1227
            # Remembers if asked explicitly or no previous location is set
 
1228
            if (remember
 
1229
                or (remember is None and branch_to.get_parent() is None)):
 
1230
                # FIXME: This shouldn't be done before the pull
 
1231
                # succeeds... -- vila 2012-01-02
985
1232
                branch_to.set_parent(branch_from.base)
986
1233
 
987
1234
        if revision is not None:
994
1241
                view_info=view_info)
995
1242
            result = tree_to.pull(
996
1243
                branch_from, overwrite, revision_id, change_reporter,
997
 
                possible_transports=possible_transports, local=local)
 
1244
                local=local, show_base=show_base)
998
1245
        else:
999
1246
            result = branch_to.pull(
1000
1247
                branch_from, overwrite, revision_id, local=local)
1004
1251
            log.show_branch_change(
1005
1252
                branch_to, self.outf, result.old_revno,
1006
1253
                result.old_revid)
 
1254
        if getattr(result, 'tag_conflicts', None):
 
1255
            return 1
 
1256
        else:
 
1257
            return 0
1007
1258
 
1008
1259
 
1009
1260
class cmd_push(Command):
1026
1277
    do a merge (see bzr help merge) from the other branch, and commit that.
1027
1278
    After that you will be able to do a push without '--overwrite'.
1028
1279
 
1029
 
    If there is no default push location set, the first push will set it.
1030
 
    After that, you can omit the location to use the default.  To change the
1031
 
    default, use --remember. The value will only be saved if the remote
1032
 
    location can be accessed.
 
1280
    If there is no default push location set, the first push will set it (use
 
1281
    --no-remember to avoid setting it).  After that, you can omit the
 
1282
    location to use the default.  To change the default, use --remember. The
 
1283
    value will only be saved if the remote location can be accessed.
 
1284
 
 
1285
    The --verbose option will display the revisions pushed using the log_format
 
1286
    configuration option. You can use a different format by overriding it with
 
1287
    -Olog_format=<other_format>.
1033
1288
    """
1034
1289
 
1035
1290
    _see_also = ['pull', 'update', 'working-trees']
1056
1311
        Option('strict',
1057
1312
               help='Refuse to push if there are uncommitted changes in'
1058
1313
               ' the working tree, --no-strict disables the check.'),
 
1314
        Option('no-tree',
 
1315
               help="Don't populate the working tree, even for protocols"
 
1316
               " that support it."),
 
1317
        Option('overwrite-tags',
 
1318
              help="Overwrite tags only."),
1059
1319
        ]
1060
1320
    takes_args = ['location?']
1061
1321
    encoding_type = 'replace'
1062
1322
 
1063
 
    def run(self, location=None, remember=False, overwrite=False,
 
1323
    def run(self, location=None, remember=None, overwrite=False,
1064
1324
        create_prefix=False, verbose=False, revision=None,
1065
1325
        use_existing_dir=False, directory=None, stacked_on=None,
1066
 
        stacked=False, strict=None):
 
1326
        stacked=False, strict=None, no_tree=False,
 
1327
        overwrite_tags=False):
1067
1328
        from bzrlib.push import _show_push_branch
1068
1329
 
 
1330
        if overwrite:
 
1331
            overwrite = ["history", "tags"]
 
1332
        elif overwrite_tags:
 
1333
            overwrite = ["tags"]
 
1334
        else:
 
1335
            overwrite = []
 
1336
 
1069
1337
        if directory is None:
1070
1338
            directory = '.'
1071
1339
        # Get the source branch
1072
1340
        (tree, br_from,
1073
 
         _unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
 
1341
         _unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1074
1342
        # Get the tip's revision_id
1075
1343
        revision = _get_one_revision('push', revision)
1076
1344
        if revision is not None:
1097
1365
                    # error by the feedback given to them. RBC 20080227.
1098
1366
                    stacked_on = parent_url
1099
1367
            if not stacked_on:
1100
 
                raise errors.BzrCommandError(
1101
 
                    "Could not determine branch to refer to.")
 
1368
                raise errors.BzrCommandError(gettext(
 
1369
                    "Could not determine branch to refer to."))
1102
1370
 
1103
1371
        # Get the destination location
1104
1372
        if location is None:
1105
1373
            stored_loc = br_from.get_push_location()
1106
1374
            if stored_loc is None:
1107
 
                raise errors.BzrCommandError(
1108
 
                    "No push location known or specified.")
 
1375
                parent_loc = br_from.get_parent()
 
1376
                if parent_loc:
 
1377
                    raise errors.BzrCommandError(gettext(
 
1378
                        "No push location known or specified. To push to the "
 
1379
                        "parent branch (at %s), use 'bzr push :parent'." %
 
1380
                        urlutils.unescape_for_display(parent_loc,
 
1381
                            self.outf.encoding)))
 
1382
                else:
 
1383
                    raise errors.BzrCommandError(gettext(
 
1384
                        "No push location known or specified."))
1109
1385
            else:
1110
1386
                display_url = urlutils.unescape_for_display(stored_loc,
1111
1387
                        self.outf.encoding)
1112
 
                self.outf.write("Using saved push location: %s\n" % display_url)
 
1388
                note(gettext("Using saved push location: %s") % display_url)
1113
1389
                location = stored_loc
1114
1390
 
1115
1391
        _show_push_branch(br_from, revision_id, location, self.outf,
1116
1392
            verbose=verbose, overwrite=overwrite, remember=remember,
1117
1393
            stacked_on=stacked_on, create_prefix=create_prefix,
1118
 
            use_existing_dir=use_existing_dir)
 
1394
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1119
1395
 
1120
1396
 
1121
1397
class cmd_branch(Command):
1130
1406
 
1131
1407
    To retrieve the branch as of a particular revision, supply the --revision
1132
1408
    parameter, as in "branch foo/bar -r 5".
 
1409
 
 
1410
    The synonyms 'clone' and 'get' for this command are deprecated.
1133
1411
    """
1134
1412
 
1135
1413
    _see_also = ['checkout']
1165
1443
            files_from=None):
1166
1444
        from bzrlib import switch as _mod_switch
1167
1445
        from bzrlib.tag import _merge_tags_if_possible
1168
 
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
 
1446
        if self.invoked_as in ['get', 'clone']:
 
1447
            ui.ui_factory.show_user_warning(
 
1448
                'deprecated_command',
 
1449
                deprecated_name=self.invoked_as,
 
1450
                recommended_name='branch',
 
1451
                deprecated_in_version='2.4')
 
1452
        accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
1169
1453
            from_location)
1170
1454
        if not (hardlink or files_from):
1171
1455
            # accelerator_tree is usually slower because you have to read N
1184
1468
            # RBC 20060209
1185
1469
            revision_id = br_from.last_revision()
1186
1470
        if to_location is None:
1187
 
            to_location = urlutils.derive_to_location(from_location)
 
1471
            to_location = getattr(br_from, "name", None)
 
1472
            if not to_location:
 
1473
                to_location = urlutils.derive_to_location(from_location)
1188
1474
        to_transport = transport.get_transport(to_location)
1189
1475
        try:
1190
1476
            to_transport.mkdir('.')
1191
1477
        except errors.FileExists:
1192
 
            if not use_existing_dir:
1193
 
                raise errors.BzrCommandError('Target directory "%s" '
1194
 
                    'already exists.' % to_location)
 
1478
            try:
 
1479
                to_dir = controldir.ControlDir.open_from_transport(
 
1480
                    to_transport)
 
1481
            except errors.NotBranchError:
 
1482
                if not use_existing_dir:
 
1483
                    raise errors.BzrCommandError(gettext('Target directory "%s" '
 
1484
                        'already exists.') % to_location)
 
1485
                else:
 
1486
                    to_dir = None
1195
1487
            else:
1196
1488
                try:
1197
 
                    bzrdir.BzrDir.open_from_transport(to_transport)
 
1489
                    to_dir.open_branch()
1198
1490
                except errors.NotBranchError:
1199
1491
                    pass
1200
1492
                else:
1201
1493
                    raise errors.AlreadyBranchError(to_location)
1202
1494
        except errors.NoSuchFile:
1203
 
            raise errors.BzrCommandError('Parent of "%s" does not exist.'
 
1495
            raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
1204
1496
                                         % to_location)
1205
 
        try:
1206
 
            # preserve whatever source format we have.
1207
 
            dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1208
 
                                        possible_transports=[to_transport],
1209
 
                                        accelerator_tree=accelerator_tree,
1210
 
                                        hardlink=hardlink, stacked=stacked,
1211
 
                                        force_new_repo=standalone,
1212
 
                                        create_tree_if_local=not no_tree,
1213
 
                                        source_branch=br_from)
1214
 
            branch = dir.open_branch()
1215
 
        except errors.NoSuchRevision:
1216
 
            to_transport.delete_tree('.')
1217
 
            msg = "The branch %s has no revision %s." % (from_location,
1218
 
                revision)
1219
 
            raise errors.BzrCommandError(msg)
 
1497
        else:
 
1498
            to_dir = None
 
1499
        if to_dir is None:
 
1500
            try:
 
1501
                # preserve whatever source format we have.
 
1502
                to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
 
1503
                                            possible_transports=[to_transport],
 
1504
                                            accelerator_tree=accelerator_tree,
 
1505
                                            hardlink=hardlink, stacked=stacked,
 
1506
                                            force_new_repo=standalone,
 
1507
                                            create_tree_if_local=not no_tree,
 
1508
                                            source_branch=br_from)
 
1509
                branch = to_dir.open_branch(
 
1510
                    possible_transports=[
 
1511
                        br_from.bzrdir.root_transport, to_transport])
 
1512
            except errors.NoSuchRevision:
 
1513
                to_transport.delete_tree('.')
 
1514
                msg = gettext("The branch {0} has no revision {1}.").format(
 
1515
                    from_location, revision)
 
1516
                raise errors.BzrCommandError(msg)
 
1517
        else:
 
1518
            try:
 
1519
                to_repo = to_dir.open_repository()
 
1520
            except errors.NoRepositoryPresent:
 
1521
                to_repo = to_dir.create_repository()
 
1522
            to_repo.fetch(br_from.repository, revision_id=revision_id)
 
1523
            branch = br_from.sprout(to_dir, revision_id=revision_id)
1220
1524
        _merge_tags_if_possible(br_from, branch)
1221
1525
        # If the source branch is stacked, the new branch may
1222
1526
        # be stacked whether we asked for that explicitly or not.
1223
1527
        # We therefore need a try/except here and not just 'if stacked:'
1224
1528
        try:
1225
 
            note('Created new stacked branch referring to %s.' %
 
1529
            note(gettext('Created new stacked branch referring to %s.') %
1226
1530
                branch.get_stacked_on_url())
1227
1531
        except (errors.NotStacked, errors.UnstackableBranchFormat,
1228
1532
            errors.UnstackableRepositoryFormat), e:
1229
 
            note('Branched %d revision(s).' % branch.revno())
 
1533
            note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1230
1534
        if bind:
1231
1535
            # Bind to the parent
1232
1536
            parent_branch = Branch.open(from_location)
1233
1537
            branch.bind(parent_branch)
1234
 
            note('New branch bound to %s' % from_location)
 
1538
            note(gettext('New branch bound to %s') % from_location)
1235
1539
        if switch:
1236
1540
            # Switch to the new branch
1237
1541
            wt, _ = WorkingTree.open_containing('.')
1238
1542
            _mod_switch.switch(wt.bzrdir, branch)
1239
 
            note('Switched to branch: %s',
 
1543
            note(gettext('Switched to branch: %s'),
1240
1544
                urlutils.unescape_for_display(branch.base, 'utf-8'))
1241
1545
 
1242
1546
 
 
1547
class cmd_branches(Command):
 
1548
    __doc__ = """List the branches available at the current location.
 
1549
 
 
1550
    This command will print the names of all the branches at the current
 
1551
    location.
 
1552
    """
 
1553
 
 
1554
    takes_args = ['location?']
 
1555
    takes_options = [
 
1556
                  Option('recursive', short_name='R',
 
1557
                         help='Recursively scan for branches rather than '
 
1558
                              'just looking in the specified location.')]
 
1559
 
 
1560
    def run(self, location=".", recursive=False):
 
1561
        if recursive:
 
1562
            t = transport.get_transport(location)
 
1563
            if not t.listable():
 
1564
                raise errors.BzrCommandError(
 
1565
                    "Can't scan this type of location.")
 
1566
            for b in controldir.ControlDir.find_branches(t):
 
1567
                self.outf.write("%s\n" % urlutils.unescape_for_display(
 
1568
                    urlutils.relative_url(t.base, b.base),
 
1569
                    self.outf.encoding).rstrip("/"))
 
1570
        else:
 
1571
            dir = controldir.ControlDir.open_containing(location)[0]
 
1572
            try:
 
1573
                active_branch = dir.open_branch(name="")
 
1574
            except errors.NotBranchError:
 
1575
                active_branch = None
 
1576
            names = {}
 
1577
            for name, branch in iter_sibling_branches(dir):
 
1578
                if name == "":
 
1579
                    continue
 
1580
                active = (active_branch is not None and
 
1581
                          active_branch.base == branch.base)
 
1582
                names[name] = active
 
1583
            # Only mention the current branch explicitly if it's not
 
1584
            # one of the colocated branches
 
1585
            if not any(names.values()) and active_branch is not None:
 
1586
                self.outf.write("* %s\n" % gettext("(default)"))
 
1587
            for name in sorted(names.keys()):
 
1588
                active = names[name]
 
1589
                if active:
 
1590
                    prefix = "*"
 
1591
                else:
 
1592
                    prefix = " "
 
1593
                self.outf.write("%s %s\n" % (
 
1594
                    prefix, name.encode(self.outf.encoding)))
 
1595
 
 
1596
 
1243
1597
class cmd_checkout(Command):
1244
1598
    __doc__ = """Create a new checkout of an existing branch.
1245
1599
 
1284
1638
        if branch_location is None:
1285
1639
            branch_location = osutils.getcwd()
1286
1640
            to_location = branch_location
1287
 
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
 
1641
        accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1288
1642
            branch_location)
1289
1643
        if not (hardlink or files_from):
1290
1644
            # accelerator_tree is usually slower because you have to read N
1327
1681
    def run(self, dir=u'.'):
1328
1682
        tree = WorkingTree.open_containing(dir)[0]
1329
1683
        self.add_cleanup(tree.lock_read().unlock)
1330
 
        new_inv = tree.inventory
1331
1684
        old_tree = tree.basis_tree()
1332
1685
        self.add_cleanup(old_tree.lock_read().unlock)
1333
 
        old_inv = old_tree.inventory
1334
1686
        renames = []
1335
1687
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1336
1688
        for f, paths, c, v, p, n, k, e in iterator:
1345
1697
 
1346
1698
 
1347
1699
class cmd_update(Command):
1348
 
    __doc__ = """Update a tree to have the latest code committed to its branch.
1349
 
 
1350
 
    This will perform a merge into the working tree, and may generate
1351
 
    conflicts. If you have any local changes, you will still
1352
 
    need to commit them after the update for the update to be complete.
1353
 
 
1354
 
    If you want to discard your local changes, you can just do a
1355
 
    'bzr revert' instead of 'bzr commit' after the update.
1356
 
 
1357
 
    If the tree's branch is bound to a master branch, it will also update
 
1700
    __doc__ = """Update a working tree to a new revision.
 
1701
 
 
1702
    This will perform a merge of the destination revision (the tip of the
 
1703
    branch, or the specified revision) into the working tree, and then make
 
1704
    that revision the basis revision for the working tree.  
 
1705
 
 
1706
    You can use this to visit an older revision, or to update a working tree
 
1707
    that is out of date from its branch.
 
1708
    
 
1709
    If there are any uncommitted changes in the tree, they will be carried
 
1710
    across and remain as uncommitted changes after the update.  To discard
 
1711
    these changes, use 'bzr revert'.  The uncommitted changes may conflict
 
1712
    with the changes brought in by the change in basis revision.
 
1713
 
 
1714
    If the tree's branch is bound to a master branch, bzr will also update
1358
1715
    the branch from the master.
 
1716
 
 
1717
    You cannot update just a single file or directory, because each Bazaar
 
1718
    working tree has just a single basis revision.  If you want to restore a
 
1719
    file that has been removed locally, use 'bzr revert' instead of 'bzr
 
1720
    update'.  If you want to restore a file to its state in a previous
 
1721
    revision, use 'bzr revert' with a '-r' option, or use 'bzr cat' to write
 
1722
    out the old content of that file to a new location.
 
1723
 
 
1724
    The 'dir' argument, if given, must be the location of the root of a
 
1725
    working tree to update.  By default, the working tree that contains the 
 
1726
    current working directory is used.
1359
1727
    """
1360
1728
 
1361
1729
    _see_also = ['pull', 'working-trees', 'status-flags']
1362
1730
    takes_args = ['dir?']
1363
 
    takes_options = ['revision']
 
1731
    takes_options = ['revision',
 
1732
                     Option('show-base',
 
1733
                            help="Show base revision text in conflicts."),
 
1734
                     ]
1364
1735
    aliases = ['up']
1365
1736
 
1366
 
    def run(self, dir='.', revision=None):
 
1737
    def run(self, dir=None, revision=None, show_base=None):
1367
1738
        if revision is not None and len(revision) != 1:
1368
 
            raise errors.BzrCommandError(
1369
 
                        "bzr update --revision takes exactly one revision")
1370
 
        tree = WorkingTree.open_containing(dir)[0]
 
1739
            raise errors.BzrCommandError(gettext(
 
1740
                "bzr update --revision takes exactly one revision"))
 
1741
        if dir is None:
 
1742
            tree = WorkingTree.open_containing('.')[0]
 
1743
        else:
 
1744
            tree, relpath = WorkingTree.open_containing(dir)
 
1745
            if relpath:
 
1746
                # See bug 557886.
 
1747
                raise errors.BzrCommandError(gettext(
 
1748
                    "bzr update can only update a whole tree, "
 
1749
                    "not a file or subdirectory"))
1371
1750
        branch = tree.branch
1372
1751
        possible_transports = []
1373
1752
        master = branch.get_master_branch(
1397
1776
            revision_id = branch.last_revision()
1398
1777
        if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1399
1778
            revno = branch.revision_id_to_dotted_revno(revision_id)
1400
 
            note("Tree is up to date at revision %s of branch %s" %
1401
 
                ('.'.join(map(str, revno)), branch_location))
 
1779
            note(gettext("Tree is up to date at revision {0} of branch {1}"
 
1780
                        ).format('.'.join(map(str, revno)), branch_location))
1402
1781
            return 0
1403
1782
        view_info = _get_view_info_for_change_reporter(tree)
1404
1783
        change_reporter = delta._ChangeReporter(
1409
1788
                change_reporter,
1410
1789
                possible_transports=possible_transports,
1411
1790
                revision=revision_id,
1412
 
                old_tip=old_tip)
 
1791
                old_tip=old_tip,
 
1792
                show_base=show_base)
1413
1793
        except errors.NoSuchRevision, e:
1414
 
            raise errors.BzrCommandError(
 
1794
            raise errors.BzrCommandError(gettext(
1415
1795
                                  "branch has no revision %s\n"
1416
1796
                                  "bzr update --revision only works"
1417
 
                                  " for a revision in the branch history"
 
1797
                                  " for a revision in the branch history")
1418
1798
                                  % (e.revision))
1419
1799
        revno = tree.branch.revision_id_to_dotted_revno(
1420
1800
            _mod_revision.ensure_null(tree.last_revision()))
1421
 
        note('Updated to revision %s of branch %s' %
1422
 
             ('.'.join(map(str, revno)), branch_location))
 
1801
        note(gettext('Updated to revision {0} of branch {1}').format(
 
1802
             '.'.join(map(str, revno)), branch_location))
1423
1803
        parent_ids = tree.get_parent_ids()
1424
1804
        if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1425
 
            note('Your local commits will now show as pending merges with '
1426
 
                 "'bzr status', and can be committed with 'bzr commit'.")
 
1805
            note(gettext('Your local commits will now show as pending merges with '
 
1806
                 "'bzr status', and can be committed with 'bzr commit'."))
1427
1807
        if conflicts != 0:
1428
1808
            return 1
1429
1809
        else:
1470
1850
        else:
1471
1851
            noise_level = 0
1472
1852
        from bzrlib.info import show_bzrdir_info
1473
 
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
 
1853
        show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1474
1854
                         verbose=noise_level, outfile=self.outf)
1475
1855
 
1476
1856
 
1479
1859
 
1480
1860
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
1481
1861
    delete them if they can easily be recovered using revert otherwise they
1482
 
    will be backed up (adding an extention of the form .~#~). If no options or
 
1862
    will be backed up (adding an extension of the form .~#~). If no options or
1483
1863
    parameters are given Bazaar will scan for files that are being tracked by
1484
1864
    Bazaar but missing in your tree and stop tracking them for you.
1485
1865
    """
1491
1871
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1492
1872
            safe='Backup changed files (default).',
1493
1873
            keep='Delete from bzr but leave the working copy.',
 
1874
            no_backup='Don\'t backup changed files.',
1494
1875
            force='Delete all the specified files, even if they can not be '
1495
 
                'recovered and even if they are non-empty directories.')]
 
1876
                'recovered and even if they are non-empty directories. '
 
1877
                '(deprecated, use no-backup)')]
1496
1878
    aliases = ['rm', 'del']
1497
1879
    encoding_type = 'replace'
1498
1880
 
1499
1881
    def run(self, file_list, verbose=False, new=False,
1500
1882
        file_deletion_strategy='safe'):
 
1883
        if file_deletion_strategy == 'force':
 
1884
            note(gettext("(The --force option is deprecated, rather use --no-backup "
 
1885
                "in future.)"))
 
1886
            file_deletion_strategy = 'no-backup'
 
1887
 
1501
1888
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1502
1889
 
1503
1890
        if file_list is not None:
1511
1898
                specific_files=file_list).added
1512
1899
            file_list = sorted([f[0] for f in added], reverse=True)
1513
1900
            if len(file_list) == 0:
1514
 
                raise errors.BzrCommandError('No matching files.')
 
1901
                raise errors.BzrCommandError(gettext('No matching files.'))
1515
1902
        elif file_list is None:
1516
1903
            # missing files show up in iter_changes(basis) as
1517
1904
            # versioned-with-no-kind.
1524
1911
            file_deletion_strategy = 'keep'
1525
1912
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1526
1913
            keep_files=file_deletion_strategy=='keep',
1527
 
            force=file_deletion_strategy=='force')
 
1914
            force=(file_deletion_strategy=='no-backup'))
1528
1915
 
1529
1916
 
1530
1917
class cmd_file_id(Command):
1601
1988
 
1602
1989
    def run(self, branch=".", canonicalize_chks=False):
1603
1990
        from bzrlib.reconcile import reconcile
1604
 
        dir = bzrdir.BzrDir.open(branch)
 
1991
        dir = controldir.ControlDir.open(branch)
1605
1992
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1606
1993
 
1607
1994
 
1616
2003
    @display_command
1617
2004
    def run(self, location="."):
1618
2005
        branch = Branch.open_containing(location)[0]
1619
 
        for revid in branch.revision_history():
 
2006
        self.add_cleanup(branch.lock_read().unlock)
 
2007
        graph = branch.repository.get_graph()
 
2008
        history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
 
2009
            [_mod_revision.NULL_REVISION]))
 
2010
        for revid in reversed(history):
1620
2011
            self.outf.write(revid)
1621
2012
            self.outf.write('\n')
1622
2013
 
1640
2031
            b = wt.branch
1641
2032
            last_revision = wt.last_revision()
1642
2033
 
1643
 
        revision_ids = b.repository.get_ancestry(last_revision)
1644
 
        revision_ids.pop(0)
1645
 
        for revision_id in revision_ids:
 
2034
        self.add_cleanup(b.repository.lock_read().unlock)
 
2035
        graph = b.repository.get_graph()
 
2036
        revisions = [revid for revid, parents in
 
2037
            graph.iter_ancestry([last_revision])]
 
2038
        for revision_id in reversed(revisions):
 
2039
            if _mod_revision.is_null(revision_id):
 
2040
                continue
1646
2041
            self.outf.write(revision_id + '\n')
1647
2042
 
1648
2043
 
1678
2073
         RegistryOption('format',
1679
2074
                help='Specify a format for this branch. '
1680
2075
                'See "help formats".',
1681
 
                lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1682
 
                converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
2076
                lazy_registry=('bzrlib.controldir', 'format_registry'),
 
2077
                converter=lambda name: controldir.format_registry.make_bzrdir(name),
1683
2078
                value_switches=True,
1684
2079
                title="Branch format",
1685
2080
                ),
1686
2081
         Option('append-revisions-only',
1687
2082
                help='Never change revnos or the existing log.'
1688
 
                '  Append revisions to it only.')
 
2083
                '  Append revisions to it only.'),
 
2084
         Option('no-tree',
 
2085
                'Create a branch without a working tree.')
1689
2086
         ]
1690
2087
    def run(self, location=None, format=None, append_revisions_only=False,
1691
 
            create_prefix=False):
 
2088
            create_prefix=False, no_tree=False):
1692
2089
        if format is None:
1693
 
            format = bzrdir.format_registry.make_bzrdir('default')
 
2090
            format = controldir.format_registry.make_bzrdir('default')
1694
2091
        if location is None:
1695
2092
            location = u'.'
1696
2093
 
1705
2102
            to_transport.ensure_base()
1706
2103
        except errors.NoSuchFile:
1707
2104
            if not create_prefix:
1708
 
                raise errors.BzrCommandError("Parent directory of %s"
 
2105
                raise errors.BzrCommandError(gettext("Parent directory of %s"
1709
2106
                    " does not exist."
1710
2107
                    "\nYou may supply --create-prefix to create all"
1711
 
                    " leading parent directories."
 
2108
                    " leading parent directories.")
1712
2109
                    % location)
1713
2110
            to_transport.create_prefix()
1714
2111
 
1715
2112
        try:
1716
 
            a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
 
2113
            a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1717
2114
        except errors.NotBranchError:
1718
2115
            # really a NotBzrDir error...
1719
 
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
2116
            create_branch = controldir.ControlDir.create_branch_convenience
 
2117
            if no_tree:
 
2118
                force_new_tree = False
 
2119
            else:
 
2120
                force_new_tree = None
1720
2121
            branch = create_branch(to_transport.base, format=format,
1721
 
                                   possible_transports=[to_transport])
 
2122
                                   possible_transports=[to_transport],
 
2123
                                   force_new_tree=force_new_tree)
1722
2124
            a_bzrdir = branch.bzrdir
1723
2125
        else:
1724
2126
            from bzrlib.transport.local import LocalTransport
1728
2130
                        raise errors.BranchExistsWithoutWorkingTree(location)
1729
2131
                raise errors.AlreadyBranchError(location)
1730
2132
            branch = a_bzrdir.create_branch()
1731
 
            a_bzrdir.create_workingtree()
 
2133
            if not no_tree and not a_bzrdir.has_workingtree():
 
2134
                a_bzrdir.create_workingtree()
1732
2135
        if append_revisions_only:
1733
2136
            try:
1734
2137
                branch.set_append_revisions_only(True)
1735
2138
            except errors.UpgradeRequired:
1736
 
                raise errors.BzrCommandError('This branch format cannot be set'
1737
 
                    ' to append-revisions-only.  Try --default.')
 
2139
                raise errors.BzrCommandError(gettext('This branch format cannot be set'
 
2140
                    ' to append-revisions-only.  Try --default.'))
1738
2141
        if not is_quiet():
1739
2142
            from bzrlib.info import describe_layout, describe_format
1740
2143
            try:
1744
2147
            repository = branch.repository
1745
2148
            layout = describe_layout(repository, branch, tree).lower()
1746
2149
            format = describe_format(a_bzrdir, repository, branch, tree)
1747
 
            self.outf.write("Created a %s (format: %s)\n" % (layout, format))
 
2150
            self.outf.write(gettext("Created a {0} (format: {1})\n").format(
 
2151
                  layout, format))
1748
2152
            if repository.is_shared():
1749
2153
                #XXX: maybe this can be refactored into transport.path_or_url()
1750
2154
                url = repository.bzrdir.root_transport.external_url()
1752
2156
                    url = urlutils.local_path_from_url(url)
1753
2157
                except errors.InvalidURL:
1754
2158
                    pass
1755
 
                self.outf.write("Using shared repository: %s\n" % url)
 
2159
                self.outf.write(gettext("Using shared repository: %s\n") % url)
1756
2160
 
1757
2161
 
1758
2162
class cmd_init_repository(Command):
1788
2192
    takes_options = [RegistryOption('format',
1789
2193
                            help='Specify a format for this repository. See'
1790
2194
                                 ' "bzr help formats" for details.',
1791
 
                            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1792
 
                            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
2195
                            lazy_registry=('bzrlib.controldir', 'format_registry'),
 
2196
                            converter=lambda name: controldir.format_registry.make_bzrdir(name),
1793
2197
                            value_switches=True, title='Repository format'),
1794
2198
                     Option('no-trees',
1795
2199
                             help='Branches in the repository will default to'
1799
2203
 
1800
2204
    def run(self, location, format=None, no_trees=False):
1801
2205
        if format is None:
1802
 
            format = bzrdir.format_registry.make_bzrdir('default')
 
2206
            format = controldir.format_registry.make_bzrdir('default')
1803
2207
 
1804
2208
        if location is None:
1805
2209
            location = '.'
1806
2210
 
1807
2211
        to_transport = transport.get_transport(location)
1808
 
        to_transport.ensure_base()
1809
2212
 
1810
 
        newdir = format.initialize_on_transport(to_transport)
1811
 
        repo = newdir.create_repository(shared=True)
1812
 
        repo.set_make_working_trees(not no_trees)
 
2213
        (repo, newdir, require_stacking, repository_policy) = (
 
2214
            format.initialize_on_transport_ex(to_transport,
 
2215
            create_prefix=True, make_working_trees=not no_trees,
 
2216
            shared_repo=True, force_new_repo=True,
 
2217
            use_existing_dir=True,
 
2218
            repo_format_name=format.repository_format.get_format_string()))
1813
2219
        if not is_quiet():
1814
2220
            from bzrlib.info import show_bzrdir_info
1815
 
            show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
 
2221
            show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1816
2222
 
1817
2223
 
1818
2224
class cmd_diff(Command):
1828
2234
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1829
2235
    produces patches suitable for "patch -p1".
1830
2236
 
 
2237
    Note that when using the -r argument with a range of revisions, the
 
2238
    differences are computed between the two specified revisions.  That
 
2239
    is, the command does not show the changes introduced by the first 
 
2240
    revision in the range.  This differs from the interpretation of 
 
2241
    revision ranges used by "bzr log" which includes the first revision
 
2242
    in the range.
 
2243
 
1831
2244
    :Exit values:
1832
2245
        1 - changed
1833
2246
        2 - unrepresentable changes
1851
2264
 
1852
2265
            bzr diff -r1..3 xxx
1853
2266
 
1854
 
        To see the changes introduced in revision X::
 
2267
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
2268
 
 
2269
            bzr diff -c2
 
2270
 
 
2271
        To see the changes introduced by revision X::
1855
2272
        
1856
2273
            bzr diff -cX
1857
2274
 
1861
2278
 
1862
2279
            bzr diff -r<chosen_parent>..X
1863
2280
 
1864
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
2281
        The changes between the current revision and the previous revision
 
2282
        (equivalent to -c-1 and -r-2..-1)
1865
2283
 
1866
 
            bzr diff -c2
 
2284
            bzr diff -r-2..
1867
2285
 
1868
2286
        Show just the differences for file NEWS::
1869
2287
 
1913
2331
            type=unicode,
1914
2332
            ),
1915
2333
        RegistryOption('format',
 
2334
            short_name='F',
1916
2335
            help='Diff format to use.',
1917
2336
            lazy_registry=('bzrlib.diff', 'format_registry'),
1918
 
            value_switches=False, title='Diff format'),
 
2337
            title='Diff format'),
1919
2338
        ]
1920
2339
    aliases = ['di', 'dif']
1921
2340
    encoding_type = 'exact'
1936
2355
        elif ':' in prefix:
1937
2356
            old_label, new_label = prefix.split(":")
1938
2357
        else:
1939
 
            raise errors.BzrCommandError(
 
2358
            raise errors.BzrCommandError(gettext(
1940
2359
                '--prefix expects two values separated by a colon'
1941
 
                ' (eg "old/:new/")')
 
2360
                ' (eg "old/:new/")'))
1942
2361
 
1943
2362
        if revision and len(revision) > 2:
1944
 
            raise errors.BzrCommandError('bzr diff --revision takes exactly'
1945
 
                                         ' one or two revision specifiers')
 
2363
            raise errors.BzrCommandError(gettext('bzr diff --revision takes exactly'
 
2364
                                         ' one or two revision specifiers'))
1946
2365
 
1947
2366
        if using is not None and format is not None:
1948
 
            raise errors.BzrCommandError('--using and --format are mutually '
1949
 
                'exclusive.')
 
2367
            raise errors.BzrCommandError(gettext(
 
2368
                '{0} and {1} are mutually exclusive').format(
 
2369
                '--using', '--format'))
1950
2370
 
1951
2371
        (old_tree, new_tree,
1952
2372
         old_branch, new_branch,
1982
2402
        self.add_cleanup(tree.lock_read().unlock)
1983
2403
        old = tree.basis_tree()
1984
2404
        self.add_cleanup(old.lock_read().unlock)
1985
 
        for path, ie in old.inventory.iter_entries():
 
2405
        for path, ie in old.iter_entries_by_dir():
1986
2406
            if not tree.has_id(ie.file_id):
1987
2407
                self.outf.write(path)
1988
2408
                if show_ids:
2002
2422
    @display_command
2003
2423
    def run(self, null=False, directory=u'.'):
2004
2424
        tree = WorkingTree.open_containing(directory)[0]
 
2425
        self.add_cleanup(tree.lock_read().unlock)
2005
2426
        td = tree.changes_from(tree.basis_tree())
 
2427
        self.cleanup_now()
2006
2428
        for path, id, kind, text_modified, meta_modified in td.modified:
2007
2429
            if null:
2008
2430
                self.outf.write(path + '\0')
2024
2446
        self.add_cleanup(wt.lock_read().unlock)
2025
2447
        basis = wt.basis_tree()
2026
2448
        self.add_cleanup(basis.lock_read().unlock)
2027
 
        basis_inv = basis.inventory
2028
 
        inv = wt.inventory
2029
 
        for file_id in inv:
2030
 
            if file_id in basis_inv:
2031
 
                continue
2032
 
            if inv.is_root(file_id) and len(basis_inv) == 0:
2033
 
                continue
2034
 
            path = inv.id2path(file_id)
 
2449
        root_id = wt.get_root_id()
 
2450
        for file_id in wt.all_file_ids():
 
2451
            if basis.has_id(file_id):
 
2452
                continue
 
2453
            if root_id == file_id:
 
2454
                continue
 
2455
            path = wt.id2path(file_id)
2035
2456
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2036
2457
                continue
2037
2458
            if null:
2058
2479
    try:
2059
2480
        return int(limitstring)
2060
2481
    except ValueError:
2061
 
        msg = "The limit argument must be an integer."
 
2482
        msg = gettext("The limit argument must be an integer.")
2062
2483
        raise errors.BzrCommandError(msg)
2063
2484
 
2064
2485
 
2066
2487
    try:
2067
2488
        return int(s)
2068
2489
    except ValueError:
2069
 
        msg = "The levels argument must be an integer."
 
2490
        msg = gettext("The levels argument must be an integer.")
2070
2491
        raise errors.BzrCommandError(msg)
2071
2492
 
2072
2493
 
2182
2603
 
2183
2604
    :Other filtering:
2184
2605
 
2185
 
      The --message option can be used for finding revisions that match a
2186
 
      regular expression in a commit message.
 
2606
      The --match option can be used for finding revisions that match a
 
2607
      regular expression in a commit message, committer, author or bug.
 
2608
      Specifying the option several times will match any of the supplied
 
2609
      expressions. --match-author, --match-bugs, --match-committer and
 
2610
      --match-message can be used to only match a specific field.
2187
2611
 
2188
2612
    :Tips & tricks:
2189
2613
 
2249
2673
                   argname='N',
2250
2674
                   type=_parse_levels),
2251
2675
            Option('message',
2252
 
                   short_name='m',
2253
2676
                   help='Show revisions whose message matches this '
2254
2677
                        'regular expression.',
2255
 
                   type=str),
 
2678
                   type=str,
 
2679
                   hidden=True),
2256
2680
            Option('limit',
2257
2681
                   short_name='l',
2258
2682
                   help='Limit the output to the first N revisions.',
2261
2685
            Option('show-diff',
2262
2686
                   short_name='p',
2263
2687
                   help='Show changes made in each revision as a patch.'),
2264
 
            Option('include-merges',
 
2688
            Option('include-merged',
2265
2689
                   help='Show merged revisions like --levels 0 does.'),
 
2690
            Option('include-merges', hidden=True,
 
2691
                   help='Historical alias for --include-merged.'),
 
2692
            Option('omit-merges',
 
2693
                   help='Do not report commits with more than one parent.'),
2266
2694
            Option('exclude-common-ancestry',
2267
2695
                   help='Display only the revisions that are not part'
2268
 
                   ' of both ancestries (require -rX..Y)'
2269
 
                   )
 
2696
                   ' of both ancestries (require -rX..Y).'
 
2697
                   ),
 
2698
            Option('signatures',
 
2699
                   help='Show digital signature validity.'),
 
2700
            ListOption('match',
 
2701
                short_name='m',
 
2702
                help='Show revisions whose properties match this '
 
2703
                'expression.',
 
2704
                type=str),
 
2705
            ListOption('match-message',
 
2706
                   help='Show revisions whose message matches this '
 
2707
                   'expression.',
 
2708
                type=str),
 
2709
            ListOption('match-committer',
 
2710
                   help='Show revisions whose committer matches this '
 
2711
                   'expression.',
 
2712
                type=str),
 
2713
            ListOption('match-author',
 
2714
                   help='Show revisions whose authors match this '
 
2715
                   'expression.',
 
2716
                type=str),
 
2717
            ListOption('match-bugs',
 
2718
                   help='Show revisions whose bugs match this '
 
2719
                   'expression.',
 
2720
                type=str)
2270
2721
            ]
2271
2722
    encoding_type = 'replace'
2272
2723
 
2282
2733
            message=None,
2283
2734
            limit=None,
2284
2735
            show_diff=False,
2285
 
            include_merges=False,
 
2736
            include_merged=None,
2286
2737
            authors=None,
2287
2738
            exclude_common_ancestry=False,
 
2739
            signatures=False,
 
2740
            match=None,
 
2741
            match_message=None,
 
2742
            match_committer=None,
 
2743
            match_author=None,
 
2744
            match_bugs=None,
 
2745
            omit_merges=False,
 
2746
            include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2288
2747
            ):
2289
2748
        from bzrlib.log import (
2290
2749
            Logger,
2292
2751
            _get_info_for_log_files,
2293
2752
            )
2294
2753
        direction = (forward and 'forward') or 'reverse'
 
2754
        if symbol_versioning.deprecated_passed(include_merges):
 
2755
            ui.ui_factory.show_user_warning(
 
2756
                'deprecated_command_option',
 
2757
                deprecated_name='--include-merges',
 
2758
                recommended_name='--include-merged',
 
2759
                deprecated_in_version='2.5',
 
2760
                command=self.invoked_as)
 
2761
            if include_merged is None:
 
2762
                include_merged = include_merges
 
2763
            else:
 
2764
                raise errors.BzrCommandError(gettext(
 
2765
                    '{0} and {1} are mutually exclusive').format(
 
2766
                    '--include-merges', '--include-merged'))
 
2767
        if include_merged is None:
 
2768
            include_merged = False
2295
2769
        if (exclude_common_ancestry
2296
2770
            and (revision is None or len(revision) != 2)):
2297
 
            raise errors.BzrCommandError(
2298
 
                '--exclude-common-ancestry requires -r with two revisions')
2299
 
        if include_merges:
 
2771
            raise errors.BzrCommandError(gettext(
 
2772
                '--exclude-common-ancestry requires -r with two revisions'))
 
2773
        if include_merged:
2300
2774
            if levels is None:
2301
2775
                levels = 0
2302
2776
            else:
2303
 
                raise errors.BzrCommandError(
2304
 
                    '--levels and --include-merges are mutually exclusive')
 
2777
                raise errors.BzrCommandError(gettext(
 
2778
                    '{0} and {1} are mutually exclusive').format(
 
2779
                    '--levels', '--include-merged'))
2305
2780
 
2306
2781
        if change is not None:
2307
2782
            if len(change) > 1:
2308
2783
                raise errors.RangeInChangeOption()
2309
2784
            if revision is not None:
2310
 
                raise errors.BzrCommandError(
2311
 
                    '--revision and --change are mutually exclusive')
 
2785
                raise errors.BzrCommandError(gettext(
 
2786
                    '{0} and {1} are mutually exclusive').format(
 
2787
                    '--revision', '--change'))
2312
2788
            else:
2313
2789
                revision = change
2314
2790
 
2320
2796
                revision, file_list, self.add_cleanup)
2321
2797
            for relpath, file_id, kind in file_info_list:
2322
2798
                if file_id is None:
2323
 
                    raise errors.BzrCommandError(
2324
 
                        "Path unknown at end or start of revision range: %s" %
 
2799
                    raise errors.BzrCommandError(gettext(
 
2800
                        "Path unknown at end or start of revision range: %s") %
2325
2801
                        relpath)
2326
2802
                # If the relpath is the top of the tree, we log everything
2327
2803
                if relpath == '':
2339
2815
                location = revision[0].get_branch()
2340
2816
            else:
2341
2817
                location = '.'
2342
 
            dir, relpath = bzrdir.BzrDir.open_containing(location)
 
2818
            dir, relpath = controldir.ControlDir.open_containing(location)
2343
2819
            b = dir.open_branch()
2344
2820
            self.add_cleanup(b.lock_read().unlock)
2345
2821
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2346
2822
 
 
2823
        if b.get_config_stack().get('validate_signatures_in_log'):
 
2824
            signatures = True
 
2825
 
 
2826
        if signatures:
 
2827
            if not gpg.GPGStrategy.verify_signatures_available():
 
2828
                raise errors.GpgmeNotInstalled(None)
 
2829
 
2347
2830
        # Decide on the type of delta & diff filtering to use
2348
2831
        # TODO: add an --all-files option to make this configurable & consistent
2349
2832
        if not verbose:
2386
2869
        match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2387
2870
            or delta_type or partial_history)
2388
2871
 
 
2872
        match_dict = {}
 
2873
        if match:
 
2874
            match_dict[''] = match
 
2875
        if match_message:
 
2876
            match_dict['message'] = match_message
 
2877
        if match_committer:
 
2878
            match_dict['committer'] = match_committer
 
2879
        if match_author:
 
2880
            match_dict['author'] = match_author
 
2881
        if match_bugs:
 
2882
            match_dict['bugs'] = match_bugs
 
2883
 
2389
2884
        # Build the LogRequest and execute it
2390
2885
        if len(file_ids) == 0:
2391
2886
            file_ids = None
2394
2889
            start_revision=rev1, end_revision=rev2, limit=limit,
2395
2890
            message_search=message, delta_type=delta_type,
2396
2891
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2397
 
            exclude_common_ancestry=exclude_common_ancestry,
 
2892
            exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
 
2893
            signature=signatures, omit_merges=omit_merges,
2398
2894
            )
2399
2895
        Logger(b, rqst).show(lf)
2400
2896
 
2417
2913
            # b is taken from revision[0].get_branch(), and
2418
2914
            # show_log will use its revision_history. Having
2419
2915
            # different branches will lead to weird behaviors.
2420
 
            raise errors.BzrCommandError(
 
2916
            raise errors.BzrCommandError(gettext(
2421
2917
                "bzr %s doesn't accept two revisions in different"
2422
 
                " branches." % command_name)
 
2918
                " branches.") % command_name)
2423
2919
        if start_spec.spec is None:
2424
2920
            # Avoid loading all the history.
2425
2921
            rev1 = RevisionInfo(branch, None, None)
2433
2929
        else:
2434
2930
            rev2 = end_spec.in_history(branch)
2435
2931
    else:
2436
 
        raise errors.BzrCommandError(
2437
 
            'bzr %s --revision takes one or two values.' % command_name)
 
2932
        raise errors.BzrCommandError(gettext(
 
2933
            'bzr %s --revision takes one or two values.') % command_name)
2438
2934
    return rev1, rev2
2439
2935
 
2440
2936
 
2511
3007
            null=False, kind=None, show_ids=False, path=None, directory=None):
2512
3008
 
2513
3009
        if kind and kind not in ('file', 'directory', 'symlink'):
2514
 
            raise errors.BzrCommandError('invalid kind specified')
 
3010
            raise errors.BzrCommandError(gettext('invalid kind specified'))
2515
3011
 
2516
3012
        if verbose and null:
2517
 
            raise errors.BzrCommandError('Cannot set both --verbose and --null')
 
3013
            raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2518
3014
        all = not (unknown or versioned or ignored)
2519
3015
 
2520
3016
        selection = {'I':ignored, '?':unknown, 'V':versioned}
2523
3019
            fs_path = '.'
2524
3020
        else:
2525
3021
            if from_root:
2526
 
                raise errors.BzrCommandError('cannot specify both --from-root'
2527
 
                                             ' and PATH')
 
3022
                raise errors.BzrCommandError(gettext('cannot specify both --from-root'
 
3023
                                             ' and PATH'))
2528
3024
            fs_path = path
2529
3025
        tree, branch, relpath = \
2530
3026
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2546
3042
            if view_files:
2547
3043
                apply_view = True
2548
3044
                view_str = views.view_display_str(view_files)
2549
 
                note("Ignoring files outside view. View is %s" % view_str)
 
3045
                note(gettext("Ignoring files outside view. View is %s") % view_str)
2550
3046
 
2551
3047
        self.add_cleanup(tree.lock_read().unlock)
2552
3048
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2638
3134
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2639
3135
    precedence over the '!' exception patterns.
2640
3136
 
2641
 
    Note: ignore patterns containing shell wildcards must be quoted from
2642
 
    the shell on Unix.
 
3137
    :Notes: 
 
3138
        
 
3139
    * Ignore patterns containing shell wildcards must be quoted from
 
3140
      the shell on Unix.
 
3141
 
 
3142
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
3143
      To ignore patterns that begin with that character, use the "RE:" prefix.
2643
3144
 
2644
3145
    :Examples:
2645
3146
        Ignore the top level Makefile::
2654
3155
 
2655
3156
            bzr ignore "!special.class"
2656
3157
 
 
3158
        Ignore files whose name begins with the "#" character::
 
3159
 
 
3160
            bzr ignore "RE:^#"
 
3161
 
2657
3162
        Ignore .o files under the lib directory::
2658
3163
 
2659
3164
            bzr ignore "lib/**/*.o"
2667
3172
            bzr ignore "RE:(?!debian/).*"
2668
3173
        
2669
3174
        Ignore everything except the "local" toplevel directory,
2670
 
        but always ignore "*~" autosave files, even under local/::
 
3175
        but always ignore autosave files ending in ~, even under local/::
2671
3176
        
2672
3177
            bzr ignore "*"
2673
3178
            bzr ignore "!./local"
2690
3195
                self.outf.write("%s\n" % pattern)
2691
3196
            return
2692
3197
        if not name_pattern_list:
2693
 
            raise errors.BzrCommandError("ignore requires at least one "
2694
 
                "NAME_PATTERN or --default-rules.")
 
3198
            raise errors.BzrCommandError(gettext("ignore requires at least one "
 
3199
                "NAME_PATTERN or --default-rules."))
2695
3200
        name_pattern_list = [globbing.normalize_pattern(p)
2696
3201
                             for p in name_pattern_list]
2697
3202
        bad_patterns = ''
 
3203
        bad_patterns_count = 0
2698
3204
        for p in name_pattern_list:
2699
3205
            if not globbing.Globster.is_pattern_valid(p):
 
3206
                bad_patterns_count += 1
2700
3207
                bad_patterns += ('\n  %s' % p)
2701
3208
        if bad_patterns:
2702
 
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
3209
            msg = (ngettext('Invalid ignore pattern found. %s', 
 
3210
                            'Invalid ignore patterns found. %s',
 
3211
                            bad_patterns_count) % bad_patterns)
2703
3212
            ui.ui_factory.show_error(msg)
2704
3213
            raise errors.InvalidPattern('')
2705
3214
        for name_pattern in name_pattern_list:
2706
3215
            if (name_pattern[0] == '/' or
2707
3216
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2708
 
                raise errors.BzrCommandError(
2709
 
                    "NAME_PATTERN should not be an absolute path")
 
3217
                raise errors.BzrCommandError(gettext(
 
3218
                    "NAME_PATTERN should not be an absolute path"))
2710
3219
        tree, relpath = WorkingTree.open_containing(directory)
2711
3220
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2712
3221
        ignored = globbing.Globster(name_pattern_list)
2719
3228
                if ignored.match(filename):
2720
3229
                    matches.append(filename)
2721
3230
        if len(matches) > 0:
2722
 
            self.outf.write("Warning: the following files are version controlled and"
2723
 
                  " match your ignore pattern:\n%s"
 
3231
            self.outf.write(gettext("Warning: the following files are version "
 
3232
                  "controlled and match your ignore pattern:\n%s"
2724
3233
                  "\nThese files will continue to be version controlled"
2725
 
                  " unless you 'bzr remove' them.\n" % ("\n".join(matches),))
 
3234
                  " unless you 'bzr remove' them.\n") % ("\n".join(matches),))
2726
3235
 
2727
3236
 
2728
3237
class cmd_ignored(Command):
2767
3276
        try:
2768
3277
            revno = int(revno)
2769
3278
        except ValueError:
2770
 
            raise errors.BzrCommandError("not a valid revision-number: %r"
 
3279
            raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
2771
3280
                                         % revno)
2772
3281
        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2773
3282
        self.outf.write("%s\n" % revid)
2801
3310
         zip                          .zip
2802
3311
      =================       =========================
2803
3312
    """
 
3313
    encoding = 'exact'
2804
3314
    takes_args = ['dest', 'branch_or_subdir?']
2805
3315
    takes_options = ['directory',
2806
3316
        Option('format',
2815
3325
        Option('per-file-timestamps',
2816
3326
               help='Set modification time of files to that of the last '
2817
3327
                    'revision in which it was changed.'),
 
3328
        Option('uncommitted',
 
3329
               help='Export the working tree contents rather than that of the '
 
3330
                    'last revision.'),
2818
3331
        ]
2819
3332
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2820
 
        root=None, filters=False, per_file_timestamps=False, directory=u'.'):
 
3333
        root=None, filters=False, per_file_timestamps=False, uncommitted=False,
 
3334
        directory=u'.'):
2821
3335
        from bzrlib.export import export
2822
3336
 
2823
3337
        if branch_or_subdir is None:
2824
 
            tree = WorkingTree.open_containing(directory)[0]
2825
 
            b = tree.branch
2826
 
            subdir = None
 
3338
            branch_or_subdir = directory
 
3339
 
 
3340
        (tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
 
3341
            branch_or_subdir)
 
3342
        if tree is not None:
 
3343
            self.add_cleanup(tree.lock_read().unlock)
 
3344
 
 
3345
        if uncommitted:
 
3346
            if tree is None:
 
3347
                raise errors.BzrCommandError(
 
3348
                    gettext("--uncommitted requires a working tree"))
 
3349
            export_tree = tree
2827
3350
        else:
2828
 
            b, subdir = Branch.open_containing(branch_or_subdir)
2829
 
            tree = None
2830
 
 
2831
 
        rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
 
3351
            export_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2832
3352
        try:
2833
 
            export(rev_tree, dest, format, root, subdir, filtered=filters,
 
3353
            export(export_tree, dest, format, root, subdir, filtered=filters,
2834
3354
                   per_file_timestamps=per_file_timestamps)
2835
3355
        except errors.NoSuchExportFormat, e:
2836
 
            raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
 
3356
            raise errors.BzrCommandError(
 
3357
                gettext('Unsupported export format: %s') % e.format)
2837
3358
 
2838
3359
 
2839
3360
class cmd_cat(Command):
2859
3380
    def run(self, filename, revision=None, name_from_revision=False,
2860
3381
            filters=False, directory=None):
2861
3382
        if revision is not None and len(revision) != 1:
2862
 
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2863
 
                                         " one revision specifier")
 
3383
            raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
 
3384
                                         " one revision specifier"))
2864
3385
        tree, branch, relpath = \
2865
3386
            _open_directory_or_containing_tree_or_branch(filename, directory)
2866
3387
        self.add_cleanup(branch.lock_read().unlock)
2876
3397
 
2877
3398
        old_file_id = rev_tree.path2id(relpath)
2878
3399
 
 
3400
        # TODO: Split out this code to something that generically finds the
 
3401
        # best id for a path across one or more trees; it's like
 
3402
        # find_ids_across_trees but restricted to find just one. -- mbp
 
3403
        # 20110705.
2879
3404
        if name_from_revision:
2880
3405
            # Try in revision if requested
2881
3406
            if old_file_id is None:
2882
 
                raise errors.BzrCommandError(
2883
 
                    "%r is not present in revision %s" % (
 
3407
                raise errors.BzrCommandError(gettext(
 
3408
                    "{0!r} is not present in revision {1}").format(
2884
3409
                        filename, rev_tree.get_revision_id()))
2885
3410
            else:
2886
 
                content = rev_tree.get_file_text(old_file_id)
 
3411
                actual_file_id = old_file_id
2887
3412
        else:
2888
3413
            cur_file_id = tree.path2id(relpath)
2889
 
            found = False
2890
 
            if cur_file_id is not None:
2891
 
                # Then try with the actual file id
2892
 
                try:
2893
 
                    content = rev_tree.get_file_text(cur_file_id)
2894
 
                    found = True
2895
 
                except errors.NoSuchId:
2896
 
                    # The actual file id didn't exist at that time
2897
 
                    pass
2898
 
            if not found and old_file_id is not None:
2899
 
                # Finally try with the old file id
2900
 
                content = rev_tree.get_file_text(old_file_id)
2901
 
                found = True
2902
 
            if not found:
2903
 
                # Can't be found anywhere
2904
 
                raise errors.BzrCommandError(
2905
 
                    "%r is not present in revision %s" % (
 
3414
            if cur_file_id is not None and rev_tree.has_id(cur_file_id):
 
3415
                actual_file_id = cur_file_id
 
3416
            elif old_file_id is not None:
 
3417
                actual_file_id = old_file_id
 
3418
            else:
 
3419
                raise errors.BzrCommandError(gettext(
 
3420
                    "{0!r} is not present in revision {1}").format(
2906
3421
                        filename, rev_tree.get_revision_id()))
2907
3422
        if filtered:
2908
 
            from bzrlib.filters import (
2909
 
                ContentFilterContext,
2910
 
                filtered_output_bytes,
2911
 
                )
2912
 
            filters = rev_tree._content_filter_stack(relpath)
2913
 
            chunks = content.splitlines(True)
2914
 
            content = filtered_output_bytes(chunks, filters,
2915
 
                ContentFilterContext(relpath, rev_tree))
2916
 
            self.cleanup_now()
2917
 
            self.outf.writelines(content)
 
3423
            from bzrlib.filter_tree import ContentFilterTree
 
3424
            filter_tree = ContentFilterTree(rev_tree,
 
3425
                rev_tree._content_filter_stack)
 
3426
            content = filter_tree.get_file_text(actual_file_id)
2918
3427
        else:
2919
 
            self.cleanup_now()
2920
 
            self.outf.write(content)
 
3428
            content = rev_tree.get_file_text(actual_file_id)
 
3429
        self.cleanup_now()
 
3430
        self.outf.write(content)
2921
3431
 
2922
3432
 
2923
3433
class cmd_local_time_offset(Command):
2984
3494
      to trigger updates to external systems like bug trackers. The --fixes
2985
3495
      option can be used to record the association between a revision and
2986
3496
      one or more bugs. See ``bzr help bugs`` for details.
2987
 
 
2988
 
      A selective commit may fail in some cases where the committed
2989
 
      tree would be invalid. Consider::
2990
 
  
2991
 
        bzr init foo
2992
 
        mkdir foo/bar
2993
 
        bzr add foo/bar
2994
 
        bzr commit foo -m "committing foo"
2995
 
        bzr mv foo/bar foo/baz
2996
 
        mkdir foo/bar
2997
 
        bzr add foo/bar
2998
 
        bzr commit foo/bar -m "committing bar but not baz"
2999
 
  
3000
 
      In the example above, the last commit will fail by design. This gives
3001
 
      the user the opportunity to decide whether they want to commit the
3002
 
      rename at the same time, separately first, or not at all. (As a general
3003
 
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3004
3497
    """
3005
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
3006
 
 
3007
 
    # TODO: Strict commit that fails if there are deleted files.
3008
 
    #       (what does "deleted files" mean ??)
3009
 
 
3010
 
    # TODO: Give better message for -s, --summary, used by tla people
3011
 
 
3012
 
    # XXX: verbose currently does nothing
3013
3498
 
3014
3499
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3015
3500
    takes_args = ['selected*']
3047
3532
             Option('show-diff', short_name='p',
3048
3533
                    help='When no message is supplied, show the diff along'
3049
3534
                    ' with the status summary in the message editor.'),
 
3535
             Option('lossy', 
 
3536
                    help='When committing to a foreign version control '
 
3537
                    'system do not push data that can not be natively '
 
3538
                    'represented.'),
3050
3539
             ]
3051
3540
    aliases = ['ci', 'checkin']
3052
3541
 
3053
3542
    def _iter_bug_fix_urls(self, fixes, branch):
 
3543
        default_bugtracker  = None
3054
3544
        # Configure the properties for bug fixing attributes.
3055
3545
        for fixed_bug in fixes:
3056
3546
            tokens = fixed_bug.split(':')
3057
 
            if len(tokens) != 2:
3058
 
                raise errors.BzrCommandError(
 
3547
            if len(tokens) == 1:
 
3548
                if default_bugtracker is None:
 
3549
                    branch_config = branch.get_config_stack()
 
3550
                    default_bugtracker = branch_config.get(
 
3551
                        "bugtracker")
 
3552
                if default_bugtracker is None:
 
3553
                    raise errors.BzrCommandError(gettext(
 
3554
                        "No tracker specified for bug %s. Use the form "
 
3555
                        "'tracker:id' or specify a default bug tracker "
 
3556
                        "using the `bugtracker` option.\nSee "
 
3557
                        "\"bzr help bugs\" for more information on this "
 
3558
                        "feature. Commit refused.") % fixed_bug)
 
3559
                tag = default_bugtracker
 
3560
                bug_id = tokens[0]
 
3561
            elif len(tokens) != 2:
 
3562
                raise errors.BzrCommandError(gettext(
3059
3563
                    "Invalid bug %s. Must be in the form of 'tracker:id'. "
3060
3564
                    "See \"bzr help bugs\" for more information on this "
3061
 
                    "feature.\nCommit refused." % fixed_bug)
3062
 
            tag, bug_id = tokens
 
3565
                    "feature.\nCommit refused.") % fixed_bug)
 
3566
            else:
 
3567
                tag, bug_id = tokens
3063
3568
            try:
3064
3569
                yield bugtracker.get_bug_url(tag, branch, bug_id)
3065
3570
            except errors.UnknownBugTrackerAbbreviation:
3066
 
                raise errors.BzrCommandError(
3067
 
                    'Unrecognized bug %s. Commit refused.' % fixed_bug)
 
3571
                raise errors.BzrCommandError(gettext(
 
3572
                    'Unrecognized bug %s. Commit refused.') % fixed_bug)
3068
3573
            except errors.MalformedBugIdentifier, e:
3069
 
                raise errors.BzrCommandError(
3070
 
                    "%s\nCommit refused." % (str(e),))
 
3574
                raise errors.BzrCommandError(gettext(
 
3575
                    "%s\nCommit refused.") % (str(e),))
3071
3576
 
3072
3577
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3073
3578
            unchanged=False, strict=False, local=False, fixes=None,
3074
 
            author=None, show_diff=False, exclude=None, commit_time=None):
 
3579
            author=None, show_diff=False, exclude=None, commit_time=None,
 
3580
            lossy=False):
3075
3581
        from bzrlib.errors import (
3076
3582
            PointlessCommit,
3077
3583
            ConflictsInTree,
3080
3586
        from bzrlib.msgeditor import (
3081
3587
            edit_commit_message_encoded,
3082
3588
            generate_commit_message_template,
3083
 
            make_commit_message_template_encoded
 
3589
            make_commit_message_template_encoded,
 
3590
            set_commit_message,
3084
3591
        )
3085
3592
 
3086
3593
        commit_stamp = offset = None
3088
3595
            try:
3089
3596
                commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3090
3597
            except ValueError, e:
3091
 
                raise errors.BzrCommandError(
3092
 
                    "Could not parse --commit-time: " + str(e))
3093
 
 
3094
 
        # TODO: Need a blackbox test for invoking the external editor; may be
3095
 
        # slightly problematic to run this cross-platform.
3096
 
 
3097
 
        # TODO: do more checks that the commit will succeed before
3098
 
        # spending the user's valuable time typing a commit message.
 
3598
                raise errors.BzrCommandError(gettext(
 
3599
                    "Could not parse --commit-time: " + str(e)))
3099
3600
 
3100
3601
        properties = {}
3101
3602
 
3134
3635
                message = message.replace('\r\n', '\n')
3135
3636
                message = message.replace('\r', '\n')
3136
3637
            if file:
3137
 
                raise errors.BzrCommandError(
3138
 
                    "please specify either --message or --file")
 
3638
                raise errors.BzrCommandError(gettext(
 
3639
                    "please specify either --message or --file"))
3139
3640
 
3140
3641
        def get_message(commit_obj):
3141
3642
            """Callback to get commit message"""
3158
3659
                # make_commit_message_template_encoded returns user encoding.
3159
3660
                # We probably want to be using edit_commit_message instead to
3160
3661
                # avoid this.
3161
 
                start_message = generate_commit_message_template(commit_obj)
3162
 
                my_message = edit_commit_message_encoded(text,
3163
 
                    start_message=start_message)
3164
 
                if my_message is None:
3165
 
                    raise errors.BzrCommandError("please specify a commit"
3166
 
                        " message with either --message or --file")
3167
 
            if my_message == "":
3168
 
                raise errors.BzrCommandError("empty commit message specified")
 
3662
                my_message = set_commit_message(commit_obj)
 
3663
                if my_message is None:
 
3664
                    start_message = generate_commit_message_template(commit_obj)
 
3665
                    my_message = edit_commit_message_encoded(text,
 
3666
                        start_message=start_message)
 
3667
                if my_message is None:
 
3668
                    raise errors.BzrCommandError(gettext("please specify a commit"
 
3669
                        " message with either --message or --file"))
 
3670
                if my_message == "":
 
3671
                    raise errors.BzrCommandError(gettext("Empty commit message specified."
 
3672
                            " Please specify a commit message with either"
 
3673
                            " --message or --file or leave a blank message"
 
3674
                            " with --message \"\"."))
3169
3675
            return my_message
3170
3676
 
3171
3677
        # The API permits a commit with a filter of [] to mean 'select nothing'
3179
3685
                        reporter=None, verbose=verbose, revprops=properties,
3180
3686
                        authors=author, timestamp=commit_stamp,
3181
3687
                        timezone=offset,
3182
 
                        exclude=tree.safe_relpath_files(exclude))
 
3688
                        exclude=tree.safe_relpath_files(exclude),
 
3689
                        lossy=lossy)
3183
3690
        except PointlessCommit:
3184
 
            raise errors.BzrCommandError("No changes to commit."
3185
 
                              " Use --unchanged to commit anyhow.")
 
3691
            raise errors.BzrCommandError(gettext("No changes to commit."
 
3692
                " Please 'bzr add' the files you want to commit, or use"
 
3693
                " --unchanged to force an empty commit."))
3186
3694
        except ConflictsInTree:
3187
 
            raise errors.BzrCommandError('Conflicts detected in working '
 
3695
            raise errors.BzrCommandError(gettext('Conflicts detected in working '
3188
3696
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3189
 
                ' resolve.')
 
3697
                ' resolve.'))
3190
3698
        except StrictCommitFailed:
3191
 
            raise errors.BzrCommandError("Commit refused because there are"
3192
 
                              " unknown files in the working tree.")
 
3699
            raise errors.BzrCommandError(gettext("Commit refused because there are"
 
3700
                              " unknown files in the working tree."))
3193
3701
        except errors.BoundBranchOutOfDate, e:
3194
 
            e.extra_help = ("\n"
 
3702
            e.extra_help = (gettext("\n"
3195
3703
                'To commit to master branch, run update and then commit.\n'
3196
3704
                'You can also pass --local to commit to continue working '
3197
 
                'disconnected.')
 
3705
                'disconnected.'))
3198
3706
            raise
3199
3707
 
3200
3708
 
3269
3777
 
3270
3778
 
3271
3779
class cmd_upgrade(Command):
3272
 
    __doc__ = """Upgrade branch storage to current format.
3273
 
 
3274
 
    The check command or bzr developers may sometimes advise you to run
3275
 
    this command. When the default format has changed you may also be warned
3276
 
    during other operations to upgrade.
 
3780
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3781
 
 
3782
    When the default format has changed after a major new release of
 
3783
    Bazaar, you may be informed during certain operations that you
 
3784
    should upgrade. Upgrading to a newer format may improve performance
 
3785
    or make new features available. It may however limit interoperability
 
3786
    with older repositories or with older versions of Bazaar.
 
3787
 
 
3788
    If you wish to upgrade to a particular format rather than the
 
3789
    current default, that can be specified using the --format option.
 
3790
    As a consequence, you can use the upgrade command this way to
 
3791
    "downgrade" to an earlier format, though some conversions are
 
3792
    a one way process (e.g. changing from the 1.x default to the
 
3793
    2.x default) so downgrading is not always possible.
 
3794
 
 
3795
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3796
    process (where # is a number). By default, this is left there on
 
3797
    completion. If the conversion fails, delete the new .bzr directory
 
3798
    and rename this one back in its place. Use the --clean option to ask
 
3799
    for the backup.bzr directory to be removed on successful conversion.
 
3800
    Alternatively, you can delete it by hand if everything looks good
 
3801
    afterwards.
 
3802
 
 
3803
    If the location given is a shared repository, dependent branches
 
3804
    are also converted provided the repository converts successfully.
 
3805
    If the conversion of a branch fails, remaining branches are still
 
3806
    tried.
 
3807
 
 
3808
    For more information on upgrades, see the Bazaar Upgrade Guide,
 
3809
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3277
3810
    """
3278
3811
 
3279
 
    _see_also = ['check']
 
3812
    _see_also = ['check', 'reconcile', 'formats']
3280
3813
    takes_args = ['url?']
3281
3814
    takes_options = [
3282
 
                    RegistryOption('format',
3283
 
                        help='Upgrade to a specific format.  See "bzr help'
3284
 
                             ' formats" for details.',
3285
 
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3286
 
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3287
 
                        value_switches=True, title='Branch format'),
3288
 
                    ]
 
3815
        RegistryOption('format',
 
3816
            help='Upgrade to a specific format.  See "bzr help'
 
3817
                 ' formats" for details.',
 
3818
            lazy_registry=('bzrlib.controldir', 'format_registry'),
 
3819
            converter=lambda name: controldir.format_registry.make_bzrdir(name),
 
3820
            value_switches=True, title='Branch format'),
 
3821
        Option('clean',
 
3822
            help='Remove the backup.bzr directory if successful.'),
 
3823
        Option('dry-run',
 
3824
            help="Show what would be done, but don't actually do anything."),
 
3825
    ]
3289
3826
 
3290
 
    def run(self, url='.', format=None):
 
3827
    def run(self, url='.', format=None, clean=False, dry_run=False):
3291
3828
        from bzrlib.upgrade import upgrade
3292
 
        upgrade(url, format)
 
3829
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3830
        if exceptions:
 
3831
            if len(exceptions) == 1:
 
3832
                # Compatibility with historical behavior
 
3833
                raise exceptions[0]
 
3834
            else:
 
3835
                return 3
3293
3836
 
3294
3837
 
3295
3838
class cmd_whoami(Command):
3320
3863
            if directory is None:
3321
3864
                # use branch if we're inside one; otherwise global config
3322
3865
                try:
3323
 
                    c = Branch.open_containing(u'.')[0].get_config()
 
3866
                    c = Branch.open_containing(u'.')[0].get_config_stack()
3324
3867
                except errors.NotBranchError:
3325
 
                    c = _mod_config.GlobalConfig()
 
3868
                    c = _mod_config.GlobalStack()
3326
3869
            else:
3327
 
                c = Branch.open(directory).get_config()
 
3870
                c = Branch.open(directory).get_config_stack()
 
3871
            identity = c.get('email')
3328
3872
            if email:
3329
 
                self.outf.write(c.user_email() + '\n')
 
3873
                self.outf.write(_mod_config.extract_email_address(identity)
 
3874
                                + '\n')
3330
3875
            else:
3331
 
                self.outf.write(c.username() + '\n')
 
3876
                self.outf.write(identity + '\n')
3332
3877
            return
3333
3878
 
 
3879
        if email:
 
3880
            raise errors.BzrCommandError(gettext("--email can only be used to display existing "
 
3881
                                         "identity"))
 
3882
 
3334
3883
        # display a warning if an email address isn't included in the given name.
3335
3884
        try:
3336
3885
            _mod_config.extract_email_address(name)
3341
3890
        # use global config unless --branch given
3342
3891
        if branch:
3343
3892
            if directory is None:
3344
 
                c = Branch.open_containing(u'.')[0].get_config()
 
3893
                c = Branch.open_containing(u'.')[0].get_config_stack()
3345
3894
            else:
3346
 
                c = Branch.open(directory).get_config()
 
3895
                b = Branch.open(directory)
 
3896
                self.add_cleanup(b.lock_write().unlock)
 
3897
                c = b.get_config_stack()
3347
3898
        else:
3348
 
            c = _mod_config.GlobalConfig()
3349
 
        c.set_user_option('email', name)
 
3899
            c = _mod_config.GlobalStack()
 
3900
        c.set('email', name)
3350
3901
 
3351
3902
 
3352
3903
class cmd_nick(Command):
3353
3904
    __doc__ = """Print or set the branch nickname.
3354
3905
 
3355
 
    If unset, the tree root directory name is used as the nickname.
3356
 
    To print the current nickname, execute with no argument.
 
3906
    If unset, the colocated branch name is used for colocated branches, and
 
3907
    the branch directory name is used for other branches.  To print the
 
3908
    current nickname, execute with no argument.
3357
3909
 
3358
3910
    Bound branches use the nickname of its master branch unless it is set
3359
3911
    locally.
3414
3966
 
3415
3967
    def remove_alias(self, alias_name):
3416
3968
        if alias_name is None:
3417
 
            raise errors.BzrCommandError(
3418
 
                'bzr alias --remove expects an alias to remove.')
 
3969
            raise errors.BzrCommandError(gettext(
 
3970
                'bzr alias --remove expects an alias to remove.'))
3419
3971
        # If alias is not found, print something like:
3420
3972
        # unalias: foo: not found
3421
3973
        c = _mod_config.GlobalConfig()
3481
4033
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3482
4034
    into a pdb postmortem session.
3483
4035
 
 
4036
    The --coverage=DIRNAME global option produces a report with covered code
 
4037
    indicated.
 
4038
 
3484
4039
    :Examples:
3485
4040
        Run only tests relating to 'ignore'::
3486
4041
 
3497
4052
        if typestring == "sftp":
3498
4053
            from bzrlib.tests import stub_sftp
3499
4054
            return stub_sftp.SFTPAbsoluteServer
3500
 
        if typestring == "memory":
 
4055
        elif typestring == "memory":
3501
4056
            from bzrlib.tests import test_server
3502
4057
            return memory.MemoryServer
3503
 
        if typestring == "fakenfs":
 
4058
        elif typestring == "fakenfs":
3504
4059
            from bzrlib.tests import test_server
3505
4060
            return test_server.FakeNFSServer
3506
4061
        msg = "No known transport type %s. Supported types are: sftp\n" %\
3540
4095
                     Option('randomize', type=str, argname="SEED",
3541
4096
                            help='Randomize the order of tests using the given'
3542
4097
                                 ' seed or "now" for the current time.'),
3543
 
                     Option('exclude', type=str, argname="PATTERN",
3544
 
                            short_name='x',
3545
 
                            help='Exclude tests that match this regular'
3546
 
                                 ' expression.'),
 
4098
                     ListOption('exclude', type=str, argname="PATTERN",
 
4099
                                short_name='x',
 
4100
                                help='Exclude tests that match this regular'
 
4101
                                ' expression.'),
3547
4102
                     Option('subunit',
3548
4103
                        help='Output test progress via subunit.'),
3549
4104
                     Option('strict', help='Fail on missing dependencies or '
3556
4111
                                param_name='starting_with', short_name='s',
3557
4112
                                help=
3558
4113
                                'Load only the tests starting with TESTID.'),
 
4114
                     Option('sync',
 
4115
                            help="By default we disable fsync and fdatasync"
 
4116
                                 " while running the test suite.")
3559
4117
                     ]
3560
4118
    encoding_type = 'replace'
3561
4119
 
3569
4127
            first=False, list_only=False,
3570
4128
            randomize=None, exclude=None, strict=False,
3571
4129
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3572
 
            parallel=None, lsprof_tests=False):
 
4130
            parallel=None, lsprof_tests=False,
 
4131
            sync=False):
 
4132
 
 
4133
        # During selftest, disallow proxying, as it can cause severe
 
4134
        # performance penalties and is only needed for thread
 
4135
        # safety. The selftest command is assumed to not use threads
 
4136
        # too heavily. The call should be as early as possible, as
 
4137
        # error reporting for past duplicate imports won't have useful
 
4138
        # backtraces.
 
4139
        lazy_import.disallow_proxying()
 
4140
 
3573
4141
        from bzrlib import tests
3574
4142
 
3575
4143
        if testspecs_list is not None:
3580
4148
            try:
3581
4149
                from bzrlib.tests import SubUnitBzrRunner
3582
4150
            except ImportError:
3583
 
                raise errors.BzrCommandError("subunit not available. subunit "
3584
 
                    "needs to be installed to use --subunit.")
 
4151
                raise errors.BzrCommandError(gettext("subunit not available. subunit "
 
4152
                    "needs to be installed to use --subunit."))
3585
4153
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3586
4154
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3587
4155
            # stdout, which would corrupt the subunit stream. 
3596
4164
            self.additional_selftest_args.setdefault(
3597
4165
                'suite_decorators', []).append(parallel)
3598
4166
        if benchmark:
3599
 
            raise errors.BzrCommandError(
 
4167
            raise errors.BzrCommandError(gettext(
3600
4168
                "--benchmark is no longer supported from bzr 2.2; "
3601
 
                "use bzr-usertest instead")
 
4169
                "use bzr-usertest instead"))
3602
4170
        test_suite_factory = None
 
4171
        if not exclude:
 
4172
            exclude_pattern = None
 
4173
        else:
 
4174
            exclude_pattern = '(' + '|'.join(exclude) + ')'
 
4175
        if not sync:
 
4176
            self._disable_fsync()
3603
4177
        selftest_kwargs = {"verbose": verbose,
3604
4178
                          "pattern": pattern,
3605
4179
                          "stop_on_failure": one,
3610
4184
                          "matching_tests_first": first,
3611
4185
                          "list_only": list_only,
3612
4186
                          "random_seed": randomize,
3613
 
                          "exclude_pattern": exclude,
 
4187
                          "exclude_pattern": exclude_pattern,
3614
4188
                          "strict": strict,
3615
4189
                          "load_list": load_list,
3616
4190
                          "debug_flags": debugflag,
3627
4201
            cleanup()
3628
4202
        return int(not result)
3629
4203
 
 
4204
    def _disable_fsync(self):
 
4205
        """Change the 'os' functionality to not synchronize."""
 
4206
        self._orig_fsync = getattr(os, 'fsync', None)
 
4207
        if self._orig_fsync is not None:
 
4208
            os.fsync = lambda filedes: None
 
4209
        self._orig_fdatasync = getattr(os, 'fdatasync', None)
 
4210
        if self._orig_fdatasync is not None:
 
4211
            os.fdatasync = lambda filedes: None
 
4212
 
3630
4213
 
3631
4214
class cmd_version(Command):
3632
4215
    __doc__ = """Show version of bzr."""
3652
4235
 
3653
4236
    @display_command
3654
4237
    def run(self):
3655
 
        self.outf.write("It sure does!\n")
 
4238
        self.outf.write(gettext("It sure does!\n"))
3656
4239
 
3657
4240
 
3658
4241
class cmd_find_merge_base(Command):
3676
4259
        graph = branch1.repository.get_graph(branch2.repository)
3677
4260
        base_rev_id = graph.find_unique_lca(last1, last2)
3678
4261
 
3679
 
        self.outf.write('merge base is revision %s\n' % base_rev_id)
 
4262
        self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
3680
4263
 
3681
4264
 
3682
4265
class cmd_merge(Command):
3685
4268
    The source of the merge can be specified either in the form of a branch,
3686
4269
    or in the form of a path to a file containing a merge directive generated
3687
4270
    with bzr send. If neither is specified, the default is the upstream branch
3688
 
    or the branch most recently merged using --remember.
3689
 
 
3690
 
    When merging a branch, by default the tip will be merged. To pick a different
3691
 
    revision, pass --revision. If you specify two values, the first will be used as
3692
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3693
 
    available revisions, like this is commonly referred to as "cherrypicking".
3694
 
 
3695
 
    Revision numbers are always relative to the branch being merged.
3696
 
 
3697
 
    By default, bzr will try to merge in all new work from the other
3698
 
    branch, automatically determining an appropriate base.  If this
3699
 
    fails, you may need to give an explicit base.
 
4271
    or the branch most recently merged using --remember.  The source of the
 
4272
    merge may also be specified in the form of a path to a file in another
 
4273
    branch:  in this case, only the modifications to that file are merged into
 
4274
    the current working tree.
 
4275
 
 
4276
    When merging from a branch, by default bzr will try to merge in all new
 
4277
    work from the other branch, automatically determining an appropriate base
 
4278
    revision.  If this fails, you may need to give an explicit base.
 
4279
 
 
4280
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
4281
    try to merge in all new work up to and including revision OTHER.
 
4282
 
 
4283
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
4284
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
4285
    causes some revisions to be skipped, i.e. if the destination branch does
 
4286
    not already contain revision BASE, such a merge is commonly referred to as
 
4287
    a "cherrypick". Unlike a normal merge, Bazaar does not currently track
 
4288
    cherrypicks. The changes look like a normal commit, and the history of the
 
4289
    changes from the other branch is not stored in the commit.
 
4290
 
 
4291
    Revision numbers are always relative to the source branch.
3700
4292
 
3701
4293
    Merge will do its best to combine the changes in two branches, but there
3702
4294
    are some kinds of problems only a human can fix.  When it encounters those,
3703
4295
    it will mark a conflict.  A conflict means that you need to fix something,
3704
 
    before you should commit.
 
4296
    before you can commit.
3705
4297
 
3706
4298
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
3707
4299
 
3708
 
    If there is no default branch set, the first merge will set it. After
3709
 
    that, you can omit the branch to use the default.  To change the
3710
 
    default, use --remember. The value will only be saved if the remote
3711
 
    location can be accessed.
 
4300
    If there is no default branch set, the first merge will set it (use
 
4301
    --no-remember to avoid setting it). After that, you can omit the branch
 
4302
    to use the default.  To change the default, use --remember. The value will
 
4303
    only be saved if the remote location can be accessed.
3712
4304
 
3713
4305
    The results of the merge are placed into the destination working
3714
4306
    directory, where they can be reviewed (with bzr diff), tested, and then
3715
4307
    committed to record the result of the merge.
3716
4308
 
3717
4309
    merge refuses to run if there are any uncommitted changes, unless
3718
 
    --force is given. The --force option can also be used to create a
 
4310
    --force is given.  If --force is given, then the changes from the source 
 
4311
    will be merged with the current working tree, including any uncommitted
 
4312
    changes in the tree.  The --force option can also be used to create a
3719
4313
    merge revision which has more than two parents.
3720
4314
 
3721
4315
    If one would like to merge changes from the working tree of the other
3726
4320
    you to apply each diff hunk and file change, similar to "shelve".
3727
4321
 
3728
4322
    :Examples:
3729
 
        To merge the latest revision from bzr.dev::
 
4323
        To merge all new revisions from bzr.dev::
3730
4324
 
3731
4325
            bzr merge ../bzr.dev
3732
4326
 
3779
4373
    ]
3780
4374
 
3781
4375
    def run(self, location=None, revision=None, force=False,
3782
 
            merge_type=None, show_base=False, reprocess=None, remember=False,
 
4376
            merge_type=None, show_base=False, reprocess=None, remember=None,
3783
4377
            uncommitted=False, pull=False,
3784
4378
            directory=None,
3785
4379
            preview=False,
3793
4387
        merger = None
3794
4388
        allow_pending = True
3795
4389
        verified = 'inapplicable'
 
4390
 
3796
4391
        tree = WorkingTree.open_containing(directory)[0]
 
4392
        if tree.branch.revno() == 0:
 
4393
            raise errors.BzrCommandError(gettext('Merging into empty branches not currently supported, '
 
4394
                                         'https://bugs.launchpad.net/bzr/+bug/308562'))
3797
4395
 
3798
4396
        try:
3799
4397
            basis_tree = tree.revision_tree(tree.last_revision())
3819
4417
                mergeable = None
3820
4418
            else:
3821
4419
                if uncommitted:
3822
 
                    raise errors.BzrCommandError('Cannot use --uncommitted'
3823
 
                        ' with bundles or merge directives.')
 
4420
                    raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
 
4421
                        ' with bundles or merge directives.'))
3824
4422
 
3825
4423
                if revision is not None:
3826
 
                    raise errors.BzrCommandError(
3827
 
                        'Cannot use -r with merge directives or bundles')
 
4424
                    raise errors.BzrCommandError(gettext(
 
4425
                        'Cannot use -r with merge directives or bundles'))
3828
4426
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
3829
4427
                   mergeable, None)
3830
4428
 
3831
4429
        if merger is None and uncommitted:
3832
4430
            if revision is not None and len(revision) > 0:
3833
 
                raise errors.BzrCommandError('Cannot use --uncommitted and'
3834
 
                    ' --revision at the same time.')
 
4431
                raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
 
4432
                    ' --revision at the same time.'))
3835
4433
            merger = self.get_merger_from_uncommitted(tree, location, None)
3836
4434
            allow_pending = False
3837
4435
 
3845
4443
        self.sanity_check_merger(merger)
3846
4444
        if (merger.base_rev_id == merger.other_rev_id and
3847
4445
            merger.other_rev_id is not None):
3848
 
            note('Nothing to do.')
 
4446
            # check if location is a nonexistent file (and not a branch) to
 
4447
            # disambiguate the 'Nothing to do'
 
4448
            if merger.interesting_files:
 
4449
                if not merger.other_tree.has_filename(
 
4450
                    merger.interesting_files[0]):
 
4451
                    note(gettext("merger: ") + str(merger))
 
4452
                    raise errors.PathsDoNotExist([location])
 
4453
            note(gettext('Nothing to do.'))
3849
4454
            return 0
3850
 
        if pull:
 
4455
        if pull and not preview:
3851
4456
            if merger.interesting_files is not None:
3852
 
                raise errors.BzrCommandError('Cannot pull individual files')
 
4457
                raise errors.BzrCommandError(gettext('Cannot pull individual files'))
3853
4458
            if (merger.base_rev_id == tree.last_revision()):
3854
4459
                result = tree.pull(merger.other_branch, False,
3855
4460
                                   merger.other_rev_id)
3856
4461
                result.report(self.outf)
3857
4462
                return 0
3858
4463
        if merger.this_basis is None:
3859
 
            raise errors.BzrCommandError(
 
4464
            raise errors.BzrCommandError(gettext(
3860
4465
                "This branch has no commits."
3861
 
                " (perhaps you would prefer 'bzr pull')")
 
4466
                " (perhaps you would prefer 'bzr pull')"))
3862
4467
        if preview:
3863
4468
            return self._do_preview(merger)
3864
4469
        elif interactive:
3915
4520
    def sanity_check_merger(self, merger):
3916
4521
        if (merger.show_base and
3917
4522
            not merger.merge_type is _mod_merge.Merge3Merger):
3918
 
            raise errors.BzrCommandError("Show-base is not supported for this"
3919
 
                                         " merge type. %s" % merger.merge_type)
 
4523
            raise errors.BzrCommandError(gettext("Show-base is not supported for this"
 
4524
                                         " merge type. %s") % merger.merge_type)
3920
4525
        if merger.reprocess is None:
3921
4526
            if merger.show_base:
3922
4527
                merger.reprocess = False
3924
4529
                # Use reprocess if the merger supports it
3925
4530
                merger.reprocess = merger.merge_type.supports_reprocess
3926
4531
        if merger.reprocess and not merger.merge_type.supports_reprocess:
3927
 
            raise errors.BzrCommandError("Conflict reduction is not supported"
3928
 
                                         " for merge type %s." %
 
4532
            raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
 
4533
                                         " for merge type %s.") %
3929
4534
                                         merger.merge_type)
3930
4535
        if merger.reprocess and merger.show_base:
3931
 
            raise errors.BzrCommandError("Cannot do conflict reduction and"
3932
 
                                         " show base.")
 
4536
            raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
 
4537
                                         " show base."))
3933
4538
 
3934
4539
    def _get_merger_from_branch(self, tree, location, revision, remember,
3935
4540
                                possible_transports, pb):
3962
4567
        if other_revision_id is None:
3963
4568
            other_revision_id = _mod_revision.ensure_null(
3964
4569
                other_branch.last_revision())
3965
 
        # Remember where we merge from
3966
 
        if ((remember or tree.branch.get_submit_branch() is None) and
3967
 
             user_location is not None):
 
4570
        # Remember where we merge from. We need to remember if:
 
4571
        # - user specify a location (and we don't merge from the parent
 
4572
        #   branch)
 
4573
        # - user ask to remember or there is no previous location set to merge
 
4574
        #   from and user didn't ask to *not* remember
 
4575
        if (user_location is not None
 
4576
            and ((remember
 
4577
                  or (remember is None
 
4578
                      and tree.branch.get_submit_branch() is None)))):
3968
4579
            tree.branch.set_submit_branch(other_branch.base)
3969
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4580
        # Merge tags (but don't set them in the master branch yet, the user
 
4581
        # might revert this merge).  Commit will propagate them.
 
4582
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3970
4583
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3971
4584
            other_revision_id, base_revision_id, other_branch, base_branch)
3972
4585
        if other_path != '':
4031
4644
            stored_location_type = "parent"
4032
4645
        mutter("%s", stored_location)
4033
4646
        if stored_location is None:
4034
 
            raise errors.BzrCommandError("No location specified or remembered")
 
4647
            raise errors.BzrCommandError(gettext("No location specified or remembered"))
4035
4648
        display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4036
 
        note(u"%s remembered %s location %s", verb_string,
4037
 
                stored_location_type, display_url)
 
4649
        note(gettext("{0} remembered {1} location {2}").format(verb_string,
 
4650
                stored_location_type, display_url))
4038
4651
        return stored_location
4039
4652
 
4040
4653
 
4077
4690
        self.add_cleanup(tree.lock_write().unlock)
4078
4691
        parents = tree.get_parent_ids()
4079
4692
        if len(parents) != 2:
4080
 
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
 
4693
            raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4081
4694
                                         " merges.  Not cherrypicking or"
4082
 
                                         " multi-merges.")
 
4695
                                         " multi-merges."))
4083
4696
        repository = tree.branch.repository
4084
4697
        interesting_ids = None
4085
4698
        new_conflicts = []
4094
4707
                if tree.kind(file_id) != "directory":
4095
4708
                    continue
4096
4709
 
4097
 
                for name, ie in tree.inventory.iter_entries(file_id):
 
4710
                # FIXME: Support nested trees
 
4711
                for name, ie in tree.root_inventory.iter_entries(file_id):
4098
4712
                    interesting_ids.add(ie.file_id)
4099
4713
            new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4100
4714
        else:
4133
4747
 
4134
4748
 
4135
4749
class cmd_revert(Command):
4136
 
    __doc__ = """Revert files to a previous revision.
 
4750
    __doc__ = """\
 
4751
    Set files in the working tree back to the contents of a previous revision.
4137
4752
 
4138
4753
    Giving a list of files will revert only those files.  Otherwise, all files
4139
4754
    will be reverted.  If the revision is not specified with '--revision', the
4140
 
    last committed revision is used.
 
4755
    working tree basis revision is used. A revert operation affects only the
 
4756
    working tree, not any revision history like the branch and repository or
 
4757
    the working tree basis revision.
4141
4758
 
4142
4759
    To remove only some changes, without reverting to a prior version, use
4143
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4144
 
    changes introduced by -2, without affecting the changes introduced by -1.
4145
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
4760
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4761
    will remove the changes introduced by the second last commit (-2), without
 
4762
    affecting the changes introduced by the last commit (-1).  To remove
 
4763
    certain changes on a hunk-by-hunk basis, see the shelve command.
 
4764
    To update the branch to a specific revision or the latest revision and
 
4765
    update the working tree accordingly while preserving local changes, see the
 
4766
    update command.
4146
4767
 
4147
 
    By default, any files that have been manually changed will be backed up
4148
 
    first.  (Files changed only by merge are not backed up.)  Backup files have
4149
 
    '.~#~' appended to their name, where # is a number.
 
4768
    Uncommitted changes to files that are reverted will be discarded.
 
4769
    Howver, by default, any files that have been manually changed will be
 
4770
    backed up first.  (Files changed only by merge are not backed up.)  Backup
 
4771
    files have '.~#~' appended to their name, where # is a number.
4150
4772
 
4151
4773
    When you provide files, you can use their current pathname or the pathname
4152
4774
    from the target revision.  So you can use revert to "undelete" a file by
4178
4800
    target branches.
4179
4801
    """
4180
4802
 
4181
 
    _see_also = ['cat', 'export']
 
4803
    _see_also = ['cat', 'export', 'merge', 'shelve']
4182
4804
    takes_options = [
4183
4805
        'revision',
4184
4806
        Option('no-backup', "Do not save backups of reverted files."),
4243
4865
 
4244
4866
    @display_command
4245
4867
    def run(self, context=None):
4246
 
        import shellcomplete
 
4868
        from bzrlib import shellcomplete
4247
4869
        shellcomplete.shellcomplete(context)
4248
4870
 
4249
4871
 
4303
4925
            type=_parse_revision_str,
4304
4926
            help='Filter on local branch revisions (inclusive). '
4305
4927
                'See "help revisionspec" for details.'),
4306
 
        Option('include-merges',
 
4928
        Option('include-merged',
4307
4929
               'Show all revisions in addition to the mainline ones.'),
 
4930
        Option('include-merges', hidden=True,
 
4931
               help='Historical alias for --include-merged.'),
4308
4932
        ]
4309
4933
    encoding_type = 'replace'
4310
4934
 
4313
4937
            theirs_only=False,
4314
4938
            log_format=None, long=False, short=False, line=False,
4315
4939
            show_ids=False, verbose=False, this=False, other=False,
4316
 
            include_merges=False, revision=None, my_revision=None,
4317
 
            directory=u'.'):
 
4940
            include_merged=None, revision=None, my_revision=None,
 
4941
            directory=u'.',
 
4942
            include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4318
4943
        from bzrlib.missing import find_unmerged, iter_log_revisions
4319
4944
        def message(s):
4320
4945
            if not is_quiet():
4321
4946
                self.outf.write(s)
4322
4947
 
 
4948
        if symbol_versioning.deprecated_passed(include_merges):
 
4949
            ui.ui_factory.show_user_warning(
 
4950
                'deprecated_command_option',
 
4951
                deprecated_name='--include-merges',
 
4952
                recommended_name='--include-merged',
 
4953
                deprecated_in_version='2.5',
 
4954
                command=self.invoked_as)
 
4955
            if include_merged is None:
 
4956
                include_merged = include_merges
 
4957
            else:
 
4958
                raise errors.BzrCommandError(gettext(
 
4959
                    '{0} and {1} are mutually exclusive').format(
 
4960
                    '--include-merges', '--include-merged'))
 
4961
        if include_merged is None:
 
4962
            include_merged = False
4323
4963
        if this:
4324
4964
            mine_only = this
4325
4965
        if other:
4340
4980
        if other_branch is None:
4341
4981
            other_branch = parent
4342
4982
            if other_branch is None:
4343
 
                raise errors.BzrCommandError("No peer location known"
4344
 
                                             " or specified.")
 
4983
                raise errors.BzrCommandError(gettext("No peer location known"
 
4984
                                             " or specified."))
4345
4985
            display_url = urlutils.unescape_for_display(parent,
4346
4986
                                                        self.outf.encoding)
4347
 
            message("Using saved parent location: "
4348
 
                    + display_url + "\n")
 
4987
            message(gettext("Using saved parent location: {0}\n").format(
 
4988
                    display_url))
4349
4989
 
4350
4990
        remote_branch = Branch.open(other_branch)
4351
4991
        if remote_branch.base == local_branch.base:
4364
5004
        local_extra, remote_extra = find_unmerged(
4365
5005
            local_branch, remote_branch, restrict,
4366
5006
            backward=not reverse,
4367
 
            include_merges=include_merges,
 
5007
            include_merged=include_merged,
4368
5008
            local_revid_range=local_revid_range,
4369
5009
            remote_revid_range=remote_revid_range)
4370
5010
 
4377
5017
 
4378
5018
        status_code = 0
4379
5019
        if local_extra and not theirs_only:
4380
 
            message("You have %d extra revision(s):\n" %
 
5020
            message(ngettext("You have %d extra revision:\n",
 
5021
                             "You have %d extra revisions:\n", 
 
5022
                             len(local_extra)) %
4381
5023
                len(local_extra))
 
5024
            rev_tag_dict = {}
 
5025
            if local_branch.supports_tags():
 
5026
                rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
4382
5027
            for revision in iter_log_revisions(local_extra,
4383
5028
                                local_branch.repository,
4384
 
                                verbose):
 
5029
                                verbose,
 
5030
                                rev_tag_dict):
4385
5031
                lf.log_revision(revision)
4386
5032
            printed_local = True
4387
5033
            status_code = 1
4391
5037
        if remote_extra and not mine_only:
4392
5038
            if printed_local is True:
4393
5039
                message("\n\n\n")
4394
 
            message("You are missing %d revision(s):\n" %
 
5040
            message(ngettext("You are missing %d revision:\n",
 
5041
                             "You are missing %d revisions:\n",
 
5042
                             len(remote_extra)) %
4395
5043
                len(remote_extra))
 
5044
            if remote_branch.supports_tags():
 
5045
                rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
4396
5046
            for revision in iter_log_revisions(remote_extra,
4397
5047
                                remote_branch.repository,
4398
 
                                verbose):
 
5048
                                verbose,
 
5049
                                rev_tag_dict):
4399
5050
                lf.log_revision(revision)
4400
5051
            status_code = 1
4401
5052
 
4402
5053
        if mine_only and not local_extra:
4403
5054
            # We checked local, and found nothing extra
4404
 
            message('This branch is up to date.\n')
 
5055
            message(gettext('This branch has no new revisions.\n'))
4405
5056
        elif theirs_only and not remote_extra:
4406
5057
            # We checked remote, and found nothing extra
4407
 
            message('Other branch is up to date.\n')
 
5058
            message(gettext('Other branch has no new revisions.\n'))
4408
5059
        elif not (mine_only or theirs_only or local_extra or
4409
5060
                  remote_extra):
4410
5061
            # We checked both branches, and neither one had extra
4411
5062
            # revisions
4412
 
            message("Branches are up to date.\n")
 
5063
            message(gettext("Branches are up to date.\n"))
4413
5064
        self.cleanup_now()
4414
5065
        if not status_code and parent is None and other_branch is not None:
4415
5066
            self.add_cleanup(local_branch.lock_write().unlock)
4445
5096
        ]
4446
5097
 
4447
5098
    def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4448
 
        dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
 
5099
        dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
4449
5100
        try:
4450
5101
            branch = dir.open_branch()
4451
5102
            repository = branch.repository
4477
5128
 
4478
5129
    @display_command
4479
5130
    def run(self, verbose=False):
4480
 
        import bzrlib.plugin
4481
 
        from inspect import getdoc
4482
 
        result = []
4483
 
        for name, plugin in bzrlib.plugin.plugins().items():
4484
 
            version = plugin.__version__
4485
 
            if version == 'unknown':
4486
 
                version = ''
4487
 
            name_ver = '%s %s' % (name, version)
4488
 
            d = getdoc(plugin.module)
4489
 
            if d:
4490
 
                doc = d.split('\n')[0]
4491
 
            else:
4492
 
                doc = '(no description)'
4493
 
            result.append((name_ver, doc, plugin.path()))
4494
 
        for name_ver, doc, path in sorted(result):
4495
 
            self.outf.write("%s\n" % name_ver)
4496
 
            self.outf.write("   %s\n" % doc)
4497
 
            if verbose:
4498
 
                self.outf.write("   %s\n" % path)
4499
 
            self.outf.write("\n")
 
5131
        from bzrlib import plugin
 
5132
        # Don't give writelines a generator as some codecs don't like that
 
5133
        self.outf.writelines(
 
5134
            list(plugin.describe_plugins(show_paths=verbose)))
4500
5135
 
4501
5136
 
4502
5137
class cmd_testament(Command):
4555
5190
    @display_command
4556
5191
    def run(self, filename, all=False, long=False, revision=None,
4557
5192
            show_ids=False, directory=None):
4558
 
        from bzrlib.annotate import annotate_file, annotate_file_tree
 
5193
        from bzrlib.annotate import (
 
5194
            annotate_file_tree,
 
5195
            )
4559
5196
        wt, branch, relpath = \
4560
5197
            _open_directory_or_containing_tree_or_branch(filename, directory)
4561
5198
        if wt is not None:
4564
5201
            self.add_cleanup(branch.lock_read().unlock)
4565
5202
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4566
5203
        self.add_cleanup(tree.lock_read().unlock)
4567
 
        if wt is not None:
 
5204
        if wt is not None and revision is None:
4568
5205
            file_id = wt.path2id(relpath)
4569
5206
        else:
4570
5207
            file_id = tree.path2id(relpath)
4571
5208
        if file_id is None:
4572
5209
            raise errors.NotVersionedError(filename)
4573
 
        file_version = tree.inventory[file_id].revision
4574
5210
        if wt is not None and revision is None:
4575
5211
            # If there is a tree and we're not annotating historical
4576
5212
            # versions, annotate the working tree's content.
4577
5213
            annotate_file_tree(wt, file_id, self.outf, long, all,
4578
5214
                show_ids=show_ids)
4579
5215
        else:
4580
 
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4581
 
                          show_ids=show_ids)
 
5216
            annotate_file_tree(tree, file_id, self.outf, long, all,
 
5217
                show_ids=show_ids, branch=branch)
4582
5218
 
4583
5219
 
4584
5220
class cmd_re_sign(Command):
4591
5227
 
4592
5228
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4593
5229
        if revision_id_list is not None and revision is not None:
4594
 
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
 
5230
            raise errors.BzrCommandError(gettext('You can only supply one of revision_id or --revision'))
4595
5231
        if revision_id_list is None and revision is None:
4596
 
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
 
5232
            raise errors.BzrCommandError(gettext('You must supply either --revision or a revision_id'))
4597
5233
        b = WorkingTree.open_containing(directory)[0].branch
4598
5234
        self.add_cleanup(b.lock_write().unlock)
4599
5235
        return self._run(b, revision_id_list, revision)
4600
5236
 
4601
5237
    def _run(self, b, revision_id_list, revision):
4602
5238
        import bzrlib.gpg as gpg
4603
 
        gpg_strategy = gpg.GPGStrategy(b.get_config())
 
5239
        gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4604
5240
        if revision_id_list is not None:
4605
5241
            b.repository.start_write_group()
4606
5242
            try:
4631
5267
                if to_revid is None:
4632
5268
                    to_revno = b.revno()
4633
5269
                if from_revno is None or to_revno is None:
4634
 
                    raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
 
5270
                    raise errors.BzrCommandError(gettext('Cannot sign a range of non-revision-history revisions'))
4635
5271
                b.repository.start_write_group()
4636
5272
                try:
4637
5273
                    for revno in range(from_revno, to_revno + 1):
4643
5279
                else:
4644
5280
                    b.repository.commit_write_group()
4645
5281
            else:
4646
 
                raise errors.BzrCommandError('Please supply either one revision, or a range.')
 
5282
                raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4647
5283
 
4648
5284
 
4649
5285
class cmd_bind(Command):
4668
5304
            try:
4669
5305
                location = b.get_old_bound_location()
4670
5306
            except errors.UpgradeRequired:
4671
 
                raise errors.BzrCommandError('No location supplied.  '
4672
 
                    'This format does not remember old locations.')
 
5307
                raise errors.BzrCommandError(gettext('No location supplied.  '
 
5308
                    'This format does not remember old locations.'))
4673
5309
            else:
4674
5310
                if location is None:
4675
5311
                    if b.get_bound_location() is not None:
4676
 
                        raise errors.BzrCommandError('Branch is already bound')
 
5312
                        raise errors.BzrCommandError(
 
5313
                            gettext('Branch is already bound'))
4677
5314
                    else:
4678
 
                        raise errors.BzrCommandError('No location supplied '
4679
 
                            'and no previous location known')
 
5315
                        raise errors.BzrCommandError(
 
5316
                            gettext('No location supplied'
 
5317
                                    ' and no previous location known'))
4680
5318
        b_other = Branch.open(location)
4681
5319
        try:
4682
5320
            b.bind(b_other)
4683
5321
        except errors.DivergedBranches:
4684
 
            raise errors.BzrCommandError('These branches have diverged.'
4685
 
                                         ' Try merging, and then bind again.')
 
5322
            raise errors.BzrCommandError(gettext('These branches have diverged.'
 
5323
                                         ' Try merging, and then bind again.'))
4686
5324
        if b.get_config().has_explicit_nickname():
4687
5325
            b.nick = b_other.nick
4688
5326
 
4701
5339
    def run(self, directory=u'.'):
4702
5340
        b, relpath = Branch.open_containing(directory)
4703
5341
        if not b.unbind():
4704
 
            raise errors.BzrCommandError('Local branch is not bound')
 
5342
            raise errors.BzrCommandError(gettext('Local branch is not bound'))
4705
5343
 
4706
5344
 
4707
5345
class cmd_uncommit(Command):
4728
5366
    takes_options = ['verbose', 'revision',
4729
5367
                    Option('dry-run', help='Don\'t actually make changes.'),
4730
5368
                    Option('force', help='Say yes to all questions.'),
 
5369
                    Option('keep-tags',
 
5370
                           help='Keep tags that point to removed revisions.'),
4731
5371
                    Option('local',
4732
5372
                           help="Only remove the commits from the local branch"
4733
5373
                                " when in a checkout."
4737
5377
    aliases = []
4738
5378
    encoding_type = 'replace'
4739
5379
 
4740
 
    def run(self, location=None,
4741
 
            dry_run=False, verbose=False,
4742
 
            revision=None, force=False, local=False):
 
5380
    def run(self, location=None, dry_run=False, verbose=False,
 
5381
            revision=None, force=False, local=False, keep_tags=False):
4743
5382
        if location is None:
4744
5383
            location = u'.'
4745
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
5384
        control, relpath = controldir.ControlDir.open_containing(location)
4746
5385
        try:
4747
5386
            tree = control.open_workingtree()
4748
5387
            b = tree.branch
4754
5393
            self.add_cleanup(tree.lock_write().unlock)
4755
5394
        else:
4756
5395
            self.add_cleanup(b.lock_write().unlock)
4757
 
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
 
5396
        return self._run(b, tree, dry_run, verbose, revision, force,
 
5397
                         local, keep_tags)
4758
5398
 
4759
 
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
 
5399
    def _run(self, b, tree, dry_run, verbose, revision, force, local,
 
5400
             keep_tags):
4760
5401
        from bzrlib.log import log_formatter, show_log
4761
5402
        from bzrlib.uncommit import uncommit
4762
5403
 
4777
5418
                rev_id = b.get_rev_id(revno)
4778
5419
 
4779
5420
        if rev_id is None or _mod_revision.is_null(rev_id):
4780
 
            self.outf.write('No revisions to uncommit.\n')
 
5421
            self.outf.write(gettext('No revisions to uncommit.\n'))
4781
5422
            return 1
4782
5423
 
4783
5424
        lf = log_formatter('short',
4792
5433
                 end_revision=last_revno)
4793
5434
 
4794
5435
        if dry_run:
4795
 
            self.outf.write('Dry-run, pretending to remove'
4796
 
                            ' the above revisions.\n')
 
5436
            self.outf.write(gettext('Dry-run, pretending to remove'
 
5437
                            ' the above revisions.\n'))
4797
5438
        else:
4798
 
            self.outf.write('The above revision(s) will be removed.\n')
 
5439
            self.outf.write(gettext('The above revision(s) will be removed.\n'))
4799
5440
 
4800
5441
        if not force:
4801
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4802
 
                self.outf.write('Canceled')
 
5442
            if not ui.ui_factory.confirm_action(
 
5443
                    gettext(u'Uncommit these revisions'),
 
5444
                    'bzrlib.builtins.uncommit',
 
5445
                    {}):
 
5446
                self.outf.write(gettext('Canceled\n'))
4803
5447
                return 0
4804
5448
 
4805
5449
        mutter('Uncommitting from {%s} to {%s}',
4806
5450
               last_rev_id, rev_id)
4807
5451
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4808
 
                 revno=revno, local=local)
4809
 
        self.outf.write('You can restore the old tip by running:\n'
4810
 
             '  bzr pull . -r revid:%s\n' % last_rev_id)
 
5452
                 revno=revno, local=local, keep_tags=keep_tags)
 
5453
        self.outf.write(gettext('You can restore the old tip by running:\n'
 
5454
             '  bzr pull . -r revid:%s\n') % last_rev_id)
4811
5455
 
4812
5456
 
4813
5457
class cmd_break_lock(Command):
4832
5476
    takes_options = [
4833
5477
        Option('config',
4834
5478
               help='LOCATION is the directory where the config lock is.'),
 
5479
        Option('force',
 
5480
            help='Do not ask for confirmation before breaking the lock.'),
4835
5481
        ]
4836
5482
 
4837
 
    def run(self, location=None, config=False):
 
5483
    def run(self, location=None, config=False, force=False):
4838
5484
        if location is None:
4839
5485
            location = u'.'
 
5486
        if force:
 
5487
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
5488
                None,
 
5489
                {'bzrlib.lockdir.break': True})
4840
5490
        if config:
4841
5491
            conf = _mod_config.LockableConfig(file_name=location)
4842
5492
            conf.break_lock()
4843
5493
        else:
4844
 
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
5494
            control, relpath = controldir.ControlDir.open_containing(location)
4845
5495
            try:
4846
5496
                control.break_lock()
4847
5497
            except NotImplementedError:
4874
5524
               help="Protocol to serve.",
4875
5525
               lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4876
5526
               value_switches=True),
 
5527
        Option('listen',
 
5528
               help='Listen for connections on nominated address.', type=str),
4877
5529
        Option('port',
4878
 
               help='Listen for connections on nominated port of the form '
4879
 
                    '[hostname:]portnumber.  Passing 0 as the port number will '
4880
 
                    'result in a dynamically allocated port.  The default port '
4881
 
                    'depends on the protocol.',
4882
 
               type=str),
 
5530
               help='Listen for connections on nominated port.  Passing 0 as '
 
5531
                    'the port number will result in a dynamically allocated '
 
5532
                    'port.  The default port depends on the protocol.',
 
5533
               type=int),
4883
5534
        custom_help('directory',
4884
5535
               help='Serve contents of this directory.'),
4885
5536
        Option('allow-writes',
4891
5542
                    'option leads to global uncontrolled write access to your '
4892
5543
                    'file system.'
4893
5544
                ),
 
5545
        Option('client-timeout', type=float,
 
5546
               help='Override the default idle client timeout (5min).'),
4894
5547
        ]
4895
5548
 
4896
 
    def get_host_and_port(self, port):
4897
 
        """Return the host and port to run the smart server on.
4898
 
 
4899
 
        If 'port' is None, None will be returned for the host and port.
4900
 
 
4901
 
        If 'port' has a colon in it, the string before the colon will be
4902
 
        interpreted as the host.
4903
 
 
4904
 
        :param port: A string of the port to run the server on.
4905
 
        :return: A tuple of (host, port), where 'host' is a host name or IP,
4906
 
            and port is an integer TCP/IP port.
4907
 
        """
4908
 
        host = None
4909
 
        if port is not None:
4910
 
            if ':' in port:
4911
 
                host, port = port.split(':')
4912
 
            port = int(port)
4913
 
        return host, port
4914
 
 
4915
 
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4916
 
            protocol=None):
 
5549
    def run(self, listen=None, port=None, inet=False, directory=None,
 
5550
            allow_writes=False, protocol=None, client_timeout=None):
4917
5551
        from bzrlib import transport
4918
5552
        if directory is None:
4919
5553
            directory = os.getcwd()
4920
5554
        if protocol is None:
4921
5555
            protocol = transport.transport_server_registry.get()
4922
 
        host, port = self.get_host_and_port(port)
4923
 
        url = urlutils.local_path_to_url(directory)
 
5556
        url = transport.location_to_url(directory)
4924
5557
        if not allow_writes:
4925
5558
            url = 'readonly+' + url
4926
 
        t = transport.get_transport(url)
4927
 
        protocol(t, host, port, inet)
 
5559
        t = transport.get_transport_from_url(url)
 
5560
        protocol(t, listen, port, inet, client_timeout)
4928
5561
 
4929
5562
 
4930
5563
class cmd_join(Command):
4936
5569
    not part of it.  (Such trees can be produced by "bzr split", but also by
4937
5570
    running "bzr branch" with the target inside a tree.)
4938
5571
 
4939
 
    The result is a combined tree, with the subtree no longer an independant
 
5572
    The result is a combined tree, with the subtree no longer an independent
4940
5573
    part.  This is marked as a merge of the subtree into the containing tree,
4941
5574
    and all history is preserved.
4942
5575
    """
4953
5586
        containing_tree = WorkingTree.open_containing(parent_dir)[0]
4954
5587
        repo = containing_tree.branch.repository
4955
5588
        if not repo.supports_rich_root():
4956
 
            raise errors.BzrCommandError(
 
5589
            raise errors.BzrCommandError(gettext(
4957
5590
                "Can't join trees because %s doesn't support rich root data.\n"
4958
 
                "You can use bzr upgrade on the repository."
 
5591
                "You can use bzr upgrade on the repository.")
4959
5592
                % (repo,))
4960
5593
        if reference:
4961
5594
            try:
4963
5596
            except errors.BadReferenceTarget, e:
4964
5597
                # XXX: Would be better to just raise a nicely printable
4965
5598
                # exception from the real origin.  Also below.  mbp 20070306
4966
 
                raise errors.BzrCommandError("Cannot join %s.  %s" %
4967
 
                                             (tree, e.reason))
 
5599
                raise errors.BzrCommandError(
 
5600
                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
4968
5601
        else:
4969
5602
            try:
4970
5603
                containing_tree.subsume(sub_tree)
4971
5604
            except errors.BadSubsumeSource, e:
4972
 
                raise errors.BzrCommandError("Cannot join %s.  %s" %
4973
 
                                             (tree, e.reason))
 
5605
                raise errors.BzrCommandError(
 
5606
                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
4974
5607
 
4975
5608
 
4976
5609
class cmd_split(Command):
5060
5693
        if submit_branch is None:
5061
5694
            submit_branch = branch.get_parent()
5062
5695
        if submit_branch is None:
5063
 
            raise errors.BzrCommandError('No submit branch specified or known')
 
5696
            raise errors.BzrCommandError(gettext('No submit branch specified or known'))
5064
5697
 
5065
5698
        stored_public_branch = branch.get_public_branch()
5066
5699
        if public_branch is None:
5067
5700
            public_branch = stored_public_branch
5068
5701
        elif stored_public_branch is None:
 
5702
            # FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5069
5703
            branch.set_public_branch(public_branch)
5070
5704
        if not include_bundle and public_branch is None:
5071
 
            raise errors.BzrCommandError('No public branch specified or'
5072
 
                                         ' known')
 
5705
            raise errors.BzrCommandError(gettext('No public branch specified or'
 
5706
                                         ' known'))
5073
5707
        base_revision_id = None
5074
5708
        if revision is not None:
5075
5709
            if len(revision) > 2:
5076
 
                raise errors.BzrCommandError('bzr merge-directive takes '
5077
 
                    'at most two one revision identifiers')
 
5710
                raise errors.BzrCommandError(gettext('bzr merge-directive takes '
 
5711
                    'at most two one revision identifiers'))
5078
5712
            revision_id = revision[-1].as_revision_id(branch)
5079
5713
            if len(revision) == 2:
5080
5714
                base_revision_id = revision[0].as_revision_id(branch)
5082
5716
            revision_id = branch.last_revision()
5083
5717
        revision_id = ensure_null(revision_id)
5084
5718
        if revision_id == NULL_REVISION:
5085
 
            raise errors.BzrCommandError('No revisions to bundle.')
 
5719
            raise errors.BzrCommandError(gettext('No revisions to bundle.'))
5086
5720
        directive = merge_directive.MergeDirective2.from_objects(
5087
5721
            branch.repository, revision_id, time.time(),
5088
5722
            osutils.local_time_offset(), submit_branch,
5096
5730
                self.outf.writelines(directive.to_lines())
5097
5731
        else:
5098
5732
            message = directive.to_email(mail_to, branch, sign)
5099
 
            s = SMTPConnection(branch.get_config())
 
5733
            s = SMTPConnection(branch.get_config_stack())
5100
5734
            s.send_email(message)
5101
5735
 
5102
5736
 
5132
5766
    source branch defaults to that containing the working directory, but can
5133
5767
    be changed using --from.
5134
5768
 
 
5769
    Both the submit branch and the public branch follow the usual behavior with
 
5770
    respect to --remember: If there is no default location set, the first send
 
5771
    will set it (use --no-remember to avoid setting it). After that, you can
 
5772
    omit the location to use the default.  To change the default, use
 
5773
    --remember. The value will only be saved if the location can be accessed.
 
5774
 
5135
5775
    In order to calculate those changes, bzr must analyse the submit branch.
5136
5776
    Therefore it is most efficient for the submit branch to be a local mirror.
5137
5777
    If a public location is known for the submit_branch, that location is used
5206
5846
        ]
5207
5847
 
5208
5848
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5209
 
            no_patch=False, revision=None, remember=False, output=None,
 
5849
            no_patch=False, revision=None, remember=None, output=None,
5210
5850
            format=None, mail_to=None, message=None, body=None,
5211
5851
            strict=None, **kwargs):
5212
5852
        from bzrlib.send import send
5336
5976
        self.add_cleanup(branch.lock_write().unlock)
5337
5977
        if delete:
5338
5978
            if tag_name is None:
5339
 
                raise errors.BzrCommandError("No tag specified to delete.")
 
5979
                raise errors.BzrCommandError(gettext("No tag specified to delete."))
5340
5980
            branch.tags.delete_tag(tag_name)
5341
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5981
            note(gettext('Deleted tag %s.') % tag_name)
5342
5982
        else:
5343
5983
            if revision:
5344
5984
                if len(revision) != 1:
5345
 
                    raise errors.BzrCommandError(
 
5985
                    raise errors.BzrCommandError(gettext(
5346
5986
                        "Tags can only be placed on a single revision, "
5347
 
                        "not on a range")
 
5987
                        "not on a range"))
5348
5988
                revision_id = revision[0].as_revision_id(branch)
5349
5989
            else:
5350
5990
                revision_id = branch.last_revision()
5351
5991
            if tag_name is None:
5352
5992
                tag_name = branch.automatic_tag_name(revision_id)
5353
5993
                if tag_name is None:
5354
 
                    raise errors.BzrCommandError(
5355
 
                        "Please specify a tag name.")
5356
 
            if (not force) and branch.tags.has_tag(tag_name):
 
5994
                    raise errors.BzrCommandError(gettext(
 
5995
                        "Please specify a tag name."))
 
5996
            try:
 
5997
                existing_target = branch.tags.lookup_tag(tag_name)
 
5998
            except errors.NoSuchTag:
 
5999
                existing_target = None
 
6000
            if not force and existing_target not in (None, revision_id):
5357
6001
                raise errors.TagAlreadyExists(tag_name)
5358
 
            branch.tags.set_tag(tag_name, revision_id)
5359
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
6002
            if existing_target == revision_id:
 
6003
                note(gettext('Tag %s already exists for that revision.') % tag_name)
 
6004
            else:
 
6005
                branch.tags.set_tag(tag_name, revision_id)
 
6006
                if existing_target is None:
 
6007
                    note(gettext('Created tag %s.') % tag_name)
 
6008
                else:
 
6009
                    note(gettext('Updated tag %s.') % tag_name)
5360
6010
 
5361
6011
 
5362
6012
class cmd_tags(Command):
5369
6019
    takes_options = [
5370
6020
        custom_help('directory',
5371
6021
            help='Branch whose tags should be displayed.'),
5372
 
        RegistryOption.from_kwargs('sort',
 
6022
        RegistryOption('sort',
5373
6023
            'Sort tags by different criteria.', title='Sorting',
5374
 
            alpha='Sort tags lexicographically (default).',
5375
 
            time='Sort tags chronologically.',
 
6024
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5376
6025
            ),
5377
6026
        'show-ids',
5378
6027
        'revision',
5379
6028
    ]
5380
6029
 
5381
6030
    @display_command
5382
 
    def run(self,
5383
 
            directory='.',
5384
 
            sort='alpha',
5385
 
            show_ids=False,
5386
 
            revision=None,
5387
 
            ):
 
6031
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
6032
        from bzrlib.tag import tag_sort_methods
5388
6033
        branch, relpath = Branch.open_containing(directory)
5389
6034
 
5390
6035
        tags = branch.tags.get_tag_dict().items()
5393
6038
 
5394
6039
        self.add_cleanup(branch.lock_read().unlock)
5395
6040
        if revision:
5396
 
            graph = branch.repository.get_graph()
5397
 
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5398
 
            revid1, revid2 = rev1.rev_id, rev2.rev_id
5399
 
            # only show revisions between revid1 and revid2 (inclusive)
5400
 
            tags = [(tag, revid) for tag, revid in tags if
5401
 
                graph.is_between(revid, revid1, revid2)]
5402
 
        if sort == 'alpha':
5403
 
            tags.sort()
5404
 
        elif sort == 'time':
5405
 
            timestamps = {}
5406
 
            for tag, revid in tags:
5407
 
                try:
5408
 
                    revobj = branch.repository.get_revision(revid)
5409
 
                except errors.NoSuchRevision:
5410
 
                    timestamp = sys.maxint # place them at the end
5411
 
                else:
5412
 
                    timestamp = revobj.timestamp
5413
 
                timestamps[revid] = timestamp
5414
 
            tags.sort(key=lambda x: timestamps[x[1]])
 
6041
            # Restrict to the specified range
 
6042
            tags = self._tags_for_range(branch, revision)
 
6043
        if sort is None:
 
6044
            sort = tag_sort_methods.get()
 
6045
        sort(branch, tags)
5415
6046
        if not show_ids:
5416
6047
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5417
6048
            for index, (tag, revid) in enumerate(tags):
5419
6050
                    revno = branch.revision_id_to_dotted_revno(revid)
5420
6051
                    if isinstance(revno, tuple):
5421
6052
                        revno = '.'.join(map(str, revno))
5422
 
                except errors.NoSuchRevision:
 
6053
                except (errors.NoSuchRevision,
 
6054
                        errors.GhostRevisionsHaveNoRevno,
 
6055
                        errors.UnsupportedOperation):
5423
6056
                    # Bad tag data/merges can lead to tagged revisions
5424
6057
                    # which are not in this branch. Fail gracefully ...
5425
6058
                    revno = '?'
5428
6061
        for tag, revspec in tags:
5429
6062
            self.outf.write('%-20s %s\n' % (tag, revspec))
5430
6063
 
 
6064
    def _tags_for_range(self, branch, revision):
 
6065
        range_valid = True
 
6066
        rev1, rev2 = _get_revision_range(revision, branch, self.name())
 
6067
        revid1, revid2 = rev1.rev_id, rev2.rev_id
 
6068
        # _get_revision_range will always set revid2 if it's not specified.
 
6069
        # If revid1 is None, it means we want to start from the branch
 
6070
        # origin which is always a valid ancestor. If revid1 == revid2, the
 
6071
        # ancestry check is useless.
 
6072
        if revid1 and revid1 != revid2:
 
6073
            # FIXME: We really want to use the same graph than
 
6074
            # branch.iter_merge_sorted_revisions below, but this is not
 
6075
            # easily available -- vila 2011-09-23
 
6076
            if branch.repository.get_graph().is_ancestor(revid2, revid1):
 
6077
                # We don't want to output anything in this case...
 
6078
                return []
 
6079
        # only show revisions between revid1 and revid2 (inclusive)
 
6080
        tagged_revids = branch.tags.get_reverse_tag_dict()
 
6081
        found = []
 
6082
        for r in branch.iter_merge_sorted_revisions(
 
6083
            start_revision_id=revid2, stop_revision_id=revid1,
 
6084
            stop_rule='include'):
 
6085
            revid_tags = tagged_revids.get(r[0], None)
 
6086
            if revid_tags:
 
6087
                found.extend([(tag, r[0]) for tag in revid_tags])
 
6088
        return found
 
6089
 
5431
6090
 
5432
6091
class cmd_reconfigure(Command):
5433
6092
    __doc__ = """Reconfigure the type of a bzr directory.
5447
6106
    takes_args = ['location?']
5448
6107
    takes_options = [
5449
6108
        RegistryOption.from_kwargs(
5450
 
            'target_type',
5451
 
            title='Target type',
5452
 
            help='The type to reconfigure the directory to.',
 
6109
            'tree_type',
 
6110
            title='Tree type',
 
6111
            help='The relation between branch and tree.',
5453
6112
            value_switches=True, enum_switch=False,
5454
6113
            branch='Reconfigure to be an unbound branch with no working tree.',
5455
6114
            tree='Reconfigure to be an unbound branch with a working tree.',
5456
6115
            checkout='Reconfigure to be a bound branch with a working tree.',
5457
6116
            lightweight_checkout='Reconfigure to be a lightweight'
5458
6117
                ' checkout (with no local history).',
 
6118
            ),
 
6119
        RegistryOption.from_kwargs(
 
6120
            'repository_type',
 
6121
            title='Repository type',
 
6122
            help='Location fo the repository.',
 
6123
            value_switches=True, enum_switch=False,
5459
6124
            standalone='Reconfigure to be a standalone branch '
5460
6125
                '(i.e. stop using shared repository).',
5461
6126
            use_shared='Reconfigure to use a shared repository.',
 
6127
            ),
 
6128
        RegistryOption.from_kwargs(
 
6129
            'repository_trees',
 
6130
            title='Trees in Repository',
 
6131
            help='Whether new branches in the repository have trees.',
 
6132
            value_switches=True, enum_switch=False,
5462
6133
            with_trees='Reconfigure repository to create '
5463
6134
                'working trees on branches by default.',
5464
6135
            with_no_trees='Reconfigure repository to not create '
5478
6149
            ),
5479
6150
        ]
5480
6151
 
5481
 
    def run(self, location=None, target_type=None, bind_to=None, force=False,
5482
 
            stacked_on=None,
5483
 
            unstacked=None):
5484
 
        directory = bzrdir.BzrDir.open(location)
 
6152
    def run(self, location=None, bind_to=None, force=False,
 
6153
            tree_type=None, repository_type=None, repository_trees=None,
 
6154
            stacked_on=None, unstacked=None):
 
6155
        directory = controldir.ControlDir.open(location)
5485
6156
        if stacked_on and unstacked:
5486
 
            raise BzrCommandError("Can't use both --stacked-on and --unstacked")
 
6157
            raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5487
6158
        elif stacked_on is not None:
5488
6159
            reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5489
6160
        elif unstacked:
5491
6162
        # At the moment you can use --stacked-on and a different
5492
6163
        # reconfiguration shape at the same time; there seems no good reason
5493
6164
        # to ban it.
5494
 
        if target_type is None:
 
6165
        if (tree_type is None and
 
6166
            repository_type is None and
 
6167
            repository_trees is None):
5495
6168
            if stacked_on or unstacked:
5496
6169
                return
5497
6170
            else:
5498
 
                raise errors.BzrCommandError('No target configuration '
5499
 
                    'specified')
5500
 
        elif target_type == 'branch':
 
6171
                raise errors.BzrCommandError(gettext('No target configuration '
 
6172
                    'specified'))
 
6173
        reconfiguration = None
 
6174
        if tree_type == 'branch':
5501
6175
            reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5502
 
        elif target_type == 'tree':
 
6176
        elif tree_type == 'tree':
5503
6177
            reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5504
 
        elif target_type == 'checkout':
 
6178
        elif tree_type == 'checkout':
5505
6179
            reconfiguration = reconfigure.Reconfigure.to_checkout(
5506
6180
                directory, bind_to)
5507
 
        elif target_type == 'lightweight-checkout':
 
6181
        elif tree_type == 'lightweight-checkout':
5508
6182
            reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5509
6183
                directory, bind_to)
5510
 
        elif target_type == 'use-shared':
 
6184
        if reconfiguration:
 
6185
            reconfiguration.apply(force)
 
6186
            reconfiguration = None
 
6187
        if repository_type == 'use-shared':
5511
6188
            reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5512
 
        elif target_type == 'standalone':
 
6189
        elif repository_type == 'standalone':
5513
6190
            reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5514
 
        elif target_type == 'with-trees':
 
6191
        if reconfiguration:
 
6192
            reconfiguration.apply(force)
 
6193
            reconfiguration = None
 
6194
        if repository_trees == 'with-trees':
5515
6195
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5516
6196
                directory, True)
5517
 
        elif target_type == 'with-no-trees':
 
6197
        elif repository_trees == 'with-no-trees':
5518
6198
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5519
6199
                directory, False)
5520
 
        reconfiguration.apply(force)
 
6200
        if reconfiguration:
 
6201
            reconfiguration.apply(force)
 
6202
            reconfiguration = None
5521
6203
 
5522
6204
 
5523
6205
class cmd_switch(Command):
5558
6240
        from bzrlib import switch
5559
6241
        tree_location = directory
5560
6242
        revision = _get_one_revision('switch', revision)
5561
 
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
 
6243
        possible_transports = []
 
6244
        control_dir = controldir.ControlDir.open_containing(tree_location,
 
6245
            possible_transports=possible_transports)[0]
5562
6246
        if to_location is None:
5563
6247
            if revision is None:
5564
 
                raise errors.BzrCommandError('You must supply either a'
5565
 
                                             ' revision or a location')
 
6248
                raise errors.BzrCommandError(gettext('You must supply either a'
 
6249
                                             ' revision or a location'))
5566
6250
            to_location = tree_location
5567
6251
        try:
5568
 
            branch = control_dir.open_branch()
 
6252
            branch = control_dir.open_branch(
 
6253
                possible_transports=possible_transports)
5569
6254
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5570
6255
        except errors.NotBranchError:
5571
6256
            branch = None
5572
6257
            had_explicit_nick = False
5573
6258
        if create_branch:
5574
6259
            if branch is None:
5575
 
                raise errors.BzrCommandError('cannot create branch without'
5576
 
                                             ' source branch')
5577
 
            to_location = directory_service.directories.dereference(
5578
 
                              to_location)
5579
 
            if '/' not in to_location and '\\' not in to_location:
5580
 
                # This path is meant to be relative to the existing branch
5581
 
                this_url = self._get_branch_location(control_dir)
5582
 
                to_location = urlutils.join(this_url, '..', to_location)
 
6260
                raise errors.BzrCommandError(
 
6261
                    gettext('cannot create branch without source branch'))
 
6262
            to_location = lookup_new_sibling_branch(control_dir, to_location,
 
6263
                 possible_transports=possible_transports)
5583
6264
            to_branch = branch.bzrdir.sprout(to_location,
5584
 
                                 possible_transports=[branch.bzrdir.root_transport],
5585
 
                                 source_branch=branch).open_branch()
 
6265
                 possible_transports=possible_transports,
 
6266
                 source_branch=branch).open_branch()
5586
6267
        else:
5587
6268
            try:
5588
 
                to_branch = Branch.open(to_location)
 
6269
                to_branch = Branch.open(to_location,
 
6270
                    possible_transports=possible_transports)
5589
6271
            except errors.NotBranchError:
5590
 
                this_url = self._get_branch_location(control_dir)
5591
 
                to_branch = Branch.open(
5592
 
                    urlutils.join(this_url, '..', to_location))
 
6272
                to_branch = open_sibling_branch(control_dir, to_location,
 
6273
                    possible_transports=possible_transports)
5593
6274
        if revision is not None:
5594
6275
            revision = revision.as_revision_id(to_branch)
5595
6276
        switch.switch(control_dir, to_branch, force, revision_id=revision)
5596
6277
        if had_explicit_nick:
5597
6278
            branch = control_dir.open_branch() #get the new branch!
5598
6279
            branch.nick = to_branch.nick
5599
 
        note('Switched to branch: %s',
 
6280
        note(gettext('Switched to branch: %s'),
5600
6281
            urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5601
6282
 
5602
 
    def _get_branch_location(self, control_dir):
5603
 
        """Return location of branch for this control dir."""
5604
 
        try:
5605
 
            this_branch = control_dir.open_branch()
5606
 
            # This may be a heavy checkout, where we want the master branch
5607
 
            master_location = this_branch.get_bound_location()
5608
 
            if master_location is not None:
5609
 
                return master_location
5610
 
            # If not, use a local sibling
5611
 
            return this_branch.base
5612
 
        except errors.NotBranchError:
5613
 
            format = control_dir.find_branch_format()
5614
 
            if getattr(format, 'get_reference', None) is not None:
5615
 
                return format.get_reference(control_dir)
5616
 
            else:
5617
 
                return control_dir.root_transport.base
5618
6283
 
5619
6284
 
5620
6285
class cmd_view(Command):
5711
6376
            name = current_view
5712
6377
        if delete:
5713
6378
            if file_list:
5714
 
                raise errors.BzrCommandError(
5715
 
                    "Both --delete and a file list specified")
 
6379
                raise errors.BzrCommandError(gettext(
 
6380
                    "Both --delete and a file list specified"))
5716
6381
            elif switch:
5717
 
                raise errors.BzrCommandError(
5718
 
                    "Both --delete and --switch specified")
 
6382
                raise errors.BzrCommandError(gettext(
 
6383
                    "Both --delete and --switch specified"))
5719
6384
            elif all:
5720
6385
                tree.views.set_view_info(None, {})
5721
 
                self.outf.write("Deleted all views.\n")
 
6386
                self.outf.write(gettext("Deleted all views.\n"))
5722
6387
            elif name is None:
5723
 
                raise errors.BzrCommandError("No current view to delete")
 
6388
                raise errors.BzrCommandError(gettext("No current view to delete"))
5724
6389
            else:
5725
6390
                tree.views.delete_view(name)
5726
 
                self.outf.write("Deleted '%s' view.\n" % name)
 
6391
                self.outf.write(gettext("Deleted '%s' view.\n") % name)
5727
6392
        elif switch:
5728
6393
            if file_list:
5729
 
                raise errors.BzrCommandError(
5730
 
                    "Both --switch and a file list specified")
 
6394
                raise errors.BzrCommandError(gettext(
 
6395
                    "Both --switch and a file list specified"))
5731
6396
            elif all:
5732
 
                raise errors.BzrCommandError(
5733
 
                    "Both --switch and --all specified")
 
6397
                raise errors.BzrCommandError(gettext(
 
6398
                    "Both --switch and --all specified"))
5734
6399
            elif switch == 'off':
5735
6400
                if current_view is None:
5736
 
                    raise errors.BzrCommandError("No current view to disable")
 
6401
                    raise errors.BzrCommandError(gettext("No current view to disable"))
5737
6402
                tree.views.set_view_info(None, view_dict)
5738
 
                self.outf.write("Disabled '%s' view.\n" % (current_view))
 
6403
                self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5739
6404
            else:
5740
6405
                tree.views.set_view_info(switch, view_dict)
5741
6406
                view_str = views.view_display_str(tree.views.lookup_view())
5742
 
                self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
 
6407
                self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
5743
6408
        elif all:
5744
6409
            if view_dict:
5745
 
                self.outf.write('Views defined:\n')
 
6410
                self.outf.write(gettext('Views defined:\n'))
5746
6411
                for view in sorted(view_dict):
5747
6412
                    if view == current_view:
5748
6413
                        active = "=>"
5751
6416
                    view_str = views.view_display_str(view_dict[view])
5752
6417
                    self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5753
6418
            else:
5754
 
                self.outf.write('No views defined.\n')
 
6419
                self.outf.write(gettext('No views defined.\n'))
5755
6420
        elif file_list:
5756
6421
            if name is None:
5757
6422
                # No name given and no current view set
5758
6423
                name = 'my'
5759
6424
            elif name == 'off':
5760
 
                raise errors.BzrCommandError(
5761
 
                    "Cannot change the 'off' pseudo view")
 
6425
                raise errors.BzrCommandError(gettext(
 
6426
                    "Cannot change the 'off' pseudo view"))
5762
6427
            tree.views.set_view(name, sorted(file_list))
5763
6428
            view_str = views.view_display_str(tree.views.lookup_view())
5764
 
            self.outf.write("Using '%s' view: %s\n" % (name, view_str))
 
6429
            self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
5765
6430
        else:
5766
6431
            # list the files
5767
6432
            if name is None:
5768
6433
                # No name given and no current view set
5769
 
                self.outf.write('No current view.\n')
 
6434
                self.outf.write(gettext('No current view.\n'))
5770
6435
            else:
5771
6436
                view_str = views.view_display_str(tree.views.lookup_view(name))
5772
 
                self.outf.write("'%s' view is: %s\n" % (name, view_str))
 
6437
                self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
5773
6438
 
5774
6439
 
5775
6440
class cmd_hooks(Command):
5789
6454
                        self.outf.write("    %s\n" %
5790
6455
                                        (some_hooks.get_hook_name(hook),))
5791
6456
                else:
5792
 
                    self.outf.write("    <no hooks installed>\n")
 
6457
                    self.outf.write(gettext("    <no hooks installed>\n"))
5793
6458
 
5794
6459
 
5795
6460
class cmd_remove_branch(Command):
5808
6473
 
5809
6474
    takes_args = ["location?"]
5810
6475
 
 
6476
    takes_options = ['directory',
 
6477
        Option('force', help='Remove branch even if it is the active branch.')]
 
6478
 
5811
6479
    aliases = ["rmbranch"]
5812
6480
 
5813
 
    def run(self, location=None):
5814
 
        if location is None:
5815
 
            location = "."
5816
 
        branch = Branch.open_containing(location)[0]
5817
 
        branch.bzrdir.destroy_branch()
5818
 
        
 
6481
    def run(self, directory=None, location=None, force=False):
 
6482
        br = open_nearby_branch(near=directory, location=location)
 
6483
        if not force and br.bzrdir.has_workingtree():
 
6484
            try:
 
6485
                active_branch = br.bzrdir.open_branch(name="")
 
6486
            except errors.NotBranchError:
 
6487
                active_branch = None
 
6488
            if (active_branch is not None and
 
6489
                br.control_url == active_branch.control_url):
 
6490
                raise errors.BzrCommandError(
 
6491
                    gettext("Branch is active. Use --force to remove it."))
 
6492
        br.bzrdir.destroy_branch(br.name)
 
6493
 
5819
6494
 
5820
6495
class cmd_shelve(Command):
5821
6496
    __doc__ = """Temporarily set aside some changes from the current tree.
5840
6515
 
5841
6516
    You can put multiple items on the shelf, and by default, 'unshelve' will
5842
6517
    restore the most recently shelved changes.
 
6518
 
 
6519
    For complicated changes, it is possible to edit the changes in a separate
 
6520
    editor program to decide what the file remaining in the working copy
 
6521
    should look like.  To do this, add the configuration option
 
6522
 
 
6523
        change_editor = PROGRAM @new_path @old_path
 
6524
 
 
6525
    where @new_path is replaced with the path of the new version of the 
 
6526
    file and @old_path is replaced with the path of the old version of 
 
6527
    the file.  The PROGRAM should save the new file with the desired 
 
6528
    contents of the file in the working tree.
 
6529
        
5843
6530
    """
5844
6531
 
5845
6532
    takes_args = ['file*']
5857
6544
        Option('destroy',
5858
6545
               help='Destroy removed changes instead of shelving them.'),
5859
6546
    ]
5860
 
    _see_also = ['unshelve']
 
6547
    _see_also = ['unshelve', 'configuration']
5861
6548
 
5862
6549
    def run(self, revision=None, all=False, file_list=None, message=None,
5863
 
            writer=None, list=False, destroy=False, directory=u'.'):
 
6550
            writer=None, list=False, destroy=False, directory=None):
5864
6551
        if list:
5865
 
            return self.run_for_list()
 
6552
            return self.run_for_list(directory=directory)
5866
6553
        from bzrlib.shelf_ui import Shelver
5867
6554
        if writer is None:
5868
6555
            writer = bzrlib.option.diff_writer_registry.get()
5876
6563
        except errors.UserAbort:
5877
6564
            return 0
5878
6565
 
5879
 
    def run_for_list(self):
5880
 
        tree = WorkingTree.open_containing('.')[0]
 
6566
    def run_for_list(self, directory=None):
 
6567
        if directory is None:
 
6568
            directory = u'.'
 
6569
        tree = WorkingTree.open_containing(directory)[0]
5881
6570
        self.add_cleanup(tree.lock_read().unlock)
5882
6571
        manager = tree.get_shelf_manager()
5883
6572
        shelves = manager.active_shelves()
5884
6573
        if len(shelves) == 0:
5885
 
            note('No shelved changes.')
 
6574
            note(gettext('No shelved changes.'))
5886
6575
            return 0
5887
6576
        for shelf_id in reversed(shelves):
5888
6577
            message = manager.get_metadata(shelf_id).get('message')
5942
6631
    """
5943
6632
    takes_options = ['directory',
5944
6633
                     Option('ignored', help='Delete all ignored files.'),
5945
 
                     Option('detritus', help='Delete conflict files, merge'
 
6634
                     Option('detritus', help='Delete conflict files, merge and revert'
5946
6635
                            ' backups, and failed selftest dirs.'),
5947
6636
                     Option('unknown',
5948
6637
                            help='Delete files unknown to bzr (default).'),
5977
6666
        if path is not None:
5978
6667
            branchdir = path
5979
6668
        tree, branch, relpath =(
5980
 
            bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
 
6669
            controldir.ControlDir.open_containing_tree_or_branch(branchdir))
5981
6670
        if path is not None:
5982
6671
            path = relpath
5983
6672
        if tree is None:
6007
6696
            self.outf.write('%s %s\n' % (path, location))
6008
6697
 
6009
6698
 
 
6699
class cmd_export_pot(Command):
 
6700
    __doc__ = """Export command helps and error messages in po format."""
 
6701
 
 
6702
    hidden = True
 
6703
    takes_options = [Option('plugin', 
 
6704
                            help='Export help text from named command '\
 
6705
                                 '(defaults to all built in commands).',
 
6706
                            type=str),
 
6707
                     Option('include-duplicates',
 
6708
                            help='Output multiple copies of the same msgid '
 
6709
                                 'string if it appears more than once.'),
 
6710
                            ]
 
6711
 
 
6712
    def run(self, plugin=None, include_duplicates=False):
 
6713
        from bzrlib.export_pot import export_pot
 
6714
        export_pot(self.outf, plugin, include_duplicates)
 
6715
 
 
6716
 
6010
6717
def _register_lazy_builtins():
6011
6718
    # register lazy builtins from other modules; called at startup and should
6012
6719
    # be only called once.
6013
6720
    for (name, aliases, module_name) in [
6014
6721
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6722
        ('cmd_config', [], 'bzrlib.config'),
6015
6723
        ('cmd_dpush', [], 'bzrlib.foreign'),
6016
6724
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6017
6725
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6018
6726
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6019
 
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6727
        ('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
 
6728
        ('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
 
6729
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6020
6730
        ]:
6021
6731
        builtin_command_registry.register_lazy(name, aliases, module_name)