/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2005-08-29 04:17:33 UTC
  • Revision ID: mbp@sourcefrog.net-20050829041732-675d3efcd9fd1875
- check command writes output through logging not direct
  to stdout

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
 
1
# Copyright (C) 2004, 2005 by Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
# TODO: Split the command framework away from the actual commands.
 
19
 
 
20
# TODO: probably should say which arguments are candidates for glob
 
21
# expansion on windows and do that at the command level.
 
22
 
 
23
# TODO: Help messages for options.
 
24
 
 
25
# TODO: Define arguments by objects, rather than just using names.
 
26
# Those objects can specify the expected type of the argument, which
 
27
# would help with validation and shell completion.
 
28
 
 
29
 
 
30
import sys
 
31
import os
 
32
 
 
33
import bzrlib
 
34
import bzrlib.trace
 
35
from bzrlib.trace import mutter, note, log_error, warning
 
36
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
 
37
from bzrlib.branch import find_branch
 
38
from bzrlib import BZRDIR
 
39
 
 
40
 
 
41
plugin_cmds = {}
 
42
 
 
43
 
 
44
def register_command(cmd):
 
45
    "Utility function to help register a command"
 
46
    global plugin_cmds
 
47
    k = cmd.__name__
 
48
    if k.startswith("cmd_"):
 
49
        k_unsquished = _unsquish_command_name(k)
 
50
    else:
 
51
        k_unsquished = k
 
52
    if not plugin_cmds.has_key(k_unsquished):
 
53
        plugin_cmds[k_unsquished] = cmd
 
54
    else:
 
55
        log_error('Two plugins defined the same command: %r' % k)
 
56
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
57
 
 
58
 
 
59
def _squish_command_name(cmd):
 
60
    return 'cmd_' + cmd.replace('-', '_')
 
61
 
 
62
 
 
63
def _unsquish_command_name(cmd):
 
64
    assert cmd.startswith("cmd_")
 
65
    return cmd[4:].replace('_','-')
 
66
 
 
67
 
 
68
def _parse_revision_str(revstr):
 
69
    """This handles a revision string -> revno.
 
70
 
 
71
    This always returns a list.  The list will have one element for 
 
72
 
 
73
    It supports integers directly, but everything else it
 
74
    defers for passing to Branch.get_revision_info()
 
75
 
 
76
    >>> _parse_revision_str('234')
 
77
    [234]
 
78
    >>> _parse_revision_str('234..567')
 
79
    [234, 567]
 
80
    >>> _parse_revision_str('..')
 
81
    [None, None]
 
82
    >>> _parse_revision_str('..234')
 
83
    [None, 234]
 
84
    >>> _parse_revision_str('234..')
 
85
    [234, None]
 
86
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
 
87
    [234, 456, 789]
 
88
    >>> _parse_revision_str('234....789') # Error?
 
89
    [234, None, 789]
 
90
    >>> _parse_revision_str('revid:test@other.com-234234')
 
91
    ['revid:test@other.com-234234']
 
92
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
 
93
    ['revid:test@other.com-234234', 'revid:test@other.com-234235']
 
94
    >>> _parse_revision_str('revid:test@other.com-234234..23')
 
95
    ['revid:test@other.com-234234', 23]
 
96
    >>> _parse_revision_str('date:2005-04-12')
 
97
    ['date:2005-04-12']
 
98
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
 
99
    ['date:2005-04-12 12:24:33']
 
100
    >>> _parse_revision_str('date:2005-04-12T12:24:33')
 
101
    ['date:2005-04-12T12:24:33']
 
102
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
 
103
    ['date:2005-04-12,12:24:33']
 
104
    >>> _parse_revision_str('-5..23')
 
105
    [-5, 23]
 
106
    >>> _parse_revision_str('-5')
 
107
    [-5]
 
108
    >>> _parse_revision_str('123a')
 
109
    ['123a']
 
110
    >>> _parse_revision_str('abc')
 
111
    ['abc']
 
112
    """
 
113
    import re
 
114
    old_format_re = re.compile('\d*:\d*')
 
115
    m = old_format_re.match(revstr)
 
116
    if m:
 
117
        warning('Colon separator for revision numbers is deprecated.'
 
118
                ' Use .. instead')
 
119
        revs = []
 
120
        for rev in revstr.split(':'):
 
121
            if rev:
 
122
                revs.append(int(rev))
 
123
            else:
 
124
                revs.append(None)
 
125
        return revs
 
126
    revs = []
 
127
    for x in revstr.split('..'):
 
128
        if not x:
 
129
            revs.append(None)
 
130
        else:
 
131
            try:
 
132
                revs.append(int(x))
 
133
            except ValueError:
 
134
                revs.append(x)
 
135
    return revs
 
136
 
 
137
 
 
138
def get_merge_type(typestring):
 
139
    """Attempt to find the merge class/factory associated with a string."""
 
140
    from merge import merge_types
 
141
    try:
 
142
        return merge_types[typestring][0]
 
143
    except KeyError:
 
144
        templ = '%s%%7s: %%s' % (' '*12)
 
145
        lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
 
146
        type_list = '\n'.join(lines)
 
147
        msg = "No known merge type %s. Supported types are:\n%s" %\
 
148
            (typestring, type_list)
 
149
        raise BzrCommandError(msg)
 
150
    
 
151
 
 
152
def get_merge_type(typestring):
 
153
    """Attempt to find the merge class/factory associated with a string."""
 
154
    from merge import merge_types
 
155
    try:
 
156
        return merge_types[typestring][0]
 
157
    except KeyError:
 
158
        templ = '%s%%7s: %%s' % (' '*12)
 
159
        lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
 
160
        type_list = '\n'.join(lines)
 
161
        msg = "No known merge type %s. Supported types are:\n%s" %\
 
162
            (typestring, type_list)
 
163
        raise BzrCommandError(msg)
 
164
    
 
165
 
 
166
 
 
167
def _get_cmd_dict(plugins_override=True):
 
168
    d = {}
 
169
    for k, v in globals().iteritems():
 
170
        if k.startswith("cmd_"):
 
171
            d[_unsquish_command_name(k)] = v
 
172
    # If we didn't load plugins, the plugin_cmds dict will be empty
 
173
    if plugins_override:
 
174
        d.update(plugin_cmds)
 
175
    else:
 
176
        d2 = plugin_cmds.copy()
 
177
        d2.update(d)
 
178
        d = d2
 
179
    return d
 
180
 
 
181
    
 
182
def get_all_cmds(plugins_override=True):
 
183
    """Return canonical name and class for all registered commands."""
 
184
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
 
185
        yield k,v
 
186
 
 
187
 
 
188
def get_cmd_class(cmd, plugins_override=True):
 
189
    """Return the canonical name and command class for a command.
 
190
    """
 
191
    cmd = str(cmd)                      # not unicode
 
192
 
 
193
    # first look up this command under the specified name
 
194
    cmds = _get_cmd_dict(plugins_override=plugins_override)
 
195
    try:
 
196
        return cmd, cmds[cmd]
 
197
    except KeyError:
 
198
        pass
 
199
 
 
200
    # look for any command which claims this as an alias
 
201
    for cmdname, cmdclass in cmds.iteritems():
 
202
        if cmd in cmdclass.aliases:
 
203
            return cmdname, cmdclass
 
204
 
 
205
    cmdclass = ExternalCommand.find_command(cmd)
 
206
    if cmdclass:
 
207
        return cmd, cmdclass
 
208
 
 
209
    raise BzrCommandError("unknown command %r" % cmd)
 
210
 
 
211
 
 
212
class Command(object):
 
213
    """Base class for commands.
 
214
 
 
215
    The docstring for an actual command should give a single-line
 
216
    summary, then a complete description of the command.  A grammar
 
217
    description will be inserted.
 
218
 
 
219
    takes_args
 
220
        List of argument forms, marked with whether they are optional,
 
221
        repeated, etc.
 
222
 
 
223
    takes_options
 
224
        List of options that may be given for this command.
 
225
 
 
226
    hidden
 
227
        If true, this command isn't advertised.
 
228
    """
 
229
    aliases = []
 
230
    
 
231
    takes_args = []
 
232
    takes_options = []
 
233
 
 
234
    hidden = False
 
235
    
 
236
    def __init__(self, options, arguments):
 
237
        """Construct and run the command.
 
238
 
 
239
        Sets self.status to the return value of run()."""
 
240
        assert isinstance(options, dict)
 
241
        assert isinstance(arguments, dict)
 
242
        cmdargs = options.copy()
 
243
        cmdargs.update(arguments)
 
244
        if self.__doc__ == Command.__doc__:
 
245
            from warnings import warn
 
246
            warn("No help message set for %r" % self)
 
247
        self.status = self.run(**cmdargs)
 
248
        if self.status is None:
 
249
            self.status = 0
 
250
 
 
251
    
 
252
    def run(self):
 
253
        """Override this in sub-classes.
 
254
 
 
255
        This is invoked with the options and arguments bound to
 
256
        keyword parameters.
 
257
 
 
258
        Return 0 or None if the command was successful, or a shell
 
259
        error code if not.
 
260
        """
 
261
        return 0
 
262
 
 
263
 
 
264
class ExternalCommand(Command):
 
