← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-31 02:00:37 UTC
  • mto: (2779.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2783.
  • Revision ID: ian.clatworthy@internode.on.net-20070831020037-6drt2nnbu38907s5
Add tests for new methods in trace.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2004, 2005, 2006, 2007 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
 
 
 
17
"""builtin bzr commands"""
 
18
 
 
19
import os
 
20
from StringIO import StringIO
 
21
 
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
import codecs
 
25
import errno
18
26
import sys
19
 
import os
 
27
import tempfile
 
28
import time
20
29
 
21
30
import bzrlib
22
 
from bzrlib import BZRDIR
23
 
from bzrlib.commands import Command
 
31
from bzrlib import (
 
32
    branch,
 
33
    bugtracker,
 
34
    bundle,
 
35
    bzrdir,
 
36
    delta,
 
37
    config,
 
38
    errors,
 
39
    globbing,
 
40
    ignores,
 
41
    log,
 
42
    merge as _mod_merge,
 
43
    merge_directive,
 
44
    osutils,
 
45
    registry,
 
46
    repository,
 
47
    revision as _mod_revision,
 
48
    revisionspec,
 
49
    symbol_versioning,
 
50
    transport,
 
51
    tree as _mod_tree,
 
52
    ui,
 
53
    urlutils,
 
54
    )
24
55
from bzrlib.branch import Branch
25
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
26
 
from bzrlib.errors import DivergedBranches
27
 
from bzrlib.option import Option
 
56
from bzrlib.conflicts import ConflictList
28
57
from bzrlib.revisionspec import RevisionSpec
29
 
import bzrlib.trace
30
 
from bzrlib.trace import mutter, note, log_error, warning
 
58
from bzrlib.smtp_connection import SMTPConnection
31
59
from bzrlib.workingtree import WorkingTree
32
 
 
 
60
""")
 
61
 
 
62
from bzrlib.commands import Command, display_command
 
63
from bzrlib.option import ListOption, Option, RegistryOption, custom_help
 
64
from bzrlib.progress import DummyProgress, ProgressPhase
 
65
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
 
66
 
 
67
 
 
68
def tree_files(file_list, default_branch=u'.'):
 
69
    try:
 
70
        return internal_tree_files(file_list, default_branch)
 
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
# XXX: Bad function name; should possibly also be a class method of
 
77
# WorkingTree rather than a function.
 
78
def internal_tree_files(file_list, default_branch=u'.'):
 
79
    """Convert command-line paths to a WorkingTree and relative paths.
 
80
 
 
81
    This is typically used for command-line processors that take one or
 
82
    more filenames, and infer the workingtree that contains them.
 
83
 
 
84
    The filenames given are not required to exist.
 
85
 
 
86
    :param file_list: Filenames to convert.  
 
87
 
 
88
    :param default_branch: Fallback tree path to use if file_list is empty or
 
89
        None.
 
90
 
 
91
    :return: workingtree, [relative_paths]
 
92
    """
 
93
    if file_list is None or len(file_list) == 0:
 
94
        return WorkingTree.open_containing(default_branch)[0], file_list
 
95
    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
 
96
    new_list = []
 
97
    for filename in file_list:
 
98
        try:
 
99
            new_list.append(tree.relpath(osutils.dereference_path(filename)))
 
100
        except errors.PathNotChild:
 
101
            raise errors.FileInWrongBranch(tree.branch, filename)
 
102
    return tree, new_list
 
103
 
 
104
 
 
105
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
 
106
def get_format_type(typestring):
 
107
    """Parse and return a format specifier."""
 
108
    # Have to use BzrDirMetaFormat1 directly, so that
 
109
    # RepositoryFormat.set_default_format works
 
110
    if typestring == "default":
 
111
        return bzrdir.BzrDirMetaFormat1()
 
112
    try:
 
113
        return bzrdir.format_registry.make_bzrdir(typestring)
 
114
    except KeyError:
 
115
        msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
 
116
        raise errors.BzrCommandError(msg)
 
117
 
 
118
 
 
119
# TODO: Make sure no commands unconditionally use the working directory as a
 
120
# branch.  If a filename argument is used, the first of them should be used to
 
121
# specify the branch.  (Perhaps this can be factored out into some kind of
 
122
# Argument class, representing a file in a branch, where the first occurrence
 
123
# opens the branch?)
33
124
 
34
125
class cmd_status(Command):
35
126
    """Display status summary.
52
143
    modified
53
144
        Text has changed since the previous revision.
54
145
 
55
 
    unchanged
56
 
        Nothing about this file has changed since the previous revision.
57
 
        Only shown with --all.
 
146
    kind changed
 
147
        File kind has been changed (e.g. from file to directory).
58
148
 
59
149
    unknown
60
150
        Not versioned and not matching an ignore pattern.
61
151
 
62
 
    To see ignored files use 'bzr ignored'.  For details in the
 
152
    To see ignored files use 'bzr ignored'.  For details on the
63
153
    changes to file texts, use 'bzr diff'.
 
154
    
 
155
    --short gives a status flags for each item, similar to the SVN's status
 
156
    command.
64
157
 
65
158
    If no arguments are specified, the status of the entire working
66
159
    directory is shown.  Otherwise, only the status of the specified
71
164
    that revision, or between two revisions if two are provided.
72
165
    """
73
166
    
74
 
    # XXX: FIXME: bzr status should accept a -r option to show changes
75
 
    # relative to a revision, or between revisions
76
 
 
77
167
    # TODO: --no-recurse, --recurse options
78
168
    
79
169
    takes_args = ['file*']
80
 
    takes_options = ['all', 'show-ids']
 
170
    takes_options = ['show-ids', 'revision',
 
171
                     Option('short', help='Give short SVN-style status lines.'),
 
172
                     Option('versioned', help='Only show versioned files.')]
81
173
    aliases = ['st', 'stat']
 
174
 
 
175
    encoding_type = 'replace'
 
176
    _see_also = ['diff', 'revert', 'status-flags']
82
177
    
83
 
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
84
 
        if file_list:
85
 
            b, relpath = Branch.open_containing(file_list[0])
86
 
            if relpath == '' and len(file_list) == 1:
87
 
                file_list = None
88
 
            else:
89
 
                # generate relative paths.
90
 
                # note that if this is a remote branch, we would want
91
 
                # relpath against the transport. RBC 20051018
92
 
                tree = WorkingTree(b.base, b)
93
 
                file_list = [tree.relpath(x) for x in file_list]
94
 
        else:
95
 
            b = Branch.open_containing('.')[0]
 
178
    @display_command
 
179
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
 
180
            versioned=False):
 
181
        from bzrlib.status import show_tree_status
 
182
 
 
183
        tree, file_list = tree_files(file_list)
96
184
            
97
 
        from bzrlib.status import show_status
98
 
        show_status(b, show_unchanged=all, show_ids=show_ids,
99
 
                    specific_files=file_list, revision=revision)
 
185
        show_tree_status(tree, show_ids=show_ids,
 
186
                         specific_files=file_list, revision=revision,
 
187
                         to_file=self.outf, short=short, versioned=versioned)
100
188
 
101
189
 
102
190
class cmd_cat_revision(Command):
109
197
    hidden = True
110
198
    takes_args = ['revision_id?']
111
199
    takes_options = ['revision']
 
200
    # cat-revision is more for frontends so should be exact
 
201
    encoding = 'strict'
112
202
    
 
203
    @display_command
113
204
    def run(self, revision_id=None, revision=None):
114
205
 
 
206
        revision_id = osutils.safe_revision_id(revision_id, warn=False)
115
207
        if revision_id is not None and revision is not None:
116
 
            raise BzrCommandError('You can only supply one of revision_id or --revision')
 
208
            raise errors.BzrCommandError('You can only supply one of'
 
209
                                         ' revision_id or --revision')
117
210
        if revision_id is None and revision is None:
118
 
            raise BzrCommandError('You must supply either --revision or a revision_id')
119
 
        b = Branch.open_containing('.')[0]
 
211
            raise errors.BzrCommandError('You must supply either'
 
212
                                         ' --revision or a revision_id')
 
213
        b = WorkingTree.open_containing(u'.')[0].branch
 
214
 
 
215
        # TODO: jam 20060112 should cat-revision always output utf-8?
120
216
        if revision_id is not None:
121
 
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
 
217
            self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
122
218
        elif revision is not None:
123
219
            for rev in revision:
124
220
                if rev is None:
125
 
                    raise BzrCommandError('You cannot specify a NULL revision.')
 
221
                    raise errors.BzrCommandError('You cannot specify a NULL'
 
222
                                                 ' revision.')
126
223
                revno, rev_id = rev.in_history(b)
127
 
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
 
224
                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
128
225
    
129
226
 
 
227
class cmd_remove_tree(Command):
 
228
    """Remove the working tree from a given branch/checkout.
 
229
 
 
230
    Since a lightweight checkout is little more than a working tree
 
231
    this will refuse to run against one.
 
232
 
 
233
    To re-create the working tree, use "bzr checkout".
 
234
    """
 
235
    _see_also = ['checkout', 'working-trees']
 
236
 
 
237
    takes_args = ['location?']
 
238
 
 
239
    def run(self, location='.'):
 
240
        d = bzrdir.BzrDir.open(location)
 
241
        
 
242
        try:
 
243
            working = d.open_workingtree()
 
244
        except errors.NoWorkingTree:
 
245
            raise errors.BzrCommandError("No working tree to remove")
 
246
        except errors.NotLocalUrl:
 
247
            raise errors.BzrCommandError("You cannot remove the working tree of a "
 
248
                                         "remote path")
 
249
        
 
250
        working_path = working.bzrdir.root_transport.base
 
251
        branch_path = working.branch.bzrdir.root_transport.base
 
252
        if working_path != branch_path:
 
253
            raise errors.BzrCommandError("You cannot remove the working tree from "
 
254
                                         "a lightweight checkout")
 
255
        
 
256
        d.destroy_workingtree()
 
257
        
 
258
 
130
259
class cmd_revno(Command):
131
260
    """Show current revision number.
132
261
 
133
 
    This is equal to the number of revisions on this branch."""
134
 
    def run(self):
135
 
        print Branch.open_containing('.')[0].revno()
 
262
    This is equal to the number of revisions on this branch.
 
263
    """
 
264
 
 
265
    _see_also = ['info']
 
266
    takes_args = ['location?']
 
267
 
 
268
    @display_command
 
269
    def run(self, location=u'.'):
 
270
        self.outf.write(str(Branch.open_containing(location)[0].revno()))
 
271
        self.outf.write('\n')
136
272
 
137
273
 
138
274
class cmd_revision_info(Command):
141
277
    hidden = True
142
278
    takes_args = ['revision_info*']
143
279
    takes_options = ['revision']
 
280
 
 
281
    @display_command
144
282
    def run(self, revision=None, revision_info_list=[]):
145
283
 
146
284
        revs = []
148
286
            revs.extend(revision)
149
287
        if revision_info_list is not None:
150
288
            for rev in revision_info_list:
151
 
                revs.append(RevisionSpec(rev))
 
289
                revs.append(RevisionSpec.from_string(rev))
 
290
 
 
291
        b = Branch.open_containing(u'.')[0]
 
292
 
152
293
        if len(revs) == 0:
153
 
            raise BzrCommandError('You must supply a revision identifier')
154
 
 
155
 
        b = Branch.open_containing('.')[0]
 
294
            revs.append(RevisionSpec.from_string('-1'))
156
295
 
157
296
        for rev in revs:
158
297
            revinfo = rev.in_history(b)
159
298
            if revinfo.revno is None:
160
 
                print '     %s' % revinfo.rev_id
 
299
                dotted_map = b.get_revision_id_to_revno_map()
 
300
                revno = '.'.join(str(i) for i in dotted_map[revinfo.rev_id])
 
301
                print '%s %s' % (revno, revinfo.rev_id)
161
302
            else:
162
303
                print '%4d %s' % (revinfo.revno, revinfo.rev_id)
163
304
 
182
323
 
183
324
    Adding a file whose parent directory is not versioned will
184
325
    implicitly add the parent, and so on up to the root. This means
185
 
    you should never need to explictly add a directory, they'll just
 
326
    you should never need to explicitly add a directory, they'll just
186
327
    get added when you add a file in the directory.
 
328
 
 
329
    --dry-run will show which files would be added, but not actually 
 
330
    add them.
 
331
 
 
332
    --file-ids-from will try to use the file ids from the supplied path.
 
333
    It looks up ids trying to find a matching parent directory with the
 
334
    same filename, and then by pure path. This option is rarely needed
 
335
    but can be useful when adding the same logical file into two
 
336
    branches that will be merged later (without showing the two different
 
337
    adds as a conflict). It is also useful when merging another project
 
338
    into a subdirectory of this one.
187
339
    """
188
340
    takes_args = ['file*']
189
 
    takes_options = ['no-recurse', 'quiet']
190
 
    
191
 
    def run(self, file_list, no_recurse=False, quiet=False):
192
 
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
193
 
        if quiet:
194
 
            reporter = add_reporter_null
 
341
    takes_options = [
 
342
        Option('no-recurse',
 
343
               help="Don't recursively add the contents of directories."),
 
344
        Option('dry-run',
 
345
               help="Show what would be done, but don't actually do anything."),
 
346
        'verbose',
 
347
        Option('file-ids-from',
 
348
               type=unicode,
 
349
               help='Lookup file ids from this tree.'),
 
350
        ]
 
351
    encoding_type = 'replace'
 
352
    _see_also = ['remove']
 
353
 
 
354
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
 
355
            file_ids_from=None):
 
356
        import bzrlib.add
 
357
 
 
358
        base_tree = None
 
359
        if file_ids_from is not None:
 
360
            try:
 
361
                base_tree, base_path = WorkingTree.open_containing(
 
362
                                            file_ids_from)
 
363
            except errors.NoWorkingTree:
 
364
                base_branch, base_path = Branch.open_containing(
 
365
                                            file_ids_from)
 
366
                base_tree = base_branch.basis_tree()
 
367
 
 
368
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
 
369
                          to_file=self.outf, should_print=(not is_quiet()))
195
370
        else:
196
 
            reporter = add_reporter_print
197
 
        smart_add(file_list, not no_recurse, reporter)
 
371
            action = bzrlib.add.AddAction(to_file=self.outf,
 
372
                should_print=(not is_quiet()))
 
373
 
 
374
        if base_tree:
 
375
            base_tree.lock_read()
 
376
        try:
 
377
            file_list = self._maybe_expand_globs(file_list)
 
378
            if file_list:
 
379
                tree = WorkingTree.open_containing(file_list[0])[0]
 
380
            else:
 
381
                tree = WorkingTree.open_containing(u'.')[0]
 
382
            added, ignored = tree.smart_add(file_list, not
 
383
                no_recurse, action=action, save=not dry_run)
 
384
        finally:
 
385
            if base_tree is not None:
 
386
                base_tree.unlock()
 
387
        if len(ignored) > 0:
 
388
            if verbose:
 
389
                for glob in sorted(ignored.keys()):
 
390
                    for path in ignored[glob]:
 
391
                        self.outf.write("ignored %s matching \"%s\"\n" 
 
392
                                        % (path, glob))
 
393
            else:
 
394
                match_len = 0
 
395
                for glob, paths in ignored.items():
 
396
                    match_len += len(paths)
 
397
                self.outf.write("ignored %d file(s).\n" % match_len)
 
398
            self.outf.write("If you wish to add some of these files,"
 
399
                            " please add them by name.\n")
198
400
 
199
401
 
200
402
class cmd_mkdir(Command):
202
404
 
203
405
    This is equivalent to creating the directory and then adding it.
204
406
    """
 
407
 
205
408
    takes_args = ['dir+']
 
409
    encoding_type = 'replace'
206
410
 
207
411
    def run(self, dir_list):
208
 
        b = None
209
 
        
210
412
        for d in dir_list:
211
413
            os.mkdir(d)
212
 
            if not b:
213
 
                b = Branch.open_containing(d)[0]
214
 
            b.add([d])
215
 
            print 'added', d
 
414
            wt, dd = WorkingTree.open_containing(d)
 
415
            wt.add([dd])
 
416
            self.outf.write('added %s\n' % d)
216
417
 
217
418
 
218
419
class cmd_relpath(Command):
219
420
    """Show path of a file relative to root"""
 
421
 
220
422
    takes_args = ['filename']
221
423
    hidden = True
222
424
    
 
425
    @display_command
223
426
    def run(self, filename):
224
 
        branch, relpath = Branch.open_containing(filename)
225
 
        print relpath
 
427
        # TODO: jam 20050106 Can relpath return a munged path if
 
428
        #       sys.stdout encoding cannot represent it?
 
429
        tree, relpath = WorkingTree.open_containing(filename)
 
430
        self.outf.write(relpath)
 
431
        self.outf.write('\n')
226
432
 
227
433
 
228
434
class cmd_inventory(Command):
229
 
    """Show inventory of the current working copy or a revision."""
230
 
    takes_options = ['revision', 'show-ids']
231
 
    
232
 
    def run(self, revision=None, show_ids=False):
233
 
        b = Branch.open_containing('.')[0]
234
 
        if revision is None:
235
 
            inv = b.read_working_inventory()
236
 
        else:
237
 
            if len(revision) > 1:
238
 
                raise BzrCommandError('bzr inventory --revision takes'
239
 
                    ' exactly one revision identifier')
240
 
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
241
 
 
242
 
        for path, entry in inv.entries():
 
435
    """Show inventory of the current working copy or a revision.
 
436
 
 
437
    It is possible to limit the output to a particular entry
 
438
    type using the --kind option.  For example: --kind file.
 
439
 
 
440
    It is also possible to restrict the list of files to a specific
 
441
    set. For example: bzr inventory --show-ids this/file
 
442
    """
 
443
 
 
444
    hidden = True
 
445
    _see_also = ['ls']
 
446
    takes_options = [
 
447
        'revision',
 
448
        'show-ids',
 
449
        Option('kind',
 
450
               help='List entries of a particular kind: file, directory, symlink.',
 
451
               type=unicode),
 
452
        ]
 
453
    takes_args = ['file*']
 
454
 
 
455
    @display_command
 
456
    def run(self, revision=None, show_ids=False, kind=None, file_list=None):
 
457
        if kind and kind not in ['file', 'directory', 'symlink']:
 
458
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
 
459
 
 
460
        work_tree, file_list = tree_files(file_list)
 
461
        work_tree.lock_read()
 
462
        try:
 
463
            if revision is not None:
 
464
                if len(revision) > 1:
 
465
                    raise errors.BzrCommandError(
 
466
                        'bzr inventory --revision takes exactly one revision'
 
467
                        ' identifier')
 
468
                revision_id = revision[0].in_history(work_tree.branch).rev_id
 
469
                tree = work_tree.branch.repository.revision_tree(revision_id)
 
470
 
 
471
                extra_trees = [work_tree]
 
472
                tree.lock_read()
 
473
            else:
 
474
                tree = work_tree
 
475
                extra_trees = []
 
476
 
 
477
            if file_list is not None:
 
478
                file_ids = tree.paths2ids(file_list, trees=extra_trees,
 
479
                                          require_versioned=True)
 
480
                # find_ids_across_trees may include some paths that don't
 
481
                # exist in 'tree'.
 
482
                entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
 
483
                                 for file_id in file_ids if file_id in tree)
 
484
            else:
 
485
                entries = tree.inventory.entries()
 
486
        finally:
 
487
            tree.unlock()
 
488
            if tree is not work_tree:
 
489
                work_tree.unlock()
 
490
 
 
491
        for path, entry in entries:
 
492
            if kind and kind != entry.kind:
 
493
                continue
243
494
            if show_ids:
244
 
                print '%-50s %s' % (path, entry.file_id)
 
495
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
245
496
            else:
246
 
                print path
247
 
 
248
 
 
249
 
class cmd_move(Command):
250
 
    """Move files to a different directory.
251
 
 
252
 
    examples:
253
 
        bzr move *.txt doc
254
 
 
255
 
    The destination must be a versioned directory in the same branch.
256
 
    """
257
 
    takes_args = ['source$', 'dest']
258
 
    def run(self, source_list, dest):
259
 
        b = Branch.open_containing('.')[0]
260
 
 
261
 
        # TODO: glob expansion on windows?
262
 
        tree = WorkingTree(b.base, b)
263
 
        b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
264
 
 
265
 
 
266
 
class cmd_rename(Command):
267
 
    """Change the name of an entry.
268
 
 
269
 
    examples:
270
 
      bzr rename frob.c frobber.c
271
 
      bzr rename src/frob.c lib/frob.c
272
 
 
273
 
    It is an error if the destination name exists.
274
 
 
275
 
    See also the 'move' command, which moves files into a different
276
 
    directory without changing their name.
277
 
    """
278
 
    # TODO: Some way to rename multiple files without invoking 
279
 
    # bzr for each one?"""
280
 
    takes_args = ['from_name', 'to_name']
281
 
    
282
 
    def run(self, from_name, to_name):
283
 
        b = Branch.open_containing('.')[0]
284
 
        tree = WorkingTree(b.base, b)
285
 
        b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
 
497
                self.outf.write(path)
 
498
                self.outf.write('\n')
286
499
 
287
500
 
288
501
class cmd_mv(Command):
289
502
    """Move or rename a file.
290
503
 
291
 
    usage:
 
504
    :Usage:
292
505
        bzr mv OLDNAME NEWNAME
 
506
 
293
507
        bzr mv SOURCE... DESTINATION
294
508
 
295
509
    If the last argument is a versioned directory, all the other names
296
510
    are moved into it.  Otherwise, there must be exactly two arguments
297
 
    and the file is changed to a new name, which must not already exist.
 
511
    and the file is changed to a new name.
 
512
 
 
513
    If OLDNAME does not exist on the filesystem but is versioned and
 
514
    NEWNAME does exist on the filesystem but is not versioned, mv
 
515
    assumes that the file has been manually moved and only updates
 
516
    its internal inventory to reflect that change.
 
517
    The same is valid when moving many SOURCE files to a DESTINATION.
298
518
 
299
519
    Files cannot be moved between branches.
300
520
    """
 
521
 
301
522
    takes_args = ['names*']
302
 
    def run(self, names_list):
 
523
    takes_options = [Option("after", help="Move only the bzr identifier"
 
524
        " of the file, because the file has already been moved."),
 
525
        ]
 
526
    aliases = ['move', 'rename']
 
527
    encoding_type = 'replace'
 
528
 
 
529
    def run(self, names_list, after=False):
 
530
        if names_list is None:
 
531
            names_list = []
 
532
 
303
533
        if len(names_list) < 2:
304
 
            raise BzrCommandError("missing file argument")
305
 
        b = Branch.open_containing(names_list[0])[0]
306
 
        tree = WorkingTree(b.base, b)
307
 
        rel_names = [tree.relpath(x) for x in names_list]
 
534
            raise errors.BzrCommandError("missing file argument")
 
535
        tree, rel_names = tree_files(names_list)
308
536
        
309
537
        if os.path.isdir(names_list[-1]):
310
538
            # move into existing directory
311
 
            for pair in b.move(rel_names[:-1], rel_names[-1]):
312
 
                print "%s => %s" % pair
 
539
            for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
 
540
                self.outf.write("%s => %s\n" % pair)
313
541
        else:
314
542
            if len(names_list) != 2:
315
 
                raise BzrCommandError('to mv multiple files the destination '
316
 
                                      'must be a versioned directory')
317
 
            b.rename_one(rel_names[0], rel_names[1])
318
 
            print "%s => %s" % (rel_names[0], rel_names[1])
 
543
                raise errors.BzrCommandError('to mv multiple files the'
 
544
                                             ' destination must be a versioned'
 
545
                                             ' directory')
 
546
            tree.rename_one(rel_names[0], rel_names[1], after=after)
 
547
            self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
319
548
            
320
549
    
321
 
 
322
 
 
323
550
class cmd_pull(Command):
324
 
    """Pull any changes from another branch into the current one.
325
 
 
326
 
    If the location is omitted, the last-used location will be used.
327
 
    Both the revision history and the working directory will be
328
 
    updated.
329
 
 
330
 
    This command only works on branches that have not diverged.  Branches are
331
 
    considered diverged if both branches have had commits without first
332
 
    pulling from the other.
333
 
 
334
 
    If branches have diverged, you can use 'bzr merge' to pull the text changes
335
 
    from one into the other.
336
 
    """
337
 
    takes_options = ['remember', 'clobber']
338
 
    takes_args = ['location?']
339
 
 
340
 
    def run(self, location=None, remember=False, clobber=False):
341
 
        from bzrlib.merge import merge
342
 
        import tempfile
343
 
        from shutil import rmtree
344
 
        import errno
345
 
        
346
 
        br_to = Branch.open_containing('.')[0]
347
 
        stored_loc = br_to.get_parent()
348
 
        if location is None:
349
 
            if stored_loc is None:
350
 
                raise BzrCommandError("No pull location known or specified.")
351
 
            else:
352
 
                print "Using saved location: %s" % stored_loc
353
 
                location = stored_loc
354
 
        br_from = Branch.open(location)
355
 
        try:
356
 
            br_to.working_tree().pull(br_from, remember, clobber)
357
 
        except DivergedBranches:
358
 
            raise BzrCommandError("These branches have diverged."
359
 
                                  "  Try merge.")
 
