← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2005-06-22 07:57:56 UTC
  • Revision ID: mbp@sourcefrog.net-20050622075756-f4f98a7f2addddf5
- stubbed-out tests for python plugins

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2004, 2005 by Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
# TODO: probably should say which arguments are candidates for glob
19
 
# expansion on windows and do that at the command level.
20
 
 
21
 
# TODO: Define arguments by objects, rather than just using names.
22
 
# Those objects can specify the expected type of the argument, which
23
 
# would help with validation and shell completion.  They could also provide
24
 
# help/explanation for that argument in a structured way.
25
 
 
26
 
# TODO: Specific "examples" property on commands for consistent formatting.
27
 
 
28
 
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
 
# the profile output behind so it can be interactively examined?
30
 
 
31
 
import os
32
 
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
 
import codecs
37
 
import errno
38
 
from warnings import warn
 
18
 
 
19
import sys, os
39
20
 
40
21
import bzrlib
41
 
from bzrlib import (
42
 
    debug,
43
 
    errors,
44
 
    option,
45
 
    osutils,
46
 
    trace,
47
 
    )
48
 
""")
49
 
 
50
 
from bzrlib.symbol_versioning import (
51
 
    deprecated_function,
52
 
    deprecated_method,
53
 
    zero_eight,
54
 
    zero_eleven,
55
 
    )
56
 
# Compatibility
57
 
from bzrlib.option import Option
 
22
from bzrlib.trace import mutter, note, log_error
 
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
 
24
from bzrlib.osutils import quotefn
 
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
 
26
     format_date
58
27
 
59
28
 
60
29
plugin_cmds = {}
61
30
 
62
31
 
63
 
def register_command(cmd, decorate=False):
64
 
    """Utility function to help register a command
65
 
 
66
 
    :param cmd: Command subclass to register
67
 
    :param decorate: If true, allow overriding an existing command
68
 
        of the same name; the old command is returned by this function.
69
 
        Otherwise it is an error to try to override an existing command.
70
 
    """
 
32
def register_plugin_command(cmd):
 
33
    "Utility function to help register a command"
71
34
    global plugin_cmds
72
35
    k = cmd.__name__
73
36
    if k.startswith("cmd_"):
74
37
        k_unsquished = _unsquish_command_name(k)
75
38
    else:
76
39
        k_unsquished = k
77
 
    if k_unsquished not in plugin_cmds:
78
 
        plugin_cmds[k_unsquished] = cmd
79
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
80
 
        if decorate and k_unsquished in builtin_command_names():
81
 
            return _builtin_commands()[k_unsquished]
82
 
    elif decorate:
83
 
        result = plugin_cmds[k_unsquished]
84
 
        plugin_cmds[k_unsquished] = cmd
85
 
        return result
 
40
    if not plugin_cmds.has_key(k_unsquished):
 
41
        plugin_cmds[k_unsquished] = cmd
86
42
    else:
87
 
        trace.log_error('Two plugins defined the same command: %r' % k)
88
 
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
43
        log_error('Two plugins defined the same command: %r' % k)
 
44
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
89
45
 
90
46
 
91
47
def _squish_command_name(cmd):
96
52
    assert cmd.startswith("cmd_")
97
53
    return cmd[4:].replace('_','-')
98
54
 
99
 
 
100
 
def _builtin_commands():
101
 
    import bzrlib.builtins
102
 
    r = {}
103
 
    builtins = bzrlib.builtins.__dict__
104
 
    for name in builtins:
105
 
        if name.startswith("cmd_"):
106
 
            real_name = _unsquish_command_name(name)
107
 
            r[real_name] = builtins[name]
108
 
    return r
109
 
            
110
 
 
111
 
def builtin_command_names():
112
 
    """Return list of builtin command names."""
113
 
    return _builtin_commands().keys()
114
 
    
115
 
 
116
 
def plugin_command_names():
117
 
    return plugin_cmds.keys()
 
55
def _parse_revision_str(revstr):
 
56
    """This handles a revision string -> revno. 
 
57
 
 
58
    There are several possibilities:
 
59
 
 
60
        '234'       -> 234
 
61
        '234:345'   -> [234, 345]
 
62
        ':234'      -> [None, 234]
 
63
        '234:'      -> [234, None]
 
64
 
 
65
    In the future we will also support:
 
66
        'uuid:blah-blah-blah'   -> ?
 
67
        'hash:blahblahblah'     -> ?
 
68
        potentially:
 
69
        'tag:mytag'             -> ?
 
70
    """
 
71
    if revstr.find(':') != -1:
 
72
        revs = revstr.split(':')
 
73
        if len(revs) > 2:
 
74
            raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
 
75
 
 
76
        if not revs[0]:
 
77
            revs[0] = None
 
78
        else:
 
79
            revs[0] = int(revs[0])
 
80
 
 
81
        if not revs[1]:
 
82
            revs[1] = None
 
83
        else:
 
84
            revs[1] = int(revs[1])
 
85
    else:
 
86
        revs = int(revstr)
 
87
    return revs
 
88
 
118
89
 
119
90
 
120
91
def _get_cmd_dict(plugins_override=True):
121
 
    """Return name->class mapping for all commands."""
122
 
    d = _builtin_commands()
 
92
    d = {}
 
93
    for k, v in globals().iteritems():
 
94
        if k.startswith("cmd_"):
 
95
            d[_unsquish_command_name(k)] = v
 
96
    # If we didn't load plugins, the plugin_cmds dict will be empty
123
97
    if plugins_override:
124
98
        d.update(plugin_cmds)
 
99
    else:
 
100
        d2 = plugin_cmds.copy()
 
101
        d2.update(d)
 
102
        d = d2
125
103
    return d
126
104
 
127
105
    
131
109
        yield k,v
132
110
 
133
111
 
134
 
def get_cmd_object(cmd_name, plugins_override=True):
 
112
def get_cmd_class(cmd, plugins_override=True):
135
113
    """Return the canonical name and command class for a command.
136
 
 
137
 
    plugins_override
138
 
        If true, plugin commands can override builtins.
139
114
    """
140
 
    from bzrlib.externalcommand import ExternalCommand
141
 
 
142
 
    # We want only 'ascii' command names, but the user may have typed
143
 
    # in a Unicode name. In that case, they should just get a
144
 
    # 'command not found' error later.
145
 
    # In the future, we may actually support Unicode command names.
 
115
    cmd = str(cmd)                      # not unicode
146
116
 
147
117
    # first look up this command under the specified name
148
118
    cmds = _get_cmd_dict(plugins_override=plugins_override)
149
119
    try:
150
 
        return cmds[cmd_name]()
 
120
        return cmd, cmds[cmd]
151
121
    except KeyError:
152
122
        pass
153
123
 
154
124
    # look for any command which claims this as an alias
155
 
    for real_cmd_name, cmd_class in cmds.iteritems():
156
 
        if cmd_name in cmd_class.aliases:
157
 
            return cmd_class()
158
 
 
159
 
    cmd_obj = ExternalCommand.find_command(cmd_name)
160
 
    if cmd_obj:
161
 
        return cmd_obj
162
 
 
163
 
    raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
125
    for cmdname, cmdclass in cmds.iteritems():
 
126
        if cmd in cmdclass.aliases:
 
127
            return cmdname, cmdclass
 
128
 
 
129
    cmdclass = ExternalCommand.find_command(cmd)
 
130
    if cmdclass:
 
131
        return cmd, cmdclass
 
132
 
 
133
    raise BzrCommandError("unknown command %r" % cmd)
164
134
 
165
135
 
166
136
class Command(object):
167
137
    """Base class for commands.
168
138
 
169
 
    Commands are the heart of the command-line bzr interface.
170
 
 
171
 
    The command object mostly handles the mapping of command-line
172
 
    parameters into one or more bzrlib operations, and of the results
173
 
    into textual output.
174
 
 
175
 
    Commands normally don't have any state.  All their arguments are
176
 
    passed in to the run method.  (Subclasses may take a different
177
 
    policy if the behaviour of the instance needs to depend on e.g. a
178
 
    shell plugin and not just its Python class.)
179
 
 
180
139
    The docstring for an actual command should give a single-line
181
140
    summary, then a complete description of the command.  A grammar
182
141
    description will be inserted.
183
142
 
184
 
    aliases
185
 
        Other accepted names for this command.
186
 
 
187
143
    takes_args
188
144
        List of argument forms, marked with whether they are optional,
189
145
        repeated, etc.
190
146
 
191
 
                Examples:
192
 
 
193
 
                ['to_location', 'from_branch?', 'file*']
194
 
 
195
 
                'to_location' is required
196
 
                'from_branch' is optional
197
 
                'file' can be specified 0 or more times
198
 
 
199
147
    takes_options
200
 
        List of options that may be given for this command.  These can
201
 
        be either strings, referring to globally-defined options,
202
 
        or option objects.  Retrieve through options().
 
148
        List of options that may be given for this command.
203
149
 
204
150
    hidden
205
 
        If true, this command isn't advertised.  This is typically
206
 
        for commands intended for expert users.
207
 
 
208
 
    encoding_type
209
 
        Command objects will get a 'outf' attribute, which has been
210
 
        setup to properly handle encoding of unicode strings.
211
 
        encoding_type determines what will happen when characters cannot
212
 
        be encoded
213
 
            strict - abort if we cannot decode
214
 
            replace - put in a bogus character (typically '?')
215
 
            exact - do not encode sys.stdout
216
 
 
217
 
            NOTE: by default on Windows, sys.stdout is opened as a text
218
 
            stream, therefore LF line-endings are converted to CRLF.
219
 
            When a command uses encoding_type = 'exact', then
220
 
            sys.stdout is forced to be a binary stream, and line-endings
221
 
            will not mangled.
222
 
 
 
151
        If true, this command isn't advertised.
