← 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
54
    ui,
49
55
    urlutils,
50
56
    views,
 
57
    gpg,
51
58
    )
52
59
from bzrlib.branch import Branch
53
60
from bzrlib.conflicts import ConflictList
 
61
from bzrlib.transport import memory
54
62
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
55
63
from bzrlib.smtp_connection import SMTPConnection
56
64
from bzrlib.workingtree import WorkingTree
 
65
from bzrlib.i18n import gettext, ngettext
57
66
""")
58
67
 
59
 
from bzrlib.commands import Command, display_command
 
68
from bzrlib.commands import (
 
69
    Command,
 
70
    builtin_command_registry,
 
71
    display_command,
 
72
    )
60
73
from bzrlib.option import (
61
74
    ListOption,
62
75
    Option,
65
78
    _parse_revision_str,
66
79
    )
67
80
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
68
 
 
69
 
 
70
 
def tree_files(file_list, default_branch=u'.', canonicalize=True,
71
 
    apply_view=True):
72
 
    try:
73
 
        return internal_tree_files(file_list, default_branch, canonicalize,
74
 
            apply_view)
75
 
    except errors.FileInWrongBranch, e:
76
 
        raise errors.BzrCommandError("%s is not in the same branch as %s" %
77
 
                                     (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
78
221
 
79
222
 
80
223
def tree_files_for_add(file_list):
105
248
            if view_files:
106
249
                file_list = view_files
107
250
                view_str = views.view_display_str(view_files)
108
 
                note("Ignoring files outside view. View is %s" % view_str)
 
251
                note(gettext("Ignoring files outside view. View is %s") % view_str)
109
252
    return tree, file_list
110
253
 
111
254
 
113
256
    if revisions is None:
114
257
        return None
115
258
    if len(revisions) != 1:
116
 
        raise errors.BzrCommandError(
117
 
            'bzr %s --revision takes exactly one revision identifier' % (
 
259
        raise errors.BzrCommandError(gettext(
 
260
            'bzr %s --revision takes exactly one revision identifier') % (
118
261
                command_name,))
119
262
    return revisions[0]
120
263
 
121
264
 
122
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
    """
123
275
    if branch is None:
124
276
        branch = tree.branch
125
277
    if revisions is None:
133
285
    return rev_tree
134
286
 
135
287
 
136
 
# XXX: Bad function name; should possibly also be a class method of
137
 
# WorkingTree rather than a function.
138
 
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
139
 
    apply_view=True):
140
 
    """Convert command-line paths to a WorkingTree and relative paths.
141
 
 
142
 
    This is typically used for command-line processors that take one or
143
 
    more filenames, and infer the workingtree that contains them.
144
 
 
145
 
    The filenames given are not required to exist.
146
 
 
147
 
    :param file_list: Filenames to convert.
148
 
 
149
 
    :param default_branch: Fallback tree path to use if file_list is empty or
150
 
        None.
151
 
 
152
 
    :param apply_view: if True and a view is set, apply it or check that
153
 
        specified files are within it
154
 
 
155
 
    :return: workingtree, [relative_paths]
156
 
    """
157
 
    if file_list is None or len(file_list) == 0:
158
 
        tree = WorkingTree.open_containing(default_branch)[0]
159
 
        if tree.supports_views() and apply_view:
160
 
            view_files = tree.views.lookup_view()
161
 
            if view_files:
162
 
                file_list = view_files
163
 
                view_str = views.view_display_str(view_files)
164
 
                note("Ignoring files outside view. View is %s" % view_str)
165
 
        return tree, file_list
166
 
    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
167
 
    return tree, safe_relpath_files(tree, file_list, canonicalize,
168
 
        apply_view=apply_view)
169
 
 
170
 
 
171
 
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
172
 
    """Convert file_list into a list of relpaths in tree.
173
 
 
174
 
    :param tree: A tree to operate on.
175
 
    :param file_list: A list of user provided paths or None.
176
 
    :param apply_view: if True and a view is set, apply it or check that
177
 
        specified files are within it
178
 
    :return: A list of relative paths.
179
 
    :raises errors.PathNotChild: When a provided path is in a different tree
180
 
        than tree.
181
 
    """
182
 
    if file_list is None:
183
 
        return None
184
 
    if tree.supports_views() and apply_view:
185
 
        view_files = tree.views.lookup_view()
186
 
    else:
187
 
        view_files = []
188
 
    new_list = []
189
 
    # tree.relpath exists as a "thunk" to osutils, but canonical_relpath
190
 
    # doesn't - fix that up here before we enter the loop.
191
 
    if canonicalize:
192
 
        fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
193
 
    else:
194
 
        fixer = tree.relpath
195
 
    for filename in file_list:
196
 
        try:
197
 
            relpath = fixer(osutils.dereference_path(filename))
198
 
            if  view_files and not osutils.is_inside_any(view_files, relpath):
199
 
                raise errors.FileOutsideView(filename, view_files)
200
 
            new_list.append(relpath)
201
 
        except errors.PathNotChild:
202
 
            raise errors.FileInWrongBranch(tree.branch, filename)
203
 
    return new_list
204
 
 
205
 
 
206
288
def _get_view_info_for_change_reporter(tree):
207
289
    """Get the view information from a tree for change reporting."""
208
290
    view_info = None
215
297
    return view_info
216
298
 
217
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
 
218
308
# TODO: Make sure no commands unconditionally use the working directory as a
219
309
# branch.  If a filename argument is used, the first of them should be used to
220
310
# specify the branch.  (Perhaps this can be factored out into some kind of
222
312
# opens the branch?)
223
313
 
224
314
class cmd_status(Command):
225
 
    """Display status summary.
 
315
    __doc__ = """Display status summary.
226
316
 
227
317
    This reports on versioned and unknown files, reporting them
228
318
    grouped by state.  Possible states are:
248
338
    unknown
249
339
        Not versioned and not matching an ignore pattern.
250
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
 
251
346
    To see ignored files use 'bzr ignored'.  For details on the
252
347
    changes to file texts, use 'bzr diff'.
253
348
 
265
360
    To skip the display of pending merge information altogether, use
266
361
    the no-pending option or specify a file/directory.
267
362
 
268
 
    If a revision argument is given, the status is calculated against
269
 
    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'.
270
369
    """
271
370
 
272
 
    # TODO: --no-recurse, --recurse options
 
371
    # TODO: --no-recurse/-N, --recurse options
273
372
 
274
373
    takes_args = ['file*']
275
374
    takes_options = ['show-ids', 'revision', 'change', 'verbose',
279
378
                            short_name='V'),
280
379
                     Option('no-pending', help='Don\'t show pending merges.',
281
380
                           ),
 
381
                     Option('no-classify',
 
382
                            help='Do not mark object type using indicator.',
 
383
                           ),
282
384
                     ]
283
385
    aliases = ['st', 'stat']
284
386
 
287
389
 
288
390
    @display_command
289
391
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
290
 
            versioned=False, no_pending=False, verbose=False):
 
392
            versioned=False, no_pending=False, verbose=False,
 
393
            no_classify=False):
291
394
        from bzrlib.status import show_tree_status
292
395
 
293
396
        if revision and len(revision) > 2:
294
 
            raise errors.BzrCommandError('bzr status --revision takes exactly'
295
 
                                         ' one or two revision specifiers')
 
397
            raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
 
398
                                         ' one or two revision specifiers'))
296
399
 
297
 
        tree, relfile_list = tree_files(file_list)
 
400
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
298
401
        # Avoid asking for specific files when that is not needed.
299
402
        if relfile_list == ['']:
300
403
            relfile_list = None
307
410
        show_tree_status(tree, show_ids=show_ids,
308
411
                         specific_files=relfile_list, revision=revision,
309
412
                         to_file=self.outf, short=short, versioned=versioned,
310
 
                         show_pending=(not no_pending), verbose=verbose)
 
413
                         show_pending=(not no_pending), verbose=verbose,
 
414
                         classify=not no_classify)
311
415
 
312
416
 
313
417
class cmd_cat_revision(Command):
314
 
    """Write out metadata for a revision.
 
418
    __doc__ = """Write out metadata for a revision.
315
419
 
316
420
    The revision to print can either be specified by a specific
317
421
    revision identifier, or you can use --revision.
319
423
 
320
424
    hidden = True
321
425
    takes_args = ['revision_id?']
322
 
    takes_options = ['revision']
 
426
    takes_options = ['directory', 'revision']
323
427
    # cat-revision is more for frontends so should be exact
324
428
    encoding = 'strict'
325
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
 
326
438
    @display_command
327
 
    def run(self, revision_id=None, revision=None):
 
439
    def run(self, revision_id=None, revision=None, directory=u'.'):
328
440
        if revision_id is not None and revision is not None:
329
 
            raise errors.BzrCommandError('You can only supply one of'
330
 
                                         ' revision_id or --revision')
 
441
            raise errors.BzrCommandError(gettext('You can only supply one of'
 
442
                                         ' revision_id or --revision'))
331
443
        if revision_id is None and revision is None:
332
 
            raise errors.BzrCommandError('You must supply either'
333
 
                                         ' --revision or a revision_id')
334
 
        b = WorkingTree.open_containing(u'.')[0].branch
335
 
 
336
 
        # TODO: jam 20060112 should cat-revision always output utf-8?
337
 
        if revision_id is not None:
338
 
            revision_id = osutils.safe_revision_id(revision_id, warn=False)
339
 
            try:
340
 
                self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
341
 
            except errors.NoSuchRevision:
342
 
                msg = "The repository %s contains no revision %s." % (b.repository.base,
343
 
                    revision_id)
344
 
                raise errors.BzrCommandError(msg)
345
 
        elif revision is not None:
346
 
            for rev in revision:
347
 
                if rev is None:
348
 
                    raise errors.BzrCommandError('You cannot specify a NULL'
349
 
                                                 ' revision.')
350
 
                rev_id = rev.as_revision_id(b)
351
 
                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
352
 
 
 
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
        
353
475
 
354
476
class cmd_dump_btree(Command):
355
 
    """Dump the contents of a btree index file to stdout.
 
477
    __doc__ = """Dump the contents of a btree index file to stdout.
356
478
 
357
479
    PATH is a btree index file, it can be any URL. This includes things like
358
480
    .bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
406
528
                self.outf.write(page_bytes[:header_end])
407
529
                page_bytes = data
408
530
            self.outf.write('\nPage %d\n' % (page_idx,))
409
 
            decomp_bytes = zlib.decompress(page_bytes)
410
 
            self.outf.write(decomp_bytes)
411
 
            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')
412
537
 
413
538
    def _dump_entries(self, trans, basename):
414
539
        try:
422
547
        for node in bt.iter_all_entries():
423
548
            # Node is made up of:
424
549
            # (index, key, value, [references])
425
 
            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,))
426
558
 
427
559
 
428
560
class cmd_remove_tree(Command):
429
 
    """Remove the working tree from a given branch/checkout.
 
561
    __doc__ = """Remove the working tree from a given branch/checkout.
430
562
 
431
563
    Since a lightweight checkout is little more than a working tree
432
564
    this will refuse to run against one.
434
566
    To re-create the working tree, use "bzr checkout".
435
567
    """
436
568
    _see_also = ['checkout', 'working-trees']
437
 
    takes_args = ['location?']
 
569
    takes_args = ['location*']
438
570
    takes_options = [
439
571
        Option('force',
440
572
               help='Remove the working tree even if it has '
441
 
                    'uncommitted changes.'),
 
573
                    'uncommitted or shelved changes.'),
442
574
        ]
443
575
 
444
 
    def run(self, location='.', force=False):
445
 
        d = bzrdir.BzrDir.open(location)
446
 
 
 
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]
447
644
        try:
448
 
            working = d.open_workingtree()
449
 
        except errors.NoWorkingTree:
450
 
            raise errors.BzrCommandError("No working tree to remove")
451
 
        except errors.NotLocalUrl:
452
 
            raise errors.BzrCommandError("You cannot remove the working tree"
453
 
                                         " of a remote path")
454
 
        if not force:
455
 
            # XXX: What about pending merges ? -- vila 20090629
456
 
            if working.has_changes(working.basis_tree()):
457
 
                raise errors.UncommittedChanges(working)
458
 
 
459
 
        working_path = working.bzrdir.root_transport.base
460
 
        branch_path = working.branch.bzrdir.root_transport.base
461
 
        if working_path != branch_path:
462
 
            raise errors.BzrCommandError("You cannot remove the working tree"
463
 
                                         " from a lightweight checkout")
464
 
 
465
 
        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))
466
653
 
467
654
 
468
655
class cmd_revno(Command):
469
 
    """Show current revision number.
 
656
    __doc__ = """Show current revision number.
470
657
 
471
658
    This is equal to the number of revisions on this branch.
472
659
    """
474
661
    _see_also = ['info']
475
662
    takes_args = ['location?']
476
663
    takes_options = [
477
 
        Option('tree', help='Show revno of working tree'),
 
664
        Option('tree', help='Show revno of working tree.'),
 
665
        'revision',
478
666
        ]
479
667
 
480
668
    @display_command
481
 
    def run(self, tree=False, location=u'.'):
 
669
    def run(self, tree=False, location=u'.', revision=None):
 
670
        if revision is not None and tree:
 
671
            raise errors.BzrCommandError(gettext("--tree and --revision can "
 
672
                "not be used together"))
 
673
 
482
674
        if tree:
483
675
            try:
484
676
                wt = WorkingTree.open_containing(location)[0]
485
 
                wt.lock_read()
 
677
                self.add_cleanup(wt.lock_read().unlock)
486
678
            except (errors.NoWorkingTree, errors.NotLocalUrl):
487
679
                raise errors.NoWorkingTree(location)
488
 
            try:
489
 
                revid = wt.last_revision()
490
 
                try:
491
 
                    revno_t = wt.branch.revision_id_to_dotted_revno(revid)
492
 
                except errors.NoSuchRevision:
493
 
                    revno_t = ('???',)
494
 
                revno = ".".join(str(n) for n in revno_t)
495
 
            finally:
496
 
                wt.unlock()
 
680
            b = wt.branch
 
681
            revid = wt.last_revision()
497
682
        else:
498
683
            b = Branch.open_containing(location)[0]
499
 
            b.lock_read()
500
 
            try:
501
 
                revno = b.revno()
502
 
            finally:
503
 
                b.unlock()
504
 
 
505
 
        self.outf.write(str(revno) + '\n')
 
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')
506
700
 
507
701
 
508
702
class cmd_revision_info(Command):
509
 
    """Show revision number and revision id for a given revision identifier.
 
703
    __doc__ = """Show revision number and revision id for a given revision identifier.
510
704
    """
511
705
    hidden = True
512
706
    takes_args = ['revision_info*']
513
707
    takes_options = [
514
708
        'revision',
515
 
        Option('directory',
 
709
        custom_help('directory',
516
710
            help='Branch to examine, '
517
 
                 'rather than the one containing the working directory.',
518
 
            short_name='d',
519
 
            type=unicode,
520
 
            ),
521
 
        Option('tree', help='Show revno of working tree'),
 
711
                 'rather than the one containing the working directory.'),
 
712
        Option('tree', help='Show revno of working tree.'),
522
713
        ]
523
714
 
524
715
    @display_command
528
719
        try:
529
720
            wt = WorkingTree.open_containing(directory)[0]
530
721
            b = wt.branch
531
 
            wt.lock_read()
 
722
            self.add_cleanup(wt.lock_read().unlock)
532
723
        except (errors.NoWorkingTree, errors.NotLocalUrl):
533
724
            wt = None
534
725
            b = Branch.open_containing(directory)[0]
535
 
            b.lock_read()
536
 
        try:
537
 
            revision_ids = []
538
 
            if revision is not None:
539
 
                revision_ids.extend(rev.as_revision_id(b) for rev in revision)
540
 
            if revision_info_list is not None:
541
 
                for rev_str in revision_info_list:
542
 
                    rev_spec = RevisionSpec.from_string(rev_str)
543
 
                    revision_ids.append(rev_spec.as_revision_id(b))
544
 
            # No arguments supplied, default to the last revision
545
 
            if len(revision_ids) == 0:
546
 
                if tree:
547
 
                    if wt is None:
548
 
                        raise errors.NoWorkingTree(directory)
549
 
                    revision_ids.append(wt.last_revision())
550
 
                else:
551
 
                    revision_ids.append(b.last_revision())
552
 
 
553
 
            revinfos = []
554
 
            maxlen = 0
555
 
            for revision_id in revision_ids:
556
 
                try:
557
 
                    dotted_revno = b.revision_id_to_dotted_revno(revision_id)
558
 
                    revno = '.'.join(str(i) for i in dotted_revno)
559
 
                except errors.NoSuchRevision:
560
 
                    revno = '???'
561
 
                maxlen = max(maxlen, len(revno))
562
 
                revinfos.append([revno, revision_id])
563
 
        finally:
564
 
            if wt is None:
565
 
                b.unlock()
 
726
            self.add_cleanup(b.lock_read().unlock)
 
727
        revision_ids = []
 
728
        if revision is not None:
 
729
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
 
730
        if revision_info_list is not None:
 
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())
566
740
            else:
567
 
                wt.unlock()
568
 
 
 
741
                revision_ids.append(b.last_revision())
 
742
 
 
743
        revinfos = []
 
744
        maxlen = 0
 
745
        for revision_id in revision_ids:
 
746
            try:
 
747
                dotted_revno = b.revision_id_to_dotted_revno(revision_id)
 
748
                revno = '.'.join(str(i) for i in dotted_revno)
 
749
            except errors.NoSuchRevision:
 
750
                revno = '???'
 
751
            maxlen = max(maxlen, len(revno))
 
752
            revinfos.append([revno, revision_id])
 
753
 
 
754
        self.cleanup_now()
569
755
        for ri in revinfos:
570
756
            self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
571
757
 
572
758
 
573
759
class cmd_add(Command):
574
 
    """Add specified files or directories.
 
760
    __doc__ = """Add specified files or directories.
575
761
 
576
762
    In non-recursive mode, all the named items are added, regardless
577
763
    of whether they were previously ignored.  A warning is given if
585
771
    are added.  This search proceeds recursively into versioned
586
772
    directories.  If no names are given '.' is assumed.
587
773
 
 
774
    A warning will be printed when nested trees are encountered,
 
775
    unless they are explicitly ignored.
 
776
 
588
777
    Therefore simply saying 'bzr add' will version all files that
589
778
    are currently unknown.
590
779
 
603
792
    branches that will be merged later (without showing the two different
604
793
    adds as a conflict). It is also useful when merging another project
605
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.
606
802
    """
607
803
    takes_args = ['file*']
608
804
    takes_options = [
609
805
        Option('no-recurse',
610
 
               help="Don't recursively add the contents of directories."),
 
806
               help="Don't recursively add the contents of directories.",
 
807
               short_name='N'),
611
808
        Option('dry-run',
612
809
               help="Show what would be done, but don't actually do anything."),
613
810
        'verbose',
616
813
               help='Lookup file ids from this tree.'),
617
814
        ]
618
815
    encoding_type = 'replace'
619
 
    _see_also = ['remove']
 
816
    _see_also = ['remove', 'ignore']
620
817
 
621
818
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
622
819
            file_ids_from=None):
635
832
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
636
833
                          to_file=self.outf, should_print=(not is_quiet()))
637
834
        else:
638
 
            action = bzrlib.add.AddAction(to_file=self.outf,
 
835
            action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
639
836
                should_print=(not is_quiet()))
640
837
 
641
838
        if base_tree:
642
 
            base_tree.lock_read()
643
 
        try:
644
 
            file_list = self._maybe_expand_globs(file_list)
645
 
            tree, file_list = tree_files_for_add(file_list)
646
 
            added, ignored = tree.smart_add(file_list, not
647
 
                no_recurse, action=action, save=not dry_run)
648
 
        finally:
649
 
            if base_tree is not None:
650
 
                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()
651
844
        if len(ignored) > 0:
652
845
            if verbose:
653
846
                for glob in sorted(ignored.keys()):
654
847
                    for path in ignored[glob]:
655
 
                        self.outf.write("ignored %s matching \"%s\"\n"
656
 
                                        % (path, glob))
657
 
            else:
658
 
                match_len = 0
659
 
                for glob, paths in ignored.items():
660
 
                    match_len += len(paths)
661
 
                self.outf.write("ignored %d file(s).\n" % match_len)
662
 
            self.outf.write("If you wish to add ignored files, "
663
 
                            "please add them explicitly by name. "
664
 
                            "(\"bzr ignored\" gives a list)\n")
 
848
                        self.outf.write(
 
849
                         gettext("ignored {0} matching \"{1}\"\n").format(
 
850
                         path, glob))
665
851
 
666
852
 
667
853
class cmd_mkdir(Command):
668
 
    """Create a new versioned directory.
 
854
    __doc__ = """Create a new versioned directory.
669
855
 
670
856
    This is equivalent to creating the directory and then adding it.
671
857
    """
672
858
 
673
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
        ]
674
867
    encoding_type = 'replace'
675
868
 
676
 
    def run(self, dir_list):
677
 
        for d in dir_list:
678
 
            os.mkdir(d)
679
 
            wt, dd = WorkingTree.open_containing(d)
680
 
            wt.add([dd])
681
 
            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)
682
898
 
683
899
 
684
900
class cmd_relpath(Command):
685
 
    """Show path of a file relative to root"""
 
901
    __doc__ = """Show path of a file relative to root"""
686
902
 
687
903
    takes_args = ['filename']
688
904
    hidden = True
697
913
 
698
914
 
699
915
class cmd_inventory(Command):
700
 
    """Show inventory of the current working copy or a revision.
 
916
    __doc__ = """Show inventory of the current working copy or a revision.
701
917
 
702
918
    It is possible to limit the output to a particular entry
703
919
    type using the --kind option.  For example: --kind file.
720
936
    @display_command
721
937
    def run(self, revision=None, show_ids=False, kind=None, file_list=None):
722
938
        if kind and kind not in ['file', 'directory', 'symlink']:
723
 
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
 
939
            raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
724
940
 
725
941
        revision = _get_one_revision('inventory', revision)
726
 
        work_tree, file_list = tree_files(file_list)
727
 
        work_tree.lock_read()
728
 
        try:
729
 
            if revision is not None:
730
 
                tree = revision.as_tree(work_tree.branch)
731
 
 
732
 
                extra_trees = [work_tree]
733
 
                tree.lock_read()
734
 
            else:
735
 
                tree = work_tree
736
 
                extra_trees = []
737
 
 
738
 
            if file_list is not None:
739
 
                file_ids = tree.paths2ids(file_list, trees=extra_trees,
740
 
                                          require_versioned=True)
741
 
                # find_ids_across_trees may include some paths that don't
742
 
                # exist in 'tree'.
743
 
                entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
744
 
                                 for file_id in file_ids if file_id in tree)
745
 
            else:
746
 
                entries = tree.inventory.entries()
747
 
        finally:
748
 
            tree.unlock()
749
 
            if tree is not work_tree:
750
 
                work_tree.unlock()
751
 
 
752
 
        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):
753
964
            if kind and kind != entry.kind:
754
965
                continue
 
966
            if path == "":
 
967
                continue
755
968
            if show_ids:
756
969
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
757
970
            else:
760
973
 
761
974
 
762
975
class cmd_mv(Command):
763
 
    """Move or rename a file.
 
976
    __doc__ = """Move or rename a file.
764
977
 
765
978
    :Usage:
766
979
        bzr mv OLDNAME NEWNAME
793
1006
        if auto:
794
1007
            return self.run_auto(names_list, after, dry_run)
795
1008
        elif dry_run:
796
 
            raise errors.BzrCommandError('--dry-run requires --auto.')
 
1009
            raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
797
1010
        if names_list is None:
798
1011
            names_list = []
799
1012
        if len(names_list) < 2:
800
 
            raise errors.BzrCommandError("missing file argument")
801
 
        tree, rel_names = tree_files(names_list, canonicalize=False)
802
 
        tree.lock_tree_write()
803
 
        try:
804
 
            self._run(tree, names_list, rel_names, after)
805
 
        finally:
806
 
            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)
807
1020
 
808
1021
    def run_auto(self, names_list, after, dry_run):
809
1022
        if names_list is not None and len(names_list) > 1:
810
 
            raise errors.BzrCommandError('Only one path may be specified to'
811
 
                                         ' --auto.')
 