551
    """Turn this branch into a mirror of another branch.
 
552
 
 
553
    This command only works on branches that have not diverged.  Branches are
 
554
    considered diverged if the destination branch's most recent commit is one
 
555
    that has not been merged (directly or indirectly) into the parent.
 
556
 
 
557
    If branches have diverged, you can use 'bzr merge' to integrate the changes
 
558
    from one into the other.  Once one branch has merged, the other should
 
559
    be able to pull it again.
 
560
 
 
561
    If you want to forget your local changes and just update your branch to
 
562
    match the remote one, use pull --overwrite.
 
563
 
 
564
    If there is no default location set, the first pull will set it.  After
 
565
    that, you can omit the location to use the default.  To change the
 
566
    default, use --remember. The value will only be saved if the remote
 
567
    location can be accessed.
 
568
    """
 
569
 
 
570
    _see_also = ['push', 'update', 'status-flags']
 
571
    takes_options = ['remember', 'overwrite', 'revision',
 
572
        custom_help('verbose',
 
573
            help='Show logs of pulled revisions.'),
 
574
        Option('directory',
 
575
            help='Branch to pull into, '
 
576
                 'rather than the one containing the working directory.',
 
577
            short_name='d',
 
578
            type=unicode,
 
579
            ),
 
580
        ]
 
581
    takes_args = ['location?']
 
582
    encoding_type = 'replace'
 
583
 
 
584
    def run(self, location=None, remember=False, overwrite=False,
 
585
            revision=None, verbose=False,
 
586
            directory=None):
 
587
        # FIXME: too much stuff is in the command class
 
588
        revision_id = None
 
589
        mergeable = None
 
590
        if directory is None:
 
591
            directory = u'.'
 
592
        try:
 
593
            tree_to = WorkingTree.open_containing(directory)[0]
 
594
            branch_to = tree_to.branch
 
595
        except errors.NoWorkingTree:
 
596
            tree_to = None
 
597
            branch_to = Branch.open_containing(directory)[0]
 
598
 
 
599
        if location is not None:
 
600
            mergeable, location_transport = _get_mergeable_helper(location)
 
601
 
 
602
        stored_loc = branch_to.get_parent()
 
603
        if location is None:
 
604
            if stored_loc is None:
 
605
                raise errors.BzrCommandError("No pull location known or"
 
606
                                             " specified.")
 
607
            else:
 
608
                display_url = urlutils.unescape_for_display(stored_loc,
 
609
                        self.outf.encoding)
 
610
                self.outf.write("Using saved location: %s\n" % display_url)
 
611
                location = stored_loc
 
612
                location_transport = transport.get_transport(location)
 
613
 
 
614
        if mergeable is not None:
 
615
            if revision is not None:
 
616
                raise errors.BzrCommandError(
 
617
                    'Cannot use -r with merge directives or bundles')
 
618
            mergeable.install_revisions(branch_to.repository)
 
619
            base_revision_id, revision_id, verified = \
 
620
                mergeable.get_merge_request(branch_to.repository)
 
621
            branch_from = branch_to
 
622
        else:
 
623
            branch_from = Branch.open_from_transport(location_transport)
 
624
 
 
625
            if branch_to.get_parent() is None or remember:
 
626
                branch_to.set_parent(branch_from.base)
 
627
 
 
628
        if revision is not None:
 
629
            if len(revision) == 1:
 
630
                revision_id = revision[0].in_history(branch_from).rev_id
 
631
            else:
 
632
                raise errors.BzrCommandError(
 
633
                    'bzr pull --revision takes one value.')
 
634
 
 
635
        if verbose:
 
636
            old_rh = branch_to.revision_history()
 
637
        if tree_to is not None:
 
638
            result = tree_to.pull(branch_from, overwrite, revision_id,
 
639
                delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
 
640
        else:
 
641
            result = branch_to.pull(branch_from, overwrite, revision_id)
 
642
 
 
643
        result.report(self.outf)
 
644
        if verbose:
 
645
            new_rh = branch_to.revision_history()
 
646
            log.show_changed_revisions(branch_to, old_rh, new_rh,
 
647
                                       to_file=self.outf)
 
648
 
 
649
 
 
650
class cmd_push(Command):
 
651
    """Update a mirror of this branch.
 
652
    
 
653
    The target branch will not have its working tree populated because this
 
654
    is both expensive, and is not supported on remote file systems.
 
655
    
 
656
    Some smart servers or protocols *may* put the working tree in place in
 
657
    the future.
 
658
 
 
659
    This command only works on branches that have not diverged.  Branches are
 
660
    considered diverged if the destination branch's most recent commit is one
 
661
    that has not been merged (directly or indirectly) by the source branch.
 
662
 
 
663
    If branches have diverged, you can use 'bzr push --overwrite' to replace
 
664
    the other branch completely, discarding its unmerged changes.
 
665
    
 
666
    If you want to ensure you have the different changes in the other branch,
 
667
    do a merge (see bzr help merge) from the other branch, and commit that.
 
668
    After that you will be able to do a push without '--overwrite'.
 
669
 
 
670
    If there is no default push location set, the first push will set it.
 
671
    After that, you can omit the location to use the default.  To change the
 
672
    default, use --remember. The value will only be saved if the remote
 
673
    location can be accessed.
 
674
    """
 
675
 
 
676
    _see_also = ['pull', 'update', 'working-trees']
 
677
    takes_options = ['remember', 'overwrite', 'verbose',
 
678
        Option('create-prefix',
 
679
               help='Create the path leading up to the branch '
 
680
                    'if it does not already exist.'),
 
681
        Option('directory',
 
682
            help='Branch to push from, '
 
683
                 'rather than the one containing the working directory.',
 
684
            short_name='d',
 
685
            type=unicode,
 
686
            ),
 
687
        Option('use-existing-dir',
 
688
               help='By default push will fail if the target'
 
689
                    ' directory exists, but does not already'
 
690
                    ' have a control directory.  This flag will'
 
691
                    ' allow push to proceed.'),
 
692
        ]
 
693
    takes_args = ['location?']
 
694
    encoding_type = 'replace'
 
695
 
 
696
    def run(self, location=None, remember=False, overwrite=False,
 
697
            create_prefix=False, verbose=False,
 
698
            use_existing_dir=False,
 
699
            directory=None):
 
700
        # FIXME: Way too big!  Put this into a function called from the
 
701
        # command.
 
702
        if directory is None:
 
703
            directory = '.'
 
704
        br_from = Branch.open_containing(directory)[0]
 
705
        stored_loc = br_from.get_push_location()
 
706
        if location is None:
 
707
            if stored_loc is None:
 
708
                raise errors.BzrCommandError("No push location known or specified.")
 
709
            else:
 
710
                display_url = urlutils.unescape_for_display(stored_loc,
 
711
                        self.outf.encoding)
 
712
                self.outf.write("Using saved location: %s\n" % display_url)
 
713
                location = stored_loc
 
714
 
 
715
        to_transport = transport.get_transport(location)
 
716
 
 
717
        br_to = repository_to = dir_to = None
 
718
        try:
 
719
            dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
 
720
        except errors.NotBranchError:
 
721
            pass # Didn't find anything
 
722
        else:
 
723
            # If we can open a branch, use its direct repository, otherwise see
 
724
            # if there is a repository without a branch.
 
725
            try:
 
726
                br_to = dir_to.open_branch()
 
727
            except errors.NotBranchError:
 
728
                # Didn't find a branch, can we find a repository?
 
729
                try:
 
730
                    repository_to = dir_to.find_repository()
 
731
                except errors.NoRepositoryPresent:
 
732
                    pass
 
733
            else:
 
734
                # Found a branch, so we must have found a repository
 
735
                repository_to = br_to.repository
 
736
        push_result = None
 
737
        if verbose:
 
738
            old_rh = []
 
739
        if dir_to is None:
 
740
            # The destination doesn't exist; create it.
 
741
            # XXX: Refactor the create_prefix/no_create_prefix code into a
 
742
            #      common helper function
 
743
            try:
 
744
                to_transport.mkdir('.')
 
745
            except errors.FileExists:
 
746
                if not use_existing_dir:
 
747
                    raise errors.BzrCommandError("Target directory %s"
 
748
                         " already exists, but does not have a valid .bzr"
 
749
                         " directory. Supply --use-existing-dir to push"
 
750
                         " there anyway." % location)
 
751
            except errors.NoSuchFile:
 
752
                if not create_prefix:
 
753
                    raise errors.BzrCommandError("Parent directory of %s"
 
754
                        " does not exist."
 
755
                        "\nYou may supply --create-prefix to create all"
 
756
                        " leading parent directories."
 
757
                        % location)
 
758
                _create_prefix(to_transport)
 
759
 
 
760
            # Now the target directory exists, but doesn't have a .bzr
 
761
            # directory. So we need to create it, along with any work to create
 
762
            # all of the dependent branches, etc.
 
763
            dir_to = br_from.bzrdir.clone_on_transport(to_transport,
 
764
                revision_id=br_from.last_revision())
 
765
            br_to = dir_to.open_branch()
 
766
            # TODO: Some more useful message about what was copied
 
767
            note('Created new branch.')
 
768
            # We successfully created the target, remember it
 
769
            if br_from.get_push_location() is None or remember:
 
770
                br_from.set_push_location(br_to.base)
 
771
        elif repository_to is None:
 
772
            # we have a bzrdir but no branch or repository
 
773
            # XXX: Figure out what to do other than complain.
 
774
            raise errors.BzrCommandError("At %s you have a valid .bzr control"
 
775
                " directory, but not a branch or repository. This is an"
 
776
                " unsupported configuration. Please move the target directory"
 
777
                " out of the way and try again."
 
778
                % location)
 
779
        elif br_to is None:
 
780
            # We have a repository but no branch, copy the revisions, and then
 
781
            # create a branch.
 
782
            last_revision_id = br_from.last_revision()
 
783
            repository_to.fetch(br_from.repository,
 
784
                                revision_id=last_revision_id)
 
785
            br_to = br_from.clone(dir_to, revision_id=last_revision_id)
 
786
            note('Created new branch.')
 
787
            if br_from.get_push_location() is None or remember:
 
788
                br_from.set_push_location(br_to.base)
 
789
        else: # We have a valid to branch
 
790
            # We were able to connect to the remote location, so remember it
 
791
            # we don't need to successfully push because of possible divergence.
 
792
            if br_from.get_push_location() is None or remember:
 
793
                br_from.set_push_location(br_to.base)
 
794
            if verbose:
 
795
                old_rh = br_to.revision_history()
 
796
            try:
 
797
                try:
 
798
                    tree_to = dir_to.open_workingtree()
 
799
                except errors.NotLocalUrl:
 
800
                    warning("This transport does not update the working " 
 
801
                            "tree of: %s. See 'bzr help working-trees' for "
 
802
                            "more information." % br_to.base)
 
803
                    push_result = br_from.push(br_to, overwrite)
 
804
                except errors.NoWorkingTree:
 
805
                    push_result = br_from.push(br_to, overwrite)
 
806
                else:
 
807
                    tree_to.lock_write()
 
808
                    try:
 
809
                        push_result = br_from.push(tree_to.branch, overwrite)
 
810
                        tree_to.update()
 
811
                    finally:
 
812
                        tree_to.unlock()
 
813
            except errors.DivergedBranches:
 
814
                raise errors.BzrCommandError('These branches have diverged.'
 
815
                                        '  Try using "merge" and then "push".')
 
816
        if push_result is not None:
 
817
            push_result.report(self.outf)
 
818
        elif verbose:
 
819
            new_rh = br_to.revision_history()
 
820
            if old_rh != new_rh:
 
821
                # Something changed
 
822
                from bzrlib.log import show_changed_revisions
 
823
                show_changed_revisions(br_to, old_rh, new_rh,
 
824
                                       to_file=self.outf)
 
825
        else:
 
826
            # we probably did a clone rather than a push, so a message was
 
827
            # emitted above
 
828
            pass
360
829
 
361
830
 
362
831
class cmd_branch(Command):
364
833
 
365
834
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
366
835
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
 
836
    If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
 
837
    is derived from the FROM_LOCATION by stripping a leading scheme or drive
 
838
    identifier, if any. For example, "branch lp:foo-bar" will attempt to
 
839
    create ./foo-bar.
367
840
 
368
841
    To retrieve the branch as of a particular revision, supply the --revision
369
842
    parameter, as in "branch foo/bar -r 5".
 
843
    """
370
844
 
371
 
    --basis is to speed up branching from remote branches.  When specified, it
372
 
    copies all the file-contents, inventory and revision data from the basis
373
 
    branch before copying anything from the remote branch.
374
 
    """
 
845
    _see_also = ['checkout']
375
846
    takes_args = ['from_location', 'to_location?']
376
 
    takes_options = ['revision', 'basis']
 
847
    takes_options = ['revision']
377
848
    aliases = ['get', 'clone']
378
849
 
379
 
    def run(self, from_location, to_location=None, revision=None, basis=None):
380
 
        from bzrlib.clone import copy_branch
381
 
        import tempfile
382
 
        import errno
383
 
        from shutil import rmtree
384
 
        cache_root = tempfile.mkdtemp()
 
850
    def run(self, from_location, to_location=None, revision=None):
 
851
        from bzrlib.tag import _merge_tags_if_possible
385
852
        if revision is None:
386
853
            revision = [None]
387
854
        elif len(revision) > 1:
388
 
            raise BzrCommandError(
 
855
            raise errors.BzrCommandError(
389
856
                'bzr branch --revision takes exactly 1 revision value')
390
 
        try:
391
 
            br_from = Branch.open(from_location)
392
 
        except OSError, e:
393
 
            if e.errno == errno.ENOENT:
394
 
                raise BzrCommandError('Source location "%s" does not'
395
 
                                      ' exist.' % to_location)
396
 
            else:
397
 
                raise
 
857
 
 
858
        br_from = Branch.open(from_location)
398
859
        br_from.lock_read()
399
860
        try:
400
 
            br_from.setup_caching(cache_root)
401
 
            if basis is not None:
402
 
                basis_branch = Branch.open_containing(basis)[0]
403
 
            else:
404
 
                basis_branch = None
405
861
            if len(revision) == 1 and revision[0] is not None:
406
862
                revision_id = revision[0].in_history(br_from)[1]
407
863
            else:
408
 
                revision_id = None
 
864
                # FIXME - wt.last_revision, fallback to branch, fall back to
 
865
                # None or perhaps NULL_REVISION to mean copy nothing
 
866
                # RBC 20060209
 
867
                revision_id = br_from.last_revision()
409
868
            if to_location is None:
410
 
                to_location = os.path.basename(from_location.rstrip("/\\"))
411
 
            try:
412
 
                os.mkdir(to_location)
413
 
            except OSError, e:
414
 
                if e.errno == errno.EEXIST:
415
 
                    raise BzrCommandError('Target directory "%s" already'
416
 
                                          ' exists.' % to_location)
417
 
                if e.errno == errno.ENOENT:
418
 
                    raise BzrCommandError('Parent of "%s" does not exist.' %
419
 
                                          to_location)
420
 
                else:
421
 
                    raise
422
 
            try:
423
 
                copy_branch(br_from, to_location, revision_id, basis_branch)
424
 
            except bzrlib.errors.NoSuchRevision:
425
 
                rmtree(to_location)
 
869
                to_location = urlutils.derive_to_location(from_location)
 
870
                name = None
 
871
            else:
 
872
                name = os.path.basename(to_location) + '\n'
 
873
 
 
874
            to_transport = transport.get_transport(to_location)
 
875
            try:
 
876
                to_transport.mkdir('.')
 
877
            except errors.FileExists:
 
878
                raise errors.BzrCommandError('Target directory "%s" already'
 
879
                                             ' exists.' % to_location)
 
880
            except errors.NoSuchFile:
 
881
                raise errors.BzrCommandError('Parent of "%s" does not exist.'
 
882
                                             % to_location)
 
883
            try:
 
884
                # preserve whatever source format we have.
 
885
                dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
 
886
                                            possible_transports=[to_transport])
 
887
                branch = dir.open_branch()
 
888
            except errors.NoSuchRevision:
 
889
                to_transport.delete_tree('.')
426
890
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
427
 
                raise BzrCommandError(msg)
428
 
            except bzrlib.errors.UnlistableBranch:
429
 
                msg = "The branch %s cannot be used as a --basis"
 
891
                raise errors.BzrCommandError(msg)
 
892
            if name:
 
893
                branch.control_files.put_utf8('branch-name', name)
 
894
            _merge_tags_if_possible(br_from, branch)
 
895
            note('Branched %d revision(s).' % branch.revno())
430
896
        finally:
431
897
            br_from.unlock()
432
 
            rmtree(cache_root)
 
898
 
 
899
 
 
900
class cmd_checkout(Command):
 
901
    """Create a new checkout of an existing branch.
 
902
 
 
903
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
 
904
    the branch found in '.'. This is useful if you have removed the working tree
 
905
    or if it was never created - i.e. if you pushed the branch to its current
 
906
    location using SFTP.
 
907
    
 
908
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
 
909
    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
 
910
    If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
 
911
    is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
 
912
    identifier, if any. For example, "checkout lp:foo-bar" will attempt to
 
913
    create ./foo-bar.
 
914
 
 
915
    To retrieve the branch as of a particular revision, supply the --revision
 
916
    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
 
917
    out of date [so you cannot commit] but it may be useful (i.e. to examine old
 
918
    code.)
 
919
    """
 
920
 
 
921
    _see_also = ['checkouts', 'branch']
 
922
    takes_args = ['branch_location?', 'to_location?']
 
923
    takes_options = ['revision',
 
924
                     Option('lightweight',
 
925
                            help="Perform a lightweight checkout.  Lightweight "
 
926
                                 "checkouts depend on access to the branch for "
 
927
                                 "every operation.  Normal checkouts can perform "
 
928
                                 "common operations like diff and status without "
 
929
                                 "such access, and also support local commits."
 
930
                            ),
 
931
                     ]
 
932
    aliases = ['co']
 
933
 
 
934
    def run(self, branch_location=None, to_location=None, revision=None,
 
935
            lightweight=False):
 
936
        if revision is None:
 
937
            revision = [None]
 
938
        elif len(revision) > 1:
 
939
            raise errors.BzrCommandError(
 
940
                'bzr checkout --revision takes exactly 1 revision value')
 
941
        if branch_location is None:
 
942
            branch_location = osutils.getcwd()
 
943
            to_location = branch_location
 
944
        source = Branch.open(branch_location)
 
945
        if len(revision) == 1 and revision[0] is not None:
 
946
            revision_id = _mod_revision.ensure_null(
 
947
                revision[0].in_history(source)[1])
 
948
        else:
 
949
            revision_id = None
 
950
        if to_location is None:
 
951
            to_location = urlutils.derive_to_location(branch_location)
 
952
        # if the source and to_location are the same, 
 
953
        # and there is no working tree,
 
954
        # then reconstitute a branch
 
955
        if (osutils.abspath(to_location) ==
 
956
            osutils.abspath(branch_location)):
 
957
            try:
 
958
                source.bzrdir.open_workingtree()
 
959
            except errors.NoWorkingTree:
 
960
                source.bzrdir.create_workingtree(revision_id)
 
961
                return
 
962
        source.create_checkout(to_location, revision_id, lightweight)
433
963
 
434
964
 
435
965
class cmd_renames(Command):
438
968
    # TODO: Option to show renames between two historical versions.
439
969
 
440
970
    # TODO: Only show renames under dir, rather than in the whole branch.
441
 
    takes_args = ['dir?']
 
971
    _see_also = ['status']
 
972
    takes_args = ['dir?']
 
973
 
 
974
    @display_command
 
975
    def run(self, dir=u'.'):
 
976
        tree = WorkingTree.open_containing(dir)[0]
 
977
        tree.lock_read()
 
978
        try:
 
979
            new_inv = tree.inventory
 
980
            old_tree = tree.basis_tree()
 
981
            old_tree.lock_read()
 
982
            try:
 
983
                old_inv = old_tree.inventory
 
984
                renames = list(_mod_tree.find_renames(old_inv, new_inv))
 
985
                renames.sort()
 
986
                for old_name, new_name in renames:
 
987
                    self.outf.write("%s => %s\n" % (old_name, new_name))
 
988
            finally:
 
989
                old_tree.unlock()
 
990
        finally:
 
991
            tree.unlock()
 
992
 
 
993
 
 
994
class cmd_update(Command):
 
995
    """Update a tree to have the latest code committed to its branch.
 
996
    
 
997
    This will perform a merge into the working tree, and may generate
 
998
    conflicts. If you have any local changes, you will still 
 
999
    need to commit them after the update for the update to be complete.
 
1000
    
 
1001
    If you want to discard your local changes, you can just do a 
 
1002
    'bzr revert' instead of 'bzr commit' after the update.
 
1003
    """
 
1004
 
 
1005
    _see_also = ['pull', 'working-trees', 'status-flags']
 
1006
    takes_args = ['dir?']
 
1007
    aliases = ['up']
442
1008
 
443
1009
    def run(self, dir='.'):
444
 
        b = Branch.open_containing(dir)[0]
445
 
        old_inv = b.basis_tree().inventory
446
 
        new_inv = b.read_working_inventory()
447
 
 
448
 
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
449
 
        renames.sort()
450
 
        for old_name, new_name in renames:
451
 
            print "%s => %s" % (old_name, new_name)        
 
1010
        tree = WorkingTree.open_containing(dir)[0]
 
1011
        master = tree.branch.get_master_branch()
 
1012
        if master is not None:
 
1013
            tree.lock_write()
 
1014
        else:
 
1015
            tree.lock_tree_write()
 
1016
        try:
 
1017
            existing_pending_merges = tree.get_parent_ids()[1:]
 
1018
            last_rev = _mod_revision.ensure_null(tree.last_revision())
 
1019
            if last_rev == _mod_revision.ensure_null(
 
1020
                tree.branch.last_revision()):
 
1021
                # may be up to date, check master too.
 
1022
                if master is None or last_rev == _mod_revision.ensure_null(
 
1023
                    master.last_revision()):
 
1024
                    revno = tree.branch.revision_id_to_revno(last_rev)
 
1025
                    note("Tree is up to date at revision %d." % (revno,))
 
1026
                    return 0
 
1027
            conflicts = tree.update(delta._ChangeReporter(
 
1028
                                        unversioned_filter=tree.is_ignored))
 
1029
            revno = tree.branch.revision_id_to_revno(
 
1030
                _mod_revision.ensure_null(tree.last_revision()))
 
1031
            note('Updated to revision %d.' % (revno,))
 
1032
            if tree.get_parent_ids()[1:] != existing_pending_merges:
 
1033
                note('Your local commits will now show as pending merges with '
 
1034
                     "'bzr status', and can be committed with 'bzr commit'.")
 
1035
            if conflicts != 0:
 
1036
                return 1
 
1037
            else:
 
1038
                return 0
 
1039
        finally:
 
1040
            tree.unlock()
452
1041
 
453
1042
 
454
1043
class cmd_info(Command):
455
 
    """Show statistical information about a branch."""
456
 
    takes_args = ['branch?']
457
 
    
458
 
    def run(self, branch=None):
459
 
        import info
460
 
        b = Branch.open_containing(branch)[0]
461
 
        info.show_info(b)
 
1044
    """Show information about a working tree, branch or repository.
 
1045
 
 
1046
    This command will show all known locations and formats associated to the
 
1047
    tree, branch or repository.  Statistical information is included with
 
1048
    each report.
 
1049
 
 
1050
    Branches and working trees will also report any missing revisions.
 
1051
    """
 
1052
    _see_also = ['revno', 'working-trees', 'repositories']
 
1053
    takes_args = ['location?']
 
1054
    takes_options = ['verbose']
 
1055
 
 
1056
    @display_command
 
1057
    def run(self, location=None, verbose=False):
 
1058
        if verbose:
 
1059
            noise_level = 2
 
1060
        else:
 
1061
            noise_level = 0
 
1062
        from bzrlib.info import show_bzrdir_info
 
1063
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
 
1064
                         verbose=noise_level)
462
1065
 
463
1066
 
464
1067
class cmd_remove(Command):
465
 
    """Make a file unversioned.
466
 
 
467
 
    This makes bzr stop tracking changes to a versioned file.  It does
468
 
    not delete the working copy.
 
1068
    """Remove files or directories.
 
1069
 
 
1070
    This makes bzr stop tracking changes to the specified files and
 
1071
    delete them if they can easily be recovered using revert.
 
1072
 
 
1073
    You can specify one or more files, and/or --new.  If you specify --new,
 
1074
    only 'added' files will be removed.  If you specify both, then new files
 
1075
    in the specified directories will be removed.  If the directories are
 
1076
    also new, they will also be removed.
