← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

- refactor handling of short option names

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
1
 
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
 
#
 
1
# Copyright (C) 2004, 2005 by Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
"""builtin bzr commands"""
18
 
 
19
 
 
20
 
import codecs
21
 
import errno
 
17
 
 
18
import sys
22
19
import os
23
 
import os.path
24
 
import sys
25
20
 
26
21
import bzrlib
27
 
from bzrlib import (
28
 
    branch,
29
 
    bundle,
30
 
    bzrdir,
31
 
    config,
32
 
    errors,
33
 
    ignores,
34
 
    log,
35
 
    osutils,
36
 
    repository,
37
 
    transport,
38
 
    ui,
39
 
    urlutils,
40
 
    )
41
 
from bzrlib.branch import Branch, BranchReferenceFormat
42
 
from bzrlib.bundle import read_bundle_from_url
43
 
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
 
from bzrlib.conflicts import ConflictList
45
 
from bzrlib.commands import Command, display_command
46
 
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 
47
 
                           NotBranchError, DivergedBranches, NotConflicted,
48
 
                           NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
 
                           NotVersionedError, NotABundle)
50
 
from bzrlib.merge import Merge3Merger
 
22
import bzrlib.trace
 
23
from bzrlib.trace import mutter, note, log_error, warning
 
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
 
25
from bzrlib.errors import DivergedBranches
 
26
from bzrlib.branch import Branch
 
27
from bzrlib import BZRDIR
 
28
from bzrlib.commands import Command
51
29
from bzrlib.option import Option
52
 
from bzrlib.progress import DummyProgress, ProgressPhase
53
 
from bzrlib.revision import common_ancestor
54
 
from bzrlib.revisionspec import RevisionSpec
55
 
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
 
from bzrlib.transport.local import LocalTransport
57
 
from bzrlib.workingtree import WorkingTree
58
 
 
59
 
 
60
 
def tree_files(file_list, default_branch=u'.'):
61
 
    try:
62
 
        return internal_tree_files(file_list, default_branch)
63
 
    except FileInWrongBranch, e:
64
 
        raise BzrCommandError("%s is not in the same branch as %s" %
65
 
                             (e.path, file_list[0]))
66
 
 
67
 
 
68
 
# XXX: Bad function name; should possibly also be a class method of
69
 
# WorkingTree rather than a function.
70
 
def internal_tree_files(file_list, default_branch=u'.'):
71
 
    """Convert command-line paths to a WorkingTree and relative paths.
72
 
 
73
 
    This is typically used for command-line processors that take one or
74
 
    more filenames, and infer the workingtree that contains them.
75
 
 
76
 
    The filenames given are not required to exist.
77
 
 
78
 
    :param file_list: Filenames to convert.  
79
 
 
80
 
    :param default_branch: Fallback tree path to use if file_list is empty or None.
81
 
 
82
 
    :return: workingtree, [relative_paths]
83
 
    """
84
 
    if file_list is None or len(file_list) == 0:
85
 
        return WorkingTree.open_containing(default_branch)[0], file_list
86
 
    tree = WorkingTree.open_containing(file_list[0])[0]
87
 
    new_list = []
88
 
    for filename in file_list:
89
 
        try:
90
 
            new_list.append(tree.relpath(filename))
91
 
        except errors.PathNotChild:
92
 
            raise FileInWrongBranch(tree.branch, filename)
93
 
    return tree, new_list
94
 
 
95
 
 
96
 
def get_format_type(typestring):
97
 
    """Parse and return a format specifier."""
98
 
    if typestring == "weave":
99
 
        return bzrdir.BzrDirFormat6()
100
 
    if typestring == "default":
101
 
        return bzrdir.BzrDirMetaFormat1()
102
 
    if typestring == "metaweave":
103
 
        format = bzrdir.BzrDirMetaFormat1()
104
 
        format.repository_format = repository.RepositoryFormat7()
105
 
        return format
106
 
    if typestring == "knit":
107
 
        format = bzrdir.BzrDirMetaFormat1()
108
 
        format.repository_format = repository.RepositoryFormatKnit1()
109
 
        return format
110
 
    msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
111
 
          "metaweave and weave" % typestring
112
 
    raise BzrCommandError(msg)
113
 
 
114
 
 
115
 
# TODO: Make sure no commands unconditionally use the working directory as a
116
 
# branch.  If a filename argument is used, the first of them should be used to
117
 
# specify the branch.  (Perhaps this can be factored out into some kind of
118
 
# Argument class, representing a file in a branch, where the first occurrence
119
 
# opens the branch?)
120
30
 
121
31
class cmd_status(Command):
122
32
    """Display status summary.
139
49
    modified
140
50
        Text has changed since the previous revision.
141
51
 
 
52
    unchanged
 
53
        Nothing about this file has changed since the previous revision.
 
54
        Only shown with --all.
 
55
 
142
56
    unknown
143
57
        Not versioned and not matching an ignore pattern.
144
58
 
153
67
    If a revision argument is given, the status is calculated against
154
68
    that revision, or between two revisions if two are provided.
155
69
    """
156
 
    
157
 
    # TODO: --no-recurse, --recurse options
158
 
    
 
70
    # XXX: FIXME: bzr status should accept a -r option to show changes
 
71
    # relative to a revision, or between revisions
 
72
 
159
73
    takes_args = ['file*']
160
 
    takes_options = ['show-ids', 'revision']
 
74
    takes_options = ['all', 'show-ids']
161
75
    aliases = ['st', 'stat']
162
 
 
163
 
    encoding_type = 'replace'
164
76
    
165
 
    @display_command
166
 
    def run(self, show_ids=False, file_list=None, revision=None):
167
 
        from bzrlib.status import show_tree_status
168
 
 
169
 
        tree, file_list = tree_files(file_list)
 
77
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
 
78
        if file_list:
 
79
            b = Branch.open_containing(file_list[0])
 
80
            file_list = [b.relpath(x) for x in file_list]
 
81
            # special case: only one path was given and it's the root
 
82
            # of the branch
 
83
            if file_list == ['']:
 
84
                file_list = None
 
85
        else:
 
86
            b = Branch.open_containing('.')
170
87
            
171
 
        show_tree_status(tree, show_ids=show_ids,
172
 
                         specific_files=file_list, revision=revision,
173
 
                         to_file=self.outf)
 
88
        from bzrlib.status import show_status
 
89
        show_status(b, show_unchanged=all, show_ids=show_ids,
 
90
                    specific_files=file_list, revision=revision)
174
91
 
175
92
 
176
93
class cmd_cat_revision(Command):
183
100
    hidden = True
184
101
    takes_args = ['revision_id?']
185
102
    takes_options = ['revision']
186
 
    # cat-revision is more for frontends so should be exact
187
 
    encoding = 'strict'
188
103
    
189
 
    @display_command
190
104
    def run(self, revision_id=None, revision=None):
 
105
        from bzrlib.revisionspec import RevisionSpec
191
106
 
192
107
        if revision_id is not None and revision is not None:
193
108
            raise BzrCommandError('You can only supply one of revision_id or --revision')
194
109
        if revision_id is None and revision is None:
195
110
            raise BzrCommandError('You must supply either --revision or a revision_id')
196
 
        b = WorkingTree.open_containing(u'.')[0].branch
197
 
 
198
 
        # TODO: jam 20060112 should cat-revision always output utf-8?
 
111
        b = Branch.open_containing('.')
199
112
        if revision_id is not None:
200
 
            self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
 
113
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
201
114
        elif revision is not None:
202
115
            for rev in revision:
203
116
                if rev is None:
204
117
                    raise BzrCommandError('You cannot specify a NULL revision.')
205
118
                revno, rev_id = rev.in_history(b)
206
 
                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
 
119
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
207
120
    
208
121
 
209
122
class cmd_revno(Command):
210
123
    """Show current revision number.
211
124
 
212
 
    This is equal to the number of revisions on this branch.
213
 
    """
214
 
 
215
 
    takes_args = ['location?']
216
 
 
217
 
    @display_command
218
 
    def run(self, location=u'.'):
219
 
        self.outf.write(str(Branch.open_containing(location)[0].revno()))
220
 
        self.outf.write('\n')
 
125
    This is equal to the number of revisions on this branch."""
 
126
    def run(self):
 
127
        print Branch.open_containing('.').revno()
221
128
 
222
129
 
223
130
class cmd_revision_info(Command):
226
133
    hidden = True
227
134
    takes_args = ['revision_info*']
228
135
    takes_options = ['revision']
229
 
 
230
 
    @display_command
231
136
    def run(self, revision=None, revision_info_list=[]):
 
137
        from bzrlib.revisionspec import RevisionSpec
232
138
 
233
139
        revs = []
234
140
        if revision is not None:
239
145
        if len(revs) == 0:
240
146
            raise BzrCommandError('You must supply a revision identifier')
241
147
 
242
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
148
        b = Branch.open_containing('.')
243
149
 
244
150
        for rev in revs:
245
151
            revinfo = rev.in_history(b)
269
175
 
270
176
    Adding a file whose parent directory is not versioned will
271
177
    implicitly add the parent, and so on up to the root. This means
272
 
    you should never need to explicitly add a directory, they'll just
 
178
    you should never need to explictly add a directory, they'll just
273
179
    get added when you add a file in the directory.
274
 
 
275
 
    --dry-run will show which files would be added, but not actually 
276
 
    add them.
277
180
    """
278
181
    takes_args = ['file*']
279
 
    takes_options = ['no-recurse', 'dry-run', 'verbose']
280
 
    encoding_type = 'replace'
281
 
 
282
 
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
283
 
        import bzrlib.add
284
 
 
285
 
        action = bzrlib.add.AddAction(to_file=self.outf,
286
 
            should_print=(not is_quiet()))
287
 
 
288
 
        added, ignored = bzrlib.add.smart_add(file_list, not no_recurse, 
289
 
                                              action=action, save=not dry_run)
290
 
        if len(ignored) > 0:
291
 
            if verbose:
292
 
                for glob in sorted(ignored.keys()):
293
 
                    for path in ignored[glob]:
294
 
                        self.outf.write("ignored %s matching \"%s\"\n" 
295
 
                                        % (path, glob))
296
 
            else:
297
 
                match_len = 0
298
 
                for glob, paths in ignored.items():
299
 
                    match_len += len(paths)
300
 
                self.outf.write("ignored %d file(s).\n" % match_len)
301
 
            self.outf.write("If you wish to add some of these files,"
302
 
                            " please add them by name.\n")
 
182
    takes_options = ['no-recurse', 'quiet']
 
183
    
 
184
    def run(self, file_list, no_recurse=False, quiet=False):
 
185
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
 
186
        if quiet:
 
187
            reporter = add_reporter_null
 
188
        else:
 
189
            reporter = add_reporter_print
 
190
        smart_add(file_list, not no_recurse, reporter)
303
191
 
304
192
 
305
193
class cmd_mkdir(Command):
307
195
 
308
196
    This is equivalent to creating the directory and then adding it.
309
197
    """
310
 
 
311
198
    takes_args = ['dir+']
312
 
    encoding_type = 'replace'
313
199
 
314
200
    def run(self, dir_list):
 
201
        b = None
 
202
        
315
203
        for d in dir_list:
316
204
            os.mkdir(d)
317
 
            wt, dd = WorkingTree.open_containing(d)
318
 
            wt.add([dd])
319
 
            self.outf.write('added %s\n' % d)
 
205
            if not b:
 
206
                b = Branch.open_containing(d)
 
207
            b.add([d])
 
208
            print 'added', d
320
209
 
321
210
 
322
211
class cmd_relpath(Command):
323
212
    """Show path of a file relative to root"""
324
 
 
325
213
    takes_args = ['filename']
326
214
    hidden = True
327
215
    
328
 
    @display_command
329
216
    def run(self, filename):
330
 
        # TODO: jam 20050106 Can relpath return a munged path if
331
 
        #       sys.stdout encoding cannot represent it?
332
 
        tree, relpath = WorkingTree.open_containing(filename)
333
 
        self.outf.write(relpath)
334
 
        self.outf.write('\n')
 
217
        print Branch.open_containing(filename).relpath(filename)
 
218
 
335
219
 
336
220
 
337
221
class cmd_inventory(Command):
338
 
    """Show inventory of the current working copy or a revision.
339
 
 
340
 
    It is possible to limit the output to a particular entry
341
 
    type using the --kind option.  For example; --kind file.
342
 
    """
343
 
 
344
 
    takes_options = ['revision', 'show-ids', 'kind']
 
222
    """Show inventory of the current working copy or a revision."""
 
223
    takes_options = ['revision', 'show-ids']
345
224
    
346
 
    @display_command
347
 
    def run(self, revision=None, show_ids=False, kind=None):
348
 
        if kind and kind not in ['file', 'directory', 'symlink']:
349
 
            raise BzrCommandError('invalid kind specified')
350
 
        tree = WorkingTree.open_containing(u'.')[0]
 
225
    def run(self, revision=None, show_ids=False):
 
226
        b = Branch.open_containing('.')
351
227
        if revision is None:
352
 
            inv = tree.read_working_inventory()
 
228
            inv = b.read_working_inventory()
353
229
        else:
354
230
            if len(revision) > 1:
355
231
                raise BzrCommandError('bzr inventory --revision takes'
356
232
                    ' exactly one revision identifier')
357
 
            inv = tree.branch.repository.get_revision_inventory(
358
 
                revision[0].in_history(tree.branch).rev_id)
 
233
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
359
234
 
360
235
        for path, entry in inv.entries():
361
 
            if kind and kind != entry.kind:
362
 
                continue
363
236
            if show_ids:
364
 
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
 
237
                print '%-50s %s' % (path, entry.file_id)
365
238
            else:
366
 
                self.outf.write(path)
367
 
                self.outf.write('\n')
 
239
                print path
 
240
 
 
241
 
 
242
class cmd_move(Command):
 
243
    """Move files to a different directory.
 
244
 
 
245
    examples:
 
246
        bzr move *.txt doc
 
247
 
 
248
    The destination must be a versioned directory in the same branch.
 
249
    """
 
250
    takes_args = ['source$', 'dest']
 
251
    def run(self, source_list, dest):
 
252
        b = Branch.open_containing('.')
 
253
 
 
254
        # TODO: glob expansion on windows?
 
255
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
 
256
 
 
257
 
 
258
class cmd_rename(Command):
 
259
    """Change the name of an entry.
 
260
 
 
261
    examples:
 
262
      bzr rename frob.c frobber.c
 
263
      bzr rename src/frob.c lib/frob.c
 
264
 
 
265
    It is an error if the destination name exists.
 
266
 
 
267
    See also the 'move' command, which moves files into a different
 
268
    directory without changing their name.
 
269
    """
 
270
    # TODO: Some way to rename multiple files without invoking 
 
271
    # bzr for each one?"""
 
272
    takes_args = ['from_name', 'to_name']
 
273
    
 
274
    def run(self, from_name, to_name):
 
275
        b = Branch.open_containing('.')
 
276
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
 
277
 
368
278
 
369
279
 
370
280
class cmd_mv(Command):
380
290
 
381
291
    Files cannot be moved between branches.
382
292
    """
383
 
 
384
293
    takes_args = ['names*']
385
 
    aliases = ['move', 'rename']
386
 
    encoding_type = 'replace'
387
 
 
388
294
    def run(self, names_list):
389
 
        if names_list is None:
390
 
            names_list = []
391
 
 
392
295
        if len(names_list) < 2:
393
296
            raise BzrCommandError("missing file argument")
394
 
        tree, rel_names = tree_files(names_list)
 
297
        b = Branch.open_containing(names_list[0])
 
298
 
 
299
        rel_names = [b.relpath(x) for x in names_list]
395
300
        
396
301
        if os.path.isdir(names_list[-1]):
397
302
            # move into existing directory
398
 
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
399
 
                self.outf.write("%s => %s\n" % pair)
 
303
            for pair in b.move(rel_names[:-1], rel_names[-1]):
 
304
                print "%s => %s" % pair
400
305
        else:
401
306
            if len(names_list) != 2:
402
307
                raise BzrCommandError('to mv multiple files the destination '
403
308
                                      'must be a versioned directory')
404
 
            tree.rename_one(rel_names[0], rel_names[1])
405
 
            self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
 
309
            b.rename_one(rel_names[0], rel_names[1])
 
310
            print "%s => %s" % (rel_names[0], rel_names[1])
406
311
            
407
312
    
 
313
 
 
314
 
408
315
class cmd_pull(Command):
409
 
    """Turn this branch into a mirror of another branch.
 