1023
            raise errors.BzrCommandError(gettext('Only one path may be specified to'
 
1024
                                         ' --auto.'))
812
1025
        if after:
813
 
            raise errors.BzrCommandError('--after cannot be specified with'
814
 
                                         ' --auto.')
815
 
        work_tree, file_list = tree_files(names_list, default_branch='.')
816
 
        work_tree.lock_tree_write()
817
 
        try:
818
 
            rename_map.RenameMap.guess_renames(work_tree, dry_run)
819
 
        finally:
820
 
            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)
821
1032
 
822
1033
    def _run(self, tree, names_list, rel_names, after):
823
1034
        into_existing = osutils.isdir(names_list[-1])
831
1042
                and rel_names[0].lower() == rel_names[1].lower()):
832
1043
                into_existing = False
833
1044
            else:
834
 
                inv = tree.inventory
835
1045
                # 'fix' the case of a potential 'from'
836
1046
                from_id = tree.path2id(
837
1047
                            tree.get_canonical_inventory_path(rel_names[0]))
838
1048
                if (not osutils.lexists(names_list[0]) and
839
 
                    from_id and inv.get_file_kind(from_id) == "directory"):
 
1049
                    from_id and tree.stored_kind(from_id) == "directory"):
840
1050
                    into_existing = False
841
1051
        # move/rename
842
1052
        if into_existing:
844
1054
            # All entries reference existing inventory items, so fix them up
845
1055
            # for cicp file-systems.
846
1056
            rel_names = tree.get_canonical_inventory_paths(rel_names)
847
 
            for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
848
 
                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))
849
1060
        else:
850
1061
            if len(names_list) != 2:
851
 
                raise errors.BzrCommandError('to mv multiple files the'
 
1062
                raise errors.BzrCommandError(gettext('to mv multiple files the'
852
1063
                                             ' destination must be a versioned'
853
 
                                             ' directory')
 
1064
                                             ' directory'))
854
1065
 
855
1066
            # for cicp file-systems: the src references an existing inventory
856
1067
            # item:
895
1106
            dest = osutils.pathjoin(dest_parent, dest_tail)
896
1107
            mutter("attempting to move %s => %s", src, dest)
897
1108
            tree.rename_one(src, dest, after=after)
898
 
            self.outf.write("%s => %s\n" % (src, dest))
 
1109
            if not is_quiet():
 
1110
                self.outf.write("%s => %s\n" % (src, dest))
899
1111
 
900
1112
 
901
1113
class cmd_pull(Command):
902
 
    """Turn this branch into a mirror of another branch.
 
1114
    __doc__ = """Turn this branch into a mirror of another branch.
903
1115
 
904
 
    This command only works on branches that have not diverged.  Branches are
905
 
    considered diverged if the destination branch's most recent commit is one
906
 
    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.
907
1120
 
908
1121
    If branches have diverged, you can use 'bzr merge' to integrate the changes
909
1122
    from one into the other.  Once one branch has merged, the other should
910
1123
    be able to pull it again.
911
1124
 
912
 
    If you want to forget your local changes and just update your branch to
913
 
    match the remote one, use pull --overwrite.
914
 
 
915
 
    If there is no default location set, the first pull will set it.  After
916
 
    that, you can omit the location to use the default.  To change the
917
 
    default, use --remember. The value will only be saved if the remote
918
 
    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>.
919
1137
 
920
1138
    Note: The location can be specified either in the form of a branch,
921
1139
    or in the form of a path to a file containing a merge directive generated
926
1144
    takes_options = ['remember', 'overwrite', 'revision',
927
1145
        custom_help('verbose',
928
1146
            help='Show logs of pulled revisions.'),
929
 
        Option('directory',
 
1147
        custom_help('directory',
930
1148
            help='Branch to pull into, '
931
 
                 'rather than the one containing the working directory.',
932
 
            short_name='d',
933
 
            type=unicode,
934
 
            ),
 
1149
                 'rather than the one containing the working directory.'),
935
1150
        Option('local',
936
1151
            help="Perform a local pull in a bound "
937
1152
                 "branch.  Local pulls are not applied to "
938
1153
                 "the master branch."
939
1154
            ),
 
1155
        Option('show-base',
 
1156
            help="Show base revision text in conflicts."),
 
1157
        Option('overwrite-tags',
 
1158
            help="Overwrite tags only."),
940
1159
        ]
941
1160
    takes_args = ['location?']
942
1161
    encoding_type = 'replace'
943
1162
 
944
 
    def run(self, location=None, remember=False, overwrite=False,
 
1163
    def run(self, location=None, remember=None, overwrite=False,
945
1164
            revision=None, verbose=False,
946
 
            directory=None, local=False):
 
1165
            directory=None, local=False,
 
1166
            show_base=False, overwrite_tags=False):
 
1167
 
 
1168
        if overwrite:
 
1169
            overwrite = ["history", "tags"]
 
1170
        elif overwrite_tags:
 
1171
            overwrite = ["tags"]
 
1172
        else:
 
1173
            overwrite = []
947
1174
        # FIXME: too much stuff is in the command class
948
1175
        revision_id = None
949
1176
        mergeable = None
952
1179
        try:
953
1180
            tree_to = WorkingTree.open_containing(directory)[0]
954
1181
            branch_to = tree_to.branch
 
1182
            self.add_cleanup(tree_to.lock_write().unlock)
955
1183
        except errors.NoWorkingTree:
956
1184
            tree_to = None
957
1185
            branch_to = Branch.open_containing(directory)[0]
958
 
        
 
1186
            self.add_cleanup(branch_to.lock_write().unlock)
 
1187
            if show_base:
 
1188
                warning(gettext("No working tree, ignoring --show-base"))
 
1189
 
959
1190
        if local and not branch_to.get_bound_location():
960
1191
            raise errors.LocalRequiresBoundBranch()
961
1192
 
970
1201
        stored_loc = branch_to.get_parent()
971
1202
        if location is None:
972
1203
            if stored_loc is None:
973
 
                raise errors.BzrCommandError("No pull location known or"
974
 
                                             " specified.")
 
1204
                raise errors.BzrCommandError(gettext("No pull location known or"
 
1205
                                             " specified."))
975
1206
            else:
976
1207
                display_url = urlutils.unescape_for_display(stored_loc,
977
1208
                        self.outf.encoding)
978
1209
                if not is_quiet():
979
 
                    self.outf.write("Using saved parent location: %s\n" % display_url)
 
1210
                    self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
980
1211
                location = stored_loc
981
1212
 
982
1213
        revision = _get_one_revision('pull', revision)
983
1214
        if mergeable is not None:
984
1215
            if revision is not None:
985
 
                raise errors.BzrCommandError(
986
 
                    'Cannot use -r with merge directives or bundles')
 
1216
                raise errors.BzrCommandError(gettext(
 
1217
                    'Cannot use -r with merge directives or bundles'))
987
1218
            mergeable.install_revisions(branch_to.repository)
988
1219
            base_revision_id, revision_id, verified = \
989
1220
                mergeable.get_merge_request(branch_to.repository)
991
1222
        else:
992
1223
            branch_from = Branch.open(location,
993
1224
                possible_transports=possible_transports)
994
 
 
995
 
            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
996
1231
                branch_to.set_parent(branch_from.base)
997
1232
 
998
 
        if branch_from is not branch_to:
999
 
            branch_from.lock_read()
1000
 
        try:
1001
 
            if revision is not None:
1002
 
                revision_id = revision.as_revision_id(branch_from)
1003
 
 
1004
 
            branch_to.lock_write()
1005
 
            try:
1006
 
                if tree_to is not None:
1007
 
                    view_info = _get_view_info_for_change_reporter(tree_to)
1008
 
                    change_reporter = delta._ChangeReporter(
1009
 
                        unversioned_filter=tree_to.is_ignored,
1010
 
                        view_info=view_info)
1011
 
                    result = tree_to.pull(
1012
 
                        branch_from, overwrite, revision_id, change_reporter,
1013
 
                        possible_transports=possible_transports, local=local)
1014
 
                else:
1015
 
                    result = branch_to.pull(
1016
 
                        branch_from, overwrite, revision_id, local=local)
1017
 
 
1018
 
                result.report(self.outf)
1019
 
                if verbose and result.old_revid != result.new_revid:
1020
 
                    log.show_branch_change(
1021
 
                        branch_to, self.outf, result.old_revno,
1022
 
                        result.old_revid)
1023
 
            finally:
1024
 
                branch_to.unlock()
1025
 
        finally:
1026
 
            if branch_from is not branch_to:
1027
 
                branch_from.unlock()
 
1233
        if revision is not None:
 
1234
            revision_id = revision.as_revision_id(branch_from)
 
1235
 
 
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)
 
1247
 
 
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
1028
1257
 
1029
1258
 
1030
1259
class cmd_push(Command):
1031
 
    """Update a mirror of this branch.
 
1260
    __doc__ = """Update a mirror of this branch.
1032
1261
 
1033
1262
    The target branch will not have its working tree populated because this
1034
1263
    is both expensive, and is not supported on remote file systems.
1047
1276
    do a merge (see bzr help merge) from the other branch, and commit that.
1048
1277
    After that you will be able to do a push without '--overwrite'.
1049
1278
 
1050
 
    If there is no default push location set, the first push will set it.
1051
 
    After that, you can omit the location to use the default.  To change the
1052
 
    default, use --remember. The value will only be saved if the remote
1053
 
    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>.
1054
1287
    """
1055
1288
 
1056
1289
    _see_also = ['pull', 'update', 'working-trees']
1058
1291
        Option('create-prefix',
1059
1292
               help='Create the path leading up to the branch '
1060
1293
                    'if it does not already exist.'),
1061
 
        Option('directory',
 
1294
        custom_help('directory',
1062
1295
            help='Branch to push from, '
1063
 
                 'rather than the one containing the working directory.',
1064
 
            short_name='d',
1065
 
            type=unicode,
1066
 
            ),
 
1296
                 'rather than the one containing the working directory.'),
1067
1297
        Option('use-existing-dir',
1068
1298
               help='By default push will fail if the target'
1069
1299
                    ' directory exists, but does not already'
1080
1310
        Option('strict',
1081
1311
               help='Refuse to push if there are uncommitted changes in'
1082
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."),
1083
1318
        ]
1084
1319
    takes_args = ['location?']
1085
1320
    encoding_type = 'replace'
1086
1321
 
1087
 
    def run(self, location=None, remember=False, overwrite=False,
 
1322
    def run(self, location=None, remember=None, overwrite=False,
1088
1323
        create_prefix=False, verbose=False, revision=None,
1089
1324
        use_existing_dir=False, directory=None, stacked_on=None,
1090
 
        stacked=False, strict=None):
 
1325
        stacked=False, strict=None, no_tree=False,
 
1326
        overwrite_tags=False):
1091
1327
        from bzrlib.push import _show_push_branch
1092
1328
 
 
1329
        if overwrite:
 
1330
            overwrite = ["history", "tags"]
 
1331
        elif overwrite_tags:
 
1332
            overwrite = ["tags"]
 
1333
        else:
 
1334
            overwrite = []
 
1335
 
1093
1336
        if directory is None:
1094
1337
            directory = '.'
1095
1338
        # Get the source branch
1096
1339
        (tree, br_from,
1097
 
         _unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1098
 
        if strict is None:
1099
 
            strict = br_from.get_config().get_user_option_as_bool('push_strict')
1100
 
        if strict is None: strict = True # default value
 
1340
         _unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1101
1341
        # Get the tip's revision_id
1102
1342
        revision = _get_one_revision('push', revision)
1103
1343
        if revision is not None:
1104
1344
            revision_id = revision.in_history(br_from).rev_id
1105
1345
        else:
1106
1346
            revision_id = None
1107
 
        if strict and tree is not None and revision_id is None:
1108
 
            if (tree.has_changes(tree.basis_tree())
1109
 
                or len(tree.get_parent_ids()) > 1):
1110
 
                raise errors.UncommittedChanges(
1111
 
                    tree, more='Use --no-strict to force the push.')
1112
 
            if tree.last_revision() != tree.branch.last_revision():
1113
 
                # The tree has lost sync with its branch, there is little
1114
 
                # chance that the user is aware of it but he can still force
1115
 
                # the push with --no-strict
1116
 
                raise errors.OutOfDateTree(
1117
 
                    tree, more='Use --no-strict to force the push.')
1118
 
 
 
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.')
1119
1352
        # Get the stacked_on branch, if any
1120
1353
        if stacked_on is not None:
1121
1354
            stacked_on = urlutils.normalize_url(stacked_on)
1131
1364
                    # error by the feedback given to them. RBC 20080227.
1132
1365
                    stacked_on = parent_url
1133
1366
            if not stacked_on:
1134
 
                raise errors.BzrCommandError(
1135
 
                    "Could not determine branch to refer to.")
 
1367
                raise errors.BzrCommandError(gettext(
 
1368
                    "Could not determine branch to refer to."))
1136
1369
 
1137
1370
        # Get the destination location
1138
1371
        if location is None:
1139
1372
            stored_loc = br_from.get_push_location()
1140
1373
            if stored_loc is None:
1141
 
                raise errors.BzrCommandError(
1142
 
                    "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."))
1143
1384
            else:
1144
1385
                display_url = urlutils.unescape_for_display(stored_loc,
1145
1386
                        self.outf.encoding)
1146
 
                self.outf.write("Using saved push location: %s\n" % display_url)
 
1387
                note(gettext("Using saved push location: %s") % display_url)
1147
1388
                location = stored_loc
1148
1389
 
1149
1390
        _show_push_branch(br_from, revision_id, location, self.outf,
1150
1391
            verbose=verbose, overwrite=overwrite, remember=remember,
1151
1392
            stacked_on=stacked_on, create_prefix=create_prefix,
1152
 
            use_existing_dir=use_existing_dir)
 
1393
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1153
1394
 
1154
1395
 
1155
1396
class cmd_branch(Command):
1156
 
    """Create a new branch that is a copy of an existing branch.
 
1397
    __doc__ = """Create a new branch that is a copy of an existing branch.
1157
1398
 
1158
1399
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1159
1400
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
1164
1405
 
1165
1406
    To retrieve the branch as of a particular revision, supply the --revision
1166
1407
    parameter, as in "branch foo/bar -r 5".
 
1408
 
 
1409
    The synonyms 'clone' and 'get' for this command are deprecated.
1167
1410
    """
1168
1411
 
1169
1412
    _see_also = ['checkout']
1170
1413
    takes_args = ['from_location', 'to_location?']
1171
 
    takes_options = ['revision', Option('hardlink',
1172
 
        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."),
1173
1418
        Option('no-tree',
1174
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."),
1175
1423
        Option('stacked',
1176
1424
            help='Create a stacked branch referring to the source branch. '
1177
1425
                'The new branch will depend on the availability of the source '
1183
1431
                    ' directory exists, but does not already'
1184
1432
                    ' have a control directory.  This flag will'
1185
1433
                    ' allow branch to proceed.'),
 
1434
        Option('bind',
 
1435
            help="Bind new branch to from location."),
1186
1436
        ]
1187
1437
    aliases = ['get', 'clone']
1188
1438
 
1189
1439
    def run(self, from_location, to_location=None, revision=None,
1190
1440
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1191
 
            use_existing_dir=False):
 
1441
            use_existing_dir=False, switch=False, bind=False,
 
1442
            files_from=None):
 
1443
        from bzrlib import switch as _mod_switch
1192
1444
        from bzrlib.tag import _merge_tags_if_possible
1193
 
 
1194
 
        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(
1195
1452
            from_location)
1196
 
        if (accelerator_tree is not None and
1197
 
            accelerator_tree.supports_content_filtering()):
 
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
1198
1457
            accelerator_tree = None
 
1458
        if files_from is not None and files_from != from_location:
 
1459
            accelerator_tree = WorkingTree.open(files_from)
1199
1460
        revision = _get_one_revision('branch', revision)
1200
 
        br_from.lock_read()
1201
 
        try:
1202
 
            if revision is not None:
1203
 
                revision_id = revision.as_revision_id(br_from)
1204
 
            else:
1205
 
                # FIXME - wt.last_revision, fallback to branch, fall back to
1206
 
                # None or perhaps NULL_REVISION to mean copy nothing
1207
 
                # RBC 20060209
1208
 
                revision_id = br_from.last_revision()
1209
 
            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:
1210
1472
                to_location = urlutils.derive_to_location(from_location)
1211
 
            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:
1212
1477
            try:
1213
 
                to_transport.mkdir('.')
1214
 
            except errors.FileExists:
 
1478
                to_dir = controldir.ControlDir.open_from_transport(
 
1479
                    to_transport)
 
1480
            except errors.NotBranchError:
1215
1481
                if not use_existing_dir:
1216
 
                    raise errors.BzrCommandError('Target directory "%s" '
1217
 
                        'already exists.' % to_location)
1218
 
                else:
1219
 
                    try:
1220
 
                        bzrdir.BzrDir.open_from_transport(to_transport)
1221
 
                    except errors.NotBranchError:
1222
 
                        pass
1223
 
                    else:
1224
 
                        raise errors.AlreadyBranchError(to_location)
1225
 
            except errors.NoSuchFile:
1226
 
                raise errors.BzrCommandError('Parent of "%s" does not exist.'
1227
 
                                             % to_location)
 
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:
1228
1499
            try:
1229
1500
                # preserve whatever source format we have.
1230
 
                dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
 
1501
                to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1231
1502
                                            possible_transports=[to_transport],
1232
1503
                                            accelerator_tree=accelerator_tree,
1233
1504
                                            hardlink=hardlink, stacked=stacked,
1234
1505
                                            force_new_repo=standalone,
1235
1506
                                            create_tree_if_local=not no_tree,
1236
1507
                                            source_branch=br_from)
1237
 
                branch = dir.open_branch()
 
1508
                branch = to_dir.open_branch(
 
1509
                    possible_transports=[
 
1510
                        br_from.bzrdir.root_transport, to_transport])
1238
1511
            except errors.NoSuchRevision:
1239
1512
                to_transport.delete_tree('.')
1240
 
                msg = "The branch %s has no revision %s." % (from_location,
1241
 
                    revision)
 
1513
                msg = gettext("The branch {0} has no revision {1}.").format(
 
1514
                    from_location, revision)
1242
1515
                raise errors.BzrCommandError(msg)
1243
 
            _merge_tags_if_possible(br_from, branch)
1244
 
            # If the source branch is stacked, the new branch may
1245
 
            # be stacked whether we asked for that explicitly or not.
1246
 
            # We therefore need a try/except here and not just 'if stacked:'
1247
 
            try:
1248
 
                note('Created new stacked branch referring to %s.' %
1249
 
                    branch.get_stacked_on_url())
1250
 
            except (errors.NotStacked, errors.UnstackableBranchFormat,
1251
 
                errors.UnstackableRepositoryFormat), e:
1252
 
                note('Branched %d revision(s).' % branch.revno())
1253
 
        finally:
1254
 
            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)))
1255
1594
 
1256
1595
 
1257
1596
class cmd_checkout(Command):
1258
 
    """Create a new checkout of an existing branch.
 
1597
    __doc__ = """Create a new checkout of an existing branch.
1259
1598
 
1260
1599
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1261
1600
    the branch found in '.'. This is useful if you have removed the working tree
1275
1614
    code.)
1276
1615
    """
1277
1616
 
1278
 
    _see_also = ['checkouts', 'branch']
 
1617
    _see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1279
1618
    takes_args = ['branch_location?', 'to_location?']
1280
1619
    takes_options = ['revision',
1281
1620
                     Option('lightweight',
1298
1637
        if branch_location is None:
1299
1638
            branch_location = osutils.getcwd()
1300
1639
            to_location = branch_location
1301
 
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
 
1640
        accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1302
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
1303
1647
        revision = _get_one_revision('checkout', revision)
1304
 
        if files_from is not None:
 
1648
        if files_from is not None and files_from != branch_location:
1305
1649
            accelerator_tree = WorkingTree.open(files_from)
1306
1650
        if revision is not None:
1307
1651
            revision_id = revision.as_revision_id(source)
1324
1668
 
1325
1669
 
1326
1670
class cmd_renames(Command):
1327
 
    """Show list of renamed files.
 
1671
    __doc__ = """Show list of renamed files.
1328
1672
    """
1329
1673
    # TODO: Option to show renames between two historical versions.
1330
1674
 
1335
1679
    @display_command
1336
1680
    def run(self, dir=u'.'):
1337
1681
        tree = WorkingTree.open_containing(dir)[0]
1338
 
        tree.lock_read()
1339
 
        try:
1340
 
            new_inv = tree.inventory
1341
 
            old_tree = tree.basis_tree()
1342
 
            old_tree.lock_read()
1343
 
            try:
1344
 
                old_inv = old_tree.inventory
1345
 
                renames = []
1346
 
                iterator = tree.iter_changes(old_tree, include_unchanged=True)
1347
 
                for f, paths, c, v, p, n, k, e in iterator:
1348
 
                    if paths[0] == paths[1]:
1349
 
                        continue
1350
 
                    if None in (paths):
1351
 
                        continue
1352
 
                    renames.append(paths)
1353
 
                renames.sort()
1354
 
                for old_name, new_name in renames:
1355
 
                    self.outf.write("%s => %s\n" % (old_name, new_name))
1356
 
            finally:
1357
 
                old_tree.unlock()
1358
 
        finally:
1359
 
            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))
1360
1696
 
1361
1697
 
1362
1698
class cmd_update(Command):
1363
 
    """Update a tree to have the latest code committed to its branch.
1364
 
 
1365
 
    This will perform a merge into the working tree, and may generate
1366
 
    conflicts. If you have any local changes, you will still
1367
 
    need to commit them after the update for the update to be complete.
1368
 
 
1369
 
    If you want to discard your local changes, you can just do a
1370
 
    '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.
1371
1726
    """
1372
1727
 
1373
1728
    _see_also = ['pull', 'working-trees', 'status-flags']
1374
1729
    takes_args = ['dir?']
 
1730
    takes_options = ['revision',
 
1731
                     Option('show-base',
 
1732
                            help="Show base revision text in conflicts."),
 
1733
                     ]
1375
1734
    aliases = ['up']
1376
1735
 
1377
 
    def run(self, dir='.'):
1378
 
        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
1379
1750
        possible_transports = []
1380
 
        master = tree.branch.get_master_branch(
 
1751
        master = branch.get_master_branch(
1381
1752
            possible_transports=possible_transports)
1382
1753
        if master is not None:
 
1754
            branch_location = master.base
1383
1755
            tree.lock_write()
1384
1756
        else:
 
1757
            branch_location = tree.branch.base
1385
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)
1386
1785
        try:
1387
 
            existing_pending_merges = tree.get_parent_ids()[1:]
1388
 
            last_rev = _mod_revision.ensure_null(tree.last_revision())
1389
 
            if last_rev == _mod_revision.ensure_null(
1390
 
                tree.branch.last_revision()):
1391
 
                # may be up to date, check master too.
1392
 
                if master is None or last_rev == _mod_revision.ensure_null(
1393
 
                    master.last_revision()):
1394
 
                    revno = tree.branch.revision_id_to_revno(last_rev)
1395
 
                    note("Tree is up to date at revision %d." % (revno,))
1396
 
                    return 0
1397
 
            view_info = _get_view_info_for_change_reporter(tree)
1398
1786
            conflicts = tree.update(
1399
 
                delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1400
 
                view_info=view_info), possible_transports=possible_transports)
1401
 
            revno = tree.branch.revision_id_to_revno(
1402
 
                _mod_revision.ensure_null(tree.last_revision()))
1403
 
            note('Updated to revision %d.' % (revno,))
1404
 
            if tree.get_parent_ids()[1:] != existing_pending_merges:
1405
 
                note('Your local commits will now show as pending merges with '
1406
 
                     "'bzr status', and can be committed with 'bzr commit'.")
1407
 
            if conflicts != 0:
1408
 
                return 1
1409
 
            else:
1410
 
                return 0
1411
 
        finally:
1412
 
            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
1413
1810
 
1414
1811
 
1415
1812
class cmd_info(Command):
1416
 
    """Show information about a working tree, branch or repository.
 
1813
    __doc__ = """Show information about a working tree, branch or repository.
1417
1814
 
1418
1815
    This command will show all known locations and formats associated to the
1419
1816
    tree, branch or repository.
1452
1849
        else:
1453
1850
            noise_level = 0