469
1077
    """
470
 
    takes_args = ['file+']
471
 
    takes_options = ['verbose']
 
1078
    takes_args = ['file*']
 
1079
    takes_options = ['verbose',
 
1080
        Option('new', help='Remove newly-added files.'),
 
1081
        RegistryOption.from_kwargs('file-deletion-strategy',
 
1082
            'The file deletion mode to be used.',
 
1083
            title='Deletion Strategy', value_switches=True, enum_switch=False,
 
1084
            safe='Only delete files if they can be'
 
1085
                 ' safely recovered (default).',
 
1086
            keep="Don't delete any files.",
 
1087
            force='Delete all the specified files, even if they can not be '
 
1088
                'recovered and even if they are non-empty directories.')]
472
1089
    aliases = ['rm']
473
 
    
474
 
    def run(self, file_list, verbose=False):
475
 
        b = Branch.open_containing(file_list[0])[0]
476
 
        tree = WorkingTree(b.base, b)
477
 
        tree.remove([tree.relpath(f) for f in file_list], verbose=verbose)
 
1090
    encoding_type = 'replace'
 
1091
 
 
1092
    def run(self, file_list, verbose=False, new=False,
 
1093
        file_deletion_strategy='safe'):
 
1094
        tree, file_list = tree_files(file_list)
 
1095
 
 
1096
        if file_list is not None:
 
1097
            file_list = [f for f in file_list if f != '']
 
1098
        elif not new:
 
1099
            raise errors.BzrCommandError('Specify one or more files to'
 
1100
            ' remove, or use --new.')
 
1101
 
 
1102
        if new:
 
1103
            added = tree.changes_from(tree.basis_tree(),
 
1104
                specific_files=file_list).added
 
1105
            file_list = sorted([f[0] for f in added], reverse=True)
 
1106
            if len(file_list) == 0:
 
1107
                raise errors.BzrCommandError('No matching files.')
 
1108
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
 
1109
            keep_files=file_deletion_strategy=='keep',
 
1110
            force=file_deletion_strategy=='force')
478
1111
 
479
1112
 
480
1113
class cmd_file_id(Command):
484
1117
    same through all revisions where the file exists, even when it is
485
1118
    moved or renamed.
486
1119
    """
 
1120
 
487
1121
    hidden = True
 
1122
    _see_also = ['inventory', 'ls']
488
1123
    takes_args = ['filename']
 
1124
 
 
1125
    @display_command
489
1126
    def run(self, filename):
490
 
        b, relpath = Branch.open_containing(filename)
491
 
        i = b.inventory.path2id(relpath)
492
 
        if i == None:
493
 
            raise BzrError("%r is not a versioned file" % filename)
 
1127
        tree, relpath = WorkingTree.open_containing(filename)
 
1128
        i = tree.path2id(relpath)
 
1129
        if i is None:
 
1130
            raise errors.NotVersionedError(filename)
494
1131
        else:
495
 
            print i
 
1132
            self.outf.write(i + '\n')
496
1133
 
497
1134
 
498
1135
class cmd_file_path(Command):
499
1136
    """Print path of file_ids to a file or directory.
500
1137
 
501
1138
    This prints one line for each directory down to the target,
502
 
    starting at the branch root."""
 
1139
    starting at the branch root.
 
1140
    """
 
1141
 
503
1142
    hidden = True
504
1143
    takes_args = ['filename']
 
1144
 
 
1145
    @display_command
505
1146
    def run(self, filename):
506
 
        b, relpath = Branch.open_containing(filename)
507
 
        inv = b.inventory
508
 
        fid = inv.path2id(relpath)
509
 
        if fid == None:
510
 
            raise BzrError("%r is not a versioned file" % filename)
511
 
        for fip in inv.get_idpath(fid):
512
 
            print fip
 
1147
        tree, relpath = WorkingTree.open_containing(filename)
 
1148
        fid = tree.path2id(relpath)
 
1149
        if fid is None:
 
1150
            raise errors.NotVersionedError(filename)
 
1151
        segments = osutils.splitpath(relpath)
 
1152
        for pos in range(1, len(segments) + 1):
 
1153
            path = osutils.joinpath(segments[:pos])
 
1154
            self.outf.write("%s\n" % tree.path2id(path))
 
1155
 
 
1156
 
 
1157
class cmd_reconcile(Command):
 
1158
    """Reconcile bzr metadata in a branch.
 
1159
 
 
1160
    This can correct data mismatches that may have been caused by
 
1161
    previous ghost operations or bzr upgrades. You should only
 
1162
    need to run this command if 'bzr check' or a bzr developer 
 
1163
    advises you to run it.
 
1164
 
 
1165
    If a second branch is provided, cross-branch reconciliation is
 
1166
    also attempted, which will check that data like the tree root
 
1167
    id which was not present in very early bzr versions is represented
 
1168
    correctly in both branches.
 
1169
 
 
1170
    At the same time it is run it may recompress data resulting in 
 
1171
    a potential saving in disk space or performance gain.
 
1172
 
 
1173
    The branch *MUST* be on a listable system such as local disk or sftp.
 
1174
    """
 
1175
 
 
1176
    _see_also = ['check']
 
1177
    takes_args = ['branch?']
 
1178
 
 
1179
    def run(self, branch="."):
 
1180
        from bzrlib.reconcile import reconcile
 
1181
        dir = bzrdir.BzrDir.open(branch)
 
1182
        reconcile(dir)
513
1183
 
514
1184
 
515
1185
class cmd_revision_history(Command):
516
 
    """Display list of revision ids on this branch."""
 
1186
    """Display the list of revision ids on a branch."""
 
1187
 
 
1188
    _see_also = ['log']
 
1189
    takes_args = ['location?']
 
1190
 
517
1191
    hidden = True
518
 
    def run(self):
519
 
        for patchid in Branch.open_containing('.')[0].revision_history():
520
 
            print patchid
 
1192
 
 
1193
    @display_command
 
1194
    def run(self, location="."):
 
1195
        branch = Branch.open_containing(location)[0]
 
1196
        for revid in branch.revision_history():
 
1197
            self.outf.write(revid)
 
1198
            self.outf.write('\n')
521
1199
 
522
1200
 
523
1201
class cmd_ancestry(Command):
524
1202
    """List all revisions merged into this branch."""
 
1203
 
 
1204
    _see_also = ['log', 'revision-history']
 
1205
    takes_args = ['location?']
 
1206
 
525
1207
    hidden = True
526
 
    def run(self):
527
 
        b = find_branch('.')
528
 
        for revision_id in b.get_ancestry(b.last_revision()):
529
 
            print revision_id
530
 
 
531
 
 
532
 
class cmd_directories(Command):
533
 
    """Display list of versioned directories in this branch."""
534
 
    def run(self):
535
 
        for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
536
 
            if name == '':
537
 
                print '.'
538
 
            else:
539
 
                print name
 
1208
 
 
1209
    @display_command
 
1210
    def run(self, location="."):
 
1211
        try:
 
1212
            wt = WorkingTree.open_containing(location)[0]
 
1213
        except errors.NoWorkingTree:
 
1214
            b = Branch.open(location)
 
1215
            last_revision = b.last_revision()
 
1216
        else:
 
1217
            b = wt.branch
 
1218
            last_revision = wt.last_revision()
 
1219
 
 
1220
        revision_ids = b.repository.get_ancestry(last_revision)
 
1221
        assert revision_ids[0] is None
 
1222
        revision_ids.pop(0)
 
1223
        for revision_id in revision_ids:
 
1224
            self.outf.write(revision_id + '\n')
540
1225
 
541
1226
 
542
1227
class cmd_init(Command):
545
1230
    Use this to create an empty branch, or before importing an
546
1231
    existing project.
547
1232
 
548
 
    Recipe for importing a tree of files:
 
1233
    If there is a repository in a parent directory of the location, then 
 
1234
    the history of the branch will be stored in the repository.  Otherwise
 
1235
    init creates a standalone branch which carries its own history
 
1236
    in the .bzr directory.
 
1237
 
 
1238
    If there is already a branch at the location but it has no working tree,
 
1239
    the tree can be populated with 'bzr checkout'.
 
1240
 
 
1241
    Recipe for importing a tree of files::
 
1242
 
549
1243
        cd ~/project
550
1244
        bzr init
551
 
        bzr add -v .
 
1245
        bzr add .
552
1246
        bzr status
553
1247
        bzr commit -m 'imported project'
554
1248
    """
555
 
    def run(self):
556
 
        Branch.initialize('.')
 
1249
 
 
1250
    _see_also = ['init-repository', 'branch', 'checkout']
 
1251
    takes_args = ['location?']
 
1252
    takes_options = [
 
1253
        Option('create-prefix',
 
1254
               help='Create the path leading up to the branch '
 
1255
                    'if it does not already exist.'),
 
1256
         RegistryOption('format',
 
1257
                help='Specify a format for this branch. '
 
1258
                'See "help formats".',
 
1259
                registry=bzrdir.format_registry,
 
1260
                converter=bzrdir.format_registry.make_bzrdir,
 
1261
                value_switches=True,
 
1262
                title="Branch Format",
 
1263
                ),
 
1264
         Option('append-revisions-only',
 
1265
                help='Never change revnos or the existing log.'
 
1266
                '  Append revisions to it only.')
 
1267
         ]
 
1268
    def run(self, location=None, format=None, append_revisions_only=False,
 
1269
            create_prefix=False):
 
1270
        if format is None:
 
1271
            format = bzrdir.format_registry.make_bzrdir('default')
 
1272
        if location is None:
 
1273
            location = u'.'
 
1274
 
 
1275
        to_transport = transport.get_transport(location)
 
1276
 
 
1277
        # The path has to exist to initialize a
 
1278
        # branch inside of it.
 
1279
        # Just using os.mkdir, since I don't
 
1280
        # believe that we want to create a bunch of
 
1281
        # locations if the user supplies an extended path
 
1282
        try:
 
1283
            to_transport.ensure_base()
 
1284
        except errors.NoSuchFile:
 
1285
            if not create_prefix:
 
1286
                raise errors.BzrCommandError("Parent directory of %s"
 
1287
                    " does not exist."
 
1288
                    "\nYou may supply --create-prefix to create all"
 
1289
                    " leading parent directories."
 
1290
                    % location)
 
1291
            _create_prefix(to_transport)
 
1292
 
 
1293
        try:
 
1294
            existing_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
 
1295
        except errors.NotBranchError:
 
1296
            # really a NotBzrDir error...
 
1297
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1298
            branch = create_branch(to_transport.base, format=format,
 
1299
                                   possible_transports=[to_transport])
 
1300
        else:
 
1301
            from bzrlib.transport.local import LocalTransport
 
1302
            if existing_bzrdir.has_branch():
 
1303
                if (isinstance(to_transport, LocalTransport)
 
1304
                    and not existing_bzrdir.has_workingtree()):
 
1305
                        raise errors.BranchExistsWithoutWorkingTree(location)
 
1306
                raise errors.AlreadyBranchError(location)
 
1307
            else:
 
1308
                branch = existing_bzrdir.create_branch()
 
1309
                existing_bzrdir.create_workingtree()
 
1310
        if append_revisions_only:
 
1311
            try:
 
1312
                branch.set_append_revisions_only(True)
 
1313
            except errors.UpgradeRequired:
 
1314
                raise errors.BzrCommandError('This branch format cannot be set'
 
1315
                    ' to append-revisions-only.  Try --experimental-branch6')
 
1316
 
 
1317
 
 
1318
class cmd_init_repository(Command):
 
1319
    """Create a shared repository to hold branches.
 
1320
 
 
1321
    New branches created under the repository directory will store their
 
1322
    revisions in the repository, not in the branch directory.
 
1323
 
 
1324
    If the --no-trees option is used then the branches in the repository
 
1325
    will not have working trees by default.
 
1326
 
 
1327
    :Examples:
 
1328
        Create a shared repositories holding just branches::
 
1329
 
 
1330
            bzr init-repo --no-trees repo
 
1331
            bzr init repo/trunk
 
1332
 
 
1333
        Make a lightweight checkout elsewhere::
 
1334
 
 
1335
            bzr checkout --lightweight repo/trunk trunk-checkout
 
1336
            cd trunk-checkout
 
1337
            (add files here)
 
1338
    """
 
1339
 
 
1340
    _see_also = ['init', 'branch', 'checkout', 'repositories']
 
1341
    takes_args = ["location"]
 
1342
    takes_options = [RegistryOption('format',
 
1343
                            help='Specify a format for this repository. See'
 
1344
                                 ' "bzr help formats" for details.',
 
1345
                            registry=bzrdir.format_registry,
 
1346
                            converter=bzrdir.format_registry.make_bzrdir,
 
1347
                            value_switches=True, title='Repository format'),
 
1348
                     Option('no-trees',
 
1349
                             help='Branches in the repository will default to'
 
1350
                                  ' not having a working tree.'),
 
1351
                    ]
 
1352
    aliases = ["init-repo"]
 
1353
 
 
1354
    def run(self, location, format=None, no_trees=False):
 
1355
        if format is None:
 
1356
            format = bzrdir.format_registry.make_bzrdir('default')
 
1357
 
 
1358
        if location is None:
 
1359
            location = '.'
 
1360
 
 
1361
        to_transport = transport.get_transport(location)
 
1362
        to_transport.ensure_base()
 
1363
 
 
1364
        newdir = format.initialize_on_transport(to_transport)
 
1365
        repo = newdir.create_repository(shared=True)
 
1366
        repo.set_make_working_trees(not no_trees)
557
1367
 
558
1368
 
559
1369
class cmd_diff(Command):
560
 
    """Show differences in working tree.
 
1370
    """Show differences in the working tree or between revisions.
561
1371
    
562
1372
    If files are listed, only the changes in those files are listed.
563
1373
    Otherwise, all changes for the tree are listed.
564
1374
 
565
 
    examples:
566
 
        bzr diff
567
 
        bzr diff -r1
568
 
        bzr diff -r1..2
 
1375
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
 
1376
    produces patches suitable for "patch -p1".
 
1377
 
 
1378
    :Examples:
 
1379
        Shows the difference in the working tree versus the last commit::
 
1380
 
 
1381
            bzr diff
 
1382
 
 
1383
        Difference between the working tree and revision 1::
 
1384
 
 
1385
            bzr diff -r1
 
1386
 
 
1387
        Difference between revision 2 and revision 1::
 
1388
 
 
1389
            bzr diff -r1..2
 
1390
 
 
1391
        Same as 'bzr diff' but prefix paths with old/ and new/::
 
1392
 
 
1393
            bzr diff --prefix old/:new/
 
1394
 
 
1395
        Show the differences between the two working trees::
 
1396
 
 
1397
            bzr diff bzr.mine bzr.dev
 
1398
 
 
1399
        Show just the differences for 'foo.c'::
 
1400
 
 
1401
            bzr diff foo.c
569
1402
    """
570
 
    # TODO: Allow diff across branches.
571
1403
    # TODO: Option to use external diff command; could be GNU diff, wdiff,
572
1404
    #       or a graphical diff.
573
1405
 
574
1406
    # TODO: Python difflib is not exactly the same as unidiff; should
575
1407
    #       either fix it up or prefer to use an external diff.
576
1408
 
577
 
    # TODO: If a directory is given, diff everything under that.
578
 
 
579
1409
    # TODO: Selected-file diff is inefficient and doesn't show you
580
1410
    #       deleted files.
581
1411
 
582
1412
    # TODO: This probably handles non-Unix newlines poorly.
583
 
    
 
1413
 
 
1414
    _see_also = ['status']
584
1415
    takes_args = ['file*']
585
 
    takes_options = ['revision', 'diff-options']
 
1416
    takes_options = [
 
1417
        Option('diff-options', type=str,
 
1418
               help='Pass these options to the external diff program.'),
 
1419
        Option('prefix', type=str,
 
1420
               short_name='p',
 
1421
               help='Set prefixes to added to old and new filenames, as '
 
1422
                    'two values separated by a colon. (eg "old/:new/").'),
 
1423
        'revision',
 
1424
        ]
586
1425
    aliases = ['di', 'dif']
587
 
 
588
 
    def run(self, revision=None, file_list=None, diff_options=None):
589
 
        from bzrlib.diff import show_diff
590
 
 
591
 
        if file_list:
592
 
            b = Branch.open_containing(file_list[0])[0]
593
 
            tree = WorkingTree(b.base, b)
594
 
            file_list = [tree.relpath(f) for f in file_list]
595
 
            if file_list == ['']:
596
 
                # just pointing to top-of-tree
597
 
                file_list = None
 
1426
    encoding_type = 'exact'
 
1427
 
 
1428
    @display_command
 
1429
    def run(self, revision=None, file_list=None, diff_options=None,
 
1430
            prefix=None):
 
1431
        from bzrlib.diff import diff_cmd_helper, show_diff_trees
 
1432
 
 
1433
        if (prefix is None) or (prefix == '0'):
 
1434
            # diff -p0 format
 
1435
            old_label = ''
 
1436
            new_label = ''
 
1437
        elif prefix == '1':
 
1438
            old_label = 'old/'
 
1439
            new_label = 'new/'
 
1440
        elif ':' in prefix:
 
1441
            old_label, new_label = prefix.split(":")
598
1442
        else:
599
 
            b = Branch.open_containing('.')[0]
600
 
 
601
 
        if revision is not None:
602
 
            if len(revision) == 1:
603
 
                show_diff(b, revision[0], specific_files=file_list,
604
 
                          external_diff_options=diff_options)
605
 
            elif len(revision) == 2:
606
 
                show_diff(b, revision[0], specific_files=file_list,
607
 
                          external_diff_options=diff_options,
608
 
                          revision2=revision[1])
 
1443
            raise errors.BzrCommandError(
 
1444
                '--prefix expects two values separated by a colon'
 
1445
                ' (eg "old/:new/")')
 
1446
 
 
1447
        if revision and len(revision) > 2:
 
1448
            raise errors.BzrCommandError('bzr diff --revision takes exactly'
 
1449
                                         ' one or two revision specifiers')
 
1450
 
 
1451
        try:
 
1452
            tree1, file_list = internal_tree_files(file_list)
 
1453
            tree2 = None
 
1454
            b = None
 
1455
            b2 = None
 
1456
        except errors.FileInWrongBranch:
 
1457
            if len(file_list) != 2:
 
1458
                raise errors.BzrCommandError("Files are in different branches")
 
1459
 
 
1460
            tree1, file1 = WorkingTree.open_containing(file_list[0])
 
1461
            tree2, file2 = WorkingTree.open_containing(file_list[1])
 
1462
            if file1 != "" or file2 != "":
 
1463
                # FIXME diff those two files. rbc 20051123
 
1464
                raise errors.BzrCommandError("Files are in different branches")
 
1465
            file_list = None
 
1466
        except errors.NotBranchError:
 
1467
            if (revision is not None and len(revision) == 2
 
1468
                and not revision[0].needs_branch()
 
1469
                and not revision[1].needs_branch()):
 
1470
                # If both revision specs include a branch, we can
 
1471
                # diff them without needing a local working tree
 
1472
                tree1, tree2 = None, None
609
1473
            else:
610
 
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
611
 
        else:
612
 
            show_diff(b, None, specific_files=file_list,
613
 
                      external_diff_options=diff_options)
614
 
 
615
 
        
 
1474
                raise
 
1475
 
 
1476
        if tree2 is not None:
 
1477
            if revision is not None:
 
1478
                # FIXME: but there should be a clean way to diff between
 
1479
                # non-default versions of two trees, it's not hard to do
 
1480
                # internally...
 
1481
                raise errors.BzrCommandError(
 
1482
                        "Sorry, diffing arbitrary revisions across branches "
 
1483
                        "is not implemented yet")
 
1484
            return show_diff_trees(tree1, tree2, sys.stdout, 
 
1485
                                   specific_files=file_list,
 
1486
                                   external_diff_options=diff_options,
 
1487
                                   old_label=old_label, new_label=new_label)
 
1488
 
 
1489
        return diff_cmd_helper(tree1, file_list, diff_options,
 
1490
                               revision_specs=revision,
 
1491
                               old_label=old_label, new_label=new_label)
616
1492
 
617
1493
 
618
1494
class cmd_deleted(Command):
624
1500
    # directories with readdir, rather than stating each one.  Same
625
1501
    # level of effort but possibly much less IO.  (Or possibly not,
626
1502
    # if the directories are very large...)
 
1503
    _see_also = ['status', 'ls']
 
1504
    takes_options = ['show-ids']
 
1505
 
 
1506
    @display_command
627
1507
    def run(self, show_ids=False):
628
 
        b = Branch.open_containing('.')[0]
629
 
        old = b.basis_tree()
630
 
        new = b.working_tree()
631
 
        for path, ie in old.inventory.iter_entries():
632
 
            if not new.has_id(ie.file_id):
633
 
                if show_ids:
634
 
                    print '%-50s %s' % (path, ie.file_id)
635
 
                else:
636
 
                    print path
 
1508
        tree = WorkingTree.open_containing(u'.')[0]
 
1509
        tree.lock_read()
 
1510
        try:
 
1511
            old = tree.basis_tree()
 
1512
            old.lock_read()
 
1513
            try:
 
1514
                for path, ie in old.inventory.iter_entries():
 
1515
                    if not tree.has_id(ie.file_id):
 
1516
                        self.outf.write(path)
 
1517
                        if show_ids:
 
1518
                            self.outf.write(' ')
 
1519
                            self.outf.write(ie.file_id)
 
1520
                        self.outf.write('\n')
 
1521
            finally:
 
1522
                old.unlock()
 
1523
        finally:
 
1524
            tree.unlock()
637
1525
 
638
1526
 
639
1527
class cmd_modified(Command):
640
 
    """List files modified in working tree."""
 
1528
    """List files modified in working tree.
 
1529
    """
 
1530
 
641
1531
    hidden = True
 
1532
    _see_also = ['status', 'ls']
 
1533
 
 
1534
    @display_command
642
1535
    def run(self):
643
 
        from bzrlib.delta import compare_trees
644
 
 
645
 
        b = Branch.open_containing('.')[0]
646
 
        td = compare_trees(b.basis_tree(), b.working_tree())
647
 
 
 
1536
        tree = WorkingTree.open_containing(u'.')[0]
 
1537
        td = tree.changes_from(tree.basis_tree())
648
1538
        for path, id, kind, text_modified, meta_modified in td.modified:
649
 
            print path
650
 
 
 
1539
            self.outf.write(path + '\n')
651
1540
 
652
1541
 
653
1542
class cmd_added(Command):
654
 
    """List files added in working tree."""
 
1543
    """List files added in working tree.
 
1544
    """
 
1545
 
655
1546
    hidden = True
 
1547
    _see_also = ['status', 'ls']
 
1548
 
 
1549
    @display_command
656
1550
    def run(self):
657
 
        b = Branch.open_containing('.')[0]
658
 
        wt = b.working_tree()
659
 
        basis_inv = b.basis_tree().inventory
660
 
        inv = wt.inventory
661
 
        for file_id in inv:
662
 
            if file_id in basis_inv:
663
 
                continue
664
 
            path = inv.id2path(file_id)
665
 
            if not os.access(b.abspath(path), os.F_OK):
666
 
                continue
667
 
            print path
668
 
                
669
 
        
 
1551
        wt = WorkingTree.open_containing(u'.')[0]
 
1552
        wt.lock_read()
 
1553
        try:
 
1554
            basis = wt.basis_tree()
 
1555
            basis.lock_read()
 
1556
            try:
 
1557
                basis_inv = basis.inventory
 
1558
                inv = wt.inventory
 
1559
                for file_id in inv:
 
1560
                    if file_id in basis_inv:
 
1561
                        continue
 
1562
                    if inv.is_root(file_id) and len(basis_inv) == 0:
 
1563
                        continue
 
1564
                    path = inv.id2path(file_id)
 
1565
                    if not os.access(osutils.abspath(path), os.F_OK):
 
1566
                        continue
 
1567
                    self.outf.write(path + '\n')
 
1568
            finally:
 
1569
                basis.unlock()
 
1570
        finally:
 
1571
            wt.unlock()
 
1572
 
670
1573
 
671
1574
class cmd_root(Command):
672
1575
    """Show the tree root directory.
673
1576
 
674
1577
    The root is the nearest enclosing directory with a .bzr control
675
1578
    directory."""
 
1579
 
676
1580
    takes_args = ['filename?']
 
1581
    @display_command
677
1582
    def run(self, filename=None):
678
1583
        """Print the branch root."""
679
 
        b = Branch.open_containing(filename)[0]
680
 
        print b.base
 
1584
        tree = WorkingTree.open_containing(filename)[0]
 
1585
        self.outf.write(tree.basedir + '\n')
 
1586
 
 
1587
 
 
1588
def _parse_limit(limitstring):
 
1589
    try:
 
1590
        return int(limitstring)
 
1591
    except ValueError:
 
1592
        msg = "The limit argument must be an integer."
 
1593
        raise errors.BzrCommandError(msg)
681
1594
 
682
1595
 
683
1596
class cmd_log(Command):
684
 
    """Show log of this branch.
685
 
 
686
 
    To request a range of logs, you can use the command -r begin:end
687
 
    -r revision requests a specific revision, -r :end or -r begin: are
 
1597
    """Show log of a branch, file, or directory.
 
1598
 
 
1599
    By default show the log of the branch containing the working directory.
 
1600
 
 
1601
    To request a range of logs, you can use the command -r begin..end
 
1602
    -r revision requests a specific revision, -r ..end or -r begin.. are
688
1603
    also valid.
 
1604
 
 
1605
    :Examples:
 
1606
        Log the current branch::
 
1607
 
 
1608
            bzr log
 
1609
 
 
1610
        Log a file::
 
1611
 
 
1612
            bzr log foo.c
 
1613
 
 
1614
        Log the last 10 revisions of a branch::
 
1615
 
 
1616
            bzr log -r -10.. http://server/branch
689
1617
    """
690
1618
 
691
1619
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
692
1620
 
693
 
    takes_args = ['filename?']
694
 
    takes_options = [Option('forward', 
695
 
                            help='show from oldest to newest'),
696
 
                     'timezone', 'verbose', 
697
 
                     'show-ids', 'revision',
698
 
                     Option('line', help='format with one line per revision'),
699
 
                     'long', 
700
 
                     Option('message',
701
 
                            help='show revisions whose message matches this regexp',
702
 
                            type=str),
703
 
                     Option('short', help='use moderately short format'),
704
 
                     ]
