← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2004, 2005, 2006 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
 
 
 
17
"""builtin bzr commands"""
 
18
 
 
19
 
 
20
import codecs
 
21
import errno
 
22
import os
 
23
import os.path
18
24
import sys
19
 
import os
20
25
 
21
26
import bzrlib
22
 
from bzrlib import BZRDIR
23
 
from bzrlib.commands import Command
24
 
from bzrlib.branch import Branch
25
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
26
 
from bzrlib.errors import DivergedBranches
 
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
27
51
from bzrlib.option import Option
 
52
from bzrlib.progress import DummyProgress, ProgressPhase
 
53
from bzrlib.revision import common_ancestor
28
54
from bzrlib.revisionspec import RevisionSpec
29
 
import bzrlib.trace
30
 
from bzrlib.trace import mutter, note, log_error, warning
 
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
 
56
from bzrlib.transport.local import LocalTransport
31
57
from bzrlib.workingtree import WorkingTree
32
58
 
33
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
 
34
121
class cmd_status(Command):
35
122
    """Display status summary.
36
123
 
52
139
    modified
53
140
        Text has changed since the previous revision.
54
141
 
55
 
    unchanged
56
 
        Nothing about this file has changed since the previous revision.
57
 
        Only shown with --all.
58
 
 
59
142
    unknown
60
143
        Not versioned and not matching an ignore pattern.
61
144
 
71
154
    that revision, or between two revisions if two are provided.
72
155
    """
73
156
    
74
 
    # XXX: FIXME: bzr status should accept a -r option to show changes
75
 
    # relative to a revision, or between revisions
76
 
 
77
157
    # TODO: --no-recurse, --recurse options
78
158
    
79
159
    takes_args = ['file*']
80
 
    takes_options = ['all', 'show-ids']
 
160
    takes_options = ['show-ids', 'revision']
81
161
    aliases = ['st', 'stat']
 
162
 
 
163
    encoding_type = 'replace'
82
164
    
83
 
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
84
 
        if file_list:
85
 
            b, relpath = Branch.open_containing(file_list[0])
86
 
            if relpath == '' and len(file_list) == 1:
87
 
                file_list = None
88
 
            else:
89
 
                # generate relative paths.
90
 
                # note that if this is a remote branch, we would want
91
 
                # relpath against the transport. RBC 20051018
92
 
                tree = WorkingTree(b.base, b)
93
 
                file_list = [tree.relpath(x) for x in file_list]
94
 
        else:
95
 
            b = Branch.open_containing('.')[0]
 
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)
96
170
            
97
 
        from bzrlib.status import show_status
98
 
        show_status(b, show_unchanged=all, show_ids=show_ids,
99
 
                    specific_files=file_list, revision=revision)
 
171
        show_tree_status(tree, show_ids=show_ids,
 
172
                         specific_files=file_list, revision=revision,
 
173
                         to_file=self.outf)
100
174
 
101
175
 
102
176
class cmd_cat_revision(Command):
109
183
    hidden = True
110
184
    takes_args = ['revision_id?']
111
185
    takes_options = ['revision']
 
186
    # cat-revision is more for frontends so should be exact
 
187
    encoding = 'strict'
112
188
    
 
189
    @display_command
113
190
    def run(self, revision_id=None, revision=None):
114
191
 
115
192
        if revision_id is not None and revision is not None:
116
193
            raise BzrCommandError('You can only supply one of revision_id or --revision')
117
194
        if revision_id is None and revision is None:
118
195
            raise BzrCommandError('You must supply either --revision or a revision_id')
119
 
        b = Branch.open_containing('.')[0]
 
196
        b = WorkingTree.open_containing(u'.')[0].branch
 
197
 
 
198
        # TODO: jam 20060112 should cat-revision always output utf-8?
120
199
        if revision_id is not None:
121
 
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
 
200
            self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
122
201
        elif revision is not None:
123
202
            for rev in revision:
124
203
                if rev is None:
125
204
                    raise BzrCommandError('You cannot specify a NULL revision.')
126
205
                revno, rev_id = rev.in_history(b)
127
 
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
 
206
                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
128
207
    
129
208
 
130
209
class cmd_revno(Command):
131
210
    """Show current revision number.
132
211
 
133
 
    This is equal to the number of revisions on this branch."""
134
 
    def run(self):
135
 
        print Branch.open_containing('.')[0].revno()
 
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')
136
221
 
137
222
 
138
223
class cmd_revision_info(Command):
141
226
    hidden = True
142
227
    takes_args = ['revision_info*']
143
228
    takes_options = ['revision']
 
229
 
 
230
    @display_command
144
231
    def run(self, revision=None, revision_info_list=[]):
145
232
 
146
233
        revs = []
152
239
        if len(revs) == 0:
153
240
            raise BzrCommandError('You must supply a revision identifier')
154
241
 
155
 
        b = Branch.open_containing('.')[0]
 
242
        b = WorkingTree.open_containing(u'.')[0].branch
156
243
 
157
244
        for rev in revs:
158
245
            revinfo = rev.in_history(b)
182
269
 
183
270
    Adding a file whose parent directory is not versioned will
184
271
    implicitly add the parent, and so on up to the root. This means
185
 
    you should never need to explictly add a directory, they'll just
 
272
    you should never need to explicitly add a directory, they'll just
186
273
    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.
187
277
    """
188
278
    takes_args = ['file*']
189
 
    takes_options = ['no-recurse', 'quiet']
190
 
    
191
 
    def run(self, file_list, no_recurse=False, quiet=False):
192
 
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
193
 
        if quiet:
194
 
            reporter = add_reporter_null
195
 
        else:
196
 
            reporter = add_reporter_print
197
 
        smart_add(file_list, not no_recurse, reporter)
 
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")
198
303
 
199
304
 
200
305
class cmd_mkdir(Command):
202
307
 
203
308
    This is equivalent to creating the directory and then adding it.
204
309
    """
 
310
 
205
311
    takes_args = ['dir+']
 
312
    encoding_type = 'replace'
206
313
 
207
314
    def run(self, dir_list):
208
 
        b = None
209
 
        
210
315
        for d in dir_list:
211
316
            os.mkdir(d)
212
 
            if not b:
213
 
                b = Branch.open_containing(d)[0]
214
 
            b.add([d])
215
 
            print 'added', d
 
317
            wt, dd = WorkingTree.open_containing(d)
 
318
            wt.add([dd])
 
319
            self.outf.write('added %s\n' % d)
216
320
 
217
321
 
218
322
class cmd_relpath(Command):
219
323
    """Show path of a file relative to root"""
 
324
 
220
325
    takes_args = ['filename']
221
326
    hidden = True
222
327
    
 
328
    @display_command
223
329
    def run(self, filename):
224
 
        branch, relpath = Branch.open_containing(filename)
225
 
        print relpath
 
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')
226
335
 
227
336
 
228
337
class cmd_inventory(Command):
229
 
    """Show inventory of the current working copy or a revision."""
230
 
    takes_options = ['revision', 'show-ids']
 
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']
231
345
    
232
 
    def run(self, revision=None, show_ids=False):
233
 
        b = Branch.open_containing('.')[0]
 
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]
234
351
        if revision is None:
235
 
            inv = b.read_working_inventory()
 
352
            inv = tree.read_working_inventory()
236
353
        else:
237
354
            if len(revision) > 1:
238
355
                raise BzrCommandError('bzr inventory --revision takes'
239
356
                    ' exactly one revision identifier')
240
 
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
 
357
            inv = tree.branch.repository.get_revision_inventory(
 
358
                revision[0].in_history(tree.branch).rev_id)
241
359
 
242
360
        for path, entry in inv.entries():
 
