/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/builtins.py

  • Committer: Jelmer Vernooij
  • Date: 2020-09-02 16:35:18 UTC
  • mto: (7490.40.109 work)
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20200902163518-sy9f4unbboljphgu
Handle duplicate directories entries for git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/builtins.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""builtin bzr commands"""
18
 
 
 
17
"""builtin brz commands"""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
import errno
19
22
import os
20
 
 
21
 
from bzrlib.lazy_import import lazy_import
22
 
lazy_import(globals(), """
23
 
import codecs
24
 
import cStringIO
25
23
import sys
 
24
 
 
25
import breezy.bzr
 
26
import breezy.git
 
27
 
 
28
from . import (
 
29
    errors,
 
30
    )
 
31
 
 
32
from . import lazy_import
 
33
lazy_import.lazy_import(globals(), """
26
34
import time
27
35
 
28
 
import bzrlib
29
 
from bzrlib import (
 
36
import breezy
 
37
from breezy import (
 
38
    branch as _mod_branch,
30
39
    bugtracker,
31
 
    bundle,
32
 
    btree_index,
33
 
    bzrdir,
 
40
    cache_utf8,
 
41
    controldir,
34
42
    directory_service,
35
43
    delta,
36
 
    config,
37
 
    errors,
 
44
    config as _mod_config,
38
45
    globbing,
 
46
    gpg,
39
47
    hooks,
 
48
    lazy_regex,
40
49
    log,
41
50
    merge as _mod_merge,
 
51
    mergeable as _mod_mergeable,
42
52
    merge_directive,
43
53
    osutils,
44
54
    reconfigure,
45
55
    rename_map,
46
56
    revision as _mod_revision,
47
 
    static_tuple,
48
57
    symbol_versioning,
49
58
    timestamp,
50
59
    transport,
 
60
    tree as _mod_tree,
51
61
    ui,
52
62
    urlutils,
53
63
    views,
54
64
    )
55
 
from bzrlib.branch import Branch
56
 
from bzrlib.conflicts import ConflictList
57
 
from bzrlib.transport import memory
58
 
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
59
 
from bzrlib.smtp_connection import SMTPConnection
60
 
from bzrlib.workingtree import WorkingTree
 
65
from breezy.branch import Branch
 
66
from breezy.transport import memory
 
67
from breezy.smtp_connection import SMTPConnection
 
68
from breezy.workingtree import WorkingTree
 
69
from breezy.i18n import gettext, ngettext
61
70
""")
62
71
 
63
 
from bzrlib.commands import (
 
72
from .commands import (
64
73
    Command,
65
74
    builtin_command_registry,
66
75
    display_command,
67
76
    )
68
 
from bzrlib.option import (
 
77
from .option import (
69
78
    ListOption,
70
79
    Option,
71
80
    RegistryOption,
72
81
    custom_help,
73
82
    _parse_revision_str,
74
83
    )
75
 
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
76
 
 
77
 
 
78
 
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
 
    apply_view=True):
80
 
    try:
81
 
        return internal_tree_files(file_list, default_branch, canonicalize,
82
 
            apply_view)
83
 
    except errors.FileInWrongBranch, e:
84
 
        raise errors.BzrCommandError("%s is not in the same branch as %s" %
85
 
                                     (e.path, file_list[0]))
 
84
from .revisionspec import (
 
85
    RevisionSpec,
 
86
    RevisionInfo,
 
87
    )
 
88
from .sixish import (
 
89
    PY3,
 
90
    text_type,
 
91
    viewitems,
 
92
    viewvalues,
 
93
)
 
94
from .trace import mutter, note, warning, is_quiet, get_verbosity_level
 
95
 
 
96
 
 
97
def _get_branch_location(control_dir, possible_transports=None):
 
98
    """Return location of branch for this control dir."""
 
99
    try:
 
100
        target = control_dir.get_branch_reference()
 
101
    except errors.NotBranchError:
 
102
        return control_dir.root_transport.base
 
103
    if target is not None:
 
104
        return target
 
105
    this_branch = control_dir.open_branch(
 
106
        possible_transports=possible_transports)
 
107
    # This may be a heavy checkout, where we want the master branch
 
108
    master_location = this_branch.get_bound_location()
 
109
    if master_location is not None:
 
110
        return master_location
 
111
    # If not, use a local sibling
 
112
    return this_branch.base
 
113
 
 
114
 
 
115
def _is_colocated(control_dir, possible_transports=None):
 
116
    """Check if the branch in control_dir is colocated.
 
117
 
 
118
    :param control_dir: Control directory
 
119
    :return: Tuple with boolean indicating whether the branch is colocated
 
120
        and the full URL to the actual branch
 
121
    """
 
122
    # This path is meant to be relative to the existing branch
 
123
    this_url = _get_branch_location(
 
124
        control_dir, possible_transports=possible_transports)
 
125
    # Perhaps the target control dir supports colocated branches?
 
126
    try:
 
127
        root = controldir.ControlDir.open(
 
128
            this_url, possible_transports=possible_transports)
 
129
    except errors.NotBranchError:
 
130
        return (False, this_url)
 
131
    else:
 
132
        try:
 
133
            control_dir.open_workingtree()
 
134
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
135
            return (False, this_url)
 
136
        else:
 
137
            return (
 
138
                root._format.colocated_branches and
 
139
                control_dir.control_url == root.control_url,
 
140
                this_url)
 
141
 
 
142
 
 
143
def lookup_new_sibling_branch(control_dir, location, possible_transports=None):
 
144
    """Lookup the location for a new sibling branch.
 
145
 
 
146
    :param control_dir: Control directory to find sibling branches from
 
147
    :param location: Name of the new branch
 
148
    :return: Full location to the new branch
 
149
    """
 
150
    location = directory_service.directories.dereference(location)
 
151
    if '/' not in location and '\\' not in location:
 
152
        (colocated, this_url) = _is_colocated(control_dir, possible_transports)
 
153
 
 
154
        if colocated:
 
155
            return urlutils.join_segment_parameters(
 
156
                this_url, {"branch": urlutils.escape(location)})
 
157
        else:
 
158
            return urlutils.join(this_url, '..', urlutils.escape(location))
 
159
    return location
 
160
 
 
161
 
 
162
def open_sibling_branch(control_dir, location, possible_transports=None):
 
163
    """Open a branch, possibly a sibling of another.
 
164
 
 
165
    :param control_dir: Control directory relative to which to lookup the
 
166
        location.
 
167
    :param location: Location to look up
 
168
    :return: branch to open
 
169
    """
 
170
    try:
 
171
        # Perhaps it's a colocated branch?
 
172
        return control_dir.open_branch(
 
173
            location, possible_transports=possible_transports)
 
174
    except (errors.NotBranchError, errors.NoColocatedBranchSupport):
 
175
        this_url = _get_branch_location(control_dir)
 
176
        return Branch.open(
 
177
            urlutils.join(
 
178
                this_url, '..', urlutils.escape(location)))
 
179
 
 
180
 
 
181
def open_nearby_branch(near=None, location=None, possible_transports=None):
 
182
    """Open a nearby branch.
 
183
 
 
184
    :param near: Optional location of container from which to open branch
 
185
    :param location: Location of the branch
 
186
    :return: Branch instance
 
187
    """
 
188
    if near is None:
 
189
        if location is None:
 
190
            location = "."
 
191
        try:
 
192
            return Branch.open(
 
193
                location, possible_transports=possible_transports)
 
194
        except errors.NotBranchError:
 
195
            near = "."
 
196
    cdir = controldir.ControlDir.open(
 
197
        near, possible_transports=possible_transports)
 
198
    return open_sibling_branch(
 
199
        cdir, location, possible_transports=possible_transports)
 
200
 
 
201
 
 
202
def iter_sibling_branches(control_dir, possible_transports=None):
 
203
    """Iterate over the siblings of a branch.
 
204
 
 
205
    :param control_dir: Control directory for which to look up the siblings
 
206
    :return: Iterator over tuples with branch name and branch object
 
207
    """
 
208
    try:
 
209
        reference = control_dir.get_branch_reference()
 
210
    except errors.NotBranchError:
 
211
        reference = None
 
212
    if reference is not None:
 
213
        try:
 
214
            ref_branch = Branch.open(
 
215
                reference, possible_transports=possible_transports)
 
216
        except errors.NotBranchError:
 
217
            ref_branch = None
 
218
    else:
 
219
        ref_branch = None
 
220
    if ref_branch is None or ref_branch.name:
 
221
        if ref_branch is not None:
 
222
            control_dir = ref_branch.controldir
 
223
        for name, branch in viewitems(control_dir.get_branches()):
 
224
            yield name, branch
 
225
    else:
 
226
        repo = ref_branch.controldir.find_repository()
 
227
        for branch in repo.find_branches(using=True):
 
228
            name = urlutils.relative_url(
 
229
                repo.user_url, branch.user_url).rstrip("/")
 
230
            yield name, branch
86
231
 
87
232
 
88
233
def tree_files_for_add(file_list):
103
248
            if view_files:
104
249
                for filename in file_list:
105
250
                    if not osutils.is_inside_any(view_files, filename):
106
 
                        raise errors.FileOutsideView(filename, view_files)
 
251
                        raise views.FileOutsideView(filename, view_files)
107
252
        file_list = file_list[:]
108
253
        file_list[0] = tree.abspath(relpath)
109
254
    else:
113
258
            if view_files:
114
259
                file_list = view_files
115
260
                view_str = views.view_display_str(view_files)
116
 
                note("Ignoring files outside view. View is %s" % view_str)
 
261
                note(gettext("Ignoring files outside view. View is %s"),
 
262
                     view_str)
117
263
    return tree, file_list
118
264
 
119
265
 
121
267
    if revisions is None:
122
268
        return None
123
269
    if len(revisions) != 1:
124
 
        raise errors.BzrCommandError(
125
 
            'bzr %s --revision takes exactly one revision identifier' % (
 
270
        raise errors.CommandError(gettext(
 
271
            'brz %s --revision takes exactly one revision identifier') % (
126
272
                command_name,))
127
273
    return revisions[0]
128
274
 
129
275
 
130
276
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
131
277
    """Get a revision tree. Not suitable for commands that change the tree.
132
 
    
 
278
 
133
279
    Specifically, the basis tree in dirstate trees is coupled to the dirstate
134
280
    and doing a commit/uncommit/pull will at best fail due to changing the
135
281
    basis revision data.
150
296
    return rev_tree
151
297
 
152
298
 
153
 
# XXX: Bad function name; should possibly also be a class method of
154
 
# WorkingTree rather than a function.
155
 
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
 
    apply_view=True):
157
 
    """Convert command-line paths to a WorkingTree and relative paths.
158
 
 
159
 
    This is typically used for command-line processors that take one or
160
 
    more filenames, and infer the workingtree that contains them.
161
 
 
162
 
    The filenames given are not required to exist.
163
 
 
164
 
    :param file_list: Filenames to convert.
165
 
 
166
 
    :param default_branch: Fallback tree path to use if file_list is empty or
167
 
        None.
168
 
 
169
 
    :param apply_view: if True and a view is set, apply it or check that
170
 
        specified files are within it
171
 
 
172
 
    :return: workingtree, [relative_paths]
173
 
    """
174
 
    if file_list is None or len(file_list) == 0:
175
 
        tree = WorkingTree.open_containing(default_branch)[0]
176
 
        if tree.supports_views() and apply_view:
177
 
            view_files = tree.views.lookup_view()
178
 
            if view_files:
179
 
                file_list = view_files
180
 
                view_str = views.view_display_str(view_files)
181
 
                note("Ignoring files outside view. View is %s" % view_str)
182
 
        return tree, file_list
183
 
    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
 
    return tree, safe_relpath_files(tree, file_list, canonicalize,
185
 
        apply_view=apply_view)
186
 
 
187
 
 
188
 
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
189
 
    """Convert file_list into a list of relpaths in tree.
190
 
 
191
 
    :param tree: A tree to operate on.
192
 
    :param file_list: A list of user provided paths or None.
193
 
    :param apply_view: if True and a view is set, apply it or check that
194
 
        specified files are within it
195
 
    :return: A list of relative paths.
196
 
    :raises errors.PathNotChild: When a provided path is in a different tree
197
 
        than tree.
198
 
    """
199
 
    if file_list is None:
200
 
        return None
201
 
    if tree.supports_views() and apply_view:
202
 
        view_files = tree.views.lookup_view()
203
 
    else:
204
 
        view_files = []
205
 
    new_list = []
206
 
    # tree.relpath exists as a "thunk" to osutils, but canonical_relpath
207
 
    # doesn't - fix that up here before we enter the loop.
208
 
    if canonicalize:
209
 
        fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
210
 
    else:
211
 
        fixer = tree.relpath
212
 
    for filename in file_list:
213
 
        try:
214
 
            relpath = fixer(osutils.dereference_path(filename))
215
 
            if  view_files and not osutils.is_inside_any(view_files, relpath):
216
 
                raise errors.FileOutsideView(filename, view_files)
217
 
            new_list.append(relpath)
218
 
        except errors.PathNotChild:
219
 
            raise errors.FileInWrongBranch(tree.branch, filename)
220
 
    return new_list
221
 
 
222
 
 
223
299
def _get_view_info_for_change_reporter(tree):
224
300
    """Get the view information from a tree for change reporting."""
225
301
    view_info = None
227
303
        current_view = tree.views.get_view_info()[0]
228
304
        if current_view is not None:
229
305
            view_info = (current_view, tree.views.lookup_view())
230
 
    except errors.ViewsNotSupported:
 
306
    except views.ViewsNotSupported:
231
307
        pass
232
308
    return view_info
233
309
 
234
310
 
 
311
def _open_directory_or_containing_tree_or_branch(filename, directory):
 
312
    """Open the tree or branch containing the specified file, unless
 
313
    the --directory option is used to specify a different branch."""
 
314
    if directory is not None:
 
315
        return (None, Branch.open(directory), filename)
 
316
    return controldir.ControlDir.open_containing_tree_or_branch(filename)
 
317
 
 
318
 
235
319
# TODO: Make sure no commands unconditionally use the working directory as a
236
320
# branch.  If a filename argument is used, the first of them should be used to
237
321
# specify the branch.  (Perhaps this can be factored out into some kind of
265
349
    unknown
266
350
        Not versioned and not matching an ignore pattern.
267
351
 
268
 
    Additionally for directories, symlinks and files with an executable
269
 
    bit, Bazaar indicates their type using a trailing character: '/', '@'
270
 
    or '*' respectively.
 
352
    Additionally for directories, symlinks and files with a changed
 
353
    executable bit, Breezy indicates their type using a trailing
 
354
    character: '/', '@' or '*' respectively. These decorations can be
 
355
    disabled using the '--no-classify' option.
271
356
 
272
 
    To see ignored files use 'bzr ignored'.  For details on the
273
 
    changes to file texts, use 'bzr diff'.
 
357
    To see ignored files use 'brz ignored'.  For details on the
 
358
    changes to file texts, use 'brz diff'.
274
359
 
275
360
    Note that --short or -S gives status flags for each item, similar
276
361
    to Subversion's status command. To get output similar to svn -q,
277
 
    use bzr status -SV.
 
362
    use brz status -SV.
278
363
 
279
364
    If no arguments are specified, the status of the entire working
280
365
    directory is shown.  Otherwise, only the status of the specified
286
371
    To skip the display of pending merge information altogether, use
287
372
    the no-pending option or specify a file/directory.
288
373
 
289
 
    If a revision argument is given, the status is calculated against
290
 
    that revision, or between two revisions if two are provided.
 
374
    To compare the working directory to a specific revision, pass a
 
375
    single revision to the revision argument.
 
376
 
 
377
    To see which files have changed in a specific revision, or between
 
378
    two revisions, pass a revision range to the revision argument.
 
379
    This will produce the same results as calling 'brz diff --summarize'.
291
380
    """
292
381
 
293
 
    # TODO: --no-recurse, --recurse options
 
382
    # TODO: --no-recurse/-N, --recurse options
294
383
 
295
384
    takes_args = ['file*']
296
385
    takes_options = ['show-ids', 'revision', 'change', 'verbose',
298
387
                            short_name='S'),
299
388
                     Option('versioned', help='Only show versioned files.',
300
389
                            short_name='V'),
301
 
                     Option('no-pending', help='Don\'t show pending merges.',
302
 
                           ),
 
390
                     Option('no-pending', help='Don\'t show pending merges.'),
 
391
                     Option('no-classify',
 
392
                            help='Do not mark object type using indicator.'),
303
393
                     ]
304
394
    aliases = ['st', 'stat']
305
395
 
308
398
 
309
399
    @display_command
310
400
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
311
 
            versioned=False, no_pending=False, verbose=False):
312
 
        from bzrlib.status import show_tree_status
 
401
            versioned=False, no_pending=False, verbose=False,
 
402
            no_classify=False):
 
403
        from .status import show_tree_status
313
404
 
314
405
        if revision and len(revision) > 2:
315
 
            raise errors.BzrCommandError('bzr status --revision takes exactly'
316
 
                                         ' one or two revision specifiers')
 
406
            raise errors.CommandError(
 
407
                gettext('brz status --revision takes exactly'
 
408
                        ' one or two revision specifiers'))
317
409
 
318
 
        tree, relfile_list = tree_files(file_list)
 
410
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
319
411
        # Avoid asking for specific files when that is not needed.
320
412
        if relfile_list == ['']:
321
413
            relfile_list = None
328
420
        show_tree_status(tree, show_ids=show_ids,
329
421
                         specific_files=relfile_list, revision=revision,
330
422
                         to_file=self.outf, short=short, versioned=versioned,
331
 
                         show_pending=(not no_pending), verbose=verbose)
 
423
                         show_pending=(not no_pending), verbose=verbose,
 
424
                         classify=not no_classify)
332
425
 
333
426
 
334
427
class cmd_cat_revision(Command):
340
433
 
341
434
    hidden = True
342
435
    takes_args = ['revision_id?']
343
 
    takes_options = ['revision']
 
436
    takes_options = ['directory', 'revision']
344
437
    # cat-revision is more for frontends so should be exact
345
438
    encoding = 'strict'
346
439
 
347
440
    def print_revision(self, revisions, revid):
348
441
        stream = revisions.get_record_stream([(revid,)], 'unordered', True)
349
 
        record = stream.next()
 
442
        record = next(stream)
350
443
        if record.storage_kind == 'absent':
351
444
            raise errors.NoSuchRevision(revisions, revid)
352
445
        revtext = record.get_bytes_as('fulltext')
353
446
        self.outf.write(revtext.decode('utf-8'))
354
447
 
355
448
    @display_command
356
 
    def run(self, revision_id=None, revision=None):
 
449
    def run(self, revision_id=None, revision=None, directory=u'.'):
357
450
        if revision_id is not None and revision is not None:
358
 
            raise errors.BzrCommandError('You can only supply one of'
359
 
                                         ' revision_id or --revision')
 
451
            raise errors.CommandError(gettext('You can only supply one of'
 
452
                                                 ' revision_id or --revision'))
360
453
        if revision_id is None and revision is None:
361
 
            raise errors.BzrCommandError('You must supply either'
362
 
                                         ' --revision or a revision_id')
363
 
        b = WorkingTree.open_containing(u'.')[0].branch
364
 
 
365
 
        revisions = b.repository.revisions
 
454
            raise errors.CommandError(
 
455
                gettext('You must supply either --revision or a revision_id'))
 
456
 
 
457
        b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]
 
458
 
 
459
        revisions = getattr(b.repository, "revisions", None)
366
460
        if revisions is None:
367
 
            raise errors.BzrCommandError('Repository %r does not support '
368
 
                'access to raw revision texts')
 
461
            raise errors.CommandError(
 
462
                gettext('Repository %r does not support '
 
463
                        'access to raw revision texts') % b.repository)
369
464
 
370
 
        b.repository.lock_read()
371
 
        try:
 
465
        with b.repository.lock_read():
372
466
            # TODO: jam 20060112 should cat-revision always output utf-8?
373
467
            if revision_id is not None:
374
 
                revision_id = osutils.safe_revision_id(revision_id, warn=False)
 
468
                revision_id = cache_utf8.encode(revision_id)
375
469
                try:
376
470
                    self.print_revision(revisions, revision_id)
377
471
                except errors.NoSuchRevision:
378
 
                    msg = "The repository %s contains no revision %s." % (
379
 
                        b.repository.base, revision_id)
380
 
                    raise errors.BzrCommandError(msg)
 
472
                    msg = gettext(
 
473
                        "The repository {0} contains no revision {1}.").format(
 
474
                            b.repository.base, revision_id.decode('utf-8'))
 
475
                    raise errors.CommandError(msg)
381
476
            elif revision is not None:
382
477
                for rev in revision:
383
478
                    if rev is None:
384
 
                        raise errors.BzrCommandError(
385
 
                            'You cannot specify a NULL revision.')
 
479
                        raise errors.CommandError(
 
480
                            gettext('You cannot specify a NULL revision.'))
386
481
                    rev_id = rev.as_revision_id(b)
387
482
                    self.print_revision(revisions, rev_id)
388
 
        finally:
389
 
            b.repository.unlock()
390
 
        
391
 
 
392
 
class cmd_dump_btree(Command):
393
 
    __doc__ = """Dump the contents of a btree index file to stdout.
394
 
 
395
 
    PATH is a btree index file, it can be any URL. This includes things like
396
 
    .bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
397
 
 
398
 
    By default, the tuples stored in the index file will be displayed. With
399
 
    --raw, we will uncompress the pages, but otherwise display the raw bytes
400
 
    stored in the index.
401
 
    """
402
 
 
403
 
    # TODO: Do we want to dump the internal nodes as well?
404
 
    # TODO: It would be nice to be able to dump the un-parsed information,
405
 
    #       rather than only going through iter_all_entries. However, this is
406
 
    #       good enough for a start
407
 
    hidden = True
408
 
    encoding_type = 'exact'
409
 
    takes_args = ['path']
410
 
    takes_options = [Option('raw', help='Write the uncompressed bytes out,'
411
 
                                        ' rather than the parsed tuples.'),
412
 
                    ]
413
 
 
414
 
    def run(self, path, raw=False):
415
 
        dirname, basename = osutils.split(path)
416
 
        t = transport.get_transport(dirname)
417
 
        if raw:
418
 
            self._dump_raw_bytes(t, basename)
419
 
        else:
420
 
            self._dump_entries(t, basename)
421
 
 
422
 
    def _get_index_and_bytes(self, trans, basename):
423
 
        """Create a BTreeGraphIndex and raw bytes."""
424
 
        bt = btree_index.BTreeGraphIndex(trans, basename, None)
425
 
        bytes = trans.get_bytes(basename)
426
 
        bt._file = cStringIO.StringIO(bytes)
427
 
        bt._size = len(bytes)
428
 
        return bt, bytes
429
 
 
430
 
    def _dump_raw_bytes(self, trans, basename):
431
 
        import zlib
432
 
 
433
 
        # We need to parse at least the root node.
434
 
        # This is because the first page of every row starts with an
435
 
        # uncompressed header.
436
 
        bt, bytes = self._get_index_and_bytes(trans, basename)
437
 
        for page_idx, page_start in enumerate(xrange(0, len(bytes),
438
 
                                                     btree_index._PAGE_SIZE)):
439
 
            page_end = min(page_start + btree_index._PAGE_SIZE, len(bytes))
440
 
            page_bytes = bytes[page_start:page_end]
441
 
            if page_idx == 0:
442
 
                self.outf.write('Root node:\n')
443
 
                header_end, data = bt._parse_header_from_bytes(page_bytes)
444
 
                self.outf.write(page_bytes[:header_end])
445
 
                page_bytes = data
446
 
            self.outf.write('\nPage %d\n' % (page_idx,))
447
 
            decomp_bytes = zlib.decompress(page_bytes)
448
 
            self.outf.write(decomp_bytes)
449
 
            self.outf.write('\n')
450
 
 
451
 
    def _dump_entries(self, trans, basename):
452
 
        try:
453
 
            st = trans.stat(basename)
454
 
        except errors.TransportNotPossible:
455
 
            # We can't stat, so we'll fake it because we have to do the 'get()'
456
 
            # anyway.
457
 
            bt, _ = self._get_index_and_bytes(trans, basename)
458
 
        else:
459
 
            bt = btree_index.BTreeGraphIndex(trans, basename, st.st_size)
460
 
        for node in bt.iter_all_entries():
461
 
            # Node is made up of:
462
 
            # (index, key, value, [references])
463
 
            try:
464
 
                refs = node[3]
465
 
            except IndexError:
466
 
                refs_as_tuples = None
467
 
            else:
468
 
                refs_as_tuples = static_tuple.as_tuples(refs)
469
 
            as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
470
 
            self.outf.write('%s\n' % (as_tuple,))
471
483
 
472
484
 
473
485
class cmd_remove_tree(Command):
476
488
    Since a lightweight checkout is little more than a working tree
477
489
    this will refuse to run against one.
478
490
 
479
 
    To re-create the working tree, use "bzr checkout".
 
491
    To re-create the working tree, use "brz checkout".
480
492
    """
481
493
    _see_also = ['checkout', 'working-trees']
482
494
    takes_args = ['location*']
483
495
    takes_options = [
484
496
        Option('force',
485
497
               help='Remove the working tree even if it has '
486
 
                    'uncommitted changes.'),
 
498
                    'uncommitted or shelved changes.'),
487
499
        ]
488
500
 
489
501
    def run(self, location_list, force=False):
490
502
        if not location_list:
491
 
            location_list=['.']
 
503
            location_list = ['.']
492
504
 
493
505
        for location in location_list:
494
 
            d = bzrdir.BzrDir.open(location)
495
 
            
 
506
            d = controldir.ControlDir.open(location)
 
507
 
496
508
            try:
497
509
                working = d.open_workingtree()
498
510
            except errors.NoWorkingTree:
499
 
                raise errors.BzrCommandError("No working tree to remove")
 
511
                raise errors.CommandError(
 
512
                    gettext("No working tree to remove"))
500
513
            except errors.NotLocalUrl:
501
 
                raise errors.BzrCommandError("You cannot remove the working tree"
502
 
                                             " of a remote path")
 
514
                raise errors.CommandError(
 
515
                    gettext("You cannot remove the working tree"
 
516
                            " of a remote path"))
503
517
            if not force:
504
518
                if (working.has_changes()):
505
519
                    raise errors.UncommittedChanges(working)
 
520
                if working.get_shelf_manager().last_shelf() is not None:
 
521
                    raise errors.ShelvedChanges(working)
506
522
 
507
523
            if working.user_url != working.branch.user_url:
508
 
                raise errors.BzrCommandError("You cannot remove the working tree"
509
 
                                             " from a lightweight checkout")
 
524
                raise errors.CommandError(
 
525
                    gettext("You cannot remove the working tree"
 
526
                            " from a lightweight checkout"))
510
527
 
511
528
            d.destroy_workingtree()
512
529
 
513
530
 
 
531
class cmd_repair_workingtree(Command):
 
532
    __doc__ = """Reset the working tree state file.
 
533
 
 
534
    This is not meant to be used normally, but more as a way to recover from
 
535
    filesystem corruption, etc. This rebuilds the working inventory back to a
 
536
    'known good' state. Any new modifications (adding a file, renaming, etc)
 
537
    will be lost, though modified files will still be detected as such.
 
538
 
 
539
    Most users will want something more like "brz revert" or "brz update"
 
540
    unless the state file has become corrupted.
 
541
 
 
542
    By default this attempts to recover the current state by looking at the
 
543
    headers of the state file. If the state file is too corrupted to even do
 
544
    that, you can supply --revision to force the state of the tree.
 
545
    """
 
546
 
 
547
    takes_options = [
 
548
        'revision', 'directory',
 
549
        Option('force',
 
550
               help='Reset the tree even if it doesn\'t appear to be'
 
551
                    ' corrupted.'),
 
552
    ]
 
553
    hidden = True
 
554
 
 
555
    def run(self, revision=None, directory='.', force=False):
 
556
        tree, _ = WorkingTree.open_containing(directory)
 
557
        self.enter_context(tree.lock_tree_write())
 
558
        if not force:
 
559
            try:
 
560
                tree.check_state()
 
561
            except errors.BzrError:
 
562
                pass  # There seems to be a real error here, so we'll reset
 
563
            else:
 
564
                # Refuse
 
565
                raise errors.CommandError(gettext(
 
566
                    'The tree does not appear to be corrupt. You probably'
 
567
                    ' want "brz revert" instead. Use "--force" if you are'
 
568
                    ' sure you want to reset the working tree.'))
 
569
        if revision is None:
 
570
            revision_ids = None
 
571
        else:
 
572
            revision_ids = [r.as_revision_id(tree.branch) for r in revision]
 
573
        try:
 
574
            tree.reset_state(revision_ids)
 
575
        except errors.BzrError:
 
576
            if revision_ids is None:
 
577
                extra = gettext(', the header appears corrupt, try passing '
 
578
                                '-r -1 to set the state to the last commit')
 
579
            else:
 
580
                extra = ''
 
581
            raise errors.CommandError(
 
582
                gettext('failed to reset the tree state{0}').format(extra))
 
583
 
 
584
 
514
585
class cmd_revno(Command):
515
586
    __doc__ = """Show current revision number.
516
587
 
520
591
    _see_also = ['info']
521
592
    takes_args = ['location?']
522
593
    takes_options = [
523
 
        Option('tree', help='Show revno of working tree'),
 
594
        Option('tree', help='Show revno of working tree.'),
 
595
        'revision',
524
596
        ]
525
597
 
526
598
    @display_command
527
 
    def run(self, tree=False, location=u'.'):
 
599
    def run(self, tree=False, location=u'.', revision=None):
 
600
        if revision is not None and tree:
 
601
            raise errors.CommandError(
 
602
                gettext("--tree and --revision can not be used together"))
 
603
 
528
604
        if tree:
529
605
            try:
530
606
                wt = WorkingTree.open_containing(location)[0]
531
 
                self.add_cleanup(wt.lock_read().unlock)
 
607
                self.enter_context(wt.lock_read())
532
608
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
609
                raise errors.NoWorkingTree(location)
 
610
            b = wt.branch
534
611
            revid = wt.last_revision()
535
 
            try:
536
 
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
537
 
            except errors.NoSuchRevision:
538
 
                revno_t = ('???',)
539
 
            revno = ".".join(str(n) for n in revno_t)
540
612
        else:
541
613
            b = Branch.open_containing(location)[0]
542
 
            self.add_cleanup(b.lock_read().unlock)
543
 
            revno = b.revno()
 
614
            self.enter_context(b.lock_read())
 
615
            if revision:
 
616
                if len(revision) != 1:
 
617
                    raise errors.CommandError(gettext(
 
618
                        "Revision numbers only make sense for single "
 
619
                        "revisions, not ranges"))
 
620
                revid = revision[0].as_revision_id(b)
 
621
            else:
 
622
                revid = b.last_revision()
 
623
        try:
 
624
            revno_t = b.revision_id_to_dotted_revno(revid)
 
625
        except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
 
626
            revno_t = ('???',)
 
627
        revno = ".".join(str(n) for n in revno_t)
544
628
        self.cleanup_now()
545
 
        self.outf.write(str(revno) + '\n')
 
629
        self.outf.write(revno + '\n')
546
630
 
547
631
 
548
632
class cmd_revision_info(Command):
552
636
    takes_args = ['revision_info*']
553
637
    takes_options = [
554
638
        'revision',
555
 
        Option('directory',
556
 
            help='Branch to examine, '
557
 
                 'rather than the one containing the working directory.',
558
 
            short_name='d',
559
 
            type=unicode,
560
 
            ),
561
 
        Option('tree', help='Show revno of working tree'),
 
639
        custom_help('directory', help='Branch to examine, '
 
640
                    'rather than the one containing the working directory.'),
 
641
        Option('tree', help='Show revno of working tree.'),
562
642
        ]
563
643
 
564
644
    @display_command
568
648
        try:
569
649
            wt = WorkingTree.open_containing(directory)[0]
570
650
            b = wt.branch
571
 
            self.add_cleanup(wt.lock_read().unlock)
 
651
            self.enter_context(wt.lock_read())
572
652
        except (errors.NoWorkingTree, errors.NotLocalUrl):
573
653
            wt = None
574
654
            b = Branch.open_containing(directory)[0]
575
 
            self.add_cleanup(b.lock_read().unlock)
 
655
            self.enter_context(b.lock_read())
576
656
        revision_ids = []
577
657
        if revision is not None:
578
658
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
598
678
            except errors.NoSuchRevision:
599
679
                revno = '???'
600
680
            maxlen = max(maxlen, len(revno))
601
 
            revinfos.append([revno, revision_id])
 
681
            revinfos.append((revno, revision_id))
602
682
 
603
683
        self.cleanup_now()
604
 
        for ri in revinfos:
605
 
            self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
 
684
        for revno, revid in revinfos:
 
685
            self.outf.write(
 
686
                '%*s %s\n' % (maxlen, revno, revid.decode('utf-8')))
606
687
 
607
688
 
608
689
class cmd_add(Command):
620
701
    are added.  This search proceeds recursively into versioned
621
702
    directories.  If no names are given '.' is assumed.
622
703
 
623
 
    Therefore simply saying 'bzr add' will version all files that
 
704
    A warning will be printed when nested trees are encountered,
 
705
    unless they are explicitly ignored.
 
706
 
 
707
    Therefore simply saying 'brz add' will version all files that
624
708
    are currently unknown.
625
709
 
626
710
    Adding a file whose parent directory is not versioned will
638
722
    branches that will be merged later (without showing the two different
639
723
    adds as a conflict). It is also useful when merging another project
640
724
    into a subdirectory of this one.
641
 
    
 
725
 
642
726
    Any files matching patterns in the ignore list will not be added
643
727
    unless they are explicitly mentioned.
 
728
 
 
729
    In recursive mode, files larger than the configuration option
 
730
    add.maximum_file_size will be skipped. Named items are never skipped due
 
731
    to file size.
644
732
    """
645
733
    takes_args = ['file*']
646
734
    takes_options = [
647
735
        Option('no-recurse',
648
 
               help="Don't recursively add the contents of directories."),
 
736
               help="Don't recursively add the contents of directories.",
 
737
               short_name='N'),
649
738
        Option('dry-run',
650
 
               help="Show what would be done, but don't actually do anything."),
 
739
               help="Show what would be done, but don't actually do "
 
740
                    "anything."),
651
741
        'verbose',
652
742
        Option('file-ids-from',
653
 
               type=unicode,
 
743
               type=text_type,
654
744
               help='Lookup file ids from this tree.'),
655
745
        ]
656
746
    encoding_type = 'replace'
658
748
 
659
749
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
660
750
            file_ids_from=None):
661
 
        import bzrlib.add
 
751
        import breezy.add
 
752
        tree, file_list = tree_files_for_add(file_list)
 
753
 
 
754
        if file_ids_from is not None and not tree.supports_setting_file_ids():
 
755
            warning(
 
756
                gettext('Ignoring --file-ids-from, since the tree does not '
 
757
                        'support setting file ids.'))
 
758
            file_ids_from = None
662
759
 
663
760
        base_tree = None
664
761
        if file_ids_from is not None:
665
762
            try:
666
763
                base_tree, base_path = WorkingTree.open_containing(
667
 
                                            file_ids_from)
 
764
                    file_ids_from)
668
765
            except errors.NoWorkingTree:
669
766
                base_branch, base_path = Branch.open_containing(
670
 
                                            file_ids_from)
 
767
                    file_ids_from)
671
768
                base_tree = base_branch.basis_tree()
672
769
 
673
 
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
674
 
                          to_file=self.outf, should_print=(not is_quiet()))
675
 
        else:
676
 
            action = bzrlib.add.AddAction(to_file=self.outf,
 
770
            action = breezy.add.AddFromBaseAction(
 
771
                base_tree, base_path, to_file=self.outf,
677
772
                should_print=(not is_quiet()))
 
773
        else:
 
774
            action = breezy.add.AddWithSkipLargeAction(
 
775
                to_file=self.outf, should_print=(not is_quiet()))
678
776
 
679
777
        if base_tree:
680
 
            self.add_cleanup(base_tree.lock_read().unlock)
681
 
        tree, file_list = tree_files_for_add(file_list)
682
 
        added, ignored = tree.smart_add(file_list, not
683
 
            no_recurse, action=action, save=not dry_run)
 
778
            self.enter_context(base_tree.lock_read())
 
779
        added, ignored = tree.smart_add(
 
780
            file_list, not no_recurse, action=action, save=not dry_run)
684
781
        self.cleanup_now()
685
782
        if len(ignored) > 0:
686
783
            if verbose:
687
 
                for glob in sorted(ignored.keys()):
 
784
                for glob in sorted(ignored):
688
785
                    for path in ignored[glob]:
689
 
                        self.outf.write("ignored %s matching \"%s\"\n"
690
 
                                        % (path, glob))
 
786
                        self.outf.write(
 
787
                            gettext("ignored {0} matching \"{1}\"\n").format(
 
788
                                path, glob))
691
789
 
692
790
 
693
791
class cmd_mkdir(Command):
697
795
    """
698
796
 
699
797
    takes_args = ['dir+']
 
798
    takes_options = [
 
799
        Option(
 
800
            'parents',
 
801
            help='No error if existing, make parent directories as needed.',
 
802
            short_name='p'
 
803
            )
 
804
        ]
700
805
    encoding_type = 'replace'
701
806
 
702
 
    def run(self, dir_list):
703
 
        for d in dir_list:
704
 
            wt, dd = WorkingTree.open_containing(d)
705
 
            base = os.path.dirname(dd)
706
 
            id = wt.path2id(base)
707
 
            if id != None:
708
 
                os.mkdir(d)
709
 
                wt.add([dd])
710
 
                self.outf.write('added %s\n' % d)
 
807
    @classmethod
 
808
    def add_file_with_parents(cls, wt, relpath):
 
809
        if wt.is_versioned(relpath):
 
810
            return
 
811
        cls.add_file_with_parents(wt, osutils.dirname(relpath))
 
812
        wt.add([relpath])
 
813
 
 
814
    @classmethod
 
815
    def add_file_single(cls, wt, relpath):
 
816
        wt.add([relpath])
 
817
 
 
818
    def run(self, dir_list, parents=False):
 
819
        if parents:
 
820
            add_file = self.add_file_with_parents
 
821
        else:
 
822
            add_file = self.add_file_single
 
823
        for dir in dir_list:
 
824
            wt, relpath = WorkingTree.open_containing(dir)
 
825
            if parents:
 
826
                try:
 
827
                    os.makedirs(dir)
 
828
                except OSError as e:
 
829
                    if e.errno != errno.EEXIST:
 
830
                        raise
711
831
            else:
712
 
                raise errors.NotVersionedError(path=base)
 
832
                os.mkdir(dir)
 
833
            add_file(wt, relpath)
 
834
            if not is_quiet():
 
835
                self.outf.write(gettext('added %s\n') % dir)
713
836
 
714
837
 
715
838
class cmd_relpath(Command):
734
857
    type using the --kind option.  For example: --kind file.
735
858
 
736
859
    It is also possible to restrict the list of files to a specific
737
 
    set. For example: bzr inventory --show-ids this/file
 
860
    set. For example: brz inventory --show-ids this/file
738
861
    """
739
862
 
740
863
    hidden = True
742
865
    takes_options = [
743
866
        'revision',
744
867
        'show-ids',
 
868
        Option('include-root',
 
869
               help='Include the entry for the root of the tree, if any.'),
745
870
        Option('kind',
746
 
               help='List entries of a particular kind: file, directory, symlink.',
747
 
               type=unicode),
 
871
               help='List entries of a particular kind: file, directory, '
 
872
                    'symlink.',
 
873
               type=text_type),
748
874
        ]
749
875
    takes_args = ['file*']
750
876
 
751
877
    @display_command
752
 
    def run(self, revision=None, show_ids=False, kind=None, file_list=None):
 
878
    def run(self, revision=None, show_ids=False, kind=None, include_root=False,
 
879
            file_list=None):
753
880
        if kind and kind not in ['file', 'directory', 'symlink']:
754
 
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
 
881
            raise errors.CommandError(
 
882
                gettext('invalid kind %r specified') % (kind,))
755
883
 
756
884
        revision = _get_one_revision('inventory', revision)
757
 
        work_tree, file_list = tree_files(file_list)
758
 
        self.add_cleanup(work_tree.lock_read().unlock)
 
885
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
 
886
        self.enter_context(work_tree.lock_read())
759
887
        if revision is not None:
760
888
            tree = revision.as_tree(work_tree.branch)
761
889
 
762
890
            extra_trees = [work_tree]
763
 
            self.add_cleanup(tree.lock_read().unlock)
 
891
            self.enter_context(tree.lock_read())
764
892
        else:
765
893
            tree = work_tree
766
894
            extra_trees = []
767
895
 
 
896
        self.enter_context(tree.lock_read())
768
897
        if file_list is not None:
769
 
            file_ids = tree.paths2ids(file_list, trees=extra_trees,
770
 
                                      require_versioned=True)
 
898
            paths = tree.find_related_paths_across_trees(
 
899
                file_list, extra_trees, require_versioned=True)
771
900
            # find_ids_across_trees may include some paths that don't
772
901
            # exist in 'tree'.
773
 
            entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
774
 
                             for file_id in file_ids if file_id in tree)
 
902
            entries = tree.iter_entries_by_dir(specific_files=paths)
775
903
        else:
776
 
            entries = tree.inventory.entries()
 
904
            entries = tree.iter_entries_by_dir()
777
905
 
778
 
        self.cleanup_now()
779
 
        for path, entry in entries:
 
906
        for path, entry in sorted(entries):
780
907
            if kind and kind != entry.kind:
781
908
                continue
 
909
            if path == "" and not include_root:
 
910
                continue
782
911
            if show_ids:
783
 
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
 
912
                self.outf.write('%-50s %s\n' % (
 
913
                    path, entry.file_id.decode('utf-8')))
784
914
            else:
785
915
                self.outf.write(path)
786
916
                self.outf.write('\n')
787
917
 
788
918
 
 
919
class cmd_cp(Command):
 
920
    __doc__ = """Copy a file.
 
921
 
 
922
    :Usage:
 
923
        brz cp OLDNAME NEWNAME
 
924
 
 
925
        brz cp SOURCE... DESTINATION
 
926
 
 
927
    If the last argument is a versioned directory, all the other names
 
928
    are copied into it.  Otherwise, there must be exactly two arguments
 
929
    and the file is copied to a new name.
 
930
 
 
931
    Files cannot be copied between branches. Only files can be copied
 
932
    at the moment.
 
933
    """
 
934
 
 
935
    takes_args = ['names*']
 
936
    takes_options = []
 
937
    aliases = ['copy']
 
938
    encoding_type = 'replace'
 
939
 
 
940
    def run(self, names_list):
 
941
        if names_list is None:
 
942
            names_list = []
 
943
        if len(names_list) < 2:
 
944
            raise errors.CommandError(gettext("missing file argument"))
 
945
        tree, rel_names = WorkingTree.open_containing_paths(
 
946
            names_list, canonicalize=False)
 
947
        for file_name in rel_names[0:-1]:
 
948
            if file_name == '':
 
949
                raise errors.CommandError(
 
950
                    gettext("can not copy root of branch"))
 
951
        self.enter_context(tree.lock_tree_write())
 
952
        into_existing = osutils.isdir(names_list[-1])
 
953
        if not into_existing:
 
954
            try:
 
955
                (src, dst) = rel_names
 
956
            except IndexError:
 
957
                raise errors.CommandError(
 
958
                    gettext('to copy multiple files the'
 
959
                            ' destination must be a versioned'
 
960
                            ' directory'))
 
961
            pairs = [(src, dst)]
 
962
        else:
 
963
            pairs = [
 
964
                (n, osutils.joinpath([rel_names[-1], osutils.basename(n)]))
 
965
                for n in rel_names[:-1]]
 
966
 
 
967
        for src, dst in pairs:
 
968
            try:
 
969
                src_kind = tree.stored_kind(src)
 
970
            except errors.NoSuchFile:
 
971
                raise errors.CommandError(
 
972
                    gettext('Could not copy %s => %s: %s is not versioned.')
 
973
                    % (src, dst, src))
 
974
            if src_kind is None:
 
975
                raise errors.CommandError(
 
976
                    gettext('Could not copy %s => %s . %s is not versioned\\.'
 
977
                            % (src, dst, src)))
 
978
            if src_kind == 'directory':
 
979
                raise errors.CommandError(
 
980
                    gettext('Could not copy %s => %s . %s is a directory.'
 
981
                            % (src, dst, src)))
 
982
            dst_parent = osutils.split(dst)[0]
 
983
            if dst_parent != '':
 
984
                try:
 
985
                    dst_parent_kind = tree.stored_kind(dst_parent)
 
986
                except errors.NoSuchFile:
 
987
                    raise errors.CommandError(
 
988
                        gettext('Could not copy %s => %s: %s is not versioned.')
 
989
                        % (src, dst, dst_parent))
 
990
                if dst_parent_kind != 'directory':
 
991
                    raise errors.CommandError(
 
992
                        gettext('Could not copy to %s: %s is not a directory.')
 
993
                        % (dst_parent, dst_parent))
 
994
 
 
995
            tree.copy_one(src, dst)
 
996
 
 
997
 
789
998
class cmd_mv(Command):
790
999
    __doc__ = """Move or rename a file.
791
1000
 
792
1001
    :Usage:
793
 
        bzr mv OLDNAME NEWNAME
 
1002
        brz mv OLDNAME NEWNAME
794
1003
 
795
 
        bzr mv SOURCE... DESTINATION
 
1004
        brz mv SOURCE... DESTINATION
796
1005
 
797
1006
    If the last argument is a versioned directory, all the other names
798
1007
    are moved into it.  Otherwise, there must be exactly two arguments
808
1017
    """
809
1018
 
810
1019
    takes_args = ['names*']
811
 
    takes_options = [Option("after", help="Move only the bzr identifier"
812
 
        " of the file, because the file has already been moved."),
813
 
        Option('auto', help='Automatically guess renames.'),
814
 
        Option('dry-run', help='Avoid making changes when guessing renames.'),
815
 
        ]
 
1020
    takes_options = [Option("after", help="Move only the brz identifier"
 
1021
                            " of the file, because the file has already been moved."),
 
1022
                     Option('auto', help='Automatically guess renames.'),
 
1023
                     Option(
 
1024
                         'dry-run', help='Avoid making changes when guessing renames.'),
 
1025
                     ]
816
1026
    aliases = ['move', 'rename']
817
1027
    encoding_type = 'replace'
818
1028
 
820
1030
        if auto:
821
1031
            return self.run_auto(names_list, after, dry_run)
822
1032
        elif dry_run:
823
 
            raise errors.BzrCommandError('--dry-run requires --auto.')
 
1033
            raise errors.CommandError(gettext('--dry-run requires --auto.'))
824
1034
        if names_list is None:
825
1035
            names_list = []
826
1036
        if len(names_list) < 2:
827
 
            raise errors.BzrCommandError("missing file argument")
828
 
        tree, rel_names = tree_files(names_list, canonicalize=False)
829
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
1037
            raise errors.CommandError(gettext("missing file argument"))
 
1038
        tree, rel_names = WorkingTree.open_containing_paths(
 
1039
            names_list, canonicalize=False)
 
1040
        for file_name in rel_names[0:-1]:
 
1041
            if file_name == '':
 
1042
                raise errors.CommandError(
 
1043
                    gettext("can not move root of branch"))
 
1044
        self.enter_context(tree.lock_tree_write())
830
1045
        self._run(tree, names_list, rel_names, after)
831
1046
 
832
1047
    def run_auto(self, names_list, after, dry_run):
833
1048
        if names_list is not None and len(names_list) > 1:
834
 
            raise errors.BzrCommandError('Only one path may be specified to'
835
 
                                         ' --auto.')
 
1049
            raise errors.CommandError(
 
1050
                gettext('Only one path may be specified to --auto.'))
836
1051
        if after:
837
 
            raise errors.BzrCommandError('--after cannot be specified with'
838
 
                                         ' --auto.')
839
 
        work_tree, file_list = tree_files(names_list, default_branch='.')
840
 
        self.add_cleanup(work_tree.lock_tree_write().unlock)
841
 
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
 
1052
            raise errors.CommandError(
 
1053
                gettext('--after cannot be specified with --auto.'))
 
1054
        work_tree, file_list = WorkingTree.open_containing_paths(
 
1055
            names_list, default_directory='.')
 
1056
        self.enter_context(work_tree.lock_tree_write())
 
1057
        rename_map.RenameMap.guess_renames(
 
1058
            work_tree.basis_tree(), work_tree, dry_run)
842
1059
 
843
1060
    def _run(self, tree, names_list, rel_names, after):
844
1061
        into_existing = osutils.isdir(names_list[-1])
849
1066
            #    a directory, but now doesn't exist in the working tree
850
1067
            #    and the target is an existing directory, just rename it)
851
1068
            if (not tree.case_sensitive
852
 
                and rel_names[0].lower() == rel_names[1].lower()):
 
1069
                    and rel_names[0].lower() == rel_names[1].lower()):
853
1070
                into_existing = False
854
1071
            else:
855
 
                inv = tree.inventory
856
1072
                # 'fix' the case of a potential 'from'
857
 
                from_id = tree.path2id(
858
 
                            tree.get_canonical_inventory_path(rel_names[0]))
 
1073
                from_path = tree.get_canonical_path(rel_names[0])
859
1074
                if (not osutils.lexists(names_list[0]) and
860
 
                    from_id and inv.get_file_kind(from_id) == "directory"):
 
1075
                    tree.is_versioned(from_path) and
 
1076
                        tree.stored_kind(from_path) == "directory"):
861
1077
                    into_existing = False
862
1078
        # move/rename
863
1079
        if into_existing:
864
1080
            # move into existing directory
865
1081
            # All entries reference existing inventory items, so fix them up
866
1082
            # for cicp file-systems.
867
 
            rel_names = tree.get_canonical_inventory_paths(rel_names)
 
1083
            rel_names = list(tree.get_canonical_paths(rel_names))
868
1084
            for src, dest in tree.move(rel_names[:-1], rel_names[-1], after=after):
869
1085
                if not is_quiet():
870
1086
                    self.outf.write("%s => %s\n" % (src, dest))
871
1087
        else:
872
1088
            if len(names_list) != 2:
873
 
                raise errors.BzrCommandError('to mv multiple files the'
874
 
                                             ' destination must be a versioned'
875
 
                                             ' directory')
 
1089
                raise errors.CommandError(gettext('to mv multiple files the'
 
1090
                                                     ' destination must be a versioned'
 
1091
                                                     ' directory'))
876
1092
 
877
1093
            # for cicp file-systems: the src references an existing inventory
878
1094
            # item:
879
 
            src = tree.get_canonical_inventory_path(rel_names[0])
 
1095
            src = tree.get_canonical_path(rel_names[0])
880
1096
            # Find the canonical version of the destination:  In all cases, the
881
1097
            # parent of the target must be in the inventory, so we fetch the
882
1098
            # canonical version from there (we do not always *use* the
883
1099
            # canonicalized tail portion - we may be attempting to rename the
884
1100
            # case of the tail)
885
 
            canon_dest = tree.get_canonical_inventory_path(rel_names[1])
 
1101
            canon_dest = tree.get_canonical_path(rel_names[1])
886
1102
            dest_parent = osutils.dirname(canon_dest)
887
1103
            spec_tail = osutils.basename(rel_names[1])
888
1104
            # For a CICP file-system, we need to avoid creating 2 inventory
899
1115
                if after:
900
1116
                    # If 'after' is specified, the tail must refer to a file on disk.
901
1117
                    if dest_parent:
902
 
                        dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
 
1118
                        dest_parent_fq = osutils.pathjoin(
 
1119
                            tree.basedir, dest_parent)
903
1120
                    else:
904
1121
                        # pathjoin with an empty tail adds a slash, which breaks
905
1122
                        # relpath :(
906
1123
                        dest_parent_fq = tree.basedir
907
1124
 
908
1125
                    dest_tail = osutils.canonical_relpath(
909
 
                                    dest_parent_fq,
910
 
                                    osutils.pathjoin(dest_parent_fq, spec_tail))
 
1126
                        dest_parent_fq,
 
1127
                        osutils.pathjoin(dest_parent_fq, spec_tail))
911
1128
                else:
912
1129
                    # not 'after', so case as specified is used
913
1130
                    dest_tail = spec_tail
925
1142
    __doc__ = """Turn this branch into a mirror of another branch.
926
1143
 
927
1144
    By default, this command only works on branches that have not diverged.
928
 
    Branches are considered diverged if the destination branch's most recent 
929
 
    commit is one that has not been merged (directly or indirectly) into the 
 
1145
    Branches are considered diverged if the destination branch's most recent
 
1146
    commit is one that has not been merged (directly or indirectly) into the
930
1147
    parent.
931
1148
 
932
 
    If branches have diverged, you can use 'bzr merge' to integrate the changes
 
1149
    If branches have diverged, you can use 'brz merge' to integrate the changes
933
1150
    from one into the other.  Once one branch has merged, the other should
934
1151
    be able to pull it again.
935
1152
 
937
1154
    match the remote one, use pull --overwrite. This will work even if the two
938
1155
    branches have diverged.
939
1156
 
940
 
    If there is no default location set, the first pull will set it.  After
941
 
    that, you can omit the location to use the default.  To change the
942
 
    default, use --remember. The value will only be saved if the remote
943
 
    location can be accessed.
 
1157
    If there is no default location set, the first pull will set it (use
 
1158
    --no-remember to avoid setting it). After that, you can omit the
 
1159
    location to use the default.  To change the default, use --remember. The
 
1160
    value will only be saved if the remote location can be accessed.
 
1161
 
 
1162
    The --verbose option will display the revisions pulled using the log_format
 
1163
    configuration option. You can use a different format by overriding it with
 
1164
    -Olog_format=<other_format>.
944
1165
 
945
1166
    Note: The location can be specified either in the form of a branch,
946
1167
    or in the form of a path to a file containing a merge directive generated
947
 
    with bzr send.
 
1168
    with brz send.
948
1169
    """
949
1170
 
950
1171
    _see_also = ['push', 'update', 'status-flags', 'send']
951
1172
    takes_options = ['remember', 'overwrite', 'revision',
952
 
        custom_help('verbose',
953
 
            help='Show logs of pulled revisions.'),
954
 
        Option('directory',
955
 
            help='Branch to pull into, '
956
 
                 'rather than the one containing the working directory.',
957
 
            short_name='d',
958
 
            type=unicode,
959
 
            ),
960
 
        Option('local',
961
 
            help="Perform a local pull in a bound "
962
 
                 "branch.  Local pulls are not applied to "
963
 
                 "the master branch."
964
 
            ),
965
 
        ]
 
1173
                     custom_help('verbose',
 
1174
                                 help='Show logs of pulled revisions.'),
 
1175
                     custom_help('directory',
 
1176
                                 help='Branch to pull into, '
 
1177
                                 'rather than the one containing the working directory.'),
 
1178
                     Option('local',
 
1179
                            help="Perform a local pull in a bound "
 
1180
                            "branch.  Local pulls are not applied to "
 
1181
                            "the master branch."
 
1182
                            ),
 
1183
                     Option('show-base',
 
1184
                            help="Show base revision text in conflicts."),
 
1185
                     Option('overwrite-tags',
 
1186
                            help="Overwrite tags only."),
 
1187
                     ]
966
1188
    takes_args = ['location?']
967
1189
    encoding_type = 'replace'
968
1190
 
969
 
    def run(self, location=None, remember=False, overwrite=False,
 
1191
    def run(self, location=None, remember=None, overwrite=False,
970
1192
            revision=None, verbose=False,
971
 
            directory=None, local=False):
 
1193
            directory=None, local=False,
 
1194
            show_base=False, overwrite_tags=False):
 
1195
 
 
1196
        if overwrite:
 
1197
            overwrite = ["history", "tags"]
 
1198
        elif overwrite_tags:
 
1199
            overwrite = ["tags"]
 
1200
        else:
 
1201
            overwrite = []
972
1202
        # FIXME: too much stuff is in the command class
973
1203
        revision_id = None
974
1204
        mergeable = None
977
1207
        try:
978
1208
            tree_to = WorkingTree.open_containing(directory)[0]
979
1209
            branch_to = tree_to.branch
980
 
            self.add_cleanup(tree_to.lock_write().unlock)
 
1210
            self.enter_context(tree_to.lock_write())
981
1211
        except errors.NoWorkingTree:
982
1212
            tree_to = None
983
1213
            branch_to = Branch.open_containing(directory)[0]
984
 
            self.add_cleanup(branch_to.lock_write().unlock)
 
1214
            self.enter_context(branch_to.lock_write())
 
1215
            if show_base:
 
1216
                warning(gettext("No working tree, ignoring --show-base"))
985
1217
 
986
1218
        if local and not branch_to.get_bound_location():
987
1219
            raise errors.LocalRequiresBoundBranch()
989
1221
        possible_transports = []
990
1222
        if location is not None:
991
1223
            try:
992
 
                mergeable = bundle.read_mergeable_from_url(location,
993
 
                    possible_transports=possible_transports)
 
1224
                mergeable = _mod_mergeable.read_mergeable_from_url(
 
1225
                    location, possible_transports=possible_transports)
994
1226
            except errors.NotABundle:
995
1227
                mergeable = None
996
1228
 
997
1229
        stored_loc = branch_to.get_parent()
998
1230
        if location is None:
999
1231
            if stored_loc is None:
1000
 
                raise errors.BzrCommandError("No pull location known or"
1001
 
                                             " specified.")
 
1232
                raise errors.CommandError(gettext("No pull location known or"
 
1233
                                                     " specified."))
1002
1234
            else:
1003
1235
                display_url = urlutils.unescape_for_display(stored_loc,
1004
 
                        self.outf.encoding)
 
1236
                                                            self.outf.encoding)
1005
1237
                if not is_quiet():
1006
 
                    self.outf.write("Using saved parent location: %s\n" % display_url)
 
1238
                    self.outf.write(
 
1239
                        gettext("Using saved parent location: %s\n") % display_url)
1007
1240
                location = stored_loc
1008
1241
 
1009
1242
        revision = _get_one_revision('pull', revision)
1010
1243
        if mergeable is not None:
1011
1244
            if revision is not None:
1012
 
                raise errors.BzrCommandError(
1013
 
                    'Cannot use -r with merge directives or bundles')
 
1245
                raise errors.CommandError(gettext(
 
1246
                    'Cannot use -r with merge directives or bundles'))
1014
1247
            mergeable.install_revisions(branch_to.repository)
1015
1248
            base_revision_id, revision_id, verified = \
1016
1249
                mergeable.get_merge_request(branch_to.repository)
1017
1250
            branch_from = branch_to
1018
1251
        else:
1019
1252
            branch_from = Branch.open(location,
1020
 
                possible_transports=possible_transports)
1021
 
            self.add_cleanup(branch_from.lock_read().unlock)
1022
 
 
1023
 
            if branch_to.get_parent() is None or remember:
 
1253
                                      possible_transports=possible_transports)
 
1254
            self.enter_context(branch_from.lock_read())
 
1255
            # Remembers if asked explicitly or no previous location is set
 
1256
            if (remember
 
1257
                    or (remember is None and branch_to.get_parent() is None)):
 
1258
                # FIXME: This shouldn't be done before the pull
 
1259
                # succeeds... -- vila 2012-01-02
1024
1260
                branch_to.set_parent(branch_from.base)
1025
1261
 
1026
1262
        if revision is not None:
1033
1269
                view_info=view_info)
1034
1270
            result = tree_to.pull(
1035
1271
                branch_from, overwrite, revision_id, change_reporter,
1036
 
                possible_transports=possible_transports, local=local)
 
1272
                local=local, show_base=show_base)
1037
1273
        else:
1038
1274
            result = branch_to.pull(
1039
1275
                branch_from, overwrite, revision_id, local=local)
1043
1279
            log.show_branch_change(
1044
1280
                branch_to, self.outf, result.old_revno,
1045
1281
                result.old_revid)
 
1282
        if getattr(result, 'tag_conflicts', None):
 
1283
            return 1
 
1284
        else:
 
1285
            return 0
1046
1286
 
1047
1287
 
1048
1288
class cmd_push(Command):
1058
1298
    considered diverged if the destination branch's most recent commit is one
1059
1299
    that has not been merged (directly or indirectly) by the source branch.
1060
1300
 
1061
 
    If branches have diverged, you can use 'bzr push --overwrite' to replace
 
1301
    If branches have diverged, you can use 'brz push --overwrite' to replace
1062
1302
    the other branch completely, discarding its unmerged changes.
1063
1303
 
1064
1304
    If you want to ensure you have the different changes in the other branch,
1065
 
    do a merge (see bzr help merge) from the other branch, and commit that.
 
1305
    do a merge (see brz help merge) from the other branch, and commit that.
1066
1306
    After that you will be able to do a push without '--overwrite'.
1067
1307
 
1068
 
    If there is no default push location set, the first push will set it.
1069
 
    After that, you can omit the location to use the default.  To change the
1070
 
    default, use --remember. The value will only be saved if the remote
1071
 
    location can be accessed.
 
1308
    If there is no default push location set, the first push will set it (use
 
1309
    --no-remember to avoid setting it).  After that, you can omit the
 
1310
    location to use the default.  To change the default, use --remember. The
 
1311
    value will only be saved if the remote location can be accessed.
 
1312
 
 
1313
    The --verbose option will display the revisions pushed using the log_format
 
1314
    configuration option. You can use a different format by overriding it with
 
1315
    -Olog_format=<other_format>.
1072
1316
    """
1073
1317
 
1074
1318
    _see_also = ['pull', 'update', 'working-trees']
1075
1319
    takes_options = ['remember', 'overwrite', 'verbose', 'revision',
1076
 
        Option('create-prefix',
1077
 
               help='Create the path leading up to the branch '
1078
 
                    'if it does not already exist.'),
1079
 
        Option('directory',
1080
 
            help='Branch to push from, '
1081
 
                 'rather than the one containing the working directory.',
1082
 
            short_name='d',
1083
 
            type=unicode,
1084
 
            ),
1085
 
        Option('use-existing-dir',
1086
 
               help='By default push will fail if the target'
1087
 
                    ' directory exists, but does not already'
1088
 
                    ' have a control directory.  This flag will'
1089
 
                    ' allow push to proceed.'),
1090
 
        Option('stacked',
1091
 
            help='Create a stacked branch that references the public location '
1092
 
                'of the parent branch.'),
1093
 
        Option('stacked-on',
1094
 
            help='Create a stacked branch that refers to another branch '
1095
 
                'for the commit history. Only the work not present in the '
1096
 
                'referenced branch is included in the branch created.',
1097
 
            type=unicode),
1098
 
        Option('strict',
1099
 
               help='Refuse to push if there are uncommitted changes in'
1100
 
               ' the working tree, --no-strict disables the check.'),
1101
 
        ]
 
1320
                     Option('create-prefix',
 
1321
                            help='Create the path leading up to the branch '
 
1322
                            'if it does not already exist.'),
 
1323
                     custom_help('directory',
 
1324
                                 help='Branch to push from, '
 
1325
                                 'rather than the one containing the working directory.'),
 
1326
                     Option('use-existing-dir',
 
1327
                            help='By default push will fail if the target'
 
1328
                            ' directory exists, but does not already'
 
1329
                            ' have a control directory.  This flag will'
 
1330
                            ' allow push to proceed.'),
 
1331
                     Option('stacked',
 
1332
                            help='Create a stacked branch that references the public location '
 
1333
                            'of the parent branch.'),
 
1334
                     Option('stacked-on',
 
1335
                            help='Create a stacked branch that refers to another branch '
 
1336
                            'for the commit history. Only the work not present in the '
 
1337
                            'referenced branch is included in the branch created.',
 
1338
                            type=text_type),
 
1339
                     Option('strict',
 
1340
                            help='Refuse to push if there are uncommitted changes in'
 
1341
                            ' the working tree, --no-strict disables the check.'),
 
1342
                     Option('no-tree',
 
1343
                            help="Don't populate the working tree, even for protocols"
 
1344
                            " that support it."),
 
1345
                     Option('overwrite-tags',
 
1346
                            help="Overwrite tags only."),
 
1347
                     Option('lossy', help="Allow lossy push, i.e. dropping metadata "
 
1348
                            "that can't be represented in the target.")
 
1349
                     ]
1102
1350
    takes_args = ['location?']
1103
1351
    encoding_type = 'replace'
1104
1352
 
1105
 
    def run(self, location=None, remember=False, overwrite=False,
1106
 
        create_prefix=False, verbose=False, revision=None,
1107
 
        use_existing_dir=False, directory=None, stacked_on=None,
1108
 
        stacked=False, strict=None):
1109
 
        from bzrlib.push import _show_push_branch
 
1353
    def run(self, location=None, remember=None, overwrite=False,
 
1354
            create_prefix=False, verbose=False, revision=None,
 
1355
            use_existing_dir=False, directory=None, stacked_on=None,
 
1356
            stacked=False, strict=None, no_tree=False,
 
1357
            overwrite_tags=False, lossy=False):
 
1358
        from .location import location_to_url
 
1359
        from .push import _show_push_branch
 
1360
 
 
1361
        if overwrite:
 
1362
            overwrite = ["history", "tags"]
 
1363
        elif overwrite_tags:
 
1364
            overwrite = ["tags"]
 
1365
        else:
 
1366
            overwrite = []
1110
1367
 
1111
1368
        if directory is None:
1112
1369
            directory = '.'
1113
1370
        # Get the source branch
1114
1371
        (tree, br_from,
1115
 
         _unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
 
1372
         _unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1116
1373
        # Get the tip's revision_id
1117
1374
        revision = _get_one_revision('push', revision)
1118
1375
        if revision is not None:
1126
1383
                more_warning='Uncommitted changes will not be pushed.')
1127
1384
        # Get the stacked_on branch, if any
1128
1385
        if stacked_on is not None:
 
1386
            stacked_on = location_to_url(stacked_on, 'read')
1129
1387
            stacked_on = urlutils.normalize_url(stacked_on)
1130
1388
        elif stacked:
1131
1389
            parent_url = br_from.get_parent()
1139
1397
                    # error by the feedback given to them. RBC 20080227.
1140
1398
                    stacked_on = parent_url
1141
1399
            if not stacked_on:
1142
 
                raise errors.BzrCommandError(
1143
 
                    "Could not determine branch to refer to.")
 
1400
                raise errors.CommandError(gettext(
 
1401
                    "Could not determine branch to refer to."))
1144
1402
 
1145
1403
        # Get the destination location
1146
1404
        if location is None:
1147
1405
            stored_loc = br_from.get_push_location()
1148
1406
            if stored_loc is None:
1149
 
                raise errors.BzrCommandError(
1150
 
                    "No push location known or specified.")
 
1407
                parent_loc = br_from.get_parent()
 
1408
                if parent_loc:
 
1409
                    raise errors.CommandError(gettext(
 
1410
                        "No push location known or specified. To push to the "
 
1411
                        "parent branch (at %s), use 'brz push :parent'." %
 
1412
                        urlutils.unescape_for_display(parent_loc,
 
1413
                                                      self.outf.encoding)))
 
1414
                else:
 
1415
                    raise errors.CommandError(gettext(
 
1416
                        "No push location known or specified."))
1151
1417
            else:
1152
1418
                display_url = urlutils.unescape_for_display(stored_loc,
1153
 
                        self.outf.encoding)
1154
 
                self.outf.write("Using saved push location: %s\n" % display_url)
 
1419
                                                            self.outf.encoding)
 
1420
                note(gettext("Using saved push location: %s") % display_url)
1155
1421
                location = stored_loc
1156
1422
 
1157
1423
        _show_push_branch(br_from, revision_id, location, self.outf,
1158
 
            verbose=verbose, overwrite=overwrite, remember=remember,
1159
 
            stacked_on=stacked_on, create_prefix=create_prefix,
1160
 
            use_existing_dir=use_existing_dir)
 
1424
                          verbose=verbose, overwrite=overwrite, remember=remember,
 
1425
                          stacked_on=stacked_on, create_prefix=create_prefix,
 
1426
                          use_existing_dir=use_existing_dir, no_tree=no_tree,
 
1427
                          lossy=lossy)
1161
1428
 
1162
1429
 
1163
1430
class cmd_branch(Command):
1174
1441
    parameter, as in "branch foo/bar -r 5".
1175
1442
    """
1176
1443
 
 
1444
    aliase = ['sprout']
1177
1445
    _see_also = ['checkout']
1178
1446
    takes_args = ['from_location', 'to_location?']
1179
 
    takes_options = ['revision', Option('hardlink',
1180
 
        help='Hard-link working tree files where possible.'),
1181
 
        Option('no-tree',
1182
 
            help="Create a branch without a working-tree."),
1183
 
        Option('switch',
1184
 
            help="Switch the checkout in the current directory "
1185
 
                 "to the new branch."),
1186
 
        Option('stacked',
1187
 
            help='Create a stacked branch referring to the source branch. '
1188
 
                'The new branch will depend on the availability of the source '
1189
 
                'branch for all operations.'),
1190
 
        Option('standalone',
1191
 
               help='Do not use a shared repository, even if available.'),
1192
 
        Option('use-existing-dir',
1193
 
               help='By default branch will fail if the target'
1194
 
                    ' directory exists, but does not already'
1195
 
                    ' have a control directory.  This flag will'
1196
 
                    ' allow branch to proceed.'),
1197
 
        Option('bind',
1198
 
            help="Bind new branch to from location."),
1199
 
        ]
1200
 
    aliases = ['get', 'clone']
 
1447
    takes_options = ['revision',
 
1448
                     Option(
 
1449
                         'hardlink', help='Hard-link working tree files where possible.'),
 
1450
                     Option('files-from', type=text_type,
 
1451
                            help="Get file contents from this tree."),
 
1452
                     Option('no-tree',
 
1453
                            help="Create a branch without a working-tree."),
 
1454
                     Option('switch',
 
1455
                            help="Switch the checkout in the current directory "
 
1456
                            "to the new branch."),
 
1457
                     Option('stacked',
 
1458
                            help='Create a stacked branch referring to the source branch. '
 
1459
                            'The new branch will depend on the availability of the source '
 
1460
                            'branch for all operations.'),
 
1461
                     Option('standalone',
 
1462
                            help='Do not use a shared repository, even if available.'),
 
1463
                     Option('use-existing-dir',
 
1464
                            help='By default branch will fail if the target'
 
1465
                            ' directory exists, but does not already'
 
1466
                            ' have a control directory.  This flag will'
 
1467
                            ' allow branch to proceed.'),
 
1468
                     Option('bind',
 
1469
                            help="Bind new branch to from location."),
 
1470
                     Option('no-recurse-nested',
 
1471
                            help='Do not recursively check out nested trees.'),
 
1472
                     Option('colocated-branch', short_name='b',
 
1473
                            type=str, help='Name of colocated branch to sprout.'),
 
1474
                     ]
1201
1475
 
1202
1476
    def run(self, from_location, to_location=None, revision=None,
1203
1477
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1204
 
            use_existing_dir=False, switch=False, bind=False):
1205
 
        from bzrlib import switch as _mod_switch
1206
 
        from bzrlib.tag import _merge_tags_if_possible
1207
 
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
 
            from_location)
 
1478
            use_existing_dir=False, switch=False, bind=False,
 
1479
            files_from=None, no_recurse_nested=False, colocated_branch=None):
 
1480
        from breezy import switch as _mod_switch
 
1481
        accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
 
1482
            from_location, name=colocated_branch)
 
1483
        if no_recurse_nested:
 
1484
            recurse = 'none'
 
1485
        else:
 
1486
            recurse = 'down'
 
1487
        if not (hardlink or files_from):
 
1488
            # accelerator_tree is usually slower because you have to read N
 
1489
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1490
            # explicitly request it
 
1491
            accelerator_tree = None
 
1492
        if files_from is not None and files_from != from_location:
 
1493
            accelerator_tree = WorkingTree.open(files_from)
1209
1494
        revision = _get_one_revision('branch', revision)
1210
 
        self.add_cleanup(br_from.lock_read().unlock)
 
1495
        self.enter_context(br_from.lock_read())
1211
1496
        if revision is not None:
1212
1497
            revision_id = revision.as_revision_id(br_from)
1213
1498
        else:
1217
1502
            revision_id = br_from.last_revision()
1218
1503
        if to_location is None:
1219
1504
            to_location = urlutils.derive_to_location(from_location)
1220
 
        to_transport = transport.get_transport(to_location)
 
1505
        to_transport = transport.get_transport(to_location, purpose='write')
1221
1506
        try:
1222
1507
            to_transport.mkdir('.')
1223
1508
        except errors.FileExists:
1224
 
            if not use_existing_dir:
1225
 
                raise errors.BzrCommandError('Target directory "%s" '
1226
 
                    'already exists.' % to_location)
 
1509
            try:
 
1510
                to_dir = controldir.ControlDir.open_from_transport(
 
1511
                    to_transport)
 
1512
            except errors.NotBranchError:
 
1513
                if not use_existing_dir:
 
1514
                    raise errors.CommandError(gettext('Target directory "%s" '
 
1515
                                                         'already exists.') % to_location)
 
1516
                else:
 
1517
                    to_dir = None
1227
1518
            else:
1228
1519
                try:
1229
 
                    bzrdir.BzrDir.open_from_transport(to_transport)
 
1520
                    to_dir.open_branch()
1230
1521
                except errors.NotBranchError:
1231
1522
                    pass
1232
1523
                else:
1233
1524
                    raise errors.AlreadyBranchError(to_location)
1234
1525
        except errors.NoSuchFile:
1235
 
            raise errors.BzrCommandError('Parent of "%s" does not exist.'
 
1526
            raise errors.CommandError(gettext('Parent of "%s" does not exist.')
1236
1527
                                         % to_location)
1237
 
        try:
1238
 
            # preserve whatever source format we have.
1239
 
            dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1240
 
                                        possible_transports=[to_transport],
1241
 
                                        accelerator_tree=accelerator_tree,
1242
 
                                        hardlink=hardlink, stacked=stacked,
1243
 
                                        force_new_repo=standalone,
1244
 
                                        create_tree_if_local=not no_tree,
1245
 
                                        source_branch=br_from)
1246
 
            branch = dir.open_branch()
1247
 
        except errors.NoSuchRevision:
1248
 
            to_transport.delete_tree('.')
1249
 
            msg = "The branch %s has no revision %s." % (from_location,
1250
 
                revision)
1251
 
            raise errors.BzrCommandError(msg)
1252
 
        _merge_tags_if_possible(br_from, branch)
 
1528
        else:
 
1529
            to_dir = None
 
1530
        if to_dir is None:
 
1531
            try:
 
1532
                # preserve whatever source format we have.
 
1533
                to_dir = br_from.controldir.sprout(
 
1534
                    to_transport.base, revision_id,
 
1535
                    possible_transports=[to_transport],
 
1536
                    accelerator_tree=accelerator_tree, hardlink=hardlink,
 
1537
                    stacked=stacked, force_new_repo=standalone,
 
1538
                    create_tree_if_local=not no_tree, source_branch=br_from,
 
1539
                    recurse=recurse)
 
1540
                branch = to_dir.open_branch(
 
1541
                    possible_transports=[
 
1542
                        br_from.controldir.root_transport, to_transport])
 
1543
            except errors.NoSuchRevision:
 
1544
                to_transport.delete_tree('.')
 
1545
                msg = gettext("The branch {0} has no revision {1}.").format(
 
1546
                    from_location, revision)
 
1547
                raise errors.CommandError(msg)
 
1548
        else:
 
1549
            try:
 
1550
                to_repo = to_dir.open_repository()
 
1551
            except errors.NoRepositoryPresent:
 
1552
                to_repo = to_dir.create_repository()
 
1553
            to_repo.fetch(br_from.repository, revision_id=revision_id)
 
1554
            branch = br_from.sprout(
 
1555
                to_dir, revision_id=revision_id)
 
1556
        br_from.tags.merge_to(branch.tags)
 
1557
 
1253
1558
        # If the source branch is stacked, the new branch may
1254
1559
        # be stacked whether we asked for that explicitly or not.
1255
1560
        # We therefore need a try/except here and not just 'if stacked:'
1256
1561
        try:
1257
 
            note('Created new stacked branch referring to %s.' %
1258
 
                branch.get_stacked_on_url())
1259
 
        except (errors.NotStacked, errors.UnstackableBranchFormat,
1260
 
            errors.UnstackableRepositoryFormat), e:
1261
 
            note('Branched %d revision(s).' % branch.revno())
 
1562
            note(gettext('Created new stacked branch referring to %s.') %
 
1563
                 branch.get_stacked_on_url())
 
1564
        except (errors.NotStacked, _mod_branch.UnstackableBranchFormat,
 
1565
                errors.UnstackableRepositoryFormat) as e:
 
1566
            revno = branch.revno()
 
1567
            if revno is not None:
 
1568
                note(ngettext('Branched %d revision.',
 
1569
                              'Branched %d revisions.',
 
1570
                              branch.revno()) % revno)
 
1571
            else:
 
1572
                note(gettext('Created new branch.'))
1262
1573
        if bind:
1263
1574
            # Bind to the parent
1264
1575
            parent_branch = Branch.open(from_location)
1265
1576
            branch.bind(parent_branch)
1266
 
            note('New branch bound to %s' % from_location)
 
1577
            note(gettext('New branch bound to %s') % from_location)
1267
1578
        if switch:
1268
1579
            # Switch to the new branch
1269
1580
            wt, _ = WorkingTree.open_containing('.')
1270
 
            _mod_switch.switch(wt.bzrdir, branch)
1271
 
            note('Switched to branch: %s',
1272
 
                urlutils.unescape_for_display(branch.base, 'utf-8'))
 
1581
            _mod_switch.switch(wt.controldir, branch)
 
1582
            note(gettext('Switched to branch: %s'),
 
1583
                 urlutils.unescape_for_display(branch.base, 'utf-8'))
 
1584
 
 
1585
 
 
1586
class cmd_branches(Command):
 
1587
    __doc__ = """List the branches available at the current location.
 
1588
 
 
1589
    This command will print the names of all the branches at the current
 
1590
    location.
 
1591
    """
 
1592
 
 
1593
    takes_args = ['location?']
 
1594
    takes_options = [
 
1595
        Option('recursive', short_name='R',
 
1596
               help='Recursively scan for branches rather than '
 
1597
               'just looking in the specified location.')]
 
1598
 
 
1599
    def run(self, location=".", recursive=False):
 
1600
        if recursive:
 
1601
            t = transport.get_transport(location, purpose='read')
 
1602
            if not t.listable():
 
1603
                raise errors.CommandError(
 
1604
                    "Can't scan this type of location.")
 
1605
            for b in controldir.ControlDir.find_branches(t):
 
1606
                self.outf.write("%s\n" % urlutils.unescape_for_display(
 
1607
                    urlutils.relative_url(t.base, b.base),
 
1608
                    self.outf.encoding).rstrip("/"))
 
1609
        else:
 
1610
            dir = controldir.ControlDir.open_containing(location)[0]
 
1611
            try:
 
1612
                active_branch = dir.open_branch(name="")
 
1613
            except errors.NotBranchError:
 
1614
                active_branch = None
 
1615
            names = {}
 
1616
            for name, branch in iter_sibling_branches(dir):
 
1617
                if name == "":
 
1618
                    continue
 
1619
                active = (active_branch is not None and
 
1620
                          active_branch.user_url == branch.user_url)
 
1621
                names[name] = active
 
1622
            # Only mention the current branch explicitly if it's not
 
1623
            # one of the colocated branches
 
1624
            if not any(viewvalues(names)) and active_branch is not None:
 
1625
                self.outf.write("* %s\n" % gettext("(default)"))
 
1626
            for name in sorted(names):
 
1627
                active = names[name]
 
1628
                if active:
 
1629
                    prefix = "*"
 
1630
                else:
 
1631
                    prefix = " "
 
1632
                self.outf.write("%s %s\n" % (
 
1633
                    prefix, (name if PY3 else name.encode(self.outf.encoding))))
1273
1634
 
1274
1635
 
1275
1636
class cmd_checkout(Command):
1276
1637
    __doc__ = """Create a new checkout of an existing branch.
1277
1638
 
1278
 
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1279
 
    the branch found in '.'. This is useful if you have removed the working tree
1280
 
    or if it was never created - i.e. if you pushed the branch to its current
1281
 
    location using SFTP.
 
1639
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree
 
1640
    for the branch found in '.'. This is useful if you have removed the working
 
1641
    tree or if it was never created - i.e. if you pushed the branch to its
 
1642
    current location using SFTP.
1282
1643
 
1283
 
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
1284
 
    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
1285
 
    If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
1286
 
    is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
1287
 
    identifier, if any. For example, "checkout lp:foo-bar" will attempt to
1288
 
    create ./foo-bar.
 
1644
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION
 
1645
    will be used.  In other words, "checkout ../foo/bar" will attempt to create
 
1646
    ./bar.  If the BRANCH_LOCATION has no / or path separator embedded, the
 
1647
    TO_LOCATION is derived from the BRANCH_LOCATION by stripping a leading
 
1648
    scheme or drive identifier, if any. For example, "checkout lp:foo-bar" will
 
1649
    attempt to create ./foo-bar.
1289
1650
 
1290
1651
    To retrieve the branch as of a particular revision, supply the --revision
1291
 
    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
1292
 
    out of date [so you cannot commit] but it may be useful (i.e. to examine old
1293
 
    code.)
 
1652
    parameter, as in "checkout foo/bar -r 5". Note that this will be
 
1653
    immediately out of date [so you cannot commit] but it may be useful (i.e.
 
1654
    to examine old code.)
1294
1655
    """
1295
1656
 
1296
 
    _see_also = ['checkouts', 'branch']
 
1657
    _see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1297
1658
    takes_args = ['branch_location?', 'to_location?']
1298
1659
    takes_options = ['revision',
1299
1660
                     Option('lightweight',
1303
1664
                                 "common operations like diff and status without "
1304
1665
                                 "such access, and also support local commits."
1305
1666
                            ),
1306
 
                     Option('files-from', type=str,
 
1667
                     Option('files-from', type=text_type,
1307
1668
                            help="Get file contents from this tree."),
1308
1669
                     Option('hardlink',
1309
1670
                            help='Hard-link working tree files where possible.'
1316
1677
        if branch_location is None:
1317
1678
            branch_location = osutils.getcwd()
1318
1679
            to_location = branch_location
1319
 
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
 
1680
        accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1320
1681
            branch_location)
 
1682
        if not (hardlink or files_from):
 
1683
            # accelerator_tree is usually slower because you have to read N
 
1684
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1685
            # explicitly request it
 
1686
            accelerator_tree = None
1321
1687
        revision = _get_one_revision('checkout', revision)
1322
 
        if files_from is not None:
 
1688
        if files_from is not None and files_from != branch_location:
1323
1689
            accelerator_tree = WorkingTree.open(files_from)
1324
1690
        if revision is not None:
1325
1691
            revision_id = revision.as_revision_id(source)
1330
1696
        # if the source and to_location are the same,
1331
1697
        # and there is no working tree,
1332
1698
        # then reconstitute a branch
1333
 
        if (osutils.abspath(to_location) ==
1334
 
            osutils.abspath(branch_location)):
 
1699
        if osutils.abspath(to_location) == osutils.abspath(branch_location):
1335
1700
            try:
1336
 
                source.bzrdir.open_workingtree()
 
1701
                source.controldir.open_workingtree()
1337
1702
            except errors.NoWorkingTree:
1338
 
                source.bzrdir.create_workingtree(revision_id)
 
1703
                source.controldir.create_workingtree(revision_id)
1339
1704
                return
1340
1705
        source.create_checkout(to_location, revision_id, lightweight,
1341
1706
                               accelerator_tree, hardlink)
1342
1707
 
1343
1708
 
 
1709
class cmd_clone(Command):
 
1710
    __doc__ = """Clone a control directory.
 
1711
    """
 
1712
 
 
1713
    takes_args = ['from_location', 'to_location?']
 
1714
    takes_options = ['revision',
 
1715
                     Option('no-recurse-nested',
 
1716
                            help='Do not recursively check out nested trees.'),
 
1717
                     ]
 
1718
 
 
1719
    def run(self, from_location, to_location=None, revision=None, no_recurse_nested=False):
 
1720
        accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
 
1721
            from_location)
 
1722
        if no_recurse_nested:
 
1723
            recurse = 'none'
 
1724
        else:
 
1725
            recurse = 'down'
 
1726
        revision = _get_one_revision('branch', revision)
 
1727
        self.enter_context(br_from.lock_read())
 
1728
        if revision is not None:
 
1729
            revision_id = revision.as_revision_id(br_from)
 
1730
        else:
 
1731
            # FIXME - wt.last_revision, fallback to branch, fall back to
 
1732
            # None or perhaps NULL_REVISION to mean copy nothing
 
1733
            # RBC 20060209
 
1734
            revision_id = br_from.last_revision()
 
1735
        if to_location is None:
 
1736
            to_location = urlutils.derive_to_location(from_location)
 
1737
        target_controldir = br_from.controldir.clone(to_location, revision_id=revision_id)
 
1738
        note(gettext('Created new control directory.'))
 
1739
 
 
1740
 
1344
1741
class cmd_renames(Command):
1345
1742
    __doc__ = """Show list of renamed files.
1346
1743
    """
1353
1750
    @display_command
1354
1751
    def run(self, dir=u'.'):
1355
1752
        tree = WorkingTree.open_containing(dir)[0]
1356
 
        self.add_cleanup(tree.lock_read().unlock)
1357
 
        new_inv = tree.inventory
 
1753
        self.enter_context(tree.lock_read())
1358
1754
        old_tree = tree.basis_tree()
1359
 
        self.add_cleanup(old_tree.lock_read().unlock)
1360
 
        old_inv = old_tree.inventory
 
1755
        self.enter_context(old_tree.lock_read())
1361
1756
        renames = []
1362
1757
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1363
 
        for f, paths, c, v, p, n, k, e in iterator:
1364
 
            if paths[0] == paths[1]:
1365
 
                continue
1366
 
            if None in (paths):
1367
 
                continue
1368
 
            renames.append(paths)
 
1758
        for change in iterator:
 
1759
            if change.path[0] == change.path[1]:
 
1760
                continue
 
1761
            if None in change.path:
 
1762
                continue
 
1763
            renames.append(change.path)
1369
1764
        renames.sort()
1370
1765
        for old_name, new_name in renames:
1371
1766
            self.outf.write("%s => %s\n" % (old_name, new_name))
1372
1767
 
1373
1768
 
1374
1769
class cmd_update(Command):
1375
 
    __doc__ = """Update a tree to have the latest code committed to its branch.
1376
 
 
1377
 
    This will perform a merge into the working tree, and may generate
1378
 
    conflicts. If you have any local changes, you will still
1379
 
    need to commit them after the update for the update to be complete.
1380
 
 
1381
 
    If you want to discard your local changes, you can just do a
1382
 
    'bzr revert' instead of 'bzr commit' after the update.
1383
 
 
1384
 
    If the tree's branch is bound to a master branch, it will also update
 
1770
    __doc__ = """Update a working tree to a new revision.
 
1771
 
 
1772
    This will perform a merge of the destination revision (the tip of the
 
1773
    branch, or the specified revision) into the working tree, and then make
 
1774
    that revision the basis revision for the working tree.
 
1775
 
 
1776
    You can use this to visit an older revision, or to update a working tree
 
1777
    that is out of date from its branch.
 
1778
 
 
1779
    If there are any uncommitted changes in the tree, they will be carried
 
1780
    across and remain as uncommitted changes after the update.  To discard
 
1781
    these changes, use 'brz revert'.  The uncommitted changes may conflict
 
1782
    with the changes brought in by the change in basis revision.
 
1783
 
 
1784
    If the tree's branch is bound to a master branch, brz will also update
1385
1785
    the branch from the master.
 
1786
 
 
1787
    You cannot update just a single file or directory, because each Breezy
 
1788
    working tree has just a single basis revision.  If you want to restore a
 
1789
    file that has been removed locally, use 'brz revert' instead of 'brz
 
1790
    update'.  If you want to restore a file to its state in a previous
 
1791
    revision, use 'brz revert' with a '-r' option, or use 'brz cat' to write
 
1792
    out the old content of that file to a new location.
 
1793
 
 
1794
    The 'dir' argument, if given, must be the location of the root of a
 
1795
    working tree to update.  By default, the working tree that contains the
 
1796
    current working directory is used.
1386
1797
    """
1387
1798
 
1388
1799
    _see_also = ['pull', 'working-trees', 'status-flags']
1389
1800
    takes_args = ['dir?']
1390
 
    takes_options = ['revision']
 
1801
    takes_options = ['revision',
 
1802
                     Option('show-base',
 
1803
                            help="Show base revision text in conflicts."),
 
1804
                     ]
1391
1805
    aliases = ['up']
1392
1806
 
1393
 
    def run(self, dir='.', revision=None):
 
1807
    def run(self, dir=None, revision=None, show_base=None):
1394
1808
        if revision is not None and len(revision) != 1:
1395
 
            raise errors.BzrCommandError(
1396
 
                        "bzr update --revision takes exactly one revision")
1397
 
        tree = WorkingTree.open_containing(dir)[0]
 
1809
            raise errors.CommandError(gettext(
 
1810
                "brz update --revision takes exactly one revision"))
 
1811
        if dir is None:
 
1812
            tree = WorkingTree.open_containing('.')[0]
 
1813
        else:
 
1814
            tree, relpath = WorkingTree.open_containing(dir)
 
1815
            if relpath:
 
1816
                # See bug 557886.
 
1817
                raise errors.CommandError(gettext(
 
1818
                    "brz update can only update a whole tree, "
 
1819
                    "not a file or subdirectory"))
1398
1820
        branch = tree.branch
1399
1821
        possible_transports = []
1400
1822
        master = branch.get_master_branch(
1401
1823
            possible_transports=possible_transports)
1402
1824
        if master is not None:
1403
1825
            branch_location = master.base
1404
 
            tree.lock_write()
 
1826
            self.enter_context(tree.lock_write())
1405
1827
        else:
1406
1828
            branch_location = tree.branch.base
1407
 
            tree.lock_tree_write()
1408
 
        self.add_cleanup(tree.unlock)
 
1829
            self.enter_context(tree.lock_tree_write())
1409
1830
        # get rid of the final '/' and be ready for display
1410
1831
        branch_location = urlutils.unescape_for_display(
1411
1832
            branch_location.rstrip('/'),
1424
1845
            revision_id = branch.last_revision()
1425
1846
        if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1426
1847
            revno = branch.revision_id_to_dotted_revno(revision_id)
1427
 
            note("Tree is up to date at revision %s of branch %s" %
1428
 
                ('.'.join(map(str, revno)), branch_location))
 
1848
            note(gettext("Tree is up to date at revision {0} of branch {1}"
 
1849
                         ).format('.'.join(map(str, revno)), branch_location))
1429
1850
            return 0
1430
1851
        view_info = _get_view_info_for_change_reporter(tree)
1431
1852
        change_reporter = delta._ChangeReporter(
1436
1857
                change_reporter,
1437
1858
                possible_transports=possible_transports,
1438
1859
                revision=revision_id,
1439
 
                old_tip=old_tip)
1440
 
        except errors.NoSuchRevision, e:
1441
 
            raise errors.BzrCommandError(
1442
 
                                  "branch has no revision %s\n"
1443
 
                                  "bzr update --revision only works"
1444
 
                                  " for a revision in the branch history"
1445
 
                                  % (e.revision))
 
1860
                old_tip=old_tip,
 
1861
                show_base=show_base)
 
1862
        except errors.NoSuchRevision as e:
 
1863
            raise errors.CommandError(gettext(
 
1864
                "branch has no revision %s\n"
 
1865
                "brz update --revision only works"
 
1866
                " for a revision in the branch history")
 
1867
                % (e.revision))
1446
1868
        revno = tree.branch.revision_id_to_dotted_revno(
1447
1869
            _mod_revision.ensure_null(tree.last_revision()))
1448
 
        note('Updated to revision %s of branch %s' %
1449
 
             ('.'.join(map(str, revno)), branch_location))
 
1870
        note(gettext('Updated to revision {0} of branch {1}').format(
 
1871
             '.'.join(map(str, revno)), branch_location))
1450
1872
        parent_ids = tree.get_parent_ids()
1451
1873
        if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1452
 
            note('Your local commits will now show as pending merges with '
1453
 
                 "'bzr status', and can be committed with 'bzr commit'.")
 
1874
            note(gettext('Your local commits will now show as pending merges with '
 
1875
                         "'brz status', and can be committed with 'brz commit'."))
1454
1876
        if conflicts != 0:
1455
1877
            return 1
1456
1878
        else:
1473
1895
 
1474
1896
      Display information on the format and related locations:
1475
1897
 
1476
 
        bzr info
 
1898
        brz info
1477
1899
 
1478
1900
      Display the above together with extended format information and
1479
1901
      basic statistics (like the number of files in the working tree and
1480
1902
      number of revisions in the branch and repository):
1481
1903
 
1482
 
        bzr info -v
 
1904
        brz info -v
1483
1905
 
1484
1906
      Display the above together with number of committers to the branch:
1485
1907
 
1486
 
        bzr info -vv
 
1908
        brz info -vv
1487
1909
    """
1488
1910
    _see_also = ['revno', 'working-trees', 'repositories']
1489
1911
    takes_args = ['location?']
1496
1918
            noise_level = get_verbosity_level()
1497
1919
        else:
1498
1920
            noise_level = 0
1499
 
        from bzrlib.info import show_bzrdir_info
1500
 
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
 
1921
        from .info import show_bzrdir_info
 
1922
        show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1501
1923
                         verbose=noise_level, outfile=self.outf)
1502
1924
 
1503
1925
 
1504
1926
class cmd_remove(Command):
1505
1927
    __doc__ = """Remove files or directories.
1506
1928
 
1507
 
    This makes bzr stop tracking changes to the specified files. bzr will delete
1508
 
    them if they can easily be recovered using revert. If no options or
1509
 
    parameters are given bzr will scan for files that are being tracked by bzr
1510
 
    but missing in your tree and stop tracking them for you.
 
1929
    This makes Breezy stop tracking changes to the specified files. Breezy will
 
1930
    delete them if they can easily be recovered using revert otherwise they
 
1931
    will be backed up (adding an extension of the form .~#~). If no options or
 
1932
    parameters are given Breezy will scan for files that are being tracked by
 
1933
    Breezy but missing in your tree and stop tracking them for you.
1511
1934
    """
1512
1935
    takes_args = ['file*']
1513
1936
    takes_options = ['verbose',
1514
 
        Option('new', help='Only remove files that have never been committed.'),
1515
 
        RegistryOption.from_kwargs('file-deletion-strategy',
1516
 
            'The file deletion mode to be used.',
1517
 
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1518
 
            safe='Only delete files if they can be'
1519
 
                 ' safely recovered (default).',
1520
 
            keep='Delete from bzr but leave the working copy.',
1521
 
            force='Delete all the specified files, even if they can not be '
1522
 
                'recovered and even if they are non-empty directories.')]
 
1937
                     Option(
 
1938
                         'new', help='Only remove files that have never been committed.'),
 
1939
                     RegistryOption.from_kwargs('file-deletion-strategy',
 
1940
                                                'The file deletion mode to be used.',
 
1941
                                                title='Deletion Strategy', value_switches=True, enum_switch=False,
 
1942
                                                safe='Backup changed files (default).',
 
1943
                                                keep='Delete from brz but leave the working copy.',
 
1944
                                                no_backup='Don\'t backup changed files.'),
 
1945
                     ]
1523
1946
    aliases = ['rm', 'del']
1524
1947
    encoding_type = 'replace'
1525
1948
 
1526
1949
    def run(self, file_list, verbose=False, new=False,
1527
 
        file_deletion_strategy='safe'):
1528
 
        tree, file_list = tree_files(file_list)
 
1950
            file_deletion_strategy='safe'):
 
1951
 
 
1952
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1529
1953
 
1530
1954
        if file_list is not None:
1531
1955
            file_list = [f for f in file_list]
1532
1956
 
1533
 
        self.add_cleanup(tree.lock_write().unlock)
 
1957
        self.enter_context(tree.lock_write())
1534
1958
        # Heuristics should probably all move into tree.remove_smart or
1535
1959
        # some such?
1536
1960
        if new:
1537
1961
            added = tree.changes_from(tree.basis_tree(),
1538
 
                specific_files=file_list).added
1539
 
            file_list = sorted([f[0] for f in added], reverse=True)
 
1962
                                      specific_files=file_list).added
 
1963
            file_list = sorted([f.path[1] for f in added], reverse=True)
1540
1964
            if len(file_list) == 0:
1541
 
                raise errors.BzrCommandError('No matching files.')
 
1965
                raise errors.CommandError(gettext('No matching files.'))
1542
1966
        elif file_list is None:
1543
1967
            # missing files show up in iter_changes(basis) as
1544
1968
            # versioned-with-no-kind.
1545
1969
            missing = []
1546
1970
            for change in tree.iter_changes(tree.basis_tree()):
1547
1971
                # Find paths in the working tree that have no kind:
1548
 
                if change[1][1] is not None and change[6][1] is None:
1549
 
                    missing.append(change[1][1])
 
1972
                if change.path[1] is not None and change.kind[1] is None:
 
1973
                    missing.append(change.path[1])
1550
1974
            file_list = sorted(missing, reverse=True)
1551
1975
            file_deletion_strategy = 'keep'
1552
1976
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1553
 
            keep_files=file_deletion_strategy=='keep',
1554
 
            force=file_deletion_strategy=='force')
1555
 
 
1556
 
 
1557
 
class cmd_file_id(Command):
1558
 
    __doc__ = """Print file_id of a particular file or directory.
1559
 
 
1560
 
    The file_id is assigned when the file is first added and remains the
1561
 
    same through all revisions where the file exists, even when it is
1562
 
    moved or renamed.
1563
 
    """
1564
 
 
1565
 
    hidden = True
1566
 
    _see_also = ['inventory', 'ls']
1567
 
    takes_args = ['filename']
1568
 
 
1569
 
    @display_command
1570
 
    def run(self, filename):
1571
 
        tree, relpath = WorkingTree.open_containing(filename)
1572
 
        i = tree.path2id(relpath)
1573
 
        if i is None:
1574
 
            raise errors.NotVersionedError(filename)
1575
 
        else:
1576
 
            self.outf.write(i + '\n')
1577
 
 
1578
 
 
1579
 
class cmd_file_path(Command):
1580
 
    __doc__ = """Print path of file_ids to a file or directory.
1581
 
 
1582
 
    This prints one line for each directory down to the target,
1583
 
    starting at the branch root.
1584
 
    """
1585
 
 
1586
 
    hidden = True
1587
 
    takes_args = ['filename']
1588
 
 
1589
 
    @display_command
1590
 
    def run(self, filename):
1591
 
        tree, relpath = WorkingTree.open_containing(filename)
1592
 
        fid = tree.path2id(relpath)
1593
 
        if fid is None:
1594
 
            raise errors.NotVersionedError(filename)
1595
 
        segments = osutils.splitpath(relpath)
1596
 
        for pos in range(1, len(segments) + 1):
1597
 
            path = osutils.joinpath(segments[:pos])
1598
 
            self.outf.write("%s\n" % tree.path2id(path))
 
1977
                    keep_files=file_deletion_strategy == 'keep',
 
1978
                    force=(file_deletion_strategy == 'no-backup'))
1599
1979
 
1600
1980
 
1601
1981
class cmd_reconcile(Command):
1602
 
    __doc__ = """Reconcile bzr metadata in a branch.
 
1982
    __doc__ = """Reconcile brz metadata in a branch.
1603
1983
 
1604
1984
    This can correct data mismatches that may have been caused by
1605
 
    previous ghost operations or bzr upgrades. You should only
1606
 
    need to run this command if 'bzr check' or a bzr developer
 
1985
    previous ghost operations or brz upgrades. You should only
 
1986
    need to run this command if 'brz check' or a brz developer
1607
1987
    advises you to run it.
1608
1988
 
1609
1989
    If a second branch is provided, cross-branch reconciliation is
1610
1990
    also attempted, which will check that data like the tree root
1611
 
    id which was not present in very early bzr versions is represented
 
1991
    id which was not present in very early brz versions is represented
1612
1992
    correctly in both branches.
1613
1993
 
1614
1994
    At the same time it is run it may recompress data resulting in
1619
1999
 
1620
2000
    _see_also = ['check']
1621
2001
    takes_args = ['branch?']
 
2002
    takes_options = [
 
2003
        Option('canonicalize-chks',
 
2004
               help='Make sure CHKs are in canonical form (repairs '
 
2005
                    'bug 522637).',
 
2006
               hidden=True),
 
2007
        ]
1622
2008
 
1623
 
    def run(self, branch="."):
1624
 
        from bzrlib.reconcile import reconcile
1625
 
        dir = bzrdir.BzrDir.open(branch)
1626
 
        reconcile(dir)
 
2009
    def run(self, branch=".", canonicalize_chks=False):
 
2010
        from .reconcile import reconcile
 
2011
        dir = controldir.ControlDir.open(branch)
 
2012
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1627
2013
 
1628
2014
 
1629
2015
class cmd_revision_history(Command):
1637
2023
    @display_command
1638
2024
    def run(self, location="."):
1639
2025
        branch = Branch.open_containing(location)[0]
1640
 
        for revid in branch.revision_history():
 
2026
        self.enter_context(branch.lock_read())
 
2027
        graph = branch.repository.get_graph()
 
2028
        history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
 
2029
                                                    [_mod_revision.NULL_REVISION]))
 
2030
        for revid in reversed(history):
1641
2031
            self.outf.write(revid)
1642
2032
            self.outf.write('\n')
1643
2033
 
1661
2051
            b = wt.branch
1662
2052
            last_revision = wt.last_revision()
1663
2053
 
1664
 
        revision_ids = b.repository.get_ancestry(last_revision)
1665
 
        revision_ids.pop(0)
1666
 
        for revision_id in revision_ids:
1667
 
            self.outf.write(revision_id + '\n')
 
2054
        self.enter_context(b.repository.lock_read())
 
2055
        graph = b.repository.get_graph()
 
2056
        revisions = [revid for revid, parents in
 
2057
                     graph.iter_ancestry([last_revision])]
 
2058
        for revision_id in reversed(revisions):
 
2059
            if _mod_revision.is_null(revision_id):
 
2060
                continue
 
2061
            self.outf.write(revision_id.decode('utf-8') + '\n')
1668
2062
 
1669
2063
 
1670
2064
class cmd_init(Command):
1679
2073
    in the .bzr directory.
1680
2074
 
1681
2075
    If there is already a branch at the location but it has no working tree,
1682
 
    the tree can be populated with 'bzr checkout'.
 
2076
    the tree can be populated with 'brz checkout'.
1683
2077
 
1684
2078
    Recipe for importing a tree of files::
1685
2079
 
1686
2080
        cd ~/project
1687
 
        bzr init
1688
 
        bzr add .
1689
 
        bzr status
1690
 
        bzr commit -m "imported project"
 
2081
        brz init
 
2082
        brz add .
 
2083
        brz status
 
2084
        brz commit -m "imported project"
1691
2085
    """
1692
2086
 
1693
 
    _see_also = ['init-repository', 'branch', 'checkout']
 
2087
    _see_also = ['init-shared-repository', 'branch', 'checkout']
1694
2088
    takes_args = ['location?']
1695
2089
    takes_options = [
1696
2090
        Option('create-prefix',
1697
2091
               help='Create the path leading up to the branch '
1698
2092
                    'if it does not already exist.'),
1699
 
         RegistryOption('format',
1700
 
                help='Specify a format for this branch. '
1701
 
                'See "help formats".',
1702
 
                lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1703
 
                converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1704
 
                value_switches=True,
1705
 
                title="Branch format",
1706
 
                ),
1707
 
         Option('append-revisions-only',
1708
 
                help='Never change revnos or the existing log.'
1709
 
                '  Append revisions to it only.')
1710
 
         ]
 
2093
        RegistryOption('format',
 
2094
                       help='Specify a format for this branch. '
 
2095
                       'See "help formats" for a full list.',
 
2096
                       lazy_registry=('breezy.controldir', 'format_registry'),
 
2097
                       converter=lambda name: controldir.format_registry.make_controldir(
 
2098
                            name),
 
2099
                       value_switches=True,
 
2100
                       title="Branch format",
 
2101
                       ),
 
2102
        Option('append-revisions-only',
 
2103
               help='Never change revnos or the existing log.'
 
2104
               '  Append revisions to it only.'),
 
2105
        Option('no-tree',
 
2106
               'Create a branch without a working tree.')
 
2107
        ]
 
2108
 
1711
2109
    def run(self, location=None, format=None, append_revisions_only=False,
1712
 
            create_prefix=False):
 
2110
            create_prefix=False, no_tree=False):
1713
2111
        if format is None:
1714
 
            format = bzrdir.format_registry.make_bzrdir('default')
 
2112
            format = controldir.format_registry.make_controldir('default')
1715
2113
        if location is None:
1716
2114
            location = u'.'
1717
2115
 
1718
 
        to_transport = transport.get_transport(location)
 
2116
        to_transport = transport.get_transport(location, purpose='write')
1719
2117
 
1720
2118
        # The path has to exist to initialize a
1721
2119
        # branch inside of it.
1726
2124
            to_transport.ensure_base()
1727
2125
        except errors.NoSuchFile:
1728
2126
            if not create_prefix:
1729
 
                raise errors.BzrCommandError("Parent directory of %s"
1730
 
                    " does not exist."
1731
 
                    "\nYou may supply --create-prefix to create all"
1732
 
                    " leading parent directories."
1733
 
                    % location)
 
2127
                raise errors.CommandError(gettext("Parent directory of %s"
 
2128
                                                     " does not exist."
 
2129
                                                     "\nYou may supply --create-prefix to create all"
 
2130
                                                     " leading parent directories.")
 
2131
                                             % location)
1734
2132
            to_transport.create_prefix()
1735
2133
 
1736
2134
        try:
1737
 
            a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
 
2135
            a_controldir = controldir.ControlDir.open_from_transport(
 
2136
                to_transport)
1738
2137
        except errors.NotBranchError:
1739
2138
            # really a NotBzrDir error...
1740
 
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
2139
            create_branch = controldir.ControlDir.create_branch_convenience
 
2140
            if no_tree:
 
2141
                force_new_tree = False
 
2142
            else:
 
2143
                force_new_tree = None
1741
2144
            branch = create_branch(to_transport.base, format=format,
1742
 
                                   possible_transports=[to_transport])
1743
 
            a_bzrdir = branch.bzrdir
 
2145
                                   possible_transports=[to_transport],
 
2146
                                   force_new_tree=force_new_tree)
 
2147
            a_controldir = branch.controldir
1744
2148
        else:
1745
 
            from bzrlib.transport.local import LocalTransport
1746
 
            if a_bzrdir.has_branch():
 
2149
            from .transport.local import LocalTransport
 
2150
            if a_controldir.has_branch():
1747
2151
                if (isinstance(to_transport, LocalTransport)
1748
 
                    and not a_bzrdir.has_workingtree()):
1749
 
                        raise errors.BranchExistsWithoutWorkingTree(location)
 
2152
                        and not a_controldir.has_workingtree()):
 
2153
                    raise errors.BranchExistsWithoutWorkingTree(location)
1750
2154
                raise errors.AlreadyBranchError(location)
1751
 
            branch = a_bzrdir.create_branch()
1752
 
            a_bzrdir.create_workingtree()
 
2155
            branch = a_controldir.create_branch()
 
2156
            if not no_tree and not a_controldir.has_workingtree():
 
2157
                a_controldir.create_workingtree()
1753
2158
        if append_revisions_only:
1754
2159
            try:
1755
2160
                branch.set_append_revisions_only(True)
1756
2161
            except errors.UpgradeRequired:
1757
 
                raise errors.BzrCommandError('This branch format cannot be set'
1758
 
                    ' to append-revisions-only.  Try --default.')
 
2162
                raise errors.CommandError(gettext('This branch format cannot be set'
 
2163
                                                     ' to append-revisions-only.  Try --default.'))
1759
2164
        if not is_quiet():
1760
 
            from bzrlib.info import describe_layout, describe_format
 
2165
            from .info import describe_layout, describe_format
1761
2166
            try:
1762
 
                tree = a_bzrdir.open_workingtree(recommend_upgrade=False)
 
2167
                tree = a_controldir.open_workingtree(recommend_upgrade=False)
1763
2168
            except (errors.NoWorkingTree, errors.NotLocalUrl):
1764
2169
                tree = None
1765
2170
            repository = branch.repository
1766
2171
            layout = describe_layout(repository, branch, tree).lower()
1767
 
            format = describe_format(a_bzrdir, repository, branch, tree)
1768
 
            self.outf.write("Created a %s (format: %s)\n" % (layout, format))
 
2172
            format = describe_format(a_controldir, repository, branch, tree)
 
2173
            self.outf.write(gettext("Created a {0} (format: {1})\n").format(
 
2174
                layout, format))
1769
2175
            if repository.is_shared():
1770
 
                #XXX: maybe this can be refactored into transport.path_or_url()
1771
 
                url = repository.bzrdir.root_transport.external_url()
 
2176
                # XXX: maybe this can be refactored into transport.path_or_url()
 
2177
                url = repository.controldir.root_transport.external_url()
1772
2178
                try:
1773
2179
                    url = urlutils.local_path_from_url(url)
1774
 
                except errors.InvalidURL:
 
2180
                except urlutils.InvalidURL:
1775
2181
                    pass
1776
 
                self.outf.write("Using shared repository: %s\n" % url)
1777
 
 
1778
 
 
1779
 
class cmd_init_repository(Command):
 
2182
                self.outf.write(gettext("Using shared repository: %s\n") % url)
 
2183
 
 
2184
 
 
2185
class cmd_init_shared_repository(Command):
1780
2186
    __doc__ = """Create a shared repository for branches to share storage space.
1781
2187
 
1782
2188
    New branches created under the repository directory will store their
1783
2189
    revisions in the repository, not in the branch directory.  For branches
1784
 
    with shared history, this reduces the amount of storage needed and 
 
2190
    with shared history, this reduces the amount of storage needed and
1785
2191
    speeds up the creation of new branches.
1786
2192
 
1787
2193
    If the --no-trees option is given then the branches in the repository
1788
 
    will not have working trees by default.  They will still exist as 
1789
 
    directories on disk, but they will not have separate copies of the 
 
2194
    will not have working trees by default.  They will still exist as
 
2195
    directories on disk, but they will not have separate copies of the
1790
2196
    files at a certain revision.  This can be useful for repositories that
1791
2197
    store branches which are interacted with through checkouts or remote
1792
2198
    branches, such as on a server.
1794
2200
    :Examples:
1795
2201
        Create a shared repository holding just branches::
1796
2202
 
1797
 
            bzr init-repo --no-trees repo
1798
 
            bzr init repo/trunk
 
2203
            brz init-shared-repo --no-trees repo
 
2204
            brz init repo/trunk
1799
2205
 
1800
2206
        Make a lightweight checkout elsewhere::
1801
2207
 
1802
 
            bzr checkout --lightweight repo/trunk trunk-checkout
 
2208
            brz checkout --lightweight repo/trunk trunk-checkout
1803
2209
            cd trunk-checkout
1804
2210
            (add files here)
1805
2211
    """
1807
2213
    _see_also = ['init', 'branch', 'checkout', 'repositories']
1808
2214
    takes_args = ["location"]
1809
2215
    takes_options = [RegistryOption('format',
1810
 
                            help='Specify a format for this repository. See'
1811
 
                                 ' "bzr help formats" for details.',
1812
 
                            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1813
 
                            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1814
 
                            value_switches=True, title='Repository format'),
 
2216
                                    help='Specify a format for this repository. See'
 
2217
                                    ' "brz help formats" for details.',
 
2218
                                    lazy_registry=(
 
2219
                                        'breezy.controldir', 'format_registry'),
 
2220
                                    converter=lambda name: controldir.format_registry.make_controldir(
 
2221
                                        name),
 
2222
                                    value_switches=True, title='Repository format'),
1815
2223
                     Option('no-trees',
1816
 
                             help='Branches in the repository will default to'
1817
 
                                  ' not having a working tree.'),
1818
 
                    ]
1819
 
    aliases = ["init-repo"]
 
2224
                            help='Branches in the repository will default to'
 
2225
                            ' not having a working tree.'),
 
2226
                     ]
 
2227
    aliases = ["init-shared-repo", "init-repo"]
1820
2228
 
1821
2229
    def run(self, location, format=None, no_trees=False):
1822
2230
        if format is None:
1823
 
            format = bzrdir.format_registry.make_bzrdir('default')
 
2231
            format = controldir.format_registry.make_controldir('default')
1824
2232
 
1825
2233
        if location is None:
1826
2234
            location = '.'
1827
2235
 
1828
 
        to_transport = transport.get_transport(location)
1829
 
        to_transport.ensure_base()
1830
 
 
1831
 
        newdir = format.initialize_on_transport(to_transport)
1832
 
        repo = newdir.create_repository(shared=True)
1833
 
        repo.set_make_working_trees(not no_trees)
 
2236
        to_transport = transport.get_transport(location, purpose='write')
 
2237
 
 
2238
        if format.fixed_components:
 
2239
            repo_format_name = None
 
2240
        else:
 
2241
            repo_format_name = format.repository_format.get_format_string()
 
2242
 
 
2243
        (repo, newdir, require_stacking, repository_policy) = (
 
2244
            format.initialize_on_transport_ex(to_transport,
 
2245
                                              create_prefix=True, make_working_trees=not no_trees,
 
2246
                                              shared_repo=True, force_new_repo=True,
 
2247
                                              use_existing_dir=True,
 
2248
                                              repo_format_name=repo_format_name))
1834
2249
        if not is_quiet():
1835
 
            from bzrlib.info import show_bzrdir_info
1836
 
            show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
 
2250
            from .info import show_bzrdir_info
 
2251
            show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1837
2252
 
1838
2253
 
1839
2254
class cmd_diff(Command):
1846
2261
    the first argument, if any, or the current tree if no arguments are
1847
2262
    given.
1848
2263
 
1849
 
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
 
2264
    "brz diff -p1" is equivalent to "brz diff --prefix old/:new/", and
1850
2265
    produces patches suitable for "patch -p1".
1851
2266
 
 
2267
    Note that when using the -r argument with a range of revisions, the
 
2268
    differences are computed between the two specified revisions.  That
 
2269
    is, the command does not show the changes introduced by the first
 
2270
    revision in the range.  This differs from the interpretation of
 
2271
    revision ranges used by "brz log" which includes the first revision
 
2272
    in the range.
 
2273
 
1852
2274
    :Exit values:
1853
2275
        1 - changed
1854
2276
        2 - unrepresentable changes
1858
2280
    :Examples:
1859
2281
        Shows the difference in the working tree versus the last commit::
1860
2282
 
1861
 
            bzr diff
 
2283
            brz diff
1862
2284
 
1863
2285
        Difference between the working tree and revision 1::
1864
2286
 
1865
 
            bzr diff -r1
 
2287
            brz diff -r1
1866
2288
 
1867
2289
        Difference between revision 3 and revision 1::
1868
2290
 
1869
 
            bzr diff -r1..3
 
2291
            brz diff -r1..3
1870
2292
 
1871
2293
        Difference between revision 3 and revision 1 for branch xxx::
1872
2294
 
1873
 
            bzr diff -r1..3 xxx
1874
 
 
1875
 
        To see the changes introduced in revision X::
1876
 
        
1877
 
            bzr diff -cX
 
2295
            brz diff -r1..3 xxx
 
2296
 
 
2297
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
2298
 
 
2299
            brz diff -c2
 
2300
 
 
2301
        To see the changes introduced by revision X::
 
2302
 
 
2303
            brz diff -cX
1878
2304
 
1879
2305
        Note that in the case of a merge, the -c option shows the changes
1880
2306
        compared to the left hand parent. To see the changes against
1881
2307
        another parent, use::
1882
2308
 
1883
 
            bzr diff -r<chosen_parent>..X
1884
 
 
1885
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
1886
 
 
1887
 
            bzr diff -c2
 
2309
            brz diff -r<chosen_parent>..X
 
2310
 
 
2311
        The changes between the current revision and the previous revision
 
2312
        (equivalent to -c-1 and -r-2..-1)
 
2313
 
 
2314
            brz diff -r-2..
1888
2315
 
1889
2316
        Show just the differences for file NEWS::
1890
2317
 
1891
 
            bzr diff NEWS
 
2318
            brz diff NEWS
1892
2319
 
1893
2320
        Show the differences in working tree xxx for file NEWS::
1894
2321
 
1895
 
            bzr diff xxx/NEWS
 
2322
            brz diff xxx/NEWS
1896
2323
 
1897
2324
        Show the differences from branch xxx to this working tree:
1898
2325
 
1899
 
            bzr diff --old xxx
 
2326
            brz diff --old xxx
1900
2327
 
1901
2328
        Show the differences between two branches for file NEWS::
1902
2329
 
1903
 
            bzr diff --old xxx --new yyy NEWS
1904
 
 
1905
 
        Same as 'bzr diff' but prefix paths with old/ and new/::
1906
 
 
1907
 
            bzr diff --prefix old/:new/
 
2330
            brz diff --old xxx --new yyy NEWS
 
2331
 
 
2332
        Same as 'brz diff' but prefix paths with old/ and new/::
 
2333
 
 
2334
            brz diff --prefix old/:new/
 
2335
 
 
2336
        Show the differences using a custom diff program with options::
 
2337
 
 
2338
            brz diff --using /usr/bin/diff --diff-options -wu
1908
2339
    """
1909
2340
    _see_also = ['status']
1910
2341
    takes_args = ['file*']
1911
2342
    takes_options = [
1912
 
        Option('diff-options', type=str,
 
2343
        Option('diff-options', type=text_type,
1913
2344
               help='Pass these options to the external diff program.'),
1914
 
        Option('prefix', type=str,
 
2345
        Option('prefix', type=text_type,
1915
2346
               short_name='p',
1916
2347
               help='Set prefixes added to old and new filenames, as '
1917
2348
                    'two values separated by a colon. (eg "old/:new/").'),
1918
2349
        Option('old',
1919
 
            help='Branch/tree to compare from.',
1920
 
            type=unicode,
1921
 
            ),
 
2350
               help='Branch/tree to compare from.',
 
2351
               type=text_type,
 
2352
               ),
1922
2353
        Option('new',
1923
 
            help='Branch/tree to compare to.',
1924
 
            type=unicode,
1925
 
            ),
 
2354
               help='Branch/tree to compare to.',
 
2355
               type=text_type,
 
2356
               ),
1926
2357
        'revision',
1927
2358
        'change',
1928
2359
        Option('using',
1929
 
            help='Use this command to compare files.',
1930
 
            type=unicode,
1931
 
            ),
 
2360
               help='Use this command to compare files.',
 
2361
               type=text_type,
 
2362
               ),
1932
2363
        RegistryOption('format',
1933
 
            help='Diff format to use.',
1934
 
            lazy_registry=('bzrlib.diff', 'format_registry'),
1935
 
            value_switches=False, title='Diff format'),
 
2364
                       short_name='F',
 
2365
                       help='Diff format to use.',
 
2366
                       lazy_registry=('breezy.diff', 'format_registry'),
 
2367
                       title='Diff format'),
 
2368
        Option('context',
 
2369
               help='How many lines of context to show.',
 
2370
               type=int,
 
2371
               ),
 
2372
        RegistryOption.from_kwargs(
 
2373
            'color',
 
2374
            help='Color mode to use.',
 
2375
            title='Color Mode', value_switches=False, enum_switch=True,
 
2376
            never='Never colorize output.',
 
2377
            auto='Only colorize output if terminal supports it and STDOUT is a'
 
2378
            ' TTY.',
 
2379
            always='Always colorize output (default).'),
 
2380
        Option(
 
2381
            'check-style',
 
2382
            help=('Warn if trailing whitespace or spurious changes have been'
 
2383
                  '  added.'))
1936
2384
        ]
 
2385
 
1937
2386
    aliases = ['di', 'dif']
1938
2387
    encoding_type = 'exact'
1939
2388
 
1940
2389
    @display_command
1941
2390
    def run(self, revision=None, file_list=None, diff_options=None,
1942
 
            prefix=None, old=None, new=None, using=None, format=None):
1943
 
        from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1944
 
            show_diff_trees)
 
2391
            prefix=None, old=None, new=None, using=None, format=None,
 
2392
            context=None, color='never'):
 
2393
        from .diff import (get_trees_and_branches_to_diff_locked,
 
2394
                           show_diff_trees)
1945
2395
 
1946
 
        if (prefix is None) or (prefix == '0'):
 
2396
        if prefix == u'0':
1947
2397
            # diff -p0 format
1948
2398
            old_label = ''
1949
2399
            new_label = ''
1950
 
        elif prefix == '1':
 
2400
        elif prefix == u'1' or prefix is None:
1951
2401
            old_label = 'old/'
1952
2402
            new_label = 'new/'
1953
 
        elif ':' in prefix:
1954
 
            old_label, new_label = prefix.split(":")
 
2403
        elif u':' in prefix:
 
2404
            old_label, new_label = prefix.split(u":")
1955
2405
        else:
1956
 
            raise errors.BzrCommandError(
 
2406
            raise errors.CommandError(gettext(
1957
2407
                '--prefix expects two values separated by a colon'
1958
 
                ' (eg "old/:new/")')
 
2408
                ' (eg "old/:new/")'))
1959
2409
 
1960
2410
        if revision and len(revision) > 2:
1961
 
            raise errors.BzrCommandError('bzr diff --revision takes exactly'
1962
 
                                         ' one or two revision specifiers')
 
2411
            raise errors.CommandError(gettext('brz diff --revision takes exactly'
 
2412
                                                 ' one or two revision specifiers'))
1963
2413
 
1964
2414
        if using is not None and format is not None:
1965
 
            raise errors.BzrCommandError('--using and --format are mutually '
1966
 
                'exclusive.')
 
2415
            raise errors.CommandError(gettext(
 
2416
                '{0} and {1} are mutually exclusive').format(
 
2417
                '--using', '--format'))
1967
2418
 
1968
2419
        (old_tree, new_tree,
1969
2420
         old_branch, new_branch,
1970
2421
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1971
 
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
1972
 
        return show_diff_trees(old_tree, new_tree, sys.stdout,
 
2422
            file_list, revision, old, new, self._exit_stack, apply_view=True)
 
2423
        # GNU diff on Windows uses ANSI encoding for filenames
 
2424
        path_encoding = osutils.get_diff_header_encoding()
 
2425
        outf = self.outf
 
2426
        if color == 'auto':
 
2427
            from .terminal import has_ansi_colors
 
2428
            if has_ansi_colors():
 
2429
                color = 'always'
 
2430
            else:
 
2431
                color = 'never'
 
2432
        if 'always' == color:
 
2433
            from .colordiff import DiffWriter
 
2434
            outf = DiffWriter(outf)
 
2435
        return show_diff_trees(old_tree, new_tree, outf,
1973
2436
                               specific_files=specific_files,
1974
2437
                               external_diff_options=diff_options,
1975
2438
                               old_label=old_label, new_label=new_label,
1976
 
                               extra_trees=extra_trees, using=using,
 
2439
                               extra_trees=extra_trees,
 
2440
                               path_encoding=path_encoding,
 
2441
                               using=using, context=context,
1977
2442
                               format_cls=format)
1978
2443
 
1979
2444
 
1987
2452
    # level of effort but possibly much less IO.  (Or possibly not,
1988
2453
    # if the directories are very large...)
1989
2454
    _see_also = ['status', 'ls']
1990
 
    takes_options = ['show-ids']
 
2455
    takes_options = ['directory', 'show-ids']
1991
2456
 
1992
2457
    @display_command
1993
 
    def run(self, show_ids=False):
1994
 
        tree = WorkingTree.open_containing(u'.')[0]
1995
 
        self.add_cleanup(tree.lock_read().unlock)
 
2458
    def run(self, show_ids=False, directory=u'.'):
 
2459
        tree = WorkingTree.open_containing(directory)[0]
 
2460
        self.enter_context(tree.lock_read())
1996
2461
        old = tree.basis_tree()
1997
 
        self.add_cleanup(old.lock_read().unlock)
1998
 
        for path, ie in old.inventory.iter_entries():
1999
 
            if not tree.has_id(ie.file_id):
2000
 
                self.outf.write(path)
2001
 
                if show_ids:
2002
 
                    self.outf.write(' ')
2003
 
                    self.outf.write(ie.file_id)
2004
 
                self.outf.write('\n')
 
2462
        self.enter_context(old.lock_read())
 
2463
        delta = tree.changes_from(old)
 
2464
        for change in delta.removed:
 
2465
            self.outf.write(change.path[0])
 
2466
            if show_ids:
 
2467
                self.outf.write(' ')
 
2468
                self.outf.write(change.file_id)
 
2469
            self.outf.write('\n')
2005
2470
 
2006
2471
 
2007
2472
class cmd_modified(Command):
2010
2475
 
2011
2476
    hidden = True
2012
2477
    _see_also = ['status', 'ls']
2013
 
    takes_options = [
2014
 
            Option('null',
2015
 
                   help='Write an ascii NUL (\\0) separator '
2016
 
                   'between files rather than a newline.')
2017
 
            ]
 
2478
    takes_options = ['directory', 'null']
2018
2479
 
2019
2480
    @display_command
2020
 
    def run(self, null=False):
2021
 
        tree = WorkingTree.open_containing(u'.')[0]
 
2481
    def run(self, null=False, directory=u'.'):
 
2482
        tree = WorkingTree.open_containing(directory)[0]
 
2483
        self.enter_context(tree.lock_read())
2022
2484
        td = tree.changes_from(tree.basis_tree())
2023
 
        for path, id, kind, text_modified, meta_modified in td.modified:
 
2485
        self.cleanup_now()
 
2486
        for change in td.modified:
2024
2487
            if null:
2025
 
                self.outf.write(path + '\0')
 
2488
                self.outf.write(change.path[1] + '\0')
2026
2489
            else:
2027
 
                self.outf.write(osutils.quotefn(path) + '\n')
 
2490
                self.outf.write(osutils.quotefn(change.path[1]) + '\n')
2028
2491
 
2029
2492
 
2030
2493
class cmd_added(Command):
2033
2496
 
2034
2497
    hidden = True
2035
2498
    _see_also = ['status', 'ls']
2036
 
    takes_options = [
2037
 
            Option('null',
2038
 
                   help='Write an ascii NUL (\\0) separator '
2039
 
                   'between files rather than a newline.')
2040
 
            ]
 
2499
    takes_options = ['directory', 'null']
2041
2500
 
2042
2501
    @display_command
2043
 
    def run(self, null=False):
2044
 
        wt = WorkingTree.open_containing(u'.')[0]
2045
 
        self.add_cleanup(wt.lock_read().unlock)
 
2502
    def run(self, null=False, directory=u'.'):
 
2503
        wt = WorkingTree.open_containing(directory)[0]
 
2504
        self.enter_context(wt.lock_read())
2046
2505
        basis = wt.basis_tree()
2047
 
        self.add_cleanup(basis.lock_read().unlock)
2048
 
        basis_inv = basis.inventory
2049
 
        inv = wt.inventory
2050
 
        for file_id in inv:
2051
 
            if file_id in basis_inv:
2052
 
                continue
2053
 
            if inv.is_root(file_id) and len(basis_inv) == 0:
2054
 
                continue
2055
 
            path = inv.id2path(file_id)
2056
 
            if not os.access(osutils.abspath(path), os.F_OK):
 
2506
        self.enter_context(basis.lock_read())
 
2507
        for path in wt.all_versioned_paths():
 
2508
            if basis.has_filename(path):
 
2509
                continue
 
2510
            if path == u'':
 
2511
                continue
 
2512
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2057
2513
                continue
2058
2514
            if null:
2059
2515
                self.outf.write(path + '\0')
2064
2520
class cmd_root(Command):
2065
2521
    __doc__ = """Show the tree root directory.
2066
2522
 
2067
 
    The root is the nearest enclosing directory with a .bzr control
 
2523
    The root is the nearest enclosing directory with a control
2068
2524
    directory."""
2069
2525
 
2070
2526
    takes_args = ['filename?']
 
2527
 
2071
2528
    @display_command
2072
2529
    def run(self, filename=None):
2073
2530
        """Print the branch root."""
2079
2536
    try:
2080
2537
        return int(limitstring)
2081
2538
    except ValueError:
2082
 
        msg = "The limit argument must be an integer."
2083
 
        raise errors.BzrCommandError(msg)
 
2539
        msg = gettext("The limit argument must be an integer.")
 
2540
        raise errors.CommandError(msg)
2084
2541
 
2085
2542
 
2086
2543
def _parse_levels(s):
2087
2544
    try:
2088
2545
        return int(s)
2089
2546
    except ValueError:
2090
 
        msg = "The levels argument must be an integer."
2091
 
        raise errors.BzrCommandError(msg)
 
2547
        msg = gettext("The levels argument must be an integer.")
 
2548
        raise errors.CommandError(msg)
2092
2549
 
2093
2550
 
2094
2551
class cmd_log(Command):
2095
2552
    __doc__ = """Show historical log for a branch or subset of a branch.
2096
2553
 
2097
 
    log is bzr's default tool for exploring the history of a branch.
 
2554
    log is brz's default tool for exploring the history of a branch.
2098
2555
    The branch to use is taken from the first parameter. If no parameters
2099
2556
    are given, the branch containing the working directory is logged.
2100
2557
    Here are some simple examples::
2101
2558
 
2102
 
      bzr log                       log the current branch
2103
 
      bzr log foo.py                log a file in its branch
2104
 
      bzr log http://server/branch  log a branch on a server
 
2559
      brz log                       log the current branch
 
2560
      brz log foo.py                log a file in its branch
 
2561
      brz log http://server/branch  log a branch on a server
2105
2562
 
2106
2563
    The filtering, ordering and information shown for each revision can
2107
2564
    be controlled as explained below. By default, all revisions are
2114
2571
 
2115
2572
      The log format controls how information about each revision is
2116
2573
      displayed. The standard log formats are called ``long``, ``short``
2117
 
      and ``line``. The default is long. See ``bzr help log-formats``
 
2574
      and ``line``. The default is long. See ``brz help log-formats``
2118
2575
      for more details on log formats.
2119
2576
 
2120
2577
      The following options can be used to control what information is
2151
2608
        -r..Y    display up to and including revision Y
2152
2609
        -rX..Y   display from X to Y inclusive
2153
2610
 
2154
 
      See ``bzr help revisionspec`` for details on how to specify X and Y.
 
2611
      See ``brz help revisionspec`` for details on how to specify X and Y.
2155
2612
      Some common examples are given below::
2156
2613
 
2157
2614
        -r-1                show just the tip
2187
2644
 
2188
2645
      In this case:
2189
2646
 
2190
 
      * ``bzr log guide.txt`` will log the file added in revision 1
2191
 
 
2192
 
      * ``bzr log tutorial.txt`` will log the new file added in revision 3
2193
 
 
2194
 
      * ``bzr log -r2 -p tutorial.txt`` will show the changes made to
 
2647
      * ``brz log guide.txt`` will log the file added in revision 1
 
2648
 
 
2649
      * ``brz log tutorial.txt`` will log the new file added in revision 3
 
2650
 
 
2651
      * ``brz log -r2 -p tutorial.txt`` will show the changes made to
2195
2652
        the original file in revision 2.
2196
2653
 
2197
 
      * ``bzr log -r2 -p guide.txt`` will display an error message as there
 
2654
      * ``brz log -r2 -p guide.txt`` will display an error message as there
2198
2655
        was no file called guide.txt in revision 2.
2199
2656
 
2200
2657
      Renames are always followed by log. By design, there is no need to
2203
2660
 
2204
2661
    :Other filtering:
2205
2662
 
2206
 
      The --message option can be used for finding revisions that match a
2207
 
      regular expression in a commit message.
 
2663
      The --match option can be used for finding revisions that match a
 
2664
      regular expression in a commit message, committer, author or bug.
 
2665
      Specifying the option several times will match any of the supplied
 
2666
      expressions. --match-author, --match-bugs, --match-committer and
 
2667
      --match-message can be used to only match a specific field.
2208
2668
 
2209
2669
    :Tips & tricks:
2210
2670
 
2211
2671
      GUI tools and IDEs are often better at exploring history than command
2212
2672
      line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2213
 
      bzr-explorer shell, or the Loggerhead web interface.  See the Plugin
2214
 
      Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2215
 
      <http://wiki.bazaar.canonical.com/IDEIntegration>.  
 
2673
      bzr-explorer shell, or the Loggerhead web interface.  See the Bazaar
 
2674
      Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/> and
 
2675
      <http://wiki.bazaar.canonical.com/IDEIntegration>.
2216
2676
 
2217
 
      You may find it useful to add the aliases below to ``bazaar.conf``::
 
2677
      You may find it useful to add the aliases below to ``breezy.conf``::
2218
2678
 
2219
2679
        [ALIASES]
2220
2680
        tip = log -r-1
2221
2681
        top = log -l10 --line
2222
2682
        show = log -v -p
2223
2683
 
2224
 
      ``bzr tip`` will then show the latest revision while ``bzr top``
 
2684
      ``brz tip`` will then show the latest revision while ``brz top``
2225
2685
      will show the last 10 mainline revisions. To see the details of a
2226
 
      particular revision X,  ``bzr show -rX``.
 
2686
      particular revision X,  ``brz show -rX``.
2227
2687
 
2228
2688
      If you are interested in looking deeper into a particular merge X,
2229
 
      use ``bzr log -n0 -rX``.
 
2689
      use ``brz log -n0 -rX``.
2230
2690
 
2231
 
      ``bzr log -v`` on a branch with lots of history is currently
 
2691
      ``brz log -v`` on a branch with lots of history is currently
2232
2692
      very slow. A fix for this issue is currently under development.
2233
2693
      With or without that fix, it is recommended that a revision range
2234
2694
      be given when using the -v option.
2235
2695
 
2236
 
      bzr has a generic full-text matching plugin, bzr-search, that can be
 
2696
      brz has a generic full-text matching plugin, brz-search, that can be
2237
2697
      used to find revisions matching user names, commit messages, etc.
2238
2698
      Among other features, this plugin can find all revisions containing
2239
2699
      a list of words but not others.
2246
2706
    takes_args = ['file*']
2247
2707
    _see_also = ['log-formats', 'revisionspec']
2248
2708
    takes_options = [
2249
 
            Option('forward',
2250
 
                   help='Show from oldest to newest.'),
2251
 
            'timezone',
2252
 
            custom_help('verbose',
2253
 
                   help='Show files changed in each revision.'),
2254
 
            'show-ids',
2255
 
            'revision',
2256
 
            Option('change',
2257
 
                   type=bzrlib.option._parse_revision_str,
2258
 
                   short_name='c',
2259
 
                   help='Show just the specified revision.'
2260
 
                   ' See also "help revisionspec".'),
2261
 
            'log-format',
2262
 
            Option('levels',
2263
 
                   short_name='n',
2264
 
                   help='Number of levels to display - 0 for all, 1 for flat.',
2265
 
                   argname='N',
2266
 
                   type=_parse_levels),
2267
 
            Option('message',
 
2709
        Option('forward',
 
2710
               help='Show from oldest to newest.'),
 
2711
        'timezone',
 
2712
        custom_help('verbose',
 
2713
                    help='Show files changed in each revision.'),
 
2714
        'show-ids',
 
2715
        'revision',
 
2716
        Option('change',
 
2717
               type=breezy.option._parse_revision_str,
 
2718
               short_name='c',
 
2719
               help='Show just the specified revision.'
 
2720
               ' See also "help revisionspec".'),
 
2721
        'log-format',
 
2722
        RegistryOption('authors',
 
2723
                       'What names to list as authors - first, all or committer.',
 
2724
                       title='Authors',
 
2725
                       lazy_registry=(
 
2726
                           'breezy.log', 'author_list_registry'),
 
2727
                       ),
 
2728
        Option('levels',
 
2729
               short_name='n',
 
2730
               help='Number of levels to display - 0 for all, 1 for flat.',
 
2731
               argname='N',
 
2732
               type=_parse_levels),
 
2733
        Option('message',
 
2734
               help='Show revisions whose message matches this '
 
2735
               'regular expression.',
 
2736
               type=text_type,
 
2737
               hidden=True),
 
2738
        Option('limit',
 
2739
               short_name='l',
 
2740
               help='Limit the output to the first N revisions.',
 
2741
               argname='N',
 
2742
               type=_parse_limit),
 
2743
        Option('show-diff',
 
2744
               short_name='p',
 
2745
               help='Show changes made in each revision as a patch.'),
 
2746
        Option('include-merged',
 
2747
               help='Show merged revisions like --levels 0 does.'),
 
2748
        Option('include-merges', hidden=True,
 
2749
               help='Historical alias for --include-merged.'),
 
2750
        Option('omit-merges',
 
2751
               help='Do not report commits with more than one parent.'),
 
2752
        Option('exclude-common-ancestry',
 
2753
               help='Display only the revisions that are not part'
 
2754
               ' of both ancestries (require -rX..Y).'
 
2755
               ),
 
2756
        Option('signatures',
 
2757
               help='Show digital signature validity.'),
 
2758
        ListOption('match',
2268
2759
                   short_name='m',
 
2760
                   help='Show revisions whose properties match this '
 
2761
                   'expression.',
 
2762
                   type=text_type),
 
2763
        ListOption('match-message',
2269
2764
                   help='Show revisions whose message matches this '
2270
 
                        'regular expression.',
2271
 
                   type=str),
2272
 
            Option('limit',
2273
 
                   short_name='l',
2274
 
                   help='Limit the output to the first N revisions.',
2275
 
                   argname='N',
2276
 
                   type=_parse_limit),
2277
 
            Option('show-diff',
2278
 
                   short_name='p',
2279
 
                   help='Show changes made in each revision as a patch.'),
2280
 
            Option('include-merges',
2281
 
                   help='Show merged revisions like --levels 0 does.'),
2282
 
            Option('exclude-common-ancestry',
2283
 
                   help='Display only the revisions that are not part'
2284
 
                   ' of both ancestries (require -rX..Y)'
2285
 
                   )
2286
 
            ]
 
2765
                   'expression.',
 
2766
                   type=text_type),
 
2767
        ListOption('match-committer',
 
2768
                   help='Show revisions whose committer matches this '
 
2769
                   'expression.',
 
2770
                   type=text_type),
 
2771
        ListOption('match-author',
 
2772
                   help='Show revisions whose authors match this '
 
2773
                   'expression.',
 
2774
                   type=text_type),
 
2775
        ListOption('match-bugs',
 
2776
                   help='Show revisions whose bugs match this '
 
2777
                   'expression.',
 
2778
                   type=text_type)
 
2779
        ]
2287
2780
    encoding_type = 'replace'
2288
2781
 
2289
2782
    @display_command
2298
2791
            message=None,
2299
2792
            limit=None,
2300
2793
            show_diff=False,
2301
 
            include_merges=False,
 
2794
            include_merged=None,
 
2795
            authors=None,
2302
2796
            exclude_common_ancestry=False,
 
2797
            signatures=False,
 
2798
            match=None,
 
2799
            match_message=None,
 
2800
            match_committer=None,
 
2801
            match_author=None,
 
2802
            match_bugs=None,
 
2803
            omit_merges=False,
2303
2804
            ):
2304
 
        from bzrlib.log import (
 
2805
        from .log import (
2305
2806
            Logger,
2306
2807
            make_log_request_dict,
2307
2808
            _get_info_for_log_files,
2308
2809
            )
2309
2810
        direction = (forward and 'forward') or 'reverse'
 
2811
        if include_merged is None:
 
2812
            include_merged = False
2310
2813
        if (exclude_common_ancestry
2311
 
            and (revision is None or len(revision) != 2)):
2312
 
            raise errors.BzrCommandError(
2313
 
                '--exclude-common-ancestry requires -r with two revisions')
2314
 
        if include_merges:
 
2814
                and (revision is None or len(revision) != 2)):
 
2815
            raise errors.CommandError(gettext(
 
2816
                '--exclude-common-ancestry requires -r with two revisions'))
 
2817
        if include_merged:
2315
2818
            if levels is None:
2316
2819
                levels = 0
2317
2820
            else:
2318
 
                raise errors.BzrCommandError(
2319
 
                    '--levels and --include-merges are mutually exclusive')
 
2821
                raise errors.CommandError(gettext(
 
2822
                    '{0} and {1} are mutually exclusive').format(
 
2823
                    '--levels', '--include-merged'))
2320
2824
 
2321
2825
        if change is not None:
2322
2826
            if len(change) > 1:
2323
2827
                raise errors.RangeInChangeOption()
2324
2828
            if revision is not None:
2325
 
                raise errors.BzrCommandError(
2326
 
                    '--revision and --change are mutually exclusive')
 
2829
                raise errors.CommandError(gettext(
 
2830
                    '{0} and {1} are mutually exclusive').format(
 
2831
                    '--revision', '--change'))
2327
2832
            else:
2328
2833
                revision = change
2329
2834
 
2330
 
        file_ids = []
 
2835
        files = []
2331
2836
        filter_by_dir = False
2332
2837
        if file_list:
2333
2838
            # find the file ids to log and check for directory filtering
2334
2839
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
 
                revision, file_list, self.add_cleanup)
2336
 
            for relpath, file_id, kind in file_info_list:
2337
 
                if file_id is None:
2338
 
                    raise errors.BzrCommandError(
2339
 
                        "Path unknown at end or start of revision range: %s" %
 
2840
                revision, file_list, self._exit_stack)
 
2841
            for relpath, kind in file_info_list:
 
2842
                if not kind:
 
2843
                    raise errors.CommandError(gettext(
 
2844
                        "Path unknown at end or start of revision range: %s") %
2340
2845
                        relpath)
2341
2846
                # If the relpath is the top of the tree, we log everything
2342
2847
                if relpath == '':
2343
 
                    file_ids = []
 
2848
                    files = []
2344
2849
                    break
2345
2850
                else:
2346
 
                    file_ids.append(file_id)
 
2851
                    files.append(relpath)
2347
2852
                filter_by_dir = filter_by_dir or (
2348
2853
                    kind in ['directory', 'tree-reference'])
2349
2854
        else:
2354
2859
                location = revision[0].get_branch()
2355
2860
            else:
2356
2861
                location = '.'
2357
 
            dir, relpath = bzrdir.BzrDir.open_containing(location)
 
2862
            dir, relpath = controldir.ControlDir.open_containing(location)
2358
2863
            b = dir.open_branch()
2359
 
            self.add_cleanup(b.lock_read().unlock)
 
2864
            self.enter_context(b.lock_read())
2360
2865
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2866
 
 
2867
        if b.get_config_stack().get('validate_signatures_in_log'):
 
2868
            signatures = True
 
2869
 
 
2870
        if signatures:
 
2871
            if not gpg.GPGStrategy.verify_signatures_available():
 
2872
                raise errors.GpgmeNotInstalled(None)
 
2873
 
2362
2874
        # Decide on the type of delta & diff filtering to use
2363
2875
        # TODO: add an --all-files option to make this configurable & consistent
2364
2876
        if not verbose:
2367
2879
            delta_type = 'full'
2368
2880
        if not show_diff:
2369
2881
            diff_type = None
2370
 
        elif file_ids:
 
2882
        elif files:
2371
2883
            diff_type = 'partial'
2372
2884
        else:
2373
2885
            diff_type = 'full'
2376
2888
        if log_format is None:
2377
2889
            log_format = log.log_formatter_registry.get_default(b)
2378
2890
        # Make a non-encoding output to include the diffs - bug 328007
2379
 
        unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
 
2891
        unencoded_output = ui.ui_factory.make_output_stream(
 
2892
            encoding_type='exact')
2380
2893
        lf = log_format(show_ids=show_ids, to_file=self.outf,
2381
2894
                        to_exact_file=unencoded_output,
2382
2895
                        show_timezone=timezone,
2383
2896
                        delta_format=get_verbosity_level(),
2384
2897
                        levels=levels,
2385
 
                        show_advice=levels is None)
 
2898
                        show_advice=levels is None,
 
2899
                        author_list_handler=authors)
2386
2900
 
2387
2901
        # Choose the algorithm for doing the logging. It's annoying
2388
2902
        # having multiple code paths like this but necessary until
2397
2911
        # original algorithm - per-file-graph - for the "single
2398
2912
        # file that isn't a directory without showing a delta" case.
2399
2913
        partial_history = revision and b.repository._format.supports_chks
2400
 
        match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2401
 
            or delta_type or partial_history)
 
2914
        match_using_deltas = (len(files) != 1 or filter_by_dir
 
2915
                              or delta_type or partial_history)
 
2916
 
 
2917
        match_dict = {}
 
2918
        if match:
 
2919
            match_dict[''] = match
 
2920
        if match_message:
 
2921
            match_dict['message'] = match_message
 
2922
        if match_committer:
 
2923
            match_dict['committer'] = match_committer
 
2924
        if match_author:
 
2925
            match_dict['author'] = match_author
 
2926
        if match_bugs:
 
2927
            match_dict['bugs'] = match_bugs
2402
2928
 
2403
2929
        # Build the LogRequest and execute it
2404
 
        if len(file_ids) == 0:
2405
 
            file_ids = None
 
2930
        if len(files) == 0:
 
2931
            files = None
2406
2932
        rqst = make_log_request_dict(
2407
 
            direction=direction, specific_fileids=file_ids,
 
2933
            direction=direction, specific_files=files,
2408
2934
            start_revision=rev1, end_revision=rev2, limit=limit,
2409
2935
            message_search=message, delta_type=delta_type,
2410
2936
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2411
 
            exclude_common_ancestry=exclude_common_ancestry,
 
2937
            exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
 
2938
            signature=signatures, omit_merges=omit_merges,
2412
2939
            )
2413
2940
        Logger(b, rqst).show(lf)
2414
2941
 
2431
2958
            # b is taken from revision[0].get_branch(), and
2432
2959
            # show_log will use its revision_history. Having
2433
2960
            # different branches will lead to weird behaviors.
2434
 
            raise errors.BzrCommandError(
2435
 
                "bzr %s doesn't accept two revisions in different"
2436
 
                " branches." % command_name)
 
2961
            raise errors.CommandError(gettext(
 
2962
                "brz %s doesn't accept two revisions in different"
 
2963
                " branches.") % command_name)
2437
2964
        if start_spec.spec is None:
2438
2965
            # Avoid loading all the history.
2439
2966
            rev1 = RevisionInfo(branch, None, None)
2447
2974
        else:
2448
2975
            rev2 = end_spec.in_history(branch)
2449
2976
    else:
2450
 
        raise errors.BzrCommandError(
2451
 
            'bzr %s --revision takes one or two values.' % command_name)
 
2977
        raise errors.CommandError(gettext(
 
2978
            'brz %s --revision takes one or two values.') % command_name)
2452
2979
    return rev1, rev2
2453
2980
 
2454
2981
 
2461
2988
        rev_id2 = revision_range[1].rev_id
2462
2989
    return rev_id1, rev_id2
2463
2990
 
 
2991
 
2464
2992
def get_log_format(long=False, short=False, line=False, default='long'):
2465
2993
    log_format = default
2466
2994
    if long:
2475
3003
class cmd_touching_revisions(Command):
2476
3004
    __doc__ = """Return revision-ids which affected a particular file.
2477
3005
 
2478
 
    A more user-friendly interface is "bzr log FILE".
 
3006
    A more user-friendly interface is "brz log FILE".
2479
3007
    """
2480
3008
 
2481
3009
    hidden = True
2484
3012
    @display_command
2485
3013
    def run(self, filename):
2486
3014
        tree, relpath = WorkingTree.open_containing(filename)
2487
 
        file_id = tree.path2id(relpath)
2488
 
        b = tree.branch
2489
 
        self.add_cleanup(b.lock_read().unlock)
2490
 
        touching_revs = log.find_touching_revisions(b, file_id)
2491
 
        for revno, revision_id, what in touching_revs:
2492
 
            self.outf.write("%6d %s\n" % (revno, what))
 
3015
        with tree.lock_read():
 
3016
            touching_revs = log.find_touching_revisions(
 
3017
                tree.branch.repository, tree.branch.last_revision(), tree, relpath)
 
3018
            for revno, revision_id, what in reversed(list(touching_revs)):
 
3019
                self.outf.write("%6d %s\n" % (revno, what))
2493
3020
 
2494
3021
 
2495
3022
class cmd_ls(Command):
2499
3026
    _see_also = ['status', 'cat']
2500
3027
    takes_args = ['path?']
2501
3028
    takes_options = [
2502
 
            'verbose',
2503
 
            'revision',
2504
 
            Option('recursive', short_name='R',
2505
 
                   help='Recurse into subdirectories.'),
2506
 
            Option('from-root',
2507
 
                   help='Print paths relative to the root of the branch.'),
2508
 
            Option('unknown', help='Print unknown files.'),
2509
 
            Option('versioned', help='Print versioned files.',
2510
 
                   short_name='V'),
2511
 
            Option('ignored', help='Print ignored files.'),
2512
 
            Option('null',
2513
 
                   help='Write an ascii NUL (\\0) separator '
2514
 
                   'between files rather than a newline.'),
2515
 
            Option('kind',
2516
 
                   help='List entries of a particular kind: file, directory, symlink.',
2517
 
                   type=unicode),
2518
 
            'show-ids',
2519
 
            ]
 
3029
        'verbose',
 
3030
        'revision',
 
3031
        Option('recursive', short_name='R',
 
3032
               help='Recurse into subdirectories.'),
 
3033
        Option('from-root',
 
3034
               help='Print paths relative to the root of the branch.'),
 
3035
        Option('unknown', short_name='u',
 
3036
               help='Print unknown files.'),
 
3037
        Option('versioned', help='Print versioned files.',
 
3038
               short_name='V'),
 
3039
        Option('ignored', short_name='i',
 
3040
               help='Print ignored files.'),
 
3041
        Option('kind', short_name='k',
 
3042
               help=('List entries of a particular kind: file, '
 
3043
                     'directory, symlink, tree-reference.'),
 
3044
               type=text_type),
 
3045
        'null',
 
3046
        'show-ids',
 
3047
        'directory',
 
3048
        ]
 
3049
 
2520
3050
    @display_command
2521
3051
    def run(self, revision=None, verbose=False,
2522
3052
            recursive=False, from_root=False,
2523
3053
            unknown=False, versioned=False, ignored=False,
2524
 
            null=False, kind=None, show_ids=False, path=None):
 
3054
            null=False, kind=None, show_ids=False, path=None, directory=None):
2525
3055
 
2526
 
        if kind and kind not in ('file', 'directory', 'symlink'):
2527
 
            raise errors.BzrCommandError('invalid kind specified')
 
3056
        if kind and kind not in ('file', 'directory', 'symlink', 'tree-reference'):
 
3057
            raise errors.CommandError(gettext('invalid kind specified'))
2528
3058
 
2529
3059
        if verbose and null:
2530
 
            raise errors.BzrCommandError('Cannot set both --verbose and --null')
 
3060
            raise errors.CommandError(
 
3061
                gettext('Cannot set both --verbose and --null'))
2531
3062
        all = not (unknown or versioned or ignored)
2532
3063
 
2533
 
        selection = {'I':ignored, '?':unknown, 'V':versioned}
 
3064
        selection = {'I': ignored, '?': unknown, 'V': versioned}
2534
3065
 
2535
3066
        if path is None:
2536
3067
            fs_path = '.'
2537
3068
        else:
2538
3069
            if from_root:
2539
 
                raise errors.BzrCommandError('cannot specify both --from-root'
2540
 
                                             ' and PATH')
 
3070
                raise errors.CommandError(gettext('cannot specify both --from-root'
 
3071
                                                     ' and PATH'))
2541
3072
            fs_path = path
2542
 
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2543
 
            fs_path)
 
3073
        tree, branch, relpath = \
 
3074
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2544
3075
 
2545
3076
        # Calculate the prefix to use
2546
3077
        prefix = None
2559
3090
            if view_files:
2560
3091
                apply_view = True
2561
3092
                view_str = views.view_display_str(view_files)
2562
 
                note("Ignoring files outside view. View is %s" % view_str)
 
3093
                note(gettext("Ignoring files outside view. View is %s") % view_str)
2563
3094
 
2564
 
        self.add_cleanup(tree.lock_read().unlock)
2565
 
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
 
            from_dir=relpath, recursive=recursive):
 
3095
        self.enter_context(tree.lock_read())
 
3096
        for fp, fc, fkind, entry in tree.list_files(
 
3097
                include_root=False, from_dir=relpath, recursive=recursive):
2567
3098
            # Apply additional masking
2568
3099
            if not all and not selection[fc]:
2569
3100
                continue
2576
3107
                    else:
2577
3108
                        fullpath = fp
2578
3109
                    views.check_path_in_view(tree, fullpath)
2579
 
                except errors.FileOutsideView:
 
3110
                except views.FileOutsideView:
2580
3111
                    continue
2581
3112
 
2582
3113
            # Output the entry
2587
3118
            ui.ui_factory.clear_term()
2588
3119
            if verbose:
2589
3120
                outstring = '%-8s %s' % (fc, outstring)
2590
 
                if show_ids and fid is not None:
2591
 
                    outstring = "%-50s %s" % (outstring, fid)
 
3121
                if show_ids and getattr(entry, 'file_id', None) is not None:
 
3122
                    outstring = "%-50s %s" % (outstring, entry.file_id.decode('utf-8'))
2592
3123
                self.outf.write(outstring + '\n')
2593
3124
            elif null:
2594
3125
                self.outf.write(fp + '\0')
2595
3126
                if show_ids:
2596
 
                    if fid is not None:
2597
 
                        self.outf.write(fid)
 
3127
                    if getattr(entry, 'file_id', None) is not None:
 
3128
                        self.outf.write(entry.file_id.decode('utf-8'))
2598
3129
                    self.outf.write('\0')
2599
3130
                self.outf.flush()
2600
3131
            else:
2601
3132
                if show_ids:
2602
 
                    if fid is not None:
2603
 
                        my_id = fid
 
3133
                    if getattr(entry, 'file_id', None) is not None:
 
3134
                        my_id = entry.file_id.decode('utf-8')
2604
3135
                    else:
2605
3136
                        my_id = ''
2606
3137
                    self.outf.write('%-50s %s\n' % (outstring, my_id))
2614
3145
 
2615
3146
    hidden = True
2616
3147
    _see_also = ['ls']
 
3148
    takes_options = ['directory']
2617
3149
 
2618
3150
    @display_command
2619
 
    def run(self):
2620
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
3151
    def run(self, directory=u'.'):
 
3152
        for f in WorkingTree.open_containing(directory)[0].unknowns():
2621
3153
            self.outf.write(osutils.quotefn(f) + '\n')
2622
3154
 
2623
3155
 
2624
3156
class cmd_ignore(Command):
2625
3157
    __doc__ = """Ignore specified files or patterns.
2626
3158
 
2627
 
    See ``bzr help patterns`` for details on the syntax of patterns.
 
3159
    See ``brz help patterns`` for details on the syntax of patterns.
2628
3160
 
2629
3161
    If a .bzrignore file does not exist, the ignore command
2630
3162
    will create one and add the specified files or patterns to the newly
2631
 
    created file. The ignore command will also automatically add the 
 
3163
    created file. The ignore command will also automatically add the
2632
3164
    .bzrignore file to be versioned. Creating a .bzrignore file without
2633
3165
    the use of the ignore command will require an explicit add command.
2634
3166
 
2636
3168
    After adding, editing or deleting that file either indirectly by
2637
3169
    using this command or directly by using an editor, be sure to commit
2638
3170
    it.
2639
 
    
2640
 
    Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2641
 
    the global ignore file can be found in the application data directory as
2642
 
    C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
 
3171
 
 
3172
    Breezy also supports a global ignore file ~/.config/breezy/ignore. On
 
3173
    Windows the global ignore file can be found in the application data
 
3174
    directory as
 
3175
    C:\\Documents and Settings\\<user>\\Application Data\\Breezy\\3.0\\ignore.
2643
3176
    Global ignores are not touched by this command. The global ignore file
2644
3177
    can be edited directly using an editor.
2645
3178
 
2646
3179
    Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
3180
    precedence over regular ignores.  Such exceptions are used to specify
2648
3181
    files that should be versioned which would otherwise be ignored.
2649
 
    
 
3182
 
2650
3183
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2651
3184
    precedence over the '!' exception patterns.
2652
3185
 
2653
 
    Note: ignore patterns containing shell wildcards must be quoted from
2654
 
    the shell on Unix.
 
3186
    :Notes:
 
3187
 
 
3188
    * Ignore patterns containing shell wildcards must be quoted from
 
3189
      the shell on Unix.
 
3190
 
 
3191
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
3192
      To ignore patterns that begin with that character, use the "RE:" prefix.
2655
3193
 
2656
3194
    :Examples:
2657
3195
        Ignore the top level Makefile::
2658
3196
 
2659
 
            bzr ignore ./Makefile
 
3197
            brz ignore ./Makefile
2660
3198
 
2661
3199
        Ignore .class files in all directories...::
2662
3200
 
2663
 
            bzr ignore "*.class"
 
3201
            brz ignore "*.class"
2664
3202
 
2665
3203
        ...but do not ignore "special.class"::
2666
3204
 
2667
 
            bzr ignore "!special.class"
2668
 
 
2669
 
        Ignore .o files under the lib directory::
2670
 
 
2671
 
            bzr ignore "lib/**/*.o"
2672
 
 
2673
 
        Ignore .o files under the lib directory::
2674
 
 
2675
 
            bzr ignore "RE:lib/.*\.o"
 
3205
            brz ignore "!special.class"
 
3206
 
 
3207
        Ignore files whose name begins with the "#" character::
 
3208
 
 
3209
            brz ignore "RE:^#"
 
3210
 
 
3211
        Ignore .o files under the lib directory::
 
3212
 
 
3213
            brz ignore "lib/**/*.o"
 
3214
 
 
3215
        Ignore .o files under the lib directory::
 
3216
 
 
3217
            brz ignore "RE:lib/.*\\.o"
2676
3218
 
2677
3219
        Ignore everything but the "debian" toplevel directory::
2678
3220
 
2679
 
            bzr ignore "RE:(?!debian/).*"
2680
 
        
 
3221
            brz ignore "RE:(?!debian/).*"
 
3222
 
2681
3223
        Ignore everything except the "local" toplevel directory,
2682
 
        but always ignore "*~" autosave files, even under local/::
2683
 
        
2684
 
            bzr ignore "*"
2685
 
            bzr ignore "!./local"
2686
 
            bzr ignore "!!*~"
 
3224
        but always ignore autosave files ending in ~, even under local/::
 
3225
 
 
3226
            brz ignore "*"
 
3227
            brz ignore "!./local"
 
3228
            brz ignore "!!*~"
2687
3229
    """
2688
3230
 
2689
3231
    _see_also = ['status', 'ignored', 'patterns']
2690
3232
    takes_args = ['name_pattern*']
2691
 
    takes_options = [
2692
 
        Option('default-rules',
2693
 
               help='Display the default ignore rules that bzr uses.')
2694
 
        ]
 
3233
    takes_options = ['directory',
 
3234
                     Option('default-rules',
 
3235
                            help='Display the default ignore rules that brz uses.')
 
3236
                     ]
2695
3237
 
2696
 
    def run(self, name_pattern_list=None, default_rules=None):
2697
 
        from bzrlib import ignores
 
3238
    def run(self, name_pattern_list=None, default_rules=None,
 
3239
            directory=u'.'):
 
3240
        from breezy import ignores
2698
3241
        if default_rules is not None:
2699
3242
            # dump the default rules and exit
2700
3243
            for pattern in ignores.USER_DEFAULTS:
2701
3244
                self.outf.write("%s\n" % pattern)
2702
3245
            return
2703
3246
        if not name_pattern_list:
2704
 
            raise errors.BzrCommandError("ignore requires at least one "
2705
 
                "NAME_PATTERN or --default-rules.")
 
3247
            raise errors.CommandError(gettext("ignore requires at least one "
 
3248
                                                 "NAME_PATTERN or --default-rules."))
2706
3249
        name_pattern_list = [globbing.normalize_pattern(p)
2707
3250
                             for p in name_pattern_list]
 
3251
        bad_patterns = ''
 
3252
        bad_patterns_count = 0
 
3253
        for p in name_pattern_list:
 
3254
            if not globbing.Globster.is_pattern_valid(p):
 
3255
                bad_patterns_count += 1
 
3256
                bad_patterns += ('\n  %s' % p)
 
3257
        if bad_patterns:
 
3258
            msg = (ngettext('Invalid ignore pattern found. %s',
 
3259
                            'Invalid ignore patterns found. %s',
 
3260
                            bad_patterns_count) % bad_patterns)
 
3261
            ui.ui_factory.show_error(msg)
 
3262
            raise lazy_regex.InvalidPattern('')
2708
3263
        for name_pattern in name_pattern_list:
2709
3264
            if (name_pattern[0] == '/' or
2710
 
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2711
 
                raise errors.BzrCommandError(
2712
 
                    "NAME_PATTERN should not be an absolute path")
2713
 
        tree, relpath = WorkingTree.open_containing(u'.')
 
3265
                    (len(name_pattern) > 1 and name_pattern[1] == ':')):
 
3266
                raise errors.CommandError(gettext(
 
3267
                    "NAME_PATTERN should not be an absolute path"))
 
3268
        tree, relpath = WorkingTree.open_containing(directory)
2714
3269
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2715
3270
        ignored = globbing.Globster(name_pattern_list)
2716
3271
        matches = []
2717
 
        tree.lock_read()
2718
 
        for entry in tree.list_files():
2719
 
            id = entry[3]
 
3272
        self.enter_context(tree.lock_read())
 
3273
        for filename, fc, fkind, entry in tree.list_files():
 
3274
            id = getattr(entry, 'file_id', None)
2720
3275
            if id is not None:
2721
 
                filename = entry[0]
2722
3276
                if ignored.match(filename):
2723
3277
                    matches.append(filename)
2724
 
        tree.unlock()
2725
3278
        if len(matches) > 0:
2726
 
            self.outf.write("Warning: the following files are version controlled and"
2727
 
                  " match your ignore pattern:\n%s"
2728
 
                  "\nThese files will continue to be version controlled"
2729
 
                  " unless you 'bzr remove' them.\n" % ("\n".join(matches),))
 
3279
            self.outf.write(gettext("Warning: the following files are version "
 
3280
                                    "controlled and match your ignore pattern:\n%s"
 
3281
                                    "\nThese files will continue to be version controlled"
 
3282
                                    " unless you 'brz remove' them.\n") % ("\n".join(matches),))
2730
3283
 
2731
3284
 
2732
3285
class cmd_ignored(Command):
2737
3290
 
2738
3291
    Alternatively, to list just the files::
2739
3292
 
2740
 
        bzr ls --ignored
 
3293
        brz ls --ignored
2741
3294
    """
2742
3295
 
2743
3296
    encoding_type = 'replace'
2744
3297
    _see_also = ['ignore', 'ls']
 
3298
    takes_options = ['directory']
2745
3299
 
2746
3300
    @display_command
2747
 
    def run(self):
2748
 
        tree = WorkingTree.open_containing(u'.')[0]
2749
 
        self.add_cleanup(tree.lock_read().unlock)
2750
 
        for path, file_class, kind, file_id, entry in tree.list_files():
 
3301
    def run(self, directory=u'.'):
 
3302
        tree = WorkingTree.open_containing(directory)[0]
 
3303
        self.enter_context(tree.lock_read())
 
3304
        for path, file_class, kind, entry in tree.list_files():
2751
3305
            if file_class != 'I':
2752
3306
                continue
2753
 
            ## XXX: Slightly inefficient since this was already calculated
 
3307
            # XXX: Slightly inefficient since this was already calculated
2754
3308
            pat = tree.is_ignored(path)
2755
3309
            self.outf.write('%-50s %s\n' % (path, pat))
2756
3310
 
2759
3313
    __doc__ = """Lookup the revision-id from a revision-number
2760
3314
 
2761
3315
    :Examples:
2762
 
        bzr lookup-revision 33
 
3316
        brz lookup-revision 33
2763
3317
    """
2764
3318
    hidden = True
2765
3319
    takes_args = ['revno']
 
3320
    takes_options = ['directory']
2766
3321
 
2767
3322
    @display_command
2768
 
    def run(self, revno):
 
3323
    def run(self, revno, directory=u'.'):
2769
3324
        try:
2770
3325
            revno = int(revno)
2771
3326
        except ValueError:
2772
 
            raise errors.BzrCommandError("not a valid revision-number: %r"
 
3327
            raise errors.CommandError(gettext("not a valid revision-number: %r")
2773
3328
                                         % revno)
2774
 
        revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2775
 
        self.outf.write("%s\n" % revid)
 
3329
        revid = WorkingTree.open_containing(
 
3330
            directory)[0].branch.get_rev_id(revno)
 
3331
        self.outf.write("%s\n" % revid.decode('utf-8'))
2776
3332
 
2777
3333
 
2778
3334
class cmd_export(Command):
2803
3359
         zip                          .zip
2804
3360
      =================       =========================
2805
3361
    """
 
3362
    encoding = 'exact'
 
3363
    encoding_type = 'exact'
2806
3364
    takes_args = ['dest', 'branch_or_subdir?']
2807
 
    takes_options = [
2808
 
        Option('format',
2809
 
               help="Type of file to export to.",
2810
 
               type=unicode),
2811
 
        'revision',
2812
 
        Option('filters', help='Apply content filters to export the '
2813
 
                'convenient form.'),
2814
 
        Option('root',
2815
 
               type=str,
2816
 
               help="Name of the root directory inside the exported file."),
2817
 
        Option('per-file-timestamps',
2818
 
               help='Set modification time of files to that of the last '
2819
 
                    'revision in which it was changed.'),
2820
 
        ]
 
3365
    takes_options = ['directory',
 
3366
                     Option('format',
 
3367
                            help="Type of file to export to.",
 
3368
                            type=text_type),
 
3369
                     'revision',
 
3370
                     Option('filters', help='Apply content filters to export the '
 
3371
                            'convenient form.'),
 
3372
                     Option('root',
 
3373
                            type=text_type,
 
3374
                            help="Name of the root directory inside the exported file."),
 
3375
                     Option('per-file-timestamps',
 
3376
                            help='Set modification time of files to that of the last '
 
3377
                            'revision in which it was changed.'),
 
3378
                     Option('uncommitted',
 
3379
                            help='Export the working tree contents rather than that of the '
 
3380
                            'last revision.'),
 
3381
                     ]
 
3382
 
2821
3383
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2822
 
        root=None, filters=False, per_file_timestamps=False):
2823
 
        from bzrlib.export import export
 
3384
            root=None, filters=False, per_file_timestamps=False, uncommitted=False,
 
3385
            directory=u'.'):
 
3386
        from .export import export, guess_format, get_root_name
2824
3387
 
2825
3388
        if branch_or_subdir is None:
2826
 
            tree = WorkingTree.open_containing(u'.')[0]
2827
 
            b = tree.branch
2828
 
            subdir = None
2829
 
        else:
2830
 
            b, subdir = Branch.open_containing(branch_or_subdir)
2831
 
            tree = None
2832
 
 
2833
 
        rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
 
3389
            branch_or_subdir = directory
 
3390
 
 
3391
        (tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
 
3392
            branch_or_subdir)
 
3393
        if tree is not None:
 
3394
            self.enter_context(tree.lock_read())
 
3395
 
 
3396
        if uncommitted:
 
3397
            if tree is None:
 
3398
                raise errors.CommandError(
 
3399
                    gettext("--uncommitted requires a working tree"))
 
3400
            export_tree = tree
 
3401
        else:
 
3402
            export_tree = _get_one_revision_tree(
 
3403
                'export', revision, branch=b,
 
3404
                tree=tree)
 
3405
 
 
3406
        if format is None:
 
3407
            format = guess_format(dest)
 
3408
 
 
3409
        if root is None:
 
3410
            root = get_root_name(dest)
 
3411
 
 
3412
        if not per_file_timestamps:
 
3413
            force_mtime = time.time()
 
3414
        else:
 
3415
            force_mtime = None
 
3416
 
 
3417
        if filters:
 
3418
            from breezy.filter_tree import ContentFilterTree
 
3419
            export_tree = ContentFilterTree(
 
3420
                export_tree, export_tree._content_filter_stack)
 
3421
 
2834
3422
        try:
2835
 
            export(rev_tree, dest, format, root, subdir, filtered=filters,
 
3423
            export(export_tree, dest, format, root, subdir,
2836
3424
                   per_file_timestamps=per_file_timestamps)
2837
 
        except errors.NoSuchExportFormat, e:
2838
 
            raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
 
3425
        except errors.NoSuchExportFormat as e:
 
3426
            raise errors.CommandError(
 
3427
                gettext('Unsupported export format: %s') % e.format)
2839
3428
 
2840
3429
 
2841
3430
class cmd_cat(Command):
2848
3437
    """
2849
3438
 
2850
3439
    _see_also = ['ls']
2851
 
    takes_options = [
2852
 
        Option('name-from-revision', help='The path name in the old tree.'),
2853
 
        Option('filters', help='Apply content filters to display the '
2854
 
                'convenience form.'),
2855
 
        'revision',
2856
 
        ]
 
3440
    takes_options = ['directory',
 
3441
                     Option('name-from-revision',
 
3442
                            help='The path name in the old tree.'),
 
3443
                     Option('filters', help='Apply content filters to display the '
 
3444
                            'convenience form.'),
 
3445
                     'revision',
 
3446
                     ]
2857
3447
    takes_args = ['filename']
2858
3448
    encoding_type = 'exact'
2859
3449
 
2860
3450
    @display_command
2861
3451
    def run(self, filename, revision=None, name_from_revision=False,
2862
 
            filters=False):
 
3452
            filters=False, directory=None):
2863
3453
        if revision is not None and len(revision) != 1:
2864
 
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2865
 
                                         " one revision specifier")
 
3454
            raise errors.CommandError(gettext("brz cat --revision takes exactly"
 
3455
                                                 " one revision specifier"))
2866
3456
        tree, branch, relpath = \
2867
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
 
        self.add_cleanup(branch.lock_read().unlock)
 
3457
            _open_directory_or_containing_tree_or_branch(filename, directory)
 
3458
        self.enter_context(branch.lock_read())
2869
3459
        return self._run(tree, branch, relpath, filename, revision,
2870
3460
                         name_from_revision, filters)
2871
3461
 
2872
3462
    def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2873
 
        filtered):
 
3463
             filtered):
 
3464
        import shutil
2874
3465
        if tree is None:
2875
3466
            tree = b.basis_tree()
2876
3467
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
 
        self.add_cleanup(rev_tree.lock_read().unlock)
2878
 
 
2879
 
        old_file_id = rev_tree.path2id(relpath)
 
3468
        self.enter_context(rev_tree.lock_read())
2880
3469
 
2881
3470
        if name_from_revision:
2882
3471
            # Try in revision if requested
2883
 
            if old_file_id is None:
2884
 
                raise errors.BzrCommandError(
2885
 
                    "%r is not present in revision %s" % (
 
3472
            if not rev_tree.is_versioned(relpath):
 
3473
                raise errors.CommandError(gettext(
 
3474
                    "{0!r} is not present in revision {1}").format(
2886
3475
                        filename, rev_tree.get_revision_id()))
2887
 
            else:
2888
 
                content = rev_tree.get_file_text(old_file_id)
 
3476
            rev_tree_path = relpath
2889
3477
        else:
2890
 
            cur_file_id = tree.path2id(relpath)
2891
 
            found = False
2892
 
            if cur_file_id is not None:
2893
 
                # Then try with the actual file id
2894
 
                try:
2895
 
                    content = rev_tree.get_file_text(cur_file_id)
2896
 
                    found = True
2897
 
                except errors.NoSuchId:
2898
 
                    # The actual file id didn't exist at that time
2899
 
                    pass
2900
 
            if not found and old_file_id is not None:
2901
 
                # Finally try with the old file id
2902
 
                content = rev_tree.get_file_text(old_file_id)
2903
 
                found = True
2904
 
            if not found:
2905
 
                # Can't be found anywhere
2906
 
                raise errors.BzrCommandError(
2907
 
                    "%r is not present in revision %s" % (
2908
 
                        filename, rev_tree.get_revision_id()))
 
3478
            try:
 
3479
                rev_tree_path = _mod_tree.find_previous_path(
 
3480
                    tree, rev_tree, relpath)
 
3481
            except errors.NoSuchFile:
 
3482
                rev_tree_path = None
 
3483
 
 
3484
            if rev_tree_path is None:
 
3485
                # Path didn't exist in working tree
 
3486
                if not rev_tree.is_versioned(relpath):
 
3487
                    raise errors.CommandError(gettext(
 
3488
                        "{0!r} is not present in revision {1}").format(
 
3489
                            filename, rev_tree.get_revision_id()))
 
3490
                else:
 
3491
                    # Fall back to the same path in the basis tree, if present.
 
3492
                    rev_tree_path = relpath
 
3493
 
2909
3494
        if filtered:
2910
 
            from bzrlib.filters import (
2911
 
                ContentFilterContext,
2912
 
                filtered_output_bytes,
2913
 
                )
2914
 
            filters = rev_tree._content_filter_stack(relpath)
2915
 
            chunks = content.splitlines(True)
2916
 
            content = filtered_output_bytes(chunks, filters,
2917
 
                ContentFilterContext(relpath, rev_tree))
2918
 
            self.cleanup_now()
2919
 
            self.outf.writelines(content)
 
3495
            from .filter_tree import ContentFilterTree
 
3496
            filter_tree = ContentFilterTree(
 
3497
                rev_tree, rev_tree._content_filter_stack)
 
3498
            fileobj = filter_tree.get_file(rev_tree_path)
2920
3499
        else:
2921
 
            self.cleanup_now()
2922
 
            self.outf.write(content)
 
3500
            fileobj = rev_tree.get_file(rev_tree_path)
 
3501
        shutil.copyfileobj(fileobj, self.outf)
 
3502
        self.cleanup_now()
2923
3503
 
2924
3504
 
2925
3505
class cmd_local_time_offset(Command):
2926
3506
    __doc__ = """Show the offset in seconds from GMT to local time."""
2927
3507
    hidden = True
 
3508
 
2928
3509
    @display_command
2929
3510
    def run(self):
2930
3511
        self.outf.write("%s\n" % osutils.local_time_offset())
2931
3512
 
2932
3513
 
2933
 
 
2934
3514
class cmd_commit(Command):
2935
3515
    __doc__ = """Commit changes into a new revision.
2936
3516
 
2950
3530
      If selected files are specified, only changes to those files are
2951
3531
      committed.  If a directory is specified then the directory and
2952
3532
      everything within it is committed.
2953
 
  
 
3533
 
2954
3534
      When excludes are given, they take precedence over selected files.
2955
3535
      For example, to commit only changes within foo, but not changes
2956
3536
      within foo/bar::
2957
 
  
2958
 
        bzr commit foo -x foo/bar
2959
 
  
 
3537
 
 
3538
        brz commit foo -x foo/bar
 
3539
 
2960
3540
      A selective commit after a merge is not yet supported.
2961
3541
 
2962
3542
    :Custom authors:
2967
3547
      "John Doe <jdoe@example.com>". If there is more than one author of
2968
3548
      the change you can specify the option multiple times, once for each
2969
3549
      author.
2970
 
  
 
3550
 
2971
3551
    :Checks:
2972
3552
 
2973
3553
      A common mistake is to forget to add a new file or directory before
2974
3554
      running the commit command. The --strict option checks for unknown
2975
3555
      files and aborts the commit if any are found. More advanced pre-commit
2976
 
      checks can be implemented by defining hooks. See ``bzr help hooks``
 
3556
      checks can be implemented by defining hooks. See ``brz help hooks``
2977
3557
      for details.
2978
3558
 
2979
3559
    :Things to note:
2980
3560
 
2981
 
      If you accidentially commit the wrong changes or make a spelling
 
3561
      If you accidentally commit the wrong changes or make a spelling
2982
3562
      mistake in the commit message say, you can use the uncommit command
2983
 
      to undo it. See ``bzr help uncommit`` for details.
 
3563
      to undo it. See ``brz help uncommit`` for details.
2984
3564
 
2985
3565
      Hooks can also be configured to run after a commit. This allows you
2986
3566
      to trigger updates to external systems like bug trackers. The --fixes
2987
3567
      option can be used to record the association between a revision and
2988
 
      one or more bugs. See ``bzr help bugs`` for details.
2989
 
 
2990
 
      A selective commit may fail in some cases where the committed
2991
 
      tree would be invalid. Consider::
2992
 
  
2993
 
        bzr init foo
2994
 
        mkdir foo/bar
2995
 
        bzr add foo/bar
2996
 
        bzr commit foo -m "committing foo"
2997
 
        bzr mv foo/bar foo/baz
2998
 
        mkdir foo/bar
2999
 
        bzr add foo/bar
3000
 
        bzr commit foo/bar -m "committing bar but not baz"
3001
 
  
3002
 
      In the example above, the last commit will fail by design. This gives
3003
 
      the user the opportunity to decide whether they want to commit the
3004
 
      rename at the same time, separately first, or not at all. (As a general
3005
 
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
 
3568
      one or more bugs. See ``brz help bugs`` for details.
3006
3569
    """
3007
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
3008
 
 
3009
 
    # TODO: Strict commit that fails if there are deleted files.
3010
 
    #       (what does "deleted files" mean ??)
3011
 
 
3012
 
    # TODO: Give better message for -s, --summary, used by tla people
3013
 
 
3014
 
    # XXX: verbose currently does nothing
3015
3570
 
3016
3571
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3017
3572
    takes_args = ['selected*']
3018
3573
    takes_options = [
3019
 
            ListOption('exclude', type=str, short_name='x',
3020
 
                help="Do not consider changes made to a given path."),
3021
 
            Option('message', type=unicode,
3022
 
                   short_name='m',
3023
 
                   help="Description of the new revision."),
3024
 
            'verbose',
3025
 
             Option('unchanged',
3026
 
                    help='Commit even if nothing has changed.'),
3027
 
             Option('file', type=str,
3028
 
                    short_name='F',
3029
 
                    argname='msgfile',
3030
 
                    help='Take commit message from this file.'),
3031
 
             Option('strict',
3032
 
                    help="Refuse to commit if there are unknown "
3033
 
                    "files in the working tree."),
3034
 
             Option('commit-time', type=str,
3035
 
                    help="Manually set a commit time using commit date "
3036
 
                    "format, e.g. '2009-10-10 08:00:00 +0100'."),
3037
 
             ListOption('fixes', type=str,
3038
 
                    help="Mark a bug as being fixed by this revision "
3039
 
                         "(see \"bzr help bugs\")."),
3040
 
             ListOption('author', type=unicode,
3041
 
                    help="Set the author's name, if it's different "
3042
 
                         "from the committer."),
3043
 
             Option('local',
3044
 
                    help="Perform a local commit in a bound "
3045
 
                         "branch.  Local commits are not pushed to "
3046
 
                         "the master branch until a normal commit "
3047
 
                         "is performed."
3048
 
                    ),
3049
 
             Option('show-diff', short_name='p',
3050
 
                    help='When no message is supplied, show the diff along'
3051
 
                    ' with the status summary in the message editor.'),
3052
 
             ]
 
3574
        ListOption(
 
3575
            'exclude', type=text_type, short_name='x',
 
3576
            help="Do not consider changes made to a given path."),
 
3577
        Option('message', type=text_type,
 
3578
               short_name='m',
 
3579
               help="Description of the new revision."),
 
3580
        'verbose',
 
3581
        Option('unchanged',
 
3582
               help='Commit even if nothing has changed.'),
 
3583
        Option('file', type=text_type,
 
3584
               short_name='F',
 
3585
               argname='msgfile',
 
3586
               help='Take commit message from this file.'),
 
3587
        Option('strict',
 
3588
               help="Refuse to commit if there are unknown "
 
3589
               "files in the working tree."),
 
3590
        Option('commit-time', type=text_type,
 
3591
               help="Manually set a commit time using commit date "
 
3592
               "format, e.g. '2009-10-10 08:00:00 +0100'."),
 
3593
        ListOption(
 
3594
            'bugs', type=text_type,
 
3595
            help="Link to a related bug. (see \"brz help bugs\")."),
 
3596
        ListOption(
 
3597
            'fixes', type=text_type,
 
3598
            help="Mark a bug as being fixed by this revision "
 
3599
                 "(see \"brz help bugs\")."),
 
3600
        ListOption(
 
3601
            'author', type=text_type,
 
3602
            help="Set the author's name, if it's different "
 
3603
                 "from the committer."),
 
3604
        Option('local',
 
3605
               help="Perform a local commit in a bound "
 
3606
                    "branch.  Local commits are not pushed to "
 
3607
                    "the master branch until a normal commit "
 
3608
                    "is performed."
 
3609
               ),
 
3610
        Option('show-diff', short_name='p',
 
3611
               help='When no message is supplied, show the diff along'
 
3612
               ' with the status summary in the message editor.'),
 
3613
        Option('lossy',
 
3614
               help='When committing to a foreign version control '
 
3615
               'system do not push data that can not be natively '
 
3616
               'represented.'), ]
3053
3617
    aliases = ['ci', 'checkin']
3054
3618
 
3055
 
    def _iter_bug_fix_urls(self, fixes, branch):
 
3619
    def _iter_bug_urls(self, bugs, branch, status):
 
3620
        default_bugtracker = None
3056
3621
        # Configure the properties for bug fixing attributes.
3057
 
        for fixed_bug in fixes:
3058
 
            tokens = fixed_bug.split(':')
3059
 
            if len(tokens) != 2:
3060
 
                raise errors.BzrCommandError(
 
3622
        for bug in bugs:
 
3623
            tokens = bug.split(':')
 
3624
            if len(tokens) == 1:
 
3625
                if default_bugtracker is None:
 
3626
                    branch_config = branch.get_config_stack()
 
3627
                    default_bugtracker = branch_config.get(
 
3628
                        "bugtracker")
 
3629
                if default_bugtracker is None:
 
3630
                    raise errors.CommandError(gettext(
 
3631
                        "No tracker specified for bug %s. Use the form "
 
3632
                        "'tracker:id' or specify a default bug tracker "
 
3633
                        "using the `bugtracker` option.\nSee "
 
3634
                        "\"brz help bugs\" for more information on this "
 
3635
                        "feature. Commit refused.") % bug)
 
3636
                tag = default_bugtracker
 
3637
                bug_id = tokens[0]
 
3638
            elif len(tokens) != 2:
 
3639
                raise errors.CommandError(gettext(
3061
3640
                    "Invalid bug %s. Must be in the form of 'tracker:id'. "
3062
 
                    "See \"bzr help bugs\" for more information on this "
3063
 
                    "feature.\nCommit refused." % fixed_bug)
3064
 
            tag, bug_id = tokens
 
3641
                    "See \"brz help bugs\" for more information on this "
 
3642
                    "feature.\nCommit refused.") % bug)
 
3643
            else:
 
3644
                tag, bug_id = tokens
3065
3645
            try:
3066
 
                yield bugtracker.get_bug_url(tag, branch, bug_id)
3067
 
            except errors.UnknownBugTrackerAbbreviation:
3068
 
                raise errors.BzrCommandError(
3069
 
                    'Unrecognized bug %s. Commit refused.' % fixed_bug)
3070
 
            except errors.MalformedBugIdentifier, e:
3071
 
                raise errors.BzrCommandError(
3072
 
                    "%s\nCommit refused." % (str(e),))
 
3646
                yield bugtracker.get_bug_url(tag, branch, bug_id), status
 
3647
            except bugtracker.UnknownBugTrackerAbbreviation:
 
3648
                raise errors.CommandError(gettext(
 
3649
                    'Unrecognized bug %s. Commit refused.') % bug)
 
3650
            except bugtracker.MalformedBugIdentifier as e:
 
3651
                raise errors.CommandError(gettext(
 
3652
                    u"%s\nCommit refused.") % (e,))
3073
3653
 
3074
3654
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3075
 
            unchanged=False, strict=False, local=False, fixes=None,
3076
 
            author=None, show_diff=False, exclude=None, commit_time=None):
3077
 
        from bzrlib.errors import (
 
3655
            unchanged=False, strict=False, local=False, fixes=None, bugs=None,
 
3656
            author=None, show_diff=False, exclude=None, commit_time=None,
 
3657
            lossy=False):
 
3658
        import itertools
 
3659
        from .commit import (
3078
3660
            PointlessCommit,
 
3661
            )
 
3662
        from .errors import (
3079
3663
            ConflictsInTree,
3080
3664
            StrictCommitFailed
3081
3665
        )
3082
 
        from bzrlib.msgeditor import (
 
3666
        from .msgeditor import (
3083
3667
            edit_commit_message_encoded,
3084
3668
            generate_commit_message_template,
3085
 
            make_commit_message_template_encoded
 
3669
            make_commit_message_template_encoded,
 
3670
            set_commit_message,
3086
3671
        )
3087
3672
 
3088
3673
        commit_stamp = offset = None
3089
3674
        if commit_time is not None:
3090
3675
            try:
3091
3676
                commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3092
 
            except ValueError, e:
3093
 
                raise errors.BzrCommandError(
3094
 
                    "Could not parse --commit-time: " + str(e))
3095
 
 
3096
 
        # TODO: Need a blackbox test for invoking the external editor; may be
3097
 
        # slightly problematic to run this cross-platform.
3098
 
 
3099
 
        # TODO: do more checks that the commit will succeed before
3100
 
        # spending the user's valuable time typing a commit message.
 
3677
            except ValueError as e:
 
3678
                raise errors.CommandError(gettext(
 
3679
                    "Could not parse --commit-time: " + str(e)))
3101
3680
 
3102
3681
        properties = {}
3103
3682
 
3104
 
        tree, selected_list = tree_files(selected_list)
 
3683
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3105
3684
        if selected_list == ['']:
3106
3685
            # workaround - commit of root of tree should be exactly the same
3107
3686
            # as just default commit in that tree, and succeed even though
3110
3689
 
3111
3690
        if fixes is None:
3112
3691
            fixes = []
 
3692
        if bugs is None:
 
3693
            bugs = []
3113
3694
        bug_property = bugtracker.encode_fixes_bug_urls(
3114
 
            self._iter_bug_fix_urls(fixes, tree.branch))
 
3695
            itertools.chain(
 
3696
                self._iter_bug_urls(bugs, tree.branch, bugtracker.RELATED),
 
3697
                self._iter_bug_urls(fixes, tree.branch, bugtracker.FIXED)))
3115
3698
        if bug_property:
3116
 
            properties['bugs'] = bug_property
 
3699
            properties[u'bugs'] = bug_property
3117
3700
 
3118
3701
        if local and not tree.branch.get_bound_location():
3119
3702
            raise errors.LocalRequiresBoundBranch()
3130
3713
                warning_msg = (
3131
3714
                    'The commit message is a file name: "%(f)s".\n'
3132
3715
                    '(use --file "%(f)s" to take commit message from that file)'
3133
 
                    % { 'f': message })
 
3716
                    % {'f': message})
3134
3717
                ui.ui_factory.show_warning(warning_msg)
3135
3718
            if '\r' in message:
3136
3719
                message = message.replace('\r\n', '\n')
3137
3720
                message = message.replace('\r', '\n')
3138
3721
            if file:
3139
 
                raise errors.BzrCommandError(
3140
 
                    "please specify either --message or --file")
 
3722
                raise errors.CommandError(gettext(
 
3723
                    "please specify either --message or --file"))
3141
3724
 
3142
3725
        def get_message(commit_obj):
3143
3726
            """Callback to get commit message"""
3144
3727
            if file:
3145
 
                my_message = codecs.open(
3146
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3728
                with open(file, 'rb') as f:
 
3729
                    my_message = f.read().decode(osutils.get_user_encoding())
3147
3730
            elif message is not None:
3148
3731
                my_message = message
3149
3732
            else:
3150
3733
                # No message supplied: make one up.
3151
3734
                # text is the status of the tree
3152
3735
                text = make_commit_message_template_encoded(tree,
3153
 
                        selected_list, diff=show_diff,
3154
 
                        output_encoding=osutils.get_user_encoding())
 
3736
                                                            selected_list, diff=show_diff,
 
3737
                                                            output_encoding=osutils.get_user_encoding())
3155
3738
                # start_message is the template generated from hooks
3156
3739
                # XXX: Warning - looks like hooks return unicode,
3157
3740
                # make_commit_message_template_encoded returns user encoding.
3158
3741
                # We probably want to be using edit_commit_message instead to
3159
3742
                # avoid this.
3160
 
                start_message = generate_commit_message_template(commit_obj)
3161
 
                my_message = edit_commit_message_encoded(text,
3162
 
                    start_message=start_message)
3163
 
                if my_message is None:
3164
 
                    raise errors.BzrCommandError("please specify a commit"
3165
 
                        " message with either --message or --file")
3166
 
            if my_message == "":
3167
 
                raise errors.BzrCommandError("empty commit message specified")
 
3743
                my_message = set_commit_message(commit_obj)
 
3744
                if my_message is None:
 
3745
                    start_message = generate_commit_message_template(
 
3746
                        commit_obj)
 
3747
                    if start_message is not None:
 
3748
                        start_message = start_message.encode(
 
3749
                            osutils.get_user_encoding())
 
3750
                    my_message = edit_commit_message_encoded(text,
 
3751
                                                             start_message=start_message)
 
3752
                if my_message is None:
 
3753
                    raise errors.CommandError(gettext("please specify a commit"
 
3754
                                                         " message with either --message or --file"))
 
3755
                if my_message == "":
 
3756
                    raise errors.CommandError(gettext("Empty commit message specified."
 
3757
                                                         " Please specify a commit message with either"
 
3758
                                                         " --message or --file or leave a blank message"
 
3759
                                                         " with --message \"\"."))
3168
3760
            return my_message
3169
3761
 
3170
3762
        # The API permits a commit with a filter of [] to mean 'select nothing'
3178
3770
                        reporter=None, verbose=verbose, revprops=properties,
3179
3771
                        authors=author, timestamp=commit_stamp,
3180
3772
                        timezone=offset,
3181
 
                        exclude=safe_relpath_files(tree, exclude))
 
3773
                        exclude=tree.safe_relpath_files(exclude),
 
3774
                        lossy=lossy)
3182
3775
        except PointlessCommit:
3183
 
            raise errors.BzrCommandError("No changes to commit."
3184
 
                              " Use --unchanged to commit anyhow.")
 
3776
            raise errors.CommandError(gettext("No changes to commit."
 
3777
                                                 " Please 'brz add' the files you want to commit, or use"
 
3778
                                                 " --unchanged to force an empty commit."))
3185
3779
        except ConflictsInTree:
3186
 
            raise errors.BzrCommandError('Conflicts detected in working '
3187
 
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3188
 
                ' resolve.')
 
3780
            raise errors.CommandError(gettext('Conflicts detected in working '
 
3781
                                                 'tree.  Use "brz conflicts" to list, "brz resolve FILE" to'
 
3782
                                                 ' resolve.'))
3189
3783
        except StrictCommitFailed:
3190
 
            raise errors.BzrCommandError("Commit refused because there are"
3191
 
                              " unknown files in the working tree.")
3192
 
        except errors.BoundBranchOutOfDate, e:
3193
 
            e.extra_help = ("\n"
3194
 
                'To commit to master branch, run update and then commit.\n'
3195
 
                'You can also pass --local to commit to continue working '
3196
 
                'disconnected.')
 
3784
            raise errors.CommandError(gettext("Commit refused because there are"
 
3785
                                                 " unknown files in the working tree."))
 
3786
        except errors.BoundBranchOutOfDate as e:
 
3787
            e.extra_help = (gettext("\n"
 
3788
                                    'To commit to master branch, run update and then commit.\n'
 
3789
                                    'You can also pass --local to commit to continue working '
 
3790
                                    'disconnected.'))
3197
3791
            raise
3198
3792
 
3199
3793
 
3201
3795
    __doc__ = """Validate working tree structure, branch consistency and repository history.
3202
3796
 
3203
3797
    This command checks various invariants about branch and repository storage
3204
 
    to detect data corruption or bzr bugs.
 
3798
    to detect data corruption or brz bugs.
3205
3799
 
3206
3800
    The working tree and branch checks will only give output if a problem is
3207
3801
    detected. The output fields of the repository check are:
3217
3811
    unreferenced ancestors
3218
3812
        Texts that are ancestors of other texts, but
3219
3813
        are not properly referenced by the revision ancestry.  This is a
3220
 
        subtle problem that Bazaar can work around.
 
3814
        subtle problem that Breezy can work around.
3221
3815
 
3222
3816
    unique file texts
3223
3817
        This is the total number of unique file contents
3229
3823
        entries are modified, but the file contents are not.  It does not
3230
3824
        indicate a problem.
3231
3825
 
3232
 
    If no restrictions are specified, all Bazaar data that is found at the given
 
3826
    If no restrictions are specified, all data that is found at the given
3233
3827
    location will be checked.
3234
3828
 
3235
3829
    :Examples:
3236
3830
 
3237
3831
        Check the tree and branch at 'foo'::
3238
3832
 
3239
 
            bzr check --tree --branch foo
 
3833
            brz check --tree --branch foo
3240
3834
 
3241
3835
        Check only the repository at 'bar'::
3242
3836
 
3243
 
            bzr check --repo bar
 
3837
            brz check --repo bar
3244
3838
 
3245
3839
        Check everything at 'baz'::
3246
3840
 
3247
 
            bzr check baz
 
3841
            brz check baz
3248
3842
    """
3249
3843
 
3250
3844
    _see_also = ['reconcile']
3259
3853
 
3260
3854
    def run(self, path=None, verbose=False, branch=False, repo=False,
3261
3855
            tree=False):
3262
 
        from bzrlib.check import check_dwim
 
3856
        from .check import check_dwim
3263
3857
        if path is None:
3264
3858
            path = '.'
3265
3859
        if not branch and not repo and not tree:
3268
3862
 
3269
3863
 
3270
3864
class cmd_upgrade(Command):
3271
 
    __doc__ = """Upgrade branch storage to current format.
3272
 
 
3273
 
    The check command or bzr developers may sometimes advise you to run
3274
 
    this command. When the default format has changed you may also be warned
3275
 
    during other operations to upgrade.
 
3865
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3866
 
 
3867
    When the default format has changed after a major new release of
 
3868
    Bazaar/Breezy, you may be informed during certain operations that you
 
3869
    should upgrade. Upgrading to a newer format may improve performance
 
3870
    or make new features available. It may however limit interoperability
 
3871
    with older repositories or with older versions of Bazaar or Breezy.
 
3872
 
 
3873
    If you wish to upgrade to a particular format rather than the
 
3874
    current default, that can be specified using the --format option.
 
3875
    As a consequence, you can use the upgrade command this way to
 
3876
    "downgrade" to an earlier format, though some conversions are
 
3877
    a one way process (e.g. changing from the 1.x default to the
 
3878
    2.x default) so downgrading is not always possible.
 
3879
 
 
3880
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3881
    process (where # is a number). By default, this is left there on
 
3882
    completion. If the conversion fails, delete the new .bzr directory
 
3883
    and rename this one back in its place. Use the --clean option to ask
 
3884
    for the backup.bzr directory to be removed on successful conversion.
 
3885
    Alternatively, you can delete it by hand if everything looks good
 
3886
    afterwards.
 
3887
 
 
3888
    If the location given is a shared repository, dependent branches
 
3889
    are also converted provided the repository converts successfully.
 
3890
    If the conversion of a branch fails, remaining branches are still
 
3891
    tried.
 
3892
 
 
3893
    For more information on upgrades, see the Breezy Upgrade Guide,
 
3894
    https://www.breezy-vcs.org/doc/en/upgrade-guide/.
3276
3895
    """
3277
3896
 
3278
 
    _see_also = ['check']
 
3897
    _see_also = ['check', 'reconcile', 'formats']
3279
3898
    takes_args = ['url?']
3280
3899
    takes_options = [
3281
 
                    RegistryOption('format',
3282
 
                        help='Upgrade to a specific format.  See "bzr help'
3283
 
                             ' formats" for details.',
3284
 
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3285
 
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3286
 
                        value_switches=True, title='Branch format'),
3287
 
                    ]
 
3900
        RegistryOption('format',
 
3901
                       help='Upgrade to a specific format.  See "brz help'
 
3902
                       ' formats" for details.',
 
3903
                       lazy_registry=('breezy.controldir', 'format_registry'),
 
3904
                       converter=lambda name: controldir.format_registry.make_controldir(
 
3905
                           name),
 
3906
                       value_switches=True, title='Branch format'),
 
3907
        Option('clean',
 
3908
               help='Remove the backup.bzr directory if successful.'),
 
3909
        Option('dry-run',
 
3910
               help="Show what would be done, but don't actually do anything."),
 
3911
    ]
3288
3912
 
3289
 
    def run(self, url='.', format=None):
3290
 
        from bzrlib.upgrade import upgrade
3291
 
        upgrade(url, format)
 
3913
    def run(self, url='.', format=None, clean=False, dry_run=False):
 
3914
        from .upgrade import upgrade
 
3915
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3916
        if exceptions:
 
3917
            if len(exceptions) == 1:
 
3918
                # Compatibility with historical behavior
 
3919
                raise exceptions[0]
 
3920
            else:
 
3921
                return 3
3292
3922
 
3293
3923
 
3294
3924
class cmd_whoami(Command):
3295
 
    __doc__ = """Show or set bzr user id.
 
3925
    __doc__ = """Show or set brz user id.
3296
3926
 
3297
3927
    :Examples:
3298
3928
        Show the email of the current user::
3299
3929
 
3300
 
            bzr whoami --email
 
3930
            brz whoami --email
3301
3931
 
3302
3932
        Set the current user::
3303
3933
 
3304
 
            bzr whoami "Frank Chu <fchu@example.com>"
 
3934
            brz whoami "Frank Chu <fchu@example.com>"
3305
3935
    """
3306
 
    takes_options = [ Option('email',
3307
 
                             help='Display email address only.'),
3308
 
                      Option('branch',
3309
 
                             help='Set identity for the current branch instead of '
3310
 
                                  'globally.'),
3311
 
                    ]
 
3936
    takes_options = ['directory',
 
3937
                     Option('email',
 
3938
                            help='Display email address only.'),
 
3939
                     Option('branch',
 
3940
                            help='Set identity for the current branch instead of '
 
3941
                            'globally.'),
 
3942
                     ]
3312
3943
    takes_args = ['name?']
3313
3944
    encoding_type = 'replace'
3314
3945
 
3315
3946
    @display_command
3316
 
    def run(self, email=False, branch=False, name=None):
 
3947
    def run(self, email=False, branch=False, name=None, directory=None):
3317
3948
        if name is None:
3318
 
            # use branch if we're inside one; otherwise global config
3319
 
            try:
3320
 
                c = Branch.open_containing('.')[0].get_config()
3321
 
            except errors.NotBranchError:
3322
 
                c = config.GlobalConfig()
 
3949
            if directory is None:
 
3950
                # use branch if we're inside one; otherwise global config
 
3951
                try:
 
3952
                    c = Branch.open_containing(u'.')[0].get_config_stack()
 
3953
                except errors.NotBranchError:
 
3954
                    c = _mod_config.GlobalStack()
 
3955
            else:
 
3956
                c = Branch.open(directory).get_config_stack()
 
3957
            identity = c.get('email')
3323
3958
            if email:
3324
 
                self.outf.write(c.user_email() + '\n')
 
3959
                self.outf.write(_mod_config.extract_email_address(identity)
 
3960
                                + '\n')
3325
3961
            else:
3326
 
                self.outf.write(c.username() + '\n')
 
3962
                self.outf.write(identity + '\n')
3327
3963
            return
3328
3964
 
 
3965
        if email:
 
3966
            raise errors.CommandError(gettext("--email can only be used to display existing "
 
3967
                                                 "identity"))
 
3968
 
3329
3969
        # display a warning if an email address isn't included in the given name.
3330
3970
        try:
3331
 
            config.extract_email_address(name)
3332
 
        except errors.NoEmailInUsername, e:
 
3971
            _mod_config.extract_email_address(name)
 
3972
        except _mod_config.NoEmailInUsername:
3333
3973
            warning('"%s" does not seem to contain an email address.  '
3334
3974
                    'This is allowed, but not recommended.', name)
3335
3975
 
3336
3976
        # use global config unless --branch given
3337
3977
        if branch:
3338
 
            c = Branch.open_containing('.')[0].get_config()
 
3978
            if directory is None:
 
3979
                c = Branch.open_containing(u'.')[0].get_config_stack()
 
3980
            else:
 
3981
                b = Branch.open(directory)
 
3982
                self.enter_context(b.lock_write())
 
3983
                c = b.get_config_stack()
3339
3984
        else:
3340
 
            c = config.GlobalConfig()
3341
 
        c.set_user_option('email', name)
 
3985
            c = _mod_config.GlobalStack()
 
3986
        c.set('email', name)
3342
3987
 
3343
3988
 
3344
3989
class cmd_nick(Command):
3345
3990
    __doc__ = """Print or set the branch nickname.
3346
3991
 
3347
 
    If unset, the tree root directory name is used as the nickname.
3348
 
    To print the current nickname, execute with no argument.
 
3992
    If unset, the colocated branch name is used for colocated branches, and
 
3993
    the branch directory name is used for other branches.  To print the
 
3994
    current nickname, execute with no argument.
3349
3995
 
3350
3996
    Bound branches use the nickname of its master branch unless it is set
3351
3997
    locally.
3353
3999
 
3354
4000
    _see_also = ['info']
3355
4001
    takes_args = ['nickname?']
3356
 
    def run(self, nickname=None):
3357
 
        branch = Branch.open_containing(u'.')[0]
 
4002
    takes_options = ['directory']
 
4003
 
 
4004
    def run(self, nickname=None, directory=u'.'):
 
4005
        branch = Branch.open_containing(directory)[0]
3358
4006
        if nickname is None:
3359
4007
            self.printme(branch)
3360
4008
        else:
3371
4019
    :Examples:
3372
4020
        Show the current aliases::
3373
4021
 
3374
 
            bzr alias
 
4022
            brz alias
3375
4023
 
3376
4024
        Show the alias specified for 'll'::
3377
4025
 
3378
 
            bzr alias ll
 
4026
            brz alias ll
3379
4027
 
3380
4028
        Set an alias for 'll'::
3381
4029
 
3382
 
            bzr alias ll="log --line -r-10..-1"
 
4030
            brz alias ll="log --line -r-10..-1"
3383
4031
 
3384
4032
        To remove an alias for 'll'::
3385
4033
 
3386
 
            bzr alias --remove ll
 
4034
            brz alias --remove ll
3387
4035
 
3388
4036
    """
3389
4037
    takes_args = ['name?']
3401
4049
            if equal_pos == -1:
3402
4050
                self.print_alias(name)
3403
4051
            else:
3404
 
                self.set_alias(name[:equal_pos], name[equal_pos+1:])
 
4052
                self.set_alias(name[:equal_pos], name[equal_pos + 1:])
3405
4053
 
3406
4054
    def remove_alias(self, alias_name):
3407
4055
        if alias_name is None:
3408
 
            raise errors.BzrCommandError(
3409
 
                'bzr alias --remove expects an alias to remove.')
 
4056
            raise errors.CommandError(gettext(
 
4057
                'brz alias --remove expects an alias to remove.'))
3410
4058
        # If alias is not found, print something like:
3411
4059
        # unalias: foo: not found
3412
 
        c = config.GlobalConfig()
 
4060
        c = _mod_config.GlobalConfig()
3413
4061
        c.unset_alias(alias_name)
3414
4062
 
3415
4063
    @display_command
3416
4064
    def print_aliases(self):
3417
4065
        """Print out the defined aliases in a similar format to bash."""
3418
 
        aliases = config.GlobalConfig().get_aliases()
3419
 
        for key, value in sorted(aliases.iteritems()):
3420
 
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
 
4066
        aliases = _mod_config.GlobalConfig().get_aliases()
 
4067
        for key, value in sorted(viewitems(aliases)):
 
4068
            self.outf.write('brz alias %s="%s"\n' % (key, value))
3421
4069
 
3422
4070
    @display_command
3423
4071
    def print_alias(self, alias_name):
3424
 
        from bzrlib.commands import get_alias
 
4072
        from .commands import get_alias
3425
4073
        alias = get_alias(alias_name)
3426
4074
        if alias is None:
3427
 
            self.outf.write("bzr alias: %s: not found\n" % alias_name)
 
4075
            self.outf.write("brz alias: %s: not found\n" % alias_name)
3428
4076
        else:
3429
4077
            self.outf.write(
3430
 
                'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
 
4078
                'brz alias %s="%s"\n' % (alias_name, ' '.join(alias)))
3431
4079
 
3432
4080
    def set_alias(self, alias_name, alias_command):
3433
4081
        """Save the alias in the global config."""
3434
 
        c = config.GlobalConfig()
 
4082
        c = _mod_config.GlobalConfig()
3435
4083
        c.set_alias(alias_name, alias_command)
3436
4084
 
3437
4085
 
3469
4117
    Tests that need working space on disk use a common temporary directory,
3470
4118
    typically inside $TMPDIR or /tmp.
3471
4119
 
3472
 
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
 
4120
    If you set BRZ_TEST_PDB=1 when running selftest, failing tests will drop
3473
4121
    into a pdb postmortem session.
3474
4122
 
 
4123
    The --coverage=DIRNAME global option produces a report with covered code
 
4124
    indicated.
 
4125
 
3475
4126
    :Examples:
3476
4127
        Run only tests relating to 'ignore'::
3477
4128
 
3478
 
            bzr selftest ignore
 
4129
            brz selftest ignore
3479
4130
 
3480
4131
        Disable plugins and list tests as they're run::
3481
4132
 
3482
 
            bzr --no-plugins selftest -v
 
4133
            brz --no-plugins selftest -v
3483
4134
    """
3484
4135
    # NB: this is used from the class without creating an instance, which is
3485
4136
    # why it does not have a self parameter.
 
4137
 
3486
4138
    def get_transport_type(typestring):
3487
4139
        """Parse and return a transport specifier."""
3488
4140
        if typestring == "sftp":
3489
 
            from bzrlib.tests import stub_sftp
 
4141
            from .tests import stub_sftp
3490
4142
            return stub_sftp.SFTPAbsoluteServer
3491
 
        if typestring == "memory":
3492
 
            from bzrlib.tests import test_server
 
4143
        elif typestring == "memory":
 
4144
            from .tests import test_server
3493
4145
            return memory.MemoryServer
3494
 
        if typestring == "fakenfs":
3495
 
            from bzrlib.tests import test_server
 
4146
        elif typestring == "fakenfs":
 
4147
            from .tests import test_server
3496
4148
            return test_server.FakeNFSServer
3497
4149
        msg = "No known transport type %s. Supported types are: sftp\n" %\
3498
4150
            (typestring)
3499
 
        raise errors.BzrCommandError(msg)
 
4151
        raise errors.CommandError(msg)
3500
4152
 
3501
4153
    hidden = True
3502
4154
    takes_args = ['testspecs*']
3503
4155
    takes_options = ['verbose',
3504
4156
                     Option('one',
3505
 
                             help='Stop when one test fails.',
3506
 
                             short_name='1',
3507
 
                             ),
 
4157
                            help='Stop when one test fails.',
 
4158
                            short_name='1',
 
4159
                            ),
3508
4160
                     Option('transport',
3509
4161
                            help='Use a different transport by default '
3510
4162
                                 'throughout the test suite.',
3511
4163
                            type=get_transport_type),
3512
4164
                     Option('benchmark',
3513
 
                            help='Run the benchmarks rather than selftests.'),
 
4165
                            help='Run the benchmarks rather than selftests.',
 
4166
                            hidden=True),
3514
4167
                     Option('lsprof-timed',
3515
4168
                            help='Generate lsprof output for benchmarked'
3516
4169
                                 ' sections of code.'),
3517
4170
                     Option('lsprof-tests',
3518
4171
                            help='Generate lsprof output for each test.'),
3519
 
                     Option('cache-dir', type=str,
3520
 
                            help='Cache intermediate benchmark output in this '
3521
 
                                 'directory.'),
3522
4172
                     Option('first',
3523
4173
                            help='Run all tests, but run specified tests first.',
3524
4174
                            short_name='f',
3526
4176
                     Option('list-only',
3527
4177
                            help='List the tests instead of running them.'),
3528
4178
                     RegistryOption('parallel',
3529
 
                        help="Run the test suite in parallel.",
3530
 
                        lazy_registry=('bzrlib.tests', 'parallel_registry'),
3531
 
                        value_switches=False,
3532
 
                        ),
3533
 
                     Option('randomize', type=str, argname="SEED",
 
4179
                                    help="Run the test suite in parallel.",
 
4180
                                    lazy_registry=(
 
4181
                                        'breezy.tests', 'parallel_registry'),
 
4182
                                    value_switches=False,
 
4183
                                    ),
 
4184
                     Option('randomize', type=text_type, argname="SEED",
3534
4185
                            help='Randomize the order of tests using the given'
3535
4186
                                 ' seed or "now" for the current time.'),
3536
 
                     Option('exclude', type=str, argname="PATTERN",
3537
 
                            short_name='x',
3538
 
                            help='Exclude tests that match this regular'
3539
 
                                 ' expression.'),
3540
 
                     Option('subunit',
3541
 
                        help='Output test progress via subunit.'),
 
4187
                     ListOption('exclude', type=text_type, argname="PATTERN",
 
4188
                                short_name='x',
 
4189
                                help='Exclude tests that match this regular'
 
4190
                                ' expression.'),
 
4191
                     Option('subunit1',
 
4192
                            help='Output test progress via subunit v1.'),
 
4193
                     Option('subunit2',
 
4194
                            help='Output test progress via subunit v2.'),
3542
4195
                     Option('strict', help='Fail on missing dependencies or '
3543
4196
                            'known failures.'),
3544
 
                     Option('load-list', type=str, argname='TESTLISTFILE',
 
4197
                     Option('load-list', type=text_type, argname='TESTLISTFILE',
3545
4198
                            help='Load a test id list from a text file.'),
3546
 
                     ListOption('debugflag', type=str, short_name='E',
 
4199
                     ListOption('debugflag', type=text_type, short_name='E',
3547
4200
                                help='Turn on a selftest debug flag.'),
3548
 
                     ListOption('starting-with', type=str, argname='TESTID',
 
4201
                     ListOption('starting-with', type=text_type, argname='TESTID',
3549
4202
                                param_name='starting_with', short_name='s',
3550
 
                                help=
3551
 
                                'Load only the tests starting with TESTID.'),
 
4203
                                help='Load only the tests starting with TESTID.'),
 
4204
                     Option('sync',
 
4205
                            help="By default we disable fsync and fdatasync"
 
4206
                                 " while running the test suite.")
3552
4207
                     ]
3553
4208
    encoding_type = 'replace'
3554
4209
 
3558
4213
 
3559
4214
    def run(self, testspecs_list=None, verbose=False, one=False,
3560
4215
            transport=None, benchmark=None,
3561
 
            lsprof_timed=None, cache_dir=None,
 
4216
            lsprof_timed=None,
3562
4217
            first=False, list_only=False,
3563
4218
            randomize=None, exclude=None, strict=False,
3564
 
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3565
 
            parallel=None, lsprof_tests=False):
3566
 
        from bzrlib.tests import selftest
3567
 
        import bzrlib.benchmarks as benchmarks
3568
 
        from bzrlib.benchmarks import tree_creator
3569
 
 
3570
 
        # Make deprecation warnings visible, unless -Werror is set
3571
 
        symbol_versioning.activate_deprecation_warnings(override=False)
3572
 
 
3573
 
        if cache_dir is not None:
3574
 
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
4219
            load_list=None, debugflag=None, starting_with=None, subunit1=False,
 
4220
            subunit2=False, parallel=None, lsprof_tests=False, sync=False):
 
4221
 
 
4222
        # During selftest, disallow proxying, as it can cause severe
 
4223
        # performance penalties and is only needed for thread
 
4224
        # safety. The selftest command is assumed to not use threads
 
4225
        # too heavily. The call should be as early as possible, as
 
4226
        # error reporting for past duplicate imports won't have useful
 
4227
        # backtraces.
 
4228
        if sys.version_info[0] < 3:
 
4229
            # TODO(pad.lv/1696545): Allow proxying on Python 3, since
 
4230
            # disallowing it currently leads to failures in many places.
 
4231
            lazy_import.disallow_proxying()
 
4232
 
 
4233
        try:
 
4234
            from . import tests
 
4235
        except ImportError as e:
 
4236
            raise errors.CommandError("tests not available. Install the "
 
4237
                                         "breezy tests to run the breezy testsuite.")
 
4238
 
3575
4239
        if testspecs_list is not None:
3576
4240
            pattern = '|'.join(testspecs_list)
3577
4241
        else:
3578
4242
            pattern = ".*"
3579
 
        if subunit:
 
4243
        if subunit1:
3580
4244
            try:
3581
 
                from bzrlib.tests import SubUnitBzrRunner
 
4245
                from .tests import SubUnitBzrRunnerv1
3582
4246
            except ImportError:
3583
 
                raise errors.BzrCommandError("subunit not available. subunit "
3584
 
                    "needs to be installed to use --subunit.")
3585
 
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
 
4247
                raise errors.CommandError(gettext(
 
4248
                    "subunit not available. subunit needs to be installed "
 
4249
                    "to use --subunit."))
 
4250
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunnerv1
3586
4251
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3587
 
            # stdout, which would corrupt the subunit stream. 
3588
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
4252
            # stdout, which would corrupt the subunit stream.
 
4253
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
4254
            # following code can be deleted when it's sufficiently deployed
 
4255
            # -- vila/mgz 20100514
 
4256
            if (sys.platform == "win32"
 
4257
                    and getattr(sys.stdout, 'fileno', None) is not None):
3589
4258
                import msvcrt
3590
4259
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
 
4260
        if subunit2:
 
4261
            try:
 
4262
                from .tests import SubUnitBzrRunnerv2
 
4263
            except ImportError:
 
4264
                raise errors.CommandError(gettext(
 
4265
                    "subunit not available. subunit "
 
4266
                    "needs to be installed to use --subunit2."))
 
4267
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunnerv2
 
4268
 
3591
4269
        if parallel:
3592
4270
            self.additional_selftest_args.setdefault(
3593
4271
                'suite_decorators', []).append(parallel)
3594
4272
        if benchmark:
3595
 
            test_suite_factory = benchmarks.test_suite
3596
 
            # Unless user explicitly asks for quiet, be verbose in benchmarks
3597
 
            verbose = not is_quiet()
3598
 
            # TODO: should possibly lock the history file...
3599
 
            benchfile = open(".perf_history", "at", buffering=1)
3600
 
            self.add_cleanup(benchfile.close)
 
4273
            raise errors.CommandError(gettext(
 
4274
                "--benchmark is no longer supported from brz 2.2; "
 
4275
                "use bzr-usertest instead"))
 
4276
        test_suite_factory = None
 
4277
        if not exclude:
 
4278
            exclude_pattern = None
3601
4279
        else:
3602
 
            test_suite_factory = None
3603
 
            benchfile = None
 
4280
            exclude_pattern = '(' + '|'.join(exclude) + ')'
 
4281
        if not sync:
 
4282
            self._disable_fsync()
3604
4283
        selftest_kwargs = {"verbose": verbose,
3605
 
                          "pattern": pattern,
3606
 
                          "stop_on_failure": one,
3607
 
                          "transport": transport,
3608
 
                          "test_suite_factory": test_suite_factory,
3609
 
                          "lsprof_timed": lsprof_timed,
3610
 
                          "lsprof_tests": lsprof_tests,
3611
 
                          "bench_history": benchfile,
3612
 
                          "matching_tests_first": first,
3613
 
                          "list_only": list_only,
3614
 
                          "random_seed": randomize,
3615
 
                          "exclude_pattern": exclude,
3616
 
                          "strict": strict,
3617
 
                          "load_list": load_list,
3618
 
                          "debug_flags": debugflag,
3619
 
                          "starting_with": starting_with
3620
 
                          }
 
4284
                           "pattern": pattern,
 
4285
                           "stop_on_failure": one,
 
4286
                           "transport": transport,
 
4287
                           "test_suite_factory": test_suite_factory,
 
4288
                           "lsprof_timed": lsprof_timed,
 
4289
                           "lsprof_tests": lsprof_tests,
 
4290
                           "matching_tests_first": first,
 
4291
                           "list_only": list_only,
 
4292
                           "random_seed": randomize,
 
4293
                           "exclude_pattern": exclude_pattern,
 
4294
                           "strict": strict,
 
4295
                           "load_list": load_list,
 
4296
                           "debug_flags": debugflag,
 
4297
                           "starting_with": starting_with
 
4298
                           }
3621
4299
        selftest_kwargs.update(self.additional_selftest_args)
3622
 
        result = selftest(**selftest_kwargs)
 
4300
 
 
4301
        # Make deprecation warnings visible, unless -Werror is set
 
4302
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
4303
            override=False)
 
4304
        try:
 
4305
            result = tests.selftest(**selftest_kwargs)
 
4306
        finally:
 
4307
            cleanup()
3623
4308
        return int(not result)
3624
4309
 
 
4310
    def _disable_fsync(self):
 
4311
        """Change the 'os' functionality to not synchronize."""
 
4312
        self._orig_fsync = getattr(os, 'fsync', None)
 
4313
        if self._orig_fsync is not None:
 
4314
            os.fsync = lambda filedes: None
 
4315
        self._orig_fdatasync = getattr(os, 'fdatasync', None)
 
4316
        if self._orig_fdatasync is not None:
 
4317
            os.fdatasync = lambda filedes: None
 
4318
 
3625
4319
 
3626
4320
class cmd_version(Command):
3627
 
    __doc__ = """Show version of bzr."""
 
4321
    __doc__ = """Show version of brz."""
3628
4322
 
3629
4323
    encoding_type = 'replace'
3630
4324
    takes_options = [
3633
4327
 
3634
4328
    @display_command
3635
4329
    def run(self, short=False):
3636
 
        from bzrlib.version import show_version
 
4330
        from .version import show_version
3637
4331
        if short:
3638
 
            self.outf.write(bzrlib.version_string + '\n')
 
4332
            self.outf.write(breezy.version_string + '\n')
3639
4333
        else:
3640
4334
            show_version(to_file=self.outf)
3641
4335
 
3647
4341
 
3648
4342
    @display_command
3649
4343
    def run(self):
3650
 
        self.outf.write("It sure does!\n")
 
4344
        self.outf.write(gettext("It sure does!\n"))
3651
4345
 
3652
4346
 
3653
4347
class cmd_find_merge_base(Command):
3659
4353
 
3660
4354
    @display_command
3661
4355
    def run(self, branch, other):
3662
 
        from bzrlib.revision import ensure_null
 
4356
        from .revision import ensure_null
3663
4357
 
3664
4358
        branch1 = Branch.open_containing(branch)[0]
3665
4359
        branch2 = Branch.open_containing(other)[0]
3666
 
        self.add_cleanup(branch1.lock_read().unlock)
3667
 
        self.add_cleanup(branch2.lock_read().unlock)
 
4360
        self.enter_context(branch1.lock_read())
 
4361
        self.enter_context(branch2.lock_read())
3668
4362
        last1 = ensure_null(branch1.last_revision())
3669
4363
        last2 = ensure_null(branch2.last_revision())
3670
4364
 
3671
4365
        graph = branch1.repository.get_graph(branch2.repository)
3672
4366
        base_rev_id = graph.find_unique_lca(last1, last2)
3673
4367
 
3674
 
        self.outf.write('merge base is revision %s\n' % base_rev_id)
 
4368
        self.outf.write(gettext('merge base is revision %s\n') %
 
4369
                        base_rev_id.decode('utf-8'))
3675
4370
 
3676
4371
 
3677
4372
class cmd_merge(Command):
3679
4374
 
3680
4375
    The source of the merge can be specified either in the form of a branch,
3681
4376
    or in the form of a path to a file containing a merge directive generated
3682
 
    with bzr send. If neither is specified, the default is the upstream branch
3683
 
    or the branch most recently merged using --remember.
3684
 
 
3685
 
    When merging a branch, by default the tip will be merged. To pick a different
3686
 
    revision, pass --revision. If you specify two values, the first will be used as
3687
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3688
 
    available revisions, like this is commonly referred to as "cherrypicking".
3689
 
 
3690
 
    Revision numbers are always relative to the branch being merged.
3691
 
 
3692
 
    By default, bzr will try to merge in all new work from the other
3693
 
    branch, automatically determining an appropriate base.  If this
3694
 
    fails, you may need to give an explicit base.
 
4377
    with brz send. If neither is specified, the default is the upstream branch
 
4378
    or the branch most recently merged using --remember.  The source of the
 
4379
    merge may also be specified in the form of a path to a file in another
 
4380
    branch:  in this case, only the modifications to that file are merged into
 
4381
    the current working tree.
 
4382
 
 
4383
    When merging from a branch, by default brz will try to merge in all new
 
4384
    work from the other branch, automatically determining an appropriate base
 
4385
    revision.  If this fails, you may need to give an explicit base.
 
4386
 
 
4387
    To pick a different ending revision, pass "--revision OTHER".  brz will
 
4388
    try to merge in all new work up to and including revision OTHER.
 
4389
 
 
4390
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
4391
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
4392
    causes some revisions to be skipped, i.e. if the destination branch does
 
4393
    not already contain revision BASE, such a merge is commonly referred to as
 
4394
    a "cherrypick". Unlike a normal merge, Breezy does not currently track
 
4395
    cherrypicks. The changes look like a normal commit, and the history of the
 
4396
    changes from the other branch is not stored in the commit.
 
4397
 
 
4398
    Revision numbers are always relative to the source branch.
3695
4399
 
3696
4400
    Merge will do its best to combine the changes in two branches, but there
3697
4401
    are some kinds of problems only a human can fix.  When it encounters those,
3698
4402
    it will mark a conflict.  A conflict means that you need to fix something,
3699
 
    before you should commit.
3700
 
 
3701
 
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
3702
 
 
3703
 
    If there is no default branch set, the first merge will set it. After
3704
 
    that, you can omit the branch to use the default.  To change the
3705
 
    default, use --remember. The value will only be saved if the remote
3706
 
    location can be accessed.
 
4403
    before you can commit.
 
4404
 
 
4405
    Use brz resolve when you have fixed a problem.  See also brz conflicts.
 
4406
 
 
4407
    If there is no default branch set, the first merge will set it (use
 
4408
    --no-remember to avoid setting it). After that, you can omit the branch
 
4409
    to use the default.  To change the default, use --remember. The value will
 
4410
    only be saved if the remote location can be accessed.
3707
4411
 
3708
4412
    The results of the merge are placed into the destination working
3709
 
    directory, where they can be reviewed (with bzr diff), tested, and then
 
4413
    directory, where they can be reviewed (with brz diff), tested, and then
3710
4414
    committed to record the result of the merge.
3711
4415
 
3712
4416
    merge refuses to run if there are any uncommitted changes, unless
3713
 
    --force is given. The --force option can also be used to create a
 
4417
    --force is given.  If --force is given, then the changes from the source
 
4418
    will be merged with the current working tree, including any uncommitted
 
4419
    changes in the tree.  The --force option can also be used to create a
3714
4420
    merge revision which has more than two parents.
3715
4421
 
3716
4422
    If one would like to merge changes from the working tree of the other
3721
4427
    you to apply each diff hunk and file change, similar to "shelve".
3722
4428
 
3723
4429
    :Examples:
3724
 
        To merge the latest revision from bzr.dev::
3725
 
 
3726
 
            bzr merge ../bzr.dev
3727
 
 
3728
 
        To merge changes up to and including revision 82 from bzr.dev::
3729
 
 
3730
 
            bzr merge -r 82 ../bzr.dev
 
4430
        To merge all new revisions from brz.dev::
 
4431
 
 
4432
            brz merge ../brz.dev
 
4433
 
 
4434
        To merge changes up to and including revision 82 from brz.dev::
 
4435
 
 
4436
            brz merge -r 82 ../brz.dev
3731
4437
 
3732
4438
        To merge the changes introduced by 82, without previous changes::
3733
4439
 
3734
 
            bzr merge -r 81..82 ../bzr.dev
 
4440
            brz merge -r 81..82 ../brz.dev
3735
4441
 
3736
4442
        To apply a merge directive contained in /tmp/merge::
3737
4443
 
3738
 
            bzr merge /tmp/merge
 
4444
            brz merge /tmp/merge
3739
4445
 
3740
4446
        To create a merge revision with three parents from two branches
3741
4447
        feature1a and feature1b:
3742
4448
 
3743
 
            bzr merge ../feature1a
3744
 
            bzr merge ../feature1b --force
3745
 
            bzr commit -m 'revision with three parents'
 
4449
            brz merge ../feature1a
 
4450
            brz merge ../feature1b --force
 
4451
            brz commit -m 'revision with three parents'
3746
4452
    """
3747
4453
 
3748
4454
    encoding_type = 'exact'
3761
4467
        Option('uncommitted', help='Apply uncommitted changes'
3762
4468
               ' from a working copy, instead of branch changes.'),
3763
4469
        Option('pull', help='If the destination is already'
3764
 
                ' completely merged into the source, pull from the'
3765
 
                ' source rather than merging.  When this happens,'
3766
 
                ' you do not need to commit the result.'),
3767
 
        Option('directory',
3768
 
               help='Branch to merge into, '
3769
 
                    'rather than the one containing the working directory.',
3770
 
               short_name='d',
3771
 
               type=unicode,
3772
 
               ),
 
4470
               ' completely merged into the source, pull from the'
 
4471
               ' source rather than merging.  When this happens,'
 
4472
               ' you do not need to commit the result.'),
 
4473
        custom_help('directory',
 
4474
                    help='Branch to merge into, '
 
4475
                    'rather than the one containing the working directory.'),
3773
4476
        Option('preview', help='Instead of merging, show a diff of the'
3774
4477
               ' merge.'),
3775
4478
        Option('interactive', help='Select changes interactively.',
3776
 
            short_name='i')
 
4479
               short_name='i')
3777
4480
    ]
3778
4481
 
3779
4482
    def run(self, location=None, revision=None, force=False,
3780
 
            merge_type=None, show_base=False, reprocess=None, remember=False,
 
4483
            merge_type=None, show_base=False, reprocess=None, remember=None,
3781
4484
            uncommitted=False, pull=False,
3782
4485
            directory=None,
3783
4486
            preview=False,
3786
4489
        if merge_type is None:
3787
4490
            merge_type = _mod_merge.Merge3Merger
3788
4491
 
3789
 
        if directory is None: directory = u'.'
 
4492
        if directory is None:
 
4493
            directory = u'.'
3790
4494
        possible_transports = []
3791
4495
        merger = None
3792
4496
        allow_pending = True
3793
4497
        verified = 'inapplicable'
 
4498
 
3794
4499
        tree = WorkingTree.open_containing(directory)[0]
3795
 
 
3796
 
        try:
3797
 
            basis_tree = tree.revision_tree(tree.last_revision())
3798
 
        except errors.NoSuchRevision:
3799
 
            basis_tree = tree.basis_tree()
 
4500
        if tree.branch.last_revision() == _mod_revision.NULL_REVISION:
 
4501
            raise errors.CommandError(gettext('Merging into empty branches not currently supported, '
 
4502
                                                 'https://bugs.launchpad.net/bzr/+bug/308562'))
3800
4503
 
3801
4504
        # die as quickly as possible if there are uncommitted changes
3802
4505
        if not force:
3807
4510
        change_reporter = delta._ChangeReporter(
3808
4511
            unversioned_filter=tree.is_ignored, view_info=view_info)
3809
4512
        pb = ui.ui_factory.nested_progress_bar()
3810
 
        self.add_cleanup(pb.finished)
3811
 
        self.add_cleanup(tree.lock_write().unlock)
 
4513
        self.enter_context(pb)
 
4514
        self.enter_context(tree.lock_write())
3812
4515
        if location is not None:
3813
4516
            try:
3814
 
                mergeable = bundle.read_mergeable_from_url(location,
3815
 
                    possible_transports=possible_transports)
 
4517
                mergeable = _mod_mergeable.read_mergeable_from_url(
 
4518
                    location, possible_transports=possible_transports)
3816
4519
            except errors.NotABundle:
3817
4520
                mergeable = None
3818
4521
            else:
3819
4522
                if uncommitted:
3820
 
                    raise errors.BzrCommandError('Cannot use --uncommitted'
3821
 
                        ' with bundles or merge directives.')
 
4523
                    raise errors.CommandError(gettext('Cannot use --uncommitted'
 
4524
                                                         ' with bundles or merge directives.'))
3822
4525
 
3823
4526
                if revision is not None:
3824
 
                    raise errors.BzrCommandError(
3825
 
                        'Cannot use -r with merge directives or bundles')
 
4527
                    raise errors.CommandError(gettext(
 
4528
                        'Cannot use -r with merge directives or bundles'))
3826
4529
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
3827
 
                   mergeable, None)
 
4530
                                                                    mergeable)
3828
4531
 
3829
4532
        if merger is None and uncommitted:
3830
4533
            if revision is not None and len(revision) > 0:
3831
 
                raise errors.BzrCommandError('Cannot use --uncommitted and'
3832
 
                    ' --revision at the same time.')
 
4534
                raise errors.CommandError(gettext('Cannot use --uncommitted and'
 
4535
                                                     ' --revision at the same time.'))
3833
4536
            merger = self.get_merger_from_uncommitted(tree, location, None)
3834
4537
            allow_pending = False
3835
4538
 
3836
4539
        if merger is None:
3837
4540
            merger, allow_pending = self._get_merger_from_branch(tree,
3838
 
                location, revision, remember, possible_transports, None)
 
4541
                                                                 location, revision, remember, possible_transports, None)
3839
4542
 
3840
4543
        merger.merge_type = merge_type
3841
4544
        merger.reprocess = reprocess
3842
4545
        merger.show_base = show_base
3843
4546
        self.sanity_check_merger(merger)
3844
4547
        if (merger.base_rev_id == merger.other_rev_id and
3845
 
            merger.other_rev_id is not None):
3846
 
            note('Nothing to do.')
 
4548
                merger.other_rev_id is not None):
 
4549
            # check if location is a nonexistent file (and not a branch) to
 
4550
            # disambiguate the 'Nothing to do'
 
4551
            if merger.interesting_files:
 
4552
                if not merger.other_tree.has_filename(
 
4553
                        merger.interesting_files[0]):
 
4554
                    note(gettext("merger: ") + str(merger))
 
4555
                    raise errors.PathsDoNotExist([location])
 
4556
            note(gettext('Nothing to do.'))
3847
4557
            return 0
3848
 
        if pull:
 
4558
        if pull and not preview:
3849
4559
            if merger.interesting_files is not None:
3850
 
                raise errors.BzrCommandError('Cannot pull individual files')
 
4560
                raise errors.CommandError(
 
4561
                    gettext('Cannot pull individual files'))
3851
4562
            if (merger.base_rev_id == tree.last_revision()):
3852
4563
                result = tree.pull(merger.other_branch, False,
3853
4564
                                   merger.other_rev_id)
3854
4565
                result.report(self.outf)
3855
4566
                return 0
3856
4567
        if merger.this_basis is None:
3857
 
            raise errors.BzrCommandError(
 
4568
            raise errors.CommandError(gettext(
3858
4569
                "This branch has no commits."
3859
 
                " (perhaps you would prefer 'bzr pull')")
 
4570
                " (perhaps you would prefer 'brz pull')"))
3860
4571
        if preview:
3861
4572
            return self._do_preview(merger)
3862
4573
        elif interactive:
3868
4579
    def _get_preview(self, merger):
3869
4580
        tree_merger = merger.make_merger()
3870
4581
        tt = tree_merger.make_preview_transform()
3871
 
        self.add_cleanup(tt.finalize)
 
4582
        self.enter_context(tt)
3872
4583
        result_tree = tt.get_preview_tree()
3873
4584
        return result_tree
3874
4585
 
3875
4586
    def _do_preview(self, merger):
3876
 
        from bzrlib.diff import show_diff_trees
 
4587
        from .diff import show_diff_trees
3877
4588
        result_tree = self._get_preview(merger)
 
4589
        path_encoding = osutils.get_diff_header_encoding()
3878
4590
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3879
 
                        old_label='', new_label='')
 
4591
                        old_label='', new_label='',
 
4592
                        path_encoding=path_encoding)
3880
4593
 
3881
4594
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3882
4595
        merger.change_reporter = change_reporter
3897
4610
        Shelver to selectively remove the differences between the working tree
3898
4611
        and the preview tree.
3899
4612
        """
3900
 
        from bzrlib import shelf_ui
 
4613
        from . import shelf_ui
3901
4614
        result_tree = self._get_preview(merger)
3902
 
        writer = bzrlib.option.diff_writer_registry.get()
 
4615
        writer = breezy.option.diff_writer_registry.get()
3903
4616
        shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3904
4617
                                   reporter=shelf_ui.ApplyReporter(),
3905
 
                                   diff_writer=writer(sys.stdout))
 
4618
                                   diff_writer=writer(self.outf))
3906
4619
        try:
3907
4620
            shelver.run()
3908
4621
        finally:
3910
4623
 
3911
4624
    def sanity_check_merger(self, merger):
3912
4625
        if (merger.show_base and
3913
 
            not merger.merge_type is _mod_merge.Merge3Merger):
3914
 
            raise errors.BzrCommandError("Show-base is not supported for this"
3915
 
                                         " merge type. %s" % merger.merge_type)
 
4626
                merger.merge_type is not _mod_merge.Merge3Merger):
 
4627
            raise errors.CommandError(gettext("Show-base is not supported for this"
 
4628
                                                 " merge type. %s") % merger.merge_type)
3916
4629
        if merger.reprocess is None:
3917
4630
            if merger.show_base:
3918
4631
                merger.reprocess = False
3920
4633
                # Use reprocess if the merger supports it
3921
4634
                merger.reprocess = merger.merge_type.supports_reprocess
3922
4635
        if merger.reprocess and not merger.merge_type.supports_reprocess:
3923
 
            raise errors.BzrCommandError("Conflict reduction is not supported"
3924
 
                                         " for merge type %s." %
 
4636
            raise errors.CommandError(gettext("Conflict reduction is not supported"
 
4637
                                                 " for merge type %s.") %
3925
4638
                                         merger.merge_type)
3926
4639
        if merger.reprocess and merger.show_base:
3927
 
            raise errors.BzrCommandError("Cannot do conflict reduction and"
3928
 
                                         " show base.")
 
4640
            raise errors.CommandError(gettext("Cannot do conflict reduction and"
 
4641
                                                 " show base."))
 
4642
 
 
4643
        if (merger.merge_type.requires_file_merge_plan and
 
4644
            (not getattr(merger.this_tree, 'plan_file_merge', None) or
 
4645
             not getattr(merger.other_tree, 'plan_file_merge', None) or
 
4646
             (merger.base_tree is not None and
 
4647
                 not getattr(merger.base_tree, 'plan_file_merge', None)))):
 
4648
            raise errors.CommandError(
 
4649
                gettext('Plan file merge unsupported: '
 
4650
                        'Merge type incompatible with tree formats.'))
3929
4651
 
3930
4652
    def _get_merger_from_branch(self, tree, location, revision, remember,
3931
4653
                                possible_transports, pb):
3932
4654
        """Produce a merger from a location, assuming it refers to a branch."""
3933
 
        from bzrlib.tag import _merge_tags_if_possible
3934
4655
        # find the branch locations
3935
4656
        other_loc, user_location = self._select_branch_location(tree, location,
3936
 
            revision, -1)
 
4657
                                                                revision, -1)
3937
4658
        if revision is not None and len(revision) == 2:
3938
4659
            base_loc, _unused = self._select_branch_location(tree,
3939
 
                location, revision, 0)
 
4660
                                                             location, revision, 0)
3940
4661
        else:
3941
4662
            base_loc = other_loc
3942
4663
        # Open the branches
3943
4664
        other_branch, other_path = Branch.open_containing(other_loc,
3944
 
            possible_transports)
 
4665
                                                          possible_transports)
3945
4666
        if base_loc == other_loc:
3946
4667
            base_branch = other_branch
3947
4668
        else:
3948
4669
            base_branch, base_path = Branch.open_containing(base_loc,
3949
 
                possible_transports)
 
4670
                                                            possible_transports)
3950
4671
        # Find the revision ids
3951
4672
        other_revision_id = None
3952
4673
        base_revision_id = None
3958
4679
        if other_revision_id is None:
3959
4680
            other_revision_id = _mod_revision.ensure_null(
3960
4681
                other_branch.last_revision())
3961
 
        # Remember where we merge from
3962
 
        if ((remember or tree.branch.get_submit_branch() is None) and
3963
 
             user_location is not None):
 
4682
        # Remember where we merge from. We need to remember if:
 
4683
        # - user specify a location (and we don't merge from the parent
 
4684
        #   branch)
 
4685
        # - user ask to remember or there is no previous location set to merge
 
4686
        #   from and user didn't ask to *not* remember
 
4687
        if (user_location is not None
 
4688
            and ((remember or
 
4689
                 (remember is None and
 
4690
                  tree.branch.get_submit_branch() is None)))):
3964
4691
            tree.branch.set_submit_branch(other_branch.base)
3965
 
        _merge_tags_if_possible(other_branch, tree.branch)
3966
 
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3967
 
            other_revision_id, base_revision_id, other_branch, base_branch)
 
4692
        # Merge tags (but don't set them in the master branch yet, the user
 
4693
        # might revert this merge).  Commit will propagate them.
 
4694
        other_branch.tags.merge_to(tree.branch.tags, ignore_master=True)
 
4695
        merger = _mod_merge.Merger.from_revision_ids(tree,
 
4696
                                                     other_revision_id, base_revision_id, other_branch, base_branch)
3968
4697
        if other_path != '':
3969
4698
            allow_pending = False
3970
4699
            merger.interesting_files = [other_path]
4005
4734
            will be the user-entered location.
4006
4735
        """
4007
4736
        if (revision is not None and index is not None
4008
 
            and revision[index] is not None):
 
4737
                and revision[index] is not None):
4009
4738
            branch = revision[index].get_branch()
4010
4739
            if branch is not None:
4011
4740
                return branch, branch
4027
4756
            stored_location_type = "parent"
4028
4757
        mutter("%s", stored_location)
4029
4758
        if stored_location is None:
4030
 
            raise errors.BzrCommandError("No location specified or remembered")
 
4759
            raise errors.CommandError(
 
4760
                gettext("No location specified or remembered"))
4031
4761
        display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4032
 
        note(u"%s remembered %s location %s", verb_string,
4033
 
                stored_location_type, display_url)
 
4762
        note(gettext("{0} remembered {1} location {2}").format(verb_string,
 
4763
                                                               stored_location_type, display_url))
4034
4764
        return stored_location
4035
4765
 
4036
4766
 
4049
4779
        Re-do the merge of all conflicted files, and show the base text in
4050
4780
        conflict regions, in addition to the usual THIS and OTHER texts::
4051
4781
 
4052
 
            bzr remerge --show-base
 
4782
            brz remerge --show-base
4053
4783
 
4054
4784
        Re-do the merge of "foobar", using the weave merge algorithm, with
4055
4785
        additional processing to reduce the size of conflict regions::
4056
4786
 
4057
 
            bzr remerge --merge-type weave --reprocess foobar
 
4787
            brz remerge --merge-type weave --reprocess foobar
4058
4788
    """
4059
4789
    takes_args = ['file*']
4060
4790
    takes_options = [
4061
 
            'merge-type',
4062
 
            'reprocess',
4063
 
            Option('show-base',
4064
 
                   help="Show base revision text in conflicts."),
4065
 
            ]
 
4791
        'merge-type',
 
4792
        'reprocess',
 
4793
        Option('show-base',
 
4794
               help="Show base revision text in conflicts."),
 
4795
        ]
4066
4796
 
4067
4797
    def run(self, file_list=None, merge_type=None, show_base=False,
4068
4798
            reprocess=False):
4069
 
        from bzrlib.conflicts import restore
 
4799
        from .conflicts import restore
4070
4800
        if merge_type is None:
4071
4801
            merge_type = _mod_merge.Merge3Merger
4072
 
        tree, file_list = tree_files(file_list)
4073
 
        self.add_cleanup(tree.lock_write().unlock)
 
4802
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4803
        self.enter_context(tree.lock_write())
4074
4804
        parents = tree.get_parent_ids()
4075
4805
        if len(parents) != 2:
4076
 
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4077
 
                                         " merges.  Not cherrypicking or"
4078
 
                                         " multi-merges.")
4079
 
        repository = tree.branch.repository
4080
 
        interesting_ids = None
 
4806
            raise errors.CommandError(
 
4807
                gettext("Sorry, remerge only works after normal"
 
4808
                        " merges.  Not cherrypicking or multi-merges."))
 
4809
        interesting_files = None
4081
4810
        new_conflicts = []
4082
4811
        conflicts = tree.conflicts()
4083
4812
        if file_list is not None:
4084
 
            interesting_ids = set()
 
4813
            interesting_files = set()
4085
4814
            for filename in file_list:
4086
 
                file_id = tree.path2id(filename)
4087
 
                if file_id is None:
 
4815
                if not tree.is_versioned(filename):
4088
4816
                    raise errors.NotVersionedError(filename)
4089
 
                interesting_ids.add(file_id)
4090
 
                if tree.kind(file_id) != "directory":
 
4817
                interesting_files.add(filename)
 
4818
                if tree.kind(filename) != "directory":
4091
4819
                    continue
4092
4820
 
4093
 
                for name, ie in tree.inventory.iter_entries(file_id):
4094
 
                    interesting_ids.add(ie.file_id)
 
4821
                for path, ie in tree.iter_entries_by_dir(
 
4822
                        specific_files=[filename]):
 
4823
                    interesting_files.add(path)
4095
4824
            new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4096
4825
        else:
4097
4826
            # Remerge only supports resolving contents conflicts
4098
4827
            allowed_conflicts = ('text conflict', 'contents conflict')
4099
4828
            restore_files = [c.path for c in conflicts
4100
4829
                             if c.typestring in allowed_conflicts]
4101
 
        _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4102
 
        tree.set_conflicts(ConflictList(new_conflicts))
 
4830
        _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_files)
 
4831
        tree.set_conflicts(new_conflicts)
4103
4832
        if file_list is not None:
4104
4833
            restore_files = file_list
4105
4834
        for filename in restore_files:
4114
4843
        # have not yet been seen.
4115
4844
        tree.set_parent_ids(parents[:1])
4116
4845
        try:
4117
 
            merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4118
 
            merger.interesting_ids = interesting_ids
 
4846
            merger = _mod_merge.Merger.from_revision_ids(tree, parents[1])
 
4847
            merger.interesting_files = interesting_files
4119
4848
            merger.merge_type = merge_type
4120
4849
            merger.show_base = show_base
4121
4850
            merger.reprocess = reprocess
4129
4858
 
4130
4859
 
4131
4860
class cmd_revert(Command):
4132
 
    __doc__ = """Revert files to a previous revision.
 
4861
    __doc__ = """\
 
4862
    Set files in the working tree back to the contents of a previous revision.
4133
4863
 
4134
4864
    Giving a list of files will revert only those files.  Otherwise, all files
4135
4865
    will be reverted.  If the revision is not specified with '--revision', the
4136
 
    last committed revision is used.
 
4866
    working tree basis revision is used. A revert operation affects only the
 
4867
    working tree, not any revision history like the branch and repository or
 
4868
    the working tree basis revision.
4137
4869
 
4138
4870
    To remove only some changes, without reverting to a prior version, use
4139
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4140
 
    changes introduced by -2, without affecting the changes introduced by -1.
4141
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
4871
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4872
    will remove the changes introduced by the second last commit (-2), without
 
4873
    affecting the changes introduced by the last commit (-1).  To remove
 
4874
    certain changes on a hunk-by-hunk basis, see the shelve command.
 
4875
    To update the branch to a specific revision or the latest revision and
 
4876
    update the working tree accordingly while preserving local changes, see the
 
4877
    update command.
4142
4878
 
4143
 
    By default, any files that have been manually changed will be backed up
4144
 
    first.  (Files changed only by merge are not backed up.)  Backup files have
4145
 
    '.~#~' appended to their name, where # is a number.
 
4879
    Uncommitted changes to files that are reverted will be discarded.
 
4880
    However, by default, any files that have been manually changed will be
 
4881
    backed up first.  (Files changed only by merge are not backed up.)  Backup
 
4882
    files have '.~#~' appended to their name, where # is a number.
4146
4883
 
4147
4884
    When you provide files, you can use their current pathname or the pathname
4148
4885
    from the target revision.  So you can use revert to "undelete" a file by
4158
4895
    not yet committed. These revisions will be included as additional parents
4159
4896
    of the next commit.  Normally, using revert clears that list as well as
4160
4897
    reverting the files.  If any files are specified, revert leaves the list
4161
 
    of uncommitted merges alone and reverts only the files.  Use ``bzr revert
 
4898
    of uncommitted merges alone and reverts only the files.  Use ``brz revert
4162
4899
    .`` in the tree root to revert all files but keep the recorded merges,
4163
 
    and ``bzr revert --forget-merges`` to clear the pending merge list without
 
4900
    and ``brz revert --forget-merges`` to clear the pending merge list without
4164
4901
    reverting any files.
4165
4902
 
4166
 
    Using "bzr revert --forget-merges", it is possible to apply all of the
 
4903
    Using "brz revert --forget-merges", it is possible to apply all of the
4167
4904
    changes from a branch in a single revision.  To do this, perform the merge
4168
4905
    as desired.  Then doing revert with the "--forget-merges" option will keep
4169
4906
    the content of the tree as it was, but it will clear the list of pending
4174
4911
    target branches.
4175
4912
    """
4176
4913
 
4177
 
    _see_also = ['cat', 'export']
 
4914
    _see_also = ['cat', 'export', 'merge', 'shelve']
4178
4915
    takes_options = [
4179
4916
        'revision',
4180
4917
        Option('no-backup', "Do not save backups of reverted files."),
4185
4922
 
4186
4923
    def run(self, revision=None, no_backup=False, file_list=None,
4187
4924
            forget_merges=None):
4188
 
        tree, file_list = tree_files(file_list)
4189
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
4925
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4926
        self.enter_context(tree.lock_tree_write())
4190
4927
        if forget_merges:
4191
4928
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4929
        else:
4196
4933
    def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4197
4934
        rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4198
4935
        tree.revert(file_list, rev_tree, not no_backup, None,
4199
 
            report_changes=True)
 
4936
                    report_changes=True)
4200
4937
 
4201
4938
 
4202
4939
class cmd_assert_fail(Command):
4215
4952
 
4216
4953
    _see_also = ['topics']
4217
4954
    takes_options = [
4218
 
            Option('long', 'Show help on all commands.'),
4219
 
            ]
 
4955
        Option('long', 'Show help on all commands.'),
 
4956
        ]
4220
4957
    takes_args = ['topic?']
4221
4958
    aliases = ['?', '--help', '-?', '-h']
4222
4959
 
4223
4960
    @display_command
4224
4961
    def run(self, topic=None, long=False):
4225
 
        import bzrlib.help
 
4962
        import breezy.help
4226
4963
        if topic is None and long:
4227
4964
            topic = "commands"
4228
 
        bzrlib.help.help(topic)
 
4965
        breezy.help.help(topic)
4229
4966
 
4230
4967
 
4231
4968
class cmd_shell_complete(Command):
4232
4969
    __doc__ = """Show appropriate completions for context.
4233
4970
 
4234
 
    For a list of all available commands, say 'bzr shell-complete'.
 
4971
    For a list of all available commands, say 'brz shell-complete'.
4235
4972
    """
4236
4973
    takes_args = ['context?']
4237
4974
    aliases = ['s-c']
4239
4976
 
4240
4977
    @display_command
4241
4978
    def run(self, context=None):
4242
 
        import shellcomplete
 
4979
        from . import shellcomplete
4243
4980
        shellcomplete.shellcomplete(context)
4244
4981
 
4245
4982
 
4251
4988
    To filter on a range of revisions, you can use the command -r begin..end
4252
4989
    -r revision requests a specific revision, -r ..end or -r begin.. are
4253
4990
    also valid.
4254
 
            
 
4991
 
4255
4992
    :Exit values:
4256
4993
        1 - some missing revisions
4257
4994
        0 - no missing revisions
4261
4998
        Determine the missing revisions between this and the branch at the
4262
4999
        remembered pull location::
4263
5000
 
4264
 
            bzr missing
 
5001
            brz missing
4265
5002
 
4266
5003
        Determine the missing revisions between this and another branch::
4267
5004
 
4268
 
            bzr missing http://server/branch
 
5005
            brz missing http://server/branch
4269
5006
 
4270
5007
        Determine the missing revisions up to a specific revision on the other
4271
5008
        branch::
4272
5009
 
4273
 
            bzr missing -r ..-10
 
5010
            brz missing -r ..-10
4274
5011
 
4275
5012
        Determine the missing revisions up to a specific revision on this
4276
5013
        branch::
4277
5014
 
4278
 
            bzr missing --my-revision ..-10
 
5015
            brz missing --my-revision ..-10
4279
5016
    """
4280
5017
 
4281
5018
    _see_also = ['merge', 'pull']
4282
5019
    takes_args = ['other_branch?']
4283
5020
    takes_options = [
 
5021
        'directory',
4284
5022
        Option('reverse', 'Reverse the order of revisions.'),
4285
5023
        Option('mine-only',
4286
5024
               'Display changes in the local branch only.'),
4287
 
        Option('this' , 'Same as --mine-only.'),
 
5025
        Option('this', 'Same as --mine-only.'),
4288
5026
        Option('theirs-only',
4289
5027
               'Display changes in the remote branch only.'),
4290
5028
        Option('other', 'Same as --theirs-only.'),
4292
5030
        'show-ids',
4293
5031
        'verbose',
4294
5032
        custom_help('revision',
4295
 
             help='Filter on other branch revisions (inclusive). '
4296
 
                'See "help revisionspec" for details.'),
 
5033
                    help='Filter on other branch revisions (inclusive). '
 
5034
                    'See "help revisionspec" for details.'),
4297
5035
        Option('my-revision',
4298
 
            type=_parse_revision_str,
4299
 
            help='Filter on local branch revisions (inclusive). '
4300
 
                'See "help revisionspec" for details.'),
4301
 
        Option('include-merges',
 
5036
               type=_parse_revision_str,
 
5037
               help='Filter on local branch revisions (inclusive). '
 
5038
               'See "help revisionspec" for details.'),
 
5039
        Option('include-merged',
4302
5040
               'Show all revisions in addition to the mainline ones.'),
 
5041
        Option('include-merges', hidden=True,
 
5042
               help='Historical alias for --include-merged.'),
4303
5043
        ]
4304
5044
    encoding_type = 'replace'
4305
5045
 
4308
5048
            theirs_only=False,
4309
5049
            log_format=None, long=False, short=False, line=False,
4310
5050
            show_ids=False, verbose=False, this=False, other=False,
4311
 
            include_merges=False, revision=None, my_revision=None):
4312
 
        from bzrlib.missing import find_unmerged, iter_log_revisions
 
5051
            include_merged=None, revision=None, my_revision=None,
 
5052
            directory=u'.'):
 
5053
        from breezy.missing import find_unmerged, iter_log_revisions
 
5054
 
4313
5055
        def message(s):
4314
5056
            if not is_quiet():
4315
5057
                self.outf.write(s)
4316
5058
 
 
5059
        if include_merged is None:
 
5060
            include_merged = False
4317
5061
        if this:
4318
5062
            mine_only = this
4319
5063
        if other:
4327
5071
        elif theirs_only:
4328
5072
            restrict = 'remote'
4329
5073
 
4330
 
        local_branch = Branch.open_containing(u".")[0]
4331
 
        self.add_cleanup(local_branch.lock_read().unlock)
 
5074
        local_branch = Branch.open_containing(directory)[0]
 
5075
        self.enter_context(local_branch.lock_read())
4332
5076
 
4333
5077
        parent = local_branch.get_parent()
4334
5078
        if other_branch is None:
4335
5079
            other_branch = parent
4336
5080
            if other_branch is None:
4337
 
                raise errors.BzrCommandError("No peer location known"
4338
 
                                             " or specified.")
 
5081
                raise errors.CommandError(gettext("No peer location known"
 
5082
                                                     " or specified."))
4339
5083
            display_url = urlutils.unescape_for_display(parent,
4340
5084
                                                        self.outf.encoding)
4341
 
            message("Using saved parent location: "
4342
 
                    + display_url + "\n")
 
5085
            message(gettext("Using saved parent location: {0}\n").format(
 
5086
                    display_url))
4343
5087
 
4344
5088
        remote_branch = Branch.open(other_branch)
4345
5089
        if remote_branch.base == local_branch.base:
4346
5090
            remote_branch = local_branch
4347
5091
        else:
4348
 
            self.add_cleanup(remote_branch.lock_read().unlock)
 
5092
            self.enter_context(remote_branch.lock_read())
4349
5093
 
4350
5094
        local_revid_range = _revision_range_to_revid_range(
4351
5095
            _get_revision_range(my_revision, local_branch,
4352
 
                self.name()))
 
5096
                                self.name()))
4353
5097
 
4354
5098
        remote_revid_range = _revision_range_to_revid_range(
4355
5099
            _get_revision_range(revision,
4356
 
                remote_branch, self.name()))
 
5100
                                remote_branch, self.name()))
4357
5101
 
4358
5102
        local_extra, remote_extra = find_unmerged(
4359
5103
            local_branch, remote_branch, restrict,
4360
5104
            backward=not reverse,
4361
 
            include_merges=include_merges,
 
5105
            include_merged=include_merged,
4362
5106
            local_revid_range=local_revid_range,
4363
5107
            remote_revid_range=remote_revid_range)
4364
5108
 
4371
5115
 
4372
5116
        status_code = 0
4373
5117
        if local_extra and not theirs_only:
4374
 
            message("You have %d extra revision(s):\n" %
4375
 
                len(local_extra))
 
5118
            message(ngettext("You have %d extra revision:\n",
 
5119
                             "You have %d extra revisions:\n",
 
5120
                             len(local_extra)) %
 
5121
                    len(local_extra))
 
5122
            rev_tag_dict = {}
 
5123
            if local_branch.supports_tags():
 
5124
                rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
4376
5125
            for revision in iter_log_revisions(local_extra,
4377
 
                                local_branch.repository,
4378
 
                                verbose):
 
5126
                                               local_branch.repository,
 
5127
                                               verbose,
 
5128
                                               rev_tag_dict):
4379
5129
                lf.log_revision(revision)
4380
5130
            printed_local = True
4381
5131
            status_code = 1
4385
5135
        if remote_extra and not mine_only:
4386
5136
            if printed_local is True:
4387
5137
                message("\n\n\n")
4388
 
            message("You are missing %d revision(s):\n" %
4389
 
                len(remote_extra))
 
5138
            message(ngettext("You are missing %d revision:\n",
 
5139
                             "You are missing %d revisions:\n",
 
5140
                             len(remote_extra)) %
 
5141
                    len(remote_extra))
 
5142
            if remote_branch.supports_tags():
 
5143
                rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
4390
5144
            for revision in iter_log_revisions(remote_extra,
4391
 
                                remote_branch.repository,
4392
 
                                verbose):
 
5145
                                               remote_branch.repository,
 
5146
                                               verbose,
 
5147
                                               rev_tag_dict):
4393
5148
                lf.log_revision(revision)
4394
5149
            status_code = 1
4395
5150
 
4396
5151
        if mine_only and not local_extra:
4397
5152
            # We checked local, and found nothing extra
4398
 
            message('This branch is up to date.\n')
 
5153
            message(gettext('This branch has no new revisions.\n'))
4399
5154
        elif theirs_only and not remote_extra:
4400
5155
            # We checked remote, and found nothing extra
4401
 
            message('Other branch is up to date.\n')
 
5156
            message(gettext('Other branch has no new revisions.\n'))
4402
5157
        elif not (mine_only or theirs_only or local_extra or
4403
5158
                  remote_extra):
4404
5159
            # We checked both branches, and neither one had extra
4405
5160
            # revisions
4406
 
            message("Branches are up to date.\n")
 
5161
            message(gettext("Branches are up to date.\n"))
4407
5162
        self.cleanup_now()
4408
5163
        if not status_code and parent is None and other_branch is not None:
4409
 
            self.add_cleanup(local_branch.lock_write().unlock)
 
5164
            self.enter_context(local_branch.lock_write())
4410
5165
            # handle race conditions - a parent might be set while we run.
4411
5166
            if local_branch.get_parent() is None:
4412
5167
                local_branch.set_parent(remote_branch.base)
4435
5190
    _see_also = ['repositories']
4436
5191
    takes_args = ['branch_or_repo?']
4437
5192
    takes_options = [
4438
 
        Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
 
5193
        Option('clean-obsolete-packs',
 
5194
               'Delete obsolete packs to save disk space.'),
4439
5195
        ]
4440
5196
 
4441
5197
    def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4442
 
        dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
 
5198
        dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
4443
5199
        try:
4444
5200
            branch = dir.open_branch()
4445
5201
            repository = branch.repository
4456
5212
 
4457
5213
    --verbose shows the path where each plugin is located.
4458
5214
 
4459
 
    A plugin is an external component for Bazaar that extends the
4460
 
    revision control system, by adding or replacing code in Bazaar.
 
5215
    A plugin is an external component for Breezy that extends the
 
5216
    revision control system, by adding or replacing code in Breezy.
4461
5217
    Plugins can do a variety of things, including overriding commands,
4462
5218
    adding new commands, providing additional network transports and
4463
5219
    customizing log output.
4471
5227
 
4472
5228
    @display_command
4473
5229
    def run(self, verbose=False):
4474
 
        import bzrlib.plugin
4475
 
        from inspect import getdoc
4476
 
        result = []
4477
 
        for name, plugin in bzrlib.plugin.plugins().items():
4478
 
            version = plugin.__version__
4479
 
            if version == 'unknown':
4480
 
                version = ''
4481
 
            name_ver = '%s %s' % (name, version)
4482
 
            d = getdoc(plugin.module)
4483
 
            if d:
4484
 
                doc = d.split('\n')[0]
4485
 
            else:
4486
 
                doc = '(no description)'
4487
 
            result.append((name_ver, doc, plugin.path()))
4488
 
        for name_ver, doc, path in sorted(result):
4489
 
            self.outf.write("%s\n" % name_ver)
4490
 
            self.outf.write("   %s\n" % doc)
4491
 
            if verbose:
4492
 
                self.outf.write("   %s\n" % path)
4493
 
            self.outf.write("\n")
 
5230
        from . import plugin
 
5231
        # Don't give writelines a generator as some codecs don't like that
 
5232
        self.outf.writelines(
 
5233
            list(plugin.describe_plugins(show_paths=verbose)))
4494
5234
 
4495
5235
 
4496
5236
class cmd_testament(Command):
4497
5237
    __doc__ = """Show testament (signing-form) of a revision."""
4498
5238
    takes_options = [
4499
 
            'revision',
4500
 
            Option('long', help='Produce long-format testament.'),
4501
 
            Option('strict',
4502
 
                   help='Produce a strict-format testament.')]
 
5239
        'revision',
 
5240
        Option('long', help='Produce long-format testament.'),
 
5241
        Option('strict',
 
5242
               help='Produce a strict-format testament.')]
4503
5243
    takes_args = ['branch?']
 
5244
    encoding_type = 'exact'
 
5245
 
4504
5246
    @display_command
4505
5247
    def run(self, branch=u'.', revision=None, long=False, strict=False):
4506
 
        from bzrlib.testament import Testament, StrictTestament
 
5248
        from .bzr.testament import Testament, StrictTestament
4507
5249
        if strict is True:
4508
5250
            testament_class = StrictTestament
4509
5251
        else:
4512
5254
            b = Branch.open_containing(branch)[0]
4513
5255
        else:
4514
5256
            b = Branch.open(branch)
4515
 
        self.add_cleanup(b.lock_read().unlock)
 
5257
        self.enter_context(b.lock_read())
4516
5258
        if revision is None:
4517
5259
            rev_id = b.last_revision()
4518
5260
        else:
4519
5261
            rev_id = revision[0].as_revision_id(b)
4520
5262
        t = testament_class.from_revision(b.repository, rev_id)
4521
5263
        if long:
4522
 
            sys.stdout.writelines(t.as_text_lines())
 
5264
            self.outf.writelines(t.as_text_lines())
4523
5265
        else:
4524
 
            sys.stdout.write(t.as_short_text())
 
5266
            self.outf.write(t.as_short_text())
4525
5267
 
4526
5268
 
4527
5269
class cmd_annotate(Command):
4542
5284
                     Option('long', help='Show commit date in annotations.'),
4543
5285
                     'revision',
4544
5286
                     'show-ids',
 
5287
                     'directory',
4545
5288
                     ]
4546
5289
    encoding_type = 'exact'
4547
5290
 
4548
5291
    @display_command
4549
5292
    def run(self, filename, all=False, long=False, revision=None,
4550
 
            show_ids=False):
4551
 
        from bzrlib.annotate import annotate_file, annotate_file_tree
 
5293
            show_ids=False, directory=None):
 
5294
        from .annotate import (
 
5295
            annotate_file_tree,
 
5296
            )
4552
5297
        wt, branch, relpath = \
4553
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
5298
            _open_directory_or_containing_tree_or_branch(filename, directory)
4554
5299
        if wt is not None:
4555
 
            self.add_cleanup(wt.lock_read().unlock)
 
5300
            self.enter_context(wt.lock_read())
4556
5301
        else:
4557
 
            self.add_cleanup(branch.lock_read().unlock)
 
5302
            self.enter_context(branch.lock_read())
4558
5303
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
 
        self.add_cleanup(tree.lock_read().unlock)
4560
 
        if wt is not None:
4561
 
            file_id = wt.path2id(relpath)
4562
 
        else:
4563
 
            file_id = tree.path2id(relpath)
4564
 
        if file_id is None:
4565
 
            raise errors.NotVersionedError(filename)
4566
 
        file_version = tree.inventory[file_id].revision
 
5304
        self.enter_context(tree.lock_read())
4567
5305
        if wt is not None and revision is None:
 
5306
            if not wt.is_versioned(relpath):
 
5307
                raise errors.NotVersionedError(relpath)
4568
5308
            # If there is a tree and we're not annotating historical
4569
5309
            # versions, annotate the working tree's content.
4570
 
            annotate_file_tree(wt, file_id, self.outf, long, all,
4571
 
                show_ids=show_ids)
 
5310
            annotate_file_tree(wt, relpath, self.outf, long, all,
 
5311
                               show_ids=show_ids)
4572
5312
        else:
4573
 
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4574
 
                          show_ids=show_ids)
 
5313
            if not tree.is_versioned(relpath):
 
5314
                raise errors.NotVersionedError(relpath)
 
5315
            annotate_file_tree(tree, relpath, self.outf, long, all,
 
5316
                               show_ids=show_ids, branch=branch)
4575
5317
 
4576
5318
 
4577
5319
class cmd_re_sign(Command):
4578
5320
    __doc__ = """Create a digital signature for an existing revision."""
4579
5321
    # TODO be able to replace existing ones.
4580
5322
 
4581
 
    hidden = True # is this right ?
 
5323
    hidden = True  # is this right ?
4582
5324
    takes_args = ['revision_id*']
4583
 
    takes_options = ['revision']
 
5325
    takes_options = ['directory', 'revision']
4584
5326
 
4585
 
    def run(self, revision_id_list=None, revision=None):
 
5327
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4586
5328
        if revision_id_list is not None and revision is not None:
4587
 
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
 
5329
            raise errors.CommandError(
 
5330
                gettext('You can only supply one of revision_id or --revision'))
4588
5331
        if revision_id_list is None and revision is None:
4589
 
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
 
        b = WorkingTree.open_containing(u'.')[0].branch
4591
 
        self.add_cleanup(b.lock_write().unlock)
 
5332
            raise errors.CommandError(
 
5333
                gettext('You must supply either --revision or a revision_id'))
 
5334
        b = WorkingTree.open_containing(directory)[0].branch
 
5335
        self.enter_context(b.lock_write())
4592
5336
        return self._run(b, revision_id_list, revision)
4593
5337
 
4594
5338
    def _run(self, b, revision_id_list, revision):
4595
 
        import bzrlib.gpg as gpg
4596
 
        gpg_strategy = gpg.GPGStrategy(b.get_config())
 
5339
        from .repository import WriteGroup
 
5340
        gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4597
5341
        if revision_id_list is not None:
4598
 
            b.repository.start_write_group()
4599
 
            try:
 
5342
            with WriteGroup(b.repository):
4600
5343
                for revision_id in revision_id_list:
 
5344
                    revision_id = cache_utf8.encode(revision_id)
4601
5345
                    b.repository.sign_revision(revision_id, gpg_strategy)
4602
 
            except:
4603
 
                b.repository.abort_write_group()
4604
 
                raise
4605
 
            else:
4606
 
                b.repository.commit_write_group()
4607
5346
        elif revision is not None:
4608
5347
            if len(revision) == 1:
4609
5348
                revno, rev_id = revision[0].in_history(b)
4610
 
                b.repository.start_write_group()
4611
 
                try:
 
5349
                with WriteGroup(b.repository):
4612
5350
                    b.repository.sign_revision(rev_id, gpg_strategy)
4613
 
                except:
4614
 
                    b.repository.abort_write_group()
4615
 
                    raise
4616
 
                else:
4617
 
                    b.repository.commit_write_group()
4618
5351
            elif len(revision) == 2:
4619
5352
                # are they both on rh- if so we can walk between them
4620
5353
                # might be nice to have a range helper for arbitrary
4624
5357
                if to_revid is None:
4625
5358
                    to_revno = b.revno()
4626
5359
                if from_revno is None or to_revno is None:
4627
 
                    raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
4628
 
                b.repository.start_write_group()
4629
 
                try:
 
5360
                    raise errors.CommandError(
 
5361
                        gettext('Cannot sign a range of non-revision-history revisions'))
 
5362
                with WriteGroup(b.repository):
4630
5363
                    for revno in range(from_revno, to_revno + 1):
4631
5364
                        b.repository.sign_revision(b.get_rev_id(revno),
4632
5365
                                                   gpg_strategy)
4633
 
                except:
4634
 
                    b.repository.abort_write_group()
4635
 
                    raise
4636
 
                else:
4637
 
                    b.repository.commit_write_group()
4638
5366
            else:
4639
 
                raise errors.BzrCommandError('Please supply either one revision, or a range.')
 
5367
                raise errors.CommandError(
 
5368
                    gettext('Please supply either one revision, or a range.'))
4640
5369
 
4641
5370
 
4642
5371
class cmd_bind(Command):
4653
5382
 
4654
5383
    _see_also = ['checkouts', 'unbind']
4655
5384
    takes_args = ['location?']
4656
 
    takes_options = []
 
5385
    takes_options = ['directory']
4657
5386
 
4658
 
    def run(self, location=None):
4659
 
        b, relpath = Branch.open_containing(u'.')
 
5387
    def run(self, location=None, directory=u'.'):
 
5388
        b, relpath = Branch.open_containing(directory)
4660
5389
        if location is None:
4661
5390
            try:
4662
5391
                location = b.get_old_bound_location()
4663
5392
            except errors.UpgradeRequired:
4664
 
                raise errors.BzrCommandError('No location supplied.  '
4665
 
                    'This format does not remember old locations.')
 
5393
                raise errors.CommandError(
 
5394
                    gettext('No location supplied.  '
 
5395
                            'This format does not remember old locations.'))
4666
5396
            else:
4667
5397
                if location is None:
4668
5398
                    if b.get_bound_location() is not None:
4669
 
                        raise errors.BzrCommandError('Branch is already bound')
 
5399
                        raise errors.CommandError(
 
5400
                            gettext('Branch is already bound'))
4670
5401
                    else:
4671
 
                        raise errors.BzrCommandError('No location supplied '
4672
 
                            'and no previous location known')
 
5402
                        raise errors.CommandError(
 
5403
                            gettext('No location supplied'
 
5404
                                    ' and no previous location known'))
4673
5405
        b_other = Branch.open(location)
4674
5406
        try:
4675
5407
            b.bind(b_other)
4676
5408
        except errors.DivergedBranches:
4677
 
            raise errors.BzrCommandError('These branches have diverged.'
4678
 
                                         ' Try merging, and then bind again.')
 
5409
            raise errors.CommandError(
 
5410
                gettext('These branches have diverged.'
 
5411
                        ' Try merging, and then bind again.'))
4679
5412
        if b.get_config().has_explicit_nickname():
4680
5413
            b.nick = b_other.nick
4681
5414
 
4689
5422
 
4690
5423
    _see_also = ['checkouts', 'bind']
4691
5424
    takes_args = []
4692
 
    takes_options = []
 
5425
    takes_options = ['directory']
4693
5426
 
4694
 
    def run(self):
4695
 
        b, relpath = Branch.open_containing(u'.')
 
5427
    def run(self, directory=u'.'):
 
5428
        b, relpath = Branch.open_containing(directory)
4696
5429
        if not b.unbind():
4697
 
            raise errors.BzrCommandError('Local branch is not bound')
 
5430
            raise errors.CommandError(gettext('Local branch is not bound'))
4698
5431
 
4699
5432
 
4700
5433
class cmd_uncommit(Command):
4705
5438
    remove anything.
4706
5439
 
4707
5440
    If --revision is specified, uncommit revisions to leave the branch at the
4708
 
    specified revision.  For example, "bzr uncommit -r 15" will leave the
 
5441
    specified revision.  For example, "brz uncommit -r 15" will leave the
4709
5442
    branch at revision 15.
4710
5443
 
4711
5444
    Uncommit leaves the working tree ready for a new commit.  The only change
4719
5452
    # information in shared branches as well.
4720
5453
    _see_also = ['commit']
4721
5454
    takes_options = ['verbose', 'revision',
4722
 
                    Option('dry-run', help='Don\'t actually make changes.'),
4723
 
                    Option('force', help='Say yes to all questions.'),
4724
 
                    Option('local',
4725
 
                           help="Only remove the commits from the local branch"
4726
 
                                " when in a checkout."
4727
 
                           ),
4728
 
                    ]
 
5455
                     Option('dry-run', help='Don\'t actually make changes.'),
 
5456
                     Option('force', help='Say yes to all questions.'),
 
5457
                     Option('keep-tags',
 
5458
                            help='Keep tags that point to removed revisions.'),
 
5459
                     Option('local',
 
5460
                            help="Only remove the commits from the local "
 
5461
                            "branch when in a checkout."
 
5462
                            ),
 
5463
                     ]
4729
5464
    takes_args = ['location?']
4730
5465
    aliases = []
4731
5466
    encoding_type = 'replace'
4732
5467
 
4733
 
    def run(self, location=None,
4734
 
            dry_run=False, verbose=False,
4735
 
            revision=None, force=False, local=False):
 
5468
    def run(self, location=None, dry_run=False, verbose=False,
 
5469
            revision=None, force=False, local=False, keep_tags=False):
4736
5470
        if location is None:
4737
5471
            location = u'.'
4738
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
5472
        control, relpath = controldir.ControlDir.open_containing(location)
4739
5473
        try:
4740
5474
            tree = control.open_workingtree()
4741
5475
            b = tree.branch
4744
5478
            b = control.open_branch()
4745
5479
 
4746
5480
        if tree is not None:
4747
 
            self.add_cleanup(tree.lock_write().unlock)
 
5481
            self.enter_context(tree.lock_write())
4748
5482
        else:
4749
 
            self.add_cleanup(b.lock_write().unlock)
4750
 
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
 
5483
            self.enter_context(b.lock_write())
 
5484
        return self._run(b, tree, dry_run, verbose, revision, force,
 
5485
                         local, keep_tags, location)
4751
5486
 
4752
 
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4753
 
        from bzrlib.log import log_formatter, show_log
4754
 
        from bzrlib.uncommit import uncommit
 
5487
    def _run(self, b, tree, dry_run, verbose, revision, force, local,
 
5488
             keep_tags, location):
 
5489
        from .log import log_formatter, show_log
 
5490
        from .uncommit import uncommit
4755
5491
 
4756
5492
        last_revno, last_rev_id = b.last_revision_info()
4757
5493
 
4760
5496
            revno = last_revno
4761
5497
            rev_id = last_rev_id
4762
5498
        else:
4763
 
            # 'bzr uncommit -r 10' actually means uncommit
 
5499
            # 'brz uncommit -r 10' actually means uncommit
4764
5500
            # so that the final tree is at revno 10.
4765
 
            # but bzrlib.uncommit.uncommit() actually uncommits
 
5501
            # but breezy.uncommit.uncommit() actually uncommits
4766
5502
            # the revisions that are supplied.
4767
5503
            # So we need to offset it by one
4768
5504
            revno = revision[0].in_history(b).revno + 1
4770
5506
                rev_id = b.get_rev_id(revno)
4771
5507
 
4772
5508
        if rev_id is None or _mod_revision.is_null(rev_id):
4773
 
            self.outf.write('No revisions to uncommit.\n')
 
5509
            self.outf.write(gettext('No revisions to uncommit.\n'))
4774
5510
            return 1
4775
5511
 
4776
5512
        lf = log_formatter('short',
4785
5521
                 end_revision=last_revno)
4786
5522
 
4787
5523
        if dry_run:
4788
 
            self.outf.write('Dry-run, pretending to remove'
4789
 
                            ' the above revisions.\n')
 
5524
            self.outf.write(gettext('Dry-run, pretending to remove'
 
5525
                                    ' the above revisions.\n'))
4790
5526
        else:
4791
 
            self.outf.write('The above revision(s) will be removed.\n')
 
5527
            self.outf.write(
 
5528
                gettext('The above revision(s) will be removed.\n'))
4792
5529
 
4793
5530
        if not force:
4794
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4795
 
                self.outf.write('Canceled')
 
5531
            if not ui.ui_factory.confirm_action(
 
5532
                    gettext(u'Uncommit these revisions'),
 
5533
                    'breezy.builtins.uncommit',
 
5534
                    {}):
 
5535
                self.outf.write(gettext('Canceled\n'))
4796
5536
                return 0
4797
5537
 
4798
5538
        mutter('Uncommitting from {%s} to {%s}',
4799
5539
               last_rev_id, rev_id)
4800
5540
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4801
 
                 revno=revno, local=local)
4802
 
        self.outf.write('You can restore the old tip by running:\n'
4803
 
             '  bzr pull . -r revid:%s\n' % last_rev_id)
 
5541
                 revno=revno, local=local, keep_tags=keep_tags)
 
5542
        if location != '.':
 
5543
            self.outf.write(
 
5544
                gettext('You can restore the old tip by running:\n'
 
5545
                        '  brz pull -d %s %s -r revid:%s\n')
 
5546
                % (location, location, last_rev_id.decode('utf-8')))
 
5547
        else:
 
5548
            self.outf.write(
 
5549
                gettext('You can restore the old tip by running:\n'
 
5550
                        '  brz pull . -r revid:%s\n')
 
5551
                % last_rev_id.decode('utf-8'))
4804
5552
 
4805
5553
 
4806
5554
class cmd_break_lock(Command):
4807
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
5555
    __doc__ = """Break a dead lock.
 
5556
 
 
5557
    This command breaks a lock on a repository, branch, working directory or
 
5558
    config file.
4808
5559
 
4809
5560
    CAUTION: Locks should only be broken when you are sure that the process
4810
5561
    holding the lock has been stopped.
4811
5562
 
4812
 
    You can get information on what locks are open via the 'bzr info
 
5563
    You can get information on what locks are open via the 'brz info
4813
5564
    [location]' command.
4814
5565
 
4815
5566
    :Examples:
4816
 
        bzr break-lock
4817
 
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
5567
        brz break-lock
 
5568
        brz break-lock brz+ssh://example.com/brz/foo
 
5569
        brz break-lock --conf ~/.config/breezy
4818
5570
    """
 
5571
 
4819
5572
    takes_args = ['location?']
 
5573
    takes_options = [
 
5574
        Option('config',
 
5575
               help='LOCATION is the directory where the config lock is.'),
 
5576
        Option('force',
 
5577
               help='Do not ask for confirmation before breaking the lock.'),
 
5578
        ]
4820
5579
 
4821
 
    def run(self, location=None, show=False):
 
5580
    def run(self, location=None, config=False, force=False):
4822
5581
        if location is None:
4823
5582
            location = u'.'
4824
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4825
 
        try:
4826
 
            control.break_lock()
4827
 
        except NotImplementedError:
4828
 
            pass
 
5583
        if force:
 
5584
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
5585
                                                               None,
 
5586
                                                               {'breezy.lockdir.break': True})
 
5587
        if config:
 
5588
            conf = _mod_config.LockableConfig(file_name=location)
 
5589
            conf.break_lock()
 
5590
        else:
 
5591
            control, relpath = controldir.ControlDir.open_containing(location)
 
5592
            try:
 
5593
                control.break_lock()
 
5594
            except NotImplementedError:
 
5595
                pass
4829
5596
 
4830
5597
 
4831
5598
class cmd_wait_until_signalled(Command):
4832
 
    __doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
5599
    __doc__ = """Test helper for test_start_and_stop_brz_subprocess_send_signal.
4833
5600
 
4834
5601
    This just prints a line to signal when it is ready, then blocks on stdin.
4835
5602
    """
4837
5604
    hidden = True
4838
5605
 
4839
5606
    def run(self):
4840
 
        sys.stdout.write("running\n")
4841
 
        sys.stdout.flush()
 
5607
        self.outf.write("running\n")
 
5608
        self.outf.flush()
4842
5609
        sys.stdin.readline()
4843
5610
 
4844
5611
 
4845
5612
class cmd_serve(Command):
4846
 
    __doc__ = """Run the bzr server."""
 
5613
    __doc__ = """Run the brz server."""
4847
5614
 
4848
5615
    aliases = ['server']
4849
5616
 
4851
5618
        Option('inet',
4852
5619
               help='Serve on stdin/out for use from inetd or sshd.'),
4853
5620
        RegistryOption('protocol',
4854
 
               help="Protocol to serve.",
4855
 
               lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4856
 
               value_switches=True),
 
5621
                       help="Protocol to serve.",
 
5622
                       lazy_registry=('breezy.transport',
 
5623
                                      'transport_server_registry'),
 
5624
                       value_switches=True),
 
5625
        Option('listen',
 
5626
               help='Listen for connections on nominated address.',
 
5627
               type=text_type),
4857
5628
        Option('port',
4858
 
               help='Listen for connections on nominated port of the form '
4859
 
                    '[hostname:]portnumber.  Passing 0 as the port number will '
4860
 
                    'result in a dynamically allocated port.  The default port '
4861
 
                    'depends on the protocol.',
4862
 
               type=str),
4863
 
        Option('directory',
4864
 
               help='Serve contents of this directory.',
4865
 
               type=unicode),
 
5629
               help='Listen for connections on nominated port.  Passing 0 as '
 
5630
                    'the port number will result in a dynamically allocated '
 
5631
                    'port.  The default port depends on the protocol.',
 
5632
               type=int),
 
5633
        custom_help('directory',
 
5634
                    help='Serve contents of this directory.'),
4866
5635
        Option('allow-writes',
4867
5636
               help='By default the server is a readonly server.  Supplying '
4868
5637
                    '--allow-writes enables write access to the contents of '
4869
 
                    'the served directory and below.  Note that ``bzr serve`` '
 
5638
                    'the served directory and below.  Note that ``brz serve`` '
4870
5639
                    'does not perform authentication, so unless some form of '
4871
5640
                    'external authentication is arranged supplying this '
4872
5641
                    'option leads to global uncontrolled write access to your '
4873
5642
                    'file system.'
4874
 
                ),
 
5643
               ),
 
5644
        Option('client-timeout', type=float,
 
5645
               help='Override the default idle client timeout (5min).'),
4875
5646
        ]
4876
5647
 
4877
 
    def get_host_and_port(self, port):
4878
 
        """Return the host and port to run the smart server on.
4879
 
 
4880
 
        If 'port' is None, None will be returned for the host and port.
4881
 
 
4882
 
        If 'port' has a colon in it, the string before the colon will be
4883
 
        interpreted as the host.
4884
 
 
4885
 
        :param port: A string of the port to run the server on.
4886
 
        :return: A tuple of (host, port), where 'host' is a host name or IP,
4887
 
            and port is an integer TCP/IP port.
4888
 
        """
4889
 
        host = None
4890
 
        if port is not None:
4891
 
            if ':' in port:
4892
 
                host, port = port.split(':')
4893
 
            port = int(port)
4894
 
        return host, port
4895
 
 
4896
 
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4897
 
            protocol=None):
4898
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5648
    def run(self, listen=None, port=None, inet=False, directory=None,
 
5649
            allow_writes=False, protocol=None, client_timeout=None):
 
5650
        from . import location, transport
4899
5651
        if directory is None:
4900
 
            directory = os.getcwd()
 
5652
            directory = osutils.getcwd()
4901
5653
        if protocol is None:
4902
 
            protocol = transport_server_registry.get()
4903
 
        host, port = self.get_host_and_port(port)
4904
 
        url = urlutils.local_path_to_url(directory)
 
5654
            protocol = transport.transport_server_registry.get()
 
5655
        url = location.location_to_url(directory)
4905
5656
        if not allow_writes:
4906
5657
            url = 'readonly+' + url
4907
 
        transport = get_transport(url)
4908
 
        protocol(transport, host, port, inet)
 
5658
        t = transport.get_transport_from_url(url)
 
5659
        protocol(t, listen, port, inet, client_timeout)
4909
5660
 
4910
5661
 
4911
5662
class cmd_join(Command):
4914
5665
    This command requires the target tree to be in a rich-root format.
4915
5666
 
4916
5667
    The TREE argument should be an independent tree, inside another tree, but
4917
 
    not part of it.  (Such trees can be produced by "bzr split", but also by
4918
 
    running "bzr branch" with the target inside a tree.)
 
5668
    not part of it.  (Such trees can be produced by "brz split", but also by
 
5669
    running "brz branch" with the target inside a tree.)
4919
5670
 
4920
 
    The result is a combined tree, with the subtree no longer an independant
 
5671
    The result is a combined tree, with the subtree no longer an independent
4921
5672
    part.  This is marked as a merge of the subtree into the containing tree,
4922
5673
    and all history is preserved.
4923
5674
    """
4925
5676
    _see_also = ['split']
4926
5677
    takes_args = ['tree']
4927
5678
    takes_options = [
4928
 
            Option('reference', help='Join by reference.', hidden=True),
4929
 
            ]
 
5679
        Option('reference', help='Join by reference.', hidden=True),
 
5680
        ]
4930
5681
 
4931
5682
    def run(self, tree, reference=False):
 
5683
        from breezy.mutabletree import BadReferenceTarget
4932
5684
        sub_tree = WorkingTree.open(tree)
4933
5685
        parent_dir = osutils.dirname(sub_tree.basedir)
4934
5686
        containing_tree = WorkingTree.open_containing(parent_dir)[0]
4935
5687
        repo = containing_tree.branch.repository
4936
5688
        if not repo.supports_rich_root():
4937
 
            raise errors.BzrCommandError(
 
5689
            raise errors.CommandError(gettext(
4938
5690
                "Can't join trees because %s doesn't support rich root data.\n"
4939
 
                "You can use bzr upgrade on the repository."
 
5691
                "You can use brz upgrade on the repository.")
4940
5692
                % (repo,))
4941
5693
        if reference:
4942
5694
            try:
4943
5695
                containing_tree.add_reference(sub_tree)
4944
 
            except errors.BadReferenceTarget, e:
 
5696
            except BadReferenceTarget as e:
4945
5697
                # XXX: Would be better to just raise a nicely printable
4946
5698
                # exception from the real origin.  Also below.  mbp 20070306
4947
 
                raise errors.BzrCommandError("Cannot join %s.  %s" %
4948
 
                                             (tree, e.reason))
 
5699
                raise errors.CommandError(
 
5700
                    gettext("Cannot join {0}.  {1}").format(tree, e.reason))
4949
5701
        else:
4950
5702
            try:
4951
5703
                containing_tree.subsume(sub_tree)
4952
 
            except errors.BadSubsumeSource, e:
4953
 
                raise errors.BzrCommandError("Cannot join %s.  %s" %
4954
 
                                             (tree, e.reason))
 
5704
            except errors.BadSubsumeSource as e:
 
5705
                raise errors.CommandError(
 
5706
                    gettext("Cannot join {0}.  {1}").format(tree, e.reason))
4955
5707
 
4956
5708
 
4957
5709
class cmd_split(Command):
4971
5723
 
4972
5724
    def run(self, tree):
4973
5725
        containing_tree, subdir = WorkingTree.open_containing(tree)
4974
 
        sub_id = containing_tree.path2id(subdir)
4975
 
        if sub_id is None:
 
5726
        if not containing_tree.is_versioned(subdir):
4976
5727
            raise errors.NotVersionedError(subdir)
4977
5728
        try:
4978
 
            containing_tree.extract(sub_id)
 
5729
            containing_tree.extract(subdir)
4979
5730
        except errors.RootNotRich:
4980
5731
            raise errors.RichRootUpgradeRequired(containing_tree.branch.base)
4981
5732
 
5004
5755
    _see_also = ['send']
5005
5756
 
5006
5757
    takes_options = [
5007
 
        RegistryOption.from_kwargs('patch-type',
 
5758
        'directory',
 
5759
        RegistryOption.from_kwargs(
 
5760
            'patch-type',
5008
5761
            'The type of patch to include in the directive.',
5009
5762
            title='Patch type',
5010
5763
            value_switches=True,
5013
5766
            diff='Normal unified diff.',
5014
5767
            plain='No patch, just directive.'),
5015
5768
        Option('sign', help='GPG-sign the directive.'), 'revision',
5016
 
        Option('mail-to', type=str,
5017
 
            help='Instead of printing the directive, email to this address.'),
5018
 
        Option('message', type=str, short_name='m',
5019
 
            help='Message to use when committing this merge.')
 
5769
        Option('mail-to', type=text_type,
 
5770
               help='Instead of printing the directive, email to this '
 
5771
               'address.'),
 
5772
        Option('message', type=text_type, short_name='m',
 
5773
               help='Message to use when committing this merge.')
5020
5774
        ]
5021
5775
 
5022
5776
    encoding_type = 'exact'
5023
5777
 
5024
5778
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5025
 
            sign=False, revision=None, mail_to=None, message=None):
5026
 
        from bzrlib.revision import ensure_null, NULL_REVISION
 
5779
            sign=False, revision=None, mail_to=None, message=None,
 
5780
            directory=u'.'):
 
5781
        from .revision import ensure_null, NULL_REVISION
5027
5782
        include_patch, include_bundle = {
5028
5783
            'plain': (False, False),
5029
5784
            'diff': (True, False),
5030
5785
            'bundle': (True, True),
5031
5786
            }[patch_type]
5032
 
        branch = Branch.open('.')
 
5787
        branch = Branch.open(directory)
5033
5788
        stored_submit_branch = branch.get_submit_branch()
5034
5789
        if submit_branch is None:
5035
5790
            submit_branch = stored_submit_branch
5039
5794
        if submit_branch is None:
5040
5795
            submit_branch = branch.get_parent()
5041
5796
        if submit_branch is None:
5042
 
            raise errors.BzrCommandError('No submit branch specified or known')
 
5797
            raise errors.CommandError(
 
5798
                gettext('No submit branch specified or known'))
5043
5799
 
5044
5800
        stored_public_branch = branch.get_public_branch()
5045
5801
        if public_branch is None:
5046
5802
            public_branch = stored_public_branch
5047
5803
        elif stored_public_branch is None:
 
5804
            # FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5048
5805
            branch.set_public_branch(public_branch)
5049
5806
        if not include_bundle and public_branch is None:
5050
 
            raise errors.BzrCommandError('No public branch specified or'
5051
 
                                         ' known')
 
5807
            raise errors.CommandError(
 
5808
                gettext('No public branch specified or known'))
5052
5809
        base_revision_id = None
5053
5810
        if revision is not None:
5054
5811
            if len(revision) > 2:
5055
 
                raise errors.BzrCommandError('bzr merge-directive takes '
5056
 
                    'at most two one revision identifiers')
 
5812
                raise errors.CommandError(
 
5813
                    gettext('brz merge-directive takes '
 
5814
                            'at most two one revision identifiers'))
5057
5815
            revision_id = revision[-1].as_revision_id(branch)
5058
5816
            if len(revision) == 2:
5059
5817
                base_revision_id = revision[0].as_revision_id(branch)
5061
5819
            revision_id = branch.last_revision()
5062
5820
        revision_id = ensure_null(revision_id)
5063
5821
        if revision_id == NULL_REVISION:
5064
 
            raise errors.BzrCommandError('No revisions to bundle.')
 
5822
            raise errors.CommandError(gettext('No revisions to bundle.'))
5065
5823
        directive = merge_directive.MergeDirective2.from_objects(
5066
5824
            branch.repository, revision_id, time.time(),
5067
5825
            osutils.local_time_offset(), submit_branch,
5075
5833
                self.outf.writelines(directive.to_lines())
5076
5834
        else:
5077
5835
            message = directive.to_email(mail_to, branch, sign)
5078
 
            s = SMTPConnection(branch.get_config())
 
5836
            s = SMTPConnection(branch.get_config_stack())
5079
5837
            s.send_email(message)
5080
5838
 
5081
5839
 
5092
5850
      directly from the merge directive, without retrieving data from a
5093
5851
      branch.
5094
5852
 
5095
 
    `bzr send` creates a compact data set that, when applied using bzr
5096
 
    merge, has the same effect as merging from the source branch.  
5097
 
    
 
5853
    `brz send` creates a compact data set that, when applied using brz
 
5854
    merge, has the same effect as merging from the source branch.
 
5855
 
5098
5856
    By default the merge directive is self-contained and can be applied to any
5099
5857
    branch containing submit_branch in its ancestory without needing access to
5100
5858
    the source branch.
5101
 
    
5102
 
    If --no-bundle is specified, then Bazaar doesn't send the contents of the
 
5859
 
 
5860
    If --no-bundle is specified, then Breezy doesn't send the contents of the
5103
5861
    revisions, but only a structured request to merge from the
5104
5862
    public_location.  In that case the public_branch is needed and it must be
5105
5863
    up-to-date and accessible to the recipient.  The public_branch is always
5111
5869
    source branch defaults to that containing the working directory, but can
5112
5870
    be changed using --from.
5113
5871
 
5114
 
    In order to calculate those changes, bzr must analyse the submit branch.
 
5872
    Both the submit branch and the public branch follow the usual behavior with
 
5873
    respect to --remember: If there is no default location set, the first send
 
5874
    will set it (use --no-remember to avoid setting it). After that, you can
 
5875
    omit the location to use the default.  To change the default, use
 
5876
    --remember. The value will only be saved if the location can be accessed.
 
5877
 
 
5878
    In order to calculate those changes, brz must analyse the submit branch.
5115
5879
    Therefore it is most efficient for the submit branch to be a local mirror.
5116
5880
    If a public location is known for the submit_branch, that location is used
5117
5881
    in the merge directive.
5120
5884
    given, in which case it is sent to a file.
5121
5885
 
5122
5886
    Mail is sent using your preferred mail program.  This should be transparent
5123
 
    on Windows (it uses MAPI).  On Linux, it requires the xdg-email utility.
 
5887
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5124
5888
    If the preferred client can't be found (or used), your editor will be used.
5125
5889
 
5126
5890
    To use a specific mail program, set the mail_client configuration option.
5127
 
    (For Thunderbird 1.5, this works around some bugs.)  Supported values for
5128
 
    specific clients are "claws", "evolution", "kmail", "mail.app" (MacOS X's
5129
 
    Mail.app), "mutt", and "thunderbird"; generic options are "default",
5130
 
    "editor", "emacsclient", "mapi", and "xdg-email".  Plugins may also add
5131
 
    supported clients.
 
5891
    Supported values for specific clients are "claws", "evolution", "kmail",
 
5892
    "mail.app" (MacOS X's Mail.app), "mutt", and "thunderbird"; generic options
 
5893
    are "default", "editor", "emacsclient", "mapi", and "xdg-email".  Plugins
 
5894
    may also add supported clients.
5132
5895
 
5133
5896
    If mail is being sent, a to address is required.  This can be supplied
5134
5897
    either on the commandline, by setting the submit_to configuration
5135
5898
    option in the branch itself or the child_submit_to configuration option
5136
5899
    in the submit branch.
5137
5900
 
5138
 
    Two formats are currently supported: "4" uses revision bundle format 4 and
5139
 
    merge directive format 2.  It is significantly faster and smaller than
5140
 
    older formats.  It is compatible with Bazaar 0.19 and later.  It is the
5141
 
    default.  "0.9" uses revision bundle format 0.9 and merge directive
5142
 
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
5143
 
 
5144
 
    The merge directives created by bzr send may be applied using bzr merge or
5145
 
    bzr pull by specifying a file containing a merge directive as the location.
5146
 
 
5147
 
    bzr send makes extensive use of public locations to map local locations into
5148
 
    URLs that can be used by other people.  See `bzr help configuration` to
5149
 
    set them, and use `bzr info` to display them.
 
5901
    The merge directives created by brz send may be applied using brz merge or
 
5902
    brz pull by specifying a file containing a merge directive as the location.
 
5903
 
 
5904
    brz send makes extensive use of public locations to map local locations into
 
5905
    URLs that can be used by other people.  See `brz help configuration` to
 
5906
    set them, and use `brz info` to display them.
5150
5907
    """
5151
5908
 
5152
5909
    encoding_type = 'exact'
5166
5923
               help='Branch to generate the submission from, '
5167
5924
               'rather than the one containing the working directory.',
5168
5925
               short_name='f',
5169
 
               type=unicode),
 
5926
               type=text_type),
5170
5927
        Option('output', short_name='o',
5171
5928
               help='Write merge directive to this file or directory; '
5172
5929
                    'use - for stdout.',
5173
 
               type=unicode),
 
5930
               type=text_type),
5174
5931
        Option('strict',
5175
5932
               help='Refuse to send if there are uncommitted changes in'
5176
5933
               ' the working tree, --no-strict disables the check.'),
5177
5934
        Option('mail-to', help='Mail the request to this address.',
5178
 
               type=unicode),
 
5935
               type=text_type),
5179
5936
        'revision',
5180
5937
        'message',
5181
 
        Option('body', help='Body for the email.', type=unicode),
 
5938
        Option('body', help='Body for the email.', type=text_type),
5182
5939
        RegistryOption('format',
5183
5940
                       help='Use the specified output format.',
5184
 
                       lazy_registry=('bzrlib.send', 'format_registry')),
 
5941
                       lazy_registry=('breezy.send', 'format_registry')),
5185
5942
        ]
5186
5943
 
5187
5944
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5188
 
            no_patch=False, revision=None, remember=False, output=None,
 
5945
            no_patch=False, revision=None, remember=None, output=None,
5189
5946
            format=None, mail_to=None, message=None, body=None,
5190
5947
            strict=None, **kwargs):
5191
 
        from bzrlib.send import send
 
5948
        from .send import send
5192
5949
        return send(submit_branch, revision, public_branch, remember,
5193
5950
                    format, no_bundle, no_patch, output,
5194
5951
                    kwargs.get('from', '.'), mail_to, message, body,
5221
5978
    branch is used in the merge instructions.  This means that a local mirror
5222
5979
    can be used as your actual submit branch, once you have set public_branch
5223
5980
    for that mirror.
5224
 
 
5225
 
    Two formats are currently supported: "4" uses revision bundle format 4 and
5226
 
    merge directive format 2.  It is significantly faster and smaller than
5227
 
    older formats.  It is compatible with Bazaar 0.19 and later.  It is the
5228
 
    default.  "0.9" uses revision bundle format 0.9 and merge directive
5229
 
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
5230
5981
    """
5231
5982
 
5232
5983
    takes_options = [
5240
5991
               help='Branch to generate the submission from, '
5241
5992
               'rather than the one containing the working directory.',
5242
5993
               short_name='f',
5243
 
               type=unicode),
 
5994
               type=text_type),
5244
5995
        Option('output', short_name='o', help='Write directive to this file.',
5245
 
               type=unicode),
 
5996
               type=text_type),
5246
5997
        Option('strict',
5247
5998
               help='Refuse to bundle revisions if there are uncommitted'
5248
5999
               ' changes in the working tree, --no-strict disables the check.'),
5249
6000
        'revision',
5250
6001
        RegistryOption('format',
5251
6002
                       help='Use the specified output format.',
5252
 
                       lazy_registry=('bzrlib.send', 'format_registry')),
 
6003
                       lazy_registry=('breezy.send', 'format_registry')),
5253
6004
        ]
5254
6005
    aliases = ['bundle']
5255
6006
 
5262
6013
            format=None, strict=None, **kwargs):
5263
6014
        if output is None:
5264
6015
            output = '-'
5265
 
        from bzrlib.send import send
 
6016
        from .send import send
5266
6017
        return send(submit_branch, revision, public_branch, remember,
5267
 
                         format, no_bundle, no_patch, output,
5268
 
                         kwargs.get('from', '.'), None, None, None,
5269
 
                         self.outf, strict=strict)
 
6018
                    format, no_bundle, no_patch, output,
 
6019
                    kwargs.get('from', '.'), None, None, None,
 
6020
                    self.outf, strict=strict)
5270
6021
 
5271
6022
 
5272
6023
class cmd_tag(Command):
5282
6033
    It is an error to give a tag name that already exists unless you pass
5283
6034
    --force, in which case the tag is moved to point to the new revision.
5284
6035
 
5285
 
    To rename a tag (change the name but keep it on the same revsion), run ``bzr
5286
 
    tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
 
6036
    To rename a tag (change the name but keep it on the same revsion), run ``brz
 
6037
    tag new-name -r tag:old-name`` and then ``brz tag --delete oldname``.
5287
6038
 
5288
 
    If no tag name is specified it will be determined through the 
 
6039
    If no tag name is specified it will be determined through the
5289
6040
    'automatic_tag_name' hook. This can e.g. be used to automatically tag
5290
 
    upstream releases by reading configure.ac. See ``bzr help hooks`` for
 
6041
    upstream releases by reading configure.ac. See ``brz help hooks`` for
5291
6042
    details.
5292
6043
    """
5293
6044
 
5295
6046
    takes_args = ['tag_name?']
5296
6047
    takes_options = [
5297
6048
        Option('delete',
5298
 
            help='Delete this tag rather than placing it.',
5299
 
            ),
5300
 
        Option('directory',
5301
 
            help='Branch in which to place the tag.',
5302
 
            short_name='d',
5303
 
            type=unicode,
5304
 
            ),
 
6049
               help='Delete this tag rather than placing it.',
 
6050
               ),
 
6051
        custom_help('directory',
 
6052
                    help='Branch in which to place the tag.'),
5305
6053
        Option('force',
5306
 
            help='Replace existing tags.',
5307
 
            ),
 
6054
               help='Replace existing tags.',
 
6055
               ),
5308
6056
        'revision',
5309
6057
        ]
5310
6058
 
5315
6063
            revision=None,
5316
6064
            ):
5317
6065
        branch, relpath = Branch.open_containing(directory)
5318
 
        self.add_cleanup(branch.lock_write().unlock)
 
6066
        self.enter_context(branch.lock_write())
5319
6067
        if delete:
5320
6068
            if tag_name is None:
5321
 
                raise errors.BzrCommandError("No tag specified to delete.")
 
6069
                raise errors.CommandError(
 
6070
                    gettext("No tag specified to delete."))
5322
6071
            branch.tags.delete_tag(tag_name)
5323
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
6072
            note(gettext('Deleted tag %s.') % tag_name)
5324
6073
        else:
5325
6074
            if revision:
5326
6075
                if len(revision) != 1:
5327
 
                    raise errors.BzrCommandError(
 
6076
                    raise errors.CommandError(gettext(
5328
6077
                        "Tags can only be placed on a single revision, "
5329
 
                        "not on a range")
 
6078
                        "not on a range"))
5330
6079
                revision_id = revision[0].as_revision_id(branch)
5331
6080
            else:
5332
6081
                revision_id = branch.last_revision()
5333
6082
            if tag_name is None:
5334
6083
                tag_name = branch.automatic_tag_name(revision_id)
5335
6084
                if tag_name is None:
5336
 
                    raise errors.BzrCommandError(
5337
 
                        "Please specify a tag name.")
5338
 
            if (not force) and branch.tags.has_tag(tag_name):
 
6085
                    raise errors.CommandError(gettext(
 
6086
                        "Please specify a tag name."))
 
6087
            try:
 
6088
                existing_target = branch.tags.lookup_tag(tag_name)
 
6089
            except errors.NoSuchTag:
 
6090
                existing_target = None
 
6091
            if not force and existing_target not in (None, revision_id):
5339
6092
                raise errors.TagAlreadyExists(tag_name)
5340
 
            branch.tags.set_tag(tag_name, revision_id)
5341
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
6093
            if existing_target == revision_id:
 
6094
                note(gettext('Tag %s already exists for that revision.') % tag_name)
 
6095
            else:
 
6096
                branch.tags.set_tag(tag_name, revision_id)
 
6097
                if existing_target is None:
 
6098
                    note(gettext('Created tag %s.') % tag_name)
 
6099
                else:
 
6100
                    note(gettext('Updated tag %s.') % tag_name)
5342
6101
 
5343
6102
 
5344
6103
class cmd_tags(Command):
5349
6108
 
5350
6109
    _see_also = ['tag']
5351
6110
    takes_options = [
5352
 
        Option('directory',
5353
 
            help='Branch whose tags should be displayed.',
5354
 
            short_name='d',
5355
 
            type=unicode,
5356
 
            ),
5357
 
        RegistryOption.from_kwargs('sort',
5358
 
            'Sort tags by different criteria.', title='Sorting',
5359
 
            alpha='Sort tags lexicographically (default).',
5360
 
            time='Sort tags chronologically.',
5361
 
            ),
 
6111
        custom_help('directory',
 
6112
                    help='Branch whose tags should be displayed.'),
 
6113
        RegistryOption('sort',
 
6114
                       'Sort tags by different criteria.', title='Sorting',
 
6115
                       lazy_registry=('breezy.tag', 'tag_sort_methods')
 
6116
                       ),
5362
6117
        'show-ids',
5363
6118
        'revision',
5364
6119
    ]
5365
6120
 
5366
6121
    @display_command
5367
 
    def run(self,
5368
 
            directory='.',
5369
 
            sort='alpha',
5370
 
            show_ids=False,
5371
 
            revision=None,
5372
 
            ):
 
6122
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
6123
        from .tag import tag_sort_methods
5373
6124
        branch, relpath = Branch.open_containing(directory)
5374
6125
 
5375
 
        tags = branch.tags.get_tag_dict().items()
 
6126
        tags = list(viewitems(branch.tags.get_tag_dict()))
5376
6127
        if not tags:
5377
6128
            return
5378
6129
 
5379
 
        self.add_cleanup(branch.lock_read().unlock)
 
6130
        self.enter_context(branch.lock_read())
5380
6131
        if revision:
5381
 
            graph = branch.repository.get_graph()
5382
 
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5383
 
            revid1, revid2 = rev1.rev_id, rev2.rev_id
5384
 
            # only show revisions between revid1 and revid2 (inclusive)
5385
 
            tags = [(tag, revid) for tag, revid in tags if
5386
 
                graph.is_between(revid, revid1, revid2)]
5387
 
        if sort == 'alpha':
5388
 
            tags.sort()
5389
 
        elif sort == 'time':
5390
 
            timestamps = {}
5391
 
            for tag, revid in tags:
5392
 
                try:
5393
 
                    revobj = branch.repository.get_revision(revid)
5394
 
                except errors.NoSuchRevision:
5395
 
                    timestamp = sys.maxint # place them at the end
5396
 
                else:
5397
 
                    timestamp = revobj.timestamp
5398
 
                timestamps[revid] = timestamp
5399
 
            tags.sort(key=lambda x: timestamps[x[1]])
 
6132
            # Restrict to the specified range
 
6133
            tags = self._tags_for_range(branch, revision)
 
6134
        if sort is None:
 
6135
            sort = tag_sort_methods.get()
 
6136
        sort(branch, tags)
5400
6137
        if not show_ids:
5401
6138
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5402
6139
            for index, (tag, revid) in enumerate(tags):
5404
6141
                    revno = branch.revision_id_to_dotted_revno(revid)
5405
6142
                    if isinstance(revno, tuple):
5406
6143
                        revno = '.'.join(map(str, revno))
5407
 
                except errors.NoSuchRevision:
 
6144
                except (errors.NoSuchRevision,
 
6145
                        errors.GhostRevisionsHaveNoRevno,
 
6146
                        errors.UnsupportedOperation):
5408
6147
                    # Bad tag data/merges can lead to tagged revisions
5409
6148
                    # which are not in this branch. Fail gracefully ...
5410
6149
                    revno = '?'
5411
6150
                tags[index] = (tag, revno)
 
6151
        else:
 
6152
            tags = [(tag, revid.decode('utf-8')) for (tag, revid) in tags]
5412
6153
        self.cleanup_now()
5413
6154
        for tag, revspec in tags:
5414
6155
            self.outf.write('%-20s %s\n' % (tag, revspec))
5415
6156
 
 
6157
    def _tags_for_range(self, branch, revision):
 
6158
        rev1, rev2 = _get_revision_range(revision, branch, self.name())
 
6159
        revid1, revid2 = rev1.rev_id, rev2.rev_id
 
6160
        # _get_revision_range will always set revid2 if it's not specified.
 
6161
        # If revid1 is None, it means we want to start from the branch
 
6162
        # origin which is always a valid ancestor. If revid1 == revid2, the
 
6163
        # ancestry check is useless.
 
6164
        if revid1 and revid1 != revid2:
 
6165
            # FIXME: We really want to use the same graph than
 
6166
            # branch.iter_merge_sorted_revisions below, but this is not
 
6167
            # easily available -- vila 2011-09-23
 
6168
            if branch.repository.get_graph().is_ancestor(revid2, revid1):
 
6169
                # We don't want to output anything in this case...
 
6170
                return []
 
6171
        # only show revisions between revid1 and revid2 (inclusive)
 
6172
        tagged_revids = branch.tags.get_reverse_tag_dict()
 
6173
        found = []
 
6174
        for r in branch.iter_merge_sorted_revisions(
 
6175
                start_revision_id=revid2, stop_revision_id=revid1,
 
6176
                stop_rule='include'):
 
6177
            revid_tags = tagged_revids.get(r[0], None)
 
6178
            if revid_tags:
 
6179
                found.extend([(tag, r[0]) for tag in revid_tags])
 
6180
        return found
 
6181
 
5416
6182
 
5417
6183
class cmd_reconfigure(Command):
5418
 
    __doc__ = """Reconfigure the type of a bzr directory.
 
6184
    __doc__ = """Reconfigure the type of a brz directory.
5419
6185
 
5420
6186
    A target configuration must be specified.
5421
6187
 
5432
6198
    takes_args = ['location?']
5433
6199
    takes_options = [
5434
6200
        RegistryOption.from_kwargs(
5435
 
            'target_type',
5436
 
            title='Target type',
5437
 
            help='The type to reconfigure the directory to.',
 
6201
            'tree_type',
 
6202
            title='Tree type',
 
6203
            help='The relation between branch and tree.',
5438
6204
            value_switches=True, enum_switch=False,
5439
6205
            branch='Reconfigure to be an unbound branch with no working tree.',
5440
6206
            tree='Reconfigure to be an unbound branch with a working tree.',
5441
6207
            checkout='Reconfigure to be a bound branch with a working tree.',
5442
6208
            lightweight_checkout='Reconfigure to be a lightweight'
5443
 
                ' checkout (with no local history).',
 
6209
            ' checkout (with no local history).',
 
6210
            ),
 
6211
        RegistryOption.from_kwargs(
 
6212
            'repository_type',
 
6213
            title='Repository type',
 
6214
            help='Location fo the repository.',
 
6215
            value_switches=True, enum_switch=False,
5444
6216
            standalone='Reconfigure to be a standalone branch '
5445
 
                '(i.e. stop using shared repository).',
 
6217
            '(i.e. stop using shared repository).',
5446
6218
            use_shared='Reconfigure to use a shared repository.',
 
6219
            ),
 
6220
        RegistryOption.from_kwargs(
 
6221
            'repository_trees',
 
6222
            title='Trees in Repository',
 
6223
            help='Whether new branches in the repository have trees.',
 
6224
            value_switches=True, enum_switch=False,
5447
6225
            with_trees='Reconfigure repository to create '
5448
 
                'working trees on branches by default.',
 
6226
            'working trees on branches by default.',
5449
6227
            with_no_trees='Reconfigure repository to not create '
5450
 
                'working trees on branches by default.'
 
6228
            'working trees on branches by default.'
5451
6229
            ),
5452
 
        Option('bind-to', help='Branch to bind checkout to.', type=str),
 
6230
        Option('bind-to', help='Branch to bind checkout to.', type=text_type),
5453
6231
        Option('force',
5454
 
            help='Perform reconfiguration even if local changes'
5455
 
            ' will be lost.'),
 
6232
               help='Perform reconfiguration even if local changes'
 
6233
               ' will be lost.'),
5456
6234
        Option('stacked-on',
5457
 
            help='Reconfigure a branch to be stacked on another branch.',
5458
 
            type=unicode,
5459
 
            ),
 
6235
               help='Reconfigure a branch to be stacked on another branch.',
 
6236
               type=text_type,
 
6237
               ),
5460
6238
        Option('unstacked',
5461
 
            help='Reconfigure a branch to be unstacked.  This '
5462
 
                'may require copying substantial data into it.',
5463
 
            ),
 
6239
               help='Reconfigure a branch to be unstacked.  This '
 
6240
               'may require copying substantial data into it.',
 
6241
               ),
5464
6242
        ]
5465
6243
 
5466
 
    def run(self, location=None, target_type=None, bind_to=None, force=False,
5467
 
            stacked_on=None,
5468
 
            unstacked=None):
5469
 
        directory = bzrdir.BzrDir.open(location)
 
6244
    def run(self, location=None, bind_to=None, force=False,
 
6245
            tree_type=None, repository_type=None, repository_trees=None,
 
6246
            stacked_on=None, unstacked=None):
 
6247
        directory = controldir.ControlDir.open(location)
5470
6248
        if stacked_on and unstacked:
5471
 
            raise BzrCommandError("Can't use both --stacked-on and --unstacked")
 
6249
            raise errors.CommandError(
 
6250
                gettext("Can't use both --stacked-on and --unstacked"))
5472
6251
        elif stacked_on is not None:
5473
6252
            reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5474
6253
        elif unstacked:
5476
6255
        # At the moment you can use --stacked-on and a different
5477
6256
        # reconfiguration shape at the same time; there seems no good reason
5478
6257
        # to ban it.
5479
 
        if target_type is None:
 
6258
        if (tree_type is None and
 
6259
            repository_type is None and
 
6260
                repository_trees is None):
5480
6261
            if stacked_on or unstacked:
5481
6262
                return
5482
6263
            else:
5483
 
                raise errors.BzrCommandError('No target configuration '
5484
 
                    'specified')
5485
 
        elif target_type == 'branch':
 
6264
                raise errors.CommandError(gettext('No target configuration '
 
6265
                                                     'specified'))
 
6266
        reconfiguration = None
 
6267
        if tree_type == 'branch':
5486
6268
            reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5487
 
        elif target_type == 'tree':
 
6269
        elif tree_type == 'tree':
5488
6270
            reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5489
 
        elif target_type == 'checkout':
 
6271
        elif tree_type == 'checkout':
5490
6272
            reconfiguration = reconfigure.Reconfigure.to_checkout(
5491
6273
                directory, bind_to)
5492
 
        elif target_type == 'lightweight-checkout':
 
6274
        elif tree_type == 'lightweight-checkout':
5493
6275
            reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5494
6276
                directory, bind_to)
5495
 
        elif target_type == 'use-shared':
 
6277
        if reconfiguration:
 
6278
            reconfiguration.apply(force)
 
6279
            reconfiguration = None
 
6280
        if repository_type == 'use-shared':
5496
6281
            reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5497
 
        elif target_type == 'standalone':
 
6282
        elif repository_type == 'standalone':
5498
6283
            reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5499
 
        elif target_type == 'with-trees':
 
6284
        if reconfiguration:
 
6285
            reconfiguration.apply(force)
 
6286
            reconfiguration = None
 
6287
        if repository_trees == 'with-trees':
5500
6288
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5501
6289
                directory, True)
5502
 
        elif target_type == 'with-no-trees':
 
6290
        elif repository_trees == 'with-no-trees':
5503
6291
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5504
6292
                directory, False)
5505
 
        reconfiguration.apply(force)
 
6293
        if reconfiguration:
 
6294
            reconfiguration.apply(force)
 
6295
            reconfiguration = None
5506
6296
 
5507
6297
 
5508
6298
class cmd_switch(Command):
5529
6319
    """
5530
6320
 
5531
6321
    takes_args = ['to_location?']
5532
 
    takes_options = [Option('force',
5533
 
                        help='Switch even if local commits will be lost.'),
 
6322
    takes_options = ['directory',
 
6323
                     Option('force',
 
6324
                            help='Switch even if local commits will be lost.'),
5534
6325
                     'revision',
5535
6326
                     Option('create-branch', short_name='b',
5536
 
                        help='Create the target branch from this one before'
5537
 
                             ' switching to it.'),
5538
 
                    ]
 
6327
                            help='Create the target branch from this one before'
 
6328
                            ' switching to it.'),
 
6329
                     Option('store',
 
6330
                            help='Store and restore uncommitted changes in the'
 
6331
                            ' branch.'),
 
6332
                     ]
5539
6333
 
5540
6334
    def run(self, to_location=None, force=False, create_branch=False,
5541
 
            revision=None):
5542
 
        from bzrlib import switch
5543
 
        tree_location = '.'
 
6335
            revision=None, directory=u'.', store=False):
 
6336
        from . import switch
 
6337
        tree_location = directory
5544
6338
        revision = _get_one_revision('switch', revision)
5545
 
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
 
6339
        control_dir = controldir.ControlDir.open_containing(tree_location)[0]
 
6340
        possible_transports = [control_dir.root_transport]
5546
6341
        if to_location is None:
5547
6342
            if revision is None:
5548
 
                raise errors.BzrCommandError('You must supply either a'
5549
 
                                             ' revision or a location')
5550
 
            to_location = '.'
 
6343
                raise errors.CommandError(gettext('You must supply either a'
 
6344
                                                     ' revision or a location'))
 
6345
            to_location = tree_location
5551
6346
        try:
5552
 
            branch = control_dir.open_branch()
 
6347
            branch = control_dir.open_branch(
 
6348
                possible_transports=possible_transports)
5553
6349
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5554
6350
        except errors.NotBranchError:
5555
6351
            branch = None
5556
6352
            had_explicit_nick = False
 
6353
        else:
 
6354
            possible_transports.append(branch.user_transport)
5557
6355
        if create_branch:
5558
6356
            if branch is None:
5559
 
                raise errors.BzrCommandError('cannot create branch without'
5560
 
                                             ' source branch')
5561
 
            to_location = directory_service.directories.dereference(
5562
 
                              to_location)
5563
 
            if '/' not in to_location and '\\' not in to_location:
5564
 
                # This path is meant to be relative to the existing branch
5565
 
                this_url = self._get_branch_location(control_dir)
5566
 
                to_location = urlutils.join(this_url, '..', to_location)
5567
 
            to_branch = branch.bzrdir.sprout(to_location,
5568
 
                                 possible_transports=[branch.bzrdir.root_transport],
5569
 
                                 source_branch=branch).open_branch()
 
6357
                raise errors.CommandError(
 
6358
                    gettext('cannot create branch without source branch'))
 
6359
            to_location = lookup_new_sibling_branch(
 
6360
                control_dir, to_location,
 
6361
                possible_transports=possible_transports)
 
6362
            if revision is not None:
 
6363
                revision = revision.as_revision_id(branch)
 
6364
            to_branch = branch.controldir.sprout(
 
6365
                to_location,
 
6366
                possible_transports=possible_transports,
 
6367
                revision_id=revision,
 
6368
                source_branch=branch).open_branch()
5570
6369
        else:
5571
6370
            try:
5572
 
                to_branch = Branch.open(to_location)
5573
 
            except errors.NotBranchError:
5574
 
                this_url = self._get_branch_location(control_dir)
5575
6371
                to_branch = Branch.open(
5576
 
                    urlutils.join(this_url, '..', to_location))
5577
 
        if revision is not None:
5578
 
            revision = revision.as_revision_id(to_branch)
5579
 
        switch.switch(control_dir, to_branch, force, revision_id=revision)
 
6372
                    to_location, possible_transports=possible_transports)
 
6373
            except errors.NotBranchError:
 
6374
                to_branch = open_sibling_branch(
 
6375
                    control_dir, to_location,
 
6376
                    possible_transports=possible_transports)
 
6377
            if revision is not None:
 
6378
                revision = revision.as_revision_id(to_branch)
 
6379
        possible_transports.append(to_branch.user_transport)
 
6380
        try:
 
6381
            switch.switch(control_dir, to_branch, force, revision_id=revision,
 
6382
                          store_uncommitted=store,
 
6383
                          possible_transports=possible_transports)
 
6384
        except controldir.BranchReferenceLoop:
 
6385
            raise errors.CommandError(
 
6386
                gettext('switching would create a branch reference loop. '
 
6387
                        'Use the "bzr up" command to switch to a '
 
6388
                        'different revision.'))
5580
6389
        if had_explicit_nick:
5581
 
            branch = control_dir.open_branch() #get the new branch!
 
6390
            branch = control_dir.open_branch()  # get the new branch!
5582
6391
            branch.nick = to_branch.nick
5583
 
        note('Switched to branch: %s',
5584
 
            urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5585
 
 
5586
 
    def _get_branch_location(self, control_dir):
5587
 
        """Return location of branch for this control dir."""
5588
 
        try:
5589
 
            this_branch = control_dir.open_branch()
5590
 
            # This may be a heavy checkout, where we want the master branch
5591
 
            master_location = this_branch.get_bound_location()
5592
 
            if master_location is not None:
5593
 
                return master_location
5594
 
            # If not, use a local sibling
5595
 
            return this_branch.base
5596
 
        except errors.NotBranchError:
5597
 
            format = control_dir.find_branch_format()
5598
 
            if getattr(format, 'get_reference', None) is not None:
5599
 
                return format.get_reference(control_dir)
 
6392
        if to_branch.name:
 
6393
            if to_branch.controldir.control_url != control_dir.control_url:
 
6394
                note(gettext('Switched to branch %s at %s'),
 
6395
                     to_branch.name, urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5600
6396
            else:
5601
 
                return control_dir.root_transport.base
 
6397
                note(gettext('Switched to branch %s'), to_branch.name)
 
6398
        else:
 
6399
            note(gettext('Switched to branch at %s'),
 
6400
                 urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5602
6401
 
5603
6402
 
5604
6403
class cmd_view(Command):
5624
6423
    :Examples:
5625
6424
      To define the current view::
5626
6425
 
5627
 
        bzr view file1 dir1 ...
 
6426
        brz view file1 dir1 ...
5628
6427
 
5629
6428
      To list the current view::
5630
6429
 
5631
 
        bzr view
 
6430
        brz view
5632
6431
 
5633
6432
      To delete the current view::
5634
6433
 
5635
 
        bzr view --delete
 
6434
        brz view --delete
5636
6435
 
5637
6436
      To disable the current view without deleting it::
5638
6437
 
5639
 
        bzr view --switch off
 
6438
        brz view --switch off
5640
6439
 
5641
6440
      To define a named view and switch to it::
5642
6441
 
5643
 
        bzr view --name view-name file1 dir1 ...
 
6442
        brz view --name view-name file1 dir1 ...
5644
6443
 
5645
6444
      To list a named view::
5646
6445
 
5647
 
        bzr view --name view-name
 
6446
        brz view --name view-name
5648
6447
 
5649
6448
      To delete a named view::
5650
6449
 
5651
 
        bzr view --name view-name --delete
 
6450
        brz view --name view-name --delete
5652
6451
 
5653
6452
      To switch to a named view::
5654
6453
 
5655
 
        bzr view --switch view-name
 
6454
        brz view --switch view-name
5656
6455
 
5657
6456
      To list all views defined::
5658
6457
 
5659
 
        bzr view --all
 
6458
        brz view --all
5660
6459
 
5661
6460
      To delete all views::
5662
6461
 
5663
 
        bzr view --delete --all
 
6462
        brz view --delete --all
5664
6463
    """
5665
6464
 
5666
6465
    _see_also = []
5667
6466
    takes_args = ['file*']
5668
6467
    takes_options = [
5669
6468
        Option('all',
5670
 
            help='Apply list or delete action to all views.',
5671
 
            ),
 
6469
               help='Apply list or delete action to all views.',
 
6470
               ),
5672
6471
        Option('delete',
5673
 
            help='Delete the view.',
5674
 
            ),
 
6472
               help='Delete the view.',
 
6473
               ),
5675
6474
        Option('name',
5676
 
            help='Name of the view to define, list or delete.',
5677
 
            type=unicode,
5678
 
            ),
 
6475
               help='Name of the view to define, list or delete.',
 
6476
               type=text_type,
 
6477
               ),
5679
6478
        Option('switch',
5680
 
            help='Name of the view to switch to.',
5681
 
            type=unicode,
5682
 
            ),
 
6479
               help='Name of the view to switch to.',
 
6480
               type=text_type,
 
6481
               ),
5683
6482
        ]
5684
6483
 
5685
6484
    def run(self, file_list,
5688
6487
            name=None,
5689
6488
            switch=None,
5690
6489
            ):
5691
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
6490
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
6491
                                                            apply_view=False)
5692
6492
        current_view, view_dict = tree.views.get_view_info()
5693
6493
        if name is None:
5694
6494
            name = current_view
5695
6495
        if delete:
5696
6496
            if file_list:
5697
 
                raise errors.BzrCommandError(
5698
 
                    "Both --delete and a file list specified")
 
6497
                raise errors.CommandError(gettext(
 
6498
                    "Both --delete and a file list specified"))
5699
6499
            elif switch:
5700
 
                raise errors.BzrCommandError(
5701
 
                    "Both --delete and --switch specified")
 
6500
                raise errors.CommandError(gettext(
 
6501
                    "Both --delete and --switch specified"))
5702
6502
            elif all:
5703
6503
                tree.views.set_view_info(None, {})
5704
 
                self.outf.write("Deleted all views.\n")
 
6504
                self.outf.write(gettext("Deleted all views.\n"))
5705
6505
            elif name is None:
5706
 
                raise errors.BzrCommandError("No current view to delete")
 
6506
                raise errors.CommandError(
 
6507
                    gettext("No current view to delete"))
5707
6508
            else:
5708
6509
                tree.views.delete_view(name)
5709
 
                self.outf.write("Deleted '%s' view.\n" % name)
 
6510
                self.outf.write(gettext("Deleted '%s' view.\n") % name)
5710
6511
        elif switch:
5711
6512
            if file_list:
5712
 
                raise errors.BzrCommandError(
5713
 
                    "Both --switch and a file list specified")
 
6513
                raise errors.CommandError(gettext(
 
6514
                    "Both --switch and a file list specified"))
5714
6515
            elif all:
5715
 
                raise errors.BzrCommandError(
5716
 
                    "Both --switch and --all specified")
 
6516
                raise errors.CommandError(gettext(
 
6517
                    "Both --switch and --all specified"))
5717
6518
            elif switch == 'off':
5718
6519
                if current_view is None:
5719
 
                    raise errors.BzrCommandError("No current view to disable")
 
6520
                    raise errors.CommandError(
 
6521
                        gettext("No current view to disable"))
5720
6522
                tree.views.set_view_info(None, view_dict)
5721
 
                self.outf.write("Disabled '%s' view.\n" % (current_view))
 
6523
                self.outf.write(gettext("Disabled '%s' view.\n") %
 
6524
                                (current_view))
5722
6525
            else:
5723
6526
                tree.views.set_view_info(switch, view_dict)
5724
6527
                view_str = views.view_display_str(tree.views.lookup_view())
5725
 
                self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
 
6528
                self.outf.write(
 
6529
                    gettext("Using '{0}' view: {1}\n").format(switch, view_str))
5726
6530
        elif all:
5727
6531
            if view_dict:
5728
 
                self.outf.write('Views defined:\n')
 
6532
                self.outf.write(gettext('Views defined:\n'))
5729
6533
                for view in sorted(view_dict):
5730
6534
                    if view == current_view:
5731
6535
                        active = "=>"
5734
6538
                    view_str = views.view_display_str(view_dict[view])
5735
6539
                    self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5736
6540
            else:
5737
 
                self.outf.write('No views defined.\n')
 
6541
                self.outf.write(gettext('No views defined.\n'))
5738
6542
        elif file_list:
5739
6543
            if name is None:
5740
6544
                # No name given and no current view set
5741
6545
                name = 'my'
5742
6546
            elif name == 'off':
5743
 
                raise errors.BzrCommandError(
5744
 
                    "Cannot change the 'off' pseudo view")
 
6547
                raise errors.CommandError(gettext(
 
6548
                    "Cannot change the 'off' pseudo view"))
5745
6549
            tree.views.set_view(name, sorted(file_list))
5746
6550
            view_str = views.view_display_str(tree.views.lookup_view())
5747
 
            self.outf.write("Using '%s' view: %s\n" % (name, view_str))
 
6551
            self.outf.write(
 
6552
                gettext("Using '{0}' view: {1}\n").format(name, view_str))
5748
6553
        else:
5749
6554
            # list the files
5750
6555
            if name is None:
5751
6556
                # No name given and no current view set
5752
 
                self.outf.write('No current view.\n')
 
6557
                self.outf.write(gettext('No current view.\n'))
5753
6558
            else:
5754
6559
                view_str = views.view_display_str(tree.views.lookup_view(name))
5755
 
                self.outf.write("'%s' view is: %s\n" % (name, view_str))
 
6560
                self.outf.write(
 
6561
                    gettext("'{0}' view is: {1}\n").format(name, view_str))
5756
6562
 
5757
6563
 
5758
6564
class cmd_hooks(Command):
5772
6578
                        self.outf.write("    %s\n" %
5773
6579
                                        (some_hooks.get_hook_name(hook),))
5774
6580
                else:
5775
 
                    self.outf.write("    <no hooks installed>\n")
 
6581
                    self.outf.write(gettext("    <no hooks installed>\n"))
5776
6582
 
5777
6583
 
5778
6584
class cmd_remove_branch(Command):
5779
6585
    __doc__ = """Remove a branch.
5780
6586
 
5781
 
    This will remove the branch from the specified location but 
 
6587
    This will remove the branch from the specified location but
5782
6588
    will keep any working tree or repository in place.
5783
6589
 
5784
6590
    :Examples:
5785
6591
 
5786
6592
      Remove the branch at repo/trunk::
5787
6593
 
5788
 
        bzr remove-branch repo/trunk
 
6594
        brz remove-branch repo/trunk
5789
6595
 
5790
6596
    """
5791
6597
 
5792
6598
    takes_args = ["location?"]
5793
6599
 
 
6600
    takes_options = ['directory',
 
6601
                     Option('force', help='Remove branch even if it is the active branch.')]
 
6602
 
5794
6603
    aliases = ["rmbranch"]
5795
6604
 
5796
 
    def run(self, location=None):
5797
 
        if location is None:
5798
 
            location = "."
5799
 
        branch = Branch.open_containing(location)[0]
5800
 
        branch.bzrdir.destroy_branch()
5801
 
        
 
6605
    def run(self, directory=None, location=None, force=False):
 
6606
        br = open_nearby_branch(near=directory, location=location)
 
6607
        if not force and br.controldir.has_workingtree():
 
6608
            try:
 
6609
                active_branch = br.controldir.open_branch(name="")
 
6610
            except errors.NotBranchError:
 
6611
                active_branch = None
 
6612
            if (active_branch is not None and
 
6613
                    br.control_url == active_branch.control_url):
 
6614
                raise errors.CommandError(
 
6615
                    gettext("Branch is active. Use --force to remove it."))
 
6616
        br.controldir.destroy_branch(br.name)
 
6617
 
5802
6618
 
5803
6619
class cmd_shelve(Command):
5804
6620
    __doc__ = """Temporarily set aside some changes from the current tree.
5823
6639
 
5824
6640
    You can put multiple items on the shelf, and by default, 'unshelve' will
5825
6641
    restore the most recently shelved changes.
 
6642
 
 
6643
    For complicated changes, it is possible to edit the changes in a separate
 
6644
    editor program to decide what the file remaining in the working copy
 
6645
    should look like.  To do this, add the configuration option
 
6646
 
 
6647
        change_editor = PROGRAM {new_path} {old_path}
 
6648
 
 
6649
    where {new_path} is replaced with the path of the new version of the
 
6650
    file and {old_path} is replaced with the path of the old version of
 
6651
    the file.  The PROGRAM should save the new file with the desired
 
6652
    contents of the file in the working tree.
 
6653
 
5826
6654
    """
5827
6655
 
5828
6656
    takes_args = ['file*']
5829
6657
 
5830
6658
    takes_options = [
 
6659
        'directory',
5831
6660
        'revision',
5832
6661
        Option('all', help='Shelve all changes.'),
5833
6662
        'message',
5834
6663
        RegistryOption('writer', 'Method to use for writing diffs.',
5835
 
                       bzrlib.option.diff_writer_registry,
 
6664
                       breezy.option.diff_writer_registry,
5836
6665
                       value_switches=True, enum_switch=False),
5837
6666
 
5838
6667
        Option('list', help='List shelved changes.'),
5839
6668
        Option('destroy',
5840
6669
               help='Destroy removed changes instead of shelving them.'),
5841
6670
    ]
5842
 
    _see_also = ['unshelve']
 
6671
    _see_also = ['unshelve', 'configuration']
5843
6672
 
5844
6673
    def run(self, revision=None, all=False, file_list=None, message=None,
5845
 
            writer=None, list=False, destroy=False):
 
6674
            writer=None, list=False, destroy=False, directory=None):
5846
6675
        if list:
5847
 
            return self.run_for_list()
5848
 
        from bzrlib.shelf_ui import Shelver
 
6676
            return self.run_for_list(directory=directory)
 
6677
        from .shelf_ui import Shelver
5849
6678
        if writer is None:
5850
 
            writer = bzrlib.option.diff_writer_registry.get()
 
6679
            writer = breezy.option.diff_writer_registry.get()
5851
6680
        try:
5852
 
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5853
 
                file_list, message, destroy=destroy)
 
6681
            shelver = Shelver.from_args(writer(self.outf), revision, all,
 
6682
                                        file_list, message, destroy=destroy, directory=directory)
5854
6683
            try:
5855
6684
                shelver.run()
5856
6685
            finally:
5858
6687
        except errors.UserAbort:
5859
6688
            return 0
5860
6689
 
5861
 
    def run_for_list(self):
5862
 
        tree = WorkingTree.open_containing('.')[0]
5863
 
        self.add_cleanup(tree.lock_read().unlock)
 
6690
    def run_for_list(self, directory=None):
 
6691
        if directory is None:
 
6692
            directory = u'.'
 
6693
        tree = WorkingTree.open_containing(directory)[0]
 
6694
        self.enter_context(tree.lock_read())
5864
6695
        manager = tree.get_shelf_manager()
5865
6696
        shelves = manager.active_shelves()
5866
6697
        if len(shelves) == 0:
5867
 
            note('No shelved changes.')
 
6698
            note(gettext('No shelved changes.'))
5868
6699
            return 0
5869
6700
        for shelf_id in reversed(shelves):
5870
 
            message = manager.get_metadata(shelf_id).get('message')
 
6701
            message = manager.get_metadata(shelf_id).get(b'message')
5871
6702
            if message is None:
5872
6703
                message = '<no message>'
5873
6704
            self.outf.write('%3d: %s\n' % (shelf_id, message))
5884
6715
 
5885
6716
    takes_args = ['shelf_id?']
5886
6717
    takes_options = [
 
6718
        'directory',
5887
6719
        RegistryOption.from_kwargs(
5888
6720
            'action', help="The action to perform.",
5889
6721
            enum_switch=False, value_switches=True,
5897
6729
    ]
5898
6730
    _see_also = ['shelve']
5899
6731
 
5900
 
    def run(self, shelf_id=None, action='apply'):
5901
 
        from bzrlib.shelf_ui import Unshelver
5902
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6732
    def run(self, shelf_id=None, action='apply', directory=u'.'):
 
6733
        from .shelf_ui import Unshelver
 
6734
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5903
6735
        try:
5904
6736
            unshelver.run()
5905
6737
        finally:
5912
6744
    By default, only unknown files, not ignored files, are deleted.  Versioned
5913
6745
    files are never deleted.
5914
6746
 
5915
 
    Another class is 'detritus', which includes files emitted by bzr during
 
6747
    Another class is 'detritus', which includes files emitted by brz during
5916
6748
    normal operations and selftests.  (The value of these files decreases with
5917
6749
    time.)
5918
6750
 
5921
6753
 
5922
6754
    To check what clean-tree will do, use --dry-run.
5923
6755
    """
5924
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
5925
 
                     Option('detritus', help='Delete conflict files, merge'
 
6756
    takes_options = ['directory',
 
6757
                     Option('ignored', help='Delete all ignored files.'),
 
6758
                     Option('detritus', help='Delete conflict files, merge and revert'
5926
6759
                            ' backups, and failed selftest dirs.'),
5927
6760
                     Option('unknown',
5928
 
                            help='Delete files unknown to bzr (default).'),
 
6761
                            help='Delete files unknown to brz (default).'),
5929
6762
                     Option('dry-run', help='Show files to delete instead of'
5930
6763
                            ' deleting them.'),
5931
6764
                     Option('force', help='Do not prompt before deleting.')]
 
6765
 
5932
6766
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5933
 
            force=False):
5934
 
        from bzrlib.clean_tree import clean_tree
 
6767
            force=False, directory=u'.'):
 
6768
        from .clean_tree import clean_tree
5935
6769
        if not (unknown or ignored or detritus):
5936
6770
            unknown = True
5937
6771
        if dry_run:
5938
6772
            force = True
5939
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5940
 
                   dry_run=dry_run, no_prompt=force)
 
6773
        clean_tree(directory, unknown=unknown, ignored=ignored,
 
6774
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
5941
6775
 
5942
6776
 
5943
6777
class cmd_reference(Command):
5951
6785
    hidden = True
5952
6786
 
5953
6787
    takes_args = ['path?', 'location?']
 
6788
    takes_options = [
 
6789
        'directory',
 
6790
        Option('force-unversioned',
 
6791
               help='Set reference even if path is not versioned.'),
 
6792
        ]
5954
6793
 
5955
 
    def run(self, path=None, location=None):
5956
 
        branchdir = '.'
5957
 
        if path is not None:
5958
 
            branchdir = path
5959
 
        tree, branch, relpath =(
5960
 
            bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
5961
 
        if path is not None:
5962
 
            path = relpath
 
6794
    def run(self, path=None, directory='.', location=None, force_unversioned=False):
 
6795
        tree, branch, relpath = (
 
6796
            controldir.ControlDir.open_containing_tree_or_branch(directory))
5963
6797
        if tree is None:
5964
6798
            tree = branch.basis_tree()
5965
6799
        if path is None:
5966
 
            info = branch._get_all_reference_info().iteritems()
5967
 
            self._display_reference_info(tree, branch, info)
 
6800
            with tree.lock_read():
 
6801
                info = [
 
6802
                    (path, tree.get_reference_info(path, branch))
 
6803
                    for path in tree.iter_references()]
 
6804
                self._display_reference_info(tree, branch, info)
5968
6805
        else:
5969
 
            file_id = tree.path2id(path)
5970
 
            if file_id is None:
 
6806
            if not tree.is_versioned(path) and not force_unversioned:
5971
6807
                raise errors.NotVersionedError(path)
5972
6808
            if location is None:
5973
 
                info = [(file_id, branch.get_reference_info(file_id))]
 
6809
                info = [(path, tree.get_reference_info(path, branch))]
5974
6810
                self._display_reference_info(tree, branch, info)
5975
6811
            else:
5976
 
                branch.set_reference_info(file_id, path, location)
 
6812
                tree.set_reference_info(path, location)
5977
6813
 
5978
6814
    def _display_reference_info(self, tree, branch, info):
5979
6815
        ref_list = []
5980
 
        for file_id, (path, location) in info:
5981
 
            try:
5982
 
                path = tree.id2path(file_id)
5983
 
            except errors.NoSuchId:
5984
 
                pass
 
6816
        for path, location in info:
5985
6817
            ref_list.append((path, location))
5986
6818
        for path, location in sorted(ref_list):
5987
6819
            self.outf.write('%s %s\n' % (path, location))
5988
6820
 
5989
6821
 
 
6822
class cmd_export_pot(Command):
 
6823
    __doc__ = """Export command helps and error messages in po format."""
 
6824
 
 
6825
    hidden = True
 
6826
    takes_options = [Option('plugin',
 
6827
                            help='Export help text from named command '
 
6828
                                 '(defaults to all built in commands).',
 
6829
                            type=text_type),
 
6830
                     Option('include-duplicates',
 
6831
                            help='Output multiple copies of the same msgid '
 
6832
                                 'string if it appears more than once.'),
 
6833
                     ]
 
6834
 
 
6835
    def run(self, plugin=None, include_duplicates=False):
 
6836
        from .export_pot import export_pot
 
6837
        export_pot(self.outf, plugin, include_duplicates)
 
6838
 
 
6839
 
 
6840
class cmd_import(Command):
 
6841
    __doc__ = """Import sources from a directory, tarball or zip file
 
6842
 
 
6843
    This command will import a directory, tarball or zip file into a bzr
 
6844
    tree, replacing any versioned files already present.  If a directory is
 
6845
    specified, it is used as the target.  If the directory does not exist, or
 
6846
    is not versioned, it is created.
 
6847
 
 
6848
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
 
6849
 
 
6850
    If the tarball or zip has a single root directory, that directory is
 
6851
    stripped when extracting the tarball.  This is not done for directories.
 
6852
    """
 
6853
 
 
6854
    takes_args = ['source', 'tree?']
 
6855
 
 
6856
    def run(self, source, tree=None):
 
6857
        from .upstream_import import do_import
 
6858
        do_import(source, tree)
 
6859
 
 
6860
 
 
6861
class cmd_link_tree(Command):
 
6862
    __doc__ = """Hardlink matching files to another tree.
 
6863
 
 
6864
    Only files with identical content and execute bit will be linked.
 
6865
    """
 
6866
 
 
6867
    takes_args = ['location']
 
6868
 
 
6869
    def run(self, location):
 
6870
        from .transform import link_tree
 
6871
        target_tree = WorkingTree.open_containing(".")[0]
 
6872
        source_tree = WorkingTree.open(location)
 
6873
        with target_tree.lock_write(), source_tree.lock_read():
 
6874
            link_tree(target_tree, source_tree)
 
6875
 
 
6876
 
 
6877
class cmd_fetch_ghosts(Command):
 
6878
    __doc__ = """Attempt to retrieve ghosts from another branch.
 
6879
 
 
6880
    If the other branch is not supplied, the last-pulled branch is used.
 
6881
    """
 
6882
 
 
6883
    hidden = True
 
6884
    aliases = ['fetch-missing']
 
6885
    takes_args = ['branch?']
 
6886
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
 
6887
 
 
6888
    def run(self, branch=None, no_fix=False):
 
6889
        from .fetch_ghosts import GhostFetcher
 
6890
        installed, failed = GhostFetcher.from_cmdline(branch).run()
 
6891
        if len(installed) > 0:
 
6892
            self.outf.write("Installed:\n")
 
6893
            for rev in installed:
 
6894
                self.outf.write(rev.decode('utf-8') + "\n")
 
6895
        if len(failed) > 0:
 
6896
            self.outf.write("Still missing:\n")
 
6897
            for rev in failed:
 
6898
                self.outf.write(rev.decode('utf-8') + "\n")
 
6899
        if not no_fix and len(installed) > 0:
 
6900
            cmd_reconcile().run(".")
 
6901
 
 
6902
 
 
6903
class cmd_grep(Command):
 
6904
    """Print lines matching PATTERN for specified files and revisions.
 
6905
 
 
6906
    This command searches the specified files and revisions for a given
 
6907
    pattern.  The pattern is specified as a Python regular expressions[1].
 
6908
 
 
6909
    If the file name is not specified, the revisions starting with the
 
6910
    current directory are searched recursively. If the revision number is
 
6911
    not specified, the working copy is searched. To search the last committed
 
6912
    revision, use the '-r -1' or '-r last:1' option.
 
6913
 
 
6914
    Unversioned files are not searched unless explicitly specified on the
 
6915
    command line. Unversioned directores are not searched.
 
6916
 
 
6917
    When searching a pattern, the output is shown in the 'filepath:string'
 
6918
    format. If a revision is explicitly searched, the output is shown as
 
6919
    'filepath~N:string', where N is the revision number.
 
6920
 
 
6921
    --include and --exclude options can be used to search only (or exclude
 
6922
    from search) files with base name matches the specified Unix style GLOB
 
6923
    pattern.  The GLOB pattern an use *, ?, and [...] as wildcards, and \\
 
6924
    to quote wildcard or backslash character literally. Note that the glob
 
6925
    pattern is not a regular expression.
 
6926
 
 
6927
    [1] http://docs.python.org/library/re.html#regular-expression-syntax
 
6928
    """
 
6929
 
 
6930
    encoding_type = 'replace'
 
6931
    takes_args = ['pattern', 'path*']
 
6932
    takes_options = [
 
6933
        'verbose',
 
6934
        'revision',
 
6935
        Option('color', type=text_type, argname='when',
 
6936
               help='Show match in color. WHEN is never, always or auto.'),
 
6937
        Option('diff', short_name='p',
 
6938
               help='Grep for pattern in changeset for each revision.'),
 
6939
        ListOption('exclude', type=text_type, argname='glob', short_name='X',
 
6940
                   help="Skip files whose base name matches GLOB."),
 
6941
        ListOption('include', type=text_type, argname='glob', short_name='I',
 
6942
                   help="Search only files whose base name matches GLOB."),
 
6943
        Option('files-with-matches', short_name='l',
 
6944
               help='Print only the name of each input file in '
 
6945
               'which PATTERN is found.'),
 
6946
        Option('files-without-match', short_name='L',
 
6947
               help='Print only the name of each input file in '
 
6948
               'which PATTERN is not found.'),
 
6949
        Option('fixed-string', short_name='F',
 
6950
               help='Interpret PATTERN is a single fixed string (not regex).'),
 
6951
        Option('from-root',
 
6952
               help='Search for pattern starting from the root of the branch. '
 
6953
               '(implies --recursive)'),
 
6954
        Option('ignore-case', short_name='i',
 
6955
               help='Ignore case distinctions while matching.'),
 
6956
        Option('levels',
 
6957
               help='Number of levels to display - 0 for all, 1 for collapsed '
 
6958
               '(1 is default).',
 
6959
               argname='N',
 
6960
               type=_parse_levels),
 
6961
        Option('line-number', short_name='n',
 
6962
               help='Show 1-based line number.'),
 
6963
        Option('no-recursive',
 
6964
               help="Don't recurse into subdirectories. (default is --recursive)"),
 
6965
        Option('null', short_name='Z',
 
6966
               help='Write an ASCII NUL (\\0) separator '
 
6967
               'between output lines rather than a newline.'),
 
6968
        ]
 
6969
 
 
6970
    @display_command
 
6971
    def run(self, verbose=False, ignore_case=False, no_recursive=False,
 
6972
            from_root=False, null=False, levels=None, line_number=False,
 
6973
            path_list=None, revision=None, pattern=None, include=None,
 
6974
            exclude=None, fixed_string=False, files_with_matches=False,
 
6975
            files_without_match=False, color=None, diff=False):
 
6976
        from breezy import _termcolor
 
6977
        from . import grep
 
6978
        import re
 
6979
        if path_list is None:
 
6980
            path_list = ['.']
 
6981
        else:
 
6982
            if from_root:
 
6983
                raise errors.CommandError(
 
6984
                    'cannot specify both --from-root and PATH.')
 
6985
 
 
6986
        if files_with_matches and files_without_match:
 
6987
            raise errors.CommandError(
 
6988
                'cannot specify both '
 
6989
                '-l/--files-with-matches and -L/--files-without-matches.')
 
6990
 
 
6991
        global_config = _mod_config.GlobalConfig()
 
6992
 
 
6993
        if color is None:
 
6994
            color = global_config.get_user_option('grep_color')
 
6995
 
 
6996
        if color is None:
 
6997
            color = 'never'
 
6998
 
 
6999
        if color not in ['always', 'never', 'auto']:
 
7000
            raise errors.CommandError('Valid values for --color are '
 
7001
                                         '"always", "never" or "auto".')
 
7002
 
 
7003
        if levels is None:
 
7004
            levels = 1
 
7005
 
 
7006
        print_revno = False
 
7007
        if revision is not None or levels == 0:
 
7008
            # print revision numbers as we may be showing multiple revisions
 
7009
            print_revno = True
 
7010
 
 
7011
        eol_marker = '\n'
 
7012
        if null:
 
7013
            eol_marker = '\0'
 
7014
 
 
7015
        if not ignore_case and grep.is_fixed_string(pattern):
 
7016
            # if the pattern isalnum, implicitly use to -F for faster grep
 
7017
            fixed_string = True
 
7018
        elif ignore_case and fixed_string:
 
7019
            # GZ 2010-06-02: Fall back to regexp rather than lowercasing
 
7020
            #                pattern and text which will cause pain later
 
7021
            fixed_string = False
 
7022
            pattern = re.escape(pattern)
 
7023
 
 
7024
        patternc = None
 
7025
        re_flags = re.MULTILINE
 
7026
        if ignore_case:
 
7027
            re_flags |= re.IGNORECASE
 
7028
 
 
7029
        if not fixed_string:
 
7030
            patternc = grep.compile_pattern(
 
7031
                pattern.encode(grep._user_encoding), re_flags)
 
7032
 
 
7033
        if color == 'always':
 
7034
            show_color = True
 
7035
        elif color == 'never':
 
7036
            show_color = False
 
7037
        elif color == 'auto':
 
7038
            show_color = _termcolor.allow_color()
 
7039
 
 
7040
        opts = grep.GrepOptions()
 
7041
 
 
7042
        opts.verbose = verbose
 
7043
        opts.ignore_case = ignore_case
 
7044
        opts.no_recursive = no_recursive
 
7045
        opts.from_root = from_root
 
7046
        opts.null = null
 
7047
        opts.levels = levels
 
7048
        opts.line_number = line_number
 
7049
        opts.path_list = path_list
 
7050
        opts.revision = revision
 
7051
        opts.pattern = pattern
 
7052
        opts.include = include
 
7053
        opts.exclude = exclude
 
7054
        opts.fixed_string = fixed_string
 
7055
        opts.files_with_matches = files_with_matches
 
7056
        opts.files_without_match = files_without_match
 
7057
        opts.color = color
 
7058
        opts.diff = False
 
7059
 
 
7060
        opts.eol_marker = eol_marker
 
7061
        opts.print_revno = print_revno
 
7062
        opts.patternc = patternc
 
7063
        opts.recursive = not no_recursive
 
7064
        opts.fixed_string = fixed_string
 
7065
        opts.outf = self.outf
 
7066
        opts.show_color = show_color
 
7067
 
 
7068
        if diff:
 
7069
            # options not used:
 
7070
            # files_with_matches, files_without_match
 
7071
            # levels(?), line_number, from_root
 
7072
            # include, exclude
 
7073
            # These are silently ignored.
 
7074
            grep.grep_diff(opts)
 
7075
        elif revision is None:
 
7076
            grep.workingtree_grep(opts)
 
7077
        else:
 
7078
            grep.versioned_grep(opts)
 
7079
 
 
7080
 
 
7081
class cmd_patch(Command):
 
7082
    """Apply a named patch to the current tree.
 
7083
 
 
7084
    """
 
7085
 
 
7086
    takes_args = ['filename?']
 
7087
    takes_options = [Option('strip', type=int, short_name='p',
 
7088
                            help=("Strip the smallest prefix containing num "
 
7089
                                  "leading slashes from filenames.")),
 
7090
                     Option('silent', help='Suppress chatter.')]
 
7091
 
 
7092
    def run(self, filename=None, strip=None, silent=False):
 
7093
        from .patch import patch_tree
 
7094
        wt = WorkingTree.open_containing('.')[0]
 
7095
        if strip is None:
 
7096
            strip = 1
 
7097
        my_file = None
 
7098
        if filename is None:
 
7099
            my_file = getattr(sys.stdin, 'buffer', sys.stdin)
 
7100
        else:
 
7101
            my_file = open(filename, 'rb')
 
7102
        patches = [my_file.read()]
 
7103
        return patch_tree(wt, patches, strip, quiet=is_quiet(), out=self.outf)
 
7104
 
 
7105
 
 
7106
class cmd_resolve_location(Command):
 
7107
    __doc__ = """Expand a location to a full URL.
 
7108
 
 
7109
    :Examples:
 
7110
        Look up a Launchpad URL.
 
7111
 
 
7112
            brz resolve-location lp:brz
 
7113
    """
 
7114
    takes_args = ['location']
 
7115
    hidden = True
 
7116
 
 
7117
    def run(self, location):
 
7118
        from .location import location_to_url
 
7119
        url = location_to_url(location)
 
7120
        display_url = urlutils.unescape_for_display(url, self.outf.encoding)
 
7121
        self.outf.write('%s\n' % display_url)
 
7122
 
 
7123
 
5990
7124
def _register_lazy_builtins():
5991
7125
    # register lazy builtins from other modules; called at startup and should
5992
7126
    # be only called once.
5993
7127
    for (name, aliases, module_name) in [
5994
 
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
5995
 
        ('cmd_dpush', [], 'bzrlib.foreign'),
5996
 
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
5997
 
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
5998
 
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
5999
 
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6000
 
        ]:
 
7128
            ('cmd_bisect', [], 'breezy.bisect'),
 
7129
            ('cmd_bundle_info', [], 'breezy.bzr.bundle.commands'),
 
7130
            ('cmd_config', [], 'breezy.config'),
 
7131
            ('cmd_dump_btree', [], 'breezy.bzr.debug_commands'),
 
7132
            ('cmd_file_id', [], 'breezy.bzr.debug_commands'),
 
7133
            ('cmd_file_path', [], 'breezy.bzr.debug_commands'),
 
7134
            ('cmd_version_info', [], 'breezy.cmd_version_info'),
 
7135
            ('cmd_resolve', ['resolved'], 'breezy.conflicts'),
 
7136
            ('cmd_conflicts', [], 'breezy.conflicts'),
 
7137
            ('cmd_ping', [], 'breezy.bzr.smart.ping'),
 
7138
            ('cmd_sign_my_commits', [], 'breezy.commit_signature_commands'),
 
7139
            ('cmd_verify_signatures', [], 'breezy.commit_signature_commands'),
 
7140
            ('cmd_test_script', [], 'breezy.cmd_test_script'),
 
7141
            ]:
6001
7142
        builtin_command_registry.register_lazy(name, aliases, module_name)