705
 
    
706
 
    def run(self, filename=None, timezone='original',
 
1621
    takes_args = ['location?']
 
1622
    takes_options = [
 
1623
            Option('forward',
 
1624
                   help='Show from oldest to newest.'),
 
1625
            Option('timezone',
 
1626
                   type=str,
 
1627
                   help='Display timezone as local, original, or utc.'),
 
1628
            custom_help('verbose',
 
1629
                   help='Show files changed in each revision.'),
 
1630
            'show-ids',
 
1631
            'revision',
 
1632
            'log-format',
 
1633
            Option('message',
 
1634
                   short_name='m',
 
1635
                   help='Show revisions whose message matches this '
 
1636
                        'regular expression.',
 
1637
                   type=str),
 
1638
            Option('limit',
 
1639
                   help='Limit the output to the first N revisions.',
 
1640
                   argname='N',
 
1641
                   type=_parse_limit),
 
1642
            ]
 
1643
    encoding_type = 'replace'
 
1644
 
 
1645
    @display_command
 
1646
    def run(self, location=None, timezone='original',
707
1647
            verbose=False,
708
1648
            show_ids=False,
709
1649
            forward=False,
710
1650
            revision=None,
 
1651
            log_format=None,
711
1652
            message=None,
712
 
            long=False,
713
 
            short=False,
714
 
            line=False):
715
 
        from bzrlib.log import log_formatter, show_log
716
 
        import codecs
 
1653
            limit=None):
 
1654
        from bzrlib.log import show_log
717
1655
        assert message is None or isinstance(message, basestring), \
718
1656
            "invalid message argument %r" % message
719
1657
        direction = (forward and 'forward') or 'reverse'
720
1658
        
721
 
        if filename:
722
 
            b, fp = Branch.open_containing(filename)
 
1659
        # log everything
 
1660
        file_id = None
 
1661
        if location:
 
1662
            # find the file id to log:
 
1663
 
 
1664
            tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
 
1665
                location)
723
1666
            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, relpath = 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
 
 
 
1667
                if tree is None:
 
1668
                    tree = b.basis_tree()
 
1669
                file_id = tree.path2id(fp)
 
1670
                if file_id is None:
 
1671
                    raise errors.BzrCommandError(
 
1672
                        "Path does not have any revision history: %s" %
 
1673
                        location)
 
1674
        else:
 
1675
            # local dir only
 
1676
            # FIXME ? log the current subdir only RBC 20060203 
 
1677
            if revision is not None \
 
1678
                    and len(revision) > 0 and revision[0].get_branch():
 
1679
                location = revision[0].get_branch()
 
1680
            else:
 
1681
                location = '.'
 
1682
            dir, relpath = bzrdir.BzrDir.open_containing(location)
 
1683
            b = dir.open_branch()
 
1684
 
 
1685
        b.lock_read()
 
1686
        try:
 
1687
            if revision is None:
 
1688
                rev1 = None
 
1689
                rev2 = None
 
1690
            elif len(revision) == 1:
 
1691
                rev1 = rev2 = revision[0].in_history(b)
 
1692
            elif len(revision) == 2:
 
1693
                if revision[1].get_branch() != revision[0].get_branch():
 
1694
                    # b is taken from revision[0].get_branch(), and
 
1695
                    # show_log will use its revision_history. Having
 
1696
                    # different branches will lead to weird behaviors.
 
1697
                    raise errors.BzrCommandError(
 
1698
                        "Log doesn't accept two revisions in different"
 
1699
                        " branches.")
 
1700
                rev1 = revision[0].in_history(b)
 
1701
                rev2 = revision[1].in_history(b)
 
1702
            else:
 
1703
                raise errors.BzrCommandError(
 
1704
                    'bzr log --revision takes one or two values.')
 
1705
 
 
1706
            if log_format is None:
 
1707
                log_format = log.log_formatter_registry.get_default(b)
 
1708
 
 
1709
            lf = log_format(show_ids=show_ids, to_file=self.outf,
 
1710
                            show_timezone=timezone)
 
1711
 
 
1712
            show_log(b,
 
1713
                     lf,
 
1714
                     file_id,
 
1715
                     verbose=verbose,
 
1716
                     direction=direction,
 
1717
                     start_revision=rev1,
 
1718
                     end_revision=rev2,
 
1719
                     search=message,
 
1720
                     limit=limit)
 
1721
        finally:
 
1722
            b.unlock()
 
1723
 
 
1724
 
 
1725
def get_log_format(long=False, short=False, line=False, default='long'):
 
1726
    log_format = default
 
1727
    if long:
753
1728
        log_format = 'long'
754
 
        if short:
755
 
            log_format = 'short'
756
 
        if line:
757
 
            log_format = 'line'
758
 
        lf = log_formatter(log_format,
759
 
                           show_ids=show_ids,
760
 
                           to_file=outf,
761
 
                           show_timezone=timezone)
762
 
 
763
 
        show_log(b,
764
 
                 lf,
765
 
                 file_id,
766
 
                 verbose=verbose,
767
 
                 direction=direction,
768
 
                 start_revision=rev1,
769
 
                 end_revision=rev2,
770
 
                 search=message)
771
 
 
 
1729
    if short:
 
1730
        log_format = 'short'
 
1731
    if line:
 
1732
        log_format = 'line'
 
1733
    return log_format
772
1734
 
773
1735
 
774
1736
class cmd_touching_revisions(Command):
775
1737
    """Return revision-ids which affected a particular file.
776
1738
 
777
 
    A more user-friendly interface is "bzr log FILE"."""
 
1739
    A more user-friendly interface is "bzr log FILE".
 
1740
    """
 
1741
 
778
1742
    hidden = True
779
1743
    takes_args = ["filename"]
 
1744
 
 
1745
    @display_command
780
1746
    def run(self, filename):
781
 
        b, relpath = Branch.open_containing(filename)[0]
782
 
        inv = b.read_working_inventory()
783
 
        file_id = inv.path2id(relpath)
784
 
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
785
 
            print "%6d %s" % (revno, what)
 
1747
        tree, relpath = WorkingTree.open_containing(filename)
 
1748
        b = tree.branch
 
1749
        file_id = tree.path2id(relpath)
 
1750
        for revno, revision_id, what in log.find_touching_revisions(b, file_id):
 
1751
            self.outf.write("%6d %s\n" % (revno, what))
786
1752
 
787
1753
 
788
1754
class cmd_ls(Command):
789
1755
    """List files in a tree.
790
1756
    """
 
1757
 
 
1758
    _see_also = ['status', 'cat']
 
1759
    takes_args = ['path?']
791
1760
    # TODO: Take a revision or remote path and list that tree instead.
792
 
    hidden = True
793
 
    def run(self, revision=None, verbose=False):
794
 
        b, relpath = Branch.open_containing('.')[0]
795
 
        if revision == None:
796
 
            tree = b.working_tree()
 
1761
    takes_options = [
 
1762
            'verbose',
 
1763
            'revision',
 
1764
            Option('non-recursive',
 
1765
                   help='Don\'t recurse into subdirectories.'),
 
1766
            Option('from-root',
 
1767
                   help='Print paths relative to the root of the branch.'),
 
1768
            Option('unknown', help='Print unknown files.'),
 
1769
            Option('versioned', help='Print versioned files.'),
 
1770
            Option('ignored', help='Print ignored files.'),
 
1771
            Option('null',
 
1772
                   help='Write an ascii NUL (\\0) separator '
 
1773
                   'between files rather than a newline.'),
 
1774
            Option('kind',
 
1775
                   help='List entries of a particular kind: file, directory, symlink.',
 
1776
                   type=unicode),
 
1777
            'show-ids',
 
1778
            ]
 
1779
    @display_command
 
1780
    def run(self, revision=None, verbose=False,
 
1781
            non_recursive=False, from_root=False,
 
1782
            unknown=False, versioned=False, ignored=False,
 
1783
            null=False, kind=None, show_ids=False, path=None):
 
1784
 
 
1785
        if kind and kind not in ('file', 'directory', 'symlink'):
 
1786
            raise errors.BzrCommandError('invalid kind specified')
 
1787
 
 
1788
        if verbose and null:
 
1789
            raise errors.BzrCommandError('Cannot set both --verbose and --null')
 
1790
        all = not (unknown or versioned or ignored)
 
1791
 
 
1792
        selection = {'I':ignored, '?':unknown, 'V':versioned}
 
1793
 
 
1794
        if path is None:
 
1795
            fs_path = '.'
 
1796
            prefix = ''
797
1797
        else:
798
 
            tree = b.revision_tree(revision.in_history(b).rev_id)
799
 
        for fp, fc, kind, fid, entry in tree.list_files():
800
 
            if verbose:
801
 
                kindch = entry.kind_character()
802
 
                print '%-8s %s%s' % (fc, fp, kindch)
803
 
            else:
804
 
                print fp
 
1798
            if from_root:
 
1799
                raise errors.BzrCommandError('cannot specify both --from-root'
 
1800
                                             ' and PATH')
 
1801
            fs_path = path
 
1802
            prefix = path
 
1803
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
1804
            fs_path)
 
1805
        if from_root:
 
1806
            relpath = u''
 
1807
        elif relpath:
 
1808
            relpath += '/'
 
1809
        if revision is not None:
 
1810
            tree = branch.repository.revision_tree(
 
1811
                revision[0].in_history(branch).rev_id)
 
1812
        elif tree is None:
 
1813
            tree = branch.basis_tree()
805
1814
 
 
1815
        tree.lock_read()
 
1816
        try:
 
1817
            for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
 
1818
                if fp.startswith(relpath):
 
1819
                    fp = osutils.pathjoin(prefix, fp[len(relpath):])
 
1820
                    if non_recursive and '/' in fp:
 
1821
                        continue
 
1822
                    if not all and not selection[fc]:
 
1823
                        continue
 
1824
                    if kind is not None and fkind != kind:
 
1825
                        continue
 
1826
                    if verbose:
 
1827
                        kindch = entry.kind_character()
 
1828
                        outstring = '%-8s %s%s' % (fc, fp, kindch)
 
1829
                        if show_ids and fid is not None:
 
1830
                            outstring = "%-50s %s" % (outstring, fid)
 
1831
                        self.outf.write(outstring + '\n')
 
1832
                    elif null:
 
1833
                        self.outf.write(fp + '\0')
 
1834
                        if show_ids:
 
1835
                            if fid is not None:
 
1836
                                self.outf.write(fid)
 
1837
                            self.outf.write('\0')
 
1838
                        self.outf.flush()
 
1839
                    else:
 
1840
                        if fid is not None:
 
1841
                            my_id = fid
 
1842
                        else:
 
1843
                            my_id = ''
 
1844
                        if show_ids:
 
1845
                            self.outf.write('%-50s %s\n' % (fp, my_id))
 
1846
                        else:
 
1847
                            self.outf.write(fp + '\n')
 
1848
        finally:
 
1849
            tree.unlock()
806
1850
 
807
1851
 
808
1852
class cmd_unknowns(Command):
809
 
    """List unknown files."""
 
1853
    """List unknown files.
 
1854
    """
 
1855
 
 
1856
    hidden = True
 
1857
    _see_also = ['ls']
 
1858
 
 
1859
    @display_command
810
1860
    def run(self):
811
 
        from bzrlib.osutils import quotefn
812
 
        for f in Branch.open_containing('.')[0].unknowns():
813
 
            print quotefn(f)
814
 
 
 
1861
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
1862
            self.outf.write(osutils.quotefn(f) + '\n')
815
1863
 
816
1864
 
817
1865
class cmd_ignore(Command):
818
 
    """Ignore a command or pattern.
 
1866
    """Ignore specified files or patterns.
819
1867
 
820
1868
    To remove patterns from the ignore list, edit the .bzrignore file.
821
1869
 
822
 
    If the pattern contains a slash, it is compared to the whole path
823
 
    from the branch root.  Otherwise, it is compared to only the last
824
 
    component of the path.  To match a file only in the root directory,
825
 
    prepend './'.
826
 
 
827
 
    Ignore patterns are case-insensitive on case-insensitive systems.
828
 
 
829
 
    Note: wildcards must be quoted from the shell on Unix.
830
 
 
831
 
    examples:
832
 
        bzr ignore ./Makefile
833
 
        bzr ignore '*.class'
 
1870
    Trailing slashes on patterns are ignored. 
 
1871
    If the pattern contains a slash or is a regular expression, it is compared 
 
1872
    to the whole path from the branch root.  Otherwise, it is compared to only
 
1873
    the last component of the path.  To match a file only in the root 
 
1874
    directory, prepend './'.
 
1875
 
 
1876
    Ignore patterns specifying absolute paths are not allowed.
 
1877
 
 
1878
    Ignore patterns may include globbing wildcards such as::
 
1879
 
 
1880
      ? - Matches any single character except '/'
 
1881
      * - Matches 0 or more characters except '/'
 
1882
      /**/ - Matches 0 or more directories in a path
 
1883
      [a-z] - Matches a single character from within a group of characters
 
1884
 
 
1885
    Ignore patterns may also be Python regular expressions.  
 
1886
    Regular expression ignore patterns are identified by a 'RE:' prefix 
 
1887
    followed by the regular expression.  Regular expression ignore patterns
 
1888
    may not include named or numbered groups.
 
1889
 
 
1890
    Note: ignore patterns containing shell wildcards must be quoted from 
 
1891
    the shell on Unix.
 
1892
 
 
1893
    :Examples:
 
1894
        Ignore the top level Makefile::
 
1895
 
 
1896
            bzr ignore ./Makefile
 
1897
 
 
1898
        Ignore class files in all directories::
 
1899
 
 
1900
            bzr ignore '*.class'
 
1901
 
 
1902
        Ignore .o files under the lib directory::
 
1903
 
 
1904
            bzr ignore 'lib/**/*.o'
 
1905
 
 
1906
        Ignore .o files under the lib directory::
 
1907
 
 
1908
            bzr ignore 'RE:lib/.*\.o'
834
1909
    """
835
 
    # TODO: Complain if the filename is absolute
836
 
    takes_args = ['name_pattern']
 
1910
 
 
1911
    _see_also = ['status', 'ignored']
 
1912
    takes_args = ['name_pattern*']
 
1913
    takes_options = [
 
1914
        Option('old-default-rules',
 
1915
               help='Write out the ignore rules bzr < 0.9 always used.')
 
1916
        ]
837
1917
    
838
 
    def run(self, name_pattern):
 
1918
    def run(self, name_pattern_list=None, old_default_rules=None):
839
1919
        from bzrlib.atomicfile import AtomicFile
840
 
        import os.path
841
 
 
842
 
        b, relpath = Branch.open_containing('.')
843
 
        ifn = b.abspath('.bzrignore')
844
 
 
 
1920
        if old_default_rules is not None:
 
1921
            # dump the rules and exit
 
1922
            for pattern in ignores.OLD_DEFAULTS:
 
1923
                print pattern
 
1924
            return
 
1925
        if not name_pattern_list:
 
1926
            raise errors.BzrCommandError("ignore requires at least one "
 
1927
                                  "NAME_PATTERN or --old-default-rules")
 
1928
        name_pattern_list = [globbing.normalize_pattern(p) 
 
1929
                             for p in name_pattern_list]
 
1930
        for name_pattern in name_pattern_list:
 
1931
            if (name_pattern[0] == '/' or 
 
1932
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
 
1933
                raise errors.BzrCommandError(
 
1934
                    "NAME_PATTERN should not be an absolute path")
 
1935
        tree, relpath = WorkingTree.open_containing(u'.')
 
1936
        ifn = tree.abspath('.bzrignore')
845
1937
        if os.path.exists(ifn):
846
1938
            f = open(ifn, 'rt')
847
1939
            try:
856
1948
 
857
1949
        if igns and igns[-1] != '\n':
858
1950
            igns += '\n'
859
 
        igns += name_pattern + '\n'
 
1951
        for name_pattern in name_pattern_list:
 
1952
            igns += name_pattern + '\n'
860
1953
 
 
1954
        f = AtomicFile(ifn, 'wb')
861
1955
        try:
862
 
            f = AtomicFile(ifn, 'wt')
863
1956
            f.write(igns.encode('utf-8'))
864
1957
            f.commit()
865
1958
        finally:
866
1959
            f.close()
867
1960
 
868
 
        inv = b.working_tree().inventory
869
 
        if inv.path2id('.bzrignore'):
870
 
            mutter('.bzrignore is already versioned')
871
 
        else:
872
 
            mutter('need to make new .bzrignore file versioned')
873
 
            b.add(['.bzrignore'])
874
 
 
 
1961
        if not tree.path2id('.bzrignore'):
 
1962
            tree.add(['.bzrignore'])
875
1963
 
876
1964
 
877
1965
class cmd_ignored(Command):
878
1966
    """List ignored files and the patterns that matched them.
 
1967
    """
879
1968
 
880
 
    See also: bzr ignore"""
 
1969
    _see_also = ['ignore']
 
1970
    @display_command
881
1971
    def run(self):
882
 
        tree = Branch.open_containing('.')[0].working_tree()
883
 
        for path, file_class, kind, file_id, entry in tree.list_files():
884
 
            if file_class != 'I':
885
 
                continue
886
 
            ## XXX: Slightly inefficient since this was already calculated
887
 
            pat = tree.is_ignored(path)
888
 
            print '%-50s %s' % (path, pat)
 
1972
        tree = WorkingTree.open_containing(u'.')[0]
 
1973
        tree.lock_read()
 
1974
        try:
 
1975
            for path, file_class, kind, file_id, entry in tree.list_files():
 
1976
                if file_class != 'I':
 
1977
                    continue
 
1978
                ## XXX: Slightly inefficient since this was already calculated
 
1979
                pat = tree.is_ignored(path)
 
1980
                print '%-50s %s' % (path, pat)
 
1981
        finally:
 
1982
            tree.unlock()
889
1983
 
890
1984
 
891
1985
class cmd_lookup_revision(Command):
892
1986
    """Lookup the revision-id from a revision-number
893
1987
 
894
 
    example:
 
1988
    :Examples:
895
1989
        bzr lookup-revision 33
896
1990
    """
897
1991
    hidden = True
898
1992
    takes_args = ['revno']
899
1993
    
 
1994
    @display_command
900
1995
    def run(self, revno):
901
1996
        try:
902
1997
            revno = int(revno)
903
1998
        except ValueError:
904
 
            raise BzrCommandError("not a valid revision-number: %r" % revno)
 
1999
            raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
905
2000
 
906
 
        print Branch.open_containing('.')[0].get_rev_id(revno)
 
2001
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
907
2002
 
908
2003
 
909
2004
class cmd_export(Command):
910
 
    """Export past revision to destination directory.
 
2005
    """Export current or past revision to a destination directory or archive.
911
2006
 
912
2007
    If no revision is specified this exports the last committed revision.
913
2008
 
915
2010
    given, try to find the format with the extension. If no extension
916
2011
    is found exports to a directory (equivalent to --format=dir).
917
2012
 
918
 
    Root may be the top directory for tar, tgz and tbz2 formats. If none
919
 
    is given, the top directory will be the root name of the file."""
920
 
    # TODO: list known exporters
921
 
    takes_args = ['dest']
922
 
    takes_options = ['revision', 'format', 'root']
923
 
    def run(self, dest, revision=None, format=None, root=None):
924
 
        import os.path
925
 
        b = Branch.open_containing('.')[0]
 
2013
    If root is supplied, it will be used as the root directory inside
 
2014
    container formats (tar, zip, etc). If it is not supplied it will default
 
2015
    to the exported filename. The root option has no effect for 'dir' format.
 
2016
 
 
2017
    If branch is omitted then the branch containing the current working
 
2018
    directory will be used.
 
2019
 
 
2020
    Note: Export of tree with non-ASCII filenames to zip is not supported.
 
2021
 
 
2022
      =================       =========================
 
2023
      Supported formats       Autodetected by extension
 
2024
      =================       =========================
 
2025
         dir                         (none)
 
2026
         tar                          .tar
 
2027
         tbz2                    .tar.bz2, .tbz2
 
2028
         tgz                      .tar.gz, .tgz
 
2029
         zip                          .zip
 
2030
      =================       =========================
 
2031
    """
 
2032
    takes_args = ['dest', 'branch?']
 
2033
    takes_options = [
 
2034
        Option('format',
 
2035
               help="Type of file to export to.",
 
2036
               type=unicode),
 
2037
        'revision',
 
2038
        Option('root',
 
2039
               type=str,
 
2040
               help="Name of the root directory inside the exported file."),
 
2041
        ]
 
2042
    def run(self, dest, branch=None, revision=None, format=None, root=None):
 
2043
        from bzrlib.export import export
 
2044
 
 
2045
        if branch is None:
 
2046
            tree = WorkingTree.open_containing(u'.')[0]
 
2047
            b = tree.branch
 
2048
        else:
 
2049
            b = Branch.open(branch)
 
2050
            
926
2051
        if revision is None:
 
2052
            # should be tree.last_revision  FIXME
927
2053
            rev_id = b.last_revision()
928
2054
        else:
929
2055
            if len(revision) != 1:
930
 
                raise BzrError('bzr export --revision takes exactly 1 argument')
 
2056
                raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
931
2057
            rev_id = revision[0].in_history(b).rev_id
932
 
        t = b.revision_tree(rev_id)
933
 
        arg_root, ext = os.path.splitext(os.path.basename(dest))
934
 
        if ext in ('.gz', '.bz2'):
935
 
            new_root, new_ext = os.path.splitext(arg_root)
936
 
            if new_ext == '.tar':
937
 
                arg_root = new_root
938
 
                ext = new_ext + ext
939
 
        if root is None:
940
 
            root = arg_root
941
 
        if not format:
942
 
            if ext in (".tar",):
943
 
                format = "tar"
944
 
            elif ext in (".tar.gz", ".tgz"):
945
 
                format = "tgz"
946
 
            elif ext in (".tar.bz2", ".tbz2"):
947
 
                format = "tbz2"
948
 
            else:
949
 
                format = "dir"
950
 
        t.export(dest, format, root)
 
2058
        t = b.repository.revision_tree(rev_id)
 
2059
        try:
 
2060
            export(t, dest, format, root)
 
2061
        except errors.NoSuchExportFormat, e:
 
2062
            raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
951
2063
 
952
2064
 
953
2065
class cmd_cat(Command):
954
 
    """Write a file's text from a previous revision."""
955
 
 
956
 
    takes_options = ['revision']
 
2066
    """Write the contents of a file as of a given revision to standard output.
 
2067
 
 
2068
    If no revision is nominated, the last revision is used.
 
2069
 
 
2070
    Note: Take care to redirect standard output when using this command on a
 
2071
    binary file. 
 
2072
    """
 
2073
 
 
2074
    _see_also = ['ls']
 
2075
    takes_options = [
 
2076
        Option('name-from-revision', help='The path name in the old tree.'),
 
2077
        'revision',
 
2078
        ]
957
2079
    takes_args = ['filename']
958
 
 
959
 
    def run(self, filename, revision=None):
 
2080
    encoding_type = 'exact'
 
2081
 
 
2082
    @display_command
 
2083
    def run(self, filename, revision=None, name_from_revision=False):
 
2084
        if revision is not None and len(revision) != 1:
 
2085
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
 
2086
                                        " one number")
 
2087
 
 
2088
        tree = None
 
2089
        try:
 
2090
            tree, b, relpath = \
 
2091
                    bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
2092
        except errors.NotBranchError:
 
2093
            pass
 
2094
 
 
2095
        if revision is not None and revision[0].get_branch() is not None:
 
2096
            b = Branch.open(revision[0].get_branch())
 
2097
        if tree is None:
 
2098
            tree = b.basis_tree()
960
2099
        if revision is None:
961
 
            raise BzrCommandError("bzr cat requires a revision number")
962
 
        elif len(revision) != 1:
963
 
            raise BzrCommandError("bzr cat --revision takes exactly one number")
964
 
        b, relpath = Branch.open_containing(filename)
965
 
        b.print_file(relpath, revision[0].in_history(b).revno)
 
2100
            revision_id = b.last_revision()
 
2101
        else:
 
2102
            revision_id = revision[0].in_history(b).rev_id
 
2103
 
 
2104
        cur_file_id = tree.path2id(relpath)
 
2105
        rev_tree = b.repository.revision_tree(revision_id)
 
2106
        old_file_id = rev_tree.path2id(relpath)
 
2107
        
 
2108
        if name_from_revision:
 
2109
            if old_file_id is None:
 
2110
                raise errors.BzrCommandError("%r is not present in revision %s"
 
2111
                                                % (filename, revision_id))
 
2112
            else:
 
2113
                rev_tree.print_file(old_file_id)
 
2114
        elif cur_file_id is not None:
 
2115
            rev_tree.print_file(cur_file_id)
 
2116
        elif old_file_id is not None:
 
2117
            rev_tree.print_file(old_file_id)
 
2118
        else:
 
2119
            raise errors.BzrCommandError("%r is not present in revision %s" %
 
2120
                                         (filename, revision_id))
966
2121
 
967
2122
 
968
2123
class cmd_local_time_offset(Command):
969
2124
    """Show the offset in seconds from GMT to local time."""
970
2125
    hidden = True    
 
2126
    @display_command
971
2127
    def run(self):
972
 
        print bzrlib.osutils.local_time_offset()
 
2128
        print osutils.local_time_offset()
973
2129
 
974
2130
 
975
2131
 
982
2138
    committed.  If a directory is specified then the directory and everything 
983
2139
    within it is committed.
984
2140
 
 
2141
    If author of the change is not the same person as the committer, you can
 
2142
    specify the author's name using the --author option. The name should be
 