316
    """Pull any changes from another branch into the current one.
 
317
 
 
318
    If the location is omitted, the last-used location will be used.
 
319
    Both the revision history and the working directory will be
 
320
    updated.
410
321
 
411
322
    This command only works on branches that have not diverged.  Branches are
412
 
    considered diverged if the destination branch's most recent commit is one
413
 
    that has not been merged (directly or indirectly) into the parent.
414
 
 
415
 
    If branches have diverged, you can use 'bzr merge' to integrate the changes
416
 
    from one into the other.  Once one branch has merged, the other should
417
 
    be able to pull it again.
418
 
 
419
 
    If you want to forget your local changes and just update your branch to
420
 
    match the remote one, use pull --overwrite.
421
 
 
422
 
    If there is no default location set, the first pull will set it.  After
423
 
    that, you can omit the location to use the default.  To change the
424
 
    default, use --remember. The value will only be saved if the remote
425
 
    location can be accessed.
 
323
    considered diverged if both branches have had commits without first
 
324
    pulling from the other.
 
325
 
 
326
    If branches have diverged, you can use 'bzr merge' to pull the text changes
 
327
    from one into the other.
426
328
    """
427
 
 
428
 
    takes_options = ['remember', 'overwrite', 'revision', 'verbose']
 
329
    takes_options = ['remember']
429
330
    takes_args = ['location?']
430
 
    encoding_type = 'replace'
431
 
 
432
 
    def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
433
 
        # FIXME: too much stuff is in the command class
434
 
        try:
435
 
            tree_to = WorkingTree.open_containing(u'.')[0]
436
 
            branch_to = tree_to.branch
437
 
        except NoWorkingTree:
438
 
            tree_to = None
439
 
            branch_to = Branch.open_containing(u'.')[0]
440
 
 
441
 
        reader = None
442
 
        if location is not None:
443
 
            try:
444
 
                reader = bundle.read_bundle_from_url(location)
445
 
            except NotABundle:
446
 
                pass # Continue on considering this url a Branch
447
 
 
448
 
        stored_loc = branch_to.get_parent()
 
331
 
 
332
    def run(self, location=None, remember=False):
 
333
        from bzrlib.merge import merge
 
334
        import tempfile
 
335
        from shutil import rmtree
 
336
        import errno
 
337
        
 
338
        br_to = Branch.open_containing('.')
 
339
        stored_loc = br_to.get_parent()
449
340
        if location is None:
450
341
            if stored_loc is None:
451
342
                raise BzrCommandError("No pull location known or specified.")
452
343
            else:
453
 
                display_url = urlutils.unescape_for_display(stored_loc,
454
 
                        self.outf.encoding)
455
 
                self.outf.write("Using saved location: %s\n" % display_url)
456
 
                location = stored_loc
457
 
 
458
 
 
459
 
        if reader is not None:
460
 
            install_bundle(branch_to.repository, reader)
461
 
            branch_from = branch_to
462
 
        else:
463
 
            branch_from = Branch.open(location)
464
 
 
465
 
            if branch_to.get_parent() is None or remember:
466
 
                branch_to.set_parent(branch_from.base)
467
 
 
468
 
        rev_id = None
469
 
        if revision is None:
470
 
            if reader is not None:
471
 
                rev_id = reader.target
472
 
        elif len(revision) == 1:
473
 
            rev_id = revision[0].in_history(branch_from).rev_id
474
 
        else:
475
 
            raise BzrCommandError('bzr pull --revision takes one value.')
476
 
 
477
 
        old_rh = branch_to.revision_history()
478
 
        if tree_to is not None:
479
 
            count = tree_to.pull(branch_from, overwrite, rev_id)
480
 
        else:
481
 
            count = branch_to.pull(branch_from, overwrite, rev_id)
482
 
        note('%d revision(s) pulled.' % (count,))
483
 
 
484
 
        if verbose:
485
 
            new_rh = branch_to.revision_history()
486
 
            if old_rh != new_rh:
487
 
                # Something changed
488
 
                from bzrlib.log import show_changed_revisions
489
 
                show_changed_revisions(branch_to, old_rh, new_rh,
490
 
                                       to_file=self.outf)
491
 
 
492
 
 
493
 
class cmd_push(Command):
494
 
    """Update a mirror of this branch.
495
 
    
496
 
    The target branch will not have its working tree populated because this
497
 
    is both expensive, and is not supported on remote file systems.
498
 
    
499
 
    Some smart servers or protocols *may* put the working tree in place in
500
 
    the future.
501
 
 
502
 
    This command only works on branches that have not diverged.  Branches are
503
 
    considered diverged if the destination branch's most recent commit is one
504
 
    that has not been merged (directly or indirectly) by the source branch.
505
 
 
506
 
    If branches have diverged, you can use 'bzr push --overwrite' to replace
507
 
    the other branch completely, discarding its unmerged changes.
508
 
    
509
 
    If you want to ensure you have the different changes in the other branch,
510
 
    do a merge (see bzr help merge) from the other branch, and commit that.
511
 
    After that you will be able to do a push without '--overwrite'.
512
 
 
513
 
    If there is no default push location set, the first push will set it.
514
 
    After that, you can omit the location to use the default.  To change the
515
 
    default, use --remember. The value will only be saved if the remote
516
 
    location can be accessed.
517
 
    """
518
 
 
519
 
    takes_options = ['remember', 'overwrite', 'verbose',
520
 
                     Option('create-prefix', 
521
 
                            help='Create the path leading up to the branch '
522
 
                                 'if it does not already exist')]
523
 
    takes_args = ['location?']
524
 
    encoding_type = 'replace'
525
 
 
526
 
    def run(self, location=None, remember=False, overwrite=False,
527
 
            create_prefix=False, verbose=False):
528
 
        # FIXME: Way too big!  Put this into a function called from the
529
 
        # command.
530
 
        
531
 
        br_from = Branch.open_containing('.')[0]
532
 
        stored_loc = br_from.get_push_location()
533
 
        if location is None:
534
 
            if stored_loc is None:
535
 
                raise BzrCommandError("No push location known or specified.")
536
 
            else:
537
 
                display_url = urlutils.unescape_for_display(stored_loc,
538
 
                        self.outf.encoding)
539
 
                self.outf.write("Using saved location: %s\n" % display_url)
540
 
                location = stored_loc
541
 
 
542
 
        to_transport = transport.get_transport(location)
543
 
        location_url = to_transport.base
544
 
 
545
 
        old_rh = []
 
344
                print "Using saved location: %s" % stored_loc
 
345
                location = stored_loc
 
346
        cache_root = tempfile.mkdtemp()
 
347
        br_from = Branch.open(location)
 
348
        br_from.lock_read()
546
349
        try:
547
 
            dir_to = bzrdir.BzrDir.open(location_url)
548
 
            br_to = dir_to.open_branch()
549
 
        except NotBranchError:
550
 
            # create a branch.
551
 
            to_transport = to_transport.clone('..')
552
 
            if not create_prefix:
553
 
                try:
554
 
                    relurl = to_transport.relpath(location_url)
555
 
                    mutter('creating directory %s => %s', location_url, relurl)
556
 
                    to_transport.mkdir(relurl)
557
 
                except NoSuchFile:
558
 
                    raise BzrCommandError("Parent directory of %s "
559
 
                                          "does not exist." % location)
560
 
            else:
561
 
                current = to_transport.base
562
 
                needed = [(to_transport, to_transport.relpath(location_url))]
563
 
                while needed:
564
 
                    try:
565
 
                        to_transport, relpath = needed[-1]
566
 
                        to_transport.mkdir(relpath)
567
 
                        needed.pop()
568
 
                    except NoSuchFile:
569
 
                        new_transport = to_transport.clone('..')
570
 
                        needed.append((new_transport,
571
 
                                       new_transport.relpath(to_transport.base)))
572
 
                        if new_transport.base == to_transport.base:
573
 
                            raise BzrCommandError("Could not create "
574
 
                                                  "path prefix.")
575
 
            dir_to = br_from.bzrdir.clone(location_url,
576
 
                revision_id=br_from.last_revision())
577
 
            br_to = dir_to.open_branch()
578
 
            count = len(br_to.revision_history())
579
 
            # We successfully created the target, remember it
580
 
            if br_from.get_push_location() is None or remember:
581
 
                br_from.set_push_location(br_to.base)
582
 
        else:
583
 
            # We were able to connect to the remote location, so remember it
584
 
            # we don't need to successfully push because of possible divergence.
585
 
            if br_from.get_push_location() is None or remember:
586
 
                br_from.set_push_location(br_to.base)
587
 
            old_rh = br_to.revision_history()
 
350
            br_from.setup_caching(cache_root)
 
351
            location = br_from.base
 
352
            old_revno = br_to.revno()
 
353
            old_revision_history = br_to.revision_history()
588
354
            try:
589
 
                try:
590
 
                    tree_to = dir_to.open_workingtree()
591
 
                except errors.NotLocalUrl:
592
 
                    warning('This transport does not update the working '
593
 
                            'tree of: %s' % (br_to.base,))
594
 
                    count = br_to.pull(br_from, overwrite)
595
 
                except NoWorkingTree:
596
 
                    count = br_to.pull(br_from, overwrite)
597
 
                else:
598
 
                    count = tree_to.pull(br_from, overwrite)
 
355
                br_to.update_revisions(br_from)
599
356
            except DivergedBranches:
600
357
                raise BzrCommandError("These branches have diverged."
601
 
                                      "  Try a merge then push with overwrite.")
602
 
        note('%d revision(s) pushed.' % (count,))
 
358
                    "  Try merge.")
 
359
            new_revision_history = br_to.revision_history()
 
360
            if new_revision_history != old_revision_history:
 
361
                merge(('.', -1), ('.', old_revno), check_clean=False)
 
362
            if stored_loc is None or remember:
 
363
                br_to.set_parent(location)
 
364
        finally:
 
365
            br_from.unlock()
 
366
            rmtree(cache_root)
603
367
 
604
 
        if verbose:
605
 
            new_rh = br_to.revision_history()
606
 
            if old_rh != new_rh:
607
 
                # Something changed
608
 
                from bzrlib.log import show_changed_revisions
609
 
                show_changed_revisions(br_to, old_rh, new_rh,
610
 
                                       to_file=self.outf)
611
368
 
612
369
 
613
370
class cmd_branch(Command):
628
385
    aliases = ['get', 'clone']
629
386
 
630
387
    def run(self, from_location, to_location=None, revision=None, basis=None):
 
388
        from bzrlib.clone import copy_branch
 
389
        import tempfile
 
390
        import errno
 
391
        from shutil import rmtree
 
392
        cache_root = tempfile.mkdtemp()
631
393
        if revision is None:
632
394
            revision = [None]
633
395
        elif len(revision) > 1:
643
405
                raise
644
406
        br_from.lock_read()
645
407
        try:
 
408
            br_from.setup_caching(cache_root)
646
409
            if basis is not None:
647
 
                basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
 
410
                basis_branch = Branch.open_containing(basis)
648
411
            else:
649
 
                basis_dir = None
 
412
                basis_branch = None
650
413
            if len(revision) == 1 and revision[0] is not None:
651
414
                revision_id = revision[0].in_history(br_from)[1]
652
415
            else:
653
 
                # FIXME - wt.last_revision, fallback to branch, fall back to
654
 
                # None or perhaps NULL_REVISION to mean copy nothing
655
 
                # RBC 20060209
656
 
                revision_id = br_from.last_revision()
 
416
                revision_id = None
657
417
            if to_location is None:
658
418
                to_location = os.path.basename(from_location.rstrip("/\\"))
659
 
                name = None
660
 
            else:
661
 
                name = os.path.basename(to_location) + '\n'
662
 
 
663
 
            to_transport = transport.get_transport(to_location)
664
 
            try:
665
 
                to_transport.mkdir('.')
666
 
            except errors.FileExists:
667
 
                raise BzrCommandError('Target directory "%s" already'
668
 
                                      ' exists.' % to_location)
669
 
            except errors.NoSuchFile:
670
 
                raise BzrCommandError('Parent of "%s" does not exist.' %
671
 
                                      to_location)
672
 
            try:
673
 
                # preserve whatever source format we have.
674
 
                dir = br_from.bzrdir.sprout(to_transport.base,
675
 
                        revision_id, basis_dir)
676
 
                branch = dir.open_branch()
677
 
            except errors.NoSuchRevision:
678
 
                to_transport.delete_tree('.')
679
 
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
680
 
                raise BzrCommandError(msg)
681
 
            except errors.UnlistableBranch:
682
 
                osutils.rmtree(to_location)
683
 
                msg = "The branch %s cannot be used as a --basis" % (basis,)
684
 
                raise BzrCommandError(msg)
685
 
            if name:
686
 
                branch.control_files.put_utf8('branch-name', name)
687
 
            note('Branched %d revision(s).' % branch.revno())
 
419
            try:
 
420
                os.mkdir(to_location)
 
421
            except OSError, e:
 
422
                if e.errno == errno.EEXIST:
 
423
                    raise BzrCommandError('Target directory "%s" already'
 
424
                                          ' exists.' % to_location)
 
425
                if e.errno == errno.ENOENT:
 
426
                    raise BzrCommandError('Parent of "%s" does not exist.' %
 
427
                                          to_location)
 
428
                else:
 
429
                    raise
 
430
            try:
 
431
                copy_branch(br_from, to_location, revision_id, basis_branch)
 
432
            except bzrlib.errors.NoSuchRevision:
 
433
                rmtree(to_location)
 
434
                msg = "The branch %s has no revision %d." % (from_location, revision[0])
 
435
                raise BzrCommandError(msg)
 
436
            except bzrlib.errors.UnlistableBranch:
 
437
                msg = "The branch %s cannot be used as a --basis"
688
438
        finally:
689
439
            br_from.unlock()
690
 
 
691
 
 
692
 
class cmd_checkout(Command):
693
 
    """Create a new checkout of an existing branch.
694
 
 
695
 
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
696
 
    the branch found in '.'. This is useful if you have removed the working tree
697
 
    or if it was never created - i.e. if you pushed the branch to its current
698
 
    location using SFTP.
699
 
    
700
 
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
701
 
    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
702
 
 
703
 
    To retrieve the branch as of a particular revision, supply the --revision
704
 
    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
705
 
    out of date [so you cannot commit] but it may be useful (i.e. to examine old
706
 
    code.)
707
 
 
708
 
    --basis is to speed up checking out from remote branches.  When specified, it
709
 
    uses the inventory and file contents from the basis branch in preference to the
710
 
    branch being checked out.
711
 
    """
712
 
    takes_args = ['branch_location?', 'to_location?']
713
 
    takes_options = ['revision', # , 'basis']
714
 
                     Option('lightweight',
715
 
                            help="perform a lightweight checkout. Lightweight "
716
 
                                 "checkouts depend on access to the branch for "
717
 
                                 "every operation. Normal checkouts can perform "
718
 
                                 "common operations like diff and status without "
719
 
                                 "such access, and also support local commits."
720
 
                            ),
721
 
                     ]
722
 
    aliases = ['co']
723
 
 
724
 
    def run(self, branch_location=None, to_location=None, revision=None, basis=None,
725
 
            lightweight=False):
726
 
        if revision is None:
727
 
            revision = [None]
728
 
        elif len(revision) > 1:
729
 
            raise BzrCommandError(
730
 
                'bzr checkout --revision takes exactly 1 revision value')
731
 
        if branch_location is None:
732
 
            branch_location = osutils.getcwd()
733
 
            to_location = branch_location
734
 
        source = Branch.open(branch_location)
735
 
        if len(revision) == 1 and revision[0] is not None:
736
 
            revision_id = revision[0].in_history(source)[1]
737
 
        else:
738
 
            revision_id = None
739
 
        if to_location is None:
740
 
            to_location = os.path.basename(branch_location.rstrip("/\\"))