265
    """Class to wrap external commands.
 
266
 
 
267
    We cheat a little here, when get_cmd_class() calls us we actually
 
268
    give it back an object we construct that has the appropriate path,
 
269
    help, options etc for the specified command.
 
270
 
 
271
    When run_bzr() tries to instantiate that 'class' it gets caught by
 
272
    the __call__ method, which we override to call the Command.__init__
 
273
    method. That then calls our run method which is pretty straight
 
274
    forward.
 
275
 
 
276
    The only wrinkle is that we have to map bzr's dictionary of options
 
277
    and arguments back into command line options and arguments for the
 
278
    script.
 
279
    """
 
280
 
 
281
    def find_command(cls, cmd):
 
282
        import os.path
 
283
        bzrpath = os.environ.get('BZRPATH', '')
 
284
 
 
285
        for dir in bzrpath.split(os.pathsep):
 
286
            path = os.path.join(dir, cmd)
 
287
            if os.path.isfile(path):
 
288
                return ExternalCommand(path)
 
289
 
 
290
        return None
 
291
 
 
292
    find_command = classmethod(find_command)
 
293
 
 
294
    def __init__(self, path):
 
295
        self.path = path
 
296
 
 
297
        pipe = os.popen('%s --bzr-usage' % path, 'r')
 
298
        self.takes_options = pipe.readline().split()
 
299
 
 
300
        for opt in self.takes_options:
 
301
            if not opt in OPTIONS:
 
302
                raise BzrError("Unknown option '%s' returned by external command %s"
 
303
                               % (opt, path))
 
304
 
 
305
        # TODO: Is there any way to check takes_args is valid here?
 
306
        self.takes_args = pipe.readline().split()
 
307
 
 
308
        if pipe.close() is not None:
 
309
            raise BzrError("Failed funning '%s --bzr-usage'" % path)
 
310
 
 
311
        pipe = os.popen('%s --bzr-help' % path, 'r')
 
312
        self.__doc__ = pipe.read()
 
313
        if pipe.close() is not None:
 
314
            raise BzrError("Failed funning '%s --bzr-help'" % path)
 
315
 
 
316
    def __call__(self, options, arguments):
 
317
        Command.__init__(self, options, arguments)
 
318
        return self
 
319
 
 
320
    def run(self, **kargs):
 
321
        opts = []
 
322
        args = []
 
323
 
 
324
        keys = kargs.keys()
 
325
        keys.sort()
 
326
        for name in keys:
 
327
            optname = name.replace('_','-')
 
328
            value = kargs[name]
 
329
            if OPTIONS.has_key(optname):
 
330
                # it's an option
 
331
                opts.append('--%s' % optname)
 
332
                if value is not None and value is not True:
 
333
                    opts.append(str(value))
 
334
            else:
 
335
                # it's an arg, or arg list
 
336
                if type(value) is not list:
 
337
                    value = [value]
 
338
                for v in value:
 
339
                    if v is not None:
 
340
                        args.append(str(v))
 
341
 
 
342
        self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
 
343
        return self.status
 
344
 
 
345
 
 
346
class cmd_status(Command):
 
347
    """Display status summary.
 
348
 
 
349
    This reports on versioned and unknown files, reporting them
 
350
    grouped by state.  Possible states are:
 
351
 
 
352
    added
 
353
        Versioned in the working copy but not in the previous revision.
 
354
 
 
355
    removed
 
356
        Versioned in the previous revision but removed or deleted
 
357
        in the working copy.
 
358
 
 
359
    renamed
 
360
        Path of this file changed from the previous revision;
 
361
        the text may also have changed.  This includes files whose
 
362
        parent directory was renamed.
 
363
 
 
364
    modified
 
365
        Text has changed since the previous revision.
 
366
 
 
367
    unchanged
 
368
        Nothing about this file has changed since the previous revision.
 
369
        Only shown with --all.
 
370
 
 
371
    unknown
 
372
        Not versioned and not matching an ignore pattern.
 
373
 
 
374
    To see ignored files use 'bzr ignored'.  For details in the
 
375
    changes to file texts, use 'bzr diff'.
 
376
 
 
377
    If no arguments are specified, the status of the entire working
 
378
    directory is shown.  Otherwise, only the status of the specified
 
379
    files or directories is reported.  If a directory is given, status
 
380
    is reported for everything inside that directory.
 
381
 
 
382
    If a revision is specified, the changes since that revision are shown.
 
383
    """
 
384
    takes_args = ['file*']
 
385
    takes_options = ['all', 'show-ids', 'revision']
 
386
    aliases = ['st', 'stat']
 
387
    
 
388
    def run(self, all=False, show_ids=False, file_list=None):
 
389
        if file_list:
 
390
            b = find_branch(file_list[0])
 
391
            file_list = [b.relpath(x) for x in file_list]
 
392
            # special case: only one path was given and it's the root
 
393
            # of the branch
 
394
            if file_list == ['']:
 
395
                file_list = None
 
396
        else:
 
397
            b = find_branch('.')
 
398
            
 
399
        from bzrlib.status import show_status
 
400
        show_status(b, show_unchanged=all, show_ids=show_ids,
 
401
                    specific_files=file_list)
 
402
 
 
403
 
 
404
class cmd_cat_revision(Command):
 
405
    """Write out metadata for a revision."""
 
406
 
 
407
    hidden = True
 
408
    takes_args = ['revision_id']
 
409
    
 
410
    def run(self, revision_id):
 
411
        from bzrlib.xml import pack_xml
 
412
        pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
 
413
 
 
414
 
 
415
class cmd_revno(Command):
 
416
    """Show current revision number.
 
417
 
 
418
    This is equal to the number of revisions on this branch."""
 
419
    def run(self):
 
420
        print find_branch('.').revno()
 
421
 
 
422
class cmd_revision_info(Command):
 
423
    """Show revision number and revision id for a given revision identifier.
 
424
    """
 
425
    hidden = True
 
426
    takes_args = ['revision_info*']
 
427
    takes_options = ['revision']
 
428
    def run(self, revision=None, revision_info_list=None):
 
429
        from bzrlib.branch import find_branch
 
430
 
 
431
        revs = []
 
432
        if revision is not None:
 
433
            revs.extend(revision)
 
434
        if revision_info_list is not None:
 
435
            revs.extend(revision_info_list)
 
436
        if len(revs) == 0:
 
437
            raise BzrCommandError('You must supply a revision identifier')
 
438
 
 
439
        b = find_branch('.')
 
440
 
 
441
        for rev in revs:
 
442
            print '%4d %s' % b.get_revision_info(rev)
 
443
 
 
444
    
 
445
class cmd_add(Command):
 
446
    """Add specified files or directories.
 
447
 
 
448
    In non-recursive mode, all the named items are added, regardless
 
449
    of whether they were previously ignored.  A warning is given if
 
450
    any of the named files are already versioned.
 
451
 
 
452
    In recursive mode (the default), files are treated the same way
 
453
    but the behaviour for directories is different.  Directories that
 
454
    are already versioned do not give a warning.  All directories,
 
455
    whether already versioned or not, are searched for files or
 
456
    subdirectories that are neither versioned or ignored, and these
 
457
    are added.  This search proceeds recursively into versioned
 
458
    directories.  If no names are given '.' is assumed.
 
459
 
 
460
    Therefore simply saying 'bzr add' will version all files that
 
461
    are currently unknown.
 
462
 
 
463
    TODO: Perhaps adding a file whose directly is not versioned should
 
464
    recursively add that parent, rather than giving an error?
 
465
    """
 
466
    takes_args = ['file*']
 
467
    takes_options = ['verbose', 'no-recurse']
 
468
    
 
469
    def run(self, file_list, verbose=False, no_recurse=False):
 
470
        from bzrlib.add import smart_add
 
471
 
 
472
        recurse = not no_recurse
 
473
        for path, kind, file_id in smart_add(file_list, verbose, recurse):
 
474
            print 'added', path
 
475
 
 
476
 
 
477
 
 
478
class cmd_mkdir(Command):
 
479
    """Create a new versioned directory.
 
480
 
 
481
    This is equivalent to creating the directory and then adding it.
 
482
    """
 
483
    takes_args = ['dir+']
 
484
 
 
485
    def run(self, dir_list):
 
486
        b = None
 
487
        
 
488
        for d in dir_list:
 
489
            os.mkdir(d)
 
490
            if not b:
 
491
                b = find_branch(d)
 
492
            b.add([d])
 
493
            print 'added', d
 
494
 
 
495
 
 
496
class cmd_relpath(Command):
 
497
    """Show path of a file relative to root"""
 
498
    takes_args = ['filename']
 
499
    hidden = True
 
500
    
 
501
    def run(self, filename):
 
502
        print find_branch(filename).relpath(filename)
 
503
 
 
504
 
 
505
 
 
506
class cmd_inventory(Command):
 
507
    """Show inventory of the current working copy or a revision."""
 
508
    takes_options = ['revision', 'show-ids']
 
509
    
 
510
    def run(self, revision=None, show_ids=False):
 
511
        b = find_branch('.')
 
512
        if revision == None:
 
513
            inv = b.read_working_inventory()
 
514
        else:
 
515
            if len(revision) > 1:
 
516
                raise BzrCommandError('bzr inventory --revision takes'
 
517
                    ' exactly one revision identifier')
 
518
            inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
 
519
 
 
520
        for path, entry in inv.entries():
 
521
            if show_ids:
 
522
                print '%-50s %s' % (path, entry.file_id)
 
523
            else:
 
524
                print path
 
525
 
 
526
 
 
527
class cmd_move(Command):
 