2143
    in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
 
2144
 
985
2145
    A selected-file commit may fail in some cases where the committed
986
 
    tree would be invalid, such as trying to commit a file in a
987
 
    newly-added directory that is not itself committed.
 
2146
    tree would be invalid. Consider::
 
2147
 
 
2148
      bzr init foo
 
2149
      mkdir foo/bar
 
2150
      bzr add foo/bar
 
2151
      bzr commit foo -m "committing foo"
 
2152
      bzr mv foo/bar foo/baz
 
2153
      mkdir foo/bar
 
2154
      bzr add foo/bar
 
2155
      bzr commit foo/bar -m "committing bar but not baz"
 
2156
 
 
2157
    In the example above, the last commit will fail by design. This gives
 
2158
    the user the opportunity to decide whether they want to commit the
 
2159
    rename at the same time, separately first, or not at all. (As a general
 
2160
    rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
 
2161
 
 
2162
    Note: A selected-file commit after a merge is not yet supported.
988
2163
    """
989
2164
    # TODO: Run hooks on tree to-be-committed, and after commit.
990
2165
 
995
2170
 
996
2171
    # XXX: verbose currently does nothing
997
2172
 
 
2173
    _see_also = ['bugs', 'uncommit']
998
2174
    takes_args = ['selected*']
999
 
    takes_options = ['message', 'verbose', 
1000
 
                     Option('unchanged',
1001
 
                            help='commit even if nothing has changed'),
1002
 
                     Option('file', type=str, 
1003
 
                            argname='msgfile',
1004
 
                            help='file containing commit message'),
1005
 
                     Option('strict',
1006
 
                            help="refuse to commit if there are unknown "
1007
 
                            "files in the working tree."),
1008
 
                     ]
 
2175
    takes_options = [
 
2176
            Option('message', type=unicode,
 
2177
                   short_name='m',
 
2178
                   help="Description of the new revision."),
 
2179
            'verbose',
 
2180
             Option('unchanged',
 
2181
                    help='Commit even if nothing has changed.'),
 
2182
             Option('file', type=str,
 
2183
                    short_name='F',
 
2184
                    argname='msgfile',
 
2185
                    help='Take commit message from this file.'),
 
2186
             Option('strict',
 
2187
                    help="Refuse to commit if there are unknown "
 
2188
                    "files in the working tree."),
 
2189
             ListOption('fixes', type=str,
 
2190
                    help="Mark a bug as being fixed by this revision."),
 
2191
             Option('author', type=str,
 
2192
                    help="Set the author's name, if it's different "
 
2193
                         "from the committer."),
 
2194
             Option('local',
 
2195
                    help="Perform a local commit in a bound "
 
2196
                         "branch.  Local commits are not pushed to "
 
2197
                         "the master branch until a normal commit "
 
2198
                         "is performed."
 
2199
                    ),
 
2200
             ]
1009
2201
    aliases = ['ci', 'checkin']
1010
2202
 
1011
 
    def run(self, message=None, file=None, verbose=True, selected_list=None,
1012
 
            unchanged=False, strict=False):
 
2203
    def _get_bug_fix_properties(self, fixes, branch):
 
2204
        properties = []
 
2205
        # Configure the properties for bug fixing attributes.
 
2206
        for fixed_bug in fixes:
 
2207
            tokens = fixed_bug.split(':')
 
2208
            if len(tokens) != 2:
 
2209
                raise errors.BzrCommandError(
 
2210
                    "Invalid bug %s. Must be in the form of 'tag:id'. "
 
2211
                    "Commit refused." % fixed_bug)
 
2212
            tag, bug_id = tokens
 
2213
            try:
 
2214
                bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
 
2215
            except errors.UnknownBugTrackerAbbreviation:
 
2216
                raise errors.BzrCommandError(
 
2217
                    'Unrecognized bug %s. Commit refused.' % fixed_bug)
 
2218
            except errors.MalformedBugIdentifier:
 
2219
                raise errors.BzrCommandError(
 
2220
                    "Invalid bug identifier for %s. Commit refused."
 
2221
                    % fixed_bug)
 
2222
            properties.append('%s fixed' % bug_url)
 
2223
        return '\n'.join(properties)
 
2224
 
 
2225
    def run(self, message=None, file=None, verbose=False, selected_list=None,
 
2226
            unchanged=False, strict=False, local=False, fixes=None,
 
2227
            author=None):
 
2228
        from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1013
2229
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1014
2230
                StrictCommitFailed)
1015
 
        from bzrlib.msgeditor import edit_commit_message
1016
 
        from bzrlib.status import show_status
1017
 
        from cStringIO import StringIO
1018
 
 
1019
 
        b = Branch.open_containing('.')[0]
1020
 
        tree = WorkingTree(b.base, b)
1021
 
        if selected_list:
1022
 
            selected_list = [tree.relpath(s) for s in selected_list]
1023
 
        if message is None and not file:
1024
 
            catcher = StringIO()
1025
 
            show_status(b, specific_files=selected_list,
1026
 
                        to_file=catcher)
1027
 
            message = edit_commit_message(catcher.getvalue())
1028
 
 
1029
 
            if message is None:
1030
 
                raise BzrCommandError("please specify a commit message"
1031
 
                                      " with either --message or --file")
1032
 
        elif message and file:
1033
 
            raise BzrCommandError("please specify either --message or --file")
1034
 
        
1035
 
        if file:
1036
 
            import codecs
1037
 
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1038
 
 
1039
 
        if message == "":
1040
 
                raise BzrCommandError("empty commit message specified")
1041
 
            
 
2231
        from bzrlib.msgeditor import edit_commit_message, \
 
2232
                make_commit_message_template
 
2233
 
 
2234
        # TODO: Need a blackbox test for invoking the external editor; may be
 
2235
        # slightly problematic to run this cross-platform.
 
2236
 
 
2237
        # TODO: do more checks that the commit will succeed before 
 
2238
        # spending the user's valuable time typing a commit message.
 
2239
 
 
2240
        properties = {}
 
2241
 
 
2242
        tree, selected_list = tree_files(selected_list)
 
2243
        if selected_list == ['']:
 
2244
            # workaround - commit of root of tree should be exactly the same
 
2245
            # as just default commit in that tree, and succeed even though
 
2246
            # selected-file merge commit is not done yet
 
2247
            selected_list = []
 
2248
 
 
2249
        bug_property = self._get_bug_fix_properties(fixes, tree.branch)
 
2250
        if bug_property:
 
2251
            properties['bugs'] = bug_property
 
2252
 
 
2253
        if local and not tree.branch.get_bound_location():
 
2254
            raise errors.LocalRequiresBoundBranch()
 
2255
 
 
2256
        def get_message(commit_obj):
 
2257
            """Callback to get commit message"""
 
2258
            my_message = message
 
2259
            if my_message is None and not file:
 
2260
                template = make_commit_message_template(tree, selected_list)
 
2261
                my_message = edit_commit_message(template)
 
2262
                if my_message is None:
 
2263
                    raise errors.BzrCommandError("please specify a commit"
 
2264
                        " message with either --message or --file")
 
2265
            elif my_message and file:
 
2266
                raise errors.BzrCommandError(
 
2267
                    "please specify either --message or --file")
 
2268
            if file:
 
2269
                my_message = codecs.open(file, 'rt', 
 
2270
                                         bzrlib.user_encoding).read()
 
2271
            if my_message == "":
 
2272
                raise errors.BzrCommandError("empty commit message specified")
 
2273
            return my_message
 
2274
 
 
2275
        if verbose or not is_quiet():
 
2276
            reporter = ReportCommitToLog()
 
2277
        else:
 
2278
            reporter = NullCommitReporter()
 
2279
 
1042
2280
        try:
1043
 
            b.commit(message, specific_files=selected_list,
1044
 
                     allow_pointless=unchanged, strict=strict)
 
2281
            tree.commit(message_callback=get_message,
 
2282
                        specific_files=selected_list,
 
2283
                        allow_pointless=unchanged, strict=strict, local=local,
 
2284
                        reporter=reporter, revprops=properties,
 
2285
                        author=author)
1045
2286
        except PointlessCommit:
1046
2287
            # FIXME: This should really happen before the file is read in;
1047
2288
            # perhaps prepare the commit; get the message; then actually commit
1048
 
            raise BzrCommandError("no changes to commit",
1049
 
                                  ["use --unchanged to commit anyhow"])
 
2289
            raise errors.BzrCommandError("no changes to commit."
 
2290
                              " use --unchanged to commit anyhow")
1050
2291
        except ConflictsInTree:
1051
 
            raise BzrCommandError("Conflicts detected in working tree.  "
1052
 
                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
 
2292
            raise errors.BzrCommandError('Conflicts detected in working '
 
2293
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
 
2294
                ' resolve.')
1053
2295
        except StrictCommitFailed:
1054
 
            raise BzrCommandError("Commit refused because there are unknown "
1055
 
                                  "files in the working tree.")
 
2296
            raise errors.BzrCommandError("Commit refused because there are"
 
2297
                              " unknown files in the working tree.")
 
2298
        except errors.BoundBranchOutOfDate, e:
 
2299
            raise errors.BzrCommandError(str(e) + "\n"
 
2300
            'To commit to master branch, run update and then commit.\n'
 
2301
            'You can also pass --local to commit to continue working '
 
2302
            'disconnected.')
1056
2303
 
1057
2304
 
1058
2305
class cmd_check(Command):
1061
2308
    This command checks various invariants about the branch storage to
1062
2309
    detect data corruption or bzr bugs.
1063
2310
    """
1064
 
    takes_args = ['dir?']
 
2311
 
 
2312
    _see_also = ['reconcile']
 
2313
    takes_args = ['branch?']
1065
2314
    takes_options = ['verbose']
1066
2315
 
1067
 
    def run(self, dir='.', verbose=False):
 
2316
    def run(self, branch=None, verbose=False):
1068
2317
        from bzrlib.check import check
1069
 
        check(Branch.open_containing(dir)[0], verbose)
1070
 
 
1071
 
 
1072
 
class cmd_scan_cache(Command):
1073
 
    hidden = True
1074
 
    def run(self):
1075
 
        from bzrlib.hashcache import HashCache
1076
 
 
1077
 
        c = HashCache('.')
1078
 
        c.read()
1079
 
        c.scan()
1080
 
            
1081
 
        print '%6d stats' % c.stat_count
1082
 
        print '%6d in hashcache' % len(c._cache)
1083
 
        print '%6d files removed from cache' % c.removed_count
1084
 
        print '%6d hashes updated' % c.update_count
1085
 
        print '%6d files changed too recently to cache' % c.danger_count
1086
 
 
1087
 
        if c.needs_write:
1088
 
            c.write()
1089
 
            
 
2318
        if branch is None:
 
2319
            tree = WorkingTree.open_containing()[0]
 
2320
            branch = tree.branch
 
2321
        else:
 
2322
            branch = Branch.open(branch)
 
2323
        check(branch, verbose)
1090
2324
 
1091
2325
 
1092
2326
class cmd_upgrade(Command):
1093
2327
    """Upgrade branch storage to current format.
1094
2328
 
1095
2329
    The check command or bzr developers may sometimes advise you to run
1096
 
    this command.
1097
 
 
1098
 
    This version of this command upgrades from the full-text storage
1099
 
    used by bzr 0.0.8 and earlier to the weave format (v5).
 
2330
    this command. When the default format has changed you may also be warned
 
2331
    during other operations to upgrade.
1100
2332
    """
1101
 
    takes_args = ['dir?']
1102
 
 
1103
 
    def run(self, dir='.'):
 
2333
 
 
2334
    _see_also = ['check']
 
2335
    takes_args = ['url?']
 
2336
    takes_options = [
 
2337
                    RegistryOption('format',
 
2338
                        help='Upgrade to a specific format.  See "bzr help'
 
2339
                             ' formats" for details.',
 
2340
                        registry=bzrdir.format_registry,
 
2341
                        converter=bzrdir.format_registry.make_bzrdir,
 
2342
                        value_switches=True, title='Branch format'),
 
2343
                    ]
 
2344
 
 
2345
    def run(self, url='.', format=None):
1104
2346
        from bzrlib.upgrade import upgrade
1105
 
        upgrade(dir)
 
2347
        if format is None:
 
2348
            format = bzrdir.format_registry.make_bzrdir('default')
 
2349
        upgrade(url, format)
1106
2350
 
1107
2351
 
1108
2352
class cmd_whoami(Command):
1109
 
    """Show bzr user id."""
1110
 
    takes_options = ['email']
1111
 
    
1112
 
    def run(self, email=False):
 
2353
    """Show or set bzr user id.
 
2354
    
 
2355
    :Examples:
 
2356
        Show the email of the current user::
 
2357
 
 
2358
            bzr whoami --email
 
2359
 
 
2360
        Set the current user::
 
2361
 
 
2362
            bzr whoami 'Frank Chu <fchu@example.com>'
 
2363
    """
 
2364
    takes_options = [ Option('email',
 
2365
                             help='Display email address only.'),
 
2366
                      Option('branch',
 
2367
                             help='Set identity for the current branch instead of '
 
2368
                                  'globally.'),
 
2369
                    ]
 
2370
    takes_args = ['name?']
 
2371
    encoding_type = 'replace'
 
2372
    
 
2373
    @display_command
 
2374
    def run(self, email=False, branch=False, name=None):
 
2375
        if name is None:
 
2376
            # use branch if we're inside one; otherwise global config
 
2377
            try:
 
2378
                c = Branch.open_containing('.')[0].get_config()
 
2379
            except errors.NotBranchError:
 
2380
                c = config.GlobalConfig()
 
2381
            if email:
 
2382
                self.outf.write(c.user_email() + '\n')
 
2383
            else:
 
2384
                self.outf.write(c.username() + '\n')
 
2385
            return
 
2386
 
 
2387
        # display a warning if an email address isn't included in the given name.
1113
2388
        try:
1114
 
            b = bzrlib.branch.Branch.open_containing('.')[0]
1115
 
            config = bzrlib.config.BranchConfig(b)
1116
 
        except NotBranchError:
1117
 
            config = bzrlib.config.GlobalConfig()
 
2389
            config.extract_email_address(name)
 
2390
        except errors.NoEmailInUsername, e:
 
2391
            warning('"%s" does not seem to contain an email address.  '
 
2392
                    'This is allowed, but not recommended.', name)
1118
2393
        
1119
 
        if email:
1120
 
            print config.user_email()
1121
 
        else:
1122
 
            print config.username()
 
2394
        # use global config unless --branch given
 
2395
        if branch:
 
2396
            c = Branch.open_containing('.')[0].get_config()
 
2397
        else:
 
2398
            c = config.GlobalConfig()
 
2399
        c.set_user_option('email', name)
 
2400
 
 
2401
 
 
2402
class cmd_nick(Command):
 
2403
    """Print or set the branch nickname.  
 
2404
 
 
2405
    If unset, the tree root directory name is used as the nickname
 
2406
    To print the current nickname, execute with no argument.  
 
2407
    """
 
2408
 
 
2409
    _see_also = ['info']
 
2410
    takes_args = ['nickname?']
 
2411
    def run(self, nickname=None):
 
2412
        branch = Branch.open_containing(u'.')[0]
 
2413
        if nickname is None:
 
2414
            self.printme(branch)
 
2415
        else:
 
2416
            branch.nick = nickname
 
2417
 
 
2418
    @display_command
 
2419
    def printme(self, branch):
 
2420
        print branch.nick
1123
2421
 
1124
2422
 
1125
2423
class cmd_selftest(Command):
1126
2424
    """Run internal test suite.
1127
2425
    
1128
 
    This creates temporary test directories in the working directory,
1129
 
    but not existing data is affected.  These directories are deleted
1130
 
    if the tests pass, or left behind to help in debugging if they
1131
 
    fail.
1132
 
    
1133
 
    If arguments are given, they are regular expressions that say
1134
 
    which tests should run.
 
2426
    If arguments are given, they are regular expressions that say which tests
 
2427
    should run.  Tests matching any expression are run, and other tests are
 
2428
    not run.
 
2429
 
 
2430
    Alternatively if --first is given, matching tests are run first and then
 
2431
    all other tests are run.  This is useful if you have been working in a
 
2432
    particular area, but want to make sure nothing else was broken.
 
2433
 
 
2434
    If --exclude is given, tests that match that regular expression are
 
2435
    excluded, regardless of whether they match --first or not.
 
2436
 
 
2437
    To help catch accidential dependencies between tests, the --randomize
 
2438
    option is useful. In most cases, the argument used is the word 'now'.
 
2439
    Note that the seed used for the random number generator is displayed
 
2440
    when this option is used. The seed can be explicitly passed as the
 
2441
    argument to this option if required. This enables reproduction of the
 
2442
    actual ordering used if and when an order sensitive problem is encountered.
 
2443
 
 
2444
    If --list-only is given, the tests that would be run are listed. This is
 
2445
    useful when combined with --first, --exclude and/or --randomize to
 
2446
    understand their impact. The test harness reports "Listed nn tests in ..."
 
2447
    instead of "Ran nn tests in ..." when list mode is enabled.
 
2448
 
 
2449
    If the global option '--no-plugins' is given, plugins are not loaded
 
2450
    before running the selftests.  This has two effects: features provided or
 
2451
    modified by plugins will not be tested, and tests provided by plugins will
 
2452
    not be run.
 
2453
 
 
2454
    Tests that need working space on disk use a common temporary directory, 
 
2455
    typically inside $TMPDIR or /tmp.
 
2456
 
 
2457
    :Examples:
 
2458
        Run only tests relating to 'ignore'::
 
2459
 
 
2460
            bzr selftest ignore
 
2461
 
 
2462
        Disable plugins and list tests as they're run::
 
2463
 
 
2464
            bzr --no-plugins selftest -v
1135
2465
    """
1136
 
    # TODO: --list should give a list of all available tests
 
2466
    # NB: this is used from the class without creating an instance, which is
 
2467
    # why it does not have a self parameter.
 
2468
    def get_transport_type(typestring):
 
2469
        """Parse and return a transport specifier."""
 
2470
        if typestring == "sftp":
 
2471
            from bzrlib.transport.sftp import SFTPAbsoluteServer
 
2472
            return SFTPAbsoluteServer
 
2473
        if typestring == "memory":
 
2474
            from bzrlib.transport.memory import MemoryServer
 
2475
            return MemoryServer
 
2476
        if typestring == "fakenfs":
 
2477
            from bzrlib.transport.fakenfs import FakeNFSServer
 
2478
            return FakeNFSServer
 
2479
        msg = "No known transport type %s. Supported types are: sftp\n" %\
 
2480
            (typestring)
 
2481
        raise errors.BzrCommandError(msg)
 
2482
 
1137
2483
    hidden = True
1138
2484
    takes_args = ['testspecs*']
1139
 
    takes_options = ['verbose', 
1140
 
                     Option('one', help='stop when one test fails'),
1141
 
                    ]
 
2485
    takes_options = ['verbose',
 
2486
                     Option('one',
 
2487
                             help='Stop when one test fails.',
 
2488
                             short_name='1',
 
2489
                             ),
 
2490
                     Option('transport',
 
2491
                            help='Use a different transport by default '
 
2492
                                 'throughout the test suite.',
 
2493
                            type=get_transport_type),
 
2494
                     Option('benchmark',
 
2495
                            help='Run the benchmarks rather than selftests.'),
 
2496
                     Option('lsprof-timed',
 
2497
                            help='Generate lsprof output for benchmarked'
 
2498
                                 ' sections of code.'),
 
2499
                     Option('cache-dir', type=str,
 
2500
                            help='Cache intermediate benchmark output in this '
 
2501
                                 'directory.'),
 
2502
                     Option('first',
 
2503
                            help='Run all tests, but run specified tests first.',
 
2504
                            short_name='f',
 
2505
                            ),
 
2506
                     Option('list-only',
 
2507
                            help='List the tests instead of running them.'),
 
2508
                     Option('randomize', type=str, argname="SEED",
 
2509
                            help='Randomize the order of tests using the given'
 
2510
                                 ' seed or "now" for the current time.'),
 
2511
                     Option('exclude', type=str, argname="PATTERN",
 
2512
                            short_name='x',
 
2513
                            help='Exclude tests that match this regular'
 
2514
                                 ' expression.'),
 
2515
                     Option('strict', help='Fail on missing dependencies or '
 
2516
                            'known failures.'),
 
2517
                     ]
 
2518
    encoding_type = 'replace'
1142
2519
 
1143
 
    def run(self, testspecs_list=None, verbose=False, one=False):
 
2520
    def run(self, testspecs_list=None, verbose=None, one=False,
 
2521
            transport=None, benchmark=None,
 
2522
            lsprof_timed=None, cache_dir=None,
 
2523
            first=False, list_only=False,
 
2524
            randomize=None, exclude=None, strict=False):
1144
2525
        import bzrlib.ui
1145
 
        from bzrlib.selftest import selftest
1146
 
        # we don't want progress meters from the tests to go to the
1147
 
        # real output; and we don't want log messages cluttering up
1148
 
        # the real logs.
1149
 
        save_ui = bzrlib.ui.ui_factory
1150
 
        bzrlib.trace.info('running tests...')
 
2526
        from bzrlib.tests import selftest
 
2527
        import bzrlib.benchmarks as benchmarks
 
2528
        from bzrlib.benchmarks import tree_creator
 
2529
        from bzrlib.version import show_version
 
2530
 
 
2531
        if cache_dir is not None:
 
2532
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
2533
        if not list_only:
 
2534
            print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
 
2535
            print '   %s (%s python%s)' % (
 
2536
                    bzrlib.__path__[0],
 
2537
                    bzrlib.version_string,
 
2538
                    '.'.join(map(str, sys.version_info)),
 
2539
                    )
 
2540
        print
 
2541
        if testspecs_list is not None:
 
2542
            pattern = '|'.join(testspecs_list)
 
2543
        else:
 
2544
            pattern = ".*"
 
2545
        if benchmark:
 
2546
            test_suite_factory = benchmarks.test_suite
 
2547
            if verbose is None:
 
2548
                verbose = True
 
2549
            # TODO: should possibly lock the history file...
 
2550
            benchfile = open(".perf_history", "at", buffering=1)
 
2551
        else:
 
2552
            test_suite_factory = None
 
2553
            if verbose is None:
 
2554
                verbose = False
 
2555
            benchfile = None
1151
2556
        try:
1152
 
            bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1153
 
            if testspecs_list is not None:
1154
 
                pattern = '|'.join(testspecs_list)
1155
 
            else:
1156
 
                pattern = ".*"
1157
 
            result = selftest(verbose=verbose, 
 
2557
            result = selftest(verbose=verbose,
1158
2558
                              pattern=pattern,
1159
 
                              stop_on_failure=one)
1160
 
            if result:
1161
 
                bzrlib.trace.info('tests passed')
1162
 
            else:
1163
 
                bzrlib.trace.info('tests failed')
1164
 
            return int(not result)
 
2559
                              stop_on_failure=one,
 
2560
                              transport=transport,
 
2561
                              test_suite_factory=test_suite_factory,
 
2562
                              lsprof_timed=lsprof_timed,
 
2563
                              bench_history=benchfile,
 
2564
                              matching_tests_first=first,
 
2565
                              list_only=list_only,
 
2566
                              random_seed=randomize,
 
2567
                              exclude_pattern=exclude,
 
2568
                              strict=strict,
 
2569
                              )
1165
2570
        finally:
1166
 
            bzrlib.ui.ui_factory = save_ui
1167
 
 
1168
 
 
1169
 
def show_version():
1170
 
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
1171
 
    # is bzrlib itself in a branch?
1172
 
    bzrrev = bzrlib.get_bzr_revision()
1173
 
    if bzrrev:
1174
 
        print "  (bzr checkout, revision %d {%s})" % bzrrev
1175
 
    print bzrlib.__copyright__
1176
 
    print "http://bazaar-ng.org/"
1177
 
    print
1178
 
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
1179
 
    print "you may use, modify and redistribute it under the terms of the GNU"
1180
 
    print "General Public License version 2 or later."
 
2571
            if benchfile is not None:
 
2572
                benchfile.close()
 
2573
        if result:
 
2574
            info('tests passed')
 
2575
        else:
 
2576
            info('tests failed')
 
2577
        return int(not result)
1181
2578
 
1182
2579
 
1183
2580
class cmd_version(Command):
1184
2581
    """Show version of bzr."""
 
2582
 
 
2583
    @display_command
1185
2584
    def run(self):
 
2585
        from bzrlib.version import show_version
1186
2586
        show_version()
1187
2587
 
 
2588
 
1188
2589
class cmd_rocks(Command):
1189
2590
    """Statement of optimism."""
 
2591
 
1190
2592
    hidden = True
 
2593
 
 
2594
    @display_command
1191
2595
    def run(self):
1192
 
        print "it sure does!"
 
2596
        print "It sure does!"
1193
2597
 
1194
2598
 
1195
2599
class cmd_find_merge_base(Command):
1196
 
    """Find and print a base revision for merging two branches.
1197
 
    """
 
2600
    """Find and print a base revision for merging two branches."""
1198
2601
    # TODO: Options to specify revisions on either side, as if
1199
2602
    #       merging only part of the history.
1200
2603
    takes_args = ['branch', 'other']
1201
2604
    hidden = True
1202
2605
    
 
2606
    @display_command
1203
2607
    def run(self, branch, other):
1204
 
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
 
2608
        from bzrlib.revision import ensure_null, MultipleRevisionSources
1205
2609
        
1206
2610
        branch1 = Branch.open_containing(branch)[0]
1207
2611
        branch2 = Branch.open_containing(other)[0]
1208
2612
 
1209
 
        history_1 = branch1.revision_history()
1210
 
        history_2 = branch2.revision_history()
1211
 
 
1212
 
        last1 = branch1.last_revision()
1213
 
        last2 = branch2.last_revision()
1214
 
 
1215
 
        source = MultipleRevisionSources(branch1, branch2)
1216
 
        
1217
 
        base_rev_id = common_ancestor(last1, last2, source)
 
2613
        last1 = ensure_null(branch1.last_revision())
 
2614
        last2 = ensure_null(branch2.last_revision())
 
2615
 
 
2616
        graph = branch1.repository.get_graph(branch2.repository)
 
2617
        base_rev_id = graph.find_unique_lca(last1, last2)
1218
2618
 
1219
2619
        print 'merge base is revision %s' % base_rev_id
1220
 
        
1221
 
        return
1222
 
 
1223
 
        if base_revno is None:
1224
 
            raise bzrlib.errors.UnrelatedBranches()
1225
 
 
1226
 
        print ' r%-6d in %s' % (base_revno, branch)
1227
 
 
1228
 
        other_revno = branch2.revision_id_to_revno(base_revid)
1229
 
        
1230
 
        print ' r%-6d in %s' % (other_revno, other)
1231
 
 
1232
2620
 
1233
2621
 
1234
2622
class cmd_merge(Command):
1235
2623
    """Perform a three-way merge.
1236
2624
    
1237
 
    The branch is the branch you will merge from.  By default, it will
1238
 
    merge the latest revision.  If you specify a revision, that
1239
 
    revision will be merged.  If you specify two revisions, the first
1240
 
    will be used as a BASE, and the second one as OTHER.  Revision
1241
 
    numbers are always relative to the specified branch.
 
2625
    The branch is the branch you will merge from.  By default, it will merge
 
2626
    the latest revision.  If you specify a revision, that revision will be
 
2627
    merged.  If you specify two revisions, the first will be used as a BASE,
 
2628
    and the second one as OTHER.  Revision numbers are always relative to the
 
2629
    specified branch.
1242
2630
 
1243
 
    By default bzr will try to merge in all new work from the other
 
2631
    By default, bzr will try to merge in all new work from the other
1244
2632
    branch, automatically determining an appropriate base.  If this
1245
2633
    fails, you may need to give an explicit base.
1246
2634
    
1247
 
    Examples:
1248
 
 
1249
 
    To merge the latest revision from bzr.dev
1250
 
    bzr merge ../bzr.dev
1251
 
 
1252
 
    To merge changes up to and including revision 82 from bzr.dev
1253
 
    bzr merge -r 82 ../bzr.dev
1254
 
 
1255
 
    To merge the changes introduced by 82, without previous changes:
1256
 
    bzr merge -r 81..82 ../bzr.dev
 
2635
    Merge will do its best to combine the changes in two branches, but there
 
2636
    are some kinds of problems only a human can fix.  When it encounters those,
 
2637
    it will mark a conflict.  A conflict means that you need to fix something,
 
2638
    before you should commit.
 
2639
 
 
2640
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
 
2641
 
 
2642
    If there is no default branch set, the first merge will set it. After
 
2643
    that, you can omit the branch to use the default.  To change the
 
2644
    default, use --remember. The value will only be saved if the remote
 
2645
    location can be accessed.
 
2646
 
 
2647
    The results of the merge are placed into the destination working
 
2648
    directory, where they can be reviewed (with bzr diff), tested, and then
 
2649
    committed to record the result of the merge.
1257
2650
    
1258
2651
    merge refuses to run if there are any uncommitted changes, unless
1259
2652
    --force is given.
 
2653
 
 
2654
    :Examples:
 
2655
        To merge the latest revision from bzr.dev::
 
2656
 
 
2657
            bzr merge ../bzr.dev
 
2658
 
 
2659
        To merge changes up to and including revision 82 from bzr.dev::
 
2660
 
 
2661
            bzr merge -r 82 ../bzr.dev
 
2662
 
 
2663
        To merge the changes introduced by 82, without previous changes::
 
2664
 
 
2665
            bzr merge -r 81..82 ../bzr.dev
1260
2666
    """
 
2667
 
 
2668
    _see_also = ['update', 'remerge', 'status-flags']
1261
2669
    takes_args = ['branch?']
1262
 
    takes_options = ['revision', 'force', 'merge-type']
1263
 
 
1264
 
    def run(self, branch=None, revision=None, force=False, 
1265
 
            merge_type=None):
1266
 
        from bzrlib.merge import merge
1267
 
        from bzrlib.merge_core import ApplyMerge3
1268
 
        if merge_type is None:
1269
 
            merge_type = ApplyMerge3
1270
 
        if branch is None:
1271
 
            branch = Branch.open_containing('.')[0].get_parent()
1272
 
            if branch is None:
1273
 
                raise BzrCommandError("No merge location known or specified.")
1274
 
            else:
1275
 
                print "Using saved location: %s" % branch 
1276
 
        if revision is None or len(revision) < 1:
1277
 
            base = [None, None]
1278
 
            other = [branch, -1]
1279
 
        else:
1280
 
            if len(revision) == 1:
1281
 
                base = [None, None]
1282
 
                other = [branch, revision[0].in_history(branch).revno]
1283
 
            else:
1284
 
                assert len(revision) == 2
1285
 
                if None in revision:
1286
 
                    raise BzrCommandError(
1287
 
                        "Merge doesn't permit that revision specifier.")
1288
 
                b = Branch.open(branch)
1289
 
 
1290
 
                base = [branch, revision[0].in_history(b).revno]
1291
 
                other = [branch, revision[1].in_history(b).revno]
1292
 
 
1293
 
        try:
1294
 
            merge(other, base, check_clean=(not force), merge_type=merge_type)
1295
 
        except bzrlib.errors.AmbiguousBase, e:
1296
 
            m = ("sorry, bzr can't determine the right merge base yet\n"
1297
 
                 "candidates are:\n  "
1298
 
                 + "\n  ".join(e.bases)
1299
 
                 + "\n"
1300
 
                 "please specify an explicit base with -r,\n"
1301
 
                 "and (if you want) report this to the bzr developers\n")
1302
 
            log_error(m)
 
2670
    takes_options = [
 
2671
        'revision',
 
2672
        Option('force',
 
2673
               help='Merge even if the destination tree has uncommitted changes.'),
 
2674
        'merge-type',
 
2675
        'reprocess',
 
2676
        'remember',
 
2677
        Option('show-base', help="Show base revision text in "
 
2678
               "conflicts."),
 
2679
        Option('uncommitted', help='Apply uncommitted changes'
 
2680
               ' from a working copy, instead of branch changes.'),
 
2681
        Option('pull', help='If the destination is already'
 
2682
                ' completely merged into the source, pull from the'
 
2683
                ' source rather than merging.  When this happens,'
 
2684
                ' you do not need to commit the result.'),
 
2685
        Option('directory',
 
2686
               help='Branch to merge into, '
 
2687
                    'rather than the one containing the working directory.',
 
2688
               short_name='d',
 
2689
               type=unicode,
 
2690
               ),
 
2691
    ]
 
2692
 
 
2693
    def run(self, branch=None, revision=None, force=False, merge_type=None,
 
2694
            show_base=False, reprocess=False, remember=False,
 
2695
            uncommitted=False, pull=False,
 
2696
            directory=None,
 
2697
            ):
 
2698
        from bzrlib.tag import _merge_tags_if_possible
 
2699
        # This is actually a branch (or merge-directive) *location*.
 
2700
        location = branch
 
2701
        del branch
 
2702
 
 
2703
        if merge_type is None:
 
2704
            merge_type = _mod_merge.Merge3Merger
 
2705
 
 
2706
        if directory is None: directory = u'.'
 
2707
        possible_transports = []
 
2708
        merger = None
 
2709
        allow_pending = True
 
2710
        verified = 'inapplicable'
 
2711
        tree = WorkingTree.open_containing(directory)[0]
 
2712
        change_reporter = delta._ChangeReporter(
 
2713
            unversioned_filter=tree.is_ignored)
 
2714
        cleanups = []
 
2715
        try:
 
2716
            pb = ui.ui_factory.nested_progress_bar()
 
2717
            cleanups.append(pb.finished)
 
2718
            tree.lock_write()
 
2719
            cleanups.append(tree.unlock)
 
2720
            if location is not None:
 
2721
                mergeable, other_transport = _get_mergeable_helper(location)
 
2722
                if mergeable:
 
2723
                    if uncommitted:
 
2724
                        raise errors.BzrCommandError('Cannot use --uncommitted'
 
2725
                            ' with bundles or merge directives.')
 
2726
 
 
2727
                    if revision is not None:
 
2728
                        raise errors.BzrCommandError(
 
2729
                            'Cannot use -r with merge directives or bundles')
 
2730
                    merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
2731
                       mergeable, pb)
 