1454
1851
        from bzrlib.info import show_bzrdir_info
1455
 
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
 
1852
        show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1456
1853
                         verbose=noise_level, outfile=self.outf)
1457
1854
 
1458
1855
 
1459
1856
class cmd_remove(Command):
1460
 
    """Remove files or directories.
 
1857
    __doc__ = """Remove files or directories.
1461
1858
 
1462
 
    This makes bzr stop tracking changes to the specified files. bzr will delete
1463
 
    them if they can easily be recovered using revert. If no options or
1464
 
    parameters are given bzr will scan for files that are being tracked by bzr
1465
 
    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.
1466
1864
    """
1467
1865
    takes_args = ['file*']
1468
1866
    takes_options = ['verbose',
1470
1868
        RegistryOption.from_kwargs('file-deletion-strategy',
1471
1869
            'The file deletion mode to be used.',
1472
1870
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1473
 
            safe='Only delete files if they can be'
1474
 
                 ' safely recovered (default).',
 
1871
            safe='Backup changed files (default).',
1475
1872
            keep='Delete from bzr but leave the working copy.',
1476
 
            force='Delete all the specified files, even if they can not be '
1477
 
                'recovered and even if they are non-empty directories.')]
 
1873
            no_backup='Don\'t backup changed files.'),
 
1874
        ]
1478
1875
    aliases = ['rm', 'del']
1479
1876
    encoding_type = 'replace'
1480
1877
 
1481
1878
    def run(self, file_list, verbose=False, new=False,
1482
1879
        file_deletion_strategy='safe'):
1483
 
        tree, file_list = tree_files(file_list)
 
1880
 
 
1881
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1484
1882
 
1485
1883
        if file_list is not None:
1486
1884
            file_list = [f for f in file_list]
1487
1885
 
1488
 
        tree.lock_write()
1489
 
        try:
1490
 
            # Heuristics should probably all move into tree.remove_smart or
1491
 
            # some such?
1492
 
            if new:
1493
 
                added = tree.changes_from(tree.basis_tree(),
1494
 
                    specific_files=file_list).added
1495
 
                file_list = sorted([f[0] for f in added], reverse=True)
1496
 
                if len(file_list) == 0:
1497
 
                    raise errors.BzrCommandError('No matching files.')
1498
 
            elif file_list is None:
1499
 
                # missing files show up in iter_changes(basis) as
1500
 
                # versioned-with-no-kind.
1501
 
                missing = []
1502
 
                for change in tree.iter_changes(tree.basis_tree()):
1503
 
                    # Find paths in the working tree that have no kind:
1504
 
                    if change[1][1] is not None and change[6][1] is None:
1505
 
                        missing.append(change[1][1])
1506
 
                file_list = sorted(missing, reverse=True)
1507
 
                file_deletion_strategy = 'keep'
1508
 
            tree.remove(file_list, verbose=verbose, to_file=self.outf,
1509
 
                keep_files=file_deletion_strategy=='keep',
1510
 
                force=file_deletion_strategy=='force')
1511
 
        finally:
1512
 
            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'))
1513
1908
 
1514
1909
 
1515
1910
class cmd_file_id(Command):
1516
 
    """Print file_id of a particular file or directory.
 
1911
    __doc__ = """Print file_id of a particular file or directory.
1517
1912
 
1518
1913
    The file_id is assigned when the file is first added and remains the
1519
1914
    same through all revisions where the file exists, even when it is
1535
1930
 
1536
1931
 
1537
1932
class cmd_file_path(Command):
1538
 
    """Print path of file_ids to a file or directory.
 
1933
    __doc__ = """Print path of file_ids to a file or directory.
1539
1934
 
1540
1935
    This prints one line for each directory down to the target,
1541
1936
    starting at the branch root.
1557
1952
 
1558
1953
 
1559
1954
class cmd_reconcile(Command):
1560
 
    """Reconcile bzr metadata in a branch.
 
1955
    __doc__ = """Reconcile bzr metadata in a branch.
1561
1956
 
1562
1957
    This can correct data mismatches that may have been caused by
1563
1958
    previous ghost operations or bzr upgrades. You should only
1577
1972
 
1578
1973
    _see_also = ['check']
1579
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
        ]
1580
1981
 
1581
 
    def run(self, branch="."):
 
1982
    def run(self, branch=".", canonicalize_chks=False):
1582
1983
        from bzrlib.reconcile import reconcile
1583
 
        dir = bzrdir.BzrDir.open(branch)
1584
 
        reconcile(dir)
 
1984
        dir = controldir.ControlDir.open(branch)
 
1985
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1585
1986
 
1586
1987
 
1587
1988
class cmd_revision_history(Command):
1588
 
    """Display the list of revision ids on a branch."""
 
1989
    __doc__ = """Display the list of revision ids on a branch."""
1589
1990
 
1590
1991
    _see_also = ['log']
1591
1992
    takes_args = ['location?']
1595
1996
    @display_command
1596
1997
    def run(self, location="."):
1597
1998
        branch = Branch.open_containing(location)[0]
1598
 
        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):
1599
2004
            self.outf.write(revid)
1600
2005
            self.outf.write('\n')
1601
2006
 
1602
2007
 
1603
2008
class cmd_ancestry(Command):
1604
 
    """List all revisions merged into this branch."""
 
2009
    __doc__ = """List all revisions merged into this branch."""
1605
2010
 
1606
2011
    _see_also = ['log', 'revision-history']
1607
2012
    takes_args = ['location?']
1619
2024
            b = wt.branch
1620
2025
            last_revision = wt.last_revision()
1621
2026
 
1622
 
        revision_ids = b.repository.get_ancestry(last_revision)
1623
 
        revision_ids.pop(0)
1624
 
        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
1625
2034
            self.outf.write(revision_id + '\n')
1626
2035
 
1627
2036
 
1628
2037
class cmd_init(Command):
1629
 
    """Make a directory into a versioned branch.
 
2038
    __doc__ = """Make a directory into a versioned branch.
1630
2039
 
1631
2040
    Use this to create an empty branch, or before importing an
1632
2041
    existing project.
1657
2066
         RegistryOption('format',
1658
2067
                help='Specify a format for this branch. '
1659
2068
                'See "help formats".',
1660
 
                lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1661
 
                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),
1662
2071
                value_switches=True,
1663
 
                title="Branch Format",
 
2072
                title="Branch format",
1664
2073
                ),
1665
2074
         Option('append-revisions-only',
1666
2075
                help='Never change revnos or the existing log.'
1667
 
                '  Append revisions to it only.')
 
2076
                '  Append revisions to it only.'),
 
2077
         Option('no-tree',
 
2078
                'Create a branch without a working tree.')
1668
2079
         ]
1669
2080
    def run(self, location=None, format=None, append_revisions_only=False,
1670
 
            create_prefix=False):
 
2081
            create_prefix=False, no_tree=False):
1671
2082
        if format is None:
1672
 
            format = bzrdir.format_registry.make_bzrdir('default')
 
2083
            format = controldir.format_registry.make_bzrdir('default')
1673
2084
        if location is None:
1674
2085
            location = u'.'
1675
2086
 
1684
2095
            to_transport.ensure_base()
1685
2096
        except errors.NoSuchFile:
1686
2097
            if not create_prefix:
1687
 
                raise errors.BzrCommandError("Parent directory of %s"
 
2098
                raise errors.BzrCommandError(gettext("Parent directory of %s"
1688
2099
                    " does not exist."
1689
2100
                    "\nYou may supply --create-prefix to create all"
1690
 
                    " leading parent directories."
 
2101
                    " leading parent directories.")
1691
2102
                    % location)
1692
2103
            to_transport.create_prefix()
1693
2104
 
1694
2105
        try:
1695
 
            a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
 
2106
            a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1696
2107
        except errors.NotBranchError:
1697
2108
            # really a NotBzrDir error...
1698
 
            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
1699
2114
            branch = create_branch(to_transport.base, format=format,
1700
 
                                   possible_transports=[to_transport])
 
2115
                                   possible_transports=[to_transport],
 
2116
                                   force_new_tree=force_new_tree)
1701
2117
            a_bzrdir = branch.bzrdir
1702
2118
        else:
1703
2119
            from bzrlib.transport.local import LocalTransport
1707
2123
                        raise errors.BranchExistsWithoutWorkingTree(location)
1708
2124
                raise errors.AlreadyBranchError(location)
1709
2125
            branch = a_bzrdir.create_branch()
1710
 
            a_bzrdir.create_workingtree()
 
2126
            if not no_tree and not a_bzrdir.has_workingtree():
 
2127
                a_bzrdir.create_workingtree()
1711
2128
        if append_revisions_only:
1712
2129
            try:
1713
2130
                branch.set_append_revisions_only(True)
1714
2131
            except errors.UpgradeRequired:
1715
 
                raise errors.BzrCommandError('This branch format cannot be set'
1716
 
                    ' to append-revisions-only.  Try --default.')
 
2132
                raise errors.BzrCommandError(gettext('This branch format cannot be set'
 
2133
                    ' to append-revisions-only.  Try --default.'))
1717
2134
        if not is_quiet():
1718
2135
            from bzrlib.info import describe_layout, describe_format
1719
2136
            try:
1723
2140
            repository = branch.repository
1724
2141
            layout = describe_layout(repository, branch, tree).lower()
1725
2142
            format = describe_format(a_bzrdir, repository, branch, tree)
1726
 
            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))
1727
2145
            if repository.is_shared():
1728
2146
                #XXX: maybe this can be refactored into transport.path_or_url()
1729
2147
                url = repository.bzrdir.root_transport.external_url()
1731
2149
                    url = urlutils.local_path_from_url(url)
1732
2150
                except errors.InvalidURL:
1733
2151
                    pass
1734
 
                self.outf.write("Using shared repository: %s\n" % url)
 
2152
                self.outf.write(gettext("Using shared repository: %s\n") % url)
1735
2153
 
1736
2154
 
1737
2155
class cmd_init_repository(Command):
1738
 
    """Create a shared repository to hold branches.
 
2156
    __doc__ = """Create a shared repository for branches to share storage space.
1739
2157
 
1740
2158
    New branches created under the repository directory will store their
1741
 
    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.
1742
2162
 
1743
 
    If the --no-trees option is used then the branches in the repository
1744
 
    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.
1745
2169
 
1746
2170
    :Examples:
1747
 
        Create a shared repositories holding just branches::
 
2171
        Create a shared repository holding just branches::
1748
2172
 
1749
2173
            bzr init-repo --no-trees repo
1750
2174
            bzr init repo/trunk
1761
2185
    takes_options = [RegistryOption('format',
1762
2186
                            help='Specify a format for this repository. See'
1763
2187
                                 ' "bzr help formats" for details.',
1764
 
                            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1765
 
                            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),
1766
2190
                            value_switches=True, title='Repository format'),
1767
2191
                     Option('no-trees',
1768
2192
                             help='Branches in the repository will default to'
1772
2196
 
1773
2197
    def run(self, location, format=None, no_trees=False):
1774
2198
        if format is None:
1775
 
            format = bzrdir.format_registry.make_bzrdir('default')
 
2199
            format = controldir.format_registry.make_bzrdir('default')
1776
2200
 
1777
2201
        if location is None:
1778
2202
            location = '.'
1779
2203
 
1780
2204
        to_transport = transport.get_transport(location)
1781
 
        to_transport.ensure_base()
1782
2205
 
1783
 
        newdir = format.initialize_on_transport(to_transport)
1784
 
        repo = newdir.create_repository(shared=True)
1785
 
        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()))
1786
2212
        if not is_quiet():
1787
2213
            from bzrlib.info import show_bzrdir_info
1788
 
            show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
 
2214
            show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1789
2215
 
1790
2216
 
1791
2217
class cmd_diff(Command):
1792
 
    """Show differences in the working tree, between revisions or branches.
 
2218
    __doc__ = """Show differences in the working tree, between revisions or branches.
1793
2219
 
1794
2220
    If no arguments are given, all changes for the current tree are listed.
1795
2221
    If files are given, only the changes in those files are listed.
1801
2227
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1802
2228
    produces patches suitable for "patch -p1".
1803
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
 
1804
2237
    :Exit values:
1805
2238
        1 - changed
1806
2239
        2 - unrepresentable changes
1816
2249
 
1817
2250
            bzr diff -r1
1818
2251
 
1819
 
        Difference between revision 2 and revision 1::
1820
 
 
1821
 
            bzr diff -r1..2
1822
 
 
1823
 
        Difference between revision 2 and revision 1 for branch xxx::
1824
 
 
1825
 
            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..
1826
2278
 
1827
2279
        Show just the differences for file NEWS::
1828
2280
 
1843
2295
        Same as 'bzr diff' but prefix paths with old/ and new/::
1844
2296
 
1845
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
1846
2302
    """
1847
2303
    _see_also = ['status']
1848
2304
    takes_args = ['file*']
1867
2323
            help='Use this command to compare files.',
1868
2324
            type=unicode,
1869
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
            ),
1870
2335
        ]
1871
2336
    aliases = ['di', 'dif']
1872
2337
    encoding_type = 'exact'
1873
2338
 
1874
2339
    @display_command
1875
2340
    def run(self, revision=None, file_list=None, diff_options=None,
1876
 
            prefix=None, old=None, new=None, using=None):
1877
 
        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)
1878
2345
 
1879
2346
        if (prefix is None) or (prefix == '0'):
1880
2347
            # diff -p0 format
1886
2353
        elif ':' in prefix:
1887
2354
            old_label, new_label = prefix.split(":")
1888
2355
        else:
1889
 
            raise errors.BzrCommandError(
 
2356
            raise errors.BzrCommandError(gettext(
1890
2357
                '--prefix expects two values separated by a colon'
1891
 
                ' (eg "old/:new/")')
 
2358
                ' (eg "old/:new/")'))
1892
2359
 
1893
2360
        if revision and len(revision) > 2:
1894
 
            raise errors.BzrCommandError('bzr diff --revision takes exactly'
1895
 
                                         ' one or two revision specifiers')
1896
 
 
1897
 
        old_tree, new_tree, specific_files, extra_trees = \
1898
 
                _get_trees_to_diff(file_list, revision, old, new,
1899
 
                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()
1900
2375
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1901
2376
                               specific_files=specific_files,
1902
2377
                               external_diff_options=diff_options,
1903
2378
                               old_label=old_label, new_label=new_label,
1904
 
                               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)
1905
2383
 
1906
2384
 
1907
2385
class cmd_deleted(Command):
1908
 
    """List files deleted in the working tree.
 
2386
    __doc__ = """List files deleted in the working tree.
1909
2387
    """
1910
2388
    # TODO: Show files deleted since a previous revision, or
1911
2389
    # between two revisions.
1914
2392
    # level of effort but possibly much less IO.  (Or possibly not,
1915
2393
    # if the directories are very large...)
1916
2394
    _see_also = ['status', 'ls']
1917
 
    takes_options = ['show-ids']
 
2395
    takes_options = ['directory', 'show-ids']
1918
2396
 
1919
2397
    @display_command
1920
 
    def run(self, show_ids=False):
1921
 
        tree = WorkingTree.open_containing(u'.')[0]
1922
 
        tree.lock_read()
1923
 
        try:
1924
 
            old = tree.basis_tree()
1925
 
            old.lock_read()
1926
 
            try:
1927
 
                for path, ie in old.inventory.iter_entries():
1928
 
                    if not tree.has_id(ie.file_id):
1929
 
                        self.outf.write(path)
1930
 
                        if show_ids:
1931
 
                            self.outf.write(' ')
1932
 
                            self.outf.write(ie.file_id)
1933
 
                        self.outf.write('\n')
1934
 
            finally:
1935
 
                old.unlock()
1936
 
        finally:
1937
 
            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')
1938
2410
 
1939
2411
 
1940
2412
class cmd_modified(Command):
1941
 
    """List files modified in working tree.
 
2413
    __doc__ = """List files modified in working tree.
1942
2414
    """
1943
2415
 
1944
2416
    hidden = True
1945
2417
    _see_also = ['status', 'ls']
1946
 
    takes_options = [
1947
 
            Option('null',
1948
 
                   help='Write an ascii NUL (\\0) separator '
1949
 
                   'between files rather than a newline.')
1950
 
            ]
 
2418
    takes_options = ['directory', 'null']
1951
2419
 
1952
2420
    @display_command
1953
 
    def run(self, null=False):
1954
 
        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)
1955
2424
        td = tree.changes_from(tree.basis_tree())
 
2425
        self.cleanup_now()
1956
2426
        for path, id, kind, text_modified, meta_modified in td.modified:
1957
2427
            if null:
1958
2428
                self.outf.write(path + '\0')
1961
2431
 
1962
2432
 
1963
2433
class cmd_added(Command):
1964
 
    """List files added in working tree.
 
2434
    __doc__ = """List files added in working tree.
1965
2435
    """
1966
2436
 
1967
2437
    hidden = True
1968
2438
    _see_also = ['status', 'ls']
1969
 
    takes_options = [
1970
 
            Option('null',
1971
 
                   help='Write an ascii NUL (\\0) separator '
1972
 
                   'between files rather than a newline.')
1973
 
            ]
 
2439
    takes_options = ['directory', 'null']
1974
2440
 
1975
2441
    @display_command
1976
 
    def run(self, null=False):
1977
 
        wt = WorkingTree.open_containing(u'.')[0]
1978
 
        wt.lock_read()
1979
 
        try:
1980
 
            basis = wt.basis_tree()
1981
 
            basis.lock_read()
1982
 
            try:
1983
 
                basis_inv = basis.inventory
1984
 
                inv = wt.inventory
1985
 
                for file_id in inv:
1986
 
                    if file_id in basis_inv:
1987
 
                        continue
1988
 
                    if inv.is_root(file_id) and len(basis_inv) == 0:
1989
 
                        continue
1990
 
                    path = inv.id2path(file_id)
1991
 
                    if not os.access(osutils.abspath(path), os.F_OK):
1992
 
                        continue
1993
 
                    if null:
1994
 
                        self.outf.write(path + '\0')
1995
 
                    else:
1996
 
                        self.outf.write(osutils.quotefn(path) + '\n')
1997
 
            finally:
1998
 
                basis.unlock()
1999
 
        finally:
2000
 
            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')
2001
2460
 
2002
2461
 
2003
2462
class cmd_root(Command):
2004
 
    """Show the tree root directory.
 
2463
    __doc__ = """Show the tree root directory.
2005
2464
 
2006
2465
    The root is the nearest enclosing directory with a .bzr control
2007
2466
    directory."""
2018
2477
    try:
2019
2478
        return int(limitstring)
2020
2479
    except ValueError:
2021
 
        msg = "The limit argument must be an integer."
 
2480
        msg = gettext("The limit argument must be an integer.")
2022
2481
        raise errors.BzrCommandError(msg)
2023
2482
 
2024
2483
 
2026
2485
    try:
2027
2486
        return int(s)
2028
2487
    except ValueError:
2029
 
        msg = "The levels argument must be an integer."
 
2488
        msg = gettext("The levels argument must be an integer.")
2030
2489
        raise errors.BzrCommandError(msg)
2031
2490
 
2032
2491
 
2033
2492
class cmd_log(Command):
2034
 
    """Show historical log for a branch or subset of a branch.
 
2493
    __doc__ = """Show historical log for a branch or subset of a branch.
2035
2494
 
2036
2495
    log is bzr's default tool for exploring the history of a branch.
2037
2496
    The branch to use is taken from the first parameter. If no parameters
2142
2601
 
2143
2602
    :Other filtering:
2144
2603
 
2145
 
      The --message option can be used for finding revisions that match a
2146
 
      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.
2147
2609
 
2148
2610
    :Tips & tricks:
2149
2611
 
2150
2612
      GUI tools and IDEs are often better at exploring history than command
2151
 
      line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2152
 
      respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2153
 
      http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2154
 
 
2155
 
      Web interfaces are often better at exploring history than command line
2156
 
      tools, particularly for branches on servers. You may prefer Loggerhead
2157
 
      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>.  
2158
2617
 
2159
2618
      You may find it useful to add the aliases below to ``bazaar.conf``::
2160
2619
 
2201
2660
                   help='Show just the specified revision.'
2202
2661
                   ' See also "help revisionspec".'),
2203
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
            ),
2204
2668
            Option('levels',
2205
2669
                   short_name='n',
2206
2670
                   help='Number of levels to display - 0 for all, 1 for flat.',
2207
2671
                   argname='N',
2208
2672
                   type=_parse_levels),
2209
2673
            Option('message',
2210
 
                   short_name='m',
2211
2674
                   help='Show revisions whose message matches this '
2212
2675
                        'regular expression.',
2213
 
                   type=str),
 
2676
                   type=str,
 
2677
                   hidden=True),
2214
2678
            Option('limit',
2215
2679
                   short_name='l',
2216
2680
                   help='Limit the output to the first N revisions.',
2219
2683
            Option('show-diff',
2220
2684
                   short_name='p',
2221
2685
                   help='Show changes made in each revision as a patch.'),
2222
 
            Option('include-merges',
 
2686
            Option('include-merged',
2223
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)
2224
2719
            ]
2225
2720
    encoding_type = 'replace'
2226
2721
 
2236
2731
            message=None,
2237
2732
            limit=None,
2238
2733
            show_diff=False,
2239
 
            include_merges=False):
 
2734
            include_merged=None,
 
2735
            authors=None,
 
2736
            exclude_common_ancestry=False,
 
2737
            signatures=False,
 
2738
            match=None,
 
2739
            match_message=None,
 
2740
            match_committer=None,
 
2741
            match_author=None,
 
2742
            match_bugs=None,
 
2743
            omit_merges=False,
 
2744
            include_merges=symbol_versioning.DEPRECATED_PARAMETER,
 
2745
            ):
2240
2746
        from bzrlib.log import (
2241
2747
            Logger,
2242
2748
            make_log_request_dict,
2243
2749
            _get_info_for_log_files,
2244
2750
            )
2245
2751
        direction = (forward and 'forward') or 'reverse'
2246
 
        if include_merges:
 
2752
        if symbol_versioning.deprecated_passed(include_merges):
 
2753
            ui.ui_factory.show_user_warning(
 
2754
                'deprecated_command_option',
 
2755
                deprecated_name='--include-merges',
 
2756
                recommended_name='--include-merged',
 
2757
                deprecated_in_version='2.5',
 
2758
                command=self.invoked_as)
 
2759
            if include_merged is None:
 
2760
                include_merged = include_merges
 
2761
            else:
 
2762
                raise errors.BzrCommandError(gettext(
 
2763
                    '{0} and {1} are mutually exclusive').format(
 
2764
                    '--include-merges', '--include-merged'))
 
2765
        if include_merged is None:
 
2766
            include_merged = False
 
2767
        if (exclude_common_ancestry
 
2768
            and (revision is None or len(revision) != 2)):
 
2769
            raise errors.BzrCommandError(gettext(
 
2770
                '--exclude-common-ancestry requires -r with two revisions'))
 
2771
        if include_merged:
2247
2772
            if levels is None:
2248
2773
                levels = 0
2249
2774
            else:
2250
 
                raise errors.BzrCommandError(
2251
 
                    '--levels and --include-merges are mutually exclusive')
 
2775
                raise errors.BzrCommandError(gettext(
 
2776
                    '{0} and {1} are mutually exclusive').format(
 
2777
                    '--levels', '--include-merged'))
2252
2778
 
2253
2779
        if change is not None:
2254
2780
            if len(change) > 1:
2255
2781
                raise errors.RangeInChangeOption()
2256
2782
            if revision is not None:
2257
 
                raise errors.BzrCommandError(
2258
 
                    '--revision and --change are mutually exclusive')
 
2783
                raise errors.BzrCommandError(gettext(
 
2784
                    '{0} and {1} are mutually exclusive').format(
 
2785
                    '--revision', '--change'))
2259
2786
            else:
2260
2787
                revision = change
2261
2788
 
2263
2790
        filter_by_dir = False
2264
2791
        if file_list:
2265
2792
            # find the file ids to log and check for directory filtering
2266
 
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(revision,
2267
 
                file_list)
 
2793
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
 
2794
                revision, file_list, self.add_cleanup)
2268
2795
            for relpath, file_id, kind in file_info_list:
2269
2796
                if file_id is None:
2270
 
                    raise errors.BzrCommandError(
2271
 
                        "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") %
2272
2799
                        relpath)