528
    """Move files to a different directory.
 
529
 
 
530
    examples:
 
531
        bzr move *.txt doc
 
532
 
 
533
    The destination must be a versioned directory in the same branch.
 
534
    """
 
535
    takes_args = ['source$', 'dest']
 
536
    def run(self, source_list, dest):
 
537
        b = find_branch('.')
 
538
 
 
539
        # TODO: glob expansion on windows?
 
540
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
 
541
 
 
542
 
 
543
class cmd_rename(Command):
 
544
    """Change the name of an entry.
 
545
 
 
546
    examples:
 
547
      bzr rename frob.c frobber.c
 
548
      bzr rename src/frob.c lib/frob.c
 
549
 
 
550
    It is an error if the destination name exists.
 
551
 
 
552
    See also the 'move' command, which moves files into a different
 
553
    directory without changing their name.
 
554
 
 
555
    TODO: Some way to rename multiple files without invoking bzr for each
 
556
    one?"""
 
557
    takes_args = ['from_name', 'to_name']
 
558
    
 
559
    def run(self, from_name, to_name):
 
560
        b = find_branch('.')
 
561
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
 
562
 
 
563
 
 
564
 
 
565
class cmd_mv(Command):
 
566
    """Move or rename a file.
 
567
 
 
568
    usage:
 
569
        bzr mv OLDNAME NEWNAME
 
570
        bzr mv SOURCE... DESTINATION
 
571
 
 
572
    If the last argument is a versioned directory, all the other names
 
573
    are moved into it.  Otherwise, there must be exactly two arguments
 
574
    and the file is changed to a new name, which must not already exist.
 
575
 
 
576
    Files cannot be moved between branches.
 
577
    """
 
578
    takes_args = ['names*']
 
579
    def run(self, names_list):
 
580
        if len(names_list) < 2:
 
581
            raise BzrCommandError("missing file argument")
 
582
        b = find_branch(names_list[0])
 
583
 
 
584
        rel_names = [b.relpath(x) for x in names_list]
 
585
        
 
586
        if os.path.isdir(names_list[-1]):
 
587
            # move into existing directory
 
588
            b.move(rel_names[:-1], rel_names[-1])
 
589
        else:
 
590
            if len(names_list) != 2:
 
591
                raise BzrCommandError('to mv multiple files the destination '
 
592
                                      'must be a versioned directory')
 
593
            b.move(rel_names[0], rel_names[1])
 
594
            
 
595
    
 
596
 
 
597
 
 
598
class cmd_pull(Command):
 
599
    """Pull any changes from another branch into the current one.
 
600
 
 
601
    If the location is omitted, the last-used location will be used.
 
602
    Both the revision history and the working directory will be
 
603
    updated.
 
604
 
 
605
    This command only works on branches that have not diverged.  Branches are
 
606
    considered diverged if both branches have had commits without first
 
607
    pulling from the other.
 
608
 
 
609
    If branches have diverged, you can use 'bzr merge' to pull the text changes
 
610
    from one into the other.
 
611
    """
 
612
    takes_args = ['location?']
 
613
 
 
614
    def run(self, location=None):
 
615
        from bzrlib.merge import merge
 
616
        import tempfile
 
617
        from shutil import rmtree
 
618
        import errno
 
619
        
 
620
        br_to = find_branch('.')
 
621
        stored_loc = None
 
622
        try:
 
623
            stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
 
624
        except IOError, e:
 
625
            if e.errno != errno.ENOENT:
 
626
                raise
 
627
        if location is None:
 
628
            if stored_loc is None:
 
629
                raise BzrCommandError("No pull location known or specified.")
 
630
            else:
 
631
                print "Using last location: %s" % stored_loc
 
632
                location = stored_loc
 
633
        cache_root = tempfile.mkdtemp()
 
634
        from bzrlib.branch import DivergedBranches
 
635
        br_from = find_branch(location)
 
636
        location = pull_loc(br_from)
 
637
        old_revno = br_to.revno()
 
638
        try:
 
639
            from branch import find_cached_branch, DivergedBranches
 
640
            br_from = find_cached_branch(location, cache_root)
 
641
            location = pull_loc(br_from)
 
642
            old_revno = br_to.revno()
 
643
            try:
 
644
                br_to.update_revisions(br_from)
 
645
            except DivergedBranches:
 
646
                raise BzrCommandError("These branches have diverged."
 
647
                    "  Try merge.")
 
648
                
 
649
            merge(('.', -1), ('.', old_revno), check_clean=False)
 
650
            if location != stored_loc:
 
651
                br_to.controlfile("x-pull", "wb").write(location + "\n")
 
652
        finally:
 
653
            rmtree(cache_root)
 
654
 
 
655
 
 
656
 
 
657
class cmd_branch(Command):
 
658
    """Create a new copy of a branch.
 
659
 
 
660
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
 
661
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
 
662
 
 
663
    To retrieve the branch as of a particular revision, supply the --revision
 
664
    parameter, as in "branch foo/bar -r 5".
 
665
    """
 
666
    takes_args = ['from_location', 'to_location?']
 
667
    takes_options = ['revision']
 
668
    aliases = ['get', 'clone']
 
669
 
 
670
    def run(self, from_location, to_location=None, revision=None):
 
671
        import errno
 
672
        from bzrlib.merge import merge
 
673
        from bzrlib.branch import DivergedBranches, \
 
674
             find_cached_branch, Branch
 
675
        from shutil import rmtree
 
676
        from meta_store import CachedStore
 
677
        import tempfile
 
678
        cache_root = tempfile.mkdtemp()
 
679
 
 
680
        if revision is None:
 
681
            revision = [None]
 
682
        elif len(revision) > 1:
 
683
            raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
 
684
 
 
685
        try:
 
686
            try:
 
687
                br_from = find_cached_branch(from_location, cache_root)
 
688
            except OSError, e:
 
689
                if e.errno == errno.ENOENT:
 
690
                    raise BzrCommandError('Source location "%s" does not'
 
691
                                          ' exist.' % to_location)
 
692
                else:
 
693
                    raise
 
694
 
 
695
            if to_location is None:
 
696
                to_location = os.path.basename(from_location.rstrip("/\\"))
 
697
 
 
698
            try:
 
699
                os.mkdir(to_location)
 
700
            except OSError, e:
 
701
                if e.errno == errno.EEXIST:
 
702
                    raise BzrCommandError('Target directory "%s" already'
 
703
                                          ' exists.' % to_location)
 
704
                if e.errno == errno.ENOENT:
 
705
                    raise BzrCommandError('Parent of "%s" does not exist.' %
 
706
                                          to_location)
 
707
                else:
 
708
                    raise
 
709
            br_to = Branch(to_location, init=True)
 
710
 
 
711
            br_to.set_root_id(br_from.get_root_id())
 
712
 
 
713
            if revision:
 
714
                if revision[0] is None:
 
715
                    revno = br_from.revno()
 
716
                else:
 
717
                    revno, rev_id = br_from.get_revision_info(revision[0])
 
718
                try:
 
719
                    br_to.update_revisions(br_from, stop_revision=revno)
 
720
                except bzrlib.errors.NoSuchRevision:
 
721
                    rmtree(to_location)
 
722
                    msg = "The branch %s has no revision %d." % (from_location,
 
723
                                                                 revno)
 
724
                    raise BzrCommandError(msg)
 
725
 
 
726
            merge((to_location, -1), (to_location, 0), this_dir=to_location,
 
727
                  check_clean=False, ignore_zero=True)
 
728
            from_location = pull_loc(br_from)
 
729
            br_to.controlfile("x-pull", "wb").write(from_location + "\n")
 
730
        finally:
 
731
            rmtree(cache_root)
 
732
 
 
733
 
 
734
def pull_loc(branch):
 
735
    # TODO: Should perhaps just make attribute be 'base' in
 
736
    # RemoteBranch and Branch?
 
737
    if hasattr(branch, "baseurl"):
 
738
        return branch.baseurl
 
739
    else:
 
740
        return branch.base
 
741
 
 
742
 
 
743
 
 
744
class cmd_renames(Command):
 
745
    """Show list of renamed files.
 
746
 
 
747
    TODO: Option to show renames between two historical versions.
 
748
 
 
749
    TODO: Only show renames under dir, rather than in the whole branch.
 
750
    """
 
751
    takes_args = ['dir?']
 
752
 
 
753
    def run(self, dir='.'):
 
754
        b = find_branch(dir)
 
755
        old_inv = b.basis_tree().inventory
 
756
        new_inv = b.read_working_inventory()
 
757
 
 
758
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
 
759
        renames.sort()
 
760
        for old_name, new_name in renames:
 
761
            print "%s => %s" % (old_name, new_name)        
 
762
 
 
763
 
 
764
class cmd_info(Command):
 
765
    """Show statistical information about a branch."""
 
766
    takes_args = ['branch?']
 
767
    
 
768
    def run(self, branch=None):
 
769
        import info
 
770
 
 
771
        b = find_branch(branch)
 
772
        info.show_info(b)
 
773
 
 
774
 
 
775
class cmd_remove(Command):
 
776
    """Make a file unversioned.
 
777
 
 
778
    This makes bzr stop tracking changes to a versioned file.  It does
 
779
    not delete the working copy.
 
780
    """
 
781
    takes_args = ['file+']
 
782
    takes_options = ['verbose']
 
783
    
 
784
    def run(self, file_list, verbose=False):
 
785
        b = find_branch(file_list[0])
 
