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