741
 
        # if the source and to_location are the same, 
742
 
        # and there is no working tree,
743
 
        # then reconstitute a branch
744
 
        if (osutils.abspath(to_location) == 
745
 
            osutils.abspath(branch_location)):
746
 
            try:
747
 
                source.bzrdir.open_workingtree()
748
 
            except errors.NoWorkingTree:
749
 
                source.bzrdir.create_workingtree()
750
 
                return
751
 
        try:
752
 
            os.mkdir(to_location)
753
 
        except OSError, e:
754
 
            if e.errno == errno.EEXIST:
755
 
                raise BzrCommandError('Target directory "%s" already'
756
 
                                      ' exists.' % to_location)
757
 
            if e.errno == errno.ENOENT:
758
 
                raise BzrCommandError('Parent of "%s" does not exist.' %
759
 
                                      to_location)
760
 
            else:
761
 
                raise
762
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
763
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
764
 
        try:
765
 
            if lightweight:
766
 
                checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
767
 
                branch.BranchReferenceFormat().initialize(checkout, source)
768
 
            else:
769
 
                checkout_branch =  bzrdir.BzrDir.create_branch_convenience(
770
 
                    to_location, force_new_tree=False)
771
 
                checkout = checkout_branch.bzrdir
772
 
                checkout_branch.bind(source)
773
 
                if revision_id is not None:
774
 
                    rh = checkout_branch.revision_history()
775
 
                    checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
776
 
            checkout.create_workingtree(revision_id)
777
 
        finally:
778
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
440
            rmtree(cache_root)
779
441
 
780
442
 
781
443
class cmd_renames(Command):
786
448
    # TODO: Only show renames under dir, rather than in the whole branch.
787
449
    takes_args = ['dir?']
788
450
 
789
 
    @display_command
790
 
    def run(self, dir=u'.'):
791
 
        from bzrlib.tree import find_renames
792
 
        tree = WorkingTree.open_containing(dir)[0]
793
 
        old_inv = tree.basis_tree().inventory
794
 
        new_inv = tree.read_working_inventory()
795
 
        renames = list(find_renames(old_inv, new_inv))
 
451
    def run(self, dir='.'):
 
452
        b = Branch.open_containing(dir)
 
453
        old_inv = b.basis_tree().inventory
 
454
        new_inv = b.read_working_inventory()
 
455
 
 
456
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
796
457
        renames.sort()
797
458
        for old_name, new_name in renames:
798
 
            self.outf.write("%s => %s\n" % (old_name, new_name))
799
 
 
800
 
 
801
 
class cmd_update(Command):
802
 
    """Update a tree to have the latest code committed to its branch.
803
 
    
804
 
    This will perform a merge into the working tree, and may generate
805
 
    conflicts. If you have any local changes, you will still 
806
 
    need to commit them after the update for the update to be complete.
807
 
    
808
 
    If you want to discard your local changes, you can just do a 
809
 
    'bzr revert' instead of 'bzr commit' after the update.
810
 
    """
811
 
    takes_args = ['dir?']
812
 
    aliases = ['up']
813
 
 
814
 
    def run(self, dir='.'):
815
 
        tree = WorkingTree.open_containing(dir)[0]
816
 
        tree.lock_write()
817
 
        try:
818
 
            last_rev = tree.last_revision() 
819
 
            if last_rev == tree.branch.last_revision():
820
 
                # may be up to date, check master too.
821
 
                master = tree.branch.get_master_branch()
822
 
                if master is None or last_rev == master.last_revision():
823
 
                    revno = tree.branch.revision_id_to_revno(last_rev)
824
 
                    note("Tree is up to date at revision %d." % (revno,))
825
 
                    return 0
826
 
            conflicts = tree.update()
827
 
            revno = tree.branch.revision_id_to_revno(tree.last_revision())
828
 
            note('Updated to revision %d.' % (revno,))
829
 
            if conflicts != 0:
830
 
                return 1
831
 
            else:
832
 
                return 0
833
 
        finally:
834
 
            tree.unlock()
 
459
            print "%s => %s" % (old_name, new_name)        
835
460
 
836
461
 
837
462
class cmd_info(Command):
838
 
    """Show information about a working tree, branch or repository.
839
 
 
840
 
    This command will show all known locations and formats associated to the
841
 
    tree, branch or repository.  Statistical information is included with
842
 
    each report.
843
 
 
844
 
    Branches and working trees will also report any missing revisions.
845
 
    """
846
 
    takes_args = ['location?']
847
 
    takes_options = ['verbose']
848
 
 
849
 
    @display_command
850
 
    def run(self, location=None, verbose=False):
851
 
        from bzrlib.info import show_bzrdir_info
852
 
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
853
 
                         verbose=verbose)
 
463
    """Show statistical information about a branch."""
 
464
    takes_args = ['branch?']
 
465
    
 
466
    def run(self, branch=None):
 
467
        import info
 
468
        b = Branch.open_containing(branch)
 
469
        info.show_info(b)
854
470
 
855
471
 
856
472
class cmd_remove(Command):
858
474
 
859
475
    This makes bzr stop tracking changes to a versioned file.  It does
860
476
    not delete the working copy.
861
 
 
862
 
    You can specify one or more files, and/or --new.  If you specify --new,
863
 
    only 'added' files will be removed.  If you specify both, then new files
864
 
    in the specified directories will be removed.  If the directories are
865
 
    also new, they will also be removed.
866
477
    """
867
 
    takes_args = ['file*']
868
 
    takes_options = ['verbose', Option('new', help='remove newly-added files')]
 
478
    takes_args = ['file+']
 
479
    takes_options = ['verbose']
869
480
    aliases = ['rm']
870
 
    encoding_type = 'replace'
871
481
    
872
 
    def run(self, file_list, verbose=False, new=False):
873
 
        tree, file_list = tree_files(file_list)
874
 
        if new is False:
875
 
            if file_list is None:
876
 
                raise BzrCommandError('Specify one or more files to remove, or'
877
 
                                      ' use --new.')
878
 
        else:
879
 
            added = tree.changes_from(tree.basis_tree(),
880
 
                specific_files=file_list).added
881
 
            file_list = sorted([f[0] for f in added], reverse=True)
882
 
            if len(file_list) == 0:
883
 
                raise BzrCommandError('No matching files.')
884
 
        tree.remove(file_list, verbose=verbose, to_file=self.outf)
 
482
    def run(self, file_list, verbose=False):
 
483
        b = Branch.open_containing(file_list[0])
 
484
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
885
485
 
886
486
 
887
487
class cmd_file_id(Command):
891
491
    same through all revisions where the file exists, even when it is
892
492
    moved or renamed.
893
493
    """
894
 
 
895
494
    hidden = True
896
495
    takes_args = ['filename']
897
 
 
898
 
    @display_command
899
496
    def run(self, filename):
900
 
        tree, relpath = WorkingTree.open_containing(filename)
901
 
        i = tree.inventory.path2id(relpath)
 
497
        b = Branch.open_containing(filename)
 
498
        i = b.inventory.path2id(b.relpath(filename))
902
499
        if i == None:
903
500
            raise BzrError("%r is not a versioned file" % filename)
904
501
        else:
905
 
            self.outf.write(i + '\n')
 
502
            print i
906
503
 
907
504
 
908
505
class cmd_file_path(Command):
909
506
    """Print path of file_ids to a file or directory.
910
507
 
911
508
    This prints one line for each directory down to the target,
912
 
    starting at the branch root.
913
 
    """
914
 
 
 
509
    starting at the branch root."""
915
510
    hidden = True
916
511
    takes_args = ['filename']
917
 
 
918
 
    @display_command
919
512
    def run(self, filename):
920
 
        tree, relpath = WorkingTree.open_containing(filename)
921
 
        inv = tree.inventory
922
 
        fid = inv.path2id(relpath)
 
513
        b = Branch.open_containing(filename)
 
514
        inv = b.inventory
 
515
        fid = inv.path2id(b.relpath(filename))
923
516
        if fid == None:
924
517
            raise BzrError("%r is not a versioned file" % filename)
925
518
        for fip in inv.get_idpath(fid):
926
 
            self.outf.write(fip + '\n')
927
 
 
928
 
 
929
 
class cmd_reconcile(Command):
930
 
    """Reconcile bzr metadata in a branch.
931
 
 
932
 
    This can correct data mismatches that may have been caused by
933
 
    previous ghost operations or bzr upgrades. You should only
934
 
    need to run this command if 'bzr check' or a bzr developer 
935
 
    advises you to run it.
936
 
 
937
 
    If a second branch is provided, cross-branch reconciliation is
938
 
    also attempted, which will check that data like the tree root
939
 
    id which was not present in very early bzr versions is represented
940
 
    correctly in both branches.
941
 
 
942
 
    At the same time it is run it may recompress data resulting in 
943
 
    a potential saving in disk space or performance gain.
944
 
 
945
 
    The branch *MUST* be on a listable system such as local disk or sftp.
946
 
    """
947
 
    takes_args = ['branch?']
948
 
 
949
 
    def run(self, branch="."):
950
 
        from bzrlib.reconcile import reconcile
951
 
        dir = bzrdir.BzrDir.open(branch)
952
 
        reconcile(dir)
 
519
            print fip
953
520
 
954
521
 
955
522
class cmd_revision_history(Command):
956
 
    """Display the list of revision ids on a branch."""
957
 
    takes_args = ['location?']
958
 
 
 
523
    """Display list of revision ids on this branch."""
959
524
    hidden = True
960
 
 
961
 
    @display_command
962
 
    def run(self, location="."):
963
 
        branch = Branch.open_containing(location)[0]
964
 
        for revid in branch.revision_history():
965
 
            self.outf.write(revid)
966
 
            self.outf.write('\n')
 
525
    def run(self):
 
526
        for patchid in Branch.open_containing('.').revision_history():
 
527
            print patchid
967
528
 
968
529
 
969
530
class cmd_ancestry(Command):
970
531
    """List all revisions merged into this branch."""
971
 
    takes_args = ['location?']
972
 
 
973
532
    hidden = True
974
 
 
975
 
    @display_command
976
 
    def run(self, location="."):
977
 
        try:
978
 
            wt = WorkingTree.open_containing(location)[0]
979
 
        except errors.NoWorkingTree:
980
 
            b = Branch.open(location)
981
 
            last_revision = b.last_revision()
982
 
        else:
983
 
            b = wt.branch
984
 
            last_revision = wt.last_revision()
985
 
 
986
 
        revision_ids = b.repository.get_ancestry(last_revision)
987
 
        assert revision_ids[0] == None
988
 
        revision_ids.pop(0)
989
 
        for revision_id in revision_ids:
990
 
            self.outf.write(revision_id + '\n')
 
533
    def run(self):
 
534
        b = find_branch('.')
 
535
        for revision_id in b.get_ancestry(b.last_revision()):
 
536
            print revision_id
 
537
 
 
538
 
 
539
class cmd_directories(Command):
 
540
    """Display list of versioned directories in this branch."""
 
541
    def run(self):
 
542
        for name, ie in Branch.open_containing('.').read_working_inventory().directories():
 
543
            if name == '':
 
544
                print '.'
 
545
            else:
 
546
                print name
991
547
 
992
548
 
993
549
class cmd_init(Command):
996
552
    Use this to create an empty branch, or before importing an
997
553
    existing project.
998
554
 
999
 
    If there is a repository in a parent directory of the location, then 
1000
 
    the history of the branch will be stored in the repository.  Otherwise
1001
 
    init creates a standalone branch which carries its own history in 
1002
 
    .bzr.
1003
 
 
1004
 
    If there is already a branch at the location but it has no working tree,
1005
 
    the tree can be populated with 'bzr checkout'.
1006
 
 
1007
555
    Recipe for importing a tree of files:
1008
556
        cd ~/project
1009
557
        bzr init
1010
 
        bzr add .
 
558
        bzr add -v .
1011
559
        bzr status
1012
560
        bzr commit -m 'imported project'
1013
561
    """
1014
 
    takes_args = ['location?']
1015
 
    takes_options = [
1016
 
                     Option('format', 
1017
 
                            help='Specify a format for this branch. Current'
1018
 
                                 ' formats are: default, knit, metaweave and'
1019
 
                                 ' weave. Default is knit; metaweave and'
1020
 
                                 ' weave are deprecated',
1021
 
                            type=get_format_type),
1022
 
                     ]
1023
 
    def run(self, location=None, format=None):
1024
 
        if format is None:
1025
 
            format = get_format_type('default')
1026
 
        if location is None:
1027
 
            location = u'.'
1028
 
 
1029
 
        to_transport = transport.get_transport(location)
1030
 
 
1031
 
        # The path has to exist to initialize a
1032
 
        # branch inside of it.
1033
 
        # Just using os.mkdir, since I don't
1034
 
        # believe that we want to create a bunch of
1035
 
        # locations if the user supplies an extended path
1036
 
        # TODO: create-prefix
1037
 
        try:
1038
 
            to_transport.mkdir('.')
1039
 
        except errors.FileExists:
1040
 
            pass
1041
 
                    
1042
 
        try:
1043
 
            existing_bzrdir = bzrdir.BzrDir.open(location)
1044
 
        except NotBranchError:
1045
 
            # really a NotBzrDir error...
1046
 
            bzrdir.BzrDir.create_branch_convenience(location, format=format)
1047
 
        else:
1048
 
            if existing_bzrdir.has_branch():
1049
 
                if (isinstance(to_transport, LocalTransport)
1050
 
                    and not existing_bzrdir.has_workingtree()):
1051
 
                        raise errors.BranchExistsWithoutWorkingTree(location)
1052
 
                raise errors.AlreadyBranchError(location)
1053
 
            else:
1054
 
                existing_bzrdir.create_branch()
1055
 
                existing_bzrdir.create_workingtree()
1056
 
 
1057
 
 
1058
 
class cmd_init_repository(Command):
1059
 
    """Create a shared repository to hold branches.
1060
 
 
1061
 
    New branches created under the repository directory will store their revisions
1062
 
    in the repository, not in the branch directory, if the branch format supports
1063
 
    shared storage.
1064
 
 
1065
 
    example:
1066
 
        bzr init-repo repo
1067
 
        bzr init repo/trunk
1068
 
        bzr checkout --lightweight repo/trunk trunk-checkout
1069
 
        cd trunk-checkout
1070
 
        (add files here)
1071
 
    """
1072
 
    takes_args = ["location"] 
1073
 
    takes_options = [Option('format', 
1074
 
                            help='Specify a format for this repository.'
1075
 
                                 ' Current formats are: default, knit,'
1076
 
                                 ' metaweave and weave. Default is knit;'
1077
 
                                 ' metaweave and weave are deprecated',
1078
 
                            type=get_format_type),
1079
 
                     Option('trees',
1080
 
                             help='Allows branches in repository to have'
1081
 
                             ' a working tree')]
1082
 
    aliases = ["init-repo"]
1083
 
    def run(self, location, format=None, trees=False):
1084
 
        if format is None:
1085
 
            format = get_format_type('default')
1086
 
 
1087
 
        if location is None:
1088
 
            location = '.'
1089
 
 
1090
 
        to_transport = transport.get_transport(location)
1091
 
        try:
1092
 
            to_transport.mkdir('.')
1093
 
        except errors.FileExists:
1094
 
            pass
1095
 
 
1096
 
        newdir = format.initialize_on_transport(to_transport)
1097
 
        repo = newdir.create_repository(shared=True)
1098
 
        repo.set_make_working_trees(trees)
 
562
    def run(self):
 
563
        Branch.initialize('.')
1099
564
 
1100
565
 
1101
566
class cmd_diff(Command):
1102
 
    """Show differences in the working tree or between revisions.
 
567
    """Show differences in working tree.
1103
568
    
1104
569
    If files are listed, only the changes in those files are listed.
1105
570
    Otherwise, all changes for the tree are listed.
1106
571
 
1107
 
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1108
 
    produces patches suitable for "patch -p1".
1109
 
 
1110
572
    examples:
1111
573
        bzr diff
1112
 
            Shows the difference in the working tree versus the last commit
1113
574
        bzr diff -r1
1114
 
            Difference between the working tree and revision 1
1115
575
        bzr diff -r1..2