786
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
 
787
 
 
788
 
 
789
class cmd_file_id(Command):
 
790
    """Print file_id of a particular file or directory.
 
791
 
 
792
    The file_id is assigned when the file is first added and remains the
 
793
    same through all revisions where the file exists, even when it is
 
794
    moved or renamed.
 
795
    """
 
796
    hidden = True
 
797
    takes_args = ['filename']
 
798
    def run(self, filename):
 
799
        b = find_branch(filename)
 
800
        i = b.inventory.path2id(b.relpath(filename))
 
801
        if i == None:
 
802
            raise BzrError("%r is not a versioned file" % filename)
 
803
        else:
 
804
            print i
 
805
 
 
806
 
 
807
class cmd_file_path(Command):
 
808
    """Print path of file_ids to a file or directory.
 
809
 
 
810
    This prints one line for each directory down to the target,
 
811
    starting at the branch root."""
 
812
    hidden = True
 
813
    takes_args = ['filename']
 
814
    def run(self, filename):
 
815
        b = find_branch(filename)
 
816
        inv = b.inventory
 
817
        fid = inv.path2id(b.relpath(filename))
 
818
        if fid == None:
 
819
            raise BzrError("%r is not a versioned file" % filename)
 
820
        for fip in inv.get_idpath(fid):
 
821
            print fip
 
822
 
 
823
 
 
824
class cmd_revision_history(Command):
 
825
    """Display list of revision ids on this branch."""
 
826
    hidden = True
 
827
    def run(self):
 
828
        for patchid in find_branch('.').revision_history():
 
829
            print patchid
 
830
 
 
831
 
 
832
class cmd_directories(Command):
 
833
    """Display list of versioned directories in this branch."""
 
834
    def run(self):
 
835
        for name, ie in find_branch('.').read_working_inventory().directories():
 
836
            if name == '':
 
837
                print '.'
 
838
            else:
 
839
                print name
 
840
 
 
841
 
 
842
class cmd_init(Command):
 
843
    """Make a directory into a versioned branch.
 
844
 
 
845
    Use this to create an empty branch, or before importing an
 
846
    existing project.
 
847
 
 
848
    Recipe for importing a tree of files:
 
849
        cd ~/project
 
850
        bzr init
 
851
        bzr add -v .
 
852
        bzr status
 
853
        bzr commit -m 'imported project'
 
854
    """
 
855
    def run(self):
 
856
        from bzrlib.branch import Branch
 
857
        Branch('.', init=True)
 
858
 
 
859
 
 
860
class cmd_diff(Command):
 
861
    """Show differences in working tree.
 
862
    
 
863
    If files are listed, only the changes in those files are listed.
 
864
    Otherwise, all changes for the tree are listed.
 
865
 
 
866
    TODO: Allow diff across branches.
 
867
 
 
868
    TODO: Option to use external diff command; could be GNU diff, wdiff,
 
869
          or a graphical diff.
 
870
 
 
871
    TODO: Python difflib is not exactly the same as unidiff; should
 
872
          either fix it up or prefer to use an external diff.
 
873
 
 
874
    TODO: If a directory is given, diff everything under that.
 
875
 
 
876
    TODO: Selected-file diff is inefficient and doesn't show you
 
877
          deleted files.
 
878
 
 
879
    TODO: This probably handles non-Unix newlines poorly.
 
880
 
 
881
    examples:
 
882
        bzr diff
 
883
        bzr diff -r1
 
884
        bzr diff -r1:2
 
885
    """
 
886
    
 
887
    takes_args = ['file*']
 
888
    takes_options = ['revision', 'diff-options']
 
889
    aliases = ['di', 'dif']
 
890
 
 
891
    def run(self, revision=None, file_list=None, diff_options=None):
 
892
        from bzrlib.diff import show_diff
 
893
 
 
894
        if file_list:
 
895
            b = find_branch(file_list[0])
 
896
            file_list = [b.relpath(f) for f in file_list]
 
897
            if file_list == ['']:
 
898
                # just pointing to top-of-tree
 
899
                file_list = None
 
900
        else:
 
901
            b = find_branch('.')
 
902
 
 
903
        if revision is not None:
 
904
            if len(revision) == 1:
 
905
                show_diff(b, revision[0], specific_files=file_list,
 
906
                          external_diff_options=diff_options)
 
907
            elif len(revision) == 2:
 
908
                show_diff(b, revision[0], specific_files=file_list,
 
909
                          external_diff_options=diff_options,
 
910
                          revision2=revision[1])
 
911
            else:
 
912
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
 
913
        else:
 
914
            show_diff(b, None, specific_files=file_list,
 
915
                      external_diff_options=diff_options)
 
916
 
 
917
        
 
918
 
 
919
 
 
920
class cmd_deleted(Command):
 
921
    """List files deleted in the working tree.
 
922
 
 
923
    TODO: Show files deleted since a previous revision, or between two revisions.
 
924
    """
 
925
    def run(self, show_ids=False):
 
926
        b = find_branch('.')
 
927
        old = b.basis_tree()
 
928
        new = b.working_tree()
 
929
 
 
930
        ## TODO: Much more efficient way to do this: read in new
 
931
        ## directories with readdir, rather than stating each one.  Same
 
932
        ## level of effort but possibly much less IO.  (Or possibly not,
 
933
        ## if the directories are very large...)
 
934
 
 
935
        for path, ie in old.inventory.iter_entries():
 
936
            if not new.has_id(ie.file_id):
 
937
                if show_ids:
 
938
                    print '%-50s %s' % (path, ie.file_id)
 
939
                else:
 
940
                    print path
 
941
 
 
942
 
 
943
class cmd_modified(Command):
 
944
    """List files modified in working tree."""
 
945
    hidden = True
 
946
    def run(self):
 
947
        from bzrlib.delta import compare_trees
 
948
 
 
949
        b = find_branch('.')
 
950
        td = compare_trees(b.basis_tree(), b.working_tree())
 
951
 
 
952
        for path, id, kind in td.modified:
 
953
            print path
 
954
 
 
955
 
 
956
 
 
957
class cmd_added(Command):
 
958
    """List files added in working tree."""
 
959
    hidden = True
 
960
    def run(self):
 
961
        b = find_branch('.')
 
962
        wt = b.working_tree()
 
963
        basis_inv = b.basis_tree().inventory
 
964
        inv = wt.inventory
 
965
        for file_id in inv:
 
966
            if file_id in basis_inv:
 
967
                continue
 
968
            path = inv.id2path(file_id)
 
969
            if not os.access(b.abspath(path), os.F_OK):
 
970
                continue
 
971
            print path
 
972
                
 
973
        
 
974
 
 
975
class cmd_root(Command):
 
976
    """Show the tree root directory.
 
977
 
 
978
    The root is the nearest enclosing directory with a .bzr control
 
979
    directory."""
 
980
    takes_args = ['filename?']
 
981
    def run(self, filename=None):
 
982
        """Print the branch root."""
 
983
        b = find_branch(filename)
 
984
        print getattr(b, 'base', None) or getattr(b, 'baseurl')
 
985
 
 
986
 
 
987
class cmd_log(Command):
 
988
    """Show log of this branch.
 
989
 
 
990
    To request a range of logs, you can use the command -r begin:end
 
991
    -r revision requests a specific revision, -r :end or -r begin: are
 
992
    also valid.
 
993
 
 
994
    --message allows you to give a regular expression, which will be evaluated
 
995
    so that only matching entries will be displayed.
 
996
 
 
997
    TODO: Make --revision support uuid: and hash: [future tag:] notation.
 
998
  
 
999
    """
 
1000
 
 
1001
    takes_args = ['filename?']
 
1002
    takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
 
1003
                     'long', 'message', 'short',]
 
1004
    
 
1005
    def run(self, filename=None, timezone='original',
 
1006
            verbose=False,
 
1007
            show_ids=False,
 
1008
            forward=False,
 
1009
            revision=None,
 
1010
            message=None,
 
1011
            long=False,
 
1012
            short=False):
 
1013
        from bzrlib.branch import find_branch
 
1014
        from bzrlib.log import log_formatter, show_log
 
1015
        import codecs
 
1016
 
 
1017
        direction = (forward and 'forward') or 'reverse'
 
1018
        
 
1019
        if filename:
 
1020
            b = find_branch(filename)
 
1021
            fp = b.relpath(filename)
 
1022
            if fp:
 
1023
                file_id = b.read_working_inventory().path2id(fp)
 
1024
            else:
 
1025
                file_id = None  # points to branch root
 
1026
        else:
 
1027
            b = find_branch('.')
 
1028
            file_id = None
 
1029
 
 
1030
        if revision is None:
 
1031
            rev1 = None
 
1032
            rev2 = None
 
1033
        elif len(revision) == 1:
 
1034
            rev1 = rev2 = b.get_revision_info(revision[0])[0]
 
1035
        elif len(revision) == 2:
 
1036
            rev1 = b.get_revision_info(revision[0])[0]
 
1037
            rev2 = b.get_revision_info(revision[1])[0]
 
1038
        else:
 
1039
            raise BzrCommandError('bzr log --revision takes one or two values.')
 
1040
 
 
1041
        if rev1 == 0:
 
1042
            rev1 = None
 
1043
        if rev2 == 0:
 
1044
            rev2 = None
 
1045
 
 
1046
        mutter('encoding log as %r' % bzrlib.user_encoding)
 
