← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Vincent Ladeuil
  • Date: 2009-06-18 19:45:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4466.
  • Revision ID: v.ladeuil+lp@free.fr-20090618194524-poedor61th3op5dm
Cleanup.

* bzrlib/tests/test__known_graph.py:
(TestKnownGraph): Delete dominator tests.

* bzrlib/_known_graph_pyx.pyx: 
Cleanup all references to old version and linear dominators :-/

* bzrlib/_known_graph_py.py: 
Cleanup all references to old version and linear dominators :-/

Show diffs side-by-side

added added

removed removed

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