/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Vincent Ladeuil
  • Date: 2007-06-20 14:25:06 UTC
  • mfrom: (2540 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070620142506-txsb1v8538kpsafw
merge bzr.dev @ 2540

Show diffs side-by-side

added added

removed removed

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