223
152
    """
224
153
    aliases = []
 
154
    
225
155
    takes_args = []
226
156
    takes_options = []
227
 
    encoding_type = 'strict'
228
157
 
229
158
    hidden = False
230
159
    
231
 
    def __init__(self):
232
 
        """Construct an instance of this command."""
233
 
        if self.__doc__ == Command.__doc__:
234
 
            warn("No help message set for %r" % self)
235
 
 
236
 
    def options(self):
237
 
        """Return dict of valid options for this command.
238
 
 
239
 
        Maps from long option name to option object."""
240
 
        r = dict()
241
 
        r['help'] = option.Option.OPTIONS['help']
242
 
        for o in self.takes_options:
243
 
            if isinstance(o, basestring):
244
 
                o = option.Option.OPTIONS[o]
245
 
            r[o.name] = o
246
 
        return r
247
 
 
248
 
    def _setup_outf(self):
249
 
        """Return a file linked to stdout, which has proper encoding."""
250
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
251
 
 
252
 
        # Originally I was using self.stdout, but that looks
253
 
        # *way* too much like sys.stdout
254
 
        if self.encoding_type == 'exact':
255
 
            # force sys.stdout to be binary stream on win32
256
 
            if sys.platform == 'win32':
257
 
                fileno = getattr(sys.stdout, 'fileno', None)
258
 
                if fileno:
259
 
                    import msvcrt
260
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
261
 
            self.outf = sys.stdout
262
 
            return
263
 
 
264
 
        output_encoding = osutils.get_terminal_encoding()
 
160
    def __init__(self, options, arguments):
 
161
        """Construct and run the command.
 
162
 
 
163
        Sets self.status to the return value of run()."""
 
164
        assert isinstance(options, dict)
 
165
        assert isinstance(arguments, dict)
 
166
        cmdargs = options.copy()
 
167
        cmdargs.update(arguments)
 
168
        assert self.__doc__ != Command.__doc__, \
 
169
               ("No help message set for %r" % self)
 
170
        self.status = self.run(**cmdargs)
 
171
 
 
172
    
 
173
    def run(self):
 
174
        """Override this in sub-classes.
 
175
 
 
176
        This is invoked with the options and arguments bound to
 
177
        keyword parameters.
 
178
 
 
179
        Return 0 or None if the command was successful, or a shell
 
180
        error code if not.
 
181
        """
 
182
        return 0
 
183
 
 
184
 
 
185
class ExternalCommand(Command):
 
186
    """Class to wrap external commands.
 
187
 
 
188
    We cheat a little here, when get_cmd_class() calls us we actually give it back
 
189
    an object we construct that has the appropriate path, help, options etc for the
 
190
    specified command.
 
191
 
 
192
    When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
 
193
    method, which we override to call the Command.__init__ method. That then calls
 
194
    our run method which is pretty straight forward.
 
195
 
 
196
    The only wrinkle is that we have to map bzr's dictionary of options and arguments
 
197
    back into command line options and arguments for the script.
 
198
    """
 
199
 
 
200
    def find_command(cls, cmd):
 
201
        import os.path
 
202
        bzrpath = os.environ.get('BZRPATH', '')
 
203
 
 
204
        for dir in bzrpath.split(os.pathsep):
 
205
            path = os.path.join(dir, cmd)
 
206
            if os.path.isfile(path):
 
207
                return ExternalCommand(path)
 
208
 
 
209
        return None
 
210
 
 
211
    find_command = classmethod(find_command)
 
212
 
 
213
    def __init__(self, path):
 
214
        self.path = path
 
215
 
 
216
        pipe = os.popen('%s --bzr-usage' % path, 'r')
 
217
        self.takes_options = pipe.readline().split()
 
218
 
 
219
        for opt in self.takes_options:
 
220
            if not opt in OPTIONS:
 
221
                raise BzrError("Unknown option '%s' returned by external command %s"
 
222
                               % (opt, path))
 
223
 
 
224
        # TODO: Is there any way to check takes_args is valid here?
 
225
        self.takes_args = pipe.readline().split()
 
226
 
 
227
        if pipe.close() is not None:
 
228
            raise BzrError("Failed funning '%s --bzr-usage'" % path)
 
229
 
 
230
        pipe = os.popen('%s --bzr-help' % path, 'r')
 
231
        self.__doc__ = pipe.read()
 
232
        if pipe.close() is not None:
 
233
            raise BzrError("Failed funning '%s --bzr-help'" % path)
 
234
 
 
235
    def __call__(self, options, arguments):
 
236
        Command.__init__(self, options, arguments)
 
237
        return self
 
238
 
 
239
    def run(self, **kargs):
 
240
        opts = []
 
241
        args = []
 
242
 
 
243
        keys = kargs.keys()
 
244
        keys.sort()
 
245
        for name in keys:
 
246
            optname = name.replace('_','-')
 
247
            value = kargs[name]
 
248
            if OPTIONS.has_key(optname):
 
249
                # it's an option
 
250
                opts.append('--%s' % optname)
 
251
                if value is not None and value is not True:
 
252
                    opts.append(str(value))
 
253
            else:
 
254
                # it's an arg, or arg list
 
255
                if type(value) is not list:
 
256
                    value = [value]
 
257
                for v in value:
 
258
                    if v is not None:
 
259
                        args.append(str(v))
 
260
 
 
261
        self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
 
262
        return self.status
 
263
 
 
264
 
 
265
class cmd_status(Command):
 
266
    """Display status summary.
 
267
 
 
268
    This reports on versioned and unknown files, reporting them
 
269
    grouped by state.  Possible states are:
 
270
 
 
271
    added
 
272
        Versioned in the working copy but not in the previous revision.
 
273
 
 
274
    removed
 
275
        Versioned in the previous revision but removed or deleted
 
276
        in the working copy.
 
277
 
 
278
    renamed
 
279
        Path of this file changed from the previous revision;
 
280
        the text may also have changed.  This includes files whose
 
281
        parent directory was renamed.
 
282
 
 
283
    modified
 
284
        Text has changed since the previous revision.
 
285
 
 
286
    unchanged
 
287
        Nothing about this file has changed since the previous revision.
 
288
        Only shown with --all.
 
289
 
 
290
    unknown
 
291
        Not versioned and not matching an ignore pattern.
 
292
 
 
293
    To see ignored files use 'bzr ignored'.  For details in the
 
294
    changes to file texts, use 'bzr diff'.
 
295
 
 
296
    If no arguments are specified, the status of the entire working
 
297
    directory is shown.  Otherwise, only the status of the specified
 
298
    files or directories is reported.  If a directory is given, status
 
299
    is reported for everything inside that directory.
 
300
    """
 
301
    takes_args = ['file*']
 
302
    takes_options = ['all', 'show-ids']
 
303
    aliases = ['st', 'stat']
 
304
    
 
305
    def run(self, all=False, show_ids=False, file_list=None):
 
306
        if file_list:
 
307
            b = Branch(file_list[0])
 
308
            file_list = [b.relpath(x) for x in file_list]
 
309
            # special case: only one path was given and it's the root
 
310
            # of the branch
 
311
            if file_list == ['']:
 
312
                file_list = None
 
313
        else:
 
314
            b = Branch('.')
 
315
        import status
 
316
        status.show_status(b, show_unchanged=all, show_ids=show_ids,
 
317
                           specific_files=file_list)
 
318
 
 
319
 
 
320
class cmd_cat_revision(Command):
 
321
    """Write out metadata for a revision."""
 
322
 
 
323
    hidden = True
 
324
    takes_args = ['revision_id']
 
325
    
 
326
    def run(self, revision_id):
 
327
        Branch('.').get_revision(revision_id).write_xml(sys.stdout)
 
328
 
 
329
 
 
330
class cmd_revno(Command):
 
331
    """Show current revision number.
 
332
 
 
333
    This is equal to the number of revisions on this branch."""
 
334
    def run(self):
 
335
        print Branch('.').revno()
 
336
 
 
337
    
 
338
class cmd_add(Command):
 
339
    """Add specified files or directories.
 
340
 
 
341
    In non-recursive mode, all the named items are added, regardless
 
342
    of whether they were previously ignored.  A warning is given if
 
343
    any of the named files are already versioned.
 
344
 
 
345
    In recursive mode (the default), files are treated the same way
 
346
    but the behaviour for directories is different.  Directories that
 
347
    are already versioned do not give a warning.  All directories,
 
348
    whether already versioned or not, are searched for files or
 
349
    subdirectories that are neither versioned or ignored, and these
 
350
    are added.  This search proceeds recursively into versioned
 
351
    directories.
 
352
 
 
353
    Therefore simply saying 'bzr add .' will version all files that
 
354
    are currently unknown.
 
355
 
 
356
    TODO: Perhaps adding a file whose directly is not versioned should
 
357
    recursively add that parent, rather than giving an error?
 
358
    """
 
359
    takes_args = ['file+']
 
360
    takes_options = ['verbose', 'no-recurse']
 
361
    
 
362
    def run(self, file_list, verbose=False, no_recurse=False):
 
363
        bzrlib.add.smart_add(file_list, verbose, not no_recurse)
 
364
 
 
365
 
 
366
 
 
367
class cmd_mkdir(Command):
 
368
    """Create a new versioned directory.
 
369
 
 
370
    This is equivalent to creating the directory and then adding it.
 
