/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Ian Clatworthy
  • Date: 2007-09-10 08:19:29 UTC
  • mto: (2818.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2819.
  • Revision ID: ian.clatworthy@internode.on.net-20070910081929-9419oqg1zhva4e7d
put back KeyboardInterrupt trapping as needed for Python 2.5

Show diffs side-by-side

added added

removed removed

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