361
            if kind and kind != entry.kind:
 
362
                continue
243
363
            if show_ids:
244
 
                print '%-50s %s' % (path, entry.file_id)
 
364
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
245
365
            else:
246
 
                print path
247
 
 
248
 
 
249
 
class cmd_move(Command):
250
 
    """Move files to a different directory.
251
 
 
252
 
    examples:
253
 
        bzr move *.txt doc
254
 
 
255
 
    The destination must be a versioned directory in the same branch.
256
 
    """
257
 
    takes_args = ['source$', 'dest']
258
 
    def run(self, source_list, dest):
259
 
        b = Branch.open_containing('.')[0]
260
 
 
261
 
        # TODO: glob expansion on windows?
262
 
        tree = WorkingTree(b.base, b)
263
 
        b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
264
 
 
265
 
 
266
 
class cmd_rename(Command):
267
 
    """Change the name of an entry.
268
 
 
269
 
    examples:
270
 
      bzr rename frob.c frobber.c
271
 
      bzr rename src/frob.c lib/frob.c
272
 
 
273
 
    It is an error if the destination name exists.
274
 
 
275
 
    See also the 'move' command, which moves files into a different
276
 
    directory without changing their name.
277
 
    """
278
 
    # TODO: Some way to rename multiple files without invoking 
279
 
    # bzr for each one?"""
280
 
    takes_args = ['from_name', 'to_name']
281
 
    
282
 
    def run(self, from_name, to_name):
283
 
        b = Branch.open_containing('.')[0]
284
 
        tree = WorkingTree(b.base, b)
285
 
        b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
 
366
                self.outf.write(path)
 
367
                self.outf.write('\n')
286
368
 
287
369
 
288
370
class cmd_mv(Command):
298
380
 
299
381
    Files cannot be moved between branches.
300
382
    """
 
383
 
301
384
    takes_args = ['names*']
 
385
    aliases = ['move', 'rename']
 
386
    encoding_type = 'replace'
 
387
 
302
388
    def run(self, names_list):
 
389
        if names_list is None:
 
390
            names_list = []
 
391
 
303
392
        if len(names_list) < 2:
304
393
            raise BzrCommandError("missing file argument")
305
 
        b = Branch.open_containing(names_list[0])[0]
306
 
        tree = WorkingTree(b.base, b)
307
 
        rel_names = [tree.relpath(x) for x in names_list]
 
394
        tree, rel_names = tree_files(names_list)
308
395
        
309
396
        if os.path.isdir(names_list[-1]):
310
397
            # move into existing directory
311
 
            for pair in b.move(rel_names[:-1], rel_names[-1]):
312
 
                print "%s => %s" % pair
 
398
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
 
399
                self.outf.write("%s => %s\n" % pair)
313
400
        else:
314
401
            if len(names_list) != 2:
315
402
                raise BzrCommandError('to mv multiple files the destination '
316
403
                                      'must be a versioned directory')
317
 
            b.rename_one(rel_names[0], rel_names[1])
318
 
            print "%s => %s" % (rel_names[0], rel_names[1])
 
404
            tree.rename_one(rel_names[0], rel_names[1])
 
405
            self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
319
406
            
320
407
    
321
 
 
322
 
 
323
408
class cmd_pull(Command):
324
 
    """Pull any changes from another branch into the current one.
325
 
 
326
 
    If the location is omitted, the last-used location will be used.
327
 
    Both the revision history and the working directory will be
328
 
    updated.
 
409
    """Turn this branch into a mirror of another branch.
329
410
 
330
411
    This command only works on branches that have not diverged.  Branches are
331
 
    considered diverged if both branches have had commits without first
332
 
    pulling from the other.
333
 
 
334
 
    If branches have diverged, you can use 'bzr merge' to pull the text changes
335
 
    from one into the other.
 
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.
336
426
    """
337
 
    takes_options = ['remember', 'clobber']
 
427
 
 
428
    takes_options = ['remember', 'overwrite', 'revision', 'verbose']
338
429
    takes_args = ['location?']
339
 
 
340
 
    def run(self, location=None, remember=False, clobber=False):
341
 
        from bzrlib.merge import merge
342
 
        import tempfile
343
 
        from shutil import rmtree
344
 
        import errno
345
 
        
346
 
        br_to = Branch.open_containing('.')[0]
347
 
        stored_loc = br_to.get_parent()
 
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()
348
449
        if location is None:
349
450
            if stored_loc is None:
350
451
                raise BzrCommandError("No pull location known or specified.")
351
452
            else:
352
 
                print "Using saved location: %s" % stored_loc
353
 
                location = stored_loc
354
 
        br_from = Branch.open(location)
 
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 = []
355
546
        try:
356
 
            br_to.working_tree().pull(br_from, remember, clobber)
357
 
        except DivergedBranches:
358
 
            raise BzrCommandError("These branches have diverged."
359
 
                                  "  Try merge.")
 
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()
 
588
            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)
 
599
            except DivergedBranches:
 
600
                raise BzrCommandError("These branches have diverged."
 
601
                                      "  Try a merge then push with overwrite.")
 
602
        note('%d revision(s) pushed.' % (count,))
 
603
 
 
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)
360
611
 
361
612
 
362
613
class cmd_branch(Command):
377
628
    aliases = ['get', 'clone']
378
629
 
379
630
    def run(self, from_location, to_location=None, revision=None, basis=None):
380
 
        from bzrlib.clone import copy_branch
381
 
        import tempfile
382
 
        import errno
383
 
        from shutil import rmtree
384
 
        cache_root = tempfile.mkdtemp()
385
631
        if revision is None:
386
632
            revision = [None]
387
633
        elif len(revision) > 1:
397
643
                raise
398
644
        br_from.lock_read()
399
645
        try:
400
 
            br_from.setup_caching(cache_root)
401
646
            if basis is not None:
402
 
                basis_branch = Branch.open_containing(basis)[0]
 
647
                basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
403
648
            else:
404
 
                basis_branch = None
 
649
                basis_dir = None
405
650
            if len(revision) == 1 and revision[0] is not None:
406
651
                revision_id = revision[0].in_history(br_from)[1]
407
652
            else:
408
 
                revision_id = None
 
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()
409
657
            if to_location is None:
410
658
                to_location = os.path.basename(from_location.rstrip("/\\"))
411
 
            try:
412
 
                os.mkdir(to_location)
413
 
            except OSError, e:
414
 
                if e.errno == errno.EEXIST:
415
 
                    raise BzrCommandError('Target directory "%s" already'
416
 
                                          ' exists.' % to_location)
417
 
                if e.errno == errno.ENOENT:
418
 
                    raise BzrCommandError('Parent of "%s" does not exist.' %
419
 
                                          to_location)
420
 
                else:
421
 
                    raise
422
 
            try:
423
 
                copy_branch(br_from, to_location, revision_id, basis_branch)
424
 
            except bzrlib.errors.NoSuchRevision:
425
 
                rmtree(to_location)
 
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('.')
426
679
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
427
680
                raise BzrCommandError(msg)
428
 
            except bzrlib.errors.UnlistableBranch:
429
 
                msg = "The branch %s cannot be used as a --basis"
 
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())
430
688
        finally:
431
689
            br_from.unlock()
432
 
            rmtree(cache_root)
 
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)
433
779
 
434
780
 
435
781
class cmd_renames(Command):
440
786
    # TODO: Only show renames under dir, rather than in the whole branch.
441
787
    takes_args = ['dir?']
442
788
 
443
 
    def run(self, dir='.'):
444
 
        b = Branch.open_containing(dir)[0]
445
 
        old_inv = b.basis_tree().inventory
446
 
        new_inv = b.read_working_inventory()