371
    """
 
372
    takes_args = ['dir+']
 
373
 
 
374
    def run(self, dir_list):
 
375
        import os
 
376
        import bzrlib.branch
 
377
        
 
378
        b = None
 
379
        
 
380
        for d in dir_list:
 
381
            os.mkdir(d)
 
382
            if not b:
 
383
                b = bzrlib.branch.Branch(d)
 
384
            b.add([d], verbose=True)
 
385
 
 
386
 
 
387
class cmd_relpath(Command):
 
388
    """Show path of a file relative to root"""
 
389
    takes_args = ['filename']
 
390
    hidden = True
 
391
    
 
392
    def run(self, filename):
 
393
        print Branch(filename).relpath(filename)
 
394
 
 
395
 
 
396
 
 
397
class cmd_inventory(Command):
 
398
    """Show inventory of the current working copy or a revision."""
 
399
    takes_options = ['revision', 'show-ids']
 
400
    
 
401
    def run(self, revision=None, show_ids=False):
 
402
        b = Branch('.')
 
403
        if revision == None:
 
404
            inv = b.read_working_inventory()
 
405
        else:
 
406
            inv = b.get_revision_inventory(b.lookup_revision(revision))
 
407
 
 
408
        for path, entry in inv.entries():
 
409
            if show_ids:
 
410
                print '%-50s %s' % (path, entry.file_id)
 
411
            else:
 
412
                print path
 
413
 
 
414
 
 
415
class cmd_move(Command):
 
416
    """Move files to a different directory.
 
417
 
 
418
    examples:
 
419
        bzr move *.txt doc
 
420
 
 
421
    The destination must be a versioned directory in the same branch.
 
422
    """
 
423
    takes_args = ['source$', 'dest']
 
424
    def run(self, source_list, dest):
 
425
        b = Branch('.')
 
426
 
 
427
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
 
428
 
 
429
 
 
430
class cmd_rename(Command):
 
431
    """Change the name of an entry.
 
432
 
 
433
    examples:
 
434
      bzr rename frob.c frobber.c
 
435
      bzr rename src/frob.c lib/frob.c
 
436
 
 
437
    It is an error if the destination name exists.
 
438
 
 
439
    See also the 'move' command, which moves files into a different
 
440
    directory without changing their name.
 
441
 
 
442
    TODO: Some way to rename multiple files without invoking bzr for each
 
443
    one?"""
 
444
    takes_args = ['from_name', 'to_name']
 
445
    
 
446
    def run(self, from_name, to_name):
 
447
        b = Branch('.')
 
448
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
 
449
 
 
450
 
 
451
 
 
452
 
 
453
 
 
454
class cmd_pull(Command):
 
455
    """Pull any changes from another branch into the current one.
 
456
 
 
457
    If the location is omitted, the last-used location will be used.
 
458
    Both the revision history and the working directory will be
 
459
    updated.
 
460
 
 
461
    This command only works on branches that have not diverged.  Branches are
 
462
    considered diverged if both branches have had commits without first
 
463
    pulling from the other.
 
464
 
 
465
    If branches have diverged, you can use 'bzr merge' to pull the text changes
 
466
    from one into the other.
 
467
    """
 
468
    takes_args = ['location?']
 
469
 
 
470
    def run(self, location=None):
 
471
        from bzrlib.merge import merge
 
472
        import errno
 
473
        
 
474
        br_to = Branch('.')
 
475
        stored_loc = None
 
476
        try:
 
477
            stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
 
478
        except IOError, e:
 
479
            if errno == errno.ENOENT:
 
480
                raise
 
481
        if location is None:
 
482
            if stored_loc is None:
 
483
                raise BzrCommandError("No pull location known or specified.")
 
484
            else:
 
485
                print "Using last location: %s" % stored_loc
 
486
                location = stored_loc
 
487
        from branch import find_branch, DivergedBranches
 
488
        br_from = find_branch(location)
 
489
        location = pull_loc(br_from)
 
490
        old_revno = br_to.revno()
 
491
        try:
 
492
            br_to.update_revisions(br_from)
 
493
        except DivergedBranches:
 
494
            raise BzrCommandError("These branches have diverged.  Try merge.")
 
495
            
 
496
        merge(('.', -1), ('.', old_revno), check_clean=False)
 
497
        if location != stored_loc:
 
498
            br_to.controlfile("x-pull", "wb").write(location + "\n")
 
499
 
 
500
 
 
501
 
 
502
class cmd_branch(Command):
 
503
    """Create a new copy of a branch.
 
504
 
 
505
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
 
506
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
 
507
 
 
508
    To retrieve the branch as of a particular revision, supply the --revision
 
509
    parameter, as in "branch foo/bar -r 5".
 
510
    """
 
511
    takes_args = ['from_location', 'to_location?']
 
512
    takes_options = ['revision']
 
513
 
 
514
    def run(self, from_location, to_location=None, revision=None):
 
515
        import errno
 
516
        from bzrlib.merge import merge
 
517
        from branch import find_branch, DivergedBranches, NoSuchRevision
 
518
        from shutil import rmtree
 
519
        try:
 
520
            br_from = find_branch(from_location)
 
521
        except OSError, e:
 
522
            if e.errno == errno.ENOENT:
 
523
                raise BzrCommandError('Source location "%s" does not exist.' %
 
524
                                      to_location)
 
525
            else:
 
526
                raise
 
527
 
 
528
        if to_location is None:
 
529
            to_location = os.path.basename(from_location.rstrip("/\\"))
 
530
 
 
531
        try:
 
532
            os.mkdir(to_location)
 
533
        except OSError, e:
 
534
            if e.errno == errno.EEXIST:
 
535
                raise BzrCommandError('Target directory "%s" already exists.' %
 
536
                                      to_location)
 
537
            if e.errno == errno.ENOENT:
 
538
                raise BzrCommandError('Parent of "%s" does not exist.' %
 
539
                                      to_location)
 
540
            else:
 
541
                raise
 
542
        br_to = Branch(to_location, init=True)
 
543
 
 
544
        try:
 
545
            br_to.update_revisions(br_from, stop_revision=revision)
 
546
        except NoSuchRevision:
 
547
            rmtree(to_location)
 
548
            msg = "The branch %s has no revision %d." % (from_location,
 
549
                                                         revision)
 
550
            raise BzrCommandError(msg)
 
551
        merge((to_location, -1), (to_location, 0), this_dir=to_location,
 
552
              check_clean=False, ignore_zero=True)
 
553
        from_location = pull_loc(br_from)
 
554
        br_to.controlfile("x-pull", "wb").write(from_location + "\n")
 
555
 
 
556
 
 
557
def pull_loc(branch):
 
558
    # TODO: Should perhaps just make attribute be 'base' in
 
559
    # RemoteBranch and Branch?
 
560
    if hasattr(branch, "baseurl"):
 
561
        return branch.baseurl
 
562
    else:
 
563
        return branch.base
 
564
 
 
565
 
 
566
 
 
567
class cmd_renames(Command):
 
568
    """Show list of renamed files.
 
569
 
 
570
    TODO: Option to show renames between two historical versions.
 
571
 
 
572
    TODO: Only show renames under dir, rather than in the whole branch.
 
573
    """
 
574
    takes_args = ['dir?']
 
575
 
 
576
    def run(self, dir='.'):
 
577
        b = Branch(dir)
 
578
        old_inv = b.basis_tree().inventory
 
579
        new_inv = b.read_working_inventory()
 
580
 
 
581
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
 
582
        renames.sort()
 
583
        for old_name, new_name in renames:
 
584
            print "%s => %s" % (old_name, new_name)        
 
585
 
 
586
 
 
587
class cmd_info(Command):
 
588
    """Show statistical information about a branch."""
 
589
    takes_args = ['branch?']
 
590
    
 
591
    def run(self, branch=None):
 
592
        import info
 
593
 
 
594
        from branch import find_branch
 
595
        b = find_branch(branch)
 
596
        info.show_info(b)
 
597
 
 
598
 
 
599
class cmd_remove(Command):
 
600
    """Make a file unversioned.
 
601
 
 
602
    This makes bzr stop tracking changes to a versioned file.  It does
 
603
    not delete the working copy.
 
604
    """
 
605
    takes_args = ['file+']
 
606
    takes_options = ['verbose']
 
607
    
 
608
    def run(self, file_list, verbose=False):
 
609
        b = Branch(file_list[0])
 
610
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
 
611
 
 
612
 
 
613
class cmd_file_id(Command):
 
614
    """Print file_id of a particular file or directory.
 
615
 
 
616
    The file_id is assigned when the file is first added and remains the
 
617
    same through all revisions where the file exists, even when it is
 
618
    moved or renamed.
 
619
    """
 
620
    hidden = True
 
621
    takes_args = ['filename']
 
622
    def run(self, filename):
 
623
        b = Branch(filename)
 
624
        i = b.inventory.path2id(b.relpath(filename))
 
625
        if i == None:
 
626
            raise BzrError("%r is not a versioned file" % filename)
 
627
        else:
 
628
            print i
 
629
 
 
630
 
 
631
class cmd_file_path(Command):
 
632
    """Print path of file_ids to a file or directory.
 
633
 
 
634
    This prints one line for each directory down to the target,
 
635
    starting at the branch root."""
 
636
    hidden = True
 
637
    takes_args = ['filename']
 
638
    def run(self, filename):
 
639
        b = Branch(filename)
 
640
        inv = b.inventory
 
641
        fid = inv.path2id(b.relpath(filename))
 
642
        if fid == None:
 
643
            raise BzrError("%r is not a versioned file" % filename)
 
644
        for fip in inv.get_idpath(fid):
 
645
            print fip
 
646
 
 
647
 
 
648
class cmd_revision_history(Command):
 
649
    """Display list of revision ids on this branch."""
 
650
    hidden = True
 
651
    def run(self):
 
652
        for patchid in Branch('.').revision_history():
 
653
            print patchid
 
654
 
 
655
 
 
656
class cmd_directories(Command):
 
657
    """Display list of versioned directories in this branch."""
 
658
    def run(self):
 
659
        for name, ie in Branch('.').read_working_inventory().directories():
 
660
            if name == '':
 
661
                print '.'
 
662
            else:
 
663
                print name
 
664
 
 
665
 
 
666
class cmd_init(Command):
 
667
    """Make a directory into a versioned branch.
 