1047
 
 
1048
        # use 'replace' so that we don't abort if trying to write out
 
1049
        # in e.g. the default C locale.
 
1050
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
1051
 
 
1052
        if not short:
 
1053
            log_format = 'long'
 
1054
        else:
 
1055
            log_format = 'short'
 
1056
        lf = log_formatter(log_format,
 
1057
                           show_ids=show_ids,
 
1058
                           to_file=outf,
 
1059
                           show_timezone=timezone)
 
1060
 
 
1061
        show_log(b,
 
1062
                 lf,
 
1063
                 file_id,
 
1064
                 verbose=verbose,
 
1065
                 direction=direction,
 
1066
                 start_revision=rev1,
 
1067
                 end_revision=rev2,
 
1068
                 search=message)
 
1069
 
 
1070
 
 
1071
 
 
1072
class cmd_touching_revisions(Command):
 
1073
    """Return revision-ids which affected a particular file.
 
1074
 
 
1075
    A more user-friendly interface is "bzr log FILE"."""
 
1076
    hidden = True
 
1077
    takes_args = ["filename"]
 
1078
    def run(self, filename):
 
1079
        b = find_branch(filename)
 
1080
        inv = b.read_working_inventory()
 
1081
        file_id = inv.path2id(b.relpath(filename))
 
1082
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
 
1083
            print "%6d %s" % (revno, what)
 
1084
 
 
1085
 
 
1086
class cmd_ls(Command):
 
1087
    """List files in a tree.
 
1088
 
 
1089
    TODO: Take a revision or remote path and list that tree instead.
 
1090
    """
 
1091
    hidden = True
 
1092
    def run(self, revision=None, verbose=False):
 
1093
        b = find_branch('.')
 
1094
        if revision == None:
 
1095
            tree = b.working_tree()
 
1096
        else:
 
1097
            tree = b.revision_tree(b.lookup_revision(revision))
 
1098
 
 
1099
        for fp, fc, kind, fid in tree.list_files():
 
1100
            if verbose:
 
1101
                if kind == 'directory':
 
1102
                    kindch = '/'
 
1103
                elif kind == 'file':
 
1104
                    kindch = ''
 
1105
                else:
 
1106
                    kindch = '???'
 
1107
 
 
1108
                print '%-8s %s%s' % (fc, fp, kindch)
 
1109
            else:
 
1110
                print fp
 
1111
 
 
1112
 
 
1113
 
 
1114
class cmd_unknowns(Command):
 
1115
    """List unknown files."""
 
1116
    def run(self):
 
1117
        from bzrlib.osutils import quotefn
 
1118
        for f in find_branch('.').unknowns():
 
1119
            print quotefn(f)
 
1120
 
 
1121
 
 
1122
 
 
1123
class cmd_ignore(Command):
 
1124
    """Ignore a command or pattern.
 
1125
 
 
1126
    To remove patterns from the ignore list, edit the .bzrignore file.
 
1127
 
 
1128
    If the pattern contains a slash, it is compared to the whole path
 
1129
    from the branch root.  Otherwise, it is comapred to only the last
 
1130
    component of the path.
 
1131
 
 
1132
    Ignore patterns are case-insensitive on case-insensitive systems.
 
1133
 
 
1134
    Note: wildcards must be quoted from the shell on Unix.
 
1135
 
 
1136
    examples:
 
1137
        bzr ignore ./Makefile
 
1138
        bzr ignore '*.class'
 
1139
    """
 
1140
    takes_args = ['name_pattern']
 
1141
    
 
1142
    def run(self, name_pattern):
 
1143
        from bzrlib.atomicfile import AtomicFile
 
1144
        import os.path
 
1145
 
 
1146
        b = find_branch('.')
 
1147
        ifn = b.abspath('.bzrignore')
 
1148
 
 
1149
        if os.path.exists(ifn):
 
1150
            f = open(ifn, 'rt')
 
1151
            try:
 
1152
                igns = f.read().decode('utf-8')
 
1153
            finally:
 
1154
                f.close()
 
1155
        else:
 
1156
            igns = ''
 
1157
 
 
1158
        # TODO: If the file already uses crlf-style termination, maybe
 
1159
        # we should use that for the newly added lines?
 
1160
 
 
1161
        if igns and igns[-1] != '\n':
 
1162
            igns += '\n'
 
1163
        igns += name_pattern + '\n'
 
1164
 
 
1165
        try:
 
1166
            f = AtomicFile(ifn, 'wt')
 
1167
            f.write(igns.encode('utf-8'))
 
1168
            f.commit()
 
1169
        finally:
 
1170
            f.close()
 
1171
 
 
1172
        inv = b.working_tree().inventory
 
1173
        if inv.path2id('.bzrignore'):
 
1174
            mutter('.bzrignore is already versioned')
 
1175
        else:
 
1176
            mutter('need to make new .bzrignore file versioned')
 
1177
            b.add(['.bzrignore'])
 
1178
 
 
1179
 
 
1180
 
 
1181
class cmd_ignored(Command):
 
1182
    """List ignored files and the patterns that matched them.
 
1183
 
 
1184
    See also: bzr ignore"""
 
1185
    def run(self):
 
1186
        tree = find_branch('.').working_tree()
 
1187
        for path, file_class, kind, file_id in tree.list_files():
 
1188
            if file_class != 'I':
 
1189
                continue
 
1190
            ## XXX: Slightly inefficient since this was already calculated
 
1191
            pat = tree.is_ignored(path)
 
1192
            print '%-50s %s' % (path, pat)
 
1193
 
 
1194
 
 
1195
class cmd_lookup_revision(Command):
 
1196
    """Lookup the revision-id from a revision-number
 
1197
 
 
1198
    example:
 
1199
        bzr lookup-revision 33
 
1200
    """
 
1201
    hidden = True
 
1202
    takes_args = ['revno']
 
1203
    
 
1204
    def run(self, revno):
 
1205
        try:
 
1206
            revno = int(revno)
 
1207
        except ValueError:
 
1208
            raise BzrCommandError("not a valid revision-number: %r" % revno)
 
1209
 
 
1210
        print find_branch('.').lookup_revision(revno)
 
1211
 
 
1212
 
 
1213
class cmd_export(Command):
 
1214
    """Export past revision to destination directory.
 
1215
 
 
1216
    If no revision is specified this exports the last committed revision.
 
1217
 
 
1218
    Format may be an "exporter" name, such as tar, tgz, tbz2.  If none is
 
1219
    given, try to find the format with the extension. If no extension
 
1220
    is found exports to a directory (equivalent to --format=dir).
 
1221
 
 
1222
    Root may be the top directory for tar, tgz and tbz2 formats. If none
 
1223
    is given, the top directory will be the root name of the file."""
 
1224
    # TODO: list known exporters
 
1225
    takes_args = ['dest']
 
1226
    takes_options = ['revision', 'format', 'root']
 
1227
    def run(self, dest, revision=None, format=None, root=None):
 
1228
        import os.path
 
1229
        b = find_branch('.')
 
1230
        if revision is None:
 
1231
            rev_id = b.last_patch()
 
1232
        else:
 
1233
            if len(revision) != 1:
 
1234
                raise BzrError('bzr export --revision takes exactly 1 argument')
 
1235
            revno, rev_id = b.get_revision_info(revision[0])
 
1236
        t = b.revision_tree(rev_id)
 
1237
        root, ext = os.path.splitext(dest)
 
1238
        if not format:
 
1239
            if ext in (".tar",):
 
1240
                format = "tar"
 
1241
            elif ext in (".gz", ".tgz"):
 
1242
                format = "tgz"
 
1243
            elif ext in (".bz2", ".tbz2"):
 
1244
                format = "tbz2"
 
1245
            else:
 
1246
                format = "dir"
 
1247
        t.export(dest, format, root)
 
1248
 
 
1249
 
 
1250
class cmd_cat(Command):
 
1251
    """Write a file's text from a previous revision."""
 
1252
 
 
1253
    takes_options = ['revision']
 
1254
    takes_args = ['filename']
 
1255
 
 
1256
    def run(self, filename, revision=None):
 
1257
        if revision == None:
 
1258
            raise BzrCommandError("bzr cat requires a revision number")
 
1259
        elif len(revision) != 1:
 
1260
            raise BzrCommandError("bzr cat --revision takes exactly one number")
 
1261
        b = find_branch('.')
 
1262
        b.print_file(b.relpath(filename), revision[0])
 
1263
 
 
1264
 
 
1265
class cmd_local_time_offset(Command):
 
1266
    """Show the offset in seconds from GMT to local time."""
 
1267
    hidden = True    
 
1268
    def run(self):
 
1269
        print bzrlib.osutils.local_time_offset()
 
1270
 
 
1271
 
 
1272
 
 
1273
class cmd_commit(Command):
 
1274
    """Commit changes into a new revision.
 
1275
    
 
1276
    If no arguments are given, the entire tree is committed.
 
1277
 
 
1278
    If selected files are specified, only changes to those files are
 
1279
    committed.  If a directory is specified then the directory and everything 
 
1280
    within it is committed.
 
1281
 
 
1282
    A selected-file commit may fail in some cases where the committed
 
1283
    tree would be invalid, such as trying to commit a file in a
 
1284
    newly-added directory that is not itself committed.
 
1285
 
 
1286
    TODO: Run hooks on tree to-be-committed, and after commit.
 
1287
 
 
1288
    TODO: Strict commit that fails if there are unknown or deleted files.
 
1289
    """
 