447
 
 
448
 
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
 
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))
449
796
        renames.sort()
450
797
        for old_name, new_name in renames:
451
 
            print "%s => %s" % (old_name, new_name)        
 
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()
452
835
 
453
836
 
454
837
class cmd_info(Command):
455
 
    """Show statistical information about a branch."""
456
 
    takes_args = ['branch?']
457
 
    
458
 
    def run(self, branch=None):
459
 
        import info
460
 
        b = Branch.open_containing(branch)[0]
461
 
        info.show_info(b)
 
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)
462
854
 
463
855
 
464
856
class cmd_remove(Command):
466
858
 
467
859
    This makes bzr stop tracking changes to a versioned file.  It does
468
860
    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.
469
866
    """
470
 
    takes_args = ['file+']
471
 
    takes_options = ['verbose']
 
867
    takes_args = ['file*']
 
868
    takes_options = ['verbose', Option('new', help='remove newly-added files')]
472
869
    aliases = ['rm']
 
870
    encoding_type = 'replace'
473
871
    
474
 
    def run(self, file_list, verbose=False):
475
 
        b = Branch.open_containing(file_list[0])[0]
476
 
        tree = WorkingTree(b.base, b)
477
 
        tree.remove([tree.relpath(f) for f in file_list], verbose=verbose)
 
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)
478
885
 
479
886
 
480
887
class cmd_file_id(Command):
484
891
    same through all revisions where the file exists, even when it is
485
892
    moved or renamed.
486
893
    """
 
894
 
487
895
    hidden = True
488
896
    takes_args = ['filename']
 
897
 
 
898
    @display_command
489
899
    def run(self, filename):
490
 
        b, relpath = Branch.open_containing(filename)
491
 
        i = b.inventory.path2id(relpath)
 
900
        tree, relpath = WorkingTree.open_containing(filename)
 
901
        i = tree.inventory.path2id(relpath)
492
902
        if i == None:
493
903
            raise BzrError("%r is not a versioned file" % filename)
494
904
        else:
495
 
            print i
 
905
            self.outf.write(i + '\n')
496
906
 
497
907
 
498
908
class cmd_file_path(Command):
499
909
    """Print path of file_ids to a file or directory.
500
910
 
501
911
    This prints one line for each directory down to the target,
502
 
    starting at the branch root."""
 
912
    starting at the branch root.
 
913
    """
 
914
 
503
915
    hidden = True
504
916
    takes_args = ['filename']
 
917
 
 
918
    @display_command
505
919
    def run(self, filename):
506
 
        b, relpath = Branch.open_containing(filename)
507
 
        inv = b.inventory
 
920
        tree, relpath = WorkingTree.open_containing(filename)
 
921
        inv = tree.inventory
508
922
        fid = inv.path2id(relpath)
509
923
        if fid == None:
510
924
            raise BzrError("%r is not a versioned file" % filename)
511
925
        for fip in inv.get_idpath(fid):
512
 
            print fip
 
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)
513
953
 
514
954
 
515
955
class cmd_revision_history(Command):
516
 
    """Display list of revision ids on this branch."""
 
956
    """Display the list of revision ids on a branch."""
 
957
    takes_args = ['location?']
 
958
 
517
959
    hidden = True
518
 
    def run(self):
519
 
        for patchid in Branch.open_containing('.')[0].revision_history():
520
 
            print patchid
 
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')
521
967
 
522
968
 
523
969
class cmd_ancestry(Command):
524
970
    """List all revisions merged into this branch."""
 
971
    takes_args = ['location?']
 
972
 
525
973
    hidden = True
526
 
    def run(self):
527
 
        b = find_branch('.')
528
 
        for revision_id in b.get_ancestry(b.last_revision()):
529
 
            print revision_id
530
 
 
531
 
 
532
 
class cmd_directories(Command):
533
 
    """Display list of versioned directories in this branch."""
534
 
    def run(self):
535
 
        for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
536
 
            if name == '':
537
 
                print '.'
538
 
            else:
539
 
                print name
 
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')
540
991
 
541
992
 
542
993
class cmd_init(Command):
545
996
    Use this to create an empty branch, or before importing an
546
997
    existing project.
547
998
 
 
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
 
548
1007
    Recipe for importing a tree of files:
549
1008
        cd ~/project
550
1009
        bzr init
551
 
        bzr add -v .
 
1010
        bzr add .
552
1011
        bzr status
553
1012
        bzr commit -m 'imported project'
554
1013
    """
555
 
    def run(self):
556
 
        Branch.initialize('.')
 
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)
557
1099
 
558
1100
 
559
1101
class cmd_diff(Command):
560
 
    """Show differences in working tree.
 
1102
    """Show differences in the working tree or between revisions.
561
1103
    
562
1104
    If files are listed, only the changes in those files are listed.
563
1105
    Otherwise, all changes for the tree are listed.
564
1106
 
 
1107
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
 
1108
    produces patches suitable for "patch -p1".
 
1109
 
565
1110
    examples:
566
1111
        bzr diff
 
1112
            Shows the difference in the working tree versus the last commit
567
1113
        bzr diff -r1
 
1114
            Difference between the working tree and revision 1
568
1115
        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'