2273
2800
                # If the relpath is the top of the tree, we log everything
2274
2801
                if relpath == '':
2286
2813
                location = revision[0].get_branch()
2287
2814
            else:
2288
2815
                location = '.'
2289
 
            dir, relpath = bzrdir.BzrDir.open_containing(location)
 
2816
            dir, relpath = controldir.ControlDir.open_containing(location)
2290
2817
            b = dir.open_branch()
 
2818
            self.add_cleanup(b.lock_read().unlock)
2291
2819
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2292
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
 
2293
2828
        # Decide on the type of delta & diff filtering to use
2294
2829
        # TODO: add an --all-files option to make this configurable & consistent
2295
2830
        if not verbose:
2303
2838
        else:
2304
2839
            diff_type = 'full'
2305
2840
 
2306
 
        b.lock_read()
2307
 
        try:
2308
 
            # Build the log formatter
2309
 
            if log_format is None:
2310
 
                log_format = log.log_formatter_registry.get_default(b)
2311
 
            lf = log_format(show_ids=show_ids, to_file=self.outf,
2312
 
                            show_timezone=timezone,
2313
 
                            delta_format=get_verbosity_level(),
2314
 
                            levels=levels,
2315
 
                            show_advice=levels is None)
2316
 
 
2317
 
            # Choose the algorithm for doing the logging. It's annoying
2318
 
            # having multiple code paths like this but necessary until
2319
 
            # the underlying repository format is faster at generating
2320
 
            # deltas or can provide everything we need from the indices.
2321
 
            # The default algorithm - match-using-deltas - works for
2322
 
            # multiple files and directories and is faster for small
2323
 
            # amounts of history (200 revisions say). However, it's too
2324
 
            # slow for logging a single file in a repository with deep
2325
 
            # history, i.e. > 10K revisions. In the spirit of "do no
2326
 
            # evil when adding features", we continue to use the
2327
 
            # original algorithm - per-file-graph - for the "single
2328
 
            # file that isn't a directory without showing a delta" case.
2329
 
            partial_history = revision and b.repository._format.supports_chks
2330
 
            match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2331
 
                or delta_type or partial_history)
2332
 
 
2333
 
            # Build the LogRequest and execute it
2334
 
            if len(file_ids) == 0:
2335
 
                file_ids = None
2336
 
            rqst = make_log_request_dict(
2337
 
                direction=direction, specific_fileids=file_ids,
2338
 
                start_revision=rev1, end_revision=rev2, limit=limit,
2339
 
                message_search=message, delta_type=delta_type,
2340
 
                diff_type=diff_type, _match_using_deltas=match_using_deltas)
2341
 
            Logger(b, rqst).show(lf)
2342
 
        finally:
2343
 
            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)
2344
2894
 
2345
2895
 
2346
2896
def _get_revision_range(revisionspec_list, branch, command_name):
2361
2911
            # b is taken from revision[0].get_branch(), and
2362
2912
            # show_log will use its revision_history. Having
2363
2913
            # different branches will lead to weird behaviors.
2364
 
            raise errors.BzrCommandError(
 
2914
            raise errors.BzrCommandError(gettext(
2365
2915
                "bzr %s doesn't accept two revisions in different"
2366
 
                " branches." % command_name)
2367
 
        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)
2368
2922
        # Avoid loading all of history when we know a missing
2369
2923
        # end of range means the last revision ...
2370
2924
        if end_spec.spec is None:
2373
2927
        else:
2374
2928
            rev2 = end_spec.in_history(branch)
2375
2929
    else:
2376
 
        raise errors.BzrCommandError(
2377
 
            '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)
2378
2932
    return rev1, rev2
2379
2933
 
2380
2934
 
2399
2953
 
2400
2954
 
2401
2955
class cmd_touching_revisions(Command):
2402
 
    """Return revision-ids which affected a particular file.
 
2956
    __doc__ = """Return revision-ids which affected a particular file.
2403
2957
 
2404
2958
    A more user-friendly interface is "bzr log FILE".
2405
2959
    """
2410
2964
    @display_command
2411
2965
    def run(self, filename):
2412
2966
        tree, relpath = WorkingTree.open_containing(filename)
 
2967
        file_id = tree.path2id(relpath)
2413
2968
        b = tree.branch
2414
 
        file_id = tree.path2id(relpath)
2415
 
        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:
2416
2972
            self.outf.write("%6d %s\n" % (revno, what))
2417
2973
 
2418
2974
 
2419
2975
class cmd_ls(Command):
2420
 
    """List files in a tree.
 
2976
    __doc__ = """List files in a tree.
2421
2977
    """
2422
2978
 
2423
2979
    _see_also = ['status', 'cat']
2429
2985
                   help='Recurse into subdirectories.'),
2430
2986
            Option('from-root',
2431
2987
                   help='Print paths relative to the root of the branch.'),
2432
 
            Option('unknown', help='Print unknown files.'),
 
2988
            Option('unknown', short_name='u',
 
2989
                help='Print unknown files.'),
2433
2990
            Option('versioned', help='Print versioned files.',
2434
2991
                   short_name='V'),
2435
 
            Option('ignored', help='Print ignored files.'),
2436
 
            Option('null',
2437
 
                   help='Write an ascii NUL (\\0) separator '
2438
 
                   'between files rather than a newline.'),
2439
 
            Option('kind',
 
2992
            Option('ignored', short_name='i',
 
2993
                help='Print ignored files.'),
 
2994
            Option('kind', short_name='k',
2440
2995
                   help='List entries of a particular kind: file, directory, symlink.',
2441
2996
                   type=unicode),
 
2997
            'null',
2442
2998
            'show-ids',
 
2999
            'directory',
2443
3000
            ]
2444
3001
    @display_command
2445
3002
    def run(self, revision=None, verbose=False,
2446
3003
            recursive=False, from_root=False,
2447
3004
            unknown=False, versioned=False, ignored=False,
2448
 
            null=False, kind=None, show_ids=False, path=None):
 
3005
            null=False, kind=None, show_ids=False, path=None, directory=None):
2449
3006
 
2450
3007
        if kind and kind not in ('file', 'directory', 'symlink'):
2451
 
            raise errors.BzrCommandError('invalid kind specified')
 
3008
            raise errors.BzrCommandError(gettext('invalid kind specified'))
2452
3009
 
2453
3010
        if verbose and null:
2454
 
            raise errors.BzrCommandError('Cannot set both --verbose and --null')
 
3011
            raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2455
3012
        all = not (unknown or versioned or ignored)
2456
3013
 
2457
3014
        selection = {'I':ignored, '?':unknown, 'V':versioned}
2460
3017
            fs_path = '.'
2461
3018
        else:
2462
3019
            if from_root:
2463
 
                raise errors.BzrCommandError('cannot specify both --from-root'
2464
 
                                             ' and PATH')
 
3020
                raise errors.BzrCommandError(gettext('cannot specify both --from-root'
 
3021
                                             ' and PATH'))
2465
3022
            fs_path = path
2466
 
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2467
 
            fs_path)
 
3023
        tree, branch, relpath = \
 
3024
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2468
3025
 
2469
3026
        # Calculate the prefix to use
2470
3027
        prefix = None
2471
3028
        if from_root:
2472
3029
            if relpath:
2473
3030
                prefix = relpath + '/'
2474
 
        elif fs_path != '.':
 
3031
        elif fs_path != '.' and not fs_path.endswith('/'):
2475
3032
            prefix = fs_path + '/'
2476
3033
 
2477
3034
        if revision is not None or tree is None:
2483
3040
            if view_files:
2484
3041
                apply_view = True
2485
3042
                view_str = views.view_display_str(view_files)
2486
 
                note("Ignoring files outside view. View is %s" % view_str)
2487
 
 
2488
 
        tree.lock_read()
2489
 
        try:
2490
 
            for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2491
 
                from_dir=relpath, recursive=recursive):
2492
 
                # Apply additional masking
2493
 
                if not all and not selection[fc]:
2494
 
                    continue
2495
 
                if kind is not None and fkind != kind:
2496
 
                    continue
2497
 
                if apply_view:
2498
 
                    try:
2499
 
                        if relpath:
2500
 
                            fullpath = osutils.pathjoin(relpath, fp)
2501
 
                        else:
2502
 
                            fullpath = fp
2503
 
                        views.check_path_in_view(tree, fullpath)
2504
 
                    except errors.FileOutsideView:
2505
 
                        continue
2506
 
 
2507
 
                # Output the entry
2508
 
                if prefix:
2509
 
                    fp = osutils.pathjoin(prefix, fp)
2510
 
                kindch = entry.kind_character()
2511
 
                outstring = fp + kindch
2512
 
                ui.ui_factory.clear_term()
2513
 
                if verbose:
2514
 
                    outstring = '%-8s %s' % (fc, outstring)
2515
 
                    if show_ids and fid is not None:
2516
 
                        outstring = "%-50s %s" % (outstring, fid)
 
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:
2517
3089
                    self.outf.write(outstring + '\n')
2518
 
                elif null:
2519
 
                    self.outf.write(fp + '\0')
2520
 
                    if show_ids:
2521
 
                        if fid is not None:
2522
 
                            self.outf.write(fid)
2523
 
                        self.outf.write('\0')
2524
 
                    self.outf.flush()
2525
 
                else:
2526
 
                    if show_ids:
2527
 
                        if fid is not None:
2528
 
                            my_id = fid
2529
 
                        else:
2530
 
                            my_id = ''
2531
 
                        self.outf.write('%-50s %s\n' % (outstring, my_id))
2532
 
                    else:
2533
 
                        self.outf.write(outstring + '\n')
2534
 
        finally:
2535
 
            tree.unlock()
2536
3090
 
2537
3091
 
2538
3092
class cmd_unknowns(Command):
2539
 
    """List unknown files.
 
3093
    __doc__ = """List unknown files.
2540
3094
    """
2541
3095
 
2542
3096
    hidden = True
2543
3097
    _see_also = ['ls']
 
3098
    takes_options = ['directory']
2544
3099
 
2545
3100
    @display_command
2546
 
    def run(self):
2547
 
        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():
2548
3103
            self.outf.write(osutils.quotefn(f) + '\n')
2549
3104
 
2550
3105
 
2551
3106
class cmd_ignore(Command):
2552
 
    """Ignore specified files or patterns.
 
3107
    __doc__ = """Ignore specified files or patterns.
2553
3108
 
2554
3109
    See ``bzr help patterns`` for details on the syntax of patterns.
2555
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
 
2556
3117
    To remove patterns from the ignore list, edit the .bzrignore file.
2557
3118
    After adding, editing or deleting that file either indirectly by
2558
3119
    using this command or directly by using an editor, be sure to commit
2559
3120
    it.
2560
 
 
2561
 
    Note: ignore patterns containing shell wildcards must be quoted from
2562
 
    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.
2563
3142
 
2564
3143
    :Examples:
2565
3144
        Ignore the top level Makefile::
2566
3145
 
2567
3146
            bzr ignore ./Makefile
2568
3147
 
2569
 
        Ignore class files in all directories::
 
3148
        Ignore .class files in all directories...::
2570
3149
 
2571
3150
            bzr ignore "*.class"
2572
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
 
2573
3160
        Ignore .o files under the lib directory::
2574
3161
 
2575
3162
            bzr ignore "lib/**/*.o"
2581
3168
        Ignore everything but the "debian" toplevel directory::
2582
3169
 
2583
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 "!!*~"
2584
3178
    """
2585
3179
 
2586
3180
    _see_also = ['status', 'ignored', 'patterns']
2587
3181
    takes_args = ['name_pattern*']
2588
 
    takes_options = [
2589
 
        Option('old-default-rules',
2590
 
               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.')
2591
3185
        ]
2592
3186
 
2593
 
    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'.'):
2594
3189
        from bzrlib import ignores
2595
 
        if old_default_rules is not None:
2596
 
            # dump the rules and exit
2597
 
            for pattern in ignores.OLD_DEFAULTS:
2598
 
                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)
2599
3194
            return
2600
3195
        if not name_pattern_list:
2601
 
            raise errors.BzrCommandError("ignore requires at least one "
2602
 
                                  "NAME_PATTERN or --old-default-rules")
 
3196
            raise errors.BzrCommandError(gettext("ignore requires at least one "
 
3197
                "NAME_PATTERN or --default-rules."))
2603
3198
        name_pattern_list = [globbing.normalize_pattern(p)
2604
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('')
2605
3212
        for name_pattern in name_pattern_list:
2606
3213
            if (name_pattern[0] == '/' or
2607
3214
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2608
 
                raise errors.BzrCommandError(
2609
 
                    "NAME_PATTERN should not be an absolute path")
2610
 
        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)
2611
3218
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2612
3219
        ignored = globbing.Globster(name_pattern_list)
2613
3220
        matches = []
2614
 
        tree.lock_read()
 
3221
        self.add_cleanup(tree.lock_read().unlock)
2615
3222
        for entry in tree.list_files():
2616
3223
            id = entry[3]
2617
3224
            if id is not None:
2618
3225
                filename = entry[0]
2619
3226
                if ignored.match(filename):
2620
 
                    matches.append(filename.encode('utf-8'))
2621
 
        tree.unlock()
 
3227
                    matches.append(filename)
2622
3228
        if len(matches) > 0:
2623
 
            print "Warning: the following files are version controlled and" \
2624
 
                  " match your ignore pattern:\n%s" \
2625
 
                  "\nThese files will continue to be version controlled" \
2626
 
                  " 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),))
2627
3233
 
2628
3234
 
2629
3235
class cmd_ignored(Command):
2630
 
    """List ignored files and the patterns that matched them.
 
3236
    __doc__ = """List ignored files and the patterns that matched them.
2631
3237
 
2632
3238
    List all the ignored files and the ignore pattern that caused the file to
2633
3239
    be ignored.
2639
3245
 
2640
3246
    encoding_type = 'replace'
2641
3247
    _see_also = ['ignore', 'ls']
 
3248
    takes_options = ['directory']
2642
3249
 
2643
3250
    @display_command
2644
 
    def run(self):
2645
 
        tree = WorkingTree.open_containing(u'.')[0]
2646
 
        tree.lock_read()
2647
 
        try:
2648
 
            for path, file_class, kind, file_id, entry in tree.list_files():
2649
 
                if file_class != 'I':
2650
 
                    continue
2651
 
                ## XXX: Slightly inefficient since this was already calculated
2652
 
                pat = tree.is_ignored(path)
2653
 
                self.outf.write('%-50s %s\n' % (path, pat))
2654
 
        finally:
2655
 
            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))
2656
3260
 
2657
3261
 
2658
3262
class cmd_lookup_revision(Command):
2659
 
    """Lookup the revision-id from a revision-number
 
3263
    __doc__ = """Lookup the revision-id from a revision-number
2660
3264
 
2661
3265
    :Examples:
2662
3266
        bzr lookup-revision 33
2663
3267
    """
2664
3268
    hidden = True
2665
3269
    takes_args = ['revno']
 
3270
    takes_options = ['directory']
2666
3271
 
2667
3272
    @display_command
2668
 
    def run(self, revno):
 
3273
    def run(self, revno, directory=u'.'):
2669
3274
        try:
2670
3275
            revno = int(revno)
2671
3276
        except ValueError:
2672
 
            raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2673
 
 
2674
 
        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)
2675
3281
 
2676
3282
 
2677
3283
class cmd_export(Command):
2678
 
    """Export current or past revision to a destination directory or archive.
 
3284
    __doc__ = """Export current or past revision to a destination directory or archive.
2679
3285
 
2680
3286
    If no revision is specified this exports the last committed revision.
2681
3287
 
2702
3308
         zip                          .zip
2703
3309
      =================       =========================
2704
3310
    """
 
3311
    encoding = 'exact'
2705
3312
    takes_args = ['dest', 'branch_or_subdir?']
2706
 
    takes_options = [
 
3313
    takes_options = ['directory',
2707
3314
        Option('format',
2708
3315
               help="Type of file to export to.",
2709
3316
               type=unicode),
2713
3320
        Option('root',
2714
3321
               type=str,
2715
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.'),
2716
3329
        ]
2717
3330
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2718
 
        root=None, filters=False):
 
3331
        root=None, filters=False, per_file_timestamps=False, uncommitted=False,
 
3332
        directory=u'.'):
2719
3333
        from bzrlib.export import export
2720
3334
 
2721
3335
        if branch_or_subdir is None:
2722
 
            tree = WorkingTree.open_containing(u'.')[0]
2723
 
            b = tree.branch
2724
 
            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
2725
3348
        else:
2726
 
            b, subdir = Branch.open_containing(branch_or_subdir)
2727
 
            tree = None
2728
 
 
2729
 
        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)
2730
3350
        try:
2731
 
            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)
2732
3353
        except errors.NoSuchExportFormat, e:
2733
 
            raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
 
3354
            raise errors.BzrCommandError(
 
3355
                gettext('Unsupported export format: %s') % e.format)
2734
3356
 
2735
3357
 
2736
3358
class cmd_cat(Command):
2737
 
    """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.
2738
3360
 
2739
3361
    If no revision is nominated, the last revision is used.
2740
3362
 
2743
3365
    """
2744
3366
 
2745
3367
    _see_also = ['ls']
2746
 
    takes_options = [
 
3368
    takes_options = ['directory',
2747
3369
        Option('name-from-revision', help='The path name in the old tree.'),
2748
3370
        Option('filters', help='Apply content filters to display the '
2749
3371
                'convenience form.'),
2754
3376
 
2755
3377
    @display_command
2756
3378
    def run(self, filename, revision=None, name_from_revision=False,
2757
 
            filters=False):
 
3379
            filters=False, directory=None):
2758
3380
        if revision is not None and len(revision) != 1:
2759
 
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2760
 
                                         " one revision specifier")
 
3381
            raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
 
3382
                                         " one revision specifier"))
2761
3383
        tree, branch, relpath = \
2762
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2763
 
        branch.lock_read()
2764
 
        try:
2765
 
            return self._run(tree, branch, relpath, filename, revision,
2766
 
                             name_from_revision, filters)
2767
 
        finally:
2768
 
            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)
2769
3388
 
2770
3389
    def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2771
3390
        filtered):
2772
3391
        if tree is None:
2773
3392
            tree = b.basis_tree()
2774
3393
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
 
3394
        self.add_cleanup(rev_tree.lock_read().unlock)
2775
3395
 
2776
3396
        old_file_id = rev_tree.path2id(relpath)
2777
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.
2778
3402
        if name_from_revision:
2779
3403
            # Try in revision if requested
2780
3404
            if old_file_id is None:
2781
 
                raise errors.BzrCommandError(
2782
 
                    "%r is not present in revision %s" % (
 
3405
                raise errors.BzrCommandError(gettext(
 
3406
                    "{0!r} is not present in revision {1}").format(
2783
3407
                        filename, rev_tree.get_revision_id()))
2784
3408
            else:
2785
 
                content = rev_tree.get_file_text(old_file_id)
 
3409
                actual_file_id = old_file_id
2786
3410
        else:
2787
3411
            cur_file_id = tree.path2id(relpath)
2788
 
            found = False
2789
 
            if cur_file_id is not None:
2790
 
                # Then try with the actual file id
2791
 
                try:
2792
 
                    content = rev_tree.get_file_text(cur_file_id)
2793
 
                    found = True
2794
 
                except errors.NoSuchId:
2795
 
                    # The actual file id didn't exist at that time
2796
 
                    pass
2797
 
            if not found and old_file_id is not None:
2798
 
                # Finally try with the old file id
2799
 
                content = rev_tree.get_file_text(old_file_id)
2800
 
                found = True
2801
 
            if not found:
2802
 
                # Can't be found anywhere
2803
 
                raise errors.BzrCommandError(
2804
 
                    "%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(
2805
3419
                        filename, rev_tree.get_revision_id()))
2806
3420
        if filtered:
2807
 
            from bzrlib.filters import (
2808
 
                ContentFilterContext,
2809
 
                filtered_output_bytes,
2810
 
                )
2811
 
            filters = rev_tree._content_filter_stack(relpath)
2812
 
            chunks = content.splitlines(True)
2813
 
            content = filtered_output_bytes(chunks, filters,
2814
 
                ContentFilterContext(relpath, rev_tree))
2815
 
            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)
2816
3425
        else:
2817
 
            self.outf.write(content)
 
3426
            content = rev_tree.get_file_text(actual_file_id)
 
3427
        self.cleanup_now()
 
3428
        self.outf.write(content)
2818
3429
 
2819
3430
 
2820
3431
class cmd_local_time_offset(Command):
2821
 
    """Show the offset in seconds from GMT to local time."""
 
3432
    __doc__ = """Show the offset in seconds from GMT to local time."""
2822
3433
    hidden = True
2823
3434
    @display_command
2824
3435
    def run(self):
2825
 
        print osutils.local_time_offset()
 
3436
        self.outf.write("%s\n" % osutils.local_time_offset())
2826
3437
 
2827
3438
 
2828
3439
 
2829
3440
class cmd_commit(Command):
2830
 
    """Commit changes into a new revision.
 
3441
    __doc__ = """Commit changes into a new revision.
2831
3442
 
2832
3443
    An explanatory message needs to be given for each commit. This is