1290
    takes_args = ['selected*']
 
1291
    takes_options = ['message', 'file', 'verbose', 'unchanged']
 
1292
    aliases = ['ci', 'checkin']
 
1293
 
 
1294
    # TODO: Give better message for -s, --summary, used by tla people
 
1295
    
 
1296
    def run(self, message=None, file=None, verbose=True, selected_list=None,
 
1297
            unchanged=False):
 
1298
        from bzrlib.errors import PointlessCommit
 
1299
        from bzrlib.osutils import get_text_message
 
1300
 
 
1301
        ## Warning: shadows builtin file()
 
1302
        if not message and not file:
 
1303
            # FIXME: Ugly; change status code to send to a provided function?
 
1304
            
 
1305
            import cStringIO
 
1306
            stdout = sys.stdout
 
1307
            catcher = cStringIO.StringIO()
 
1308
            sys.stdout = catcher
 
1309
            cmd_status({"file_list":selected_list}, {})
 
1310
            info = catcher.getvalue()
 
1311
            sys.stdout = stdout
 
1312
            message = get_text_message(info)
 
1313
            
 
1314
            if message is None:
 
1315
                raise BzrCommandError("please specify a commit message",
 
1316
                                      ["use either --message or --file"])
 
1317
        elif message and file:
 
1318
            raise BzrCommandError("please specify either --message or --file")
 
1319
        
 
1320
        if file:
 
1321
            import codecs
 
1322
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
 
1323
 
 
1324
        b = find_branch('.')
 
1325
        if selected_list:
 
1326
            selected_list = [b.relpath(s) for s in selected_list]
 
1327
            
 
1328
        try:
 
1329
            b.commit(message, verbose=verbose,
 
1330
                     specific_files=selected_list,
 
1331
                     allow_pointless=unchanged)
 
1332
        except PointlessCommit:
 
1333
            # FIXME: This should really happen before the file is read in;
 
1334
            # perhaps prepare the commit; get the message; then actually commit
 
1335
            raise BzrCommandError("no changes to commit",
 
1336
                                  ["use --unchanged to commit anyhow"])
 
1337
 
 
1338
 
 
1339
class cmd_check(Command):
 
1340
    """Validate consistency of branch history.
 
1341
 
 
1342
    This command checks various invariants about the branch storage to
 
1343
    detect data corruption or bzr bugs.
 
1344
 
 
1345
    If given the --update flag, it will update some optional fields
 
1346
    to help ensure data consistency.
 
1347
    """
 
1348
    takes_args = ['dir?']
 
1349
 
 
1350
    def run(self, dir='.'):
 
1351
        from bzrlib.check import check
 
1352
 
 
1353
        check(find_branch(dir))
 
1354
 
 
1355
 
 
1356
class cmd_scan_cache(Command):
 
1357
    hidden = True
 
1358
    def run(self):
 
1359
        from bzrlib.hashcache import HashCache
 
1360
        import os
 
1361
 
 
1362
        c = HashCache('.')
 
1363
        c.read()
 
1364
        c.scan()
 
1365
            
 
1366
        print '%6d stats' % c.stat_count
 
1367
        print '%6d in hashcache' % len(c._cache)
 
1368
        print '%6d files removed from cache' % c.removed_count
 
1369
        print '%6d hashes updated' % c.update_count
 
1370
        print '%6d files changed too recently to cache' % c.danger_count
 
1371
 
 
1372
        if c.needs_write:
 
1373
            c.write()
 
1374
            
 
1375
 
 
1376
 
 
1377
class cmd_upgrade(Command):
 
1378
    """Upgrade branch storage to current format.
 
1379
 
 
1380
    The check command or bzr developers may sometimes advise you to run
 
1381
    this command.
 
1382
    """
 
1383
    takes_args = ['dir?']
 
1384
 
 
1385
    def run(self, dir='.'):
 
1386
        from bzrlib.upgrade import upgrade
 
1387
        upgrade(find_branch(dir))
 
1388
 
 
1389
 
 
1390
 
 
1391
class cmd_whoami(Command):
 
1392
    """Show bzr user id."""
 
1393
    takes_options = ['email']
 
1394
    
 
1395
    def run(self, email=False):
 
1396
        try:
 
1397
            b = bzrlib.branch.find_branch('.')
 
1398
        except:
 
1399
            b = None
 
1400
        
 
1401
        if email:
 
1402
            print bzrlib.osutils.user_email(b)
 
1403
        else:
 
1404
            print bzrlib.osutils.username(b)
 
1405
 
 
1406
 
 
1407
class cmd_selftest(Command):
 
1408
    """Run internal test suite"""
 
1409
    hidden = True
 
1410
    takes_options = ['verbose']
 
1411
    def run(self, verbose=False):
 
1412
        import bzrlib.ui
 
1413
        from bzrlib.selftest import selftest
 
1414
 
 
1415
        # we don't want progress meters from the tests to go to the
 
1416
        # real output; and we don't want log messages cluttering up
 
1417
        # the real logs.
 
1418
 
 
1419
        save_ui = bzrlib.ui.ui_factory
 
1420
        bzrlib.trace.info('running tests...')
 
1421
        try:
 
1422
            bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
1423
            result = selftest(verbose=verbose)
 
1424
            if result:
 
1425
                bzrlib.trace.info('tests passed')
 
1426
            else:
 
1427
                bzrlib.trace.info('tests failed')
 
1428
            return int(not result)
 
1429
        finally:
 
1430
            bzrlib.ui.ui_factory = save_ui
 
1431
 
 
1432
 
 
1433
class cmd_version(Command):
 
1434
    """Show version of bzr."""
 
1435
    def run(self):
 
1436
        show_version()
 
1437
 
 
1438
def show_version():
 
1439
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
1440
    # is bzrlib itself in a branch?
 
1441
    bzrrev = bzrlib.get_bzr_revision()
 
1442
    if bzrrev:
 
1443
        print "  (bzr checkout, revision %d {%s})" % bzrrev
 
1444
    print bzrlib.__copyright__
 
1445
    print "http://bazaar-ng.org/"
 
1446
    print
 
1447
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
 
1448
    print "you may use, modify and redistribute it under the terms of the GNU"
 
1449
    print "General Public License version 2 or later."
 
1450
 
 
1451
 
 
1452
class cmd_rocks(Command):
 
1453
    """Statement of optimism."""
 
1454
    hidden = True
 
1455
    def run(self):
 
1456
        print "it sure does!"
 
1457
 
 
1458
def parse_spec(spec):
 
1459
    """
 
1460
    >>> parse_spec(None)
 
1461
    [None, None]
 
1462
    >>> parse_spec("./")
 
1463
    ['./', None]
 
1464
    >>> parse_spec("../@")
 
1465
    ['..', -1]
 
1466
    >>> parse_spec("../f/@35")
 
1467
    ['../f', 35]
 
1468
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
 
1469
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
 
1470
    """
 
1471
    if spec is None:
 
1472
        return [None, None]
 
1473
    if '/@' in spec:
 
1474
        parsed = spec.split('/@')
 
1475
        assert len(parsed) == 2
 
1476
        if parsed[1] == "":
 
1477
            parsed[1] = -1
 
1478
        else:
 
1479
            try:
 
1480
                parsed[1] = int(parsed[1])
 
1481
            except ValueError:
 
1482
                pass # We can allow stuff like ./@revid:blahblahblah
 
1483
            else:
 
1484
                assert parsed[1] >=0
 
1485
    else:
 
1486
        parsed = [spec, None]
 
1487
    return parsed
 
1488
 
 
1489
 
 
1490
 
 
1491
class cmd_find_merge_base(Command):
 
1492
    """Find and print a base revision for merging two branches.
 
1493
 
 
1494
    TODO: Options to specify revisions on either side, as if
 
1495
          merging only part of the history.
 
1496
    """
 
1497
    takes_args = ['branch', 'other']
 
1498
    hidden = True
 
1499
    
 
1500
    def run(self, branch, other):
 
1501
        branch1 = find_branch(branch)
 
1502
        branch2 = find_branch(other)
 
1503
 
 
1504
        base_revno, base_revid = branch1.common_ancestor(branch2)
 
1505
 
 
1506
        if base_revno is None:
 
1507
            raise bzrlib.errors.UnrelatedBranches()
 
1508
 
 
1509
        print 'merge base is revision %s' % base_revid
 
1510
        print ' r%-6d in %s' % (base_revno, branch)
 
1511
 
 
1512
        other_revno = branch2.revision_id_to_revno(base_revid)
 
1513
        
 
1514
        print ' r%-6d in %s' % (other_revno, other)
 
1515
 
 
1516
 
 
1517
 
 
1518
class cmd_merge(Command):
 
1519
    """Perform a three-way merge.
 
1520
    
 
1521
    The branch is the branch you will merge from.  By default, it will merge
 
1522
    the latest revision.  If you specify a revision, that revision will be
 
1523
    merged.  If you specify two revisions, the first will be used as a BASE, 
 
1524
    and the second one as OTHER.  Revision numbers are always relative to the
 
1525
    specified branch.
 
1526
    
 
1527
    Examples:
 
1528
 
 
1529
    To merge the latest revision from bzr.dev
 
1530
    bzr merge ../bzr.dev
 
1531
 
 
1532
    To merge changes up to and including revision 82 from bzr.dev
 
1533
    bzr merge -r 82 ../bzr.dev
 
1534
 
 
1535
    To merge the changes introduced by 82, without previous changes:
 
1536
    bzr merge -r 81..82 ../bzr.dev
 
1537
    
 
1538
    merge refuses to run if there are any uncommitted changes, unless
 
1539
    --force is given.
 
1540
    """
 