569
1123
    """
570
 
    # TODO: Allow diff across branches.
571
1124
    # TODO: Option to use external diff command; could be GNU diff, wdiff,
572
1125
    #       or a graphical diff.
573
1126
 
574
1127
    # TODO: Python difflib is not exactly the same as unidiff; should
575
1128
    #       either fix it up or prefer to use an external diff.
576
1129
 
577
 
    # TODO: If a directory is given, diff everything under that.
578
 
 
579
1130
    # TODO: Selected-file diff is inefficient and doesn't show you
580
1131
    #       deleted files.
581
1132
 
582
1133
    # TODO: This probably handles non-Unix newlines poorly.
583
1134
    
584
1135
    takes_args = ['file*']
585
 
    takes_options = ['revision', 'diff-options']
 
1136
    takes_options = ['revision', 'diff-options', 'prefix']
586
1137
    aliases = ['di', 'dif']
587
 
 
588
 
    def run(self, revision=None, file_list=None, diff_options=None):
589
 
        from bzrlib.diff import show_diff
590
 
 
591
 
        if file_list:
592
 
            b = Branch.open_containing(file_list[0])[0]
593
 
            tree = WorkingTree(b.base, b)
594
 
            file_list = [tree.relpath(f) for f in file_list]
595
 
            if file_list == ['']:
596
 
                # just pointing to top-of-tree
597
 
                file_list = None
 
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/'
598
1152
        else:
599
 
            b = Branch.open_containing('.')[0]
 
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")
600
1165
 
 
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
601
1181
        if revision is not None:
602
 
            if len(revision) == 1:
603
 
                show_diff(b, revision[0], specific_files=file_list,
604
 
                          external_diff_options=diff_options)
 
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)
605
1188
            elif len(revision) == 2:
606
 
                show_diff(b, revision[0], specific_files=file_list,
607
 
                          external_diff_options=diff_options,
608
 
                          revision2=revision[1])
 
1189
                return diff_cmd_helper(tree1, file_list, diff_options,
 
1190
                                       revision[0], revision[1],
 
1191
                                       old_label=old_label, new_label=new_label)
609
1192
            else:
610
1193
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
611
1194
        else:
612
 
            show_diff(b, None, specific_files=file_list,
613
 
                      external_diff_options=diff_options)
614
 
 
615
 
        
 
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)
616
1203
 
617
1204
 
618
1205
class cmd_deleted(Command):
624
1211
    # directories with readdir, rather than stating each one.  Same
625
1212
    # level of effort but possibly much less IO.  (Or possibly not,
626
1213
    # if the directories are very large...)
 
1214
    takes_options = ['show-ids']
 
1215
 
 
1216
    @display_command
627
1217
    def run(self, show_ids=False):
628
 
        b = Branch.open_containing('.')[0]
629
 
        old = b.basis_tree()
630
 
        new = b.working_tree()
 
1218
        tree = WorkingTree.open_containing(u'.')[0]
 
1219
        old = tree.basis_tree()
631
1220
        for path, ie in old.inventory.iter_entries():
632
 
            if not new.has_id(ie.file_id):
 
1221
            if not tree.has_id(ie.file_id):
 
1222
                self.outf.write(path)
633
1223
                if show_ids:
634
 
                    print '%-50s %s' % (path, ie.file_id)
635
 
                else:
636
 
                    print path
 
1224
                    self.outf.write(' ')
 
1225
                    self.outf.write(ie.file_id)
 
1226
                self.outf.write('\n')
637
1227
 
638
1228
 
639
1229
class cmd_modified(Command):
640
1230
    """List files modified in working tree."""
641
1231
    hidden = True
 
1232
    @display_command
642
1233
    def run(self):
643
 
        from bzrlib.delta import compare_trees
644
 
 
645
 
        b = Branch.open_containing('.')[0]
646
 
        td = compare_trees(b.basis_tree(), b.working_tree())
647
 
 
 
1234
        tree = WorkingTree.open_containing(u'.')[0]
 
1235
        td = tree.changes_from(tree.basis_tree())
648
1236
        for path, id, kind, text_modified, meta_modified in td.modified:
649
 
            print path
650
 
 
 
1237
            self.outf.write(path + '\n')
651
1238
 
652
1239
 
653
1240
class cmd_added(Command):
654
1241
    """List files added in working tree."""
655
1242
    hidden = True
 
1243
    @display_command
656
1244
    def run(self):
657
 
        b = Branch.open_containing('.')[0]
658
 
        wt = b.working_tree()
659
 
        basis_inv = b.basis_tree().inventory
 
1245
        wt = WorkingTree.open_containing(u'.')[0]
 
1246
        basis_inv = wt.basis_tree().inventory
660
1247
        inv = wt.inventory
661
1248
        for file_id in inv:
662
1249
            if file_id in basis_inv:
663
1250
                continue
664
1251
            path = inv.id2path(file_id)
665
 
            if not os.access(b.abspath(path), os.F_OK):
 
1252
            if not os.access(osutils.abspath(path), os.F_OK):
666
1253
                continue
667
 
            print path
668
 
                
669
 
        
 
1254
            self.outf.write(path + '\n')
 
1255
 
670
1256
 
671
1257
class cmd_root(Command):
672
1258
    """Show the tree root directory.
674
1260
    The root is the nearest enclosing directory with a .bzr control
675
1261
    directory."""
676
1262
    takes_args = ['filename?']
 
1263
    @display_command
677
1264
    def run(self, filename=None):
678
1265
        """Print the branch root."""
679
 
        b = Branch.open_containing(filename)[0]
680
 
        print b.base
 
1266
        tree = WorkingTree.open_containing(filename)[0]
 
1267
        self.outf.write(tree.basedir + '\n')
681
1268
 
682
1269
 
683
1270
class cmd_log(Command):
684
 
    """Show log of this branch.
685
 
 
686
 
    To request a range of logs, you can use the command -r begin:end
687
 
    -r revision requests a specific revision, -r :end or -r begin: are
 
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
688
1277
    also valid.
 
1278
 
 
1279
    examples:
 
1280
        bzr log
 
1281
        bzr log foo.c
 
1282
        bzr log -r -10.. http://server/branch
689
1283
    """
690
1284
 
691
1285
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
692
1286
 
693
 
    takes_args = ['filename?']
 
1287
    takes_args = ['location?']
694
1288
    takes_options = [Option('forward', 
695
1289
                            help='show from oldest to newest'),
696
 
                     'timezone', 'verbose', 
 
1290
                     'timezone', 
 
1291
                     Option('verbose', 
 
1292
                             help='show files changed in each revision'),
697
1293
                     'show-ids', 'revision',
698
 
                     Option('line', help='format with one line per revision'),
699
 
                     'long', 
 
1294
                     'log-format',
 
1295
                     'line', 'long', 
700
1296
                     Option('message',
701
1297
                            help='show revisions whose message matches this regexp',
702
1298
                            type=str),
703
 
                     Option('short', help='use moderately short format'),
 
1299
                     'short',
704
1300
                     ]
705
 
    
706
 
    def run(self, filename=None, timezone='original',
 
1301
    encoding_type = 'replace'
 
1302
 
 
1303
    @display_command
 
1304
    def run(self, location=None, timezone='original',
707
1305
            verbose=False,
708
1306
            show_ids=False,
709
1307
            forward=False,
710
1308
            revision=None,
 
1309
            log_format=None,
711
1310
            message=None,
712
1311
            long=False,
713
1312
            short=False,
714
1313
            line=False):
715
1314
        from bzrlib.log import log_formatter, show_log
716
 
        import codecs
717
1315
        assert message is None or isinstance(message, basestring), \
718
1316
            "invalid message argument %r" % message
719
1317
        direction = (forward and 'forward') or 'reverse'
720
1318
        
721
 
        if filename:
722
 
            b, fp = Branch.open_containing(filename)
 
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()
723
1326
            if fp != '':
724
 
                file_id = b.read_working_inventory().path2id(fp)
725
 
            else:
726
 
                file_id = None  # points to branch root
 
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)
727
1334
        else:
728
 
            b, relpath = Branch.open_containing('.')
729
 
            file_id = None
 
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()
730
1339
 
731
1340
        if revision is None:
732
1341
            rev1 = None
734
1343
        elif len(revision) == 1:
735
1344
            rev1 = rev2 = revision[0].in_history(b).revno
736
1345
        elif len(revision) == 2:
737
 
            rev1 = revision[0].in_history(b).revno
738
 
            rev2 = revision[1].in_history(b).revno
 
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
739
1357
        else:
740
1358
            raise BzrCommandError('bzr log --revision takes one or two values.')
741
1359
 
742
 
        if rev1 == 0:
743
 
            rev1 = None
744
 
        if rev2 == 0:
745
 
            rev2 = None
746
 
 
747
 
        mutter('encoding log as %r' % bzrlib.user_encoding)
748
 
 
749
 
        # use 'replace' so that we don't abort if trying to write out
750
 
        # in e.g. the default C locale.
751
 
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
752
 
 
753
 
        log_format = 'long'
754
 
        if short:
755
 
            log_format = 'short'
756
 
        if line:
757
 
            log_format = 'line'
 
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)
758
1370
        lf = log_formatter(log_format,
759
1371
                           show_ids=show_ids,
760
 
                           to_file=outf,
 
1372
                           to_file=self.outf,
761
1373
                           show_timezone=timezone)
762
1374
 
763
1375
        show_log(b,
770
1382
                 search=message)
771
1383
 
772
1384
 
 
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
 
773
1395
 
774
1396
class cmd_touching_revisions(Command):
775
1397
    """Return revision-ids which affected a particular file.
776
1398
 
777
 
    A more user-friendly interface is "bzr log FILE"."""
 
1399
    A more user-friendly interface is "bzr log FILE".
 
1400
    """
 
1401
 
778
1402
    hidden = True
779
1403
    takes_args = ["filename"]
 
1404
 
 
1405
    @display_command
780
1406
    def run(self, filename):
781
 
        b, relpath = Branch.open_containing(filename)[0]
782
 
        inv = b.read_working_inventory()
 
1407
        tree, relpath = WorkingTree.open_containing(filename)
 
1408
        b = tree.branch
 