1116
 
            Difference between revision 2 and revision 1
1117
 
        bzr diff --diff-prefix old/:new/
1118
 
            Same as 'bzr diff' but prefix paths with old/ and new/
1119
 
        bzr diff bzr.mine bzr.dev
1120
 
            Show the differences between the two working trees
1121
 
        bzr diff foo.c
1122
 
            Show just the differences for 'foo.c'
1123
576
    """
 
577
    # TODO: Allow diff across branches.
1124
578
    # TODO: Option to use external diff command; could be GNU diff, wdiff,
1125
579
    #       or a graphical diff.
1126
580
 
1127
581
    # TODO: Python difflib is not exactly the same as unidiff; should
1128
582
    #       either fix it up or prefer to use an external diff.
1129
583
 
 
584
    # TODO: If a directory is given, diff everything under that.
 
585
 
1130
586
    # TODO: Selected-file diff is inefficient and doesn't show you
1131
587
    #       deleted files.
1132
588
 
1133
589
    # TODO: This probably handles non-Unix newlines poorly.
1134
590
    
1135
591
    takes_args = ['file*']
1136
 
    takes_options = ['revision', 'diff-options', 'prefix']
 
592
    takes_options = ['revision', 'diff-options']
1137
593
    aliases = ['di', 'dif']
1138
 
    encoding_type = 'exact'
1139
 
 
1140
 
    @display_command
1141
 
    def run(self, revision=None, file_list=None, diff_options=None,
1142
 
            prefix=None):
1143
 
        from bzrlib.diff import diff_cmd_helper, show_diff_trees
1144
 
 
1145
 
        if (prefix is None) or (prefix == '0'):
1146
 
            # diff -p0 format
1147
 
            old_label = ''
1148
 
            new_label = ''
1149
 
        elif prefix == '1':
1150
 
            old_label = 'old/'
1151
 
            new_label = 'new/'
 
594
 
 
595
    def run(self, revision=None, file_list=None, diff_options=None):
 
596
        from bzrlib.diff import show_diff
 
597
 
 
598
        if file_list:
 
599
            b = Branch.open_containing(file_list[0])
 
600
            file_list = [b.relpath(f) for f in file_list]
 
601
            if file_list == ['']:
 
602
                # just pointing to top-of-tree
 
603
                file_list = None
1152
604
        else:
1153
 
            if not ':' in prefix:
1154
 
                 raise BzrError("--diff-prefix expects two values separated by a colon")
1155
 
            old_label, new_label = prefix.split(":")
1156
 
        
1157
 
        try:
1158
 
            tree1, file_list = internal_tree_files(file_list)
1159
 
            tree2 = None
1160
 
            b = None
1161
 
            b2 = None
1162
 
        except FileInWrongBranch:
1163
 
            if len(file_list) != 2:
1164
 
                raise BzrCommandError("Files are in different branches")
 
605
            b = Branch.open_containing('.')
1165
606
 
1166
 
            tree1, file1 = WorkingTree.open_containing(file_list[0])
1167
 
            tree2, file2 = WorkingTree.open_containing(file_list[1])
1168
 
            if file1 != "" or file2 != "":
1169
 
                # FIXME diff those two files. rbc 20051123
1170
 
                raise BzrCommandError("Files are in different branches")
1171
 
            file_list = None
1172
 
        except NotBranchError:
1173
 
            if (revision is not None and len(revision) == 2
1174
 
                and not revision[0].needs_branch()
1175
 
                and not revision[1].needs_branch()):
1176
 
                # If both revision specs include a branch, we can
1177
 
                # diff them without needing a local working tree
1178
 
                tree1, tree2 = None, None
1179
 
            else:
1180
 
                raise
1181
607
        if revision is not None:
1182
 
            if tree2 is not None:
1183
 
                raise BzrCommandError("Can't specify -r with two branches")
1184
 
            if (len(revision) == 1) or (revision[1].spec is None):
1185
 
                return diff_cmd_helper(tree1, file_list, diff_options,
1186
 
                                       revision[0], 
1187
 
                                       old_label=old_label, new_label=new_label)
 
608
            if len(revision) == 1:
 
609
                show_diff(b, revision[0], specific_files=file_list,
 
610
                          external_diff_options=diff_options)
1188
611
            elif len(revision) == 2:
1189
 
                return diff_cmd_helper(tree1, file_list, diff_options,
1190
 
                                       revision[0], revision[1],
1191
 
                                       old_label=old_label, new_label=new_label)
 
612
                show_diff(b, revision[0], specific_files=file_list,
 
613
                          external_diff_options=diff_options,
 
614
                          revision2=revision[1])
1192
615
            else:
1193
616
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1194
617
        else:
1195
 
            if tree2 is not None:
1196
 
                return show_diff_trees(tree1, tree2, sys.stdout, 
1197
 
                                       specific_files=file_list,
1198
 
                                       external_diff_options=diff_options,
1199
 
                                       old_label=old_label, new_label=new_label)
1200
 
            else:
1201
 
                return diff_cmd_helper(tree1, file_list, diff_options,
1202
 
                                       old_label=old_label, new_label=new_label)
 
618
            show_diff(b, None, specific_files=file_list,
 
619
                      external_diff_options=diff_options)
 
620
 
 
621
        
1203
622
 
1204
623
 
1205
624
class cmd_deleted(Command):
1211
630
    # directories with readdir, rather than stating each one.  Same
1212
631
    # level of effort but possibly much less IO.  (Or possibly not,
1213
632
    # if the directories are very large...)
1214
 
    takes_options = ['show-ids']
1215
 
 
1216
 
    @display_command
1217
633
    def run(self, show_ids=False):
1218
 
        tree = WorkingTree.open_containing(u'.')[0]
1219
 
        old = tree.basis_tree()
 
634
        b = Branch.open_containing('.')
 
635
        old = b.basis_tree()
 
636
        new = b.working_tree()
1220
637
        for path, ie in old.inventory.iter_entries():
1221
 
            if not tree.has_id(ie.file_id):
1222
 
                self.outf.write(path)
 
638
            if not new.has_id(ie.file_id):
1223
639
                if show_ids:
1224
 
                    self.outf.write(' ')
1225
 
                    self.outf.write(ie.file_id)
1226
 
                self.outf.write('\n')
 
640
                    print '%-50s %s' % (path, ie.file_id)
 
641
                else:
 
642
                    print path
1227
643
 
1228
644
 
1229
645
class cmd_modified(Command):
1230
646
    """List files modified in working tree."""
1231
647
    hidden = True
1232
 
    @display_command
1233
648
    def run(self):
1234
 
        tree = WorkingTree.open_containing(u'.')[0]
1235
 
        td = tree.changes_from(tree.basis_tree())
 
649
        from bzrlib.delta import compare_trees
 
650
 
 
651
        b = Branch.open_containing('.')
 
652
        td = compare_trees(b.basis_tree(), b.working_tree())
 
653
 
1236
654
        for path, id, kind, text_modified, meta_modified in td.modified:
1237
 
            self.outf.write(path + '\n')
 
655
            print path
 
656
 
1238
657
 
1239
658
 
1240
659
class cmd_added(Command):
1241
660
    """List files added in working tree."""
1242
661
    hidden = True
1243
 
    @display_command
1244
662
    def run(self):
1245
 
        wt = WorkingTree.open_containing(u'.')[0]
1246
 
        basis_inv = wt.basis_tree().inventory
 
663
        b = Branch.open_containing('.')
 
664
        wt = b.working_tree()
 
665
        basis_inv = b.basis_tree().inventory
1247
666
        inv = wt.inventory
1248
667
        for file_id in inv:
1249
668
            if file_id in basis_inv:
1250
669
                continue
1251
670
            path = inv.id2path(file_id)
1252
 
            if not os.access(osutils.abspath(path), os.F_OK):
 
671
            if not os.access(b.abspath(path), os.F_OK):
1253
672
                continue
1254
 
            self.outf.write(path + '\n')
1255
 
 
 
673
            print path
 
674
                
 
675
        
1256
676
 
1257
677
class cmd_root(Command):
1258
678
    """Show the tree root directory.
1260
680
    The root is the nearest enclosing directory with a .bzr control
1261
681
    directory."""
1262
682
    takes_args = ['filename?']
1263
 
    @display_command
1264
683
    def run(self, filename=None):
1265
684
        """Print the branch root."""
1266
 
        tree = WorkingTree.open_containing(filename)[0]
1267
 
        self.outf.write(tree.basedir + '\n')
 
685
        b = Branch.open_containing(filename)
 
686
        print b.base
1268
687
 
1269
688
 
1270
689
class cmd_log(Command):
1271
 
    """Show log of a branch, file, or directory.
1272
 
 
1273
 
    By default show the log of the branch containing the working directory.
1274
 
 
1275
 
    To request a range of logs, you can use the command -r begin..end
1276
 
    -r revision requests a specific revision, -r ..end or -r begin.. are
 
690
    """Show log of this branch.
 
691
 
 
692
    To request a range of logs, you can use the command -r begin:end
 
693
    -r revision requests a specific revision, -r :end or -r begin: are
1277
694
    also valid.
1278
695
 
1279
 
    examples:
1280
 
        bzr log
1281
 
        bzr log foo.c
1282
 
        bzr log -r -10.. http://server/branch
 
696
    --message allows you to give a regular expression, which will be evaluated
 
697
    so that only matching entries will be displayed.
1283
698
    """
1284
699
 
1285
700
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
1286
701
 
1287
 
    takes_args = ['location?']
1288
 
    takes_options = [Option('forward', 
1289
 
                            help='show from oldest to newest'),
1290
 
                     'timezone', 
1291
 
                     Option('verbose', 
1292
 
                             help='show files changed in each revision'),
1293
 
                     'show-ids', 'revision',
1294
 
                     'log-format',
1295
 
                     'line', 'long', 
1296
 
                     Option('message',
1297
 
                            help='show revisions whose message matches this regexp',
1298
 
                            type=str),
1299
 
                     'short',
1300
 
                     ]
1301
 
    encoding_type = 'replace'
1302
 
 
1303
 
    @display_command
1304
 
    def run(self, location=None, timezone='original',
 
702
    takes_args = ['filename?']
 
703
    takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
 
704
                     'long', 'message', 'short',]
 
705
    
 
706
    def run(self, filename=None, timezone='original',
1305
707
            verbose=False,
1306
708
            show_ids=False,
1307
709
            forward=False,
1308
710
            revision=None,
1309
 
            log_format=None,
1310
711
            message=None,
1311
712
            long=False,
1312
 
            short=False,
1313
 
            line=False):
 
713
            short=False):
1314
714
        from bzrlib.log import log_formatter, show_log
1315
 
        assert message is None or isinstance(message, basestring), \
1316
 
            "invalid message argument %r" % message
 
715
        import codecs
 
716
 
1317
717
        direction = (forward and 'forward') or 'reverse'
1318
718
        
1319
 
        # log everything
1320
 
        file_id = None
1321
 
        if location:
1322
 
            # find the file id to log:
1323
 
 
1324
 
            dir, fp = bzrdir.BzrDir.open_containing(location)
1325
 
            b = dir.open_branch()
1326
 
            if fp != '':
1327
 
                try:
1328
 
                    # might be a tree:
1329
 
                    inv = dir.open_workingtree().inventory
1330
 
                except (errors.NotBranchError, errors.NotLocalUrl):
1331
 
                    # either no tree, or is remote.
1332
 
                    inv = b.basis_tree().inventory
1333
 
                file_id = inv.path2id(fp)
 
719
        if filename:
 
720
            b = Branch.open_containing(filename)
 
721
            fp = b.relpath(filename)
 
722
            if fp:
 
723
                file_id = b.read_working_inventory().path2id(fp)
 
724
            else:
 
725
                file_id = None  # points to branch root
1334
726
        else:
1335
 
            # local dir only
1336
 
            # FIXME ? log the current subdir only RBC 20060203 
1337
 
            dir, relpath = bzrdir.BzrDir.open_containing('.')
1338
 
            b = dir.open_branch()
 
727
            b = Branch.open_containing('.')
 
728
            file_id = None
1339
729
 
1340
730
        if revision is None:
1341
731
            rev1 = None
1343
733
        elif len(revision) == 1:
1344
734
            rev1 = rev2 = revision[0].in_history(b).revno
1345
735
        elif len(revision) == 2:
1346
 
            if revision[0].spec is None:
1347
 
                # missing begin-range means first revision
1348
 
                rev1 = 1
1349
 
            else:
1350
 
                rev1 = revision[0].in_history(b).revno
1351
 
 
1352
 
            if revision[1].spec is None:
1353
 
                # missing end-range means last known revision
1354
 
                rev2 = b.revno()
1355
 
            else:
1356
 
                rev2 = revision[1].in_history(b).revno
 
736
            rev1 = revision[0].in_history(b).revno
 
737
            rev2 = revision[1].in_history(b).revno
1357
738
        else:
1358
739
            raise BzrCommandError('bzr log --revision takes one or two values.')
1359
740
 
1360
 
        # By this point, the revision numbers are converted to the +ve
1361
 
        # form if they were supplied in the -ve form, so we can do
1362
 
        # this comparison in relative safety
1363
 
        if rev1 > rev2:
1364
 
            (rev2, rev1) = (rev1, rev2)
1365
 
 
1366
 
        if (log_format == None):
1367
 
            default = b.get_config().log_format()
1368
 
            log_format = get_log_format(long=long, short=short, line=line, 
1369
 
                                        default=default)
 
741
        if rev1 == 0:
 
742
            rev1 = None
 
743
        if rev2 == 0:
 
744
            rev2 = None
 
745
 
 
746
        mutter('encoding log as %r' % bzrlib.user_encoding)
 
747
 
 
748
        # use 'replace' so that we don't abort if trying to write out
 
749
        # in e.g. the default C locale.
 
750
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
751
 
 
752
        if not short:
 
753
            log_format = 'long'
 
754
        else:
 
755
            log_format = 'short'
1370
756
        lf = log_formatter(log_format,
1371
757
                           show_ids=show_ids,
1372
 
                           to_file=self.outf,
 
758
                           to_file=outf,
1373
759
                           show_timezone=timezone)
1374
760
 
1375
761
        show_log(b,
1382
768
                 search=message)
1383
769
 
1384
770
 
1385
 
def get_log_format(long=False, short=False, line=False, default='long'):
1386
 
    log_format = default
1387
 
    if long:
1388
 
        log_format = 'long'
1389
 
    if short:
1390
 
        log_format = 'short'
1391
 
    if line:
1392
 
        log_format = 'line'
1393
 
    return log_format
1394
 
 
1395
771
 
1396
772
class cmd_touching_revisions(Command):
1397
773
    """Return revision-ids which affected a particular file.
1398
774
 
1399
 
    A more user-friendly interface is "bzr log FILE".
1400
 
    """
1401
 
 
 
775
    A more user-friendly interface is "bzr log FILE"."""
1402
776
    hidden = True
1403
777
    takes_args = ["filename"]
1404
 
 
1405
 
    @display_command
1406
778
    def run(self, filename):
1407
 
        tree, relpath = WorkingTree.open_containing(filename)
1408
 
        b = tree.branch
1409
 
        inv = tree.read_working_inventory()
1410
 
        file_id = inv.path2id(relpath)
1411
 
        for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1412
 
            self.outf.write("%6d %s\n" % (revno, what))
 
779
        b = Branch.open_containing(filename)
 
780
        inv = b.read_working_inventory()
 
781
        file_id = inv.path2id(b.relpath(filename))
 
782
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
 
783
            print "%6d %s" % (revno, what)
1413
784
 
1414
785
 
1415
786
class cmd_ls(Command):
1417
788
    """
1418
789
    # TODO: Take a revision or remote path and list that tree instead.
1419
790
    hidden = True
1420
 
    takes_options = ['verbose', 'revision',
1421
 
                     Option('non-recursive',
1422
 
                            help='don\'t recurse into sub-directories'),
1423
 
                     Option('from-root',
1424
 
                            help='Print all paths from the root of the branch.'),
1425
 
                     Option('unknown', help='Print unknown files'),
1426
 
                     Option('versioned', help='Print versioned files'),
1427
 
                     Option('ignored', help='Print ignored files'),
1428
 
 
1429
 
                     Option('null', help='Null separate the files'),
1430
 
                    ]