1541
    takes_args = ['branch?']
 
1542
    takes_options = ['revision', 'force', 'merge-type']
 
1543
 
 
1544
    def run(self, branch='.', revision=None, force=False, 
 
1545
            merge_type=None):
 
1546
        from bzrlib.merge import merge
 
1547
        from bzrlib.merge_core import ApplyMerge3
 
1548
        if merge_type is None:
 
1549
            merge_type = ApplyMerge3
 
1550
 
 
1551
        if revision is None or len(revision) < 1:
 
1552
            base = (None, None)
 
1553
            other = (branch, -1)
 
1554
        else:
 
1555
            if len(revision) == 1:
 
1556
                other = (branch, revision[0])
 
1557
                base = (None, None)
 
1558
            else:
 
1559
                assert len(revision) == 2
 
1560
                if None in revision:
 
1561
                    raise BzrCommandError(
 
1562
                        "Merge doesn't permit that revision specifier.")
 
1563
                base = (branch, revision[0])
 
1564
                other = (branch, revision[1])
 
1565
            
 
1566
        merge(other, base, check_clean=(not force), merge_type=merge_type)
 
1567
 
 
1568
 
 
1569
class cmd_revert(Command):
 
1570
    """Reverse all changes since the last commit.
 
1571
 
 
1572
    Only versioned files are affected.  Specify filenames to revert only 
 
1573
    those files.  By default, any files that are changed will be backed up
 
1574
    first.  Backup files have a '~' appended to their name.
 
1575
    """
 
1576
    takes_options = ['revision', 'no-backup']
 
1577
    takes_args = ['file*']
 
1578
    aliases = ['merge-revert']
 
1579
 
 
1580
    def run(self, revision=None, no_backup=False, file_list=None):
 
1581
        from bzrlib.merge import merge
 
1582
        if file_list is not None:
 
1583
            if len(file_list) == 0:
 
1584
                raise BzrCommandError("No files specified")
 
1585
        if revision is None:
 
1586
            revision = [-1]
 
1587
        elif len(revision) != 1:
 
1588
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
 
1589
        merge(('.', revision[0]), parse_spec('.'),
 
1590
              check_clean=False,
 
1591
              ignore_zero=True,
 
1592
              backup_files=not no_backup,
 
1593
              file_list=file_list)
 
1594
 
 
1595
 
 
1596
class cmd_assert_fail(Command):
 
1597
    """Test reporting of assertion failures"""
 
1598
    hidden = True
 
1599
    def run(self):
 
1600
        assert False, "always fails"
 
1601
 
 
1602
 
 
1603
class cmd_help(Command):
 
1604
    """Show help on a command or other topic.
 
1605
 
 
1606
    For a list of all available commands, say 'bzr help commands'."""
 
1607
    takes_options = ['long']
 
1608
    takes_args = ['topic?']
 
1609
    aliases = ['?']
 
1610
    
 
1611
    def run(self, topic=None, long=False):
 
1612
        import help
 
1613
        if topic is None and long:
 
1614
            topic = "commands"
 
1615
        help.help(topic)
 
1616
 
 
1617
 
 
1618
class cmd_shell_complete(Command):
 
1619
    """Show appropriate completions for context.
 
1620
 
 
1621
    For a list of all available commands, say 'bzr shell-complete'."""
 
1622
    takes_args = ['context?']
 
1623
    aliases = ['s-c']
 
1624
    hidden = True
 
1625
    
 
1626
    def run(self, context=None):
 
1627
        import shellcomplete
 
1628
        shellcomplete.shellcomplete(context)
 
1629
 
 
1630
 
 
1631
class cmd_missing(Command):
 
1632
    """What is missing in this branch relative to other branch.
 
1633
    """
 
1634
    takes_args = ['remote?']
 
1635
    aliases = ['mis', 'miss']
 
1636
    # We don't have to add quiet to the list, because 
 
1637
    # unknown options are parsed as booleans
 
1638
    takes_options = ['verbose', 'quiet']
 
1639
 
 
1640
    def run(self, remote=None, verbose=False, quiet=False):
 
1641
        from bzrlib.branch import find_branch, DivergedBranches
 
1642
        from bzrlib.errors import BzrCommandError
 
1643
        from bzrlib.missing import get_parent, show_missing
 
1644
 
 
1645
        if verbose and quiet:
 
1646
            raise BzrCommandError('Cannot pass both quiet and verbose')
 
1647
 
 
1648
        b = find_branch('.')
 
1649
        parent = get_parent(b)
 
1650
        if remote is None:
 
1651
            if parent is None:
 
1652
                raise BzrCommandError("No missing location known or specified.")
 
1653
            else:
 
1654
                if not quiet:
 
1655
                    print "Using last location: %s" % parent
 
1656
                remote = parent
 
1657
        elif parent is None:
 
1658
            # We only update x-pull if it did not exist, missing should not change the parent
 
1659
            b.controlfile('x-pull', 'wb').write(remote + '\n')
 
1660
        br_remote = find_branch(remote)
 
1661
 
 
1662
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
 
1663
 
 
1664
 
 
1665
 
 
1666
class cmd_plugins(Command):
 
1667
    """List plugins"""
 
1668
    hidden = True
 
1669
    def run(self):
 
1670
        import bzrlib.plugin
 
1671
        from inspect import getdoc
 
1672
        from pprint import pprint
 
1673
        for plugin in bzrlib.plugin.all_plugins:
 
1674
            print plugin.__path__[0]
 
1675
            d = getdoc(plugin)
 
1676
            if d:
 
1677
                print '\t', d.split('\n')[0]
 
1678
 
 
1679
        #pprint(bzrlib.plugin.all_plugins)
 
1680
 
 
1681
 
 
1682
 
 
1683
# list of all available options; the rhs can be either None for an
 
1684
# option that takes no argument, or a constructor function that checks
 
1685
# the type.
 
1686
OPTIONS = {
 
1687
    'all':                    None,
 
1688
    'diff-options':           str,
 
1689
    'help':                   None,
 
1690
    'file':                   unicode,
 
1691
    'force':                  None,
 
1692
    'format':                 unicode,
 
1693
    'forward':                None,
 
1694
    'message':                unicode,
 
1695
    'no-recurse':             None,
 
1696
    'profile':                None,
 
1697
    'revision':               _parse_revision_str,
 
1698
    'short':                  None,
 
1699
    'show-ids':               None,
 
1700
    'timezone':               str,
 
1701
    'verbose':                None,
 
1702
    'version':                None,
 
1703
    'email':                  None,
 
1704
    'unchanged':              None,
 
1705
    'update':                 None,
 
1706
    'long':                   None,
 
1707
    'root':                   str,
 
1708
    'no-backup':              None,
 
1709
    'merge-type':             get_merge_type,
 
1710
    }
 
1711
 
 
1712
SHORT_OPTIONS = {
 
1713
    'F':                      'file', 
 
1714
    'h':                      'help',
 
1715
    'm':                      'message',
 
1716
    'r':                      'revision',
 
1717
    'v':                      'verbose',
 
1718
    'l':                      'long',
 
1719
}
 
1720
 
 
1721
 
 
1722
def parse_args(argv):
 
1723
    """Parse command line.
 
1724
    
 
1725
    Arguments and options are parsed at this level before being passed
 
1726
    down to specific command handlers.  This routine knows, from a
 
1727
    lookup table, something about the available options, what optargs
 
1728
    they take, and which commands will accept them.
 
1729
 
 
1730
    >>> parse_args('--help'.split())
 
1731
    ([], {'help': True})
 
1732
    >>> parse_args('--version'.split())
 
1733
    ([], {'version': True})
 
1734
    >>> parse_args('status --all'.split())
 
1735
    (['status'], {'all': True})
 
1736
    >>> parse_args('commit --message=biter'.split())
 
1737
    (['commit'], {'message': u'biter'})
 
1738
    >>> parse_args('log -r 500'.split())
 
1739
    (['log'], {'revision': [500]})
 
1740
    >>> parse_args('log -r500..600'.split())
 
1741
    (['log'], {'revision': [500, 600]})
 
1742
    >>> parse_args('log -vr500..600'.split())
 
1743
    (['log'], {'verbose': True, 'revision': [500, 600]})
 
1744
    >>> parse_args('log -rv500..600'.split()) #the r takes an argument
 
1745
    (['log'], {'revision': ['v500', 600]})
 
1746
    """
 
1747
    args = []
 
1748
    opts = {}
 
1749
 
 
1750
    # TODO: Maybe handle '--' to end options?
 
1751
 
 
1752
    while argv:
 
1753
        a = argv.pop(0)
 
1754
        if a[0] == '-':
 
1755
            # option names must not be unicode
 
1756
            a = str(a)
 
1757
            optarg = None
 
1758
            if a[1] == '-':
 
1759
                mutter("  got option %r" % a)
 
1760
                if '=' in a:
 
1761
                    optname, optarg = a[2:].split('=', 1)
 
1762
                else:
 
1763
                    optname = a[2:]
 
1764
                if optname not in OPTIONS:
 
1765
                    raise BzrError('unknown long option %r' % a)
 
1766
            else:
 
