~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

Test ConnectionError exceptions.

* bzrlib/transport/http/_urllib2_wrappers.py
(AbstractHTTPConnection.getresponse): Not needed anymore.
(AbstractHTTPHandler.do_open): Better exception handling.
(HTTPBasicAuthHandler): Not yet implemented.

* bzrlib/transport/http/_urllib.py: 
Fix spurious spaces.

* bzrlib/transport/http/__init__.py:
(WallRequestHandler, WallHttpServer): A http server closing
connections as soon as a request arrives.

* bzrlib/tests/test_http.py:
(TestWallServer): Check exceptions during connection.

* bzrlib/tests/HTTPTestUtil.py:
(TestCaseWithWallserver): New class. A server which close
connections as soon as possible.

Show diffs side-by-side

added added

removed removed

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