2833
3444
    often done by using the --message option (getting the message from the
2881
3492
      to trigger updates to external systems like bug trackers. The --fixes
2882
3493
      option can be used to record the association between a revision and
2883
3494
      one or more bugs. See ``bzr help bugs`` for details.
2884
 
 
2885
 
      A selective commit may fail in some cases where the committed
2886
 
      tree would be invalid. Consider::
2887
 
  
2888
 
        bzr init foo
2889
 
        mkdir foo/bar
2890
 
        bzr add foo/bar
2891
 
        bzr commit foo -m "committing foo"
2892
 
        bzr mv foo/bar foo/baz
2893
 
        mkdir foo/bar
2894
 
        bzr add foo/bar
2895
 
        bzr commit foo/bar -m "committing bar but not baz"
2896
 
  
2897
 
      In the example above, the last commit will fail by design. This gives
2898
 
      the user the opportunity to decide whether they want to commit the
2899
 
      rename at the same time, separately first, or not at all. (As a general
2900
 
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2901
3495
    """
2902
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
2903
 
 
2904
 
    # TODO: Strict commit that fails if there are deleted files.
2905
 
    #       (what does "deleted files" mean ??)
2906
 
 
2907
 
    # TODO: Give better message for -s, --summary, used by tla people
2908
 
 
2909
 
    # XXX: verbose currently does nothing
2910
3496
 
2911
3497
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
2912
3498
    takes_args = ['selected*']
2926
3512
             Option('strict',
2927
3513
                    help="Refuse to commit if there are unknown "
2928
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'."),
2929
3518
             ListOption('fixes', type=str,
2930
3519
                    help="Mark a bug as being fixed by this revision "
2931
3520
                         "(see \"bzr help bugs\")."),
2938
3527
                         "the master branch until a normal commit "
2939
3528
                         "is performed."
2940
3529
                    ),
2941
 
              Option('show-diff',
2942
 
                     help='When no message is supplied, show the diff along'
2943
 
                     ' 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.'),
2944
3537
             ]
2945
3538
    aliases = ['ci', 'checkin']
2946
3539
 
2947
3540
    def _iter_bug_fix_urls(self, fixes, branch):
 
3541
        default_bugtracker  = None
2948
3542
        # Configure the properties for bug fixing attributes.
2949
3543
        for fixed_bug in fixes:
2950
3544
            tokens = fixed_bug.split(':')
2951
 
            if len(tokens) != 2:
2952
 
                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(
2953
3561
                    "Invalid bug %s. Must be in the form of 'tracker:id'. "
2954
3562
                    "See \"bzr help bugs\" for more information on this "
2955
 
                    "feature.\nCommit refused." % fixed_bug)
2956
 
            tag, bug_id = tokens
 
3563
                    "feature.\nCommit refused.") % fixed_bug)
 
3564
            else:
 
3565
                tag, bug_id = tokens
2957
3566
            try:
2958
3567
                yield bugtracker.get_bug_url(tag, branch, bug_id)
2959
3568
            except errors.UnknownBugTrackerAbbreviation:
2960
 
                raise errors.BzrCommandError(
2961
 
                    'Unrecognized bug %s. Commit refused.' % fixed_bug)
 
3569
                raise errors.BzrCommandError(gettext(
 
3570
                    'Unrecognized bug %s. Commit refused.') % fixed_bug)
2962
3571
            except errors.MalformedBugIdentifier, e:
2963
 
                raise errors.BzrCommandError(
2964
 
                    "%s\nCommit refused." % (str(e),))
 
3572
                raise errors.BzrCommandError(gettext(
 
3573
                    "%s\nCommit refused.") % (str(e),))
2965
3574
 
2966
3575
    def run(self, message=None, file=None, verbose=False, selected_list=None,
2967
3576
            unchanged=False, strict=False, local=False, fixes=None,
2968
 
            author=None, show_diff=False, exclude=None):
 
3577
            author=None, show_diff=False, exclude=None, commit_time=None,
 
3578
            lossy=False):
2969
3579
        from bzrlib.errors import (
2970
3580
            PointlessCommit,
2971
3581
            ConflictsInTree,
2974
3584
        from bzrlib.msgeditor import (
2975
3585
            edit_commit_message_encoded,
2976
3586
            generate_commit_message_template,
2977
 
            make_commit_message_template_encoded
 
3587
            make_commit_message_template_encoded,
 
3588
            set_commit_message,
2978
3589
        )
2979
3590
 
2980
 
        # TODO: Need a blackbox test for invoking the external editor; may be
2981
 
        # slightly problematic to run this cross-platform.
2982
 
 
2983
 
        # TODO: do more checks that the commit will succeed before
2984
 
        # 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)))
2985
3598
 
2986
3599
        properties = {}
2987
3600
 
2988
 
        tree, selected_list = tree_files(selected_list)
 
3601
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
2989
3602
        if selected_list == ['']:
2990
3603
            # workaround - commit of root of tree should be exactly the same
2991
3604
            # as just default commit in that tree, and succeed even though
3002
3615
        if local and not tree.branch.get_bound_location():
3003
3616
            raise errors.LocalRequiresBoundBranch()
3004
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
 
3005
3639
        def get_message(commit_obj):
3006
3640
            """Callback to get commit message"""
3007
 
            my_message = message
3008
 
            if my_message is None and not file:
3009
 
                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,
3010
3653
                        selected_list, diff=show_diff,
3011
3654
                        output_encoding=osutils.get_user_encoding())
3012
 
                start_message = generate_commit_message_template(commit_obj)
3013
 
                my_message = edit_commit_message_encoded(t,
3014
 
                    start_message=start_message)
3015
 
                if my_message is None:
3016
 
                    raise errors.BzrCommandError("please specify a commit"
3017
 
                        " message with either --message or --file")
3018
 
            elif my_message and file:
3019
 
                raise errors.BzrCommandError(
3020
 
                    "please specify either --message or --file")
3021
 
            if file:
3022
 
                my_message = codecs.open(file, 'rt',
3023
 
                                         osutils.get_user_encoding()).read()
3024
 
            if my_message == "":
3025
 
                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 \"\"."))
3026
3673
            return my_message
3027
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
3028
3679
        try:
3029
3680
            tree.commit(message_callback=get_message,
3030
3681
                        specific_files=selected_list,
3031
3682
                        allow_pointless=unchanged, strict=strict, local=local,
3032
3683
                        reporter=None, verbose=verbose, revprops=properties,
3033
 
                        authors=author,
3034
 
                        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)
3035
3688
        except PointlessCommit:
3036
 
            # FIXME: This should really happen before the file is read in;
3037
 
            # perhaps prepare the commit; get the message; then actually commit
3038
 
            raise errors.BzrCommandError("No changes to commit."
3039
 
                              " 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."))
3040
3692
        except ConflictsInTree:
3041
 
            raise errors.BzrCommandError('Conflicts detected in working '
 
3693
            raise errors.BzrCommandError(gettext('Conflicts detected in working '
3042
3694
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3043
 
                ' resolve.')
 
3695
                ' resolve.'))
3044
3696
        except StrictCommitFailed:
3045
 
            raise errors.BzrCommandError("Commit refused because there are"
3046
 
                              " unknown files in the working tree.")
 
3697
            raise errors.BzrCommandError(gettext("Commit refused because there are"
 
3698
                              " unknown files in the working tree."))
3047
3699
        except errors.BoundBranchOutOfDate, e:
3048
 
            raise errors.BzrCommandError(str(e) + "\n"
3049
 
            'To commit to master branch, run update and then commit.\n'
3050
 
            'You can also pass --local to commit to continue working '
3051
 
            '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
3052
3705
 
3053
3706
 
3054
3707
class cmd_check(Command):
3055
 
    """Validate working tree structure, branch consistency and repository history.
 
3708
    __doc__ = """Validate working tree structure, branch consistency and repository history.
3056
3709
 
3057
3710
    This command checks various invariants about branch and repository storage
3058
3711
    to detect data corruption or bzr bugs.
3122
3775
 
3123
3776
 
3124
3777
class cmd_upgrade(Command):
3125
 
    """Upgrade branch storage to current format.
3126
 
 
3127
 
    The check command or bzr developers may sometimes advise you to run
3128
 
    this command. When the default format has changed you may also be warned
3129
 
    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/.
3130
3808
    """
3131
3809
 
3132
 
    _see_also = ['check']
 
3810
    _see_also = ['check', 'reconcile', 'formats']
3133
3811
    takes_args = ['url?']
3134
3812
    takes_options = [
3135
 
                    RegistryOption('format',
3136
 
                        help='Upgrade to a specific format.  See "bzr help'
3137
 
                             ' formats" for details.',
3138
 
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3139
 
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3140
 
                        value_switches=True, title='Branch format'),
3141
 
                    ]
 
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
    ]
3142
3824
 
3143
 
    def run(self, url='.', format=None):
 
3825
    def run(self, url='.', format=None, clean=False, dry_run=False):
3144
3826
        from bzrlib.upgrade import upgrade
3145
 
        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
3146
3834
 
3147
3835
 
3148
3836
class cmd_whoami(Command):
3149
 
    """Show or set bzr user id.
 
3837
    __doc__ = """Show or set bzr user id.
3150
3838
 
3151
3839
    :Examples:
3152
3840
        Show the email of the current user::
3157
3845
 
3158
3846
            bzr whoami "Frank Chu <fchu@example.com>"
3159
3847
    """
3160
 
    takes_options = [ Option('email',
 
3848
    takes_options = [ 'directory',
 
3849
                      Option('email',
3161
3850
                             help='Display email address only.'),
3162
3851
                      Option('branch',
3163
3852
                             help='Set identity for the current branch instead of '
3167
3856
    encoding_type = 'replace'
3168
3857
 
3169
3858
    @display_command
3170
 
    def run(self, email=False, branch=False, name=None):
 
3859
    def run(self, email=False, branch=False, name=None, directory=None):
3171
3860
        if name is None:
3172
 
            # use branch if we're inside one; otherwise global config
3173
 
            try:
3174
 
                c = Branch.open_containing('.')[0].get_config()
3175
 
            except errors.NotBranchError:
3176
 
                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')
3177
3870
            if email:
3178
 
                self.outf.write(c.user_email() + '\n')
 
3871
                self.outf.write(_mod_config.extract_email_address(identity)
 
3872
                                + '\n')
3179
3873
            else:
3180
 
                self.outf.write(c.username() + '\n')
 
3874
                self.outf.write(identity + '\n')
3181
3875
            return
3182
3876
 
 
3877
        if email:
 
3878
            raise errors.BzrCommandError(gettext("--email can only be used to display existing "
 
3879
                                         "identity"))
 
3880
 
3183
3881
        # display a warning if an email address isn't included in the given name.
3184
3882
        try:
3185
 
            config.extract_email_address(name)
 
3883
            _mod_config.extract_email_address(name)
3186
3884
        except errors.NoEmailInUsername, e:
3187
3885
            warning('"%s" does not seem to contain an email address.  '
3188
3886
                    'This is allowed, but not recommended.', name)
3189
3887
 
3190
3888
        # use global config unless --branch given
3191
3889
        if branch:
3192
 
            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()
3193
3896
        else:
3194
 
            c = config.GlobalConfig()
3195
 
        c.set_user_option('email', name)
 
3897
            c = _mod_config.GlobalStack()
 
3898
        c.set('email', name)
3196
3899
 
3197
3900
 
3198
3901
class cmd_nick(Command):
3199
 
    """Print or set the branch nickname.
 
3902
    __doc__ = """Print or set the branch nickname.
3200
3903
 
3201
 
    If unset, the tree root directory name is used as the nickname.
3202
 
    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.
3203
3907
 
3204
3908
    Bound branches use the nickname of its master branch unless it is set
3205
3909
    locally.
3207
3911
 
3208
3912
    _see_also = ['info']
3209
3913
    takes_args = ['nickname?']
3210
 
    def run(self, nickname=None):
3211
 
        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]
3212
3917
        if nickname is None:
3213
3918
            self.printme(branch)
3214
3919
        else:
3216
3921
 
3217
3922
    @display_command
3218
3923
    def printme(self, branch):
3219
 
        print branch.nick
 
3924
        self.outf.write('%s\n' % branch.nick)
3220
3925
 
3221
3926
 
3222
3927
class cmd_alias(Command):
3223
 
    """Set/unset and display aliases.
 
3928
    __doc__ = """Set/unset and display aliases.
3224
3929
 
3225
3930
    :Examples:
3226
3931
        Show the current aliases::
3259
3964
 
3260
3965
    def remove_alias(self, alias_name):
3261
3966
        if alias_name is None:
3262
 
            raise errors.BzrCommandError(
3263
 
                'bzr alias --remove expects an alias to remove.')
 
3967
            raise errors.BzrCommandError(gettext(
 
3968
                'bzr alias --remove expects an alias to remove.'))
3264
3969
        # If alias is not found, print something like:
3265
3970
        # unalias: foo: not found
3266
 
        c = config.GlobalConfig()
 
3971
        c = _mod_config.GlobalConfig()
3267
3972
        c.unset_alias(alias_name)
3268
3973
 
3269
3974
    @display_command
3270
3975
    def print_aliases(self):
3271
3976
        """Print out the defined aliases in a similar format to bash."""
3272
 
        aliases = config.GlobalConfig().get_aliases()
 
3977
        aliases = _mod_config.GlobalConfig().get_aliases()
3273
3978
        for key, value in sorted(aliases.iteritems()):
3274
3979
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3275
3980
 
3285
3990
 
3286
3991
    def set_alias(self, alias_name, alias_command):
3287
3992
        """Save the alias in the global config."""
3288
 
        c = config.GlobalConfig()
 
3993
        c = _mod_config.GlobalConfig()
3289
3994
        c.set_alias(alias_name, alias_command)
3290
3995
 
3291
3996
 
3292
3997
class cmd_selftest(Command):
3293
 
    """Run internal test suite.
 
3998
    __doc__ = """Run internal test suite.
3294
3999
 
3295
4000
    If arguments are given, they are regular expressions that say which tests
3296
4001
    should run.  Tests matching any expression are run, and other tests are
3323
4028
    Tests that need working space on disk use a common temporary directory,
3324
4029
    typically inside $TMPDIR or /tmp.
3325
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
 
3326
4037
    :Examples:
3327
4038
        Run only tests relating to 'ignore'::
3328
4039
 
3337
4048
    def get_transport_type(typestring):
3338
4049
        """Parse and return a transport specifier."""
3339
4050
        if typestring == "sftp":
3340
 
            from bzrlib.transport.sftp import SFTPAbsoluteServer
3341
 
            return SFTPAbsoluteServer
3342
 
        if typestring == "memory":
3343
 
            from bzrlib.transport.memory import MemoryServer
3344
 
            return MemoryServer
3345
 
        if typestring == "fakenfs":
3346
 
            from bzrlib.transport.fakenfs import FakeNFSServer
3347
 
            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
3348
4059
        msg = "No known transport type %s. Supported types are: sftp\n" %\
3349
4060
            (typestring)
3350
4061
        raise errors.BzrCommandError(msg)
3361
4072
                                 'throughout the test suite.',
3362
4073
                            type=get_transport_type),
3363
4074
                     Option('benchmark',
3364
 
                            help='Run the benchmarks rather than selftests.'),
 
4075
                            help='Run the benchmarks rather than selftests.',
 
4076
                            hidden=True),
3365
4077
                     Option('lsprof-timed',
3366
4078
                            help='Generate lsprof output for benchmarked'
3367
4079
                                 ' sections of code.'),
3368
 
                     Option('cache-dir', type=str,
3369
 
                            help='Cache intermediate benchmark output in this '
3370
 
                                 'directory.'),
 
4080
                     Option('lsprof-tests',
 
4081
                            help='Generate lsprof output for each test.'),
3371
4082
                     Option('first',
3372
4083
                            help='Run all tests, but run specified tests first.',
3373
4084
                            short_name='f',
3382
4093
                     Option('randomize', type=str, argname="SEED",
3383
4094
                            help='Randomize the order of tests using the given'
3384
4095
                                 ' seed or "now" for the current time.'),
3385
 
                     Option('exclude', type=str, argname="PATTERN",
3386
 
                            short_name='x',
3387
 
                            help='Exclude tests that match this regular'
3388
 
                                 ' expression.'),
 
4096
                     ListOption('exclude', type=str, argname="PATTERN",
 
4097
                                short_name='x',
 
4098
                                help='Exclude tests that match this regular'
 
4099
                                ' expression.'),
3389
4100
                     Option('subunit',
3390
4101
                        help='Output test progress via subunit.'),
3391
4102
                     Option('strict', help='Fail on missing dependencies or '
3398
4109
                                param_name='starting_with', short_name='s',
3399
4110
                                help=
3400
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.")
3401
4115
                     ]
3402
4116
    encoding_type = 'replace'
3403
4117
 
3407
4121
 
3408
4122
    def run(self, testspecs_list=None, verbose=False, one=False,
3409
4123
            transport=None, benchmark=None,
3410
 
            lsprof_timed=None, cache_dir=None,
 
4124
            lsprof_timed=None,
3411
4125
            first=False, list_only=False,
3412
4126
            randomize=None, exclude=None, strict=False,
3413
4127
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3414
 
            parallel=None):
3415
 
        from bzrlib.tests import selftest
3416
 
        import bzrlib.benchmarks as benchmarks
3417
 
        from bzrlib.benchmarks import tree_creator
3418
 
 
3419
 
        # Make deprecation warnings visible, unless -Werror is set
3420
 
        symbol_versioning.activate_deprecation_warnings(override=False)
3421
 
 
3422
 
        if cache_dir is not None:
3423
 
            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
 
3424
4141
        if testspecs_list is not None:
3425
4142
            pattern = '|'.join(testspecs_list)
3426
4143
        else:
3429
4146
            try:
3430
4147
                from bzrlib.tests import SubUnitBzrRunner
3431
4148
            except ImportError:
3432
 
                raise errors.BzrCommandError("subunit not available. subunit "
3433
 
                    "needs to be installed to use --subunit.")
 
4149
                raise errors.BzrCommandError(gettext("subunit not available. subunit "
 
4150
                    "needs to be installed to use --subunit."))
3434
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)
3435
4161
        if parallel:
3436
4162
            self.additional_selftest_args.setdefault(
3437
4163
                'suite_decorators', []).append(parallel)
3438
4164
        if benchmark:
3439
 
            test_suite_factory = benchmarks.test_suite
3440
 
            # Unless user explicitly asks for quiet, be verbose in benchmarks
3441
 
            verbose = not is_quiet()
3442
 
            # TODO: should possibly lock the history file...
3443
 
            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
3444
4171
        else:
3445
 
            test_suite_factory = None
3446
 
            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)
3447
4196
        try:
3448
 
            selftest_kwargs = {"verbose": verbose,
3449
 
                              "pattern": pattern,
3450
 
                              "stop_on_failure": one,
3451
 
                              "transport": transport,
3452
 
                              "test_suite_factory": test_suite_factory,
3453
 
                              "lsprof_timed": lsprof_timed,
3454
 
                              "bench_history": benchfile,
3455
 
                              "matching_tests_first": first,
3456
 
                              "list_only": list_only,
3457
 
                              "random_seed": randomize,
3458
 
                              "exclude_pattern": exclude,
3459
 
                              "strict": strict,
3460
 
                              "load_list": load_list,
3461
 
                              "debug_flags": debugflag,
3462
 
                              "starting_with": starting_with
3463
 
                              }
3464
 
            selftest_kwargs.update(self.additional_selftest_args)
3465
 
            result = selftest(**selftest_kwargs)
 
4197
            result = tests.selftest(**selftest_kwargs)
3466
4198
        finally:
3467
 
            if benchfile is not None:
3468
 
                benchfile.close()
 
4199
            cleanup()
3469
4200
        return int(not result)
3470
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
 
3471
4211
 
3472
4212
class cmd_version(Command):
3473
 
    """Show version of bzr."""
 
4213
    __doc__ = """Show version of bzr."""
3474
4214
 
3475
4215
    encoding_type = 'replace'
3476
4216
    takes_options = [
3487
4227
 
3488
4228
 
3489
4229
class cmd_rocks(Command):
3490
 
    """Statement of optimism."""
 
4230
    __doc__ = """Statement of optimism."""
3491
4231
 
3492
4232
    hidden = True
3493
4233
 
3494
4234
    @display_command
3495
4235
    def run(self):
3496
 
        print "It sure does!"
 
4236
        self.outf.write(gettext("It sure does!\n"))
3497
4237
 
3498
4238
 
3499
4239
class cmd_find_merge_base(Command):
3500
 
    """Find and print a base revision for merging two branches."""
 
4240
    __doc__ = """Find and print a base revision for merging two branches."""
3501
4241
    # TODO: Options to specify revisions on either side, as if
3502
4242
    #       merging only part of the history.
3503
4243
    takes_args = ['branch', 'other']
3509
4249
 
3510
4250
        branch1 = Branch.open_containing(branch)[0]
3511
4251
        branch2 = Branch.open_containing(other)[0]
3512
 
        branch1.lock_read()
3513
 
        try:
3514
 
            branch2.lock_read()
3515
 
            try:
3516
 
                last1 = ensure_null(branch1.last_revision())
3517
 
                last2 = ensure_null(branch2.last_revision())
3518
 
 
3519
 
                graph = branch1.repository.get_graph(branch2.repository)
3520
 
                base_rev_id = graph.find_unique_lca(last1, last2)
3521
 
 
3522
 
                print 'merge base is revision %s' % base_rev_id
3523
 
            finally:
3524
 
                branch2.unlock()
3525
 
        finally:
3526
 
            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)
3527
4261
 
3528
4262
 
3529
4263
class cmd_merge(Command):
3530
 
    """Perform a three-way merge.
 
4264
    __doc__ = """Perform a three-way merge.
3531
4265
 
3532
4266
    The source of the merge can be specified either in the form of a branch,
3533
4267
    or in the form of a path to a file containing a merge directive generated
3534
4268
    with bzr send. If neither is specified, the default is the upstream branch
3535
 
    or the branch most recently merged using --remember.
3536
 
 
3537
 
    When merging a branch, by default the tip will be merged. To pick a different
3538
 
    revision, pass --revision. If you specify two values, the first will be used as
3539
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3540
 
    available revisions, like this is commonly referred to as "cherrypicking".
3541
 
 
3542
 
    Revision numbers are always relative to the branch being merged.
3543
 
 
3544
 
    By default, bzr will try to merge in all new work from the other
3545
 
    branch, automatically determining an appropriate base.  If this
3546
 
    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.
3547
4290
 
3548
4291
    Merge will do its best to combine the changes in two branches, but there
3549
4292
    are some kinds of problems only a human can fix.  When it encounters those,
3550
4293
    it will mark a conflict.  A conflict means that you need to fix something,
3551
 
    before you should commit.
 
4294
    before you can commit.
3552
4295
 
3553
4296
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
3554
4297
 
3555
 
    If there is no default branch set, the first merge will set it. After
3556
 
    that, you can omit the branch to use the default.  To change the
3557
 
    default, use --remember. The value will only be saved if the remote
3558
 
    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.
3559
4302
 
3560
4303
    The results of the merge are placed into the destination working
3561
4304
    directory, where they can be reviewed (with bzr diff), tested, and then
3562
4305
    committed to record the result of the merge.
3563
4306
 
3564
4307
    merge refuses to run if there are any uncommitted changes, unless
3565
 
    --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.
3566
4316
 
3567
4317
    To select only some changes to merge, use "merge -i", which will prompt
3568
4318
    you to apply each diff hunk and file change, similar to "shelve".
3569
4319
 
3570
4320
    :Examples:
3571
 
        To merge the latest revision from bzr.dev::
 
4321
        To merge all new revisions from bzr.dev::
3572
4322
 
3573
4323
            bzr merge ../bzr.dev
3574
4324
 
3580
4330
 
3581
4331
            bzr merge -r 81..82 ../bzr.dev
3582
4332
 
3583
 
        To apply a merge directive contained in /tmp/merge:
 
4333
        To apply a merge directive contained in /tmp/merge::
3584
4334
 
3585
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'
3586
4343
    """
3587
4344
 
3588
4345
    encoding_type = 'exact'
3604
4361
                ' completely merged into the source, pull from the'
3605
4362
                ' source rather than merging.  When this happens,'
3606
4363
                ' you do not need to commit the result.'),
3607
 
        Option('directory',
 
4364
        custom_help('directory',
3608
4365
               help='Branch to merge into, '
3609
 
                    'rather than the one containing the working directory.',
3610
 
               short_name='d',
3611
 
               type=unicode,
3612
 
               ),
 
4366
                    'rather than the one containing the working directory.'),
3613
4367
        Option('preview', help='Instead of merging, show a diff of the'
3614
4368
               ' merge.'),
3615
4369
        Option('interactive', help='Select changes interactively.',
3617
4371
    ]
3618
4372
 
3619
4373
    def run(self, location=None, revision=None, force=False,
3620
 
            merge_type=None, show_base=False, reprocess=None, remember=False,
 
4374
            merge_type=None, show_base=False, reprocess=None, remember=None,
3621
4375
            uncommitted=False, pull=False,
3622
4376
            directory=None,
3623
4377
            preview=False,
3631
4385
        merger = None
3632
4386
        allow_pending = True
3633
4387
        verified = 'inapplicable'
 
4388
 
3634
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'))
3635
4393
 
3636
 
        # die as quickly as possible if there are uncommitted changes
3637
4394
        try:
3638
4395
            basis_tree = tree.revision_tree(tree.last_revision())
3639
4396
        except errors.NoSuchRevision:
3640
4397
            basis_tree = tree.basis_tree()
 
4398
 
 
4399
        # die as quickly as possible if there are uncommitted changes
3641
4400
        if not force:
3642
 
            if tree.has_changes(basis_tree):
 
4401
            if tree.has_changes():
3643
4402
                raise errors.UncommittedChanges(tree)
3644
4403
 
3645
4404
        view_info = _get_view_info_for_change_reporter(tree)
3646
4405
        change_reporter = delta._ChangeReporter(
3647
4406
            unversioned_filter=tree.is_ignored, view_info=view_info)
3648
 
        cleanups = []
3649
 
        try:
3650
 
            pb = ui.ui_factory.nested_progress_bar()
3651
 
            cleanups.append(pb.finished)
3652
 
            tree.lock_write()
3653
 
            cleanups.append(tree.unlock)
3654
 
            if location is not None:
3655
 
                try:
3656
 
                    mergeable = bundle.read_mergeable_from_url(location,
3657
 
                        possible_transports=possible_transports)
3658
 
                except errors.NotABundle:
3659
 
                    mergeable = None
3660
 
                else:
3661
 
                    if uncommitted:
3662
 
                        raise errors.BzrCommandError('Cannot use --uncommitted'
3663
 
                            ' with bundles or merge directives.')
3664
 
 
3665
 
                    if revision is not None:
3666
 
                        raise errors.BzrCommandError(
3667
 
                            'Cannot use -r with merge directives or bundles')
3668
 
                    merger, verified = _mod_merge.Merger.from_mergeable(tree,
3669
 
                       mergeable, pb)
3670
 
 
3671
 
            if merger is None and uncommitted:
3672
 
                if revision is not None and len(revision) > 0:
3673
 
                    raise errors.BzrCommandError('Cannot use --uncommitted and'
3674
 
                        ' --revision at the same time.')
3675
 
                merger = self.get_merger_from_uncommitted(tree, location, pb,
3676
 
                                                          cleanups)
3677
 
                allow_pending = False
3678
 
 
3679
 
            if merger is None:
3680
 
                merger, allow_pending = self._get_merger_from_branch(tree,
3681
 
                    location, revision, remember, possible_transports, pb)
3682
 
 
3683
 
            merger.merge_type = merge_type
3684
 
            merger.reprocess = reprocess
3685
 
            merger.show_base = show_base
3686
 
            self.sanity_check_merger(merger)
3687
 
            if (merger.base_rev_id == merger.other_rev_id and
3688
 
                merger.other_rev_id is not None):
3689
 
                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)
3690
4460
                return 0
3691
 
            if pull:
3692
 
                if merger.interesting_files is not None:
3693
 
                    raise errors.BzrCommandError('Cannot pull individual files')
3694
 
                if (merger.base_rev_id == tree.last_revision()):
3695
 
                    result = tree.pull(merger.other_branch, False,
3696
 
                                       merger.other_rev_id)
3697
 
                    result.report(self.outf)
3698
 
                    return 0
3699
 
            merger.check_basis(False)
3700
 
            if preview:
3701
 
                return self._do_preview(merger, cleanups)
3702
 
            elif interactive:
3703
 
                return self._do_interactive(merger, cleanups)
3704
 
            else:
3705
 
                return self._do_merge(merger, change_reporter, allow_pending,
3706
 
                                      verified)
3707
 
        finally:
3708
 
            for cleanup in reversed(cleanups):
3709
 
                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)
3710
4472
 
3711
 
    def _get_preview(self, merger, cleanups):
 
4473
    def _get_preview(self, merger):
3712
4474
        tree_merger = merger.make_merger()
3713
4475
        tt = tree_merger.make_preview_transform()
3714
 
        cleanups.append(tt.finalize)
 
4476
        self.add_cleanup(tt.finalize)
3715
4477
        result_tree = tt.get_preview_tree()
3716
4478
        return result_tree
3717
4479
 
3718
 
    def _do_preview(self, merger, cleanups):
 
4480
    def _do_preview(self, merger):
3719
4481
        from bzrlib.diff import show_diff_trees
3720
 
        result_tree = self._get_preview(merger, cleanups)
 
4482
        result_tree = self._get_preview(merger)
 
4483
        path_encoding = osutils.get_diff_header_encoding()
3721
4484
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3722
 
                        old_label='', new_label='')
 
4485
                        old_label='', new_label='',
 
4486
                        path_encoding=path_encoding)
3723
4487
 
3724
4488
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3725
4489
        merger.change_reporter = change_reporter
3733
4497
        else:
3734
4498
            return 0
3735
4499
 
3736
 
    def _do_interactive(self, merger, cleanups):
 
4500
    def _do_interactive(self, merger):
3737
4501
        """Perform an interactive merge.
3738
4502
 
3739
4503
        This works by generating a preview tree of the merge, then using
3741
4505
        and the preview tree.
3742
4506
        """
3743
4507
        from bzrlib import shelf_ui
3744
 
        result_tree = self._get_preview(merger, cleanups)
 
4508
        result_tree = self._get_preview(merger)
3745
4509
        writer = bzrlib.option.diff_writer_registry.get()
3746
4510
        shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3747
4511
                                   reporter=shelf_ui.ApplyReporter(),
3748
4512
                                   diff_writer=writer(sys.stdout))
3749
 
        shelver.run()
 
4513
        try:
 
4514
            shelver.run()
 
4515
        finally:
 
4516
            shelver.finalize()
3750
4517
 
3751
4518
    def sanity_check_merger(self, merger):
3752
4519
        if (merger.show_base and
3753
4520
            not merger.merge_type is _mod_merge.Merge3Merger):
3754
 
            raise errors.BzrCommandError("Show-base is not supported for this"
3755
 
                                         " 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)
3756
4523
        if merger.reprocess is None:
3757
4524
            if merger.show_base:
3758
4525
                merger.reprocess = False
3760
4527
                # Use reprocess if the merger supports it
3761
4528
                merger.reprocess = merger.merge_type.supports_reprocess
3762
4529
        if merger.reprocess and not merger.merge_type.supports_reprocess:
3763
 
            raise errors.BzrCommandError("Conflict reduction is not supported"
3764
 
                                         " for merge type %s." %
 
4530
            raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
 
4531
                                         " for merge type %s.") %
3765
4532
                                         merger.merge_type)
3766
4533
        if merger.reprocess and merger.show_base:
3767
 
            raise errors.BzrCommandError("Cannot do conflict reduction and"
3768
 
                                         " show base.")
 
4534
            raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
 
4535
                                         " show base."))
3769
4536
 
3770
4537
    def _get_merger_from_branch(self, tree, location, revision, remember,
3771
4538
                                possible_transports, pb):
3798
4565
        if other_revision_id is None:
3799
4566
            other_revision_id = _mod_revision.ensure_null(
3800
4567
                other_branch.last_revision())
3801
 
        # Remember where we merge from
3802
 
        if ((remember or tree.branch.get_submit_branch() is None) and
3803
 
             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)))):
3804
4577
            tree.branch.set_submit_branch(other_branch.base)
3805
 
        _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)
3806
4581
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3807
4582
            other_revision_id, base_revision_id, other_branch, base_branch)
3808
4583
        if other_path != '':
3812
4587
            allow_pending = True
3813
4588
        return merger, allow_pending
3814
4589
 
3815
 
    def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
 
4590
    def get_merger_from_uncommitted(self, tree, location, pb):
3816
4591
        """Get a merger for uncommitted changes.
3817
4592
 
3818
4593
        :param tree: The tree the merger should apply to.
3819
4594
        :param location: The location containing uncommitted changes.
3820
4595
        :param pb: The progress bar to use for showing progress.
3821
 
        :param cleanups: A list of operations to perform to clean up the
3822
 
            temporary directories, unfinalized objects, etc.
3823
4596
        """
3824
4597
        location = self._select_branch_location(tree, location)[0]
3825
4598
        other_tree, other_path = WorkingTree.open_containing(location)
3869
4642
            stored_location_type = "parent"
3870
4643
        mutter("%s", stored_location)
3871
4644
        if stored_location is None:
3872
 
            raise errors.BzrCommandError("No location specified or remembered")
 
4645
            raise errors.BzrCommandError(gettext("No location specified or remembered"))
3873
4646
        display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
3874
 
        note(u"%s remembered %s location %s", verb_string,
3875
 
                stored_location_type, display_url)
 
4647
        note(gettext("{0} remembered {1} location {2}").format(verb_string,
 
4648
                stored_location_type, display_url))
3876
4649
        return stored_location
3877
4650
 
3878
4651
 
3879
4652
class cmd_remerge(Command):
3880
 
    """Redo a merge.
 
4653
    __doc__ = """Redo a merge.
3881
4654
 
3882
4655
    Use this if you want to try a different merge technique while resolving
3883
4656
    conflicts.  Some merge techniques are better than others, and remerge
3908
4681
 
3909
4682
    def run(self, file_list=None, merge_type=None, show_base=False,
3910
4683
            reprocess=False):
 
4684
        from bzrlib.conflicts import restore
3911
4685
        if merge_type is None:
3912
4686
            merge_type = _mod_merge.Merge3Merger
3913
 
        tree, file_list = tree_files(file_list)
3914
 
        tree.lock_write()
3915
 
        try:
3916
 
            parents = tree.get_parent_ids()
3917
 
            if len(parents) != 2:
3918
 
                raise errors.BzrCommandError("Sorry, remerge only works after normal"
3919
 
                                             " merges.  Not cherrypicking or"
3920
 
                                             " multi-merges.")
3921
 
            repository = tree.branch.repository
3922
 
            interesting_ids = None
3923
 
            new_conflicts = []
3924
 
            conflicts = tree.conflicts()
3925
 
            if file_list is not None:
3926
 
                interesting_ids = set()
3927
 
                for filename in file_list:
3928
 
                    file_id = tree.path2id(filename)
3929
 
                    if file_id is None:
3930
 
                        raise errors.NotVersionedError(filename)
3931
 
                    interesting_ids.add(file_id)
3932
 
                    if tree.kind(file_id) != "directory":
3933
 
                        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
3934
4707
 
3935
 
                    for name, ie in tree.inventory.iter_entries(file_id):
3936
 
                        interesting_ids.add(ie.file_id)
3937
 
                new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3938
 
            else:
3939
 
                # Remerge only supports resolving contents conflicts
3940
 
                allowed_conflicts = ('text conflict', 'contents conflict')
3941
 
                restore_files = [c.path for c in conflicts
3942
 
                                 if c.typestring in allowed_conflicts]
3943
 
            _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3944
 
            tree.set_conflicts(ConflictList(new_conflicts))
3945
 
            if file_list is not None:
3946
 
                restore_files = file_list
3947
 
            for filename in restore_files:
3948
 
                try:
3949
 
                    restore(tree.abspath(filename))
3950
 
                except errors.NotConflicted:
3951
 
                    pass
3952
 
            # Disable pending merges, because the file texts we are remerging
3953
 
            # have not had those merges performed.  If we use the wrong parents
3954
 
            # list, we imply that the working tree text has seen and rejected
3955
 
            # all the changes from the other tree, when in fact those changes
3956
 
            # have not yet been seen.
3957
 
            pb = ui.ui_factory.nested_progress_bar()
3958
 
            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:
3959
4722
            try:
3960
 
                merger = _mod_merge.Merger.from_revision_ids(pb,
3961
 
                                                             tree, parents[1])
3962
 
                merger.interesting_ids = interesting_ids
3963
 
                merger.merge_type = merge_type
3964
 
                merger.show_base = show_base
3965
 
                merger.reprocess = reprocess
3966
 
                conflicts = merger.do_merge()
3967
 
            finally:
3968
 
                tree.set_parent_ids(parents)
3969
 
                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()
3970
4739
        finally:
3971
 
            tree.unlock()
 
4740
            tree.set_parent_ids(parents)
3972
4741
        if conflicts > 0:
3973
4742
            return 1
3974
4743
        else:
3976
4745
 
3977
4746
 
3978
4747
class cmd_revert(Command):
3979
 
    """Revert files to a previous revision.
 
4748
    __doc__ = """\
 
4749
    Set files in the working tree back to the contents of a previous revision.
3980
4750
 
3981
4751
    Giving a list of files will revert only those files.  Otherwise, all files
3982
4752
    will be reverted.  If the revision is not specified with '--revision', the
3983
 
    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.
3984
4756
 
3985
4757
    To remove only some changes, without reverting to a prior version, use
3986
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
3987
 
    changes introduced by -2, without affecting the changes introduced by -1.
3988
 
    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.
3989
4765
 
3990
 
    By default, any files that have been manually changed will be backed up
3991
 
    first.  (Files changed only by merge are not backed up.)  Backup files have
3992
 
    '.~#~' 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.
3993
4770
 
3994
4771
    When you provide files, you can use their current pathname or the pathname
3995
4772
    from the target revision.  So you can use revert to "undelete" a file by
3996
4773
    name.  If you name a directory, all the contents of that directory will be
3997
4774
    reverted.
3998
4775
 
3999
 
    Any files that have been newly added since that revision will be deleted,
4000
 
    with a backup kept if appropriate.  Directories containing unknown files
4001
 
    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.
4002
4780
 
4003
 
    The working tree contains a list of pending merged revisions, which will
4004
 
    be included as parents in the next commit.  Normally, revert clears that
4005
 
    list as well as reverting the files.  If any files are specified, revert
4006
 
    leaves the pending merge list alone and reverts only the files.  Use "bzr
4007
 
    revert ." in the tree root to revert all files but keep the merge record,
4008
 
    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
4009
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.
4010
4799
    """
4011
4800
 
4012
 
    _see_also = ['cat', 'export']
 
4801
    _see_also = ['cat', 'export', 'merge', 'shelve']
4013
4802
    takes_options = [
4014
4803
        'revision',
4015
4804
        Option('no-backup', "Do not save backups of reverted files."),
4020
4809
 
4021
4810
    def run(self, revision=None, no_backup=False, file_list=None,
4022
4811
            forget_merges=None):
4023
 
        tree, file_list = tree_files(file_list)
4024
 
        tree.lock_write()
4025
 
        try:
4026
 
            if forget_merges:
4027
 
                tree.set_parent_ids(tree.get_parent_ids()[:1])
4028
 
            else:
4029
 
                self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4030
 
        finally:
4031
 
            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)
4032
4818
 
4033
4819
    @staticmethod
4034
4820
    def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4035
4821
        rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4036
 
        pb = ui.ui_factory.nested_progress_bar()
4037
 
        try:
4038
 
            tree.revert(file_list, rev_tree, not no_backup, pb,
4039
 
                report_changes=True)
4040
 
        finally:
4041
 
            pb.finished()
 
4822
        tree.revert(file_list, rev_tree, not no_backup, None,
 
4823
            report_changes=True)
4042
4824
 
4043
4825
 
4044
4826
class cmd_assert_fail(Command):
4045
 
    """Test reporting of assertion failures"""
 
4827
    __doc__ = """Test reporting of assertion failures"""
4046
4828
    # intended just for use in testing
4047
4829
 
4048
4830
    hidden = True
4052
4834
 
4053
4835
 
4054
4836
class cmd_help(Command):
4055
 
    """Show help on a command or other topic.
 
4837
    __doc__ = """Show help on a command or other topic.
4056
4838
    """
4057
4839
 
4058
4840
    _see_also = ['topics']
4071
4853
 
4072
4854
 
4073
4855
class cmd_shell_complete(Command):
4074
 
    """Show appropriate completions for context.
 
4856
    __doc__ = """Show appropriate completions for context.
4075
4857
 
4076
4858
    For a list of all available commands, say 'bzr shell-complete'.
4077
4859
    """
4081
4863
 
4082
4864
    @display_command
4083
4865
    def run(self, context=None):
4084
 
        import shellcomplete
 
4866
        from bzrlib import shellcomplete
4085
4867
        shellcomplete.shellcomplete(context)
4086
4868
 
4087
4869
 
4088
4870
class cmd_missing(Command):
4089
 
    """Show unmerged/unpulled revisions between two branches.
 
4871
    __doc__ = """Show unmerged/unpulled revisions between two branches.
4090
4872
 
4091
4873
    OTHER_BRANCH may be local or remote.
4092
4874
 
4093
4875
    To filter on a range of revisions, you can use the command -r begin..end
4094
4876
    -r revision requests a specific revision, -r ..end or -r begin.. are
4095
4877
    also valid.
 
4878
            
 
4879
    :Exit values:
 
4880
        1 - some missing revisions
 
4881
        0 - no missing revisions
4096
4882
 
4097
4883
    :Examples:
4098
4884
 
4119
4905
    _see_also = ['merge', 'pull']
4120
4906
    takes_args = ['other_branch?']
4121
4907
    takes_options = [
 
4908
        'directory',
4122
4909
        Option('reverse', 'Reverse the order of revisions.'),
4123
4910
        Option('mine-only',
4124
4911
               'Display changes in the local branch only.'),
4136
4923
            type=_parse_revision_str,
4137
4924
            help='Filter on local branch revisions (inclusive). '
4138
4925
                'See "help revisionspec" for details.'),
4139
 
        Option('include-merges',
 
4926
        Option('include-merged',
4140
4927
               'Show all revisions in addition to the mainline ones.'),
 
4928
        Option('include-merges', hidden=True,
 
4929
               help='Historical alias for --include-merged.'),
4141
4930
        ]
4142
4931
    encoding_type = 'replace'
4143
4932
 
4146
4935
            theirs_only=False,
4147
4936
            log_format=None, long=False, short=False, line=False,
4148
4937
            show_ids=False, verbose=False, this=False, other=False,
4149
 
            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):
4150
4941
        from bzrlib.missing import find_unmerged, iter_log_revisions
4151
4942
        def message(s):
4152
4943
            if not is_quiet():
4153
4944
                self.outf.write(s)
4154
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
4155
4961
        if this:
4156
4962
            mine_only = this
4157
4963
        if other:
4165
4971
        elif theirs_only:
4166
4972
            restrict = 'remote'
4167
4973
 
4168
 
        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
 
4169
4977
        parent = local_branch.get_parent()
4170
4978
        if other_branch is None:
4171
4979
            other_branch = parent
4172
4980
            if other_branch is None:
4173
 
                raise errors.BzrCommandError("No peer location known"
4174
 
                                             " or specified.")
 
4981
                raise errors.BzrCommandError(gettext("No peer location known"
 
4982
                                             " or specified."))
4175
4983
            display_url = urlutils.unescape_for_display(parent,
4176
4984
                                                        self.outf.encoding)
4177
 
            message("Using saved parent location: "
4178
 
                    + display_url + "\n")
 
4985
            message(gettext("Using saved parent location: {0}\n").format(
 
4986
                    display_url))
4179
4987
 
4180
4988
        remote_branch = Branch.open(other_branch)
4181
4989
        if remote_branch.base == local_branch.base:
4182
4990
            remote_branch = local_branch
 
4991
        else:
 
4992
            self.add_cleanup(remote_branch.lock_read().unlock)
4183
4993
 
4184
4994
        local_revid_range = _revision_range_to_revid_range(
4185
4995
            _get_revision_range(my_revision, local_branch,
4189
4999
            _get_revision_range(revision,
4190
5000
                remote_branch, self.name()))
4191
5001
 
4192
 
        local_branch.lock_read()
4193
 
        try:
4194
 
            remote_branch.lock_read()
4195
 
            try:
4196
 
                local_extra, remote_extra = find_unmerged(
4197
 
                    local_branch, remote_branch, restrict,
4198
 
                    backward=not reverse,
4199
 
                    include_merges=include_merges,
4200
 
                    local_revid_range=local_revid_range,
4201
 
                    remote_revid_range=remote_revid_range)
4202
 
 
4203
 
                if log_format is None:
4204
 
                    registry = log.log_formatter_registry
4205
 
                    log_format = registry.get_default(local_branch)
4206
 
                lf = log_format(to_file=self.outf,
4207
 
                                show_ids=show_ids,
4208
 
                                show_timezone='original')
4209
 
 
4210
 
                status_code = 0
4211
 
                if local_extra and not theirs_only:
4212
 
                    message("You have %d extra revision(s):\n" %
4213
 
                        len(local_extra))
4214
 
                    for revision in iter_log_revisions(local_extra,
4215
 
                                        local_branch.repository,
4216
 
                                        verbose):
4217
 
                        lf.log_revision(revision)
4218
 
                    printed_local = True
4219
 
                    status_code = 1
4220
 
                else:
4221
 
                    printed_local = False
4222
 
 
4223
 
                if remote_extra and not mine_only:
4224
 
                    if printed_local is True:
4225
 
                        message("\n\n\n")
4226
 
                    message("You are missing %d revision(s):\n" %
4227
 
                        len(remote_extra))
4228
 
                    for revision in iter_log_revisions(remote_extra,
4229
 
                                        remote_branch.repository,
4230
 
                                        verbose):
4231
 
                        lf.log_revision(revision)
4232
 
                    status_code = 1
4233
 
 
4234
 
                if mine_only and not local_extra:
4235
 
                    # We checked local, and found nothing extra
4236
 
                    message('This branch is up to date.\n')
4237
 
                elif theirs_only and not remote_extra:
4238
 
                    # We checked remote, and found nothing extra
4239
 
                    message('Other branch is up to date.\n')
4240
 
                elif not (mine_only or theirs_only or local_extra or
4241
 
                          remote_extra):
4242
 
                    # We checked both branches, and neither one had extra
4243
 
                    # revisions
4244
 
                    message("Branches are up to date.\n")
4245
 
            finally:
4246
 
                remote_branch.unlock()
4247
 
        finally:
4248
 
            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()
4249
5063
        if not status_code and parent is None and other_branch is not None:
4250
 
            local_branch.lock_write()
4251
 
            try:
4252
 
                # handle race conditions - a parent might be set while we run.
4253
 
                if local_branch.get_parent() is None:
4254
 
                    local_branch.set_parent(remote_branch.base)
4255
 
            finally:
4256
 
                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)
4257
5068
        return status_code
4258
5069
 
4259
5070
 
4260
5071
class cmd_pack(Command):
4261
 
    """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
    """
4262
5089
 
4263
5090
    _see_also = ['repositories']
4264
5091
    takes_args = ['branch_or_repo?']
 
5092
    takes_options = [
 
5093
        Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
 
5094
        ]
4265
5095
 
4266
 
    def run(self, branch_or_repo='.'):
4267
 
        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]
