← 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: 2005-10-03 01:15:02 UTC
  • mfrom: (1092.2.28)
  • Revision ID: robertc@robertcollins.net-20051003011502-f579a509a136b774
merge from baz2bzr

Show diffs side-by-side

added added

removed removed

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