668
 
 
669
    Use this to create an empty branch, or before importing an
 
670
    existing project.
 
671
 
 
672
    Recipe for importing a tree of files:
 
673
        cd ~/project
 
674
        bzr init
 
675
        bzr add -v .
 
676
        bzr status
 
677
        bzr commit -m 'imported project'
 
678
    """
 
679
    def run(self):
 
680
        Branch('.', init=True)
 
681
 
 
682
 
 
683
class cmd_diff(Command):
 
684
    """Show differences in working tree.
 
685
    
 
686
    If files are listed, only the changes in those files are listed.
 
687
    Otherwise, all changes for the tree are listed.
 
688
 
 
689
    TODO: Given two revision arguments, show the difference between them.
 
690
 
 
691
    TODO: Allow diff across branches.
 
692
 
 
693
    TODO: Option to use external diff command; could be GNU diff, wdiff,
 
694
          or a graphical diff.
 
695
 
 
696
    TODO: Python difflib is not exactly the same as unidiff; should
 
697
          either fix it up or prefer to use an external diff.
 
698
 
 
699
    TODO: If a directory is given, diff everything under that.
 
700
 
 
701
    TODO: Selected-file diff is inefficient and doesn't show you
 
702
          deleted files.
 
703
 
 
704
    TODO: This probably handles non-Unix newlines poorly.
 
705
    """
 
706
    
 
707
    takes_args = ['file*']
 
708
    takes_options = ['revision', 'diff-options']
 
709
    aliases = ['di', 'dif']
 
710
 
 
711
    def run(self, revision=None, file_list=None, diff_options=None):
 
712
        from bzrlib.diff import show_diff
 
713
        from bzrlib import find_branch
 
714
 
 
715
        if file_list:
 
716
            b = find_branch(file_list[0])
 
717
            file_list = [b.relpath(f) for f in file_list]
 
718
            if file_list == ['']:
 
719
                # just pointing to top-of-tree
 
720
                file_list = None
 
721
        else:
 
722
            b = Branch('.')
 
723
    
 
724
        show_diff(b, revision, specific_files=file_list,
 
725
                  external_diff_options=diff_options)
 
726
 
 
727
 
 
728
        
 
729
 
 
730
 
 
731
class cmd_deleted(Command):
 
732
    """List files deleted in the working tree.
 
733
 
 
734
    TODO: Show files deleted since a previous revision, or between two revisions.
 
735
    """
 
736
    def run(self, show_ids=False):
 
737
        b = Branch('.')
 
738
        old = b.basis_tree()
 
739
        new = b.working_tree()
 
740
 
 
741
        ## TODO: Much more efficient way to do this: read in new
 
742
        ## directories with readdir, rather than stating each one.  Same
 
743
        ## level of effort but possibly much less IO.  (Or possibly not,
 
744
        ## if the directories are very large...)
 
745
 
 
746
        for path, ie in old.inventory.iter_entries():
 
747
            if not new.has_id(ie.file_id):
 
748
                if show_ids:
 
749
                    print '%-50s %s' % (path, ie.file_id)
 
750
                else:
 
751
                    print path
 
752
 
 
753
 
 
754
class cmd_modified(Command):
 
755
    """List files modified in working tree."""
 
756
    hidden = True
 
757
    def run(self):
 
758
        import statcache
 
759
        b = Branch('.')
 
760
        inv = b.read_working_inventory()
 
761
        sc = statcache.update_cache(b, inv)
 
762
        basis = b.basis_tree()
 
763
        basis_inv = basis.inventory
 
764
        
 
765
        # We used to do this through iter_entries(), but that's slow
 
766
        # when most of the files are unmodified, as is usually the
 
767
        # case.  So instead we iterate by inventory entry, and only
 
768
        # calculate paths as necessary.
 
769
 
 
770
        for file_id in basis_inv:
 
771
            cacheentry = sc.get(file_id)
 
772
            if not cacheentry:                 # deleted
 
773
                continue
 
774
            ie = basis_inv[file_id]
 
775
            if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
 
776
                path = inv.id2path(file_id)
 
777
                print path
 
778
 
 
779
 
 
780
 
 
781
class cmd_added(Command):
 
782
    """List files added in working tree."""
 
783
    hidden = True
 
784
    def run(self):
 
785
        b = Branch('.')
 
786
        wt = b.working_tree()
 
787
        basis_inv = b.basis_tree().inventory
 
788
        inv = wt.inventory
 
789
        for file_id in inv:
 
790
            if file_id in basis_inv:
 
791
                continue
 
792
            path = inv.id2path(file_id)
 
793
            if not os.access(b.abspath(path), os.F_OK):
 
794
                continue
 
795
            print path
 
796
                
 
797
        
 
798
 
 
799
class cmd_root(Command):
 
800
    """Show the tree root directory.
 
801
 
 
802
    The root is the nearest enclosing directory with a .bzr control
 
803
    directory."""
 
804
    takes_args = ['filename?']
 
805
    def run(self, filename=None):
 
806
        """Print the branch root."""
 
807
        from branch import find_branch
 
808
        b = find_branch(filename)
 
809
        print getattr(b, 'base', None) or getattr(b, 'baseurl')
 
810
 
 
811
 
 
812
class cmd_log(Command):
 
813
    """Show log of this branch.
 
814
 
 
815
    To request a range of logs, you can use the command -r begin:end
 
816
    -r revision requests a specific revision, -r :end or -r begin: are
 
817
    also valid.
 
818
 
 
819
    TODO: Make --revision support uuid: and hash: [future tag:] notation.
 
820
  
 
821
    """
 
822
 
 
823
    takes_args = ['filename?']
 
824
    takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
 
825
    
 
826
    def run(self, filename=None, timezone='original',
 
827
            verbose=False,
 
828
            show_ids=False,
 
829
            forward=False,
 
830
            revision=None):
 
831
        from bzrlib import show_log, find_branch
 
832
        import codecs
 
833
 
 
834
        direction = (forward and 'forward') or 'reverse'
 
835
        
 
836
        if filename:
 
837
            b = find_branch(filename)
 
838
            fp = b.relpath(filename)
 
839
            if fp:
 
840
                file_id = b.read_working_inventory().path2id(fp)
 
841
            else:
 
842
                file_id = None  # points to branch root
 
843
        else:
 
844
            b = find_branch('.')
 
845
            file_id = None
 
846
 
 
847
        if revision == None:
 
848
            revision = [None, None]
 
849
        elif isinstance(revision, int):
 
850
            revision = [revision, revision]
 
851
        else:
 
852
            # pair of revisions?
 
853
            pass
 
854
            
 
855
        assert len(revision) == 2
 
856
 
 
857
        mutter('encoding log as %r' % bzrlib.user_encoding)
265
858
 
266
859
        # use 'replace' so that we don't abort if trying to write out
267
860
        # in e.g. the default C locale.
268
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
269
 
        # For whatever reason codecs.getwriter() does not advertise its encoding
270
 
        # it just returns the encoding of the wrapped file, which is completely
271
 
        # bogus. So set the attribute, so we can find the correct encoding later.
272
 
        self.outf.encoding = output_encoding
273
 
 
274
 
    @deprecated_method(zero_eight)
275
 
    def run_argv(self, argv):
276
 
        """Parse command line and run.
 
861
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
862
 
 
863
        show_log(b, file_id,
 
864
                 show_timezone=timezone,
 
865
                 verbose=verbose,
 
866
                 show_ids=show_ids,
 
867
                 to_file=outf,
 
868
                 direction=direction,
 
869
                 start_revision=revision[0],
 
870
                 end_revision=revision[1])
 
871
 
 
872
 
 
873
 
 
874
class cmd_touching_revisions(Command):
 
875
    """Return revision-ids which affected a particular file.
 
876
 
 
877
    A more user-friendly interface is "bzr log FILE"."""
 
878
    hidden = True
 
879
    takes_args = ["filename"]
 
880
    def run(self, filename):
 
881
        b = Branch(filename)
 
882
        inv = b.read_working_inventory()
 
883
        file_id = inv.path2id(b.relpath(filename))
 
884
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
 
885
            print "%6d %s" % (revno, what)
 
886
 
 
887
 
 
888
class cmd_ls(Command):
 
889
    """List files in a tree.
 
890
 
 
891
    TODO: Take a revision or remote path and list that tree instead.
 
892
    """
 
893
    hidden = True
 
894
    def run(self, revision=None, verbose=False):
 
895
        b = Branch('.')
 
896
        if revision == None:
 
897
            tree = b.working_tree()
 
898
        else:
 
899
            tree = b.revision_tree(b.lookup_revision(revision))
 
900
 
 
901
        for fp, fc, kind, fid in tree.list_files():
 
902
            if verbose:
 
903
                if kind == 'directory':
 
904
                    kindch = '/'
 
905
                elif kind == 'file':
 
906
                    kindch = ''
 
907
                else:
 
908
                    kindch = '???'
 
909
 
 
910
                print '%-8s %s%s' % (fc, fp, kindch)
 
911
            else:
 
912
                print fp
 
913
 
 
914
 
 
915
 
 
916
class cmd_unknowns(Command):
 
917
    """List unknown files."""
 
918
    def run(self):
 
919
        for f in Branch('.').unknowns():
 
920
            print quotefn(f)
 
921
 
 
922
 
 
923
 
 
924
class cmd_ignore(Command):
 
925
    """Ignore a command or pattern.
 
926
 
 
927
    To remove patterns from the ignore list, edit the .bzrignore file.
 
928
 
 
929
    If the pattern contains a slash, it is compared to the whole path
 
930
    from the branch root.  Otherwise, it is comapred to only the last
 
931
    component of the path.
 
932
 
 
933
    Ignore patterns are case-insensitive on case-insensitive systems.
 
934
 
 
935
    Note: wildcards must be quoted from the shell on Unix.
 
936
 
 
937
    examples:
 
938
        bzr ignore ./Makefile
 
939
        bzr ignore '*.class'
 
940
    """
 