1431
 
    @display_command
1432
 
    def run(self, revision=None, verbose=False, 
1433
 
            non_recursive=False, from_root=False,
1434
 
            unknown=False, versioned=False, ignored=False,
1435
 
            null=False):
1436
 
 
1437
 
        if verbose and null:
1438
 
            raise BzrCommandError('Cannot set both --verbose and --null')
1439
 
        all = not (unknown or versioned or ignored)
1440
 
 
1441
 
        selection = {'I':ignored, '?':unknown, 'V':versioned}
1442
 
 
1443
 
        tree, relpath = WorkingTree.open_containing(u'.')
1444
 
        if from_root:
1445
 
            relpath = u''
1446
 
        elif relpath:
1447
 
            relpath += '/'
1448
 
        if revision is not None:
1449
 
            tree = tree.branch.repository.revision_tree(
1450
 
                revision[0].in_history(tree.branch).rev_id)
1451
 
 
 
791
    def run(self, revision=None, verbose=False):
 
792
        b = Branch.open_containing('.')
 
793
        if revision == None:
 
794
            tree = b.working_tree()
 
795
        else:
 
796
            tree = b.revision_tree(revision.in_history(b).rev_id)
1452
797
        for fp, fc, kind, fid, entry in tree.list_files():
1453
 
            if fp.startswith(relpath):
1454
 
                fp = fp[len(relpath):]
1455
 
                if non_recursive and '/' in fp:
1456
 
                    continue
1457
 
                if not all and not selection[fc]:
1458
 
                    continue
1459
 
                if verbose:
1460
 
                    kindch = entry.kind_character()
1461
 
                    self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1462
 
                elif null:
1463
 
                    self.outf.write(fp + '\0')
1464
 
                    self.outf.flush()
1465
 
                else:
1466
 
                    self.outf.write(fp + '\n')
 
798
            if verbose:
 
799
                kindch = entry.kind_character()
 
800
                print '%-8s %s%s' % (fc, fp, kindch)
 
801
            else:
 
802
                print fp
 
803
 
1467
804
 
1468
805
 
1469
806
class cmd_unknowns(Command):
1470
807
    """List unknown files."""
1471
 
    @display_command
1472
808
    def run(self):
1473
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
1474
 
            self.outf.write(osutils.quotefn(f) + '\n')
 
809
        from bzrlib.osutils import quotefn
 
810
        for f in Branch.open_containing('.').unknowns():
 
811
            print quotefn(f)
 
812
 
1475
813
 
1476
814
 
1477
815
class cmd_ignore(Command):
1493
831
        bzr ignore '*.class'
1494
832
    """
1495
833
    # TODO: Complain if the filename is absolute
1496
 
    takes_args = ['name_pattern?']
1497
 
    takes_options = [
1498
 
                     Option('old-default-rules',
1499
 
                            help='Out the ignore rules bzr < 0.9 always used.')
1500
 
                     ]
 
834
    takes_args = ['name_pattern']
1501
835
    
1502
 
    def run(self, name_pattern=None, old_default_rules=None):
 
836
    def run(self, name_pattern):
1503
837
        from bzrlib.atomicfile import AtomicFile
1504
 
        if old_default_rules is not None:
1505
 
            # dump the rules and exit
1506
 
            for pattern in ignores.OLD_DEFAULTS:
1507
 
                print pattern
1508
 
            return
1509
 
        if name_pattern is None:
1510
 
            raise BzrCommandError("ignore requires a NAME_PATTERN")
1511
 
        tree, relpath = WorkingTree.open_containing(u'.')
1512
 
        ifn = tree.abspath('.bzrignore')
 
838
        import os.path
 
839
 
 
840
        b = Branch.open_containing('.')
 
841
        ifn = b.abspath('.bzrignore')
 
842
 
1513
843
        if os.path.exists(ifn):
1514
844
            f = open(ifn, 'rt')
1515
845
            try:
1526
856
            igns += '\n'
1527
857
        igns += name_pattern + '\n'
1528
858
 
1529
 
        f = AtomicFile(ifn, 'wt')
1530
859
        try:
 
860
            f = AtomicFile(ifn, 'wt')
1531
861
            f.write(igns.encode('utf-8'))
1532
862
            f.commit()
1533
863
        finally:
1534
864
            f.close()
1535
865
 
1536
 
        inv = tree.inventory
 
866
        inv = b.working_tree().inventory
1537
867
        if inv.path2id('.bzrignore'):
1538
868
            mutter('.bzrignore is already versioned')
1539
869
        else:
1540
870
            mutter('need to make new .bzrignore file versioned')
1541
 
            tree.add(['.bzrignore'])
 
871
            b.add(['.bzrignore'])
 
872
 
1542
873
 
1543
874
 
1544
875
class cmd_ignored(Command):
1545
876
    """List ignored files and the patterns that matched them.
1546
877
 
1547
878
    See also: bzr ignore"""
1548
 
    @display_command
1549
879
    def run(self):
1550
 
        tree = WorkingTree.open_containing(u'.')[0]
 
880
        tree = Branch.open_containing('.').working_tree()
1551
881
        for path, file_class, kind, file_id, entry in tree.list_files():
1552
882
            if file_class != 'I':
1553
883
                continue
1565
895
    hidden = True
1566
896
    takes_args = ['revno']
1567
897
    
1568
 
    @display_command
1569
898
    def run(self, revno):
1570
899
        try:
1571
900
            revno = int(revno)
1572
901
        except ValueError:
1573
902
            raise BzrCommandError("not a valid revision-number: %r" % revno)
1574
903
 
1575
 
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
904
        print Branch.open_containing('.').get_rev_id(revno)
1576
905
 
1577
906
 
1578
907
class cmd_export(Command):
1585
914
    is found exports to a directory (equivalent to --format=dir).
1586
915
 
1587
916
    Root may be the top directory for tar, tgz and tbz2 formats. If none
1588
 
    is given, the top directory will be the root name of the file.
1589
 
 
1590
 
    Note: export of tree with non-ascii filenames to zip is not supported.
1591
 
 
1592
 
     Supported formats       Autodetected by extension
1593
 
     -----------------       -------------------------
1594
 
         dir                            -
1595
 
         tar                          .tar
1596
 
         tbz2                    .tar.bz2, .tbz2
1597
 
         tgz                      .tar.gz, .tgz
1598
 
         zip                          .zip
1599
 
    """
 
917
    is given, the top directory will be the root name of the file."""
 
918
    # TODO: list known exporters
1600
919
    takes_args = ['dest']
1601
920
    takes_options = ['revision', 'format', 'root']
1602
921
    def run(self, dest, revision=None, format=None, root=None):
1603
 
        from bzrlib.export import export
1604
 
        tree = WorkingTree.open_containing(u'.')[0]
1605
 
        b = tree.branch
 
922
        import os.path
 
923
        b = Branch.open_containing('.')
1606
924
        if revision is None:
1607
 
            # should be tree.last_revision  FIXME
1608
925
            rev_id = b.last_revision()
1609
926
        else:
1610
927
            if len(revision) != 1:
1611
928
                raise BzrError('bzr export --revision takes exactly 1 argument')
1612
929
            rev_id = revision[0].in_history(b).rev_id
1613
 
        t = b.repository.revision_tree(rev_id)
1614
 
        try:
1615
 
            export(t, dest, format, root)
1616
 
        except errors.NoSuchExportFormat, e:
1617
 
            raise BzrCommandError('Unsupported export format: %s' % e.format)
 
930
        t = b.revision_tree(rev_id)
 
931
        arg_root, ext = os.path.splitext(os.path.basename(dest))
 
932
        if ext in ('.gz', '.bz2'):
 
933
            new_root, new_ext = os.path.splitext(arg_root)
 
934
            if new_ext == '.tar':
 
935
                arg_root = new_root
 
936
                ext = new_ext + ext
 
937
        if root is None:
 
938
            root = arg_root
 
939
        if not format:
 
940
            if ext in (".tar",):
 
941
                format = "tar"
 
942
            elif ext in (".tar.gz", ".tgz"):
 
943
                format = "tgz"
 
944
            elif ext in (".tar.bz2", ".tbz2"):
 
945
                format = "tbz2"
 
946
            else:
 
947
                format = "dir"
 
948
        t.export(dest, format, root)
1618
949
 
1619
950
 
1620
951
class cmd_cat(Command):
1623
954
    takes_options = ['revision']
1624
955
    takes_args = ['filename']
1625
956
 
1626
 
    @display_command
1627
957
    def run(self, filename, revision=None):
1628
 
        if revision is not None and len(revision) != 1:
 
958
        if revision is None:
 
959
            raise BzrCommandError("bzr cat requires a revision number")
 
960
        elif len(revision) != 1:
1629
961
            raise BzrCommandError("bzr cat --revision takes exactly one number")
1630
 
        tree = None
1631
 
        try:
1632
 
            tree, relpath = WorkingTree.open_containing(filename)
1633
 
            b = tree.branch
1634
 
        except NotBranchError:
1635
 
            pass
1636
 
 
1637
 
        if tree is None:
1638
 
            b, relpath = Branch.open_containing(filename)
1639
 
        if revision is None:
1640
 
            revision_id = b.last_revision()
1641
 
        else:
1642
 
            revision_id = revision[0].in_history(b).rev_id
1643
 
        b.print_file(relpath, revision_id)
 
962
        b = Branch.open_containing('.')
 
963
        b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
1644
964
 
1645
965
 
1646
966
class cmd_local_time_offset(Command):
1647
967
    """Show the offset in seconds from GMT to local time."""
1648
968
    hidden = True    
1649
 
    @display_command
1650
969
    def run(self):
1651
 
        print osutils.local_time_offset()
 
970
        print bzrlib.osutils.local_time_offset()
1652
971
 
1653
972
 
1654
973
 
1667
986
    """
1668
987
    # TODO: Run hooks on tree to-be-committed, and after commit.
1669
988
 
1670
 
    # TODO: Strict commit that fails if there are deleted files.
1671
 
    #       (what does "deleted files" mean ??)
1672
 
 
 
989
    # TODO: Strict commit that fails if there are unknown or deleted files.
1673
990
    # TODO: Give better message for -s, --summary, used by tla people
1674
991
 
1675
992
    # XXX: verbose currently does nothing
1676
993
 
1677
994
    takes_args = ['selected*']
1678
 
    takes_options = ['message', 'verbose', 
1679
 
                     Option('unchanged',
1680
 
                            help='commit even if nothing has changed'),
1681
 
                     Option('file', type=str, 
1682
 
                            argname='msgfile',
1683
 
                            help='file containing commit message'),
1684
 
                     Option('strict',
1685
 
                            help="refuse to commit if there are unknown "
1686
 
                            "files in the working tree."),
1687
 
                     Option('local',
1688
 
                            help="perform a local only commit in a bound "
1689
 
                                 "branch. Such commits are not pushed to "
1690
 
                                 "the master branch until a normal commit "
1691
 
                                 "is performed."
1692
 
                            ),
 
995
    takes_options = ['message', 'verbose', 'unchanged',
 
996
                     Option('file', type=str, help='file containing commit message'),
1693
997
                     ]
1694
998
    aliases = ['ci', 'checkin']
1695
999
 
1696
1000
    def run(self, message=None, file=None, verbose=True, selected_list=None,
1697
 
            unchanged=False, strict=False, local=False):
1698
 
        from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1699
 
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1700
 
                StrictCommitFailed)
1701
 
        from bzrlib.msgeditor import edit_commit_message, \
1702
 
                make_commit_message_template
1703
 
        from tempfile import TemporaryFile
1704
 
 
1705
 
        # TODO: Need a blackbox test for invoking the external editor; may be
1706
 
        # slightly problematic to run this cross-platform.
1707
 
 
1708
 
        # TODO: do more checks that the commit will succeed before 
1709
 
        # spending the user's valuable time typing a commit message.
1710
 
        #
1711
 
        # TODO: if the commit *does* happen to fail, then save the commit 
1712
 
        # message to a temporary file where it can be recovered
1713
 
        tree, selected_list = tree_files(selected_list)
1714
 
        if selected_list == ['']:
1715
 
            # workaround - commit of root of tree should be exactly the same
1716
 
            # as just default commit in that tree, and succeed even though
1717
 
            # selected-file merge commit is not done yet
1718
 
            selected_list = []
1719
 
 
1720
 
        if local and not tree.branch.get_bound_location():
1721
 
            raise errors.LocalRequiresBoundBranch()
 
1001
            unchanged=False):
 
1002
        from bzrlib.errors import PointlessCommit, ConflictsInTree
 
1003
        from bzrlib.msgeditor import edit_commit_message
 
1004
        from bzrlib.status import show_status
 
1005
        from cStringIO import StringIO
 
1006
 
 
1007
        b = Branch.open_containing('.')
 
1008
        if selected_list:
 
1009
            selected_list = [b.relpath(s) for s in selected_list]
 
1010
 
1722
1011
        if message is None and not file:
1723
 
            template = make_commit_message_template(tree, selected_list)
1724
 
            message = edit_commit_message(template)
 
1012
            catcher = StringIO()
 
1013
            show_status(b, specific_files=selected_list,
 
1014
                        to_file=catcher)
 
1015
            message = edit_commit_message(catcher.getvalue())
 
1016
 
1725
1017
            if message is None:
1726
1018
                raise BzrCommandError("please specify a commit message"
1727
1019
                                      " with either --message or --file")
1729
1021
            raise BzrCommandError("please specify either --message or --file")
1730
1022
        
1731
1023
        if file:
 
1024
            import codecs
1732
1025
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1733
1026
 
1734
1027
        if message == "":
1735
 
            raise BzrCommandError("empty commit message specified")
1736
 
        
1737
 
        if verbose:
1738
 
            reporter = ReportCommitToLog()
1739
 
        else:
1740
 
            reporter = NullCommitReporter()
1741
 
        
 
1028
                raise BzrCommandError("empty commit message specified")
 
1029
            
1742
1030
        try:
1743
 
            tree.commit(message, specific_files=selected_list,
1744
 
                        allow_pointless=unchanged, strict=strict, local=local,
1745
 
                        reporter=reporter)
 
1031
            b.commit(message,
 
1032
                     specific_files=selected_list,
 
1033
                     allow_pointless=unchanged)
1746
1034
        except PointlessCommit:
1747
1035
            # FIXME: This should really happen before the file is read in;
1748
1036
            # perhaps prepare the commit; get the message; then actually commit
1749
 
            raise BzrCommandError("no changes to commit."
1750
 
                                  " use --unchanged to commit anyhow")
 
1037
            raise BzrCommandError("no changes to commit",
 
1038
                                  ["use --unchanged to commit anyhow"])
1751
1039
        except ConflictsInTree:
1752
1040
            raise BzrCommandError("Conflicts detected in working tree.  "
1753
1041
                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1754
 
        except StrictCommitFailed:
1755
 
            raise BzrCommandError("Commit refused because there are unknown "
1756
 
                                  "files in the working tree.")
1757
 
        except errors.BoundBranchOutOfDate, e:
1758
 
            raise BzrCommandError(str(e)
1759
 
                                  + ' Either unbind, update, or'
1760
 
                                    ' pass --local to commit.')
1761
1042
 
1762
1043
 
1763
1044
class cmd_check(Command):
1766
1047
    This command checks various invariants about the branch storage to
1767
1048
    detect data corruption or bzr bugs.
1768
1049
    """
1769
 
    takes_args = ['branch?']
1770
 
    takes_options = ['verbose']
 
1050
    takes_args = ['dir?']
1771
1051
 
1772
 
    def run(self, branch=None, verbose=False):
 
1052
    def run(self, dir='.'):
1773
1053
        from bzrlib.check import check
1774
 
        if branch is None:
1775
 
            tree = WorkingTree.open_containing()[0]
1776
 
            branch = tree.branch
1777
 
        else:
1778
 
            branch = Branch.open(branch)
1779
 
        check(branch, verbose)
 
1054
 
 
1055
        check(Branch.open_containing(dir))
1780
1056
 
1781
1057
 
1782
1058
class cmd_scan_cache(Command):
1784
1060
    def run(self):
1785
1061
        from bzrlib.hashcache import HashCache
1786
1062
 
1787
 
        c = HashCache(u'.')
 
1063
        c = HashCache('.')
1788
1064
        c.read()
1789
1065
        c.scan()
1790
1066
            
1796
1072
 
1797
1073
        if c.needs_write:
1798
1074
            c.write()
 
1075
            
1799
1076
 
1800
1077
 
1801
1078
class cmd_upgrade(Command):
1802
1079
    """Upgrade branch storage to current format.
1803
1080
 
1804
1081
    The check command or bzr developers may sometimes advise you to run
1805
 
    this command. When the default format has changed you may also be warned
1806
 
    during other operations to upgrade.
 
1082
    this command.
 
1083
 
 
1084
    This version of this command upgrades from the full-text storage
 
1085
    used by bzr 0.0.8 and earlier to the weave format (v5).
1807
1086
    """
1808
 
    takes_args = ['url?']
1809
 
    takes_options = [
1810
 
                     Option('format', 
1811
 
                            help='Upgrade to a specific format. Current formats'
1812
 
                                 ' are: default, knit, metaweave and weave.'
1813
 
                                 ' Default is knit; metaweave and weave are'
1814
 
                                 ' deprecated',
1815
 
                            type=get_format_type),
1816
 
                    ]
1817
 
 
1818
 
 
1819
 
    def run(self, url='.', format=None):
 
1087
    takes_args = ['dir?']
 
1088
 
 
1089
    def run(self, dir='.'):
1820
1090
        from bzrlib.upgrade import upgrade
1821
 
        if format is None:
1822
 
            format = get_format_type('default')
1823
 
        upgrade(url, format)
 
1091
        upgrade(dir)
1824
1092
 
1825
1093
 
1826
1094
class cmd_whoami(Command):
1827
 
    """Show or set bzr user id.
1828
 
    
1829
 
    examples:
1830
 
        bzr whoami --email
1831
 
        bzr whoami 'Frank Chu <fchu@example.com>'
1832
 
    """
1833
 
    takes_options = [ Option('email',
1834
 
                             help='display email address only'),
1835
 
                      Option('branch',
1836
 
                             help='set identity for the current branch instead of '
1837
 
                                  'globally'),
1838
 
                    ]
1839
 
    takes_args = ['name?']
1840
 
    encoding_type = 'replace'
1841
 
    
1842
 
    @display_command
1843
 
    def run(self, email=False, branch=False, name=None):
1844
 
        if name is None:
1845
 
            # use branch if we're inside one; otherwise global config
1846
 
            try:
1847
 
                c = Branch.open_containing('.')[0].get_config()
1848
 
            except NotBranchError:
1849
 
                c = config.GlobalConfig()
1850
 
            if email:
1851
 
                self.outf.write(c.user_email() + '\n')
1852
 
            else:
1853
 
                self.outf.write(c.username() + '\n')
1854
 
            return
1855
 
 
1856
 
        # display a warning if an email address isn't included in the given name.
 
1095
    """Show bzr user id."""
 
1096
    takes_options = ['email']
 
1097
    
 
1098
    def run(self, email=False):
1857
1099
        try:
1858
 
            config.extract_email_address(name)
1859
 
        except BzrError, e:
1860
 
            warning('"%s" does not seem to contain an email address.  '
1861
 
                    'This is allowed, but not recommended.', name)
 
1100
            b = bzrlib.branch.Branch.open_containing('.')
 
1101
        except NotBranchError:
 
1102
            b = None
1862
1103
        
1863
 
        # use global config unless --branch given
1864
 
        if branch:
1865
 
            c = Branch.open_containing('.')[0].get_config()
1866
 
        else:
1867
 
            c = config.GlobalConfig()
1868
 
        c.set_user_option('email', name)
1869
 
 
1870
 
 
1871
 
class cmd_nick(Command):
1872
 
    """Print or set the branch nickname.  
1873
 
 
1874
 
    If unset, the tree root directory name is used as the nickname
1875
 
    To print the current nickname, execute with no argument.  
1876
 
    """
1877
 
    takes_args = ['nickname?']
1878
 
    def run(self, nickname=None):
1879
 
        branch = Branch.open_containing(u'.')[0]
1880
 
        if nickname is None:
1881
 
            self.printme(branch)
1882
 
        else:
1883
 
            branch.nick = nickname
1884
 
 
1885
 
    @display_command
1886
 
    def printme(self, branch):
1887
 
        print branch.nick 
 
1104
        if email:
 
1105
            print bzrlib.config.user_email(b)
 
1106
        else:
 
1107
            print bzrlib.config.username(b)
1888
1108
 
1889
1109
 
1890
1110
class cmd_selftest(Command):
1893
1113
    This creates temporary test directories in the working directory,
1894
1114
    but not existing data is affected.  These directories are deleted
1895
1115
    if the tests pass, or left behind to help in debugging if they
1896
 
    fail and --keep-output is specified.
 
1116
    fail.
1897
1117
    
1898
1118
    If arguments are given, they are regular expressions that say
1899
 
    which tests should run.
1900
 
 
1901
 
    If the global option '--no-plugins' is given, plugins are not loaded
1902
 
    before running the selftests.  This has two effects: features provided or
1903
 
    modified by plugins will not be tested, and tests provided by plugins will
1904
 
    not be run.
1905
 
 
1906
 
    examples:
1907
 
        bzr selftest ignore
1908
 
        bzr --no-plugins selftest -v
1909
 
    """
 
1119
    which tests should run."""
1910
1120
    # TODO: --list should give a list of all available tests
1911
 
 
1912
 
    # NB: this is used from the class without creating an instance, which is
1913
 
    # why it does not have a self parameter.
1914
 
    def get_transport_type(typestring):
1915
 
        """Parse and return a transport specifier."""
1916
 
        if typestring == "sftp":
1917
 
            from bzrlib.transport.sftp import SFTPAbsoluteServer
1918
 
            return SFTPAbsoluteServer
1919
 
        if typestring == "memory":
1920
 
            from bzrlib.transport.memory import MemoryServer
1921
 
            return MemoryServer
1922
 
        if typestring == "fakenfs":
1923
 
            from bzrlib.transport.fakenfs import FakeNFSServer
1924
 
            return FakeNFSServer
1925
 
        msg = "No known transport type %s. Supported types are: sftp\n" %\
1926
 
            (typestring)
1927
 
        raise BzrCommandError(msg)
1928
 
 
1929
1121
    hidden = True
1930
1122
    takes_args = ['testspecs*']
1931
 
    takes_options = ['verbose',
1932
 
                     Option('one', help='stop when one test fails'),
1933
 
                     Option('keep-output', 
1934
 
                            help='keep output directories when tests fail'),
1935
 
                     Option('transport', 
1936
 
                            help='Use a different transport by default '
1937
 
                                 'throughout the test suite.',
1938
 
                            type=get_transport_type),
1939
 
                     Option('benchmark', help='run the bzr bencharks.'),
1940
 
                     Option('lsprof-timed',
1941
 
                            help='generate lsprof output for benchmarked'
1942
 
                                 ' sections of code.'),
1943
 
                     ]
1944
 
 
1945
 
    def run(self, testspecs_list=None, verbose=None, one=False,
1946
 
            keep_output=False, transport=None, benchmark=None,
1947
 
            lsprof_timed=None):
 
1123
    takes_options = ['verbose']
 
1124
    def run(self, testspecs_list=None, verbose=False):
1948
1125
        import bzrlib.ui
1949
 
        from bzrlib.tests import selftest
1950
 
        import bzrlib.benchmarks as benchmarks
 
1126
        from bzrlib.selftest import selftest
1951
1127
        # we don't want progress meters from the tests to go to the
1952
1128
        # real output; and we don't want log messages cluttering up
1953
1129
        # the real logs.
1954
 
        save_ui = ui.ui_factory
1955
 
        print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1956
 
        print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1957
 
        print
1958
 
        info('running tests...')
 
1130
        save_ui = bzrlib.ui.ui_factory
 
1131
        bzrlib.trace.info('running tests...')
1959
1132
        try:
1960
 
            ui.ui_factory = ui.SilentUIFactory()
 
1133
            bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1961
1134
            if testspecs_list is not None:
1962
1135
                pattern = '|'.join(testspecs_list)
1963
1136
            else:
1964
1137
                pattern = ".*"
1965
 
            if benchmark:
1966
 
                test_suite_factory = benchmarks.test_suite
1967
 
                if verbose is None:
1968
 
                    verbose = True
1969
 
            else:
1970
 
                test_suite_factory = None
1971
 
                if verbose is None:
1972
 
                    verbose = False
1973
1138
            result = selftest(verbose=verbose, 
1974
 
                              pattern=pattern,
1975
 
                              stop_on_failure=one, 
1976
 
                              keep_output=keep_output,
1977
 
                              transport=transport,
1978
 
                              test_suite_factory=test_suite_factory,
1979
 
                              lsprof_timed=lsprof_timed)
 
1139
                              pattern=pattern)
1980
1140
            if result:
1981
 
                info('tests passed')
 
1141
                bzrlib.trace.info('tests passed')
1982
1142
            else:
1983
 
                info('tests failed')
 
1143
                bzrlib.trace.info('tests failed')
1984
1144
            return int(not result)
1985
1145
        finally:
1986
 
            ui.ui_factory = save_ui
1987
 
 
1988
 
 
1989
 
def _get_bzr_branch():
1990
 
    """If bzr is run from a branch, return Branch or None"""
1991
 
    from os.path import dirname
1992
 
    
1993
 
    try:
1994
 
        branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1995
 
        return branch
1996
 
    except errors.BzrError:
1997
 
        return None
1998
 
    
 
1146
            bzrlib.ui.ui_factory = save_ui
 
1147
 
1999
1148
 
2000
1149
def show_version():
2001
 
    import bzrlib
2002
1150
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
2003
1151
    # is bzrlib itself in a branch?
2004
 
    branch = _get_bzr_branch()
2005
 
    if branch:
2006
 
        rh = branch.revision_history()
2007
 
        revno = len(rh)
2008
 
        print "  bzr checkout, revision %d" % (revno,)
2009
 
        print "  nick: %s" % (branch.nick,)
2010
 
        if rh:
2011
 
            print "  revid: %s" % (rh[-1],)
2012
 
    print "Using python interpreter:", sys.executable
2013
 
    import site
2014
 
    print "Using python standard library:", os.path.dirname(site.__file__)
2015
 
    print "Using bzrlib:",
2016
 
    if len(bzrlib.__path__) > 1:
2017
 
        # print repr, which is a good enough way of making it clear it's
2018
 
        # more than one element (eg ['/foo/bar', '/foo/bzr'])
2019
 
        print repr(bzrlib.__path__)
2020
 
    else:
2021
 
        print bzrlib.__path__[0]
2022
 
 
2023
 
    print
 
1152
    bzrrev = bzrlib.get_bzr_revision()
 
1153
    if bzrrev:
 
1154
        print "  (bzr checkout, revision %d {%s})" % bzrrev
2024
1155
    print bzrlib.__copyright__
2025
 
    print "http://bazaar-vcs.org/"
 
1156
    print "http://bazaar-ng.org/"
2026
1157
    print
2027
1158
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
2028
1159
    print "you may use, modify and redistribute it under the terms of the GNU"
2031
1162
 
2032
1163
class cmd_version(Command):
2033
1164
    """Show version of bzr."""
2034
 
 
2035
 
    @display_command
2036
1165
    def run(self):
2037
1166
        show_version()
2038
1167
 
2039
 
 
2040
1168
class cmd_rocks(Command):
2041
1169
    """Statement of optimism."""
2042
 
 
2043
1170
    hidden = True
2044
 
 
2045
 
    @display_command
2046
1171
    def run(self):
2047
1172
        print "it sure does!"
2048
1173
 
2049
1174
 
2050
1175
class cmd_find_merge_base(Command):
2051
 
    """Find and print a base revision for merging two branches."""
 
1176
    """Find and print a base revision for merging two branches.
 
1177
    """
2052
1178
    # TODO: Options to specify revisions on either side, as if
2053
1179
    #       merging only part of the history.
2054
1180
    takes_args = ['branch', 'other']
2055
1181
    hidden = True
2056
1182
    
2057
 
    @display_command
2058
1183
    def run(self, branch, other):
2059
1184
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
2060
1185
        
2061
 
        branch1 = Branch.open_containing(branch)[0]
2062
 
        branch2 = Branch.open_containing(other)[0]
 
1186
        branch1 = Branch.open_containing(branch)
 
1187
        branch2 = Branch.open_containing(other)
2063
1188
 
2064
1189
        history_1 = branch1.revision_history()
2065
1190
        history_2 = branch2.revision_history()
2067
1192
        last1 = branch1.last_revision()
2068
1193
        last2 = branch2.last_revision()
2069
1194
 
2070
 
        source = MultipleRevisionSources(branch1.repository, 
2071
 
                                         branch2.repository)
 
1195
        source = MultipleRevisionSources(branch1, branch2)
2072
1196
        
2073
1197
        base_rev_id = common_ancestor(last1, last2, source)
2074
1198
 
2075
1199
        print 'merge base is revision %s' % base_rev_id
 
1200
        
 
1201
        return
 
1202
 
 
1203
        if base_revno is None:
 
1204
            raise bzrlib.errors.UnrelatedBranches()
 
1205
 
 
1206
        print ' r%-6d in %s' % (base_revno, branch)
 
1207
 
 
1208
        other_revno = branch2.revision_id_to_revno(base_revid)
 
1209
        
 
1210
        print ' r%-6d in %s' % (other_revno, other)
 
1211
 
2076
1212
 
2077
1213
 
2078
1214
class cmd_merge(Command):
2079
1215
    """Perform a three-way merge.
2080
1216
    
2081
 
    The branch is the branch you will merge from.  By default, it will merge
2082
 
    the latest revision.  If you specify a revision, that revision will be
2083
 
    merged.  If you specify two revisions, the first will be used as a BASE,
2084
 
    and the second one as OTHER.  Revision numbers are always relative to the
2085
 
    specified branch.
 
1217
    The branch is the branch you will merge from.  By default, it will
 
1218
    merge the latest revision.  If you specify a revision, that
 
1219
    revision will be merged.  If you specify two revisions, the first
 
1220
    will be used as a BASE, and the second one as OTHER.  Revision
 
1221
    numbers are always relative to the specified branch.
2086
1222
 
2087
 
    By default, bzr will try to merge in all new work from the other
 
1223
    By default bzr will try to merge in all new work from the other
2088
1224
    branch, automatically determining an appropriate base.  If this
2089
1225
    fails, you may need to give an explicit base.
2090
1226
    
2091
 
    Merge will do its best to combine the changes in two branches, but there
2092
 
    are some kinds of problems only a human can fix.  When it encounters those,
2093
 
    it will mark a conflict.  A conflict means that you need to fix something,
2094
 
    before you should commit.
2095
 
 
2096
 
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
2097
 
 
2098
 
    If there is no default branch set, the first merge will set it. After
2099
 
    that, you can omit the branch to use the default.  To change the
2100
 
    default, use --remember. The value will only be saved if the remote
2101
 
    location can be accessed.
2102
 
 
2103
1227
    Examples:
2104
1228
 
2105
1229
    To merge the latest revision from bzr.dev
2113
1237
    
2114
1238
    merge refuses to run if there are any uncommitted changes, unless
2115
1239
    --force is given.
2116
 
 
2117
 
    The following merge types are available:
2118
1240
    """
2119
1241
    takes_args = ['branch?']
2120
 
    takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2121
 
                     Option('show-base', help="Show base revision text in "
2122
 
                            "conflicts")]
2123
 
 
2124
 
    def help(self):
2125
 
        from merge import merge_type_help
2126
 
        from inspect import getdoc
2127
 
        return getdoc(self) + '\n' + merge_type_help() 
2128
 
 
2129
 
    def run(self, branch=None, revision=None, force=False, merge_type=None,
2130
 
            show_base=False, reprocess=False, remember=False):
 
1242
    takes_options = ['revision', 'force', 'merge-type']
 
1243
 
 
1244
    def run(self, branch=None, revision=None, force=False, 
 
1245
            merge_type=None):
 
1246
        from bzrlib.merge import merge
 
1247
        from bzrlib.merge_core import ApplyMerge3
2131
1248
        if merge_type is None:
2132
 
            merge_type = Merge3Merger
2133
 
 
2134
 
        tree = WorkingTree.open_containing(u'.')[0]
2135
 
 
2136
 
        if branch is not None:
2137
 
            try:
2138
 
                reader = bundle.read_bundle_from_url(branch)
2139
 
            except NotABundle:
2140
 
                pass # Continue on considering this url a Branch
 
1249
            merge_type = ApplyMerge3
 
1250
        if branch is None:
 
1251
            branch = Branch.open_containing('.').get_parent()
 
1252
            if branch is None:
 
1253
                raise BzrCommandError("No merge location known or specified.")
2141
1254
            else:
2142
 
                conflicts = merge_bundle(reader, tree, not force, merge_type,
2143
 
                                            reprocess, show_base)
2144
 
                if conflicts == 0:
2145
 
                    return 0
2146
 
                else:
2147
 
                    return 1
2148
 
 
2149
 
        branch = self._get_remembered_parent(tree, branch, 'Merging from')
2150
 
 
 
1255
                print "Using saved location: %s" % branch 
2151
1256
        if revision is None or len(revision) < 1:
2152
1257
            base = [None, None]
2153
1258
            other = [branch, -1]
2154
 
            other_branch, path = Branch.open_containing(branch)
2155
1259
        else:
2156
1260
            if len(revision) == 1:
2157
1261
                base = [None, None]
2158
 
                other_branch, path = Branch.open_containing(branch)
2159
 
                revno = revision[0].in_history(other_branch).revno
2160
 
                other = [branch, revno]
 
1262
                other = [branch, revision[0].in_history(branch).revno]
2161
1263
            else:
2162
1264
                assert len(revision) == 2
2163
1265
                if None in revision:
2164
1266
                    raise BzrCommandError(
2165
1267
                        "Merge doesn't permit that revision specifier.")
2166
 
                other_branch, path = Branch.open_containing(branch)
2167
 
 
2168
 
                base = [branch, revision[0].in_history(other_branch).revno]
2169
 
                other = [branch, revision[1].in_history(other_branch).revno]
2170
 
 
2171
 
        if tree.branch.get_parent() is None or remember:
2172
 
            tree.branch.set_parent(other_branch.base)
2173
 
 
2174
 
        if path != "":
2175
 
            interesting_files = [path]
2176
 
        else:
2177
 
            interesting_files = None
2178
 
        pb = ui.ui_factory.nested_progress_bar()
 
1268
                b = Branch.open(branch)
 
1269
 
 
1270
                base = [branch, revision[0].in_history(b).revno]
 
1271
                other = [branch, revision[1].in_history(b).revno]
 
1272
 
2179
1273
        try:
2180
 
            try:
2181
 
                conflict_count = merge(other, base, check_clean=(not force),
2182
 
                                       merge_type=merge_type,
2183
 
                                       reprocess=reprocess,
2184
 
                                       show_base=show_base,
2185
 
                                       pb=pb, file_list=interesting_files)
2186
 
            finally:
2187
 
                pb.finished()
2188
 
            if conflict_count != 0:
2189
 
                return 1
2190
 
            else:
2191
 
                return 0
2192
 
        except errors.AmbiguousBase, e:
 
1274
            merge(other, base, check_clean=(not force), merge_type=merge_type)
 
1275
        except bzrlib.errors.AmbiguousBase, e:
2193
1276
            m = ("sorry, bzr can't determine the right merge base yet\n"
2194
1277
                 "candidates are:\n  "
2195
1278
                 + "\n  ".join(e.bases)
2198
1281
                 "and (if you want) report this to the bzr developers\n")
2199
1282
            log_error(m)
2200
1283
 
2201
 
    # TODO: move up to common parent; this isn't merge-specific anymore. 
2202
 
    def _get_remembered_parent(self, tree, supplied_location, verb_string):
2203
 
        """Use tree.branch's parent if none was supplied.
2204
 
 
2205
 
        Report if the remembered location was used.
2206
 
        """
2207
 
        if supplied_location is not None:
2208
 
            return supplied_location
2209
 
        stored_location = tree.branch.get_parent()
2210
 
        mutter("%s", stored_location)
2211
 
        if stored_location is None:
2212
 
            raise BzrCommandError("No location specified or remembered")
2213
 
        display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2214
 
        self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2215
 
        return stored_location
2216
 
 
2217
 
 
2218
 
class cmd_remerge(Command):
2219
 
    """Redo a merge.
2220
 
 
2221
 
    Use this if you want to try a different merge technique while resolving
2222
 
    conflicts.  Some merge techniques are better than others, and remerge 
2223
 
    lets you try different ones on different files.
2224
 
 
2225
 
    The options for remerge have the same meaning and defaults as the ones for
2226
 
    merge.  The difference is that remerge can (only) be run when there is a
2227
 
    pending merge, and it lets you specify particular files.
2228
 
 
2229
 
    Examples:
2230
 
    $ bzr remerge --show-base
2231
 
        Re-do the merge of all conflicted files, and show the base text in
2232
 
        conflict regions, in addition to the usual THIS and OTHER texts.
2233
 
 
2234
 
    $ bzr remerge --merge-type weave --reprocess foobar
2235
 
        Re-do the merge of "foobar", using the weave merge algorithm, with
2236
 
        additional processing to reduce the size of conflict regions.
2237
 
    
2238
 
    The following merge types are available:"""
2239
 
    takes_args = ['file*']
2240
 
    takes_options = ['merge-type', 'reprocess',
2241
 
                     Option('show-base', help="Show base revision text in "
2242
 
                            "conflicts")]
2243
 
 
2244
 
    def help(self):
2245
 
        from merge import merge_type_help
2246
 
        from inspect import getdoc
2247
 
        return getdoc(self) + '\n' + merge_type_help() 
2248
 
 
2249
 
    def run(self, file_list=None, merge_type=None, show_base=False,
2250
 
            reprocess=False):
2251
 
        from bzrlib.merge import merge_inner, transform_tree
2252
 
        if merge_type is None:
2253
 
            merge_type = Merge3Merger
2254
 
        tree, file_list = tree_files(file_list)
2255
 
        tree.lock_write()
2256
 
        try:
2257
 
            pending_merges = tree.pending_merges() 
2258
 
            if len(pending_merges) != 1:
2259
 
                raise BzrCommandError("Sorry, remerge only works after normal"
2260
 
                                      " merges.  Not cherrypicking or"
2261
 
                                      " multi-merges.")
2262
 
            repository = tree.branch.repository
2263
 
            base_revision = common_ancestor(tree.branch.last_revision(), 
2264
 
                                            pending_merges[0], repository)
2265
 
            base_tree = repository.revision_tree(base_revision)
2266
 
            other_tree = repository.revision_tree(pending_merges[0])
2267
 
            interesting_ids = None
2268
 
            new_conflicts = []
2269
 
            conflicts = tree.conflicts()
2270
 
            if file_list is not None:
2271
 
                interesting_ids = set()
2272
 
                for filename in file_list:
2273
 
                    file_id = tree.path2id(filename)
2274
 
                    if file_id is None:
2275
 
                        raise NotVersionedError(filename)
2276
 
                    interesting_ids.add(file_id)
2277
 
                    if tree.kind(file_id) != "directory":
2278
 
                        continue
2279
 
                    
2280
 
                    for name, ie in tree.inventory.iter_entries(file_id):
2281
 
                        interesting_ids.add(ie.file_id)
2282
 
                new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2283
 
            transform_tree(tree, tree.basis_tree(), interesting_ids)
2284
 
            tree.set_conflicts(ConflictList(new_conflicts))
2285
 
            if file_list is None:
2286
 
                restore_files = list(tree.iter_conflicts())
2287
 
            else:
2288
 
                restore_files = file_list
2289
 
            for filename in restore_files:
2290
 
                try:
2291
 
                    restore(tree.abspath(filename))
2292
 
                except NotConflicted:
2293
 
                    pass
2294
 
            conflicts = merge_inner(tree.branch, other_tree, base_tree,
2295
 
                                    this_tree=tree,
2296
 
                                    interesting_ids=interesting_ids, 
2297
 
                                    other_rev_id=pending_merges[0], 
2298
 
                                    merge_type=merge_type, 
2299
 
                                    show_base=show_base,
2300
 
                                    reprocess=reprocess)
2301
 
        finally:
2302
 
            tree.unlock()
2303
 
        if conflicts > 0:
2304
 
            return 1
2305
 
        else:
2306
 
            return 0
2307
1284
 
2308
1285
class cmd_revert(Command):
2309
1286
    """Reverse all changes since the last commit.
2317
1294
    aliases = ['merge-revert']
2318
1295
 
2319
1296
    def run(self, revision=None, no_backup=False, file_list=None):
 
1297
        from bzrlib.merge import merge
2320
1298
        from bzrlib.commands import parse_spec
 
1299
 
2321
1300
        if file_list is not None:
2322
1301
            if len(file_list) == 0:
2323
1302
                raise BzrCommandError("No files specified")
2324
 
        else:
2325
 
            file_list = []
2326
 
        
2327
 
        tree, file_list = tree_files(file_list)
2328
1303
        if revision is None:
2329
 
            # FIXME should be tree.last_revision
2330
 
            rev_id = tree.last_revision()
 
1304
            revno = -1
2331
1305
        elif len(revision) != 1:
2332
1306
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2333
1307
        else:
2334
 
            rev_id = revision[0].in_history(tree.branch).rev_id
2335
 
        pb = ui.ui_factory.nested_progress_bar()
2336
 
        try:
2337
 
            tree.revert(file_list, 
2338
 
                        tree.branch.repository.revision_tree(rev_id),
2339
 
                        not no_backup, pb)
2340
 
        finally:
2341
 
            pb.finished()
 
1308
            b = Branch.open_containing('.')
 
1309
            revno = revision[0].in_history(b).revno
 
1310
        merge(('.', revno), parse_spec('.'),
 
1311
              check_clean=False,
 
1312
              ignore_zero=True,
 
1313
              backup_files=not no_backup,
 
1314
              file_list=file_list)
 
1315
        if not file_list:
 
1316
            Branch.open_containing('.').set_pending_merges([])
2342
1317
 
2343
1318
 
2344
1319
class cmd_assert_fail(Command):
2352
1327
    """Show help on a command or other topic.
2353
1328
 
2354
1329
    For a list of all available commands, say 'bzr help commands'."""
2355
 
    takes_options = [Option('long', 'show help on all commands')]
 
1330
    takes_options = ['long']
2356
1331
    takes_args = ['topic?']
2357
 
    aliases = ['?', '--help', '-?', '-h']
 
1332
    aliases = ['?']
2358
1333
    
2359
 
    @display_command
2360
1334
    def run(self, topic=None, long=False):
2361
1335
        import help
2362
1336
        if topic is None and long:
2372
1346
    aliases = ['s-c']
2373
1347
    hidden = True
2374
1348
    
2375
 
    @display_command
2376
1349
    def run(self, context=None):
2377
1350
        import shellcomplete
2378
1351
        shellcomplete.shellcomplete(context)
2386
1359
    takes_args = ['from_branch', 'to_branch']
2387
1360
    def run(self, from_branch, to_branch):
2388
1361
        from bzrlib.fetch import Fetcher
2389
 
        from_b = Branch.open(from_branch)
2390
 
        to_b = Branch.open(to_branch)
 
1362
        from bzrlib.branch import Branch
 
1363
        from_b = Branch(from_branch)
 
1364
        to_b = Branch(to_branch)
2391
1365
        Fetcher(to_b, from_b)
 
1366
        
2392
1367
 
2393
1368
 
2394
1369
class cmd_missing(Command):
2395
 
    """Show unmerged/unpulled revisions between two branches.
2396
 
 
2397
 
    OTHER_BRANCH may be local or remote."""
2398
 
    takes_args = ['other_branch?']
2399
 
    takes_options = [Option('reverse', 'Reverse the order of revisions'),
2400
 
                     Option('mine-only', 
2401
 
                            'Display changes in the local branch only'),
2402
 
                     Option('theirs-only', 
2403
 
                            'Display changes in the remote branch only'), 
2404
 
                     'log-format',
2405
 
                     'line',
2406
 
                     'long', 
2407
 
                     'short',
2408
 
                     'show-ids',
2409
 
                     'verbose'
2410
 
                     ]
2411
 
    encoding_type = 'replace'
2412
 
 
2413
 
    @display_command
2414
 
    def run(self, other_branch=None, reverse=False, mine_only=False,
2415
 
            theirs_only=False, log_format=None, long=False, short=False, line=False, 
2416
 
            show_ids=False, verbose=False):
2417
 
        from bzrlib.missing import find_unmerged, iter_log_data
2418
 
        from bzrlib.log import log_formatter
2419
 
        local_branch = Branch.open_containing(u".")[0]
2420
 
        parent = local_branch.get_parent()
2421
 
        if other_branch is None:
2422
 
            other_branch = parent
2423
 
            if other_branch is None:
2424
 
                raise BzrCommandError("No peer location known or specified.")
2425
 
            print "Using last location: " + local_branch.get_parent()
2426
 
        remote_branch = Branch.open(other_branch)
2427
 
        if remote_branch.base == local_branch.base:
2428
 
            remote_branch = local_branch
2429
 
        local_branch.lock_read()
2430
 
        try:
2431
 
            remote_branch.lock_read()
2432
 
            try:
2433
 
                local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2434
 
                if (log_format == None):
2435
 
                    default = local_branch.get_config().log_format()
2436
 
                    log_format = get_log_format(long=long, short=short, 
2437
 
                                                line=line, default=default)
2438
 
                lf = log_formatter(log_format,
2439
 
                                   to_file=self.outf,
2440
 
                                   show_ids=show_ids,
2441
 
                                   show_timezone='original')
2442
 
                if reverse is False:
2443
 
                    local_extra.reverse()
2444
 
                    remote_extra.reverse()
2445
 
                if local_extra and not theirs_only:
2446
 
                    print "You have %d extra revision(s):" % len(local_extra)
2447
 
                    for data in iter_log_data(local_extra, local_branch.repository,
2448
 
                                              verbose):
2449
 
                        lf.show(*data)
2450
 
                    printed_local = True
2451
 
                else:
2452
 
                    printed_local = False
2453
 
                if remote_extra and not mine_only:
2454
 
                    if printed_local is True:
2455
 
                        print "\n\n"
2456
 
                    print "You are missing %d revision(s):" % len(remote_extra)
2457
 
                    for data in iter_log_data(remote_extra, remote_branch.repository, 
2458
 
                                              verbose):
2459
 
                        lf.show(*data)
2460
 
                if not remote_extra and not local_extra:
2461
 
                    status_code = 0
2462
 
                    print "Branches are up to date."
2463
 
                else:
2464
 
                    status_code = 1
2465
 
            finally:
2466
 
                remote_branch.unlock()
2467
 
        finally:
2468
 
            local_branch.unlock()
2469
 
        if not status_code and parent is None and other_branch is not None:
2470
 
            local_branch.lock_write()
2471
 
            try:
2472
 
                # handle race conditions - a parent might be set while we run.
2473
 
                if local_branch.get_parent() is None:
2474
 
                    local_branch.set_parent(remote_branch.base)
2475
 
            finally:
2476
 
                local_branch.unlock()
2477
 
        return status_code
 
1370
    """What is missing in this branch relative to other branch.
 
1371
    """
 
1372
    # TODO: rewrite this in terms of ancestry so that it shows only
 
1373
    # unmerged things
 
1374
    
 
1375
    takes_args = ['remote?']
 
1376
    aliases = ['mis', 'miss']
 
1377
    # We don't have to add quiet to the list, because 
 
1378
    # unknown options are parsed as booleans
 
1379
    takes_options = ['verbose', 'quiet']
 
1380
 
 
1381
    def run(self, remote=None, verbose=False, quiet=False):
 
1382
        from bzrlib.errors import BzrCommandError
 
1383
        from bzrlib.missing import show_missing
 
1384
 
 
1385
        if verbose and quiet:
 
1386
            raise BzrCommandError('Cannot pass both quiet and verbose')
 
1387
 
 
1388
        b = Branch.open_containing('.')
 
1389
        parent = b.get_parent()
 
1390
        if remote is None:
 
1391
            if parent is None:
 
1392
                raise BzrCommandError("No missing location known or specified.")
 
1393
            else:
 
1394
                if not quiet:
 
1395
                    print "Using last location: %s" % parent
 
1396
                remote = parent
 
1397
        elif parent is None:
 
1398
            # We only update parent if it did not exist, missing
 
1399
            # should not change the parent
 
1400
            b.set_parent(remote)
 
1401
        br_remote = Branch.open_containing(remote)
 
1402
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
2478
1403
 
2479
1404
 
2480
1405
class cmd_plugins(Command):
2481
1406
    """List plugins"""
2482
1407
    hidden = True
2483
 
    @display_command
2484
1408
    def run(self):
2485
1409
        import bzrlib.plugin
2486
1410
        from inspect import getdoc
2487
 
        for name, plugin in bzrlib.plugin.all_plugins().items():
 
1411
        for plugin in bzrlib.plugin.all_plugins:
2488
1412
            if hasattr(plugin, '__path__'):
2489
1413
                print plugin.__path__[0]
2490
1414
            elif hasattr(plugin, '__file__'):
2499
1423
 
2500
1424
class cmd_testament(Command):
2501
1425
    """Show testament (signing-form) of a revision."""
2502
 
    takes_options = ['revision', 'long', 
2503
 
                     Option('strict', help='Produce a strict-format'
2504
 
                            ' testament')]
 
1426
    takes_options = ['revision', 'long']
2505
1427
    takes_args = ['branch?']
2506
 
    @display_command
2507
 
    def run(self, branch=u'.', revision=None, long=False, strict=False):
2508
 
        from bzrlib.testament import Testament, StrictTestament
2509
 
        if strict is True:
2510
 
            testament_class = StrictTestament
2511
 
        else:
2512
 
            testament_class = Testament
2513
 
        b = WorkingTree.open_containing(branch)[0].branch
 
1428
    def run(self, branch='.', revision=None, long=False):
 
1429
        from bzrlib.testament import Testament
 
1430
        b = Branch.open_containing(branch)
2514
1431
        b.lock_read()
2515
1432
        try:
2516
1433
            if revision is None:
2517
1434
                rev_id = b.last_revision()
2518
1435
            else:
2519
1436
                rev_id = revision[0].in_history(b).rev_id
2520
 
            t = testament_class.from_revision(b.repository, rev_id)
 
1437
            t = Testament.from_revision(b, rev_id)
2521
1438
            if long:
2522
1439
                sys.stdout.writelines(t.as_text_lines())
2523
1440
            else:
2529
1446
class cmd_annotate(Command):
2530
1447
    """Show the origin of each line in a file.
2531
1448
 
2532
 
    This prints out the given file with an annotation on the left side
2533
 
    indicating which revision, author and date introduced the change.
2534
 
 
2535
 
    If the origin is the same for a run of consecutive lines, it is 
2536
 
    shown only at the top, unless the --all option is given.
 
1449
    This prints out the given file with an annotation on the 
 
1450
    left side indicating which revision, author and date introduced the 
 
1451
    change.
2537
1452
    """
2538
1453
    # TODO: annotate directories; showing when each file was last changed
2539
 
    # TODO: if the working copy is modified, show annotations on that 
2540
 
    #       with new uncommitted lines marked
2541
 
    aliases = ['ann', 'blame', 'praise']
 
1454
    # TODO: annotate a previous version of a file
 
1455
    aliases = ['blame', 'praise']
2542
1456
    takes_args = ['filename']
2543
 
    takes_options = [Option('all', help='show annotations on all lines'),
2544
 
                     Option('long', help='show date in annotations'),
2545
 
                     'revision'
2546
 
                     ]
2547
1457
 
2548
 
    @display_command
2549
 
    def run(self, filename, all=False, long=False, revision=None):
 
1458
    def run(self, filename):
2550
1459
        from bzrlib.annotate import annotate_file
2551
 
        tree, relpath = WorkingTree.open_containing(filename)
2552
 
        branch = tree.branch
2553
 
        branch.lock_read()
 
1460
        b = Branch.open_containing(filename)
 
1461
        b.lock_read()
2554
1462
        try:
2555
 
            if revision is None:
2556
 
                revision_id = branch.last_revision()
2557
 
            elif len(revision) != 1:
2558
 
                raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2559
 
            else:
2560
 
                revision_id = revision[0].in_history(branch).rev_id
2561
 
            file_id = tree.inventory.path2id(relpath)
2562
 
            tree = branch.repository.revision_tree(revision_id)
 
1463
            rp = b.relpath(filename)
 
1464
            tree = b.revision_tree(b.last_revision())
 
1465
            file_id = tree.inventory.path2id(rp)
2563
1466
            file_version = tree.inventory[file_id].revision
2564
 
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
 
1467
            annotate_file(b, file_version, file_id, sys.stdout)
2565
1468
        finally:
2566
 
            branch.unlock()
2567
 
 
2568
 
 
2569
 
class cmd_re_sign(Command):
2570
 
    """Create a digital signature for an existing revision."""
2571
 
    # TODO be able to replace existing ones.
2572
 
 
2573
 
    hidden = True # is this right ?
2574
 
    takes_args = ['revision_id*']
2575
 
    takes_options = ['revision']
2576
 
    
2577
 
    def run(self, revision_id_list=None, revision=None):
2578
 
        import bzrlib.gpg as gpg
2579
 
        if revision_id_list is not None and revision is not None:
2580
 
            raise BzrCommandError('You can only supply one of revision_id or --revision')
2581
 
        if revision_id_list is None and revision is None:
2582
 
            raise BzrCommandError('You must supply either --revision or a revision_id')
2583
 
        b = WorkingTree.open_containing(u'.')[0].branch
2584
 
        gpg_strategy = gpg.GPGStrategy(b.get_config())
2585
 
        if revision_id_list is not None:
2586
 
            for revision_id in revision_id_list:
2587
 
                b.repository.sign_revision(revision_id, gpg_strategy)
2588
 
        elif revision is not None:
2589
 
            if len(revision) == 1:
2590
 
                revno, rev_id = revision[0].in_history(b)
2591
 
                b.repository.sign_revision(rev_id, gpg_strategy)
2592
 
            elif len(revision) == 2:
2593
 
                # are they both on rh- if so we can walk between them
2594
 
                # might be nice to have a range helper for arbitrary
2595
 
                # revision paths. hmm.
2596
 
                from_revno, from_revid = revision[0].in_history(b)
2597
 
                to_revno, to_revid = revision[1].in_history(b)
2598
 
                if to_revid is None:
2599
 
                    to_revno = b.revno()
2600
 
                if from_revno is None or to_revno is None:
2601
 
                    raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2602
 
                for revno in range(from_revno, to_revno + 1):
2603
 
                    b.repository.sign_revision(b.get_rev_id(revno), 
2604
 
                                               gpg_strategy)
2605
 
            else:
2606
 
                raise BzrCommandError('Please supply either one revision, or a range.')
2607
 
 
2608
 
 
2609
 
class cmd_bind(Command):
2610
 
    """Bind the current branch to a master branch.
2611
 
 
2612
 
    After binding, commits must succeed on the master branch
2613
 
    before they are executed on the local one.
2614
 
    """
2615
 
 
2616
 
    takes_args = ['location']
2617
 
    takes_options = []
2618
 
 
2619
 
    def run(self, location=None):
2620
 
        b, relpath = Branch.open_containing(u'.')
2621
 
        b_other = Branch.open(location)
2622
 
        try:
2623
 
            b.bind(b_other)
2624
 
        except DivergedBranches:
2625
 
            raise BzrCommandError('These branches have diverged.'
2626
 
                                  ' Try merging, and then bind again.')
2627
 
 
2628
 
 
2629
 
class cmd_unbind(Command):
2630
 
    """Unbind the current branch from its master branch.
2631
 
 
2632
 
    After unbinding, the local branch is considered independent.
2633
 
    All subsequent commits will be local.
2634
 
    """
2635
 
 
2636
 
    takes_args = []
2637
 
    takes_options = []
2638
 
 
2639
 
    def run(self):
2640
 
        b, relpath = Branch.open_containing(u'.')
2641
 
        if not b.unbind():
2642
 
            raise BzrCommandError('Local branch is not bound')
2643
 
 
2644
 
 
2645
 
class cmd_uncommit(Command):
2646
 
    """Remove the last committed revision.
2647
 
 
2648
 
    --verbose will print out what is being removed.
2649
 
    --dry-run will go through all the motions, but not actually
2650
 
    remove anything.
2651
 
    
2652
 
    In the future, uncommit will create a revision bundle, which can then
2653
 
    be re-applied.
2654
 
    """
2655
 
 
2656
 
    # TODO: jam 20060108 Add an option to allow uncommit to remove
2657
 
    # unreferenced information in 'branch-as-repository' branches.
2658
 
    # TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2659
 
    # information in shared branches as well.
2660
 
    takes_options = ['verbose', 'revision',
2661
 
                    Option('dry-run', help='Don\'t actually make changes'),
2662
 
                    Option('force', help='Say yes to all questions.')]
2663
 
    takes_args = ['location?']
2664
 
    aliases = []
2665
 
 
2666
 
    def run(self, location=None,
2667
 
            dry_run=False, verbose=False,
2668
 
            revision=None, force=False):
2669
 
        from bzrlib.log import log_formatter, show_log
2670
 
        import sys
2671
 
        from bzrlib.uncommit import uncommit
2672
 
 
2673
 
        if location is None:
2674
 
            location = u'.'
2675
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
2676
 
        try:
2677
 
            tree = control.open_workingtree()
2678
 
            b = tree.branch
2679
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
2680
 
            tree = None
2681
 
            b = control.open_branch()
2682
 
 
2683
 
        rev_id = None
2684
 
        if revision is None:
2685
 
            revno = b.revno()
2686
 
        else:
2687
 
            # 'bzr uncommit -r 10' actually means uncommit
2688
 
            # so that the final tree is at revno 10.
2689
 
            # but bzrlib.uncommit.uncommit() actually uncommits
2690
 
            # the revisions that are supplied.
2691
 
            # So we need to offset it by one
2692
 
            revno = revision[0].in_history(b).revno+1
2693
 
 
2694
 
        if revno <= b.revno():
2695
 
            rev_id = b.get_rev_id(revno)
2696
 
        if rev_id is None:
2697
 
            self.outf.write('No revisions to uncommit.\n')
2698
 
            return 1
2699
 
 
2700
 
        lf = log_formatter('short',
2701
 
                           to_file=self.outf,
2702
 
                           show_timezone='original')
2703
 
 
2704
 
        show_log(b,
2705
 
                 lf,
2706
 
                 verbose=False,
2707
 
                 direction='forward',
2708
 
                 start_revision=revno,
2709
 
                 end_revision=b.revno())
2710
 
 
2711
 
        if dry_run:
2712
 
            print 'Dry-run, pretending to remove the above revisions.'
2713
 
            if not force:
2714
 
                val = raw_input('Press <enter> to continue')
2715
 
        else:
2716
 
            print 'The above revision(s) will be removed.'
2717
 
            if not force:
2718
 
                val = raw_input('Are you sure [y/N]? ')
2719
 
                if val.lower() not in ('y', 'yes'):
2720
 
                    print 'Canceled'
2721
 
                    return 0
2722
 
 
2723
 
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2724
 
                revno=revno)