1767
                shortopt = a[1:]
 
1768
                if shortopt in SHORT_OPTIONS:
 
1769
                    # Multi-character options must have a space to delimit
 
1770
                    # their value
 
1771
                    optname = SHORT_OPTIONS[shortopt]
 
1772
                else:
 
1773
                    # Single character short options, can be chained,
 
1774
                    # and have their value appended to their name
 
1775
                    shortopt = a[1:2]
 
1776
                    if shortopt not in SHORT_OPTIONS:
 
1777
                        # We didn't find the multi-character name, and we
 
1778
                        # didn't find the single char name
 
1779
                        raise BzrError('unknown short option %r' % a)
 
1780
                    optname = SHORT_OPTIONS[shortopt]
 
1781
 
 
1782
                    if a[2:]:
 
1783
                        # There are extra things on this option
 
1784
                        # see if it is the value, or if it is another
 
1785
                        # short option
 
1786
                        optargfn = OPTIONS[optname]
 
1787
                        if optargfn is None:
 
1788
                            # This option does not take an argument, so the
 
1789
                            # next entry is another short option, pack it back
 
1790
                            # into the list
 
1791
                            argv.insert(0, '-' + a[2:])
 
1792
                        else:
 
1793
                            # This option takes an argument, so pack it
 
1794
                            # into the array
 
1795
                            optarg = a[2:]
 
1796
            
 
1797
            if optname in opts:
 
1798
                # XXX: Do we ever want to support this, e.g. for -r?
 
1799
                raise BzrError('repeated option %r' % a)
 
1800
                
 
1801
            optargfn = OPTIONS[optname]
 
1802
            if optargfn:
 
1803
                if optarg == None:
 
1804
                    if not argv:
 
1805
                        raise BzrError('option %r needs an argument' % a)
 
1806
                    else:
 
1807
                        optarg = argv.pop(0)
 
1808
                opts[optname] = optargfn(optarg)
 
1809
            else:
 
1810
                if optarg != None:
 
1811
                    raise BzrError('option %r takes no argument' % optname)
 
1812
                opts[optname] = True
 
1813
        else:
 
1814
            args.append(a)
 
1815
 
 
1816
    return args, opts
 
1817
 
 
1818
 
 
1819
 
 
1820
 
 
1821
def _match_argform(cmd, takes_args, args):
 
1822
    argdict = {}
 
1823
 
 
1824
    # step through args and takes_args, allowing appropriate 0-many matches
 
1825
    for ap in takes_args:
 
1826
        argname = ap[:-1]
 
1827
        if ap[-1] == '?':
 
1828
            if args:
 
1829
                argdict[argname] = args.pop(0)
 
1830
        elif ap[-1] == '*': # all remaining arguments
 
1831
            if args:
 
1832
                argdict[argname + '_list'] = args[:]
 
1833
                args = []
 
1834
            else:
 
1835
                argdict[argname + '_list'] = None
 
1836
        elif ap[-1] == '+':
 
1837
            if not args:
 
1838
                raise BzrCommandError("command %r needs one or more %s"
 
1839
                        % (cmd, argname.upper()))
 
1840
            else:
 
1841
                argdict[argname + '_list'] = args[:]
 
1842
                args = []
 
1843
        elif ap[-1] == '$': # all but one
 
1844
            if len(args) < 2:
 
1845
                raise BzrCommandError("command %r needs one or more %s"
 
1846
                        % (cmd, argname.upper()))
 
1847
            argdict[argname + '_list'] = args[:-1]
 
1848
            args[:-1] = []                
 
1849
        else:
 
1850
            # just a plain arg
 
1851
            argname = ap
 
1852
            if not args:
 
1853
                raise BzrCommandError("command %r requires argument %s"
 
1854
                        % (cmd, argname.upper()))
 
1855
            else:
 
1856
                argdict[argname] = args.pop(0)
 
1857
            
 
1858
    if args:
 
1859
        raise BzrCommandError("extra argument to command %s: %s"
 
1860
                              % (cmd, args[0]))
 
1861
 
 
1862
    return argdict
 
1863
 
 
1864
 
 
1865
 
 
1866
def run_bzr(argv):
 
1867
    """Execute a command.
 
1868
 
 
1869
    This is similar to main(), but without all the trappings for
 
1870
    logging and error handling.  
 
1871
    
 
1872
    argv
 
1873
       The command-line arguments, without the program name from argv[0]
 
1874
    
 
1875
    Returns a command status or raises an exception.
 
1876
 
 
1877
    Special master options: these must come before the command because
 
1878
    they control how the command is interpreted.
 
1879
 
 
1880
    --no-plugins
 
1881
        Do not load plugin modules at all
 
1882
 
 
1883
    --builtin
 
1884
        Only use builtin commands.  (Plugins are still allowed to change
 
1885
        other behaviour.)
 
1886
 
 
1887
    --profile
 
1888
        Run under the Python profiler.
 
1889
    """
 
1890
    
 
1891
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
1892
 
 
1893
    opt_profile = opt_no_plugins = opt_builtin = False
 
1894
 
 
1895
    # --no-plugins is handled specially at a very early stage. We need
 
1896
    # to load plugins before doing other command parsing so that they
 
1897
    # can override commands, but this needs to happen first.
 
1898
 
 
1899
    for a in argv[:]:
 
1900
        if a == '--profile':
 
1901
            opt_profile = True
 
1902
        elif a == '--no-plugins':
 
1903
            opt_no_plugins = True
 
1904
        elif a == '--builtin':
 
1905
            opt_builtin = True
 
1906
        else:
 
1907
            break
 
1908
        argv.remove(a)
 
1909
 
 
1910
    if not opt_no_plugins:
 
1911
        from bzrlib.plugin import load_plugins
 
1912
        load_plugins()
 
1913
 
 
1914
    args, opts = parse_args(argv)
 
1915
 
 
1916
    if 'help' in opts:
 
1917
        from bzrlib.help import help
 
1918
        if args:
 
1919
            help(args[0])
 
1920
        else:
 
1921
            help()
 
1922
        return 0            
 
1923
        
 
1924
    if 'version' in opts:
 
1925
        show_version()
 
1926
        return 0
 
1927
    
 
1928
    if not args:
 
1929
        from bzrlib.help import help
 
1930
        help(None)
 
1931
        return 0
 
1932
    
 
1933
    cmd = str(args.pop(0))
 
1934
 
 
1935
    canonical_cmd, cmd_class = \
 
1936
                   get_cmd_class(cmd, plugins_override=not opt_builtin)
 
1937
 
 
1938
    # check options are reasonable
 
1939
    allowed = cmd_class.takes_options
 
1940
    for oname in opts:
 
1941
        if oname not in allowed:
 
1942
            raise BzrCommandError("option '--%s' is not allowed for command %r"
 
1943
                                  % (oname, cmd))
 
1944
 
 
1945
    # mix arguments and options into one dictionary
 
1946
    cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
 
1947
    cmdopts = {}
 
1948
    for k, v in opts.items():
 
1949
        cmdopts[k.replace('-', '_')] = v
 
1950
 
 
1951
    if opt_profile:
 
1952
        import hotshot, tempfile
 
1953
        pffileno, pfname = tempfile.mkstemp()
 
1954
        try:
 
1955
            prof = hotshot.Profile(pfname)
 
1956
            ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
 
1957
            prof.close()
 
1958
 
 
1959
            import hotshot.stats
 
1960
            stats = hotshot.stats.load(pfname)
 
1961
            #stats.strip_dirs()
 
1962
            stats.sort_stats('time')
 
1963
            ## XXX: Might like to write to stderr or the trace file instead but
 
1964
            ## print_stats seems hardcoded to stdout
 
1965
            stats.print_stats(20)
 
1966
            
 
1967
            return ret.status
 
1968
 
 
1969
        finally:
 
1970
            os.close(pffileno)
 
1971
            os.remove(pfname)
 
1972
    else:
 
1973
        return cmd_class(cmdopts, cmdargs).status 
 
1974
 
 
1975
 
 
1976
def main(argv):
 
1977
    import bzrlib.ui
 
1978
    
 
1979
    bzrlib.trace.log_startup(argv)
 
1980
 
 
1981
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
 
1982
 
 
1983
    try:
 
1984
        try:
 
1985
            return run_bzr(argv[1:])
 
1986
        finally:
 
1987
            # do this here inside the exception wrappers to catch EPIPE
 
1988
            sys.stdout.flush()
 
1989
    except BzrCommandError, e:
 
1990
        # command line syntax error, etc
 
1991
        log_error(str(e))
 
1992
        return 1
 
1993
    except BzrError, e:
 
1994
        bzrlib.trace.log_exception()
 
1995
        return 1
 
1996
    except AssertionError, e:
 
1997
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
 
1998
        return 3
 
1999
    except KeyboardInterrupt, e:
 
2000
        bzrlib.trace.note('interrupted')
 
2001
        return 2
 
2002
    except Exception, e:
 
2003
        import errno
 
2004
        if (isinstance(e, IOError) 
 
2005
            and hasattr(e, 'errno')
 
2006
            and e.errno == errno.EPIPE):
 
2007
            bzrlib.trace.note('broken pipe')
 
2008
            return 2
 
2009
        else:
 
2010
            bzrlib.trace.log_exception()
 
2011
            return 2
 
2012
 
 
2013
 
 
2014
if __name__ == '__main__':
 
2015
    sys.exit(main(sys.argv))