4268
5098
        try:
4269
5099
            branch = dir.open_branch()
4270
5100
            repository = branch.repository
4271
5101
        except errors.NotBranchError:
4272
5102
            repository = dir.open_repository()
4273
 
        repository.pack()
 
5103
        repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4274
5104
 
4275
5105
 
4276
5106
class cmd_plugins(Command):
4277
 
    """List the installed plugins.
 
5107
    __doc__ = """List the installed plugins.
4278
5108
 
4279
5109
    This command displays the list of installed plugins including
4280
5110
    version of plugin and a short description of each.
4287
5117
    adding new commands, providing additional network transports and
4288
5118
    customizing log output.
4289
5119
 
4290
 
    See the Bazaar web site, http://bazaar-vcs.org, for further
4291
 
    information on plugins including where to find them and how to
4292
 
    install them. Instructions are also provided there on how to
4293
 
    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.
4294
5124
    """
4295
5125
    takes_options = ['verbose']
4296
5126
 
4297
5127
    @display_command
4298
5128
    def run(self, verbose=False):
4299
 
        import bzrlib.plugin
4300
 
        from inspect import getdoc
4301
 
        result = []
4302
 
        for name, plugin in bzrlib.plugin.plugins().items():
4303
 
            version = plugin.__version__
4304
 
            if version == 'unknown':
4305
 
                version = ''
4306
 
            name_ver = '%s %s' % (name, version)
4307
 
            d = getdoc(plugin.module)
4308
 
            if d:
4309
 
                doc = d.split('\n')[0]
4310
 
            else:
4311
 
                doc = '(no description)'
4312
 
            result.append((name_ver, doc, plugin.path()))
4313
 
        for name_ver, doc, path in sorted(result):
4314
 
            print name_ver
4315
 
            print '   ', doc
4316
 
            if verbose:
4317
 
                print '   ', path
4318
 
            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)))
4319
5133
 
4320
5134
 
4321
5135
class cmd_testament(Command):
4322
 
    """Show testament (signing-form) of a revision."""
 
5136
    __doc__ = """Show testament (signing-form) of a revision."""
4323
5137
    takes_options = [
4324
5138
            'revision',
4325
5139
            Option('long', help='Produce long-format testament.'),
4326
5140
            Option('strict',
4327
5141
                   help='Produce a strict-format testament.')]
4328
5142
    takes_args = ['branch?']
 
5143
    encoding_type = 'exact'
4329
5144
    @display_command
4330
5145
    def run(self, branch=u'.', revision=None, long=False, strict=False):
4331
5146
        from bzrlib.testament import Testament, StrictTestament
4337
5152
            b = Branch.open_containing(branch)[0]
4338
5153
        else:
4339
5154
            b = Branch.open(branch)
4340
 
        b.lock_read()
4341
 
        try:
4342
 
            if revision is None:
4343
 
                rev_id = b.last_revision()
4344
 
            else:
4345
 
                rev_id = revision[0].as_revision_id(b)
4346
 
            t = testament_class.from_revision(b.repository, rev_id)
4347
 
            if long:
4348
 
                sys.stdout.writelines(t.as_text_lines())
4349
 
            else:
4350
 
                sys.stdout.write(t.as_short_text())
4351
 
        finally:
4352
 
            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())
4353
5165
 
4354
5166
 
4355
5167
class cmd_annotate(Command):
4356
 
    """Show the origin of each line in a file.
 