2725
 
 
2726
 
 
2727
 
class cmd_break_lock(Command):
2728
 
    """Break a dead lock on a repository, branch or working directory.
2729
 
 
2730
 
    CAUTION: Locks should only be broken when you are sure that the process
2731
 
    holding the lock has been stopped.
2732
 
 
2733
 
    You can get information on what locks are open via the 'bzr info' command.
2734
 
    
2735
 
    example:
2736
 
        bzr break-lock
2737
 
    """
2738
 
    takes_args = ['location?']
2739
 
 
2740
 
    def run(self, location=None, show=False):
2741
 
        if location is None:
2742
 
            location = u'.'
2743
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
2744
 
        try:
2745
 
            control.break_lock()
2746
 
        except NotImplementedError:
2747
 
            pass
2748
 
        
2749
 
 
2750
 
 
2751
 
# command-line interpretation helper for merge-related commands
2752
 
def merge(other_revision, base_revision,
2753
 
          check_clean=True, ignore_zero=False,
2754
 
          this_dir=None, backup_files=False, merge_type=Merge3Merger,
2755
 
          file_list=None, show_base=False, reprocess=False,
2756
 
          pb=DummyProgress()):
2757
 
    """Merge changes into a tree.
2758
 
 
2759
 
    base_revision
2760
 
        list(path, revno) Base for three-way merge.  
2761
 
        If [None, None] then a base will be automatically determined.
2762
 
    other_revision
2763
 
        list(path, revno) Other revision for three-way merge.
2764
 
    this_dir
2765
 
        Directory to merge changes into; '.' by default.
2766
 
    check_clean
2767
 
        If true, this_dir must have no uncommitted changes before the
2768
 
        merge begins.
2769
 
    ignore_zero - If true, suppress the "zero conflicts" message when 
2770
 
        there are no conflicts; should be set when doing something we expect
2771
 
        to complete perfectly.
2772
 
    file_list - If supplied, merge only changes to selected files.
2773
 
 
2774
 
    All available ancestors of other_revision and base_revision are
2775
 
    automatically pulled into the branch.
2776
 
 
2777
 
    The revno may be -1 to indicate the last revision on the branch, which is
2778
 
    the typical case.
2779
 
 
2780
 
    This function is intended for use from the command line; programmatic
2781
 
    clients might prefer to call merge.merge_inner(), which has less magic 
2782
 
    behavior.
2783
 
    """