941
    takes_args = ['name_pattern']
 
942
    
 
943
    def run(self, name_pattern):
 
944
        from bzrlib.atomicfile import AtomicFile
 
945
        import os.path
 
946
 
 
947
        b = Branch('.')
 
948
        ifn = b.abspath('.bzrignore')
 
949
 
 
950
        if os.path.exists(ifn):
 
951
            f = open(ifn, 'rt')
 
952
            try:
 
953
                igns = f.read().decode('utf-8')
 
954
            finally:
 
955
                f.close()
 
956
        else:
 
957
            igns = ''
 
958
 
 
959
        # TODO: If the file already uses crlf-style termination, maybe
 
960
        # we should use that for the newly added lines?
 
961
 
 
962
        if igns and igns[-1] != '\n':
 
963
            igns += '\n'
 
964
        igns += name_pattern + '\n'
 
965
 
 
966
        try:
 
967
            f = AtomicFile(ifn, 'wt')
 
968
            f.write(igns.encode('utf-8'))
 
969
            f.commit()
 
970
        finally:
 
971
            f.close()
 
972
 
 
973
        inv = b.working_tree().inventory
 
974
        if inv.path2id('.bzrignore'):
 
975
            mutter('.bzrignore is already versioned')
 
976
        else:
 
977
            mutter('need to make new .bzrignore file versioned')
 
978
            b.add(['.bzrignore'])
 
979
 
 
980
 
 
981
 
 
982
class cmd_ignored(Command):
 
983
    """List ignored files and the patterns that matched them.
 
984
 
 
985
    See also: bzr ignore"""
 
986
    def run(self):
 
987
        tree = Branch('.').working_tree()
 
988
        for path, file_class, kind, file_id in tree.list_files():
 
989
            if file_class != 'I':
 
990
                continue
 
991
            ## XXX: Slightly inefficient since this was already calculated
 
992
            pat = tree.is_ignored(path)
 
993
            print '%-50s %s' % (path, pat)
 
994
 
 
995
 
 
996
class cmd_lookup_revision(Command):
 
997
    """Lookup the revision-id from a revision-number
 
998
 
 
999
    example:
 
1000
        bzr lookup-revision 33
 
1001
    """
 
1002
    hidden = True
 
1003
    takes_args = ['revno']
 
1004
    
 
1005
    def run(self, revno):
 
1006
        try:
 
1007
            revno = int(revno)
 
1008
        except ValueError:
 
1009
            raise BzrCommandError("not a valid revision-number: %r" % revno)
 
1010
 
 
1011
        print Branch('.').lookup_revision(revno)
 
1012
 
 
1013
 
 
1014
class cmd_export(Command):
 
1015
    """Export past revision to destination directory.
 
1016
 
 
1017
    If no revision is specified this exports the last committed revision.
 
1018
 
 
1019
    Format may be an "exporter" name, such as tar, tgz, tbz2.  If none is
 
1020
    given, exports to a directory (equivalent to --format=dir)."""
 
1021
    # TODO: list known exporters
 
1022
    takes_args = ['dest']
 
1023
    takes_options = ['revision', 'format']
 
1024
    def run(self, dest, revision=None, format='dir'):
 
1025
        b = Branch('.')
 
1026
        if revision == None:
 
1027
            rh = b.revision_history()[-1]
 
1028
        else:
 
1029
            rh = b.lookup_revision(int(revision))
 
1030
        t = b.revision_tree(rh)
 
1031
        t.export(dest, format)
 
1032
 
 
1033
 
 
1034
class cmd_cat(Command):
 
1035
    """Write a file's text from a previous revision."""
 
1036
 
 
1037
    takes_options = ['revision']
 
1038
    takes_args = ['filename']
 
1039
 
 
1040
    def run(self, filename, revision=None):
 
1041
        if revision == None:
 
1042
            raise BzrCommandError("bzr cat requires a revision number")
 
1043
        b = Branch('.')
 
1044
        b.print_file(b.relpath(filename), int(revision))
 
1045
 
 
1046
 
 
1047
class cmd_local_time_offset(Command):
 
1048
    """Show the offset in seconds from GMT to local time."""
 
1049
    hidden = True    
 
1050
    def run(self):
 
1051
        print bzrlib.osutils.local_time_offset()
 
1052
 
 
1053
 
 
1054
 
 
1055
class cmd_commit(Command):
 
1056
    """Commit changes into a new revision.
 
1057
 
 
1058
    If selected files are specified, only changes to those files are
 
1059
    committed.  If a directory is specified then its contents are also
 
1060
    committed.
 
1061
 
 
1062
    A selected-file commit may fail in some cases where the committed
 
1063
    tree would be invalid, such as trying to commit a file in a
 
1064
    newly-added directory that is not itself committed.
 
1065
 
 
1066
    TODO: Run hooks on tree to-be-committed, and after commit.
 
1067
 
 
1068
    TODO: Strict commit that fails if there are unknown or deleted files.
 
1069
    """
 
1070
    takes_args = ['selected*']
 
1071
    takes_options = ['message', 'file', 'verbose']
 
1072
    aliases = ['ci', 'checkin']
 
1073
 
 
1074
    def run(self, message=None, file=None, verbose=True, selected_list=None):
 
1075
        from bzrlib.commit import commit
 
1076
 
 
1077
        ## Warning: shadows builtin file()
 
1078
        if not message and not file:
 
1079
            raise BzrCommandError("please specify a commit message",
 
1080
                                  ["use either --message or --file"])
 
1081
        elif message and file:
 
1082
            raise BzrCommandError("please specify either --message or --file")
277
1083
        
278
 
        See run_argv_aliases for the 0.8 and beyond api.
279
 
        """
280
 
        return self.run_argv_aliases(argv)
281
 
 
282
 
    def run_argv_aliases(self, argv, alias_argv=None):
283
 
        """Parse the command line and run with extra aliases in alias_argv."""
284
 
        if argv is None:
285
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
286
 
                 DeprecationWarning, stacklevel=2)
287
 
            argv = []
288
 
        args, opts = parse_args(self, argv, alias_argv)
289
 
        if 'help' in opts:  # e.g. bzr add --help
290
 
            from bzrlib.help import help_on_command
291
 
            help_on_command(self.name())
292
 
            return 0
293
 
        # mix arguments and options into one dictionary
294
 
        cmdargs = _match_argform(self.name(), self.takes_args, args)
295
 
        cmdopts = {}
296
 
        for k, v in opts.items():
297
 
            cmdopts[k.replace('-', '_')] = v
298
 
 
299
 
        all_cmd_args = cmdargs.copy()
300
 
        all_cmd_args.update(cmdopts)
301
 
 
302
 
        self._setup_outf()
303
 
 
304
 
        return self.run(**all_cmd_args)
 
1084
        if file:
 
1085
            import codecs
 
1086
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
 
1087
 
 
1088
        b = Branch('.')
 
1089
        commit(b, message, verbose=verbose, specific_files=selected_list)
 
1090
 
 
1091
 
 
1092
class cmd_check(Command):
 
1093
    """Validate consistency of branch history.
 
1094
 
 
1095
    This command checks various invariants about the branch storage to
 
1096
    detect data corruption or bzr bugs.
 
1097
 
 
1098
    If given the --update flag, it will update some optional fields
 
1099
    to help ensure data consistency.
 
1100
    """
 
1101
    takes_args = ['dir?']
 
1102
 
 
1103
    def run(self, dir='.'):
 
1104
        import bzrlib.check
 
1105
        bzrlib.check.check(Branch(dir))
 
1106
 
 
1107
 
 
1108
 
 
1109
class cmd_upgrade(Command):
 
1110
    """Upgrade branch storage to current format.
 
1111
 
 
1112
    This should normally be used only after the check command tells
 
1113
    you to run it.
 
1114
    """
 
1115
    takes_args = ['dir?']
 
1116
 
 
1117
    def run(self, dir='.'):
 
1118
        from bzrlib.upgrade import upgrade
 
1119
        upgrade(Branch(dir))
 
1120
 
 
1121
 
 
1122
 
 
1123
class cmd_whoami(Command):
 
1124
    """Show bzr user id."""
 
1125
    takes_options = ['email']
305
1126
    
306
 
    def run(self):
307
 
        """Actually run the command.
308
 
 
309
 
        This is invoked with the options and arguments bound to
310
 
        keyword parameters.
311
 
 
312
 
        Return 0 or None if the command was successful, or a non-zero
313
 
        shell error code if not.  It's OK for this method to allow
314
 
        an exception to raise up.
315
 
        """
316
 
        raise NotImplementedError('no implementation of command %r'
317
 
                                  % self.name())
318
 
 
319
 
    def help(self):
320
 
        """Return help message for this class."""
321
 
        from inspect import getdoc
322
 
        if self.__doc__ is Command.__doc__:
323
 
            return None
324
 
        return getdoc(self)
325
 
 
326
 
    def name(self):
327
 
        return _unsquish_command_name(self.__class__.__name__)
328
 
 
329
 
    def plugin_name(self):
330
 
        """Get the name of the plugin that provides this command.
331
 
 
332
 
        :return: The name of the plugin or None if the command is builtin.