1409
        inv = tree.read_working_inventory()
783
1410
        file_id = inv.path2id(relpath)
784
 
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
785
 
            print "%6d %s" % (revno, what)
 
1411
        for revno, revision_id, what in log.find_touching_revisions(b, file_id):
 
1412
            self.outf.write("%6d %s\n" % (revno, what))
786
1413
 
787
1414
 
788
1415
class cmd_ls(Command):
790
1417
    """
791
1418
    # TODO: Take a revision or remote path and list that tree instead.
792
1419
    hidden = True
793
 
    def run(self, revision=None, verbose=False):
794
 
        b, relpath = Branch.open_containing('.')[0]
795
 
        if revision == None:
796
 
            tree = b.working_tree()
797
 
        else:
798
 
            tree = b.revision_tree(revision.in_history(b).rev_id)
 
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
 
799
1452
        for fp, fc, kind, fid, entry in tree.list_files():
800
 
            if verbose:
801
 
                kindch = entry.kind_character()
802
 
                print '%-8s %s%s' % (fc, fp, kindch)
803
 
            else:
804
 
                print fp
805
 
 
 
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')
806
1467
 
807
1468
 
808
1469
class cmd_unknowns(Command):
809
1470
    """List unknown files."""
 
1471
    @display_command
810
1472
    def run(self):
811
 
        from bzrlib.osutils import quotefn
812
 
        for f in Branch.open_containing('.')[0].unknowns():
813
 
            print quotefn(f)
814
 
 
 
1473
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
1474
            self.outf.write(osutils.quotefn(f) + '\n')
815
1475
 
816
1476
 
817
1477
class cmd_ignore(Command):
833
1493
        bzr ignore '*.class'
834
1494
    """
835
1495
    # TODO: Complain if the filename is absolute
836
 
    takes_args = ['name_pattern']
 
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
                     ]
837
1501
    
838
 
    def run(self, name_pattern):
 
1502
    def run(self, name_pattern=None, old_default_rules=None):
839
1503
        from bzrlib.atomicfile import AtomicFile
840
 
        import os.path
841
 
 
842
 
        b, relpath = Branch.open_containing('.')
843
 
        ifn = b.abspath('.bzrignore')
844
 
 
 
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')
845
1513
        if os.path.exists(ifn):
846
1514
            f = open(ifn, 'rt')
847
1515
            try:
858
1526
            igns += '\n'
859
1527
        igns += name_pattern + '\n'
860
1528
 
 
1529
        f = AtomicFile(ifn, 'wt')
861
1530
        try:
862
 
            f = AtomicFile(ifn, 'wt')
863
1531
            f.write(igns.encode('utf-8'))
864
1532
            f.commit()
865
1533
        finally:
866
1534
            f.close()
867
1535
 
868
 
        inv = b.working_tree().inventory
 
1536
        inv = tree.inventory
869
1537
        if inv.path2id('.bzrignore'):
870
1538
            mutter('.bzrignore is already versioned')
871
1539
        else:
872
1540
            mutter('need to make new .bzrignore file versioned')
873
 
            b.add(['.bzrignore'])
874
 
 
 
1541
            tree.add(['.bzrignore'])
875
1542
 
876
1543
 
877
1544
class cmd_ignored(Command):
878
1545
    """List ignored files and the patterns that matched them.
879
1546
 
880
1547
    See also: bzr ignore"""
 
1548
    @display_command
881
1549
    def run(self):
882
 
        tree = Branch.open_containing('.')[0].working_tree()
 
1550
        tree = WorkingTree.open_containing(u'.')[0]
883
1551
        for path, file_class, kind, file_id, entry in tree.list_files():
884
1552
            if file_class != 'I':
885
1553
                continue
897
1565
    hidden = True
898
1566
    takes_args = ['revno']
899
1567
    
 
1568
    @display_command
900
1569
    def run(self, revno):
901
1570
        try:
902
1571
            revno = int(revno)
903
1572
        except ValueError:
904
1573
            raise BzrCommandError("not a valid revision-number: %r" % revno)
905
1574
 
906
 
        print Branch.open_containing('.')[0].get_rev_id(revno)
 
1575
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
907
1576
 
908
1577
 
909
1578
class cmd_export(Command):
916
1585
    is found exports to a directory (equivalent to --format=dir).
917
1586
 
918
1587
    Root may be the top directory for tar, tgz and tbz2 formats. If none
919
 
    is given, the top directory will be the root name of the file."""
920
 
    # TODO: list known exporters
 
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
    """
921
1600
    takes_args = ['dest']
922
1601
    takes_options = ['revision', 'format', 'root']
923
1602
    def run(self, dest, revision=None, format=None, root=None):
924
 
        import os.path
925
 
        b = Branch.open_containing('.')[0]
 
1603
        from bzrlib.export import export
 
1604
        tree = WorkingTree.open_containing(u'.')[0]
 
1605
        b = tree.branch
926
1606
        if revision is None:
 
1607
            # should be tree.last_revision  FIXME
927
1608
            rev_id = b.last_revision()
928
1609
        else:
929
1610
            if len(revision) != 1:
930
1611
                raise BzrError('bzr export --revision takes exactly 1 argument')
931
1612
            rev_id = revision[0].in_history(b).rev_id
932
 
        t = b.revision_tree(rev_id)
933
 
        arg_root, ext = os.path.splitext(os.path.basename(dest))
934
 
        if ext in ('.gz', '.bz2'):
935
 
            new_root, new_ext = os.path.splitext(arg_root)
936
 
            if new_ext == '.tar':
937
 
                arg_root = new_root
938
 
                ext = new_ext + ext
939
 
        if root is None:
940
 
            root = arg_root
941
 
        if not format:
942
 
            if ext in (".tar",):
943
 
                format = "tar"
944
 
            elif ext in (".tar.gz", ".tgz"):
945
 
                format = "tgz"
946
 
            elif ext in (".tar.bz2", ".tbz2"):
947
 
                format = "tbz2"
948
 
            else:
949
 
                format = "dir"
950
 
        t.export(dest, format, root)
 
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)
951
1618
 
952
1619
 
953
1620
class cmd_cat(Command):
956
1623
    takes_options = ['revision']
957
1624
    takes_args = ['filename']
958
1625
 
 
1626
    @display_command
959
1627
    def run(self, filename, revision=None):
960
 
        if revision is None:
961
 
            raise BzrCommandError("bzr cat requires a revision number")
962
 
        elif len(revision) != 1:
 
1628
        if revision is not None and len(revision) != 1:
963
1629
            raise BzrCommandError("bzr cat --revision takes exactly one number")
964
 
        b, relpath = Branch.open_containing(filename)
965
 
        b.print_file(relpath, revision[0].in_history(b).revno)
 
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)
966
1644
 
967
1645
 
968
1646
class cmd_local_time_offset(Command):
969
1647
    """Show the offset in seconds from GMT to local time."""
970
1648
    hidden = True    
 
1649
    @display_command
971
1650
    def run(self):
972
 
        print bzrlib.osutils.local_time_offset()
 
1651
        print osutils.local_time_offset()
973
1652
 
974
1653
 
975
1654
 
1005
1684
                     Option('strict',
1006
1685
                            help="refuse to commit if there are unknown "
1007
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
                            ),
1008
1693
                     ]
1009
1694
    aliases = ['ci', 'checkin']
1010
1695
 
1011
1696
    def run(self, message=None, file=None, verbose=True, selected_list=None,
1012
 
            unchanged=False, strict=False):
 
1697
            unchanged=False, strict=False, local=False):
 
1698
        from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1013
1699
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1014
1700
                StrictCommitFailed)
1015
 
        from bzrlib.msgeditor import edit_commit_message