2784
 
    from bzrlib.merge import Merger
2785
 
    if this_dir is None:
2786
 
        this_dir = u'.'
2787
 
    this_tree = WorkingTree.open_containing(this_dir)[0]
2788
 
    if show_base and not merge_type is Merge3Merger:
2789
 
        raise BzrCommandError("Show-base is not supported for this merge"
2790
 
                              " type. %s" % merge_type)
2791
 
    if reprocess and not merge_type.supports_reprocess:
2792
 
        raise BzrCommandError("Conflict reduction is not supported for merge"
2793
 
                              " type %s." % merge_type)
2794
 
    if reprocess and show_base:
2795
 
        raise BzrCommandError("Cannot do conflict reduction and show base.")
2796
 
    try:
2797
 
        merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2798
 
        merger.pp = ProgressPhase("Merge phase", 5, pb)
2799
 
        merger.pp.next_phase()
2800
 
        merger.check_basis(check_clean)
2801
 
        merger.set_other(other_revision)
2802
 
        merger.pp.next_phase()
2803
 
        merger.set_base(base_revision)
2804
 
        if merger.base_rev_id == merger.other_rev_id:
2805
 
            note('Nothing to do.')
2806
 
            return 0
2807
 
        merger.backup_files = backup_files
2808
 
        merger.merge_type = merge_type 
2809
 
        merger.set_interesting_files(file_list)
2810
 
        merger.show_base = show_base 
2811
 
        merger.reprocess = reprocess
2812
 
        conflicts = merger.do_merge()
2813
 
        if file_list is None:
2814
 
            merger.set_pending()
2815
 
    finally:
2816
 
        pb.clear()
2817
 
    return conflicts
2818
 
 
 
1469
            b.unlock()
2819
1470
 
2820
1471
# these get imported and then picked up by the scan for cmd_*
2821
1472
# TODO: Some more consistent way to split command definitions across files;
2822
1473
# we do need to load at least some information about them to know of 
2823
 
# aliases.  ideally we would avoid loading the implementation until the
2824
 
# details were needed.
2825
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2826
 
from bzrlib.bundle.commands import cmd_bundle_revisions
2827
 
from bzrlib.sign_my_commits import cmd_sign_my_commits
2828
 
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2829
 
        cmd_weave_plan_merge, cmd_weave_merge_text
 
1474
# aliases.
 
1475
from bzrlib.conflicts import cmd_resolve, cmd_conflicts