333
 
        """
334
 
        mod_parts = self.__module__.split('.')
335
 
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
336
 
            return mod_parts[2]
 
1127
    def run(self, email=False):
 
1128
        if email:
 
1129
            print bzrlib.osutils.user_email()
337
1130
        else:
338
 
            return None
339
 
 
340
 
 
341
 
# Technically, this function hasn't been use in a *really* long time
342
 
# but we are only deprecating it now.
343
 
@deprecated_function(zero_eleven)
 
1131
            print bzrlib.osutils.username()
 
1132
 
 
1133
 
 
1134
class cmd_selftest(Command):
 
1135
    """Run internal test suite"""
 
1136
    hidden = True
 
1137
    def run(self):
 
1138
        from bzrlib.selftest import selftest
 
1139
        return int(not selftest())
 
1140
 
 
1141
 
 
1142
class cmd_version(Command):
 
1143
    """Show version of bzr."""
 
1144
    def run(self):
 
1145
        show_version()
 
1146
 
 
1147
def show_version():
 
1148
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
1149
    # is bzrlib itself in a branch?
 
1150
    bzrrev = bzrlib.get_bzr_revision()
 
1151
    if bzrrev:
 
1152
        print "  (bzr checkout, revision %d {%s})" % bzrrev
 
1153
    print bzrlib.__copyright__
 
1154
    print "http://bazaar-ng.org/"
 
1155
    print
 
1156
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
 
1157
    print "you may use, modify and redistribute it under the terms of the GNU"
 
1158
    print "General Public License version 2 or later."
 
1159
 
 
1160
 
 
1161
class cmd_rocks(Command):
 
1162
    """Statement of optimism."""
 
1163
    hidden = True
 
1164
    def run(self):
 
1165
        print "it sure does!"
 
1166
 
344
1167
def parse_spec(spec):
345
1168
    """
346
1169
    >>> parse_spec(None)
351
1174
    ['..', -1]
352
1175
    >>> parse_spec("../f/@35")
353
1176
    ['../f', 35]
354
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
355
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
356
1177
    """
357
1178
    if spec is None:
358
1179
        return [None, None]
362
1183
        if parsed[1] == "":
363
1184
            parsed[1] = -1
364
1185
        else:
365
 
            try:
366
 
                parsed[1] = int(parsed[1])
367
 
            except ValueError:
368
 
                pass # We can allow stuff like ./@revid:blahblahblah
369
 
            else:
370
 
                assert parsed[1] >=0
 
1186
            parsed[1] = int(parsed[1])
 
1187
            assert parsed[1] >=0
371
1188
    else:
372
1189
        parsed = [spec, None]
373
1190
    return parsed
374
1191
 
375
 
def parse_args(command, argv, alias_argv=None):
 
1192
 
 
1193
 
 
1194
class cmd_merge(Command):
 
1195
    """Perform a three-way merge of trees.
 
1196
    
 
1197
    The SPEC parameters are working tree or revision specifiers.  Working trees
 
1198
    are specified using standard paths or urls.  No component of a directory
 
1199
    path may begin with '@'.
 
1200
    
 
1201
    Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
 
1202
 
 
1203
    Revisions are specified using a dirname/@revno pair, where dirname is the
 
1204
    branch directory and revno is the revision within that branch.  If no revno
 
1205
    is specified, the latest revision is used.
 
1206
 
 
1207
    Revision examples: './@127', 'foo/@', '../@1'
 
1208
 
 
1209
    The OTHER_SPEC parameter is required.  If the BASE_SPEC parameter is
 
1210
    not supplied, the common ancestor of OTHER_SPEC the current branch is used
 
1211
    as the BASE.
 
1212
 
 
1213
    merge refuses to run if there are any uncommitted changes, unless
 
1214
    --force is given.
 
1215
    """
 
1216
    takes_args = ['other_spec', 'base_spec?']
 
1217
    takes_options = ['force']
 
1218
 
 
1219
    def run(self, other_spec, base_spec=None, force=False):
 
1220
        from bzrlib.merge import merge
 
1221
        merge(parse_spec(other_spec), parse_spec(base_spec),
 
1222
              check_clean=(not force))
 
1223
 
 
1224
 
 
1225
class cmd_revert(Command):
 
1226
    """Reverse all changes since the last commit.
 
1227
 
 
1228
    Only versioned files are affected.
 
1229
 
 
1230
    TODO: Store backups of any files that will be reverted, so
 
1231
          that the revert can be undone.          
 
1232
    """
 
1233
    takes_options = ['revision']
 
1234
 
 
1235
    def run(self, revision=-1):
 
1236
        from bzrlib.merge import merge
 
1237
        merge(('.', revision), parse_spec('.'),
 
1238
              check_clean=False,
 
1239
              ignore_zero=True)
 
1240
 
 
1241
 
 
1242
class cmd_assert_fail(Command):
 
1243
    """Test reporting of assertion failures"""
 
1244
    hidden = True
 
1245
    def run(self):
 
1246
        assert False, "always fails"
 
1247
 
 
1248
 
 
1249
class cmd_help(Command):
 
1250
    """Show help on a command or other topic.
 
1251
 
 
1252
    For a list of all available commands, say 'bzr help commands'."""
 
1253
    takes_args = ['topic?']
 
1254
    aliases = ['?']
 
1255
    
 
1256
    def run(self, topic=None):
 
1257
        import help
 
1258
        help.help(topic)
 
1259
 
 
1260
 
 
1261
class cmd_update_stat_cache(Command):
 
1262
    """Update stat-cache mapping inodes to SHA-1 hashes.
 
1263
 
 
1264
    For testing only."""
 
1265
    hidden = True
 
1266
    def run(self):
 
1267
        import statcache
 
1268
        b = Branch('.')
 
1269
        statcache.update_cache(b.base, b.read_working_inventory())
 
1270
 
 
1271
 
 
1272
 
 
1273
# list of all available options; the rhs can be either None for an
 
1274
# option that takes no argument, or a constructor function that checks
 
1275
# the type.
 
1276
OPTIONS = {
 
1277
    'all':                    None,
 
1278
    'diff-options':           str,
 
1279
    'help':                   None,
 
1280
    'file':                   unicode,
 
1281
    'force':                  None,
 
1282
    'format':                 unicode,
 
1283
    'forward':                None,
 
1284
    'message':                unicode,
 
1285
    'no-recurse':             None,
 
1286
    'profile':                None,
 
1287
    'revision':               _parse_revision_str,
 
1288
    'show-ids':               None,
 
1289
    'timezone':               str,
 
1290
    'verbose':                None,
 
1291
    'version':                None,
 
1292
    'email':                  None,
 
1293
    'update':                 None,
 
1294
    }
 
1295
 
 
1296
SHORT_OPTIONS = {
 
1297
    'F':                      'file', 
 
1298
    'h':                      'help',
 
1299
    'm':                      'message',
 
1300
    'r':                      'revision',
 
1301
    'v':                      'verbose',
 
1302
}
 
1303
 
 
1304
 
 
1305
def parse_args(argv):
376
1306
    """Parse command line.
377
1307
    
378
1308
    Arguments and options are parsed at this level before being passed
379
1309
    down to specific command handlers.  This routine knows, from a
380
1310
    lookup table, something about the available options, what optargs
381
1311
    they take, and which commands will accept them.
 
1312
 
 
1313
    >>> parse_args('--help'.split())
 
1314
    ([], {'help': True})
 
1315
    >>> parse_args('--version'.split())
 
1316
    ([], {'version': True})
 
1317
    >>> parse_args('status --all'.split())
 
1318
    (['status'], {'all': True})
 
1319
    >>> parse_args('commit --message=biter'.split())
 
1320
    (['commit'], {'message': u'biter'})
 
1321
    >>> parse_args('log -r 500'.split())
 
1322
    (['log'], {'revision': 500})
 
1323
    >>> parse_args('log -r500:600'.split())
 
1324
    (['log'], {'revision': [500, 600]})
 
1325
    >>> parse_args('log -vr500:600'.split())
 
1326
    (['log'], {'verbose': True, 'revision': [500, 600]})
 
1327
    >>> parse_args('log -rv500:600'.split()) #the r takes an argument
 
1328
    Traceback (most recent call last):
 
1329
    ...
 
1330
    ValueError: invalid literal for int(): v500
