← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

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