/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

merge shallow->stacked tweaks

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