1016
 
        from bzrlib.status import show_status
1017
 
        from cStringIO import StringIO
1018
 
 
1019
 
        b = Branch.open_containing('.')[0]
1020
 
        tree = WorkingTree(b.base, b)
1021
 
        if selected_list:
1022
 
            selected_list = [tree.relpath(s) for s in selected_list]
 
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()
1023
1722
        if message is None and not file:
1024
 
            catcher = StringIO()
1025
 
            show_status(b, specific_files=selected_list,
1026
 
                        to_file=catcher)
1027
 
            message = edit_commit_message(catcher.getvalue())
1028
 
 
 
1723
            template = make_commit_message_template(tree, selected_list)
 
1724
            message = edit_commit_message(template)
1029
1725
            if message is None:
1030
1726
                raise BzrCommandError("please specify a commit message"
1031
1727
                                      " with either --message or --file")
1033
1729
            raise BzrCommandError("please specify either --message or --file")
1034
1730
        
1035
1731
        if file:
1036
 
            import codecs
1037
1732
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1038
1733
 
1039
1734
        if message == "":
1040
 
                raise BzrCommandError("empty commit message specified")
1041
 
            
 
1735
            raise BzrCommandError("empty commit message specified")
 
1736
        
 
1737
        if verbose:
 
1738
            reporter = ReportCommitToLog()
 
1739
        else:
 
1740
            reporter = NullCommitReporter()
 
1741
        
1042
1742
        try:
1043
 
            b.commit(message, specific_files=selected_list,
1044
 
                     allow_pointless=unchanged, strict=strict)
 
1743
            tree.commit(message, specific_files=selected_list,
 
1744
                        allow_pointless=unchanged, strict=strict, local=local,
 
1745
                        reporter=reporter)
1045
1746
        except PointlessCommit:
1046
1747
            # FIXME: This should really happen before the file is read in;
1047
1748
            # perhaps prepare the commit; get the message; then actually commit
1048
 
            raise BzrCommandError("no changes to commit",
1049
 
                                  ["use --unchanged to commit anyhow"])
 
1749
            raise BzrCommandError("no changes to commit."
 
1750
                                  " use --unchanged to commit anyhow")
1050
1751
        except ConflictsInTree:
1051
1752
            raise BzrCommandError("Conflicts detected in working tree.  "
1052
1753
                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1053
1754
        except StrictCommitFailed:
1054
1755
            raise BzrCommandError("Commit refused because there are unknown "
1055
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.')
1056
1761
 
1057
1762
 
1058
1763
class cmd_check(Command):
1061
1766
    This command checks various invariants about the branch storage to
1062
1767
    detect data corruption or bzr bugs.
1063
1768
    """
1064
 
    takes_args = ['dir?']
 
1769
    takes_args = ['branch?']
1065
1770
    takes_options = ['verbose']
1066
1771
 
1067
 
    def run(self, dir='.', verbose=False):
 
1772
    def run(self, branch=None, verbose=False):
1068
1773
        from bzrlib.check import check
1069
 
        check(Branch.open_containing(dir)[0], verbose)
 
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)
1070
1780
 
1071
1781
 
1072
1782
class cmd_scan_cache(Command):
1074
1784
    def run(self):
1075
1785
        from bzrlib.hashcache import HashCache
1076
1786
 
1077
 
        c = HashCache('.')
 
1787
        c = HashCache(u'.')
1078
1788
        c.read()
1079
1789
        c.scan()
1080
1790
            
1086
1796
 
1087
1797
        if c.needs_write:
1088
1798
            c.write()
1089
 
            
1090
1799
 
1091
1800
 
1092
1801
class cmd_upgrade(Command):
1093
1802
    """Upgrade branch storage to current format.
1094
1803
 
1095
1804
    The check command or bzr developers may sometimes advise you to run
1096
 
    this command.
1097
 
 
1098
 
    This version of this command upgrades from the full-text storage
1099
 
    used by bzr 0.0.8 and earlier to the weave format (v5).
 
1805
    this command. When the default format has changed you may also be warned
 
1806
    during other operations to upgrade.
1100
1807
    """
1101
 
    takes_args = ['dir?']
1102
 
 
1103
 
    def run(self, dir='.'):
 
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):
1104
1820
        from bzrlib.upgrade import upgrade
1105
 
        upgrade(dir)
 
1821
        if format is None:
 
1822
            format = get_format_type('default')
 
1823
        upgrade(url, format)
1106
1824
 
1107
1825
 
1108
1826
class cmd_whoami(Command):
1109
 
    """Show bzr user id."""
1110
 
    takes_options = ['email']
1111
 
    
1112
 
    def run(self, email=False):
 
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.
1113
1857
        try:
1114
 
            b = bzrlib.branch.Branch.open_containing('.')[0]
1115
 
            config = bzrlib.config.BranchConfig(b)
1116
 
        except NotBranchError:
1117
 
            config = bzrlib.config.GlobalConfig()
 
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)
1118
1862
        
1119
 
        if email:
1120
 
            print config.user_email()
1121
 
        else:
1122
 
            print config.username()
 
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 
1123
1888
 
1124
1889
 
1125
1890
class cmd_selftest(Command):
1128
1893
    This creates temporary test directories in the working directory,
1129
1894
    but not existing data is affected.  These directories are deleted
1130
1895
    if the tests pass, or left behind to help in debugging if they
1131
 
    fail.
 
1896
    fail and --keep-output is specified.
1132
1897
    
1133
1898
    If arguments are given, they are regular expressions that say
1134
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
1135
1909
    """
1136
1910
    # 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
 
1137
1929
    hidden = True
1138
1930
    takes_args = ['testspecs*']
1139
 
    takes_options = ['verbose', 
 
1931
    takes_options = ['verbose',
1140
1932
                     Option('one', help='stop when one test fails'),
1141
 
                    ]
 
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
                     ]
1142
1944
 
1143
 
    def run(self, testspecs_list=None, verbose=False, one=False):
 
1945
    def run(self, testspecs_list=None, verbose=None, one=False,
 
1946
            keep_output=False, transport=None, benchmark=None,
 
1947
            lsprof_timed=None):
1144
1948
        import bzrlib.ui
1145
 
        from bzrlib.selftest import selftest
 
1949
        from bzrlib.tests import selftest
 
1950
        import bzrlib.benchmarks as benchmarks
1146
1951
        # we don't want progress meters from the tests to go to the
1147
1952
        # real output; and we don't want log messages cluttering up
1148
1953
        # the real logs.
1149
 
        save_ui = bzrlib.ui.ui_factory
1150
 
        bzrlib.trace.info('running tests...')
 
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...')
1151
1959
        try:
1152
 
            bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
1960
            ui.ui_factory = ui.SilentUIFactory()
1153
1961
            if testspecs_list is not None:
1154
1962
                pattern = '|'.join(testspecs_list)
1155
1963
            else:
1156
1964
                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
1157
1973
            result = selftest(verbose=verbose, 
1158
1974
                              pattern=pattern,
1159
 
                              stop_on_failure=one)
 
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)
1160
1980
            if result:
1161
 
                bzrlib.trace.info('tests passed')
 
1981
                info('tests passed')
1162
1982
            else:
1163
 
                bzrlib.trace.info('tests failed')
 
1983
                info('tests failed')
1164
1984
            return int(not result)
1165
1985
        finally:
1166
 
            bzrlib.ui.ui_factory = save_ui
1167
 
 
 
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
    
1168
1999
 
1169
2000
def show_version():
1170
 
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
2001
    import bzrlib
 
2002
    print "Bazaar (bzr) %s" % bzrlib.__version__
1171
2003
    # is bzrlib itself in a branch?
1172
 
    bzrrev = bzrlib.get_bzr_revision()
1173
 
    if bzrrev:
1174
 
        print "  (bzr checkout, revision %d {%s})" % bzrrev
 
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
1175
2024
    print bzrlib.__copyright__
1176
 
    print "http://bazaar-ng.org/"
 
2025
    print "http://bazaar-vcs.org/"
1177
2026
    print
1178
2027
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
1179
2028
    print "you may use, modify and redistribute it under the terms of the GNU"
1182
2031
 
1183
2032
class cmd_version(Command):
1184
2033
    """Show version of bzr."""
 
2034
 
 
2035
    @display_command
1185
2036
    def run(self):
1186
2037
        show_version()
1187
2038
 
 
2039
 
1188
2040
class cmd_rocks(Command):
1189
2041
    """Statement of optimism."""
 
2042
 
1190
2043
    hidden = True
 
2044
 
 
2045
    @display_command
1191
2046
    def run(self):
1192
2047
        print "it sure does!"
1193
2048
 
1194
2049
 
1195
2050
class cmd_find_merge_base(Command):
1196
 
    """Find and print a base revision for merging two branches.
1197
 
    """
 
2051
    """Find and print a base revision for merging two branches."""
1198
2052
    # TODO: Options to specify revisions on either side, as if
1199
2053
    #       merging only part of the history.
1200
2054
    takes_args = ['branch', 'other']
1201
2055
    hidden = True
1202
2056
    
 
2057
    @display_command
1203
2058
    def run(self, branch, other):
1204
2059
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
1205
2060
        
1212
2067
        last1 = branch1.last_revision()
1213
2068
        last2 = branch2.last_revision()
1214
2069
 
1215
 
        source = MultipleRevisionSources(branch1, branch2)
 
2070
        source = MultipleRevisionSources(branch1.repository, 
 
2071
                                         branch2.repository)
1216
2072
        
1217
2073
        base_rev_id = common_ancestor(last1, last2, source)
1218
2074
 
1219
2075
        print 'merge base is revision %s' % base_rev_id
1220
 
        
1221
 
        return
1222
 
 
1223
 
        if base_revno is None:
1224
 
            raise bzrlib.errors.UnrelatedBranches()
1225
 
 
1226
 
        print ' r%-6d in %s' % (base_revno, branch)
1227
 
 
1228
 
        other_revno = branch2.revision_id_to_revno(base_revid)
1229
 
        
1230
 
        print ' r%-6d in %s' % (other_revno, other)
1231
 
 
1232
2076
 
1233
2077
 
1234
2078
class cmd_merge(Command):
1235
2079
    """Perform a three-way merge.
1236
2080
    
1237
 
    The branch is the branch you will merge from.  By default, it will
1238
 
    merge the latest revision.  If you specify a revision, that
1239
 
    revision will be merged.  If you specify two revisions, the first
1240
 
    will be used as a BASE, and the second one as OTHER.  Revision
1241
 
    numbers are always relative to the specified branch.
 
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.
1242
2086
 
1243
 
    By default bzr will try to merge in all new work from the other
 
2087
    By default, bzr will try to merge in all new work from the other
1244
2088
    branch, automatically determining an appropriate base.  If this
1245
2089
    fails, you may need to give an explicit base.
1246
2090
    
 
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
 
1247
2103
    Examples:
1248
2104
 
1249
2105
    To merge the latest revision from bzr.dev
1257
2113
    
1258
2114
    merge refuses to run if there are any uncommitted changes, unless
1259
2115
    --force is given.
 
2116
 
 
2117
    The following merge types are available:
1260
2118
    """
1261
2119
    takes_args = ['branch?']
1262
 
    takes_options = ['revision', 'force', 'merge-type']
1263
 
 
1264
 
    def run(self, branch=None, revision=None, force=False, 
1265
 
            merge_type=None):
1266
 
        from bzrlib.merge import merge
1267
 
        from bzrlib.merge_core import ApplyMerge3
 
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):
1268
2131
        if merge_type is None:
1269
 
            merge_type = ApplyMerge3
1270
 
        if branch is None:
1271
 
            branch = Branch.open_containing('.')[0].get_parent()
1272
 
            if branch is None:
1273
 
                raise BzrCommandError("No merge location known or specified.")
 
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
1274
2141
            else:
1275
 
                print "Using saved location: %s" % branch 
 
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
 
1276
2151
        if revision is None or len(revision) < 1:
1277
2152
            base = [None, None]
1278
2153
            other = [branch, -1]
 
2154
            other_branch, path = Branch.open_containing(branch)
1279
2155
        else:
1280
2156
            if len(revision) == 1:
1281
2157
                base = [None, None]
1282
 
                other = [branch, revision[0].in_history(branch).revno]
 
2158
                other_branch, path = Branch.open_containing(branch)
 
2159
                revno = revision[0].in_history(other_branch).revno
 
2160
                other = [branch, revno]
1283
2161
            else:
1284
2162
                assert len(revision) == 2
1285
2163
                if None in revision:
1286
2164
                    raise BzrCommandError(
1287
2165
                        "Merge doesn't permit that revision specifier.")
1288
 
                b = Branch.open(branch)
1289
 
 
1290
 
                base = [branch, revision[0].in_history(b).revno]
1291
 
                other = [branch, revision[1].in_history(b).revno]
1292
 
 
 
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()
1293
2179
        try:
1294
 
            merge(other, base, check_clean=(not force), merge_type=merge_type)
1295
 
        except bzrlib.errors.AmbiguousBase, e:
 
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:
1296
2193
            m = ("sorry, bzr can't determine the right merge base yet\n"
1297
2194
                 "candidates are:\n  "
1298
2195
                 + "\n  ".join(e.bases)
1301
2198
                 "and (if you want) report this to the bzr developers\n")
1302
2199
            log_error(m)
1303
2200
 
 
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
1304
2307
 
1305
2308
class cmd_revert(Command):
1306
2309
    """Reverse all changes since the last commit.
1314
2317
    aliases = ['merge-revert']
1315
2318
 
1316
2319
    def run(self, revision=None, no_backup=False, file_list=None):
1317
 
        from bzrlib.merge import merge
1318
2320
        from bzrlib.commands import parse_spec
1319
 
 
1320
2321
        if file_list is not None:
1321
2322
            if len(file_list) == 0:
1322
2323
                raise BzrCommandError("No files specified")
 
2324
        else:
 
2325
            file_list = []
 
2326
        
 
2327
        tree, file_list = tree_files(file_list)
1323
2328
        if revision is None:
1324
 
            revno = -1
 
2329
            # FIXME should be tree.last_revision
 
2330
            rev_id = tree.last_revision()
1325
2331
        elif len(revision) != 1:
1326
2332
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1327
2333
        else:
1328
 
            b = Branch.open_containing('.')[0]
1329
 
            revno = revision[0].in_history(b).revno
1330
 
        merge(('.', revno), parse_spec('.'),
1331
 
              check_clean=False,
1332
 
              ignore_zero=True,
1333
 
              backup_files=not no_backup,
1334
 
              file_list=file_list)
1335
 
        if not file_list:
1336
 
            Branch.open_containing('.')[0].set_pending_merges([])
 
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()
1337
2342
 
1338
2343
 
1339
2344
class cmd_assert_fail(Command):
1347
2352
    """Show help on a command or other topic.
1348
2353
 
