← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-05-04 12:10:51 UTC
  • mfrom: (5819.1.4 777007-developer-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20110504121051-aovlsmqiivjmc4fc
(jelmer) Small fixes to developer documentation. (Jonathan Riddell)

Show diffs side-by-side

added added

removed removed

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