382
1331
    """
383
 
    # TODO: make it a method of the Command?
384
 
    parser = option.get_optparser(command.options())
385
 
    if alias_argv is not None:
386
 
        args = alias_argv + argv
387
 
    else:
388
 
        args = argv
389
 
 
390
 
    options, args = parser.parse_args(args)
391
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
392
 
                 v is not option.OptionParser.DEFAULT_VALUE])
 
1332
    args = []
 
1333
    opts = {}
 
1334
 
 
1335
    # TODO: Maybe handle '--' to end options?
 
1336
 
 
1337
    while argv:
 
1338
        a = argv.pop(0)
 
1339
        if a[0] == '-':
 
1340
            # option names must not be unicode
 
1341
            a = str(a)
 
1342
            optarg = None
 
1343
            if a[1] == '-':
 
1344
                mutter("  got option %r" % a)
 
1345
                if '=' in a:
 
1346
                    optname, optarg = a[2:].split('=', 1)
 
1347
                else:
 
1348
                    optname = a[2:]
 
1349
                if optname not in OPTIONS:
 
1350
                    raise BzrError('unknown long option %r' % a)
 
1351
            else:
 
1352
                shortopt = a[1:]
 
1353
                if shortopt in SHORT_OPTIONS:
 
1354
                    # Multi-character options must have a space to delimit
 
1355
                    # their value
 
1356
                    optname = SHORT_OPTIONS[shortopt]
 
1357
                else:
 
1358
                    # Single character short options, can be chained,
 
1359
                    # and have their value appended to their name
 
1360
                    shortopt = a[1:2]
 
1361
                    if shortopt not in SHORT_OPTIONS:
 
1362
                        # We didn't find the multi-character name, and we
 
1363
                        # didn't find the single char name
 
1364
                        raise BzrError('unknown short option %r' % a)
 
1365
                    optname = SHORT_OPTIONS[shortopt]
 
1366
 
 
1367
                    if a[2:]:
 
1368
                        # There are extra things on this option
 
1369
                        # see if it is the value, or if it is another
 
1370
                        # short option
 
1371
                        optargfn = OPTIONS[optname]
 
1372
                        if optargfn is None:
 
1373
                            # This option does not take an argument, so the
 
1374
                            # next entry is another short option, pack it back
 
1375
                            # into the list
 
1376
                            argv.insert(0, '-' + a[2:])
 
1377
                        else:
 
1378
                            # This option takes an argument, so pack it
 
1379
                            # into the array
 
1380
                            optarg = a[2:]
 
1381
            
 
1382
            if optname in opts:
 
1383
                # XXX: Do we ever want to support this, e.g. for -r?
 
1384
                raise BzrError('repeated option %r' % a)
 
1385
                
 
1386
            optargfn = OPTIONS[optname]
 
1387
            if optargfn:
 
1388
                if optarg == None:
 
1389
                    if not argv:
 
1390
                        raise BzrError('option %r needs an argument' % a)
 
1391
                    else:
 
1392
                        optarg = argv.pop(0)
 
1393
                opts[optname] = optargfn(optarg)
 
1394
            else:
 
1395
                if optarg != None:
 
1396
                    raise BzrError('option %r takes no argument' % optname)
 
1397
                opts[optname] = True
 
1398
        else:
 
1399
            args.append(a)
 
1400
 
393
1401
    return args, opts
394
1402
 
395
1403
 
 
1404
 
 
1405
 
396
1406
def _match_argform(cmd, takes_args, args):
397
1407
    argdict = {}
398
1408
 
410
1420
                argdict[argname + '_list'] = None
411
1421
        elif ap[-1] == '+':
412
1422
            if not args:
413
 
                raise errors.BzrCommandError("command %r needs one or more %s"
414
 
                                             % (cmd, argname.upper()))
 
1423
                raise BzrCommandError("command %r needs one or more %s"
 
1424
                        % (cmd, argname.upper()))
415
1425
            else:
416
1426
                argdict[argname + '_list'] = args[:]
417
1427
                args = []
418
1428
        elif ap[-1] == '$': # all but one
419
1429
            if len(args) < 2:
420
 
                raise errors.BzrCommandError("command %r needs one or more %s"
421
 
                                             % (cmd, argname.upper()))
 
1430
                raise BzrCommandError("command %r needs one or more %s"
 
1431
                        % (cmd, argname.upper()))
422
1432
            argdict[argname + '_list'] = args[:-1]
423
 
            args[:-1] = []
 
1433
            args[:-1] = []                
424
1434
        else:
425
1435
            # just a plain arg
426
1436
            argname = ap
427
1437
            if not args:
428
 
                raise errors.BzrCommandError("command %r requires argument %s"
429
 
                               % (cmd, argname.upper()))
 
1438
                raise BzrCommandError("command %r requires argument %s"
 
1439
                        % (cmd, argname.upper()))
430
1440
            else:
431
1441
                argdict[argname] = args.pop(0)
432
1442
            
433
1443
    if args:
434
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
435
 
                                     % (cmd, args[0]))
 
1444
        raise BzrCommandError("extra argument to command %s: %s"
 
1445
                              % (cmd, args[0]))
436
1446
 
437
1447
    return argdict
438
1448
 
439
1449
 
440
 
 
441
 
def apply_profiled(the_callable, *args, **kwargs):
442
 
    import hotshot
443
 
    import tempfile
444
 
    import hotshot.stats
445
 
    pffileno, pfname = tempfile.mkstemp()
446
 
    try:
447
 
        prof = hotshot.Profile(pfname)
448
 
        try:
449
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
450
 
        finally:
451
 
            prof.close()
452
 
        stats = hotshot.stats.load(pfname)
453
 
        stats.strip_dirs()
454
 
        stats.sort_stats('cum')   # 'time'
455
 
        ## XXX: Might like to write to stderr or the trace file instead but
456
 
        ## print_stats seems hardcoded to stdout
457
 
        stats.print_stats(20)
458
 
        return ret
459
 
    finally:
460
 
        os.close(pffileno)
461
 
        os.remove(pfname)
462
 
 
463
 
 
464
 
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
465
 
    from bzrlib.lsprof import profile
466
 
    import cPickle
467
 
    ret, stats = profile(the_callable, *args, **kwargs)
468
 
    stats.sort()
469
 
    if filename is None:
470
 
        stats.pprint()
471
 
    else:
472
 
        stats.freeze()
473
 
        cPickle.dump(stats, open(filename, 'w'), 2)
474
 
        print 'Profile data written to %r.' % filename
475
 
    return ret
476
 
 
477
 
 
478
 
def get_alias(cmd, config=None):
479
 
    """Return an expanded alias, or None if no alias exists.
480
 
 
481
 
    cmd
482
 
        Command to be checked for an alias.
483
 
    config
484
 
        Used to specify an alternative config to use,
485
 
        which is especially useful for testing.
486
 
        If it is unspecified, the global config will be used.
 
1450
def _parse_master_args(argv):
 
1451
    """Parse the arguments that always go with the original command.
 
1452
    These are things like bzr --no-plugins, etc.
 
1453
 
 
1454
    There are now 2 types of option flags. Ones that come *before* the command,
 
1455
    and ones that come *after* the command.
 
1456
    Ones coming *before* the command are applied against all possible commands.
 
1457
    And are generally applied before plugins are loaded.
 
1458
 
 
1459
    The current list are:
 
1460
        --builtin   Allow plugins to load, but don't let them override builtin commands,
 
1461
                    they will still be allowed if they do not override a builtin.
 
1462
        --no-plugins    Don't load any plugins. This lets you get back to official source
 
1463
                        behavior.
 
1464
        --profile   Enable the hotspot profile before running the command.
 
1465
                    For backwards compatibility, this is also a non-master option.
 
1466
        --version   Spit out the version of bzr that is running and exit.
 
1467
                    This is also a non-master option.
 
1468
        --help      Run help and exit, also a non-master option (I think that should stay, though)
 
1469
 
 
1470
    >>> argv, opts = _parse_master_args(['bzr', '--test'])
 
1471
    Traceback (most recent call last):
 
1472
    ...
 
1473
    BzrCommandError: Invalid master option: 'test'
 
1474
    >>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
 
1475
    >>> print argv
 
1476
    ['command']
 
1477
    >>> print opts['version']
 
1478
    True
 
1479
    >>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
 
1480
    >>> print argv
 
1481
    ['command', '--more-options']
 
1482
    >>> print opts['profile']
 
1483
    True
 
1484
    >>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
 
1485
    >>> print argv
 
1486
    ['command']
 
1487
    >>> print opts['no-plugins']
 
1488
    True
 
1489
    >>> print opts['profile']
 
1490
    False
 
1491
    >>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
 
1492
    >>> print argv
 
1493
    ['command', '--profile']
 
1494
    >>> print opts['profile']
 
1495
    False
487
1496
    """
488
 
    if config is None:
489
 
        import bzrlib.config
490
 
        config = bzrlib.config.GlobalConfig()
491
 
    alias = config.get_alias(cmd)
492
 
    if (alias):
493
 
        import shlex
494
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
495
 
    return None
 
1497
    master_opts = {'builtin':False,
 
1498
        'no-plugins':False,
 
1499
        'version':False,
 
1500
        'profile':False,
 
1501
        'help':False
 
1502
    }
 
1503
 
 
1504
    # This is the point where we could hook into argv[0] to determine
 
1505
    # what front-end is supposed to be run
 
1506
    # For now, we are just ignoring it.
 
1507
    cmd_name = argv.pop(0)
 
1508
    for arg in argv[:]:
 
1509
        if arg[:2] != '--': # at the first non-option, we return the rest
 
1510
            break
 
1511
        arg = arg[2:] # Remove '--'
 
1512
        if arg not in master_opts:
 
1513
            # We could say that this is not an error, that we should
 
1514
            # just let it be handled by the main section instead
 
1515
            raise BzrCommandError('Invalid master option: %r' % arg)
 
1516
        argv.pop(0) # We are consuming this entry
 
1517
        master_opts[arg] = True
 
1518
    return argv, master_opts
 
1519
 
496
1520
 
497
1521
 
498
1522
def run_bzr(argv):
500
1524
 
501
1525
    This is similar to main(), but without all the trappings for
502
1526
    logging and error handling.  
503
 
    
504
 
    argv
505
 
       The command-line arguments, without the program name from argv[0]
506
 
       These should already be decoded. All library/test code calling