1349
2354
    For a list of all available commands, say 'bzr help commands'."""
1350
 
    takes_options = ['long']
 
2355
    takes_options = [Option('long', 'show help on all commands')]
1351
2356
    takes_args = ['topic?']
1352
 
    aliases = ['?']
 
2357
    aliases = ['?', '--help', '-?', '-h']
1353
2358
    
 
2359
    @display_command
1354
2360
    def run(self, topic=None, long=False):
1355
2361
        import help
1356
2362
        if topic is None and long:
1366
2372
    aliases = ['s-c']
1367
2373
    hidden = True
1368
2374
    
 
2375
    @display_command
1369
2376
    def run(self, context=None):
1370
2377
        import shellcomplete
1371
2378
        shellcomplete.shellcomplete(context)
1379
2386
    takes_args = ['from_branch', 'to_branch']
1380
2387
    def run(self, from_branch, to_branch):
1381
2388
        from bzrlib.fetch import Fetcher
1382
 
        from bzrlib.branch import Branch
1383
 
        from_b = Branch(from_branch)
1384
 
        to_b = Branch(to_branch)
 
2389
        from_b = Branch.open(from_branch)
 
2390
        to_b = Branch.open(to_branch)
1385
2391
        Fetcher(to_b, from_b)
1386
 
        
1387
2392
 
1388
2393
 
1389
2394
class cmd_missing(Command):
1390
 
    """What is missing in this branch relative to other branch.
1391
 
    """
1392
 
    # TODO: rewrite this in terms of ancestry so that it shows only
1393
 
    # unmerged things
1394
 
    
1395
 
    takes_args = ['remote?']
1396
 
    aliases = ['mis', 'miss']
1397
 
    # We don't have to add quiet to the list, because 
1398
 
    # unknown options are parsed as booleans
1399
 
    takes_options = ['verbose', 'quiet']
1400
 
 
1401
 
    def run(self, remote=None, verbose=False, quiet=False):
1402
 
        from bzrlib.errors import BzrCommandError
1403
 
        from bzrlib.missing import show_missing
1404
 
 
1405
 
        if verbose and quiet:
1406
 
            raise BzrCommandError('Cannot pass both quiet and verbose')
1407
 
 
1408
 
        b = Branch.open_containing('.')[0]
1409
 
        parent = b.get_parent()
1410
 
        if remote is None:
1411
 
            if parent is None:
1412
 
                raise BzrCommandError("No missing location known or specified.")
1413
 
            else:
1414
 
                if not quiet:
1415
 
                    print "Using last location: %s" % parent
1416
 
                remote = parent
1417
 
        elif parent is None:
1418
 
            # We only update parent if it did not exist, missing
1419
 
            # should not change the parent
1420
 
            b.set_parent(remote)
1421
 
        br_remote = Branch.open_containing(remote)[0]
1422
 
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
 
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
1423
2478
 
1424
2479
 
1425
2480
class cmd_plugins(Command):
1426
2481
    """List plugins"""
1427
2482
    hidden = True
 
2483
    @display_command
1428
2484
    def run(self):
1429
2485
        import bzrlib.plugin
1430
2486
        from inspect import getdoc
1431
 
        for plugin in bzrlib.plugin.all_plugins:
 
2487
        for name, plugin in bzrlib.plugin.all_plugins().items():
1432
2488
            if hasattr(plugin, '__path__'):
1433
2489
                print plugin.__path__[0]
1434
2490
            elif hasattr(plugin, '__file__'):
1443
2499
 
1444
2500
class cmd_testament(Command):
1445
2501
    """Show testament (signing-form) of a revision."""
1446
 
    takes_options = ['revision', 'long']
 
2502
    takes_options = ['revision', 'long', 
 
2503
                     Option('strict', help='Produce a strict-format'
 
2504
                            ' testament')]
1447
2505
    takes_args = ['branch?']
1448
 
    def run(self, branch='.', revision=None, long=False):
1449
 
        from bzrlib.testament import Testament
1450
 
        b = Branch.open_containing(branch)[0]
 
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
1451
2514
        b.lock_read()
1452
2515
        try:
1453
2516
            if revision is None:
1454
2517
                rev_id = b.last_revision()
1455
2518
            else:
1456
2519
                rev_id = revision[0].in_history(b).rev_id
1457
 
            t = Testament.from_revision(b, rev_id)
 
2520
            t = testament_class.from_revision(b.repository, rev_id)
1458
2521
            if long:
1459
2522
                sys.stdout.writelines(t.as_text_lines())
1460
2523
            else:
1473
2536
    shown only at the top, unless the --all option is given.
1474
2537
    """
1475
2538
    # TODO: annotate directories; showing when each file was last changed
1476
 
    # TODO: annotate a previous version of a file
1477
2539
    # TODO: if the working copy is modified, show annotations on that 
1478
2540
    #       with new uncommitted lines marked
1479
 
    aliases = ['blame', 'praise']
 
2541
    aliases = ['ann', 'blame', 'praise']
1480
2542
    takes_args = ['filename']
1481
2543
    takes_options = [Option('all', help='show annotations on all lines'),
1482
2544
                     Option('long', help='show date in annotations'),
 
2545
                     'revision'
1483
2546
                     ]
1484
2547
 
1485
 
    def run(self, filename, all=False, long=False):
 
2548
    @display_command
 
2549
    def run(self, filename, all=False, long=False, revision=None):
1486
2550
        from bzrlib.annotate import annotate_file
1487
 
        b, relpath = Branch.open_containing(filename)
1488
 
        b.lock_read()
 
2551
        tree, relpath = WorkingTree.open_containing(filename)
 
2552
        branch = tree.branch
 
2553
        branch.lock_read()
1489
2554
        try:
1490
 
            tree = WorkingTree(b.base, b)
1491
 
            tree = b.revision_tree(b.last_revision())
 
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
1492
2561
            file_id = tree.inventory.path2id(relpath)
 
2562
            tree = branch.repository.revision_tree(revision_id)
1493
2563
            file_version = tree.inventory[file_id].revision
1494
 
            annotate_file(b, file_version, file_id, long, all, sys.stdout)
 
2564
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1495
2565
        finally:
1496
 
            b.unlock()
 
2566
            branch.unlock()
1497
2567
 
1498
2568
 
1499
2569
class cmd_re_sign(Command):
1501
2571
    # TODO be able to replace existing ones.
1502
2572
 
1503
2573
    hidden = True # is this right ?
1504
 
    takes_args = ['revision_id?']
 
2574
    takes_args = ['revision_id*']
1505
2575
    takes_options = ['revision']
1506
2576
    
1507
 
    def run(self, revision_id=None, revision=None):
1508
 
        import bzrlib.config as config
 
2577
    def run(self, revision_id_list=None, revision=None):
1509
2578
        import bzrlib.gpg as gpg
1510
 
        if revision_id is not None and revision is not None:
 
2579
        if revision_id_list is not None and revision is not None:
1511
2580
            raise BzrCommandError('You can only supply one of revision_id or --revision')
1512
 
        if revision_id is None and revision is None:
 
2581
        if revision_id_list is None and revision is None:
1513
2582
            raise BzrCommandError('You must supply either --revision or a revision_id')
1514
 
        b = Branch.open_containing('.')[0]
1515
 
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1516
 
        if revision_id is not None:
1517
 
            b.sign_revision(revision_id, gpg_strategy)
 
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)
1518
2588
        elif revision is not None:
1519
 
            for rev in revision:
1520
 
                if rev is None:
1521
 
                    raise BzrCommandError('You cannot specify a NULL revision.')
1522
 
                revno, rev_id = rev.in_history(b)
1523
 
                b.sign_revision(rev_id, gpg_strategy)
 
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
1524
2818
 
1525
2819
 
1526
2820
# these get imported and then picked up by the scan for cmd_*
1527
2821
# TODO: Some more consistent way to split command definitions across files;
1528
2822
# we do need to load at least some information about them to know of 
1529
 
# aliases.
1530
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
 
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