← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

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