5168
    __doc__ = """Show the origin of each line in a file.
4357
5169
 
4358
5170
    This prints out the given file with an annotation on the left side
4359
5171
    indicating which revision, author and date introduced the change.
4370
5182
                     Option('long', help='Show commit date in annotations.'),
4371
5183
                     'revision',
4372
5184
                     'show-ids',
 
5185
                     'directory',
4373
5186
                     ]
4374
5187
    encoding_type = 'exact'
4375
5188
 
4376
5189
    @display_command
4377
5190
    def run(self, filename, all=False, long=False, revision=None,
4378
 
            show_ids=False):
4379
 
        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
            )
4380
5195
        wt, branch, relpath = \
4381
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
5196
            _open_directory_or_containing_tree_or_branch(filename, directory)
4382
5197
        if wt is not None:
4383
 
            wt.lock_read()
4384
 
        else:
4385
 
            branch.lock_read()
4386
 
        try:
4387
 
            tree = _get_one_revision_tree('annotate', revision, branch=branch)
4388
 
            if wt is not None:
4389
 
                file_id = wt.path2id(relpath)
4390
 
            else:
4391
 
                file_id = tree.path2id(relpath)
4392
 
            if file_id is None:
4393
 
                raise errors.NotVersionedError(filename)
4394
 
            file_version = tree.inventory[file_id].revision
4395
 
            if wt is not None and revision is None:
4396
 
                # If there is a tree and we're not annotating historical
4397
 
                # versions, annotate the working tree's content.
4398
 
                annotate_file_tree(wt, file_id, self.outf, long, all,
4399
 
                    show_ids=show_ids)
4400
 
            else:
4401
 
                annotate_file(branch, file_version, file_id, long, all, self.outf,
4402
 
                              show_ids=show_ids)
4403
 
        finally:
4404
 
            if wt is not None:
4405
 
                wt.unlock()
4406
 
            else:
4407
 
                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)
4408
5217
 
4409
5218
 
4410
5219
class cmd_re_sign(Command):
4411
 
    """Create a digital signature for an existing revision."""
 
5220
    __doc__ = """Create a digital signature for an existing revision."""
4412
5221
    # TODO be able to replace existing ones.
4413
5222
 
4414
5223
    hidden = True # is this right ?
4415
5224
    takes_args = ['revision_id*']
4416
 
    takes_options = ['revision']
 
5225
    takes_options = ['directory', 'revision']
4417
5226
 
4418
 
    def run(self, revision_id_list=None, revision=None):
 
5227
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4419
5228
        if revision_id_list is not None and revision is not None:
4420
 
            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'))
4421
5230
        if revision_id_list is None and revision is None:
4422
 
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4423
 
        b = WorkingTree.open_containing(u'.')[0].branch
4424
 
        b.lock_write()
4425
 
        try:
4426
 
            return self._run(b, revision_id_list, revision)
4427
 
        finally:
4428
 
            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)
4429
5235
 
4430
5236
    def _run(self, b, revision_id_list, revision):
4431
5237
        import bzrlib.gpg as gpg
4432
 
        gpg_strategy = gpg.GPGStrategy(b.get_config())
 
5238
        gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4433
5239
        if revision_id_list is not None:
4434
5240
            b.repository.start_write_group()
4435
5241
            try:
4460
5266
                if to_revid is None:
4461
5267
                    to_revno = b.revno()
4462
5268
                if from_revno is None or to_revno is None:
4463
 
                    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'))
4464
5270
                b.repository.start_write_group()
4465
5271
                try:
4466
5272
                    for revno in range(from_revno, to_revno + 1):
4472
5278
                else:
4473
5279
                    b.repository.commit_write_group()
4474
5280
            else:
4475
 
                raise errors.BzrCommandError('Please supply either one revision, or a range.')
 
5281
                raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4476
5282
 
4477
5283
 
4478
5284
class cmd_bind(Command):
4479
 
    """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.
4480
5287
 
4481
5288
    Once converted into a checkout, commits must succeed on the master branch
4482
5289
    before they will be applied to the local branch.
4483
5290
 
4484
5291
    Bound branches use the nickname of its master branch unless it is set
4485
 
    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
4486
5293
    that of the master.
4487
5294
    """
4488
5295
 
4489
5296
    _see_also = ['checkouts', 'unbind']
4490
5297
    takes_args = ['location?']
4491
 
    takes_options = []
 
5298
    takes_options = ['directory']
4492
5299
 
4493
 
    def run(self, location=None):
4494
 
        b, relpath = Branch.open_containing(u'.')
 
5300
    def run(self, location=None, directory=u'.'):
 
5301
        b, relpath = Branch.open_containing(directory)
4495
5302
        if location is None:
4496
5303
            try:
4497
5304
                location = b.get_old_bound_location()
4498
5305
            except errors.UpgradeRequired:
4499
 
                raise errors.BzrCommandError('No location supplied.  '
4500
 
                    'This format does not remember old locations.')
 
5306
                raise errors.BzrCommandError(gettext('No location supplied.  '
 
5307
                    'This format does not remember old locations.'))
4501
5308
            else:
4502
5309
                if location is None:
4503
 
                    raise errors.BzrCommandError('No location supplied and no '
4504
 
                        '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'))
4505
5317
        b_other = Branch.open(location)
4506
5318
        try:
4507
5319
            b.bind(b_other)
4508
5320
        except errors.DivergedBranches:
4509
 
            raise errors.BzrCommandError('These branches have diverged.'
4510
 
                                         ' Try merging, and then bind again.')
 
5321
            raise errors.BzrCommandError(gettext('These branches have diverged.'
 
5322
                                         ' Try merging, and then bind again.'))
4511
5323
        if b.get_config().has_explicit_nickname():
4512
5324
            b.nick = b_other.nick
4513
5325
 
4514
5326
 
4515
5327
class cmd_unbind(Command):
4516
 
    """Convert the current checkout into a regular branch.
 
5328
    __doc__ = """Convert the current checkout into a regular branch.
4517
5329
 
4518
5330
    After unbinding, the local branch is considered independent and subsequent
4519
5331
    commits will be local only.
4521
5333
 
4522
5334
    _see_also = ['checkouts', 'bind']
4523
5335
    takes_args = []
4524
 
    takes_options = []
 
5336
    takes_options = ['directory']
4525
5337
 
4526
 
    def run(self):
4527
 
        b, relpath = Branch.open_containing(u'.')
 
5338
    def run(self, directory=u'.'):
 
5339
        b, relpath = Branch.open_containing(directory)
4528
5340
        if not b.unbind():
4529
 
            raise errors.BzrCommandError('Local branch is not bound')
 
5341
            raise errors.BzrCommandError(gettext('Local branch is not bound'))
4530
5342
 
4531
5343
 
4532
5344
class cmd_uncommit(Command):
4533
 
    """Remove the last committed revision.
 
5345
    __doc__ = """Remove the last committed revision.
4534
5346
 
4535
5347
    --verbose will print out what is being removed.
4536
5348
    --dry-run will go through all the motions, but not actually
4553
5365
    takes_options = ['verbose', 'revision',
4554
5366
                    Option('dry-run', help='Don\'t actually make changes.'),
4555
5367
                    Option('force', help='Say yes to all questions.'),
 
5368
                    Option('keep-tags',
 
5369
                           help='Keep tags that point to removed revisions.'),
4556
5370
                    Option('local',
4557
5371
                           help="Only remove the commits from the local branch"
4558
5372
                                " when in a checkout."
4562
5376
    aliases = []
4563
5377
    encoding_type = 'replace'
4564
5378
 
4565
 
    def run(self, location=None,
4566
 
            dry_run=False, verbose=False,
4567
 
            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):
4568
5381
        if location is None:
4569
5382
            location = u'.'
4570
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
5383
        control, relpath = controldir.ControlDir.open_containing(location)
4571
5384
        try:
4572
5385
            tree = control.open_workingtree()
4573
5386
            b = tree.branch
4576
5389
            b = control.open_branch()
4577
5390
 
4578
5391
        if tree is not None:
4579
 
            tree.lock_write()
 
5392
            self.add_cleanup(tree.lock_write().unlock)
4580
5393
        else:
4581
 
            b.lock_write()
4582
 
        try:
4583
 
            return self._run(b, tree, dry_run, verbose, revision, force,
4584
 
                             local=local)
4585
 
        finally:
4586
 
            if tree is not None:
4587
 
                tree.unlock()
4588
 
            else:
4589
 
                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)
4590
5397
 
4591
 
    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):
4592
5400
        from bzrlib.log import log_formatter, show_log
4593
5401
        from bzrlib.uncommit import uncommit
4594
5402
 
4609
5417
                rev_id = b.get_rev_id(revno)
4610
5418
 
4611
5419
        if rev_id is None or _mod_revision.is_null(rev_id):
4612
 
            self.outf.write('No revisions to uncommit.\n')
 
5420
            self.outf.write(gettext('No revisions to uncommit.\n'))
4613
5421
            return 1
4614
5422
 
4615
5423
        lf = log_formatter('short',
4624
5432
                 end_revision=last_revno)
4625
5433
 
4626
5434
        if dry_run:
4627
 
            print 'Dry-run, pretending to remove the above revisions.'
4628
 
            if not force:
4629
 
                val = raw_input('Press <enter> to continue')
 
5435
            self.outf.write(gettext('Dry-run, pretending to remove'
 
5436
                            ' the above revisions.\n'))
4630
5437
        else:
4631
 
            print 'The above revision(s) will be removed.'
4632
 
            if not force:
4633
 
                val = raw_input('Are you sure [y/N]? ')
4634
 
                if val.lower() not in ('y', 'yes'):
4635
 
                    print 'Canceled'
4636
 
                    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
4637
5447
 
4638
5448
        mutter('Uncommitting from {%s} to {%s}',
4639
5449
               last_rev_id, rev_id)
4640
5450
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4641
 
                 revno=revno, local=local)
4642
 
        note('You can restore the old tip by running:\n'
4643
 
             '  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)
4644
5454
 
4645
5455
 
4646
5456
class cmd_break_lock(Command):
4647
 
    """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.
4648
5461
 
4649
5462
    CAUTION: Locks should only be broken when you are sure that the process
4650
5463
    holding the lock has been stopped.
4651
5464
 
4652
 
    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.
4653
5467
 
4654
5468
    :Examples:
4655
5469
        bzr break-lock
 
5470
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
5471
        bzr break-lock --conf ~/.bazaar
4656
5472
    """
 
5473
 
4657
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
        ]
4658
5481
 
4659
 
    def run(self, location=None, show=False):
 
5482
    def run(self, location=None, config=False, force=False):
4660
5483
        if location is None:
4661
5484
            location = u'.'
4662
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4663
 
        try:
4664
 
            control.break_lock()
4665
 
        except NotImplementedError:
4666
 
            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
4667
5498
 
4668
5499
 
4669
5500
class cmd_wait_until_signalled(Command):
4670
 
    """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
5501
    __doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4671
5502
 
4672
5503
    This just prints a line to signal when it is ready, then blocks on stdin.
4673
5504
    """
4681
5512
 
4682
5513
 
4683
5514
class cmd_serve(Command):
4684
 
    """Run the bzr server."""
 
5515
    __doc__ = """Run the bzr server."""
4685
5516
 
4686
5517
    aliases = ['server']
4687
5518
 
4688
5519
    takes_options = [
4689
5520
        Option('inet',
4690
5521
               help='Serve on stdin/out for use from inetd or sshd.'),
4691
 
        RegistryOption('protocol', 
4692
 
               help="Protocol to serve.", 
 
5522
        RegistryOption('protocol',
 
5523
               help="Protocol to serve.",
4693
5524
               lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4694
5525
               value_switches=True),
 
5526
        Option('listen',
 
5527
               help='Listen for connections on nominated address.', type=str),
4695
5528
        Option('port',
4696
 
               help='Listen for connections on nominated port of the form '
4697
 
                    '[hostname:]portnumber.  Passing 0 as the port number will '
4698
 
                    'result in a dynamically allocated port.  The default port '
4699
 
                    'depends on the protocol.',
4700
 
               type=str),
4701
 
        Option('directory',
4702
 
               help='Serve contents of this directory.',
4703
 
               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.'),
4704
5535
        Option('allow-writes',
4705
5536
               help='By default the server is a readonly server.  Supplying '
4706
5537
                    '--allow-writes enables write access to the contents of '
4707
 
                    '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.'
4708
5543
                ),
 
5544
        Option('client-timeout', type=float,
 
5545
               help='Override the default idle client timeout (5min).'),
4709
5546
        ]
4710
5547
 
4711
 
    def get_host_and_port(self, port):
4712
 
        """Return the host and port to run the smart server on.
4713
 
 
4714
 
        If 'port' is None, None will be returned for the host and port.
4715
 
 
4716
 
        If 'port' has a colon in it, the string before the colon will be
4717
 
        interpreted as the host.
4718
 
 
4719
 
        :param port: A string of the port to run the server on.
4720
 
        :return: A tuple of (host, port), where 'host' is a host name or IP,
4721
 
            and port is an integer TCP/IP port.
4722
 
        """
4723
 
        host = None
4724
 
        if port is not None:
4725
 
            if ':' in port:
4726
 
                host, port = port.split(':')
4727
 
            port = int(port)
4728
 
        return host, port
4729
 
 
4730
 
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4731
 
            protocol=None):
4732
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5548
    def run(self, listen=None, port=None, inet=False, directory=None,
 
5549
            allow_writes=False, protocol=None, client_timeout=None):
 
5550
        from bzrlib import transport
4733
5551
        if directory is None:
4734
5552
            directory = os.getcwd()
4735
5553
        if protocol is None:
4736
 
            protocol = transport_server_registry.get()
4737
 
        host, port = self.get_host_and_port(port)
4738
 
        url = urlutils.local_path_to_url(directory)
 
5554
            protocol = transport.transport_server_registry.get()
 
5555
        url = transport.location_to_url(directory)
4739
5556
        if not allow_writes:
4740
5557
            url = 'readonly+' + url
4741
 
        transport = get_transport(url)
4742
 
        protocol(transport, host, port, inet)
 
5558
        t = transport.get_transport_from_url(url)
 
5559
        protocol(t, listen, port, inet, client_timeout)
4743
5560
 
4744
5561
 
4745
5562
class cmd_join(Command):
4746
 
    """Combine a tree into its containing tree.
 
5563
    __doc__ = """Combine a tree into its containing tree.
4747
5564
 
4748
5565
    This command requires the target tree to be in a rich-root format.
4749
5566
 
4751
5568
    not part of it.  (Such trees can be produced by "bzr split", but also by
4752
5569
    running "bzr branch" with the target inside a tree.)
4753
5570
 
4754
 
    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
4755
5572
    part.  This is marked as a merge of the subtree into the containing tree,
4756
5573
    and all history is preserved.
4757
5574
    """
4768
5585
        containing_tree = WorkingTree.open_containing(parent_dir)[0]
4769
5586
        repo = containing_tree.branch.repository
4770
5587
        if not repo.supports_rich_root():