2732
                possible_transports.append(other_transport)
 
2733
 
 
2734
            if merger is None and uncommitted:
 
2735
                if revision is not None and len(revision) > 0:
 
2736
                    raise errors.BzrCommandError('Cannot use --uncommitted and'
 
2737
                        ' --revision at the same time.')
 
2738
                location = self._select_branch_location(tree, location)[0]
 
2739
                other_tree, other_path = WorkingTree.open_containing(location)
 
2740
                merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
 
2741
                    pb)
 
2742
                allow_pending = False
 
2743
 
 
2744
            if merger is None:
 
2745
                merger, allow_pending = self._get_merger_from_branch(tree,
 
2746
                    location, revision, remember, possible_transports, pb)
 
2747
 
 
2748
            merger.merge_type = merge_type
 
2749
            merger.reprocess = reprocess
 
2750
            merger.show_base = show_base
 
2751
            merger.change_reporter = change_reporter
 
2752
            self.sanity_check_merger(merger)
 
2753
            if (merger.base_rev_id == merger.other_rev_id and
 
2754
                merger.other_rev_id != None):
 
2755
                note('Nothing to do.')
 
2756
                return 0
 
2757
            if pull:
 
2758
                if merger.interesting_files is not None:
 
2759
                    raise BzrCommandError('Cannot pull individual files')
 
2760
                if (merger.base_rev_id == tree.last_revision()):
 
2761
                    result = tree.pull(merger.other_branch, False,
 
2762
                                       merger.other_rev_id)
 
2763
                    result.report(self.outf)
 
2764
                    return 0
 
2765
            merger.check_basis(not force)
 
2766
            conflict_count = merger.do_merge()
 
2767
            if allow_pending:
 
2768
                merger.set_pending()
 
2769
            if verified == 'failed':
 
2770
                warning('Preview patch does not match changes')
 
2771
            if conflict_count != 0:
 
2772
                return 1
 
2773
            else:
 
2774
                return 0
 
2775
        finally:
 
2776
            for cleanup in reversed(cleanups):
 
2777
                cleanup()
 
2778
 
 
2779
    def sanity_check_merger(self, merger):
 
2780
        if (merger.show_base and
 
2781
            not merger.merge_type is _mod_merge.Merge3Merger):
 
2782
            raise errors.BzrCommandError("Show-base is not supported for this"
 
2783
                                         " merge type. %s" % merger.merge_type)
 
2784
        if merger.reprocess and not merger.merge_type.supports_reprocess:
 
2785
            raise errors.BzrCommandError("Conflict reduction is not supported"
 
2786
                                         " for merge type %s." %
 
2787
                                         merger.merge_type)
 
2788
        if merger.reprocess and merger.show_base:
 
2789
            raise errors.BzrCommandError("Cannot do conflict reduction and"
 
2790
                                         " show base.")
 
2791
 
 
2792
    def _get_merger_from_branch(self, tree, location, revision, remember,
 
2793
                                possible_transports, pb):
 
2794
        """Produce a merger from a location, assuming it refers to a branch."""
 
2795
        from bzrlib.tag import _merge_tags_if_possible
 
2796
        assert revision is None or len(revision) < 3
 
2797
        # find the branch locations
 
2798
        other_loc, location = self._select_branch_location(tree, location,
 
2799
            revision, -1)
 
2800
        if revision is not None and len(revision) == 2:
 
2801
            base_loc, location = self._select_branch_location(tree, location,
 
2802
                                                              revision, 0)
 
2803
        else:
 
2804
            base_loc = other_loc
 
2805
        # Open the branches
 
2806
        other_branch, other_path = Branch.open_containing(other_loc,
 
2807
            possible_transports)
 
2808
        if base_loc == other_loc:
 
2809
            base_branch = other_branch
 
2810
        else:
 
2811
            base_branch, base_path = Branch.open_containing(base_loc,
 
2812
                possible_transports)
 
2813
        # Find the revision ids
 
2814
        if revision is None or len(revision) < 1 or revision[-1] is None:
 
2815
            other_revision_id = _mod_revision.ensure_null(
 
2816
                other_branch.last_revision())
 
2817
        else:
 
2818
            other_revision_id = \
 
2819
                _mod_revision.ensure_null(
 
2820
                    revision[-1].in_history(other_branch).rev_id)
 
2821
        if (revision is not None and len(revision) == 2
 
2822
            and revision[0] is not None):
 
2823
            base_revision_id = \
 
2824
                _mod_revision.ensure_null(
 
2825
                    revision[0].in_history(base_branch).rev_id)
 
2826
        else:
 
2827
            base_revision_id = None
 
2828
        # Remember where we merge from
 
2829
        if ((tree.branch.get_parent() is None or remember) and
 
2830
            other_branch is not None):
 
2831
            tree.branch.set_parent(other_branch.base)
 
2832
        _merge_tags_if_possible(other_branch, tree.branch)
 
2833
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
 
2834
            other_revision_id, base_revision_id, other_branch, base_branch)
 
2835
        if other_path != '':
 
2836
            allow_pending = False
 
2837
            merger.interesting_files = [other_path]
 
2838
        else:
 
2839
            allow_pending = True
 
2840
        return merger, allow_pending
 
2841
 
 
2842
    def _select_branch_location(self, tree, location, revision=None,
 
2843
                                index=None):
 
2844
        """Select a branch location, according to possible inputs.
 
2845
 
 
2846
        If provided, branches from ``revision`` are preferred.  (Both
 
2847
        ``revision`` and ``index`` must be supplied.)
 
2848
 
 
2849
        Otherwise, the ``location`` parameter is used.  If it is None, then the
 
2850
        ``parent`` location is used, and a note is printed.
 
2851
 
 
2852
        :param tree: The working tree to select a branch for merging into
 
2853
        :param location: The location entered by the user
 
2854
        :param revision: The revision parameter to the command
 
2855
        :param index: The index to use for the revision parameter.  Negative
 
2856
            indices are permitted.
 
2857
        :return: (selected_location, default_location).  The default location
 
2858
            will be the user-entered location, if any, or else the remembered
 
2859
            location.
 
2860
        """
 
2861
        if (revision is not None and index is not None
 
2862
            and revision[index] is not None):
 
2863
            branch = revision[index].get_branch()
 
2864
            if branch is not None:
 
2865
                return branch, location
 
2866
        location = self._get_remembered_parent(tree, location, 'Merging from')
 
2867
        return location, location
 
2868
 
 
2869
    # TODO: move up to common parent; this isn't merge-specific anymore. 
 
2870
    def _get_remembered_parent(self, tree, supplied_location, verb_string):
 
2871
        """Use tree.branch's parent if none was supplied.
 
2872
 
 
2873
        Report if the remembered location was used.
 
2874
        """
 
2875
        if supplied_location is not None:
 
2876
            return supplied_location
 
2877
        stored_location = tree.branch.get_parent()
 
2878
        mutter("%s", stored_location)
 
2879
        if stored_location is None:
 
2880
            raise errors.BzrCommandError("No location specified or remembered")
 
2881
        display_url = urlutils.unescape_for_display(stored_location,
 
2882
            self.outf.encoding)
 
2883
        self.outf.write("%s remembered location %s\n" % (verb_string,
 
2884
            display_url))
 
2885
        return stored_location
 
2886
 
 
2887
 
 
2888
class cmd_remerge(Command):
 
2889
    """Redo a merge.
 
2890
 
 
2891
    Use this if you want to try a different merge technique while resolving
 
2892
    conflicts.  Some merge techniques are better than others, and remerge 
 
2893
    lets you try different ones on different files.
 
2894
 
 
2895
    The options for remerge have the same meaning and defaults as the ones for
 
2896
    merge.  The difference is that remerge can (only) be run when there is a
 
2897
    pending merge, and it lets you specify particular files.
 
2898
 
 
2899
    :Examples:
 
2900
        Re-do the merge of all conflicted files, and show the base text in
 
2901
        conflict regions, in addition to the usual THIS and OTHER texts::
 
2902
      
 
2903
            bzr remerge --show-base
 
2904
 
 
2905
        Re-do the merge of "foobar", using the weave merge algorithm, with
 
2906
        additional processing to reduce the size of conflict regions::
 
2907
      
 
2908
            bzr remerge --merge-type weave --reprocess foobar
 
2909
    """
 
2910
    takes_args = ['file*']
 
2911
    takes_options = [
 
2912
            'merge-type',
 
2913
            'reprocess',
 
2914
            Option('show-base',
 
2915
                   help="Show base revision text in conflicts."),
 
2916
            ]
 
2917
 
 
2918
    def run(self, file_list=None, merge_type=None, show_base=False,
 
2919
            reprocess=False):
 
2920
        if merge_type is None:
 
2921
            merge_type = _mod_merge.Merge3Merger
 
2922
        tree, file_list = tree_files(file_list)
 
2923
        tree.lock_write()
 
2924
        try:
 
2925
            parents = tree.get_parent_ids()
 
2926
            if len(parents) != 2:
 
2927
                raise errors.BzrCommandError("Sorry, remerge only works after normal"
 
2928
                                             " merges.  Not cherrypicking or"
 
2929
                                             " multi-merges.")
 
2930
            repository = tree.branch.repository
 
2931
            graph = repository.get_graph()
 
2932
            base_revision = graph.find_unique_lca(parents[0], parents[1])
 
2933
            base_tree = repository.revision_tree(base_revision)
 
2934
            other_tree = repository.revision_tree(parents[1])
 
2935
            interesting_ids = None
 
2936
            new_conflicts = []
 
2937
            conflicts = tree.conflicts()
 
2938
            if file_list is not None:
 
2939
                interesting_ids = set()
 
2940
                for filename in file_list:
 
2941
                    file_id = tree.path2id(filename)
 
2942
                    if file_id is None:
 
2943
                        raise errors.NotVersionedError(filename)
 
2944
                    interesting_ids.add(file_id)
 
2945
                    if tree.kind(file_id) != "directory":
 
2946
                        continue
 
2947
                    
 
2948
                    for name, ie in tree.inventory.iter_entries(file_id):
 
2949
                        interesting_ids.add(ie.file_id)
 
2950
                new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
 
2951
            else:
 
2952
                # Remerge only supports resolving contents conflicts
 
2953
                allowed_conflicts = ('text conflict', 'contents conflict')
 
2954
                restore_files = [c.path for c in conflicts
 
2955
                                 if c.typestring in allowed_conflicts]
 
2956
            _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
 
2957
            tree.set_conflicts(ConflictList(new_conflicts))
 
2958
            if file_list is not None:
 
2959
                restore_files = file_list
 
2960
            for filename in restore_files:
 
2961
                try:
 
2962
                    restore(tree.abspath(filename))
 
2963
                except errors.NotConflicted:
 
2964
                    pass
 
2965
            # Disable pending merges, because the file texts we are remerging
 
2966
            # have not had those merges performed.  If we use the wrong parents
 
2967
            # list, we imply that the working tree text has seen and rejected
 
2968
            # all the changes from the other tree, when in fact those changes
 
2969
            # have not yet been seen.
 
2970
            tree.set_parent_ids(parents[:1])
 
2971
            try:
 
2972
                conflicts = _mod_merge.merge_inner(
 
2973
                                          tree.branch, other_tree, base_tree,
 
2974
                                          this_tree=tree,
 
2975
                                          interesting_ids=interesting_ids,
 
2976
                                          other_rev_id=parents[1],
 
2977
                                          merge_type=merge_type,
 
2978
                                          show_base=show_base,
 
2979
                                          reprocess=reprocess)
 
2980
            finally:
 
2981
                tree.set_parent_ids(parents)
 
2982
        finally:
 
2983
            tree.unlock()
 
2984
        if conflicts > 0:
 
2985
            return 1
 
2986
        else:
 
2987
            return 0
1303
2988
 
1304
2989
 
1305
2990
class cmd_revert(Command):
1306
 
    """Reverse all changes since the last commit.
1307
 
 
1308
 
    Only versioned files are affected.  Specify filenames to revert only 
1309
 
    those files.  By default, any files that are changed will be backed up
1310
 
    first.  Backup files have a '~' appended to their name.
 
2991
    """Revert files to a previous revision.
 
2992
 
 
2993
    Giving a list of files will revert only those files.  Otherwise, all files
 
2994
    will be reverted.  If the revision is not specified with '--revision', the
 
2995
    last committed revision is used.
 
2996
 
 
2997
    To remove only some changes, without reverting to a prior version, use
 
2998
    merge instead.  For example, "merge . --r-2..-3" will remove the changes
 
2999
    introduced by -2, without affecting the changes introduced by -1.  Or
 
3000
    to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
3001
    
 
3002
    By default, any files that have been manually changed will be backed up
 
3003
    first.  (Files changed only by merge are not backed up.)  Backup files have
 
3004
    '.~#~' appended to their name, where # is a number.
 
3005
 
 
3006
    When you provide files, you can use their current pathname or the pathname
 
3007
    from the target revision.  So you can use revert to "undelete" a file by
 
3008
    name.  If you name a directory, all the contents of that directory will be
 
3009
    reverted.
1311
3010
    """
1312
 
    takes_options = ['revision', 'no-backup']
 
3011
 
 
3012
    _see_also = ['cat', 'export']
 
3013
    takes_options = [
 
3014
            'revision',
 
3015
            Option('no-backup', "Do not save backups of reverted files."),
 
3016
            ]
1313
3017
    takes_args = ['file*']
1314
 
    aliases = ['merge-revert']
1315
3018
 
1316
3019
    def run(self, revision=None, no_backup=False, file_list=None):
1317
 
        from bzrlib.merge import merge
1318
 
        from bzrlib.commands import parse_spec
1319
 
 
1320
3020
        if file_list is not None:
1321
3021
            if len(file_list) == 0:
1322
 
                raise BzrCommandError("No files specified")
 
3022
                raise errors.BzrCommandError("No files specified")
 
3023
        else:
 
3024
            file_list = []
 
3025
        
 
3026
        tree, file_list = tree_files(file_list)
1323
3027
        if revision is None:
1324
 
            revno = -1
 
3028
            # FIXME should be tree.last_revision
 
3029
            rev_id = tree.last_revision()
1325
3030
        elif len(revision) != 1:
1326
 
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
 
3031
            raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
1327
3032
        else:
1328
 
            b = Branch.open_containing('.')[0]
1329
 
            revno = revision[0].in_history(b).revno
1330
 
        merge(('.', revno), parse_spec('.'),
1331
 
              check_clean=False,
1332
 
              ignore_zero=True,
1333
 
              backup_files=not no_backup,
1334
 
              file_list=file_list)
1335
 
        if not file_list:
1336
 
            Branch.open_containing('.')[0].set_pending_merges([])
 
3033
            rev_id = revision[0].in_history(tree.branch).rev_id
 
3034
        pb = ui.ui_factory.nested_progress_bar()
 
3035
        try:
 
3036
            tree.revert(file_list, 
 
3037
                        tree.branch.repository.revision_tree(rev_id),
 
3038
                        not no_backup, pb, report_changes=True)
 
3039
        finally:
 
3040
            pb.finished()
1337
3041
 
1338
3042
 
1339
3043
class cmd_assert_fail(Command):
1340
3044
    """Test reporting of assertion failures"""
 
3045
    # intended just for use in testing
 
3046
 
1341
3047
    hidden = True
 
3048
 
1342
3049
    def run(self):
1343
 
        assert False, "always fails"
 
3050
        raise AssertionError("always fails")
1344
3051
 
1345
3052
 
1346
3053
class cmd_help(Command):
1347
3054
    """Show help on a command or other topic.
 
3055
    """
1348
3056
 
1349
 
    For a list of all available commands, say 'bzr help commands'."""
1350
 
    takes_options = ['long']
 
3057
    _see_also = ['topics']
 
3058
    takes_options = [
 
3059
            Option('long', 'Show help on all commands.'),
 
3060
            ]
1351
3061
    takes_args = ['topic?']
1352
 
    aliases = ['?']
 
3062
    aliases = ['?', '--help', '-?', '-h']
1353
3063
    
 
3064
    @display_command
1354
3065
    def run(self, topic=None, long=False):
1355
 
        import help
 
3066
        import bzrlib.help
1356
3067
        if topic is None and long:
1357
3068
            topic = "commands"
1358
 
        help.help(topic)
 
3069
        bzrlib.help.help(topic)
1359
3070
 
1360
3071
 
1361
3072
class cmd_shell_complete(Command):
1362
3073
    """Show appropriate completions for context.
1363
3074
 
1364
 
    For a list of all available commands, say 'bzr shell-complete'."""
 
3075
    For a list of all available commands, say 'bzr shell-complete'.
 
