/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: Robert Collins
  • Date: 2005-08-25 06:14:17 UTC
  • mto: (974.1.50) (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: robertc@robertcollins.net-20050825061417-3c01eb11acb37ff0
merge from mpool up to rev 1110

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