4771
 
            raise errors.BzrCommandError(
 
5588
            raise errors.BzrCommandError(gettext(
4772
5589
                "Can't join trees because %s doesn't support rich root data.\n"
4773
 
                "You can use bzr upgrade on the repository."
 
5590
                "You can use bzr upgrade on the repository.")
4774
5591
                % (repo,))
4775
5592
        if reference:
4776
5593
            try:
4778
5595
            except errors.BadReferenceTarget, e:
4779
5596
                # XXX: Would be better to just raise a nicely printable
4780
5597
                # exception from the real origin.  Also below.  mbp 20070306
4781
 
                raise errors.BzrCommandError("Cannot join %s.  %s" %
4782
 
                                             (tree, e.reason))
 
5598
                raise errors.BzrCommandError(
 
5599
                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
4783
5600
        else:
4784
5601
            try:
4785
5602
                containing_tree.subsume(sub_tree)
4786
5603
            except errors.BadSubsumeSource, e:
4787
 
                raise errors.BzrCommandError("Cannot join %s.  %s" %
4788
 
                                             (tree, e.reason))
 
5604
                raise errors.BzrCommandError(
 
5605
                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
4789
5606
 
4790
5607
 
4791
5608
class cmd_split(Command):
4792
 
    """Split a subdirectory of a tree into a separate tree.
 
5609
    __doc__ = """Split a subdirectory of a tree into a separate tree.
4793
5610
 
4794
5611
    This command will produce a target tree in a format that supports
4795
5612
    rich roots, like 'rich-root' or 'rich-root-pack'.  These formats cannot be
4815
5632
 
4816
5633
 
4817
5634
class cmd_merge_directive(Command):
4818
 
    """Generate a merge directive for auto-merge tools.
 
5635
    __doc__ = """Generate a merge directive for auto-merge tools.
4819
5636
 
4820
5637
    A directive requests a merge to be performed, and also provides all the
4821
5638
    information necessary to do so.  This means it must either include a
4838
5655
    _see_also = ['send']
4839
5656
 
4840
5657
    takes_options = [
 
5658
        'directory',
4841
5659
        RegistryOption.from_kwargs('patch-type',
4842
5660
            'The type of patch to include in the directive.',
4843
5661
            title='Patch type',
4856
5674
    encoding_type = 'exact'
4857
5675
 
4858
5676
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4859
 
            sign=False, revision=None, mail_to=None, message=None):
 
5677
            sign=False, revision=None, mail_to=None, message=None,
 
5678
            directory=u'.'):
4860
5679
        from bzrlib.revision import ensure_null, NULL_REVISION
4861
5680
        include_patch, include_bundle = {
4862
5681
            'plain': (False, False),
4863
5682
            'diff': (True, False),
4864
5683
            'bundle': (True, True),
4865
5684
            }[patch_type]
4866
 
        branch = Branch.open('.')
 
5685
        branch = Branch.open(directory)
4867
5686
        stored_submit_branch = branch.get_submit_branch()
4868
5687
        if submit_branch is None:
4869
5688
            submit_branch = stored_submit_branch
4873
5692
        if submit_branch is None:
4874
5693
            submit_branch = branch.get_parent()
4875
5694
        if submit_branch is None:
4876
 
            raise errors.BzrCommandError('No submit branch specified or known')
 
5695
            raise errors.BzrCommandError(gettext('No submit branch specified or known'))
4877
5696
 
4878
5697
        stored_public_branch = branch.get_public_branch()
4879
5698
        if public_branch is None:
4880
5699
            public_branch = stored_public_branch
4881
5700
        elif stored_public_branch is None:
 
5701
            # FIXME: Should be done only if we succeed ? -- vila 2012-01-03
4882
5702
            branch.set_public_branch(public_branch)
4883
5703
        if not include_bundle and public_branch is None:
4884
 
            raise errors.BzrCommandError('No public branch specified or'
4885
 
                                         ' known')
 
5704
            raise errors.BzrCommandError(gettext('No public branch specified or'
 
5705
                                         ' known'))
4886
5706
        base_revision_id = None
4887
5707
        if revision is not None:
4888
5708
            if len(revision) > 2:
4889
 
                raise errors.BzrCommandError('bzr merge-directive takes '
4890
 
                    'at most two one revision identifiers')
 
5709
                raise errors.BzrCommandError(gettext('bzr merge-directive takes '
 
5710
                    'at most two one revision identifiers'))
4891
5711
            revision_id = revision[-1].as_revision_id(branch)
4892
5712
            if len(revision) == 2:
4893
5713
                base_revision_id = revision[0].as_revision_id(branch)
4895
5715
            revision_id = branch.last_revision()
4896
5716
        revision_id = ensure_null(revision_id)
4897
5717
        if revision_id == NULL_REVISION:
4898
 
            raise errors.BzrCommandError('No revisions to bundle.')
 
5718
            raise errors.BzrCommandError(gettext('No revisions to bundle.'))
4899
5719
        directive = merge_directive.MergeDirective2.from_objects(
4900
5720
            branch.repository, revision_id, time.time(),
4901
5721
            osutils.local_time_offset(), submit_branch,
4909
5729
                self.outf.writelines(directive.to_lines())
4910
5730
        else:
4911
5731
            message = directive.to_email(mail_to, branch, sign)
4912
 
            s = SMTPConnection(branch.get_config())
 
5732
            s = SMTPConnection(branch.get_config_stack())
4913
5733
            s.send_email(message)
4914
5734
 
4915
5735
 
4916
5736
class cmd_send(Command):
4917
 
    """Mail or create a merge-directive for submitting changes.
 
5737
    __doc__ = """Mail or create a merge-directive for submitting changes.
4918
5738
 
4919
5739
    A merge directive provides many things needed for requesting merges:
4920
5740
 
4926
5746
      directly from the merge directive, without retrieving data from a
4927
5747
      branch.
4928
5748
 
4929
 
    If --no-bundle is specified, then public_branch is needed (and must be
4930
 
    up-to-date), so that the receiver can perform the merge using the
4931
 
    public_branch.  The public_branch is always included if known, so that
4932
 
    people can check it later.
4933
 
 
4934
 
    The submit branch defaults to the parent, but can be overridden.  Both
4935
 
    submit branch and public branch will be remembered if supplied.
4936
 
 
4937
 
    If a public_branch is known for the submit_branch, that public submit
4938
 
    branch is used in the merge instructions.  This means that a local mirror
4939
 
    can be used as your actual submit branch, once you have set public_branch
4940
 
    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.
4941
5781
 
4942
5782
    Mail is sent using your preferred mail program.  This should be transparent
4943
 
    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.
4944
5784
    If the preferred client can't be found (or used), your editor will be used.
4945
5785
 
4946
5786
    To use a specific mail program, set the mail_client configuration option.
4947
5787
    (For Thunderbird 1.5, this works around some bugs.)  Supported values for
4948
 
    specific clients are "claws", "evolution", "kmail", "mutt", and
4949
 
    "thunderbird"; generic options are "default", "editor", "emacsclient",
4950
 
    "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.
4951
5792
 
4952
5793
    If mail is being sent, a to address is required.  This can be supplied
4953
5794
    either on the commandline, by setting the submit_to configuration
4962
5803
 
4963
5804
    The merge directives created by bzr send may be applied using bzr merge or
4964
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.
4965
5810
    """
4966
5811
 
4967
5812
    encoding_type = 'exact'
4983
5828
               short_name='f',
4984
5829
               type=unicode),
4985
5830
        Option('output', short_name='o',
4986
 
               help='Write merge directive to this file; '
 
5831
               help='Write merge directive to this file or directory; '
4987
5832
                    'use - for stdout.',
4988
5833
               type=unicode),
4989
5834
        Option('strict',
5000
5845
        ]
5001
5846
 
5002
5847
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5003
 
            no_patch=False, revision=None, remember=False, output=None,
 
5848
            no_patch=False, revision=None, remember=None, output=None,
5004
5849
            format=None, mail_to=None, message=None, body=None,
5005
5850
            strict=None, **kwargs):
5006
5851
        from bzrlib.send import send
5012
5857
 
5013
5858
 
5014
5859
class cmd_bundle_revisions(cmd_send):
5015
 
    """Create a merge-directive for submitting changes.
 
5860
    __doc__ = """Create a merge-directive for submitting changes.
5016
5861
 
5017
5862
    A merge directive provides many things needed for requesting merges:
5018
5863
 
5085
5930
 
5086
5931
 
5087
5932
class cmd_tag(Command):
5088
 
    """Create, remove or modify a tag naming a revision.
 
5933
    __doc__ = """Create, remove or modify a tag naming a revision.
5089
5934
 
5090
5935
    Tags give human-meaningful names to revisions.  Commands that take a -r
5091
5936
    (--revision) option can be given -rtag:X, where X is any previously
5099
5944
 
5100
5945
    To rename a tag (change the name but keep it on the same revsion), run ``bzr
5101
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.
5102
5952
    """
5103
5953
 
5104
5954
    _see_also = ['commit', 'tags']
5105
 
    takes_args = ['tag_name']
 
5955
    takes_args = ['tag_name?']
5106
5956
    takes_options = [
5107
5957
        Option('delete',
5108
5958
            help='Delete this tag rather than placing it.',
5109
5959
            ),
5110
 
        Option('directory',
5111
 
            help='Branch in which to place the tag.',
5112
 
            short_name='d',
5113
 
            type=unicode,
5114
 
            ),
 
5960
        custom_help('directory',
 
5961
            help='Branch in which to place the tag.'),
5115
5962
        Option('force',
5116
5963
            help='Replace existing tags.',
5117
5964
            ),
5118
5965
        'revision',
5119
5966
        ]
5120
5967
 
5121
 
    def run(self, tag_name,
 
5968
    def run(self, tag_name=None,
5122
5969
            delete=None,
5123
5970
            directory='.',
5124
5971
            force=None,
5125
5972
            revision=None,
5126
5973
            ):
5127
5974
        branch, relpath = Branch.open_containing(directory)
5128
 
        branch.lock_write()
5129
 
        try:
5130
 
            if delete:
5131
 
                branch.tags.delete_tag(tag_name)
5132
 
                self.outf.write('Deleted tag %s.\n' % tag_name)
5133
 
            else:
5134
 
                if revision:
5135
 
                    if len(revision) != 1:
5136
 
                        raise errors.BzrCommandError(
5137
 
                            "Tags can only be placed on a single revision, "
5138
 
                            "not on a range")
5139
 
                    revision_id = revision[0].as_revision_id(branch)
5140
 
                else:
5141
 
                    revision_id = branch.last_revision()
5142
 
                if (not force) and branch.tags.has_tag(tag_name):
5143
 
                    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:
5144
6004
                branch.tags.set_tag(tag_name, revision_id)
5145
 
                self.outf.write('Created tag %s.\n' % tag_name)
5146
 
        finally:
5147
 
            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)
5148
6009
 
5149
6010
 
5150
6011
class cmd_tags(Command):
5151
 
    """List tags.
 
6012
    __doc__ = """List tags.
5152
6013
 
5153
6014
    This command shows a table of tag names and the revisions they reference.
5154
6015
    """
5155
6016
 
5156
6017
    _see_also = ['tag']
5157
6018
    takes_options = [
5158
 
        Option('directory',
5159
 
            help='Branch whose tags should be displayed.',
5160
 
            short_name='d',
5161
 
            type=unicode,
5162
 
            ),
5163
 
        RegistryOption.from_kwargs('sort',
 
6019
        custom_help('directory',
 
6020
            help='Branch whose tags should be displayed.'),
 
6021
        RegistryOption('sort',
5164
6022
            'Sort tags by different criteria.', title='Sorting',
5165
 
            alpha='Sort tags lexicographically (default).',
5166
 
            time='Sort tags chronologically.',
 
6023
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5167
6024
            ),
5168
6025
        'show-ids',
5169
6026
        'revision',
5170
6027
    ]
5171
6028
 
5172
6029
    @display_command
5173
 
    def run(self,
5174
 
            directory='.',
5175
 
            sort='alpha',
5176
 
            show_ids=False,
5177
 
            revision=None,
5178
 
            ):
 
6030
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
6031
        from bzrlib.tag import tag_sort_methods
5179
6032
        branch, relpath = Branch.open_containing(directory)
5180
6033
 
5181
6034
        tags = branch.tags.get_tag_dict().items()
5182
6035
        if not tags:
5183
6036
            return
5184
6037
 
5185
 
        branch.lock_read()
5186
 
        try:
5187
 
            if revision:
5188
 
                graph = branch.repository.get_graph()
5189
 
                rev1, rev2 = _get_revision_range(revision, branch, self.name())
5190
 
                revid1, revid2 = rev1.rev_id, rev2.rev_id
5191
 
                # only show revisions between revid1 and revid2 (inclusive)
5192
 
                tags = [(tag, revid) for tag, revid in tags if
5193
 
                    graph.is_between(revid, revid1, revid2)]
5194
 
            if sort == 'alpha':
5195
 
                tags.sort()
5196
 
            elif sort == 'time':
5197
 
                timestamps = {}
5198
 
                for tag, revid in tags:
5199
 
                    try:
5200
 
                        revobj = branch.repository.get_revision(revid)
5201
 
                    except errors.NoSuchRevision:
5202
 
                        timestamp = sys.maxint # place them at the end
5203
 
                    else:
5204
 
                        timestamp = revobj.timestamp
5205
 
                    timestamps[revid] = timestamp
5206
 
                tags.sort(key=lambda x: timestamps[x[1]])
5207
 
            if not show_ids:
5208
 
                # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5209
 
                for index, (tag, revid) in enumerate(tags):
5210
 
                    try:
5211
 
                        revno = branch.revision_id_to_dotted_revno(revid)
5212
 
                        if isinstance(revno, tuple):
5213
 
                            revno = '.'.join(map(str, revno))
5214
 
                    except errors.NoSuchRevision:
5215
 
                        # Bad tag data/merges can lead to tagged revisions
5216
 
                        # which are not in this branch. Fail gracefully ...
5217
 
                        revno = '?'
5218
 
                    tags[index] = (tag, revno)
5219
 
        finally:
5220
 
            branch.unlock()
 
6038
        self.add_cleanup(branch.lock_read().unlock)
 
6039
        if revision:
 
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)
 
6045
        if not show_ids:
 
6046
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
 
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()
5221
6060
        for tag, revspec in tags:
5222
6061
            self.outf.write('%-20s %s\n' % (tag, revspec))
5223
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
 
5224
6089
 
5225
6090
class cmd_reconfigure(Command):
5226
 
    """Reconfigure the type of a bzr directory.
 
6091
    __doc__ = """Reconfigure the type of a bzr directory.
5227
6092
 
5228
6093
    A target configuration must be specified.
5229
6094
 
5240
6105
    takes_args = ['location?']
5241
6106
    takes_options = [
5242
6107
        RegistryOption.from_kwargs(
5243
 
            'target_type',
5244
 
            title='Target type',
5245
 
            help='The type to reconfigure the directory to.',
 
6108
            'tree_type',
 
6109
            title='Tree type',
 
6110
            help='The relation between branch and tree.',
5246
6111
            value_switches=True, enum_switch=False,
5247
6112
            branch='Reconfigure to be an unbound branch with no working tree.',
5248
6113
            tree='Reconfigure to be an unbound branch with a working tree.',
5249
6114
            checkout='Reconfigure to be a bound branch with a working tree.',
5250
6115
            lightweight_checkout='Reconfigure to be a lightweight'
5251
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,
5252
6123
            standalone='Reconfigure to be a standalone branch '
5253
6124
                '(i.e. stop using shared repository).',
5254
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,
5255
6132
            with_trees='Reconfigure repository to create '
5256
6133
                'working trees on branches by default.',
5257
6134
            with_no_trees='Reconfigure repository to not create '
5271
6148
            ),
5272
6149
        ]
5273
6150
 
5274
 
    def run(self, location=None, target_type=None, bind_to=None, force=False,
5275
 
            stacked_on=None,
5276
 
            unstacked=None):
5277
 
        directory = bzrdir.BzrDir.open(location)
 
6151
    def run(self, location=None, bind_to=None, force=False,
 
6152
            tree_type=None, repository_type=None, repository_trees=None,
 
6153
            stacked_on=None, unstacked=None):
 
6154
        directory = controldir.ControlDir.open(location)
5278
6155
        if stacked_on and unstacked:
5279
 
            raise BzrCommandError("Can't use both --stacked-on and --unstacked")
 
6156
            raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5280
6157
        elif stacked_on is not None:
5281
6158
            reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5282
6159
        elif unstacked:
5284
6161
        # At the moment you can use --stacked-on and a different
5285
6162
        # reconfiguration shape at the same time; there seems no good reason
5286
6163
        # to ban it.
5287
 
        if target_type is None:
 
6164
        if (tree_type is None and
 
6165
            repository_type is None and
 
6166
            repository_trees is None):
5288
6167
            if stacked_on or unstacked:
5289
6168
                return
5290
6169
            else:
5291
 
                raise errors.BzrCommandError('No target configuration '
5292
 
                    'specified')
5293
 
        elif target_type == 'branch':
 
6170
                raise errors.BzrCommandError(gettext('No target configuration '
 
6171
                    'specified'))
 
6172
        reconfiguration = None
 
6173
        if tree_type == 'branch':
5294
6174
            reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5295
 
        elif target_type == 'tree':
 
6175
        elif tree_type == 'tree':
5296
6176
            reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5297
 
        elif target_type == 'checkout':
 
6177
        elif tree_type == 'checkout':
5298
6178
            reconfiguration = reconfigure.Reconfigure.to_checkout(
5299
6179
                directory, bind_to)
5300
 
        elif target_type == 'lightweight-checkout':
 
6180
        elif tree_type == 'lightweight-checkout':
5301
6181
            reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5302
6182
                directory, bind_to)
5303
 
        elif target_type == 'use-shared':
 
6183
        if reconfiguration:
 
6184
            reconfiguration.apply(force)
 
6185
            reconfiguration = None
 
6186
        if repository_type == 'use-shared':
5304
6187
            reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5305
 
        elif target_type == 'standalone':
 
6188
        elif repository_type == 'standalone':
5306
6189
            reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5307
 
        elif target_type == 'with-trees':
 
6190
        if reconfiguration:
 
6191
            reconfiguration.apply(force)
 
6192
            reconfiguration = None
 
6193
        if repository_trees == 'with-trees':
5308
6194
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5309
6195
                directory, True)
5310
 
        elif target_type == 'with-no-trees':
 
6196
        elif repository_trees == 'with-no-trees':
5311
6197
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5312
6198
                directory, False)
5313
 
        reconfiguration.apply(force)
 
6199
        if reconfiguration:
 
6200
            reconfiguration.apply(force)
 
6201
            reconfiguration = None
5314
6202
 
5315
6203
 
5316
6204
class cmd_switch(Command):
5317
 
    """Set the branch of a checkout and update.
 
6205
    __doc__ = """Set the branch of a checkout and update.
5318
6206
 
5319
6207
    For lightweight checkouts, this changes the branch being referenced.
5320
6208
    For heavyweight checkouts, this checks that there are no local commits
5332
6220
    /path/to/newbranch.
5333
6221
 
5334
6222
    Bound branches use the nickname of its master branch unless it is set
5335
 
    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
5336
6224
    that of the master.
5337
6225
    """
5338
6226
 
5339
 
    takes_args = ['to_location']
5340
 
    takes_options = [Option('force',
 
6227
    takes_args = ['to_location?']
 
6228
    takes_options = ['directory',
 
6229
                     Option('force',
5341
6230
                        help='Switch even if local commits will be lost.'),
 
6231
                     'revision',
5342
6232
                     Option('create-branch', short_name='b',
5343
6233
                        help='Create the target branch from this one before'
5344
6234
                             ' switching to it.'),
5345
 
                     ]
 
6235
                     Option('store',
 
6236
                        help='Store and restore uncommitted changes in the'
 
6237
                             ' branch.'),
 
6238
                    ]
5346
6239
 
5347
 
    def run(self, to_location, force=False, create_branch=False):
 
6240
    def run(self, to_location=None, force=False, create_branch=False,
 
6241
            revision=None, directory=u'.', store=False):
5348
6242
        from bzrlib import switch
5349
 
        tree_location = '.'
5350
 
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
 
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
5351
6253
        try:
5352
 
            branch = control_dir.open_branch()
 
6254
            branch = control_dir.open_branch(
 
6255
                possible_transports=possible_transports)
5353
6256
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5354
6257
        except errors.NotBranchError:
5355
6258
            branch = None
5356
6259
            had_explicit_nick = False
5357
6260
        if create_branch:
5358
6261
            if branch is None:
5359
 
                raise errors.BzrCommandError('cannot create branch without'
5360
 
                                             ' source branch')
5361
 
            if '/' not in to_location and '\\' not in to_location:
5362
 
                # This path is meant to be relative to the existing branch
5363
 
                this_url = self._get_branch_location(control_dir)
5364
 
                to_location = urlutils.join(this_url, '..', to_location)
 
6262
                raise errors.BzrCommandError(
 
6263
                    gettext('cannot create branch without source branch'))
 
6264
            to_location = lookup_new_sibling_branch(control_dir, to_location,
 
6265
                 possible_transports=possible_transports)
5365
6266
            to_branch = branch.bzrdir.sprout(to_location,
5366
 
                                 possible_transports=[branch.bzrdir.root_transport],
5367
 
                                 source_branch=branch).open_branch()
5368
 
            # try:
5369
 
            #     from_branch = control_dir.open_branch()
5370
 
            # except errors.NotBranchError:
5371
 
            #     raise BzrCommandError('Cannot create a branch from this'
5372
 
            #         ' location when we cannot open this branch')
5373
 
            # from_branch.bzrdir.sprout(
5374
 
            pass
 
6267
                 possible_transports=possible_transports,
 
6268
                 source_branch=branch).open_branch()
5375
6269
        else:
5376
6270
            try:
5377
 
                to_branch = Branch.open(to_location)
 
6271
                to_branch = Branch.open(to_location,
 
6272
                    possible_transports=possible_transports)
5378
6273
            except errors.NotBranchError:
5379
 
                this_url = self._get_branch_location(control_dir)
5380
 
                to_branch = Branch.open(
5381
 
                    urlutils.join(this_url, '..', to_location))
5382
 
        switch.switch(control_dir, to_branch, force)
 
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)
5383
6280
        if had_explicit_nick:
5384
6281
            branch = control_dir.open_branch() #get the new branch!
5385
6282
            branch.nick = to_branch.nick
5386
 
        note('Switched to branch: %s',
 
6283
        note(gettext('Switched to branch: %s'),
5387
6284
            urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5388
6285
 
5389
 
    def _get_branch_location(self, control_dir):
5390
 
        """Return location of branch for this control dir."""
5391
 
        try:
5392
 
            this_branch = control_dir.open_branch()
5393
 
            # This may be a heavy checkout, where we want the master branch
5394
 
            master_location = this_branch.get_bound_location()
5395
 
            if master_location is not None:
5396
 
                return master_location
5397
 
            # If not, use a local sibling
5398
 
            return this_branch.base
5399
 
        except errors.NotBranchError:
5400
 
            format = control_dir.find_branch_format()
5401
 
            if getattr(format, 'get_reference', None) is not None:
5402
 
                return format.get_reference(control_dir)
5403
 
            else:
5404
 
                return control_dir.root_transport.base
5405
6286
 
5406
6287
 
5407
6288
class cmd_view(Command):
5408
 
    """Manage filtered views.
 
6289
    __doc__ = """Manage filtered views.
5409
6290
 
5410
6291
    Views provide a mask over the tree so that users can focus on
5411
6292
    a subset of a tree when doing their work. After creating a view,
5491
6372
            name=None,
5492
6373
            switch=None,
5493
6374
            ):
5494
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
6375
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
6376
            apply_view=False)
5495
6377
        current_view, view_dict = tree.views.get_view_info()
5496
6378
        if name is None:
5497
6379
            name = current_view
5498
6380
        if delete:
5499
6381
            if file_list:
5500
 
                raise errors.BzrCommandError(
5501
 
                    "Both --delete and a file list specified")
 
6382
                raise errors.BzrCommandError(gettext(
 
6383
                    "Both --delete and a file list specified"))
5502
6384
            elif switch:
5503
 
                raise errors.BzrCommandError(
5504
 
                    "Both --delete and --switch specified")
 
6385
                raise errors.BzrCommandError(gettext(
 
6386
                    "Both --delete and --switch specified"))
5505
6387
            elif all:
5506
6388
                tree.views.set_view_info(None, {})
5507
 
                self.outf.write("Deleted all views.\n")
 
6389
                self.outf.write(gettext("Deleted all views.\n"))
5508
6390
            elif name is None:
5509
 
                raise errors.BzrCommandError("No current view to delete")
 
6391
                raise errors.BzrCommandError(gettext("No current view to delete"))
5510
6392
            else:
5511
6393
                tree.views.delete_view(name)
5512
 
                self.outf.write("Deleted '%s' view.\n" % name)
 
6394
                self.outf.write(gettext("Deleted '%s' view.\n") % name)
5513
6395
        elif switch:
5514
6396
            if file_list:
5515
 
                raise errors.BzrCommandError(
5516
 
                    "Both --switch and a file list specified")
 
6397
                raise errors.BzrCommandError(gettext(
 
6398
                    "Both --switch and a file list specified"))
5517
6399
            elif all:
5518
 
                raise errors.BzrCommandError(
5519
 
                    "Both --switch and --all specified")
 
6400
                raise errors.BzrCommandError(gettext(
 
6401
                    "Both --switch and --all specified"))
5520
6402
            elif switch == 'off':
5521
6403
                if current_view is None:
5522
 
                    raise errors.BzrCommandError("No current view to disable")
 
6404
                    raise errors.BzrCommandError(gettext("No current view to disable"))
5523
6405
                tree.views.set_view_info(None, view_dict)
5524
 
                self.outf.write("Disabled '%s' view.\n" % (current_view))
 
6406
                self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5525
6407
            else:
5526
6408
                tree.views.set_view_info(switch, view_dict)
5527
6409
                view_str = views.view_display_str(tree.views.lookup_view())
5528
 
                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))
5529
6411
        elif all:
5530
6412
            if view_dict:
5531
 
                self.outf.write('Views defined:\n')
 
6413
                self.outf.write(gettext('Views defined:\n'))
5532
6414
                for view in sorted(view_dict):
5533
6415
                    if view == current_view:
5534
6416
                        active = "=>"
5537
6419
                    view_str = views.view_display_str(view_dict[view])
5538
6420
                    self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5539
6421
            else:
5540
 
                self.outf.write('No views defined.\n')
 
6422
                self.outf.write(gettext('No views defined.\n'))
5541
6423
        elif file_list:
5542
6424
            if name is None:
5543
6425
                # No name given and no current view set
5544
6426
                name = 'my'
5545
6427
            elif name == 'off':
5546
 
                raise errors.BzrCommandError(
5547
 
                    "Cannot change the 'off' pseudo view")
 
6428
                raise errors.BzrCommandError(gettext(
 
6429
                    "Cannot change the 'off' pseudo view"))
5548
6430
            tree.views.set_view(name, sorted(file_list))
5549
6431
            view_str = views.view_display_str(tree.views.lookup_view())
5550
 
            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))
5551
6433
        else:
5552
6434
            # list the files
5553
6435
            if name is None:
5554
6436
                # No name given and no current view set
5555
 
                self.outf.write('No current view.\n')
 
6437
                self.outf.write(gettext('No current view.\n'))
5556
6438
            else:
5557
6439
                view_str = views.view_display_str(tree.views.lookup_view(name))
5558
 
                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))
5559
6441
 
5560
6442
 
5561
6443
class cmd_hooks(Command):
5562
 
    """Show hooks."""
 
6444
    __doc__ = """Show hooks."""
5563
6445
 
5564
6446
    hidden = True
5565
6447
 
5575
6457
                        self.outf.write("    %s\n" %
5576
6458
                                        (some_hooks.get_hook_name(hook),))
5577
6459
                else:
5578
 
                    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)
5579
6496
 
5580
6497
 
5581
6498
class cmd_shelve(Command):
5582
 
    """Temporarily set aside some changes from the current tree.
 
6499
    __doc__ = """Temporarily set aside some changes from the current tree.
5583
6500
 
5584
6501
    Shelve allows you to temporarily put changes you've made "on the shelf",
5585
6502
    ie. out of the way, until a later time when you can bring them back from
5601
6518
 
5602
6519
    You can put multiple items on the shelf, and by default, 'unshelve' will
5603
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
        
5604
6533
    """
5605
6534
 
5606
6535
    takes_args = ['file*']
5607
6536
 
5608
6537
    takes_options = [
 
6538
        'directory',
5609
6539
        'revision',
5610
6540
        Option('all', help='Shelve all changes.'),
5611
6541
        'message',
5617
6547
        Option('destroy',
5618
6548
               help='Destroy removed changes instead of shelving them.'),
5619
6549
    ]
5620
 
    _see_also = ['unshelve']
 
6550
    _see_also = ['unshelve', 'configuration']
5621
6551
 
5622
6552
    def run(self, revision=None, all=False, file_list=None, message=None,
5623
 
            writer=None, list=False, destroy=False):
 
6553
            writer=None, list=False, destroy=False, directory=None):
5624
6554
        if list:
5625
 
            return self.run_for_list()
 
6555
            return self.run_for_list(directory=directory)
5626
6556
        from bzrlib.shelf_ui import Shelver
5627
6557
        if writer is None:
5628
6558
            writer = bzrlib.option.diff_writer_registry.get()
5629
6559
        try:
5630
 
            Shelver.from_args(writer(sys.stdout), revision, all, file_list,
5631
 
                              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()
5632
6566
        except errors.UserAbort:
5633
6567
            return 0
5634
6568
 
5635
 
    def run_for_list(self):
5636
 
        tree = WorkingTree.open_containing('.')[0]
5637
 
        tree.lock_read()
5638
 
        try:
5639
 
            manager = tree.get_shelf_manager()
5640
 
            shelves = manager.active_shelves()
5641
 
            if len(shelves) == 0:
5642
 
                note('No shelved changes.')
5643
 
                return 0
5644
 
            for shelf_id in reversed(shelves):
5645
 
                message = manager.get_metadata(shelf_id).get('message')
5646
 
                if message is None:
5647
 
                    message = '<no message>'
5648
 
                self.outf.write('%3d: %s\n' % (shelf_id, message))
5649
 
            return 1
5650
 
        finally:
5651
 
            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
5652
6585
 
5653
6586
 
5654
6587
class cmd_unshelve(Command):
5655
 
    """Restore shelved changes.
 
6588
    __doc__ = """Restore shelved changes.
5656
6589
 
5657
6590
    By default, the most recently shelved changes are restored. However if you
5658
6591
    specify a shelf by id those changes will be restored instead.  This works
5661
6594
 
5662
6595
    takes_args = ['shelf_id?']
5663
6596
    takes_options = [
 
6597
        'directory',
5664
6598
        RegistryOption.from_kwargs(
5665
6599
            'action', help="The action to perform.",
5666
6600
            enum_switch=False, value_switches=True,
5667
6601
            apply="Apply changes and remove from the shelf.",
5668
6602
            dry_run="Show changes, but do not apply or remove them.",
5669
 
            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.",
5670
6607
        )
5671
6608
    ]
5672
6609
    _see_also = ['shelve']
5673
6610
 
5674
 
    def run(self, shelf_id=None, action='apply'):
 
6611
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5675
6612
        from bzrlib.shelf_ui import Unshelver
5676
 
        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()
5677
6618
 
5678
6619
 
5679
6620
class cmd_clean_tree(Command):
5680
 
    """Remove unwanted files from working tree.
 
6621
    __doc__ = """Remove unwanted files from working tree.
5681
6622
 
5682
6623
    By default, only unknown files, not ignored files, are deleted.  Versioned
5683
6624
    files are never deleted.
5691
6632
 
5692
6633
    To check what clean-tree will do, use --dry-run.
5693
6634
    """
5694
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
5695
 
                     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'
5696
6638
                            ' backups, and failed selftest dirs.'),
5697
6639
                     Option('unknown',
5698
6640
                            help='Delete files unknown to bzr (default).'),
5700
6642
                            ' deleting them.'),
5701
6643
                     Option('force', help='Do not prompt before deleting.')]
5702
6644
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5703
 
            force=False):
 
6645
            force=False, directory=u'.'):
5704
6646
        from bzrlib.clean_tree import clean_tree
5705
6647
        if not (unknown or ignored or detritus):
5706
6648
            unknown = True
5707
6649
        if dry_run:
5708
6650
            force = True
5709
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5710
 
                   dry_run=dry_run, no_prompt=force)
 
6651
        clean_tree(directory, unknown=unknown, ignored=ignored,
 
6652
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
5711
6653
 
5712
6654
 
5713
6655
class cmd_reference(Command):
5714
 
    """list, view and set branch locations for nested trees.
 
6656
    __doc__ = """list, view and set branch locations for nested trees.
5715
6657
 
5716
6658
    If no arguments are provided, lists the branch locations for nested trees.
5717
6659
    If one argument is provided, display the branch location for that tree.
5727
6669
        if path is not None:
5728
6670
            branchdir = path
5729
6671
        tree, branch, relpath =(
5730
 
            bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
 
6672
            controldir.ControlDir.open_containing_tree_or_branch(branchdir))
5731
6673
        if path is not None:
5732
6674
            path = relpath
5733
6675
        if tree is None:
5757
6699
            self.outf.write('%s %s\n' % (path, location))
5758
6700
 
5759
6701
 
5760
 
# these get imported and then picked up by the scan for cmd_*
5761
 
# TODO: Some more consistent way to split command definitions across files;
5762
 
# we do need to load at least some information about them to know of
5763
 
# aliases.  ideally we would avoid loading the implementation until the
5764
 
# details were needed.
5765
 
from bzrlib.cmd_version_info import cmd_version_info
5766
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5767
 
from bzrlib.bundle.commands import (
5768
 
    cmd_bundle_info,
5769
 
    )
5770
 
from bzrlib.foreign import cmd_dpush
5771
 
from bzrlib.sign_my_commits import cmd_sign_my_commits
5772
 
from bzrlib.weave_commands import cmd_versionedfile_list, \
5773
 
        cmd_weave_plan_merge, cmd_weave_merge_text
 
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)