3076
    """
1365
3077
    takes_args = ['context?']
1366
3078
    aliases = ['s-c']
1367
3079
    hidden = True
1368
3080
    
 
3081
    @display_command
1369
3082
    def run(self, context=None):
1370
3083
        import shellcomplete
1371
3084
        shellcomplete.shellcomplete(context)
1374
3087
class cmd_fetch(Command):
1375
3088
    """Copy in history from another branch but don't merge it.
1376
3089
 
1377
 
    This is an internal method used for pull and merge."""
 
3090
    This is an internal method used for pull and merge.
 
3091
    """
1378
3092
    hidden = True
1379
3093
    takes_args = ['from_branch', 'to_branch']
1380
3094
    def run(self, from_branch, to_branch):
1381
3095
        from bzrlib.fetch import Fetcher
1382
 
        from bzrlib.branch import Branch
1383
 
        from_b = Branch(from_branch)
1384
 
        to_b = Branch(to_branch)
 
3096
        from_b = Branch.open(from_branch)
 
3097
        to_b = Branch.open(to_branch)
1385
3098
        Fetcher(to_b, from_b)
1386
 
        
1387
3099
 
1388
3100
 
1389
3101
class cmd_missing(Command):
1390
 
    """What is missing in this branch relative to other branch.
 
3102
    """Show unmerged/unpulled revisions between two branches.
 
3103
    
 
3104
    OTHER_BRANCH may be local or remote.
1391
3105
    """
1392
 
    # TODO: rewrite this in terms of ancestry so that it shows only
1393
 
    # unmerged things
1394
 
    
1395
 
    takes_args = ['remote?']
1396
 
    aliases = ['mis', 'miss']
1397
 
    # We don't have to add quiet to the list, because 
1398
 
    # unknown options are parsed as booleans
1399
 
    takes_options = ['verbose', 'quiet']
1400
 
 
1401
 
    def run(self, remote=None, verbose=False, quiet=False):
1402
 
        from bzrlib.errors import BzrCommandError
1403
 
        from bzrlib.missing import show_missing
1404
 
 
1405
 
        if verbose and quiet:
1406
 
            raise BzrCommandError('Cannot pass both quiet and verbose')
1407
 
 
1408
 
        b = Branch.open_containing('.')[0]
1409
 
        parent = b.get_parent()
1410
 
        if remote is None:
1411
 
            if parent is None:
1412
 
                raise BzrCommandError("No missing location known or specified.")
1413
 
            else:
1414
 
                if not quiet:
1415
 
                    print "Using last location: %s" % parent
1416
 
                remote = parent
1417
 
        elif parent is None:
1418
 
            # We only update parent if it did not exist, missing
1419
 
            # should not change the parent
1420
 
            b.set_parent(remote)
1421
 
        br_remote = Branch.open_containing(remote)[0]
1422
 
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
 
3106
 
 
3107
    _see_also = ['merge', 'pull']
 
3108
    takes_args = ['other_branch?']
 
3109
    takes_options = [
 
3110
            Option('reverse', 'Reverse the order of revisions.'),
 
3111
            Option('mine-only',
 
3112
                   'Display changes in the local branch only.'),
 
3113
            Option('this' , 'Same as --mine-only.'),
 
3114
            Option('theirs-only',
 
3115
                   'Display changes in the remote branch only.'),
 
3116
            Option('other', 'Same as --theirs-only.'),
 
3117
            'log-format',
 
3118
            'show-ids',
 
3119
            'verbose'
 
3120
            ]
 
3121
    encoding_type = 'replace'
 
3122
 
 
3123
    @display_command
 
3124
    def run(self, other_branch=None, reverse=False, mine_only=False,
 
3125
            theirs_only=False, log_format=None, long=False, short=False, line=False, 
 
3126
            show_ids=False, verbose=False, this=False, other=False):
 
3127
        from bzrlib.missing import find_unmerged, iter_log_revisions
 
3128
        from bzrlib.log import log_formatter
 
3129
 
 
3130
        if this:
 
3131
          mine_only = this
 
3132
        if other:
 
3133
          theirs_only = other
 
3134
 
 
3135
        local_branch = Branch.open_containing(u".")[0]
 
3136
        parent = local_branch.get_parent()
 
3137
        if other_branch is None:
 
3138
            other_branch = parent
 
3139
            if other_branch is None:
 
3140
                raise errors.BzrCommandError("No peer location known"
 
3141
                                             " or specified.")
 
3142
            display_url = urlutils.unescape_for_display(parent,
 
3143
                                                        self.outf.encoding)
 
3144
            self.outf.write("Using last location: " + display_url + "\n")
 
3145
 
 
3146
        remote_branch = Branch.open(other_branch)
 
3147
        if remote_branch.base == local_branch.base:
 
3148
            remote_branch = local_branch
 
3149
        local_branch.lock_read()
 
3150
        try:
 
3151
            remote_branch.lock_read()
 
3152
            try:
 
3153
                local_extra, remote_extra = find_unmerged(local_branch,
 
3154
                                                          remote_branch)
 
3155
                if log_format is None:
 
3156
                    registry = log.log_formatter_registry
 
3157
                    log_format = registry.get_default(local_branch)
 
3158
                lf = log_format(to_file=self.outf,
 
3159
                                show_ids=show_ids,
 
3160
                                show_timezone='original')
 
3161
                if reverse is False:
 
3162
                    local_extra.reverse()
 
3163
                    remote_extra.reverse()
 
3164
                if local_extra and not theirs_only:
 
3165
                    self.outf.write("You have %d extra revision(s):\n" %
 
3166
                                    len(local_extra))
 
3167
                    for revision in iter_log_revisions(local_extra,
 
3168
                                        local_branch.repository,
 
3169
                                        verbose):
 
3170
                        lf.log_revision(revision)
 
3171
                    printed_local = True
 
3172
                else:
 
3173
                    printed_local = False
 
3174
                if remote_extra and not mine_only:
 
3175
                    if printed_local is True:
 
3176
                        self.outf.write("\n\n\n")
 
3177
                    self.outf.write("You are missing %d revision(s):\n" %
 
3178
                                    len(remote_extra))
 
3179
                    for revision in iter_log_revisions(remote_extra,
 
3180
                                        remote_branch.repository,
 
3181
                                        verbose):
 
3182
                        lf.log_revision(revision)
 
3183
                if not remote_extra and not local_extra:
 
3184
                    status_code = 0
 
3185
                    self.outf.write("Branches are up to date.\n")
 
3186
                else:
 
3187
                    status_code = 1
 
3188
            finally:
 
3189
                remote_branch.unlock()
 
3190
        finally:
 
3191
            local_branch.unlock()
 
3192
        if not status_code and parent is None and other_branch is not None:
 
3193
            local_branch.lock_write()
 
3194
            try:
 
3195
                # handle race conditions - a parent might be set while we run.
 
3196
                if local_branch.get_parent() is None:
 
3197
                    local_branch.set_parent(remote_branch.base)
 
3198
            finally:
 
3199
                local_branch.unlock()
 
3200
        return status_code
 
3201
 
 
3202
 
 
3203
class cmd_pack(Command):
 
3204
    """Compress the data within a repository."""
 
3205
 
 
3206
    _see_also = ['repositories']
 
3207
    takes_args = ['branch_or_repo?']
 
3208
 
 
3209
    def run(self, branch_or_repo='.'):
 
3210
        dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
 
3211
        try:
 
3212
            branch = dir.open_branch()
 
3213
            repository = branch.repository
 
3214
        except errors.NotBranchError:
 
3215
            repository = dir.open_repository()
 
3216
        repository.pack()
1423
3217
 
1424
3218
 
1425
3219
class cmd_plugins(Command):
1426
 
    """List plugins"""
1427
 
    hidden = True
 
3220
    """List the installed plugins.
 
3221
    
 
3222
    This command displays the list of installed plugins including the
 
3223
    path where each one is located and a short description of each.
 
3224
 
 
3225
    A plugin is an external component for Bazaar that extends the
 
3226
    revision control system, by adding or replacing code in Bazaar.
 
3227
    Plugins can do a variety of things, including overriding commands,
 
3228
    adding new commands, providing additional network transports and
 
3229
    customizing log output.
 
3230
 
 
3231
    See the Bazaar web site, http://bazaar-vcs.org, for further
 
3232
    information on plugins including where to find them and how to
 
3233
    install them. Instructions are also provided there on how to
 
3234
    write new plugins using the Python programming language.
 
3235
    """
 
3236
 
 
3237
    @display_command
1428
3238
    def run(self):
1429
3239
        import bzrlib.plugin
1430
3240
        from inspect import getdoc
1431
 
        for plugin in bzrlib.plugin.all_plugins:
1432
 
            if hasattr(plugin, '__path__'):
1433
 
                print plugin.__path__[0]
1434
 
            elif hasattr(plugin, '__file__'):
1435
 
                print plugin.__file__
1436
 
            else:
1437
 
                print `plugin`
1438
 
                
1439
 
            d = getdoc(plugin)
 
3241
        for name, plugin in bzrlib.plugin.plugins().items():
 
3242
            print plugin.path(), "[%s]" % plugin.__version__
 
3243
            d = getdoc(plugin.module)
1440
3244
            if d:
1441
3245
                print '\t', d.split('\n')[0]
1442
3246
 
1443
3247
 
1444
3248
class cmd_testament(Command):
1445
3249
    """Show testament (signing-form) of a revision."""
1446
 
    takes_options = ['revision', 'long']
 
3250
    takes_options = [
 
3251
            'revision',
 
3252
            Option('long', help='Produce long-format testament.'),
 
3253
            Option('strict',
 
3254
                   help='Produce a strict-format testament.')]
1447
3255
    takes_args = ['branch?']
1448
 
    def run(self, branch='.', revision=None, long=False):
1449
 
        from bzrlib.testament import Testament
1450
 
        b = Branch.open_containing(branch)[0]
 
3256
    @display_command
 
3257
    def run(self, branch=u'.', revision=None, long=False, strict=False):
 
3258
        from bzrlib.testament import Testament, StrictTestament
 
3259
        if strict is True:
 
3260
            testament_class = StrictTestament
 
3261
        else:
 
3262
            testament_class = Testament
 
3263
        b = WorkingTree.open_containing(branch)[0].branch
1451
3264
        b.lock_read()
1452
3265
        try:
1453
3266
            if revision is None:
1454
3267
                rev_id = b.last_revision()
1455
3268
            else:
1456
3269
                rev_id = revision[0].in_history(b).rev_id
1457
 
            t = Testament.from_revision(b, rev_id)
 
3270
            t = testament_class.from_revision(b.repository, rev_id)
1458
3271
            if long:
1459
3272
                sys.stdout.writelines(t.as_text_lines())
1460
3273
            else:
1473
3286
    shown only at the top, unless the --all option is given.
1474
3287
    """
1475
3288
    # TODO: annotate directories; showing when each file was last changed
1476
 
    # TODO: annotate a previous version of a file
1477
3289
    # TODO: if the working copy is modified, show annotations on that 
1478
3290
    #       with new uncommitted lines marked
1479
 
    aliases = ['blame', 'praise']
 
3291
    aliases = ['ann', 'blame', 'praise']
1480
3292
    takes_args = ['filename']
1481
 
    takes_options = [Option('all', help='show annotations on all lines'),
1482
 
                     Option('long', help='show date in annotations'),
 
3293
    takes_options = [Option('all', help='Show annotations on all lines.'),
 
3294
                     Option('long', help='Show commit date in annotations.'),
 
3295
                     'revision',
 
3296
                     'show-ids',
1483
3297
                     ]
 
3298
    encoding_type = 'exact'
1484
3299
 
1485
 
    def run(self, filename, all=False, long=False):
 
3300
    @display_command
 
3301
    def run(self, filename, all=False, long=False, revision=None,
 
3302
            show_ids=False):
1486
3303
        from bzrlib.annotate import annotate_file
1487
 
        b, relpath = Branch.open_containing(filename)
1488
 
        b.lock_read()
 
3304
        tree, relpath = WorkingTree.open_containing(filename)
 
3305
        branch = tree.branch
 
3306
        branch.lock_read()
1489
3307
        try:
1490
 
            tree = WorkingTree(b.base, b)
1491
 
            tree = b.revision_tree(b.last_revision())
1492
 
            file_id = tree.inventory.path2id(relpath)
 
3308
            if revision is None:
 
3309
                revision_id = branch.last_revision()
 
3310
            elif len(revision) != 1:
 
3311
                raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
 
3312
            else:
 
3313
                revision_id = revision[0].in_history(branch).rev_id
 
3314
            file_id = tree.path2id(relpath)
 
3315
            if file_id is None:
 
3316
                raise errors.NotVersionedError(filename)
 
3317
            tree = branch.repository.revision_tree(revision_id)
1493
3318
            file_version = tree.inventory[file_id].revision
1494
 
            annotate_file(b, file_version, file_id, long, all, sys.stdout)
 
3319
            annotate_file(branch, file_version, file_id, long, all, self.outf,
 
3320
                          show_ids=show_ids)
1495
3321
        finally:
1496
 
            b.unlock()
 
3322
            branch.unlock()
1497
3323
 
1498
3324
 
1499
3325
class cmd_re_sign(Command):
1501
3327
    # TODO be able to replace existing ones.
1502
3328
 
1503
3329
    hidden = True # is this right ?
1504
 
    takes_args = ['revision_id?']
 
3330
    takes_args = ['revision_id*']
1505
3331
    takes_options = ['revision']
1506
3332
    
1507
 
    def run(self, revision_id=None, revision=None):
1508
 
        import bzrlib.config as config
 
3333
    def run(self, revision_id_list=None, revision=None):
1509
3334
        import bzrlib.gpg as gpg
1510
 
        if revision_id is not None and revision is not None:
1511
 
            raise BzrCommandError('You can only supply one of revision_id or --revision')
1512
 
        if revision_id is None and revision is None:
1513
 
            raise BzrCommandError('You must supply either --revision or a revision_id')
1514
 
        b = Branch.open_containing('.')[0]
1515
 
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1516
 
        if revision_id is not None:
1517
 
            b.sign_revision(revision_id, gpg_strategy)
 
3335
        if revision_id_list is not None and revision is not None:
 
3336
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
 
3337
        if revision_id_list is None and revision is None:
 
3338
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
 
3339
        b = WorkingTree.open_containing(u'.')[0].branch
 
3340
        gpg_strategy = gpg.GPGStrategy(b.get_config())
 
3341
        if revision_id_list is not None:
 
3342
            for revision_id in revision_id_list:
 
3343
                b.repository.sign_revision(revision_id, gpg_strategy)
1518
3344
        elif revision is not None:
1519
 
            for rev in revision:
1520
 
                if rev is None:
1521
 
                    raise BzrCommandError('You cannot specify a NULL revision.')
1522
 
                revno, rev_id = rev.in_history(b)
1523
 
                b.sign_revision(rev_id, gpg_strategy)
 
3345
            if len(revision) == 1:
 
3346
                revno, rev_id = revision[0].in_history(b)
 
3347
                b.repository.sign_revision(rev_id, gpg_strategy)
 
3348
            elif len(revision) == 2:
 
3349
                # are they both on rh- if so we can walk between them
 
3350
                # might be nice to have a range helper for arbitrary
 
3351
                # revision paths. hmm.
 
3352
                from_revno, from_revid = revision[0].in_history(b)
 
3353
                to_revno, to_revid = revision[1].in_history(b)
 
3354
                if to_revid is None:
 
3355
                    to_revno = b.revno()
 
3356
                if from_revno is None or to_revno is None:
 
3357
                    raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
 
3358
                for revno in range(from_revno, to_revno + 1):
 
3359
                    b.repository.sign_revision(b.get_rev_id(revno), 
 
3360
                                               gpg_strategy)
 
3361
            else:
 
3362
                raise errors.BzrCommandError('Please supply either one revision, or a range.')
 
3363
 
 
3364
 
 
3365
class cmd_bind(Command):
 
3366
    """Convert the current branch into a checkout of the supplied branch.
 
3367
 
 
3368
    Once converted into a checkout, commits must succeed on the master branch
 
3369
    before they will be applied to the local branch.
 
3370
    """
 
3371
 
 
3372
    _see_also = ['checkouts', 'unbind']
 
3373
    takes_args = ['location?']
 
3374
    takes_options = []
 
3375
 
 
3376
    def run(self, location=None):
 
3377
        b, relpath = Branch.open_containing(u'.')
 
3378
        if location is None:
 
3379
            try:
 
3380
                location = b.get_old_bound_location()
 
3381
            except errors.UpgradeRequired:
 
3382
                raise errors.BzrCommandError('No location supplied.  '
 
3383
                    'This format does not remember old locations.')
 
3384
            else:
 
3385
                if location is None:
 
3386
                    raise errors.BzrCommandError('No location supplied and no '
 
3387
                        'previous location known')
 
3388
        b_other = Branch.open(location)
 
3389
        try:
 
3390
            b.bind(b_other)
 
3391
        except errors.DivergedBranches:
 
3392
            raise errors.BzrCommandError('These branches have diverged.'
 
3393
                                         ' Try merging, and then bind again.')
 
3394
 
 
3395
 
 
3396
class cmd_unbind(Command):
 
3397
    """Convert the current checkout into a regular branch.
 
3398
 
 
3399
    After unbinding, the local branch is considered independent and subsequent
 
3400
    commits will be local only.
 
3401
    """
 
3402
 
 
3403
    _see_also = ['checkouts', 'bind']
 
3404
    takes_args = []
 
3405
    takes_options = []
 
3406
 
 
3407
    def run(self):
 
3408
        b, relpath = Branch.open_containing(u'.')
 
3409
        if not b.unbind():
 
3410
            raise errors.BzrCommandError('Local branch is not bound')
 
3411
 
 
3412
 
 
3413
class cmd_uncommit(Command):
 
3414
    """Remove the last committed revision.
 
3415
 
 
3416
    --verbose will print out what is being removed.
 
3417
    --dry-run will go through all the motions, but not actually
 
3418
    remove anything.
 
3419
 
 
3420
    If --revision is specified, uncommit revisions to leave the branch at the
 
3421
    specified revision.  For example, "bzr uncommit -r 15" will leave the
 
3422
    branch at revision 15.
 
3423
 
 
3424
    In the future, uncommit will create a revision bundle, which can then
 
3425
    be re-applied.
 
3426
    """
 
3427
 
 
3428
    # TODO: jam 20060108 Add an option to allow uncommit to remove
 
3429
    # unreferenced information in 'branch-as-repository' branches.
 
3430
    # TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
 
3431
    # information in shared branches as well.
 
3432
    _see_also = ['commit']
 
3433
    takes_options = ['verbose', 'revision',
 
3434
                    Option('dry-run', help='Don\'t actually make changes.'),
 
3435
                    Option('force', help='Say yes to all questions.')]
 
3436
    takes_args = ['location?']
 
3437
    aliases = []
 
3438
 
 
3439
    def run(self, location=None,
 
3440
            dry_run=False, verbose=False,
 
3441
            revision=None, force=False):
 
3442
        from bzrlib.log import log_formatter, show_log
 
3443
        import sys
 
3444
        from bzrlib.uncommit import uncommit
 
3445
 
 
3446
        if location is None:
 
3447
            location = u'.'
 
3448
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
3449
        try:
 
3450
            tree = control.open_workingtree()
 
3451
            b = tree.branch
 
3452
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
3453
            tree = None
 
3454
            b = control.open_branch()
 
3455
 
 
3456
        rev_id = None
 
3457
        if revision is None:
 
3458
            revno = b.revno()
 
3459
        else:
 
3460
            # 'bzr uncommit -r 10' actually means uncommit
 
3461
            # so that the final tree is at revno 10.
 
3462
            # but bzrlib.uncommit.uncommit() actually uncommits
 
3463
            # the revisions that are supplied.
 
3464
            # So we need to offset it by one
 
3465
            revno = revision[0].in_history(b).revno+1
 
3466
 
 
3467
        if revno <= b.revno():
 
3468
            rev_id = b.get_rev_id(revno)
 
3469
        if rev_id is None:
 
3470
            self.outf.write('No revisions to uncommit.\n')
 
3471
            return 1
 
3472
 
 
3473
        lf = log_formatter('short',
 
3474
                           to_file=self.outf,
 
3475
                           show_timezone='original')
 
3476
 
 
3477
        show_log(b,
 
3478
                 lf,
 
3479
                 verbose=False,
 
3480
                 direction='forward',
 
3481
                 start_revision=revno,
 
3482
                 end_revision=b.revno())
 
3483
 
 
3484
        if dry_run:
 
3485
            print 'Dry-run, pretending to remove the above revisions.'
 
3486
            if not force:
 
3487
                val = raw_input('Press <enter> to continue')
 
3488
        else:
 
3489
            print 'The above revision(s) will be removed.'
 
3490
            if not force:
 
3491
                val = raw_input('Are you sure [y/N]? ')
 
3492
                if val.lower() not in ('y', 'yes'):
 
3493
                    print 'Canceled'
 
3494
                    return 0
 
3495
 
 
3496
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
 
3497
                revno=revno)
 
3498
 
 
3499
 
 
3500
class cmd_break_lock(Command):
 
3501
    """Break a dead lock on a repository, branch or working directory.
 
3502
 
 
3503
    CAUTION: Locks should only be broken when you are sure that the process
 
3504
    holding the lock has been stopped.
 
3505
 
 
3506
    You can get information on what locks are open via the 'bzr info' command.
 
3507
    
 
3508
    :Examples:
 
3509
        bzr break-lock
 
3510
    """
 
3511
    takes_args = ['location?']
 
3512
 
 
3513
    def run(self, location=None, show=False):
 
3514
        if location is None:
 
3515
            location = u'.'
 
3516
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
3517
        try:
 
3518
            control.break_lock()
 
3519
        except NotImplementedError:
 
3520
            pass
 
3521
        
 
3522
 
 
3523
class cmd_wait_until_signalled(Command):
 
3524
    """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
3525
 
 
3526
    This just prints a line to signal when it is ready, then blocks on stdin.
 
3527
    """
 
3528
 
 
3529
    hidden = True
 
3530
 
 
3531
    def run(self):
 
3532
        sys.stdout.write("running\n")
 
3533
        sys.stdout.flush()
 
3534
        sys.stdin.readline()
 
3535
 
 
3536
 
 
3537
class cmd_serve(Command):
 
3538
    """Run the bzr server."""
 
3539
 
 
3540
    aliases = ['server']
 
3541
 
 
3542
    takes_options = [
 
3543
        Option('inet',
 
3544
               help='Serve on stdin/out for use from inetd or sshd.'),
 
3545
        Option('port',
 
3546
               help='Listen for connections on nominated port of the form '
 
3547
                    '[hostname:]portnumber.  Passing 0 as the port number will '
 
3548
                    'result in a dynamically allocated port.  The default port is '
 
3549
                    '4155.',
 
3550
               type=str),
 
3551
        Option('directory',
 
3552
               help='Serve contents of this directory.',
 
3553
               type=unicode),
 
3554
        Option('allow-writes',
 
3555
               help='By default the server is a readonly server.  Supplying '
 
3556
                    '--allow-writes enables write access to the contents of '
 
3557
                    'the served directory and below.'
 
3558
                ),
 
3559
        ]
 
3560
 
 
3561
    def run(self, port=None, inet=False, directory=None, allow_writes=False):
 
3562
        from bzrlib.smart import medium, server
 
3563
        from bzrlib.transport import get_transport
 
3564
        from bzrlib.transport.chroot import ChrootServer
 
3565
        from bzrlib.transport.remote import BZR_DEFAULT_PORT, BZR_DEFAULT_INTERFACE
 
3566
        if directory is None:
 
3567
            directory = os.getcwd()
 
3568
        url = urlutils.local_path_to_url(directory)
 
3569
        if not allow_writes:
 
3570
            url = 'readonly+' + url
 
3571
        chroot_server = ChrootServer(get_transport(url))
 
3572
        chroot_server.setUp()
 
3573
        t = get_transport(chroot_server.get_url())
 
3574
        if inet:
 
3575
            smart_server = medium.SmartServerPipeStreamMedium(
 
3576
                sys.stdin, sys.stdout, t)
 
3577
        else:
 
3578
            host = BZR_DEFAULT_INTERFACE
 
3579
            if port is None:
 
3580
                port = BZR_DEFAULT_PORT
 
3581
            else:
 
3582
                if ':' in port:
 
3583
                    host, port = port.split(':')
 
3584
                port = int(port)
 
3585
            smart_server = server.SmartTCPServer(t, host=host, port=port)
 
3586
            print 'listening on port: ', smart_server.port
 
3587
            sys.stdout.flush()
 
3588
        # for the duration of this server, no UI output is permitted.
 
3589
        # note that this may cause problems with blackbox tests. This should
 
3590
        # be changed with care though, as we dont want to use bandwidth sending
 
3591
        # progress over stderr to smart server clients!
 
3592
        old_factory = ui.ui_factory
 
3593
        try:
 
3594
            ui.ui_factory = ui.SilentUIFactory()
 
3595
            smart_server.serve()
 
3596
        finally:
 
3597
            ui.ui_factory = old_factory
 
3598
 
 
3599
 
 
3600
class cmd_join(Command):
 