507
 
       run_bzr should be passing valid strings (don't need decoding).
508
 
    
509
 
    Returns a command status or raises an exception.
510
 
 
511
 
    Special master options: these must come before the command because
512
 
    they control how the command is interpreted.
513
 
 
514
 
    --no-plugins
515
 
        Do not load plugin modules at all
516
 
 
517
 
    --no-aliases
518
 
        Do not allow aliases
519
 
 
520
 
    --builtin
521
 
        Only use builtin commands.  (Plugins are still allowed to change
522
 
        other behaviour.)
523
 
 
524
 
    --profile
525
 
        Run under the Python hotshot profiler.
526
 
 
527
 
    --lsprof
528
 
        Run under the Python lsprof profiler.
529
1527
    """
530
 
    argv = list(argv)
531
 
    trace.mutter("bzr arguments: %r", argv)
532
 
 
533
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
534
 
                opt_no_aliases = False
535
 
    opt_lsprof_file = None
536
 
 
537
 
    # --no-plugins is handled specially at a very early stage. We need
538
 
    # to load plugins before doing other command parsing so that they
539
 
    # can override commands, but this needs to happen first.
540
 
 
541
 
    argv_copy = []
542
 
    i = 0
543
 
    while i < len(argv):
544
 
        a = argv[i]
545
 
        if a == '--profile':
546
 
            opt_profile = True
547
 
        elif a == '--lsprof':
548
 
            opt_lsprof = True
549
 
        elif a == '--lsprof-file':
550
 
            opt_lsprof = True
551
 
            opt_lsprof_file = argv[i + 1]
552
 
            i += 1
553
 
        elif a == '--no-plugins':
554
 
            opt_no_plugins = True
555
 
        elif a == '--no-aliases':
556
 
            opt_no_aliases = True
557
 
        elif a == '--builtin':
558
 
            opt_builtin = True
559
 
        elif a in ('--quiet', '-q'):
560
 
            trace.be_quiet()
561
 
        elif a.startswith('-D'):
562
 
            debug.debug_flags.add(a[2:])
563
 
        else:
564
 
            argv_copy.append(a)
565
 
        i += 1
566
 
 
567
 
    argv = argv_copy
568
 
    if (not argv):
569
 
        from bzrlib.builtins import cmd_help
570
 
        cmd_help().run_argv_aliases([])
571
 
        return 0
572
 
 
573
 
    if argv[0] == '--version':
574
 
        from bzrlib.version import show_version
575
 
        show_version()
576
 
        return 0
577
 
        
578
 
    if not opt_no_plugins:
579
 
        from bzrlib.plugin import load_plugins
580
 
        load_plugins()
581
 
    else:
582
 
        from bzrlib.plugin import disable_plugins
583
 
        disable_plugins()
584
 
 
585
 
    alias_argv = None
586
 
 
587
 
    if not opt_no_aliases:
588
 
        alias_argv = get_alias(argv[0])
589
 
        if alias_argv:
590
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
591
 
            argv[0] = alias_argv.pop(0)
592
 
 
593
 
    cmd = argv.pop(0)
594
 
    # We want only 'ascii' command names, but the user may have typed
595
 
    # in a Unicode name. In that case, they should just get a
596
 
    # 'command not found' error later.
597
 
 
598
 
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
599
 
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
600
 
        run = cmd_obj.run_argv
601
 
        run_argv = [argv]
602
 
    else:
603
 
        run = cmd_obj.run_argv_aliases
604
 
        run_argv = [argv, alias_argv]
605
 
 
 
1528
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
1529
    
606
1530
    try:
607
 
        if opt_lsprof:
608
 
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
609
 
        elif opt_profile:
610
 
            ret = apply_profiled(run, *run_argv)
611
 
        else:
612
 
            ret = run(*run_argv)
613
 
        return ret or 0
614
 
    finally:
615
 
        # reset, in case we may do other commands later within the same process
616
 
        trace.be_quiet(False)
617
 
 
618
 
def display_command(func):
619
 
    """Decorator that suppresses pipe/interrupt errors."""
620
 
    def ignore_pipe(*args, **kwargs):
 
1531
        # some options like --builtin and --no-plugins have special effects
 
1532
        argv, master_opts = _parse_master_args(argv)
 
1533
        if 'no-plugins' not in master_opts:
 
1534
            bzrlib.load_plugins()
 
1535
 
 
1536
        args, opts = parse_args(argv)
 
1537
 
 
1538
        if master_opts['help']:
 
1539
            from bzrlib.help import help
 
1540
            if argv:
 
1541
                help(argv[0])
 
1542
            else:
 
1543
                help()
 
1544
            return 0            
 
1545
            
 
1546
        if 'help' in opts:
 
1547
            from bzrlib.help import help
 
1548
            if args:
 
1549
                help(args[0])
 
1550
            else:
 
1551
                help()
 
1552
            return 0
 
1553
        elif 'version' in opts:
 
1554
            show_version()
 
1555
            return 0
 
1556
        elif args and args[0] == 'builtin':
 
1557
            include_plugins=False
 
1558
            args = args[1:]
 
1559
        cmd = str(args.pop(0))
 
1560
    except IndexError:
 
1561
        import help
 
1562
        help.help()
 
1563
        return 1
 
1564
          
 
1565
 
 
1566
    plugins_override = not (master_opts['builtin'])
 
1567
    canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
 
1568
 
 
1569
    profile = master_opts['profile']
 
1570
    # For backwards compatibility, I would rather stick with --profile being a
 
1571
    # master/global option
 
1572
    if 'profile' in opts:
 
1573
        profile = True
 
1574
        del opts['profile']
 
1575
 
 
1576
    # check options are reasonable
 
1577
    allowed = cmd_class.takes_options
 
1578
    for oname in opts:
 
1579
        if oname not in allowed:
 
1580
            raise BzrCommandError("option '--%s' is not allowed for command %r"
 
1581
                                  % (oname, cmd))
 
1582
 
 
1583
    # mix arguments and options into one dictionary
 
1584
    cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
 
1585
    cmdopts = {}
 
1586
    for k, v in opts.items():
 
1587
        cmdopts[k.replace('-', '_')] = v
 
1588
 
 
1589
    if profile:
 
1590
        import hotshot, tempfile
 
1591
        pffileno, pfname = tempfile.mkstemp()
621
1592
        try:
622
 
            result = func(*args, **kwargs)
623
 
            sys.stdout.flush()
624
 
            return result
625
 
        except IOError, e:
626
 
            if getattr(e, 'errno', None) is None:
627
 
                raise
628
 
            if e.errno != errno.EPIPE:
629
 
                # Win32 raises IOError with errno=0 on a broken pipe
630
 
                if sys.platform != 'win32' or e.errno != 0:
631
 
                    raise
632
 
            pass
633
 
        except KeyboardInterrupt:
634
 
            pass
635
 
    return ignore_pipe
 
1593
            prof = hotshot.Profile(pfname)
 
1594
            ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
 
1595
            prof.close()
 
1596
 
 
1597
            import hotshot.stats
 
1598
            stats = hotshot.stats.load(pfname)
 
1599
            #stats.strip_dirs()
 
1600
            stats.sort_stats('time')
 
1601
            ## XXX: Might like to write to stderr or the trace file instead but
 
1602
            ## print_stats seems hardcoded to stdout
 
1603
            stats.print_stats(20)
 
1604
            
 
1605
            return ret.status
 
1606
 
 
1607
        finally:
 
1608
            os.close(pffileno)
 
1609
            os.remove(pfname)
 
1610
    else:
 
1611
        return cmd_class(cmdopts, cmdargs).status 
 
1612
 
 
1613
 
 
1614
def _report_exception(summary, quiet=False):
 
1615
    import traceback
 
1616
    log_error('bzr: ' + summary)
 
1617
    bzrlib.trace.log_exception()
 
1618
 
 
1619
    if not quiet:
 
1620
        tb = sys.exc_info()[2]
 
1621
        exinfo = traceback.extract_tb(tb)
 
1622
        if exinfo:
 
1623
            sys.stderr.write('  at %s:%d in %s()\n' % exinfo[-1][:3])
 
1624
        sys.stderr.write('  see ~/.bzr.log for debug information\n')
 
1625
 
636
1626
 
637
1627
 
638
1628
def main(argv):
639
 
    import bzrlib.ui
640
 
    from bzrlib.ui.text import TextUIFactory
641
 
    bzrlib.ui.ui_factory = TextUIFactory()
642
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
643
 
    ret = run_bzr_catch_errors(argv)
644
 
    trace.mutter("return code %d", ret)
645
 
    return ret
646
 
 
647
 
 
648
 
def run_bzr_catch_errors(argv):
 
1629
    import errno
 
1630
    
 
1631
    bzrlib.open_tracefile(argv)
 
1632
 
649
1633
    try:
650
 
        return run_bzr(argv)
651
 
        # do this here inside the exception wrappers to catch EPIPE
652
 
        sys.stdout.flush()
653
 
    except (KeyboardInterrupt, Exception), e:
654
 
        # used to handle AssertionError and KeyboardInterrupt
655
 
        # specially here, but hopefully they're handled ok by the logger now
656
 
        trace.report_exception(sys.exc_info(), sys.stderr)
657
 
        if os.environ.get('BZR_PDB'):
658
 
            print '**** entering debugger'
659
 
            import pdb
660
 
            pdb.post_mortem(sys.exc_traceback)
661
 
        return 3
 
1634
        try:
 
1635
            try:
 
1636
                return run_bzr(argv)
 
1637
            finally:
 
1638
                # do this here inside the exception wrappers to catch EPIPE
 
1639
                sys.stdout.flush()
 
1640
        except BzrError, e:
 
1641
            quiet = isinstance(e, (BzrCommandError))
 
1642
            _report_exception('error: ' + e.args[0], quiet=quiet)
 
1643
            if len(e.args) > 1:
 
1644
                for h in e.args[1]:
 
1645
                    # some explanation or hints
 
1646
                    log_error('  ' + h)
 
1647
            return 1
 
1648
        except AssertionError, e:
 
1649
            msg = 'assertion failed'
 
1650
            if str(e):
 
1651
                msg += ': ' + str(e)
 
1652
            _report_exception(msg)
 
1653
            return 2
 
1654
        except KeyboardInterrupt, e:
 
1655
            _report_exception('interrupted', quiet=True)
 
1656
            return 2
 
1657
        except Exception, e:
 
1658
            quiet = False
 
1659
            if (isinstance(e, IOError) 
 
1660
                and hasattr(e, 'errno')
 
1661
                and e.errno == errno.EPIPE):
 
1662
                quiet = True
 
1663
                msg = 'broken pipe'
 
1664
            else:
 
1665
                msg = str(e).rstrip('\n')
 
1666
            _report_exception(msg, quiet)
 
1667
            return 2
 
1668
    finally:
 
1669
        bzrlib.trace.close_trace()
 
1670
 
662
1671
 
663
1672
if __name__ == '__main__':
664
1673
    sys.exit(main(sys.argv))