← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Robert Collins
  • Date: 2007-03-05 03:10:21 UTC
  • mto: (2255.11.4 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: robertc@robertcollins.net-20070305031021-ypbakvagbivyw5mu
Teach delta.report_changes about unversioned files, removing all inventory access during status --short.

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