3601
    """Combine a subtree into its containing tree.
 
3602
    
 
3603
    This command is for experimental use only.  It requires the target tree
 
3604
    to be in dirstate-with-subtree format, which cannot be converted into
 
3605
    earlier formats.
 
3606
 
 
3607
    The TREE argument should be an independent tree, inside another tree, but
 
3608
    not part of it.  (Such trees can be produced by "bzr split", but also by
 
3609
    running "bzr branch" with the target inside a tree.)
 
3610
 
 
3611
    The result is a combined tree, with the subtree no longer an independant
 
3612
    part.  This is marked as a merge of the subtree into the containing tree,
 
3613
    and all history is preserved.
 
3614
 
 
3615
    If --reference is specified, the subtree retains its independence.  It can
 
3616
    be branched by itself, and can be part of multiple projects at the same
 
3617
    time.  But operations performed in the containing tree, such as commit
 
3618
    and merge, will recurse into the subtree.
 
3619
    """
 
3620
 
 
3621
    _see_also = ['split']
 
3622
    takes_args = ['tree']
 
3623
    takes_options = [
 
3624
            Option('reference', help='Join by reference.'),
 
3625
            ]
 
3626
    hidden = True
 
3627
 
 
3628
    def run(self, tree, reference=False):
 
3629
        sub_tree = WorkingTree.open(tree)
 
3630
        parent_dir = osutils.dirname(sub_tree.basedir)
 
3631
        containing_tree = WorkingTree.open_containing(parent_dir)[0]
 
3632
        repo = containing_tree.branch.repository
 
3633
        if not repo.supports_rich_root():
 
3634
            raise errors.BzrCommandError(
 
3635
                "Can't join trees because %s doesn't support rich root data.\n"
 
3636
                "You can use bzr upgrade on the repository."
 
3637
                % (repo,))
 
3638
        if reference:
 
3639
            try:
 
3640
                containing_tree.add_reference(sub_tree)
 
3641
            except errors.BadReferenceTarget, e:
 
3642
                # XXX: Would be better to just raise a nicely printable
 
3643
                # exception from the real origin.  Also below.  mbp 20070306
 
3644
                raise errors.BzrCommandError("Cannot join %s.  %s" %
 
3645
                                             (tree, e.reason))
 
3646
        else:
 
3647
            try:
 
3648
                containing_tree.subsume(sub_tree)
 
3649
            except errors.BadSubsumeSource, e:
 
3650
                raise errors.BzrCommandError("Cannot join %s.  %s" % 
 
3651
                                             (tree, e.reason))
 
3652
 
 
3653
 
 
3654
class cmd_split(Command):
 
3655
    """Split a tree into two trees.
 
3656
 
 
3657
    This command is for experimental use only.  It requires the target tree
 
3658
    to be in dirstate-with-subtree format, which cannot be converted into
 
3659
    earlier formats.
 
3660
 
 
3661
    The TREE argument should be a subdirectory of a working tree.  That
 
3662
    subdirectory will be converted into an independent tree, with its own
 
3663
    branch.  Commits in the top-level tree will not apply to the new subtree.
 
3664
    If you want that behavior, do "bzr join --reference TREE".
 
3665
    """
 
3666
 
 
3667
    _see_also = ['join']
 
3668
    takes_args = ['tree']
 
3669
 
 
3670
    hidden = True
 
3671
 
 
3672
    def run(self, tree):
 
3673
        containing_tree, subdir = WorkingTree.open_containing(tree)
 
3674
        sub_id = containing_tree.path2id(subdir)
 
3675
        if sub_id is None:
 
3676
            raise errors.NotVersionedError(subdir)
 
3677
        try:
 
3678
            containing_tree.extract(sub_id)
 
3679
        except errors.RootNotRich:
 
3680
            raise errors.UpgradeRequired(containing_tree.branch.base)
 
3681
 
 
3682
 
 
3683
 
 
3684
class cmd_merge_directive(Command):
 
3685
    """Generate a merge directive for auto-merge tools.
 
3686
 
 
3687
    A directive requests a merge to be performed, and also provides all the
 
3688
    information necessary to do so.  This means it must either include a
 
3689
    revision bundle, or the location of a branch containing the desired
 
3690
    revision.
 
3691
 
 
3692
    A submit branch (the location to merge into) must be supplied the first
 
3693
    time the command is issued.  After it has been supplied once, it will
 
3694
    be remembered as the default.
 
3695
 
 
3696
    A public branch is optional if a revision bundle is supplied, but required
 
3697
    if --diff or --plain is specified.  It will be remembered as the default
 
3698
    after the first use.
 
3699
    """
 
3700
 
 
3701
    takes_args = ['submit_branch?', 'public_branch?']
 
3702
 
 
3703
    hidden = True
 
3704
 
 
3705
    _see_also = ['send']
 
3706
 
 
3707
    takes_options = [
 
3708
        RegistryOption.from_kwargs('patch-type',
 
3709
            'The type of patch to include in the directive.',
 
3710
            title='Patch type',
 
3711
            value_switches=True,
 
3712
            enum_switch=False,
 
3713
            bundle='Bazaar revision bundle (default).',
 
3714
            diff='Normal unified diff.',
 
3715
            plain='No patch, just directive.'),
 
3716
        Option('sign', help='GPG-sign the directive.'), 'revision',
 
3717
        Option('mail-to', type=str,
 
3718
            help='Instead of printing the directive, email to this address.'),
 
3719
        Option('message', type=str, short_name='m',
 
3720
            help='Message to use when committing this merge.')
 
3721
        ]
 
3722
 
 
3723
    encoding_type = 'exact'
 
3724
 
 
3725
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
 
3726
            sign=False, revision=None, mail_to=None, message=None):
 
3727
        from bzrlib.revision import ensure_null, NULL_REVISION
 
3728
        include_patch, include_bundle = {
 
3729
            'plain': (False, False),
 
3730
            'diff': (True, False),
 
3731
            'bundle': (True, True),
 
3732
            }[patch_type]
 
3733
        branch = Branch.open('.')
 
3734
        stored_submit_branch = branch.get_submit_branch()
 
3735
        if submit_branch is None:
 
3736
            submit_branch = stored_submit_branch
 
3737
        else:
 
3738
            if stored_submit_branch is None:
 
3739
                branch.set_submit_branch(submit_branch)
 
3740
        if submit_branch is None:
 
3741
            submit_branch = branch.get_parent()
 
3742
        if submit_branch is None:
 
3743
            raise errors.BzrCommandError('No submit branch specified or known')
 
3744
 
 
3745
        stored_public_branch = branch.get_public_branch()
 
3746
        if public_branch is None:
 
3747
            public_branch = stored_public_branch
 
3748
        elif stored_public_branch is None:
 
3749
            branch.set_public_branch(public_branch)
 
3750
        if not include_bundle and public_branch is None:
 
3751
            raise errors.BzrCommandError('No public branch specified or'
 
3752
                                         ' known')
 
3753
        base_revision_id = None
 
3754
        if revision is not None:
 
3755
            if len(revision) > 2:
 
3756
                raise errors.BzrCommandError('bzr merge-directive takes '
 
3757
                    'at most two one revision identifiers')
 
3758
            revision_id = revision[-1].in_history(branch).rev_id
 
3759
            if len(revision) == 2:
 
3760
                base_revision_id = revision[0].in_history(branch).rev_id
 
3761
                base_revision_id = ensure_null(base_revision_id)
 
3762
        else:
 
3763
            revision_id = branch.last_revision()
 
3764
        revision_id = ensure_null(revision_id)
 
3765
        if revision_id == NULL_REVISION:
 
3766
            raise errors.BzrCommandError('No revisions to bundle.')
 
3767
        directive = merge_directive.MergeDirective2.from_objects(
 
3768
            branch.repository, revision_id, time.time(),
 
3769
            osutils.local_time_offset(), submit_branch,
 
3770
            public_branch=public_branch, include_patch=include_patch,
 
3771
            include_bundle=include_bundle, message=message,
 
3772
            base_revision_id=base_revision_id)
 
3773
        if mail_to is None:
 
3774
            if sign:
 
3775
                self.outf.write(directive.to_signed(branch))
 
3776
            else:
 
3777
                self.outf.writelines(directive.to_lines())
 
3778
        else:
 
3779
            message = directive.to_email(mail_to, branch, sign)
 
3780
            s = SMTPConnection(branch.get_config())
 
3781
            s.send_email(message)
 
3782
 
 
3783
 
 
3784
class cmd_send(Command):
 
3785
    """Mail or create a merge-directive for submiting changes.
 
3786
 
 
3787
    A merge directive provides many things needed for requesting merges:
 
3788
 
 
3789
    * A machine-readable description of the merge to perform
 
3790
 
 
3791
    * An optional patch that is a preview of the changes requested
 
3792
 
 
3793
    * An optional bundle of revision data, so that the changes can be applied
 
3794
      directly from the merge directive, without retrieving data from a
 
3795
      branch.
 
3796
 
 
3797
    If --no-bundle is specified, then public_branch is needed (and must be
 
3798
    up-to-date), so that the receiver can perform the merge using the
 
3799
    public_branch.  The public_branch is always included if known, so that
 
3800
    people can check it later.
 
3801
 
 
3802
    The submit branch defaults to the parent, but can be overridden.  Both
 
3803
    submit branch and public branch will be remembered if supplied.
 
3804
 
 
3805
    If a public_branch is known for the submit_branch, that public submit
 
3806
    branch is used in the merge instructions.  This means that a local mirror
 
3807
    can be used as your actual submit branch, once you have set public_branch
 
3808
    for that mirror.
 
3809
 
 
3810
    Mail is sent using your preferred mail program.  This should be transparent
 
3811
    on Windows (it uses MAPI).  On *nix, it requires the xdg-email utility.  If
 
3812
    the preferred client can't be found (or used), your editor will be used.
 
3813
    
 
3814
    To use a specific mail program, set the mail_client configuration option.
 
3815
    (For Thunderbird 1.5, this works around some bugs.)  Supported values are
 
3816
    "thunderbird", "evolution", "editor", "xdg-email", "mapi", "kmail" and
 
3817
    "default".
 
3818
 
 
3819
    If mail is being sent, a to address is required.  This can be supplied
 
3820
    either on the commandline, or by setting the submit_to configuration
 
3821
    option.
 
3822
 
 
3823
    Two formats are currently supported: "4" uses revision bundle format 4 and
 
3824
    merge directive format 2.  It is significantly faster and smaller than
 
3825
    older formats.  It is compatible with Bazaar 0.19 and later.  It is the
 
3826
    default.  "0.9" uses revision bundle format 0.9 and merge directive
 
3827
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
 
3828
    """
 
3829
 
 
3830
    encoding_type = 'exact'
 
3831
 
 
3832
    _see_also = ['merge', 'doc/configuration.txt']
 
3833
 
 
3834
    takes_args = ['submit_branch?', 'public_branch?']
 
3835
 
 
3836
    takes_options = [
 
3837
        Option('no-bundle',
 
3838
               help='Do not include a bundle in the merge directive.'),
 
3839
        Option('no-patch', help='Do not include a preview patch in the merge'
 
3840
               ' directive.'),
 
3841
        Option('remember',
 
3842
               help='Remember submit and public branch.'),
 
3843
        Option('from',
 
3844
               help='Branch to generate the submission from, '
 
3845
               'rather than the one containing the working directory.',
 
3846
               short_name='f',
 
3847
               type=unicode),
 
3848
        Option('output', short_name='o', help='Write directive to this file.',
 
3849
               type=unicode),
 
3850
        Option('mail-to', help='Mail the request to this address.',
 
3851
               type=unicode),
 
3852
        'revision',
 
3853
        'message',
 
3854
        RegistryOption.from_kwargs('format',
 
3855
        'Use the specified output format.',
 
3856
        **{'4': 'Bundle format 4, Merge Directive 2 (default)',
 
3857
           '0.9': 'Bundle format 0.9, Merge Directive 1',})
 
3858
        ]
 
3859
 
 
3860
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
 
3861
            no_patch=False, revision=None, remember=False, output=None,
 
3862
            format='4', mail_to=None, message=None, **kwargs):
 
3863
        return self._run(submit_branch, revision, public_branch, remember,
 
3864
                         format, no_bundle, no_patch, output,
 
3865
                         kwargs.get('from', '.'), mail_to, message)
 
3866
 
 
3867
    def _run(self, submit_branch, revision, public_branch, remember, format,
 
3868
             no_bundle, no_patch, output, from_, mail_to, message):
 
3869
        from bzrlib.revision import ensure_null, NULL_REVISION
 
3870
        if output is None:
 
3871
            outfile = StringIO()
 
3872
        elif output == '-':
 
3873
            outfile = self.outf
 
3874
        else:
 
3875
            outfile = open(output, 'wb')
 
3876
        try:
 
3877
            branch = Branch.open_containing(from_)[0]
 
3878
            if output is None:
 
3879
                config = branch.get_config()
 
3880
                if mail_to is None:
 
3881
                    mail_to = config.get_user_option('submit_to')
 
3882
                if mail_to is None:
 
3883
                    raise errors.BzrCommandError('No mail-to address'
 
3884
                                                 ' specified')
 
3885
                mail_client = config.get_mail_client()
 
3886
            if remember and submit_branch is None:
 
3887
                raise errors.BzrCommandError(
 
3888
                    '--remember requires a branch to be specified.')
 
3889
            stored_submit_branch = branch.get_submit_branch()
 
3890
            remembered_submit_branch = False
 
3891
            if submit_branch is None:
 
3892
                submit_branch = stored_submit_branch
 
3893
                remembered_submit_branch = True
 
3894
            else:
 
3895
                if stored_submit_branch is None or remember:
 
3896
                    branch.set_submit_branch(submit_branch)
 
3897
            if submit_branch is None:
 
3898
                submit_branch = branch.get_parent()
 
3899
                remembered_submit_branch = True
 
3900
            if submit_branch is None:
 
3901
                raise errors.BzrCommandError('No submit branch known or'
 
3902
                                             ' specified')
 
3903
            if remembered_submit_branch:
 
3904
                note('Using saved location: %s', submit_branch)
 
3905
 
 
3906
            stored_public_branch = branch.get_public_branch()
 
3907
            if public_branch is None:
 
3908
                public_branch = stored_public_branch
 
3909
            elif stored_public_branch is None or remember:
 
3910
                branch.set_public_branch(public_branch)
 
3911
            if no_bundle and public_branch is None:
 
3912
                raise errors.BzrCommandError('No public branch specified or'
 
3913
                                             ' known')
 
3914
            base_revision_id = None
 
3915
            revision_id = None
 
3916
            if revision is not None:
 
3917
                if len(revision) > 2:
 
3918
                    raise errors.BzrCommandError('bzr send takes '
 
3919
                        'at most two one revision identifiers')
 
3920
                revision_id = revision[-1].in_history(branch).rev_id
 
3921
                if len(revision) == 2:
 
3922
                    base_revision_id = revision[0].in_history(branch).rev_id
 
3923
            if revision_id is None:
 
3924
                revision_id = branch.last_revision()
 
3925
            if revision_id == NULL_REVISION:
 
3926
                raise errors.BzrCommandError('No revisions to submit.')
 
3927
            if format == '4':
 
3928
                directive = merge_directive.MergeDirective2.from_objects(
 
3929
                    branch.repository, revision_id, time.time(),
 
3930
                    osutils.local_time_offset(), submit_branch,
 
3931
                    public_branch=public_branch, include_patch=not no_patch,
 
3932
                    include_bundle=not no_bundle, message=message,
 
3933
                    base_revision_id=base_revision_id)
 
3934
            elif format == '0.9':
 
3935
                if not no_bundle:
 
3936
                    if not no_patch:
 
3937
                        patch_type = 'bundle'
 
3938
                    else:
 
3939
                        raise errors.BzrCommandError('Format 0.9 does not'
 
3940
                            ' permit bundle with no patch')
 
3941
                else:
 
3942
                    if not no_patch:
 
3943
                        patch_type = 'diff'
 
3944
                    else:
 
3945
                        patch_type = None
 
3946
                directive = merge_directive.MergeDirective.from_objects(
 
3947
                    branch.repository, revision_id, time.time(),
 
3948
                    osutils.local_time_offset(), submit_branch,
 
3949
                    public_branch=public_branch, patch_type=patch_type,
 
3950
                    message=message)
 
3951
 
 
3952
            outfile.writelines(directive.to_lines())
 
3953
            if output is None:
 
3954
                subject = '[MERGE] '
 
3955
                if message is not None:
 
3956
                    subject += message
 
3957
                else:
 
3958
                    revision = branch.repository.get_revision(revision_id)
 
3959
                    subject += revision.get_summary()
 
3960
                mail_client.compose_merge_request(mail_to, subject,
 
3961
                                                  outfile.getvalue())
 
3962
        finally:
 
3963
            if output != '-':
 
3964
                outfile.close()
 
3965
 
 
3966
 
 
3967
class cmd_bundle_revisions(cmd_send):
 
3968
 
 
3969
    """Create a merge-directive for submiting changes.
 
3970
 
 
3971
    A merge directive provides many things needed for requesting merges:
 
3972
 
 
3973
    * A machine-readable description of the merge to perform
 
3974
 
 
3975
    * An optional patch that is a preview of the changes requested
 
3976
 
 
3977
    * An optional bundle of revision data, so that the changes can be applied
 
3978
      directly from the merge directive, without retrieving data from a
 
3979
      branch.
 
3980
 
 
3981
    If --no-bundle is specified, then public_branch is needed (and must be
 
3982
    up-to-date), so that the receiver can perform the merge using the
 
3983
    public_branch.  The public_branch is always included if known, so that
 
3984
    people can check it later.
 
3985
 
 
3986
    The submit branch defaults to the parent, but can be overridden.  Both
 
3987
    submit branch and public branch will be remembered if supplied.
 
3988
 
 
3989
    If a public_branch is known for the submit_branch, that public submit
 
3990
    branch is used in the merge instructions.  This means that a local mirror
 
3991
    can be used as your actual submit branch, once you have set public_branch
 
3992
    for that mirror.
 
3993
 
 
3994
    Two formats are currently supported: "4" uses revision bundle format 4 and
 
3995
    merge directive format 2.  It is significantly faster and smaller than
 
3996
    older formats.  It is compatible with Bazaar 0.19 and later.  It is the
 
3997
    default.  "0.9" uses revision bundle format 0.9 and merge directive
 
3998
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
 
3999
    """
 
4000
 
 
4001
    takes_options = [
 
4002
        Option('no-bundle',
 
4003
               help='Do not include a bundle in the merge directive.'),
 
4004
        Option('no-patch', help='Do not include a preview patch in the merge'
 
4005
               ' directive.'),
 
4006
        Option('remember',
 
4007
               help='Remember submit and public branch.'),
 
4008
        Option('from',
 
4009
               help='Branch to generate the submission from, '
 
4010
               'rather than the one containing the working directory.',
 
4011
               short_name='f',
 
4012
               type=unicode),
 
4013
        Option('output', short_name='o', help='Write directive to this file.',
 
4014
               type=unicode),
 
4015
        'revision',
 
4016
        RegistryOption.from_kwargs('format',
 
4017
        'Use the specified output format.',
 
4018
        **{'4': 'Bundle format 4, Merge Directive 2 (default)',
 
4019
           '0.9': 'Bundle format 0.9, Merge Directive 1',})
 
4020
        ]
 
4021
    aliases = ['bundle']
 
4022
 
 
4023
    _see_also = ['send', 'merge']
 
4024
 
 
4025
    hidden = True
 
4026
 
 
4027
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
 
4028
            no_patch=False, revision=None, remember=False, output=None,
 
4029
            format='4', **kwargs):
 
4030
        if output is None:
 
4031
            output = '-'
 
4032
        return self._run(submit_branch, revision, public_branch, remember,
 
4033
                         format, no_bundle, no_patch, output,
 
4034
                         kwargs.get('from', '.'), None, None)
 
4035
 
 
4036
 
 
4037
class cmd_tag(Command):
 
4038
    """Create, remove or modify a tag naming a revision.
 
4039
    
 
4040
    Tags give human-meaningful names to revisions.  Commands that take a -r
 
4041
    (--revision) option can be given -rtag:X, where X is any previously
 
4042
    created tag.
 
4043
 
 
4044
    Tags are stored in the branch.  Tags are copied from one branch to another
 
4045
    along when you branch, push, pull or merge.
 
4046
 
 
4047
    It is an error to give a tag name that already exists unless you pass 
 
4048
    --force, in which case the tag is moved to point to the new revision.
 
4049
    """
 
4050
 
 
4051
    _see_also = ['commit', 'tags']
 
4052
    takes_args = ['tag_name']
 
4053
    takes_options = [
 
4054
        Option('delete',
 
4055
            help='Delete this tag rather than placing it.',
 
4056
            ),
 
4057
        Option('directory',
 
4058
            help='Branch in which to place the tag.',
 
4059
            short_name='d',
 
4060
            type=unicode,
 
4061
            ),
 
4062
        Option('force',
 
4063
            help='Replace existing tags.',
 
4064
            ),
 
4065
        'revision',
 
4066
        ]
 
4067
 
 
4068
    def run(self, tag_name,
 
4069
            delete=None,
 
4070
            directory='.',
 
4071
            force=None,
 
4072
            revision=None,
 
4073
            ):
 
4074
        branch, relpath = Branch.open_containing(directory)
 
4075
        branch.lock_write()
 
4076
        try:
 
4077
            if delete:
 
4078
                branch.tags.delete_tag(tag_name)
 
4079
                self.outf.write('Deleted tag %s.\n' % tag_name)
 
4080
            else:
 
4081
                if revision:
 
4082
                    if len(revision) != 1:
 
4083
                        raise errors.BzrCommandError(
 
4084
                            "Tags can only be placed on a single revision, "
 
4085
                            "not on a range")
 
4086
                    revision_id = revision[0].in_history(branch).rev_id
 
4087
                else:
 
4088
                    revision_id = branch.last_revision()
 
4089
                if (not force) and branch.tags.has_tag(tag_name):
 
4090
                    raise errors.TagAlreadyExists(tag_name)
 
4091
                branch.tags.set_tag(tag_name, revision_id)
 
4092
                self.outf.write('Created tag %s.\n' % tag_name)
 
4093
        finally:
 
4094
            branch.unlock()
 
4095
 
 
4096
 
 
4097
class cmd_tags(Command):
 
4098
    """List tags.
 
4099
 
 
4100
    This tag shows a table of tag names and the revisions they reference.
 
4101
    """
 
4102
 
 
4103
    _see_also = ['tag']
 
4104
    takes_options = [
 
4105
        Option('directory',
 
4106
            help='Branch whose tags should be displayed.',
 
4107
            short_name='d',
 
4108
            type=unicode,
 
4109
            ),
 
4110
    ]
 
4111
 
 
4112
    @display_command
 
4113
    def run(self,
 
4114
            directory='.',
 
4115
            ):
 
4116
        branch, relpath = Branch.open_containing(directory)
 
4117
        for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
 
4118
            self.outf.write('%-20s %s\n' % (tag_name, target))
 
4119
 
 
4120
 
 
4121
def _create_prefix(cur_transport):
 
4122
    needed = [cur_transport]
 
4123
    # Recurse upwards until we can create a directory successfully
 
4124
    while True:
 
4125
        new_transport = cur_transport.clone('..')
 
4126
        if new_transport.base == cur_transport.base:
 
4127
            raise errors.BzrCommandError(
 
4128
                "Failed to create path prefix for %s."
 
4129
                % cur_transport.base)
 
4130
        try:
 
4131
            new_transport.mkdir('.')
 
4132
        except errors.NoSuchFile:
 
4133
            needed.append(new_transport)
 
4134
            cur_transport = new_transport
 
4135
        else:
 
4136
            break
 
4137
    # Now we only need to create child directories
 
4138
    while needed:
 
4139
        cur_transport = needed.pop()
 
4140
        cur_transport.ensure_base()
 
4141
 
 
4142
 
 
4143
def _get_mergeable_helper(location):
 
4144
    """Get a merge directive or bundle if 'location' points to one.
 
4145
 
 
4146
    Try try to identify a bundle and returns its mergeable form. If it's not,
 
4147
    we return the tried transport anyway so that it can reused to access the
 
4148
    branch
 
4149
 
 
4150
    :param location: can point to a bundle or a branch.
 
4151
 
 
4152
    :return: mergeable, transport
 
4153
    """
 
4154
    mergeable = None
 
4155
    url = urlutils.normalize_url(location)
 
4156
    url, filename = urlutils.split(url, exclude_trailing_slash=False)
 
4157
    location_transport = transport.get_transport(url)
 
4158
    if filename:
 
4159
        try:
 
4160
            # There may be redirections but we ignore the intermediate
 
4161
            # and final transports used
 
4162
            read = bundle.read_mergeable_from_transport
 
4163
            mergeable, t = read(location_transport, filename)
 
4164
        except errors.NotABundle:
 
4165
            # Continue on considering this url a Branch but adjust the
 
4166
            # location_transport
 
4167
            location_transport = location_transport.clone(filename)
 
4168
    return mergeable, location_transport
1524
4169
 
1525
4170
 
1526
4171
# these get imported and then picked up by the scan for cmd_*
1527
4172
# TODO: Some more consistent way to split command definitions across files;
1528
4173
# we do need to load at least some information about them to know of 
1529
 
# aliases.
1530
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
 
4174
# aliases.  ideally we would avoid loading the implementation until the
 
4175
# details were needed.
 
4176
from bzrlib.cmd_version_info import cmd_version_info
 
4177
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
 
4178
from bzrlib.bundle.commands import (
 
4179
    cmd_bundle_info,
 
4180
    )
 
4181
from bzrlib.sign_my_commits import cmd_sign_my_commits
 
4182
from bzrlib.weave_commands import cmd_versionedfile_list, cmd_weave_join, \
 
4183
        cmd_weave_plan_merge, cmd_weave_merge_text