~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2005-05-12 02:18:48 UTC
  • Revision ID: mbp@sourcefrog.net-20050512021848-d1a727373aee2c85
- WorkingTree loads statcache in constructor and holds
  it permanently

Show diffs side-by-side

added added

removed removed

Lines of Context:
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, time, os.path
 
20
from sets import Set
39
21
 
40
22
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
58
 
 
59
 
 
60
 
plugin_cmds = {}
61
 
 
62
 
 
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
 
    """
71
 
    global plugin_cmds
72
 
    k = cmd.__name__
73
 
    if k.startswith("cmd_"):
74
 
        k_unsquished = _unsquish_command_name(k)
75
 
    else:
76
 
        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
86
 
    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__])
 
23
from bzrlib.trace import mutter, note, log_error
 
24
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
 
25
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
 
26
from bzrlib.tree import RevisionTree, EmptyTree, Tree
 
27
from bzrlib.revision import Revision
 
28
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
 
29
     format_date
89
30
 
90
31
 
91
32
def _squish_command_name(cmd):
96
37
    assert cmd.startswith("cmd_")
97
38
    return cmd[4:].replace('_','-')
98
39
 
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()
118
 
 
119
 
 
120
 
def _get_cmd_dict(plugins_override=True):
121
 
    """Return name->class mapping for all commands."""
122
 
    d = _builtin_commands()
123
 
    if plugins_override:
124
 
        d.update(plugin_cmds)
125
 
    return d
126
 
 
127
 
    
128
 
def get_all_cmds(plugins_override=True):
 
40
def get_all_cmds():
129
41
    """Return canonical name and class for all registered commands."""
130
 
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
131
 
        yield k,v
132
 
 
133
 
 
134
 
def get_cmd_object(cmd_name, plugins_override=True):
 
42
    for k, v in globals().iteritems():
 
43
        if k.startswith("cmd_"):
 
44
            yield _unsquish_command_name(k), v
 
45
 
 
46
def get_cmd_class(cmd):
135
47
    """Return the canonical name and command class for a command.
136
 
 
137
 
    plugins_override
138
 
        If true, plugin commands can override builtins.
139
48
    """
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.
 
49
    cmd = str(cmd)                      # not unicode
146
50
 
147
51
    # first look up this command under the specified name
148
 
    cmds = _get_cmd_dict(plugins_override=plugins_override)
149
52
    try:
150
 
        return cmds[cmd_name]()
 
53
        return cmd, globals()[_squish_command_name(cmd)]
151
54
    except KeyError:
152
55
        pass
153
56
 
154
57
    # 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)
164
 
 
165
 
 
166
 
class Command(object):
 
58
    for cmdname, cmdclass in get_all_cmds():
 
59
        if cmd in cmdclass.aliases:
 
60
            return cmdname, cmdclass
 
61
 
 
62
    cmdclass = ExternalCommand.find_command(cmd)
 
63
    if cmdclass:
 
64
        return cmd, cmdclass
 
65
 
 
66
    raise BzrCommandError("unknown command %r" % cmd)
 
67
 
 
68
 
 
69
class Command:
167
70
    """Base class for commands.
168
71
 
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
72
    The docstring for an actual command should give a single-line
181
73
    summary, then a complete description of the command.  A grammar
182
74
    description will be inserted.
183
75
 
184
 
    aliases
185
 
        Other accepted names for this command.
186
 
 
187
76
    takes_args
188
77
        List of argument forms, marked with whether they are optional,
189
78
        repeated, etc.
190
79
 
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
80
    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().
 
81
        List of options that may be given for this command.
203
82
 
204
83
    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
 
 
 
84
        If true, this command isn't advertised.
223
85
    """
224
86
    aliases = []
 
87
    
225
88
    takes_args = []
226
89
    takes_options = []
227
 
    encoding_type = 'strict'
228
90
 
229
91
    hidden = False
230
92
    
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()
265
 
 
266
 
        # use 'replace' so that we don't abort if trying to write out
267
 
        # 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
 
    def run_argv_aliases(self, argv, alias_argv=None):
275
 
        """Parse the command line and run with extra aliases in alias_argv."""
276
 
        if argv is None:
277
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
278
 
                 DeprecationWarning, stacklevel=2)
279
 
            argv = []
280
 
        args, opts = parse_args(self, argv, alias_argv)
281
 
        if 'help' in opts:  # e.g. bzr add --help
282
 
            from bzrlib.help import help_on_command
283
 
            help_on_command(self.name())
284
 
            return 0
285
 
        # mix arguments and options into one dictionary
286
 
        cmdargs = _match_argform(self.name(), self.takes_args, args)
287
 
        cmdopts = {}
288
 
        for k, v in opts.items():
289
 
            cmdopts[k.replace('-', '_')] = v
290
 
 
291
 
        all_cmd_args = cmdargs.copy()
292
 
        all_cmd_args.update(cmdopts)
293
 
 
294
 
        self._setup_outf()
295
 
 
296
 
        return self.run(**all_cmd_args)
 
93
    def __init__(self, options, arguments):
 
94
        """Construct and run the command.
 
95
 
 
96
        Sets self.status to the return value of run()."""
 
97
        assert isinstance(options, dict)
 
98
        assert isinstance(arguments, dict)
 
99
        cmdargs = options.copy()
 
100
        cmdargs.update(arguments)
 
101
        assert self.__doc__ != Command.__doc__, \
 
102
               ("No help message set for %r" % self)
 
103
        self.status = self.run(**cmdargs)
 
104
 
297
105
    
298
106
    def run(self):
299
 
        """Actually run the command.
 
107
        """Override this in sub-classes.
300
108
 
301
109
        This is invoked with the options and arguments bound to
302
110
        keyword parameters.
303
111
 
304
 
        Return 0 or None if the command was successful, or a non-zero
305
 
        shell error code if not.  It's OK for this method to allow
306
 
        an exception to raise up.
307
 
        """
308
 
        raise NotImplementedError('no implementation of command %r'
309
 
                                  % self.name())
310
 
 
311
 
    def help(self):
312
 
        """Return help message for this class."""
313
 
        from inspect import getdoc
314
 
        if self.__doc__ is Command.__doc__:
315
 
            return None
316
 
        return getdoc(self)
317
 
 
318
 
    def name(self):
319
 
        return _unsquish_command_name(self.__class__.__name__)
320
 
 
321
 
    def plugin_name(self):
322
 
        """Get the name of the plugin that provides this command.
323
 
 
324
 
        :return: The name of the plugin or None if the command is builtin.
325
 
        """
326
 
        mod_parts = self.__module__.split('.')
327
 
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
328
 
            return mod_parts[2]
329
 
        else:
330
 
            return None
331
 
 
332
 
 
333
 
# Technically, this function hasn't been use in a *really* long time
334
 
# but we are only deprecating it now.
335
 
@deprecated_function(zero_eleven)
336
 
def parse_spec(spec):
337
 
    """
338
 
    >>> parse_spec(None)
339
 
    [None, None]
340
 
    >>> parse_spec("./")
341
 
    ['./', None]
342
 
    >>> parse_spec("../@")
343
 
    ['..', -1]
344
 
    >>> parse_spec("../f/@35")
345
 
    ['../f', 35]
346
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
347
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
348
 
    """
349
 
    if spec is None:
350
 
        return [None, None]
351
 
    if '/@' in spec:
352
 
        parsed = spec.split('/@')
353
 
        assert len(parsed) == 2
354
 
        if parsed[1] == "":
355
 
            parsed[1] = -1
356
 
        else:
357
 
            try:
358
 
                parsed[1] = int(parsed[1])
359
 
            except ValueError:
360
 
                pass # We can allow stuff like ./@revid:blahblahblah
361
 
            else:
362
 
                assert parsed[1] >=0
363
 
    else:
364
 
        parsed = [spec, None]
365
 
    return parsed
366
 
 
367
 
def parse_args(command, argv, alias_argv=None):
 
112
        Return 0 or None if the command was successful, or a shell
 
113
        error code if not.
 
114
        """
 
115
        return 0
 
116
 
 
117
 
 
118
class ExternalCommand(Command):
 
119
    """Class to wrap external commands.
 
120
 
 
121
    We cheat a little here, when get_cmd_class() calls us we actually give it back
 
122
    an object we construct that has the appropriate path, help, options etc for the
 
123
    specified command.
 
124
 
 
125
    When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
 
126
    method, which we override to call the Command.__init__ method. That then calls
 
127
    our run method which is pretty straight forward.
 
128
 
 
129
    The only wrinkle is that we have to map bzr's dictionary of options and arguments
 
130
    back into command line options and arguments for the script.
 
131
    """
 
132
 
 
133
    def find_command(cls, cmd):
 
134
        bzrpath = os.environ.get('BZRPATH', '')
 
135
 
 
136
        for dir in bzrpath.split(':'):
 
137
            path = os.path.join(dir, cmd)
 
138
            if os.path.isfile(path):
 
139
                return ExternalCommand(path)
 
140
 
 
141
        return None
 
142
 
 
143
    find_command = classmethod(find_command)
 
144
 
 
145
    def __init__(self, path):
 
146
        self.path = path
 
147
 
 
148
        # TODO: If either of these fail, we should detect that and
 
149
        # assume that path is not really a bzr plugin after all.
 
150
 
 
151
        pipe = os.popen('%s --bzr-usage' % path, 'r')
 
152
        self.takes_options = pipe.readline().split()
 
153
        self.takes_args = pipe.readline().split()
 
154
        pipe.close()
 
155
 
 
156
        pipe = os.popen('%s --bzr-help' % path, 'r')
 
157
        self.__doc__ = pipe.read()
 
158
        pipe.close()
 
159
 
 
160
    def __call__(self, options, arguments):
 
161
        Command.__init__(self, options, arguments)
 
162
        return self
 
163
 
 
164
    def run(self, **kargs):
 
165
        opts = []
 
166
        args = []
 
167
 
 
168
        keys = kargs.keys()
 
169
        keys.sort()
 
170
        for name in keys:
 
171
            value = kargs[name]
 
172
            if OPTIONS.has_key(name):
 
173
                # it's an option
 
174
                opts.append('--%s' % name)
 
175
                if value is not None and value is not True:
 
176
                    opts.append(str(value))
 
177
            else:
 
178
                # it's an arg, or arg list
 
179
                if type(value) is not list:
 
180
                    value = [value]
 
181
                for v in value:
 
182
                    if v is not None:
 
183
                        args.append(str(v))
 
184
 
 
185
        self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
 
186
        return self.status
 
187
 
 
188
 
 
189
class cmd_status(Command):
 
190
    """Display status summary.
 
191
 
 
192
    This reports on versioned and unknown files, reporting them
 
193
    grouped by state.  Possible states are:
 
194
 
 
195
    added
 
196
        Versioned in the working copy but not in the previous revision.
 
197
 
 
198
    removed
 
199
        Versioned in the previous revision but removed or deleted
 
200
        in the working copy.
 
201
 
 
202
    renamed
 
203
        Path of this file changed from the previous revision;
 
204
        the text may also have changed.  This includes files whose
 
205
        parent directory was renamed.
 
206
 
 
207
    modified
 
208
        Text has changed since the previous revision.
 
209
 
 
210
    unchanged
 
211
        Nothing about this file has changed since the previous revision.
 
212
        Only shown with --all.
 
213
 
 
214
    unknown
 
215
        Not versioned and not matching an ignore pattern.
 
216
 
 
217
    To see ignored files use 'bzr ignored'.  For details in the
 
218
    changes to file texts, use 'bzr diff'.
 
219
 
 
220
    If no arguments are specified, the status of the entire working
 
221
    directory is shown.  Otherwise, only the status of the specified
 
222
    files or directories is reported.  If a directory is given, status
 
223
    is reported for everything inside that directory.
 
224
    """
 
225
    takes_args = ['file*']
 
226
    takes_options = ['all', 'show-ids']
 
227
    aliases = ['st', 'stat']
 
228
    
 
229
    def run(self, all=False, show_ids=False, file_list=None):
 
230
        if file_list:
 
231
            b = Branch(file_list[0], lock_mode='r')
 
232
            file_list = [b.relpath(x) for x in file_list]
 
233
            # special case: only one path was given and it's the root
 
234
            # of the branch
 
235
            if file_list == ['']:
 
236
                file_list = None
 
237
        else:
 
238
            b = Branch('.', lock_mode='r')
 
239
        import status
 
240
        status.show_status(b, show_unchanged=all, show_ids=show_ids,
 
241
                           specific_files=file_list)
 
242
 
 
243
 
 
244
class cmd_cat_revision(Command):
 
245
    """Write out metadata for a revision."""
 
246
 
 
247
    hidden = True
 
248
    takes_args = ['revision_id']
 
249
    
 
250
    def run(self, revision_id):
 
251
        Branch('.').get_revision(revision_id).write_xml(sys.stdout)
 
252
 
 
253
 
 
254
class cmd_revno(Command):
 
255
    """Show current revision number.
 
256
 
 
257
    This is equal to the number of revisions on this branch."""
 
258
    def run(self):
 
259
        print Branch('.').revno()
 
260
 
 
261
    
 
262
class cmd_add(Command):
 
263
    """Add specified files or directories.
 
264
 
 
265
    In non-recursive mode, all the named items are added, regardless
 
266
    of whether they were previously ignored.  A warning is given if
 
267
    any of the named files are already versioned.
 
268
 
 
269
    In recursive mode (the default), files are treated the same way
 
270
    but the behaviour for directories is different.  Directories that
 
271
    are already versioned do not give a warning.  All directories,
 
272
    whether already versioned or not, are searched for files or
 
273
    subdirectories that are neither versioned or ignored, and these
 
274
    are added.  This search proceeds recursively into versioned
 
275
    directories.
 
276
 
 
277
    Therefore simply saying 'bzr add .' will version all files that
 
278
    are currently unknown.
 
279
 
 
280
    TODO: Perhaps adding a file whose directly is not versioned should
 
281
    recursively add that parent, rather than giving an error?
 
282
    """
 
283
    takes_args = ['file+']
 
284
    takes_options = ['verbose']
 
285
    
 
286
    def run(self, file_list, verbose=False):
 
287
        bzrlib.add.smart_add(file_list, verbose)
 
288
 
 
289
 
 
290
class cmd_relpath(Command):
 
291
    """Show path of a file relative to root"""
 
292
    takes_args = ['filename']
 
293
    
 
294
    def run(self, filename):
 
295
        print Branch(filename).relpath(filename)
 
296
 
 
297
 
 
298
 
 
299
class cmd_inventory(Command):
 
300
    """Show inventory of the current working copy or a revision."""
 
301
    takes_options = ['revision']
 
302
    
 
303
    def run(self, revision=None):
 
304
        b = Branch('.')
 
305
        if revision == None:
 
306
            inv = b.read_working_inventory()
 
307
        else:
 
308
            inv = b.get_revision_inventory(b.lookup_revision(revision))
 
309
 
 
310
        for path, entry in inv.iter_entries():
 
311
            print '%-50s %s' % (entry.file_id, path)
 
312
 
 
313
 
 
314
class cmd_move(Command):
 
315
    """Move files to a different directory.
 
316
 
 
317
    examples:
 
318
        bzr move *.txt doc
 
319
 
 
320
    The destination must be a versioned directory in the same branch.
 
321
    """
 
322
    takes_args = ['source$', 'dest']
 
323
    def run(self, source_list, dest):
 
324
        b = Branch('.')
 
325
 
 
326
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
 
327
 
 
328
 
 
329
class cmd_rename(Command):
 
330
    """Change the name of an entry.
 
331
 
 
332
    examples:
 
333
      bzr rename frob.c frobber.c
 
334
      bzr rename src/frob.c lib/frob.c
 
335
 
 
336
    It is an error if the destination name exists.
 
337
 
 
338
    See also the 'move' command, which moves files into a different
 
339
    directory without changing their name.
 
340
 
 
341
    TODO: Some way to rename multiple files without invoking bzr for each
 
342
    one?"""
 
343
    takes_args = ['from_name', 'to_name']
 
344
    
 
345
    def run(self, from_name, to_name):
 
346
        b = Branch('.')
 
347
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
 
348
 
 
349
 
 
350
 
 
351
class cmd_renames(Command):
 
352
    """Show list of renamed files.
 
353
 
 
354
    TODO: Option to show renames between two historical versions.
 
355
 
 
356
    TODO: Only show renames under dir, rather than in the whole branch.
 
357
    """
 
358
    takes_args = ['dir?']
 
359
 
 
360
    def run(self, dir='.'):
 
361
        b = Branch(dir)
 
362
        old_inv = b.basis_tree().inventory
 
363
        new_inv = b.read_working_inventory()
 
364
 
 
365
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
 
366
        renames.sort()
 
367
        for old_name, new_name in renames:
 
368
            print "%s => %s" % (old_name, new_name)        
 
369
 
 
370
 
 
371
class cmd_info(Command):
 
372
    """Show statistical information about a branch."""
 
373
    takes_args = ['branch?']
 
374
    
 
375
    def run(self, branch=None):
 
376
        import info
 
377
 
 
378
        from branch import find_branch
 
379
        b = find_branch(branch)
 
380
        info.show_info(b)
 
381
 
 
382
 
 
383
class cmd_remove(Command):
 
384
    """Make a file unversioned.
 
385
 
 
386
    This makes bzr stop tracking changes to a versioned file.  It does
 
387
    not delete the working copy.
 
388
    """
 
389
    takes_args = ['file+']
 
390
    takes_options = ['verbose']
 
391
    
 
392
    def run(self, file_list, verbose=False):
 
393
        b = Branch(file_list[0])
 
394
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
 
395
 
 
396
 
 
397
class cmd_file_id(Command):
 
398
    """Print file_id of a particular file or directory.
 
399
 
 
400
    The file_id is assigned when the file is first added and remains the
 
401
    same through all revisions where the file exists, even when it is
 
402
    moved or renamed.
 
403
    """
 
404
    hidden = True
 
405
    takes_args = ['filename']
 
406
    def run(self, filename):
 
407
        b = Branch(filename)
 
408
        i = b.inventory.path2id(b.relpath(filename))
 
409
        if i == None:
 
410
            bailout("%r is not a versioned file" % filename)
 
411
        else:
 
412
            print i
 
413
 
 
414
 
 
415
class cmd_file_path(Command):
 
416
    """Print path of file_ids to a file or directory.
 
417
 
 
418
    This prints one line for each directory down to the target,
 
419
    starting at the branch root."""
 
420
    hidden = True
 
421
    takes_args = ['filename']
 
422
    def run(self, filename):
 
423
        b = Branch(filename)
 
424
        inv = b.inventory
 
425
        fid = inv.path2id(b.relpath(filename))
 
426
        if fid == None:
 
427
            bailout("%r is not a versioned file" % filename)
 
428
        for fip in inv.get_idpath(fid):
 
429
            print fip
 
430
 
 
431
 
 
432
class cmd_revision_history(Command):
 
433
    """Display list of revision ids on this branch."""
 
434
    def run(self):
 
435
        for patchid in Branch('.').revision_history():
 
436
            print patchid
 
437
 
 
438
 
 
439
class cmd_directories(Command):
 
440
    """Display list of versioned directories in this branch."""
 
441
    def run(self):
 
442
        for name, ie in Branch('.').read_working_inventory().directories():
 
443
            if name == '':
 
444
                print '.'
 
445
            else:
 
446
                print name
 
447
 
 
448
 
 
449
class cmd_init(Command):
 
450
    """Make a directory into a versioned branch.
 
451
 
 
452
    Use this to create an empty branch, or before importing an
 
453
    existing project.
 
454
 
 
455
    Recipe for importing a tree of files:
 
456
        cd ~/project
 
457
        bzr init
 
458
        bzr add -v .
 
459
        bzr status
 
460
        bzr commit -m 'imported project'
 
461
    """
 
462
    def run(self):
 
463
        Branch('.', init=True)
 
464
 
 
465
 
 
466
class cmd_diff(Command):
 
467
    """Show differences in working tree.
 
468
    
 
469
    If files are listed, only the changes in those files are listed.
 
470
    Otherwise, all changes for the tree are listed.
 
471
 
 
472
    TODO: Given two revision arguments, show the difference between them.
 
473
 
 
474
    TODO: Allow diff across branches.
 
475
 
 
476
    TODO: Option to use external diff command; could be GNU diff, wdiff,
 
477
          or a graphical diff.
 
478
 
 
479
    TODO: Python difflib is not exactly the same as unidiff; should
 
480
          either fix it up or prefer to use an external diff.
 
481
 
 
482
    TODO: If a directory is given, diff everything under that.
 
483
 
 
484
    TODO: Selected-file diff is inefficient and doesn't show you
 
485
          deleted files.
 
486
 
 
487
    TODO: This probably handles non-Unix newlines poorly.
 
488
    """
 
489
    
 
490
    takes_args = ['file*']
 
491
    takes_options = ['revision']
 
492
    aliases = ['di']
 
493
 
 
494
    def run(self, revision=None, file_list=None):
 
495
        from bzrlib.diff import show_diff
 
496
    
 
497
        show_diff(Branch('.'), revision, specific_files=file_list)
 
498
 
 
499
 
 
500
        
 
501
 
 
502
 
 
503
class cmd_deleted(Command):
 
504
    """List files deleted in the working tree.
 
505
 
 
506
    TODO: Show files deleted since a previous revision, or between two revisions.
 
507
    """
 
508
    def run(self, show_ids=False):
 
509
        b = Branch('.')
 
510
        old = b.basis_tree()
 
511
        new = b.working_tree()
 
512
 
 
513
        ## TODO: Much more efficient way to do this: read in new
 
514
        ## directories with readdir, rather than stating each one.  Same
 
515
        ## level of effort but possibly much less IO.  (Or possibly not,
 
516
        ## if the directories are very large...)
 
517
 
 
518
        for path, ie in old.inventory.iter_entries():
 
519
            if not new.has_id(ie.file_id):
 
520
                if show_ids:
 
521
                    print '%-50s %s' % (path, ie.file_id)
 
522
                else:
 
523
                    print path
 
524
 
 
525
 
 
526
class cmd_modified(Command):
 
527
    """List files modified in working tree."""
 
528
    hidden = True
 
529
    def run(self):
 
530
        import statcache
 
531
        b = Branch('.')
 
532
        inv = b.read_working_inventory()
 
533
        sc = statcache.update_cache(b, inv)
 
534
        basis = b.basis_tree()
 
535
        basis_inv = basis.inventory
 
536
        
 
537
        # We used to do this through iter_entries(), but that's slow
 
538
        # when most of the files are unmodified, as is usually the
 
539
        # case.  So instead we iterate by inventory entry, and only
 
540
        # calculate paths as necessary.
 
541
 
 
542
        for file_id in basis_inv:
 
543
            cacheentry = sc.get(file_id)
 
544
            if not cacheentry:                 # deleted
 
545
                continue
 
546
            ie = basis_inv[file_id]
 
547
            if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
 
548
                path = inv.id2path(file_id)
 
549
                print path
 
550
 
 
551
 
 
552
 
 
553
class cmd_added(Command):
 
554
    """List files added in working tree."""
 
555
    hidden = True
 
556
    def run(self):
 
557
        b = Branch('.')
 
558
        wt = b.working_tree()
 
559
        basis_inv = b.basis_tree().inventory
 
560
        inv = wt.inventory
 
561
        for file_id in inv:
 
562
            if file_id in basis_inv:
 
563
                continue
 
564
            path = inv.id2path(file_id)
 
565
            if not os.access(b.abspath(path), os.F_OK):
 
566
                continue
 
567
            print path
 
568
                
 
569
        
 
570
 
 
571
class cmd_root(Command):
 
572
    """Show the tree root directory.
 
573
 
 
574
    The root is the nearest enclosing directory with a .bzr control
 
575
    directory."""
 
576
    takes_args = ['filename?']
 
577
    def run(self, filename=None):
 
578
        """Print the branch root."""
 
579
        from branch import find_branch
 
580
        b = find_branch(filename)
 
581
        print getattr(b, 'base', None) or getattr(b, 'baseurl')
 
582
 
 
583
 
 
584
class cmd_log(Command):
 
585
    """Show log of this branch.
 
586
 
 
587
    TODO: Option to limit range.
 
588
 
 
589
    TODO: Perhaps show most-recent first with an option for last.
 
590
    """
 
591
    takes_args = ['filename?']
 
592
    takes_options = ['timezone', 'verbose', 'show-ids']
 
593
    def run(self, filename=None, timezone='original', verbose=False, show_ids=False):
 
594
        from branch import find_branch
 
595
        b = find_branch((filename or '.'), lock_mode='r')
 
596
        if filename:
 
597
            filename = b.relpath(filename)
 
598
        bzrlib.show_log(b, filename,
 
599
                        show_timezone=timezone,
 
600
                        verbose=verbose,
 
601
                        show_ids=show_ids)
 
602
 
 
603
 
 
604
 
 
605
class cmd_touching_revisions(Command):
 
606
    """Return revision-ids which affected a particular file."""
 
607
    hidden = True
 
608
    takes_args = ["filename"]
 
609
    def run(self, filename):
 
610
        b = Branch(filename, lock_mode='r')
 
611
        inv = b.read_working_inventory()
 
612
        file_id = inv.path2id(b.relpath(filename))
 
613
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
 
614
            print "%6d %s" % (revno, what)
 
615
 
 
616
 
 
617
class cmd_ls(Command):
 
618
    """List files in a tree.
 
619
 
 
620
    TODO: Take a revision or remote path and list that tree instead.
 
621
    """
 
622
    hidden = True
 
623
    def run(self, revision=None, verbose=False):
 
624
        b = Branch('.')
 
625
        if revision == None:
 
626
            tree = b.working_tree()
 
627
        else:
 
628
            tree = b.revision_tree(b.lookup_revision(revision))
 
629
 
 
630
        for fp, fc, kind, fid in tree.list_files():
 
631
            if verbose:
 
632
                if kind == 'directory':
 
633
                    kindch = '/'
 
634
                elif kind == 'file':
 
635
                    kindch = ''
 
636
                else:
 
637
                    kindch = '???'
 
638
 
 
639
                print '%-8s %s%s' % (fc, fp, kindch)
 
640
            else:
 
641
                print fp
 
642
 
 
643
 
 
644
 
 
645
class cmd_unknowns(Command):
 
646
    """List unknown files"""
 
647
    def run(self):
 
648
        for f in Branch('.').unknowns():
 
649
            print quotefn(f)
 
650
 
 
651
 
 
652
 
 
653
class cmd_ignore(Command):
 
654
    """Ignore a command or pattern
 
655
 
 
656
    To remove patterns from the ignore list, edit the .bzrignore file.
 
657
 
 
658
    If the pattern contains a slash, it is compared to the whole path
 
659
    from the branch root.  Otherwise, it is comapred to only the last
 
660
    component of the path.
 
661
 
 
662
    Ignore patterns are case-insensitive on case-insensitive systems.
 
663
 
 
664
    Note: wildcards must be quoted from the shell on Unix.
 
665
 
 
666
    examples:
 
667
        bzr ignore ./Makefile
 
668
        bzr ignore '*.class'
 
669
    """
 
670
    takes_args = ['name_pattern']
 
671
    
 
672
    def run(self, name_pattern):
 
673
        from bzrlib.atomicfile import AtomicFile
 
674
        import codecs
 
675
 
 
676
        b = Branch('.')
 
677
        ifn = b.abspath('.bzrignore')
 
678
 
 
679
        # FIXME: probably doesn't handle non-ascii patterns
 
680
 
 
681
        if os.path.exists(ifn):
 
682
            f = b.controlfile(ifn, 'rt')
 
683
            igns = f.read()
 
684
            f.close()
 
685
        else:
 
686
            igns = ''
 
687
 
 
688
        if igns and igns[-1] != '\n':
 
689
            igns += '\n'
 
690
        igns += name_pattern + '\n'
 
691
 
 
692
        f = AtomicFile(ifn, 'wt')
 
693
        f.write(igns)
 
694
        f.commit()
 
695
 
 
696
        inv = b.working_tree().inventory
 
697
        if inv.path2id('.bzrignore'):
 
698
            mutter('.bzrignore is already versioned')
 
699
        else:
 
700
            mutter('need to make new .bzrignore file versioned')
 
701
            b.add(['.bzrignore'])
 
702
 
 
703
 
 
704
 
 
705
class cmd_ignored(Command):
 
706
    """List ignored files and the patterns that matched them.
 
707
 
 
708
    See also: bzr ignore"""
 
709
    def run(self):
 
710
        tree = Branch('.').working_tree()
 
711
        for path, file_class, kind, file_id in tree.list_files():
 
712
            if file_class != 'I':
 
713
                continue
 
714
            ## XXX: Slightly inefficient since this was already calculated
 
715
            pat = tree.is_ignored(path)
 
716
            print '%-50s %s' % (path, pat)
 
717
 
 
718
 
 
719
class cmd_lookup_revision(Command):
 
720
    """Lookup the revision-id from a revision-number
 
721
 
 
722
    example:
 
723
        bzr lookup-revision 33
 
724
    """
 
725
    hidden = True
 
726
    takes_args = ['revno']
 
727
    
 
728
    def run(self, revno):
 
729
        try:
 
730
            revno = int(revno)
 
731
        except ValueError:
 
732
            raise BzrCommandError("not a valid revision-number: %r" % revno)
 
733
 
 
734
        print Branch('.').lookup_revision(revno)
 
735
 
 
736
 
 
737
class cmd_export(Command):
 
738
    """Export past revision to destination directory.
 
739
 
 
740
    If no revision is specified this exports the last committed revision."""
 
741
    takes_args = ['dest']
 
742
    takes_options = ['revision']
 
743
    def run(self, dest, revision=None):
 
744
        b = Branch('.')
 
745
        if revision == None:
 
746
            rh = b.revision_history()[-1]
 
747
        else:
 
748
            rh = b.lookup_revision(int(revision))
 
749
        t = b.revision_tree(rh)
 
750
        t.export(dest)
 
751
 
 
752
 
 
753
class cmd_cat(Command):
 
754
    """Write a file's text from a previous revision."""
 
755
 
 
756
    takes_options = ['revision']
 
757
    takes_args = ['filename']
 
758
 
 
759
    def run(self, filename, revision=None):
 
760
        if revision == None:
 
761
            raise BzrCommandError("bzr cat requires a revision number")
 
762
        b = Branch('.')
 
763
        b.print_file(b.relpath(filename), int(revision))
 
764
 
 
765
 
 
766
class cmd_local_time_offset(Command):
 
767
    """Show the offset in seconds from GMT to local time."""
 
768
    hidden = True    
 
769
    def run(self):
 
770
        print bzrlib.osutils.local_time_offset()
 
771
 
 
772
 
 
773
 
 
774
class cmd_commit(Command):
 
775
    """Commit changes into a new revision.
 
776
 
 
777
    TODO: Commit only selected files.
 
778
 
 
779
    TODO: Run hooks on tree to-be-committed, and after commit.
 
780
 
 
781
    TODO: Strict commit that fails if there are unknown or deleted files.
 
782
    """
 
783
    takes_options = ['message', 'file', 'verbose']
 
784
    aliases = ['ci', 'checkin']
 
785
 
 
786
    def run(self, message=None, file=None, verbose=False):
 
787
        from bzrlib.commit import commit
 
788
 
 
789
        ## Warning: shadows builtin file()
 
790
        if not message and not file:
 
791
            raise BzrCommandError("please specify a commit message",
 
792
                                  ["use either --message or --file"])
 
793
        elif message and file:
 
794
            raise BzrCommandError("please specify either --message or --file")
 
795
        
 
796
        if file:
 
797
            import codecs
 
798
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
 
799
 
 
800
        b = Branch('.')
 
801
        commit(b, message, verbose=verbose)
 
802
 
 
803
 
 
804
class cmd_check(Command):
 
805
    """Validate consistency of branch history.
 
806
 
 
807
    This command checks various invariants about the branch storage to
 
808
    detect data corruption or bzr bugs.
 
809
    """
 
810
    takes_args = ['dir?']
 
811
    def run(self, dir='.'):
 
812
        import bzrlib.check
 
813
        bzrlib.check.check(Branch(dir, find_root=False))
 
814
 
 
815
 
 
816
 
 
817
class cmd_whoami(Command):
 
818
    """Show bzr user id."""
 
819
    takes_options = ['email']
 
820
    
 
821
    def run(self, email=False):
 
822
        if email:
 
823
            print bzrlib.osutils.user_email()
 
824
        else:
 
825
            print bzrlib.osutils.username()
 
826
 
 
827
 
 
828
class cmd_selftest(Command):
 
829
    """Run internal test suite"""
 
830
    hidden = True
 
831
    def run(self):
 
832
        failures, tests = 0, 0
 
833
 
 
834
        import doctest, bzrlib.store, bzrlib.tests
 
835
        bzrlib.trace.verbose = False
 
836
 
 
837
        for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
 
838
            bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
 
839
            mf, mt = doctest.testmod(m)
 
840
            failures += mf
 
841
            tests += mt
 
842
            print '%-40s %3d tests' % (m.__name__, mt),
 
843
            if mf:
 
844
                print '%3d FAILED!' % mf
 
845
            else:
 
846
                print
 
847
 
 
848
        print '%-40s %3d tests' % ('total', tests),
 
849
        if failures:
 
850
            print '%3d FAILED!' % failures
 
851
        else:
 
852
            print
 
853
 
 
854
 
 
855
 
 
856
class cmd_version(Command):
 
857
    """Show version of bzr"""
 
858
    def run(self):
 
859
        show_version()
 
860
 
 
861
def show_version():
 
862
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
863
    print bzrlib.__copyright__
 
864
    print "http://bazaar-ng.org/"
 
865
    print
 
866
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
 
867
    print "you may use, modify and redistribute it under the terms of the GNU"
 
868
    print "General Public License version 2 or later."
 
869
 
 
870
 
 
871
class cmd_rocks(Command):
 
872
    """Statement of optimism."""
 
873
    hidden = True
 
874
    def run(self):
 
875
        print "it sure does!"
 
876
 
 
877
 
 
878
class cmd_assert_fail(Command):
 
879
    """Test reporting of assertion failures"""
 
880
    hidden = True
 
881
    def run(self):
 
882
        assert False, "always fails"
 
883
 
 
884
 
 
885
class cmd_help(Command):
 
886
    """Show help on a command or other topic.
 
887
 
 
888
    For a list of all available commands, say 'bzr help commands'."""
 
889
    takes_args = ['topic?']
 
890
    aliases = ['?']
 
891
    
 
892
    def run(self, topic=None):
 
893
        import help
 
894
        help.help(topic)
 
895
 
 
896
 
 
897
class cmd_update_stat_cache(Command):
 
898
    """Update stat-cache mapping inodes to SHA-1 hashes.
 
899
 
 
900
    For testing only."""
 
901
    hidden = True
 
902
    def run(self):
 
903
        import statcache
 
904
        b = Branch('.')
 
905
        statcache.update_cache(b.base, b.read_working_inventory())
 
906
 
 
907
 
 
908
######################################################################
 
909
# main routine
 
910
 
 
911
 
 
912
# list of all available options; the rhs can be either None for an
 
913
# option that takes no argument, or a constructor function that checks
 
914
# the type.
 
915
OPTIONS = {
 
916
    'all':                    None,
 
917
    'help':                   None,
 
918
    'file':                   unicode,
 
919
    'message':                unicode,
 
920
    'profile':                None,
 
921
    'revision':               int,
 
922
    'show-ids':               None,
 
923
    'timezone':               str,
 
924
    'verbose':                None,
 
925
    'version':                None,
 
926
    'email':                  None,
 
927
    }
 
928
 
 
929
SHORT_OPTIONS = {
 
930
    'm':                      'message',
 
931
    'F':                      'file', 
 
932
    'r':                      'revision',
 
933
    'v':                      'verbose',
 
934
}
 
935
 
 
936
 
 
937
def parse_args(argv):
368
938
    """Parse command line.
369
939
    
370
940
    Arguments and options are parsed at this level before being passed
371
941
    down to specific command handlers.  This routine knows, from a
372
942
    lookup table, something about the available options, what optargs
373
943
    they take, and which commands will accept them.
 
944
 
 
945
    >>> parse_args('--help'.split())
 
946
    ([], {'help': True})
 
947
    >>> parse_args('--version'.split())
 
948
    ([], {'version': True})
 
949
    >>> parse_args('status --all'.split())
 
950
    (['status'], {'all': True})
 
951
    >>> parse_args('commit --message=biter'.split())
 
952
    (['commit'], {'message': u'biter'})
374
953
    """
375
 
    # TODO: make it a method of the Command?
376
 
    parser = option.get_optparser(command.options())
377
 
    if alias_argv is not None:
378
 
        args = alias_argv + argv
379
 
    else:
380
 
        args = argv
381
 
 
382
 
    options, args = parser.parse_args(args)
383
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
384
 
                 v is not option.OptionParser.DEFAULT_VALUE])
 
954
    args = []
 
955
    opts = {}
 
956
 
 
957
    # TODO: Maybe handle '--' to end options?
 
958
 
 
959
    while argv:
 
960
        a = argv.pop(0)
 
961
        if a[0] == '-':
 
962
            # option names must not be unicode
 
963
            a = str(a)
 
964
            optarg = None
 
965
            if a[1] == '-':
 
966
                mutter("  got option %r" % a)
 
967
                if '=' in a:
 
968
                    optname, optarg = a[2:].split('=', 1)
 
969
                else:
 
970
                    optname = a[2:]
 
971
                if optname not in OPTIONS:
 
972
                    bailout('unknown long option %r' % a)
 
973
            else:
 
974
                shortopt = a[1:]
 
975
                if shortopt not in SHORT_OPTIONS:
 
976
                    bailout('unknown short option %r' % a)
 
977
                optname = SHORT_OPTIONS[shortopt]
 
978
            
 
979
            if optname in opts:
 
980
                # XXX: Do we ever want to support this, e.g. for -r?
 
981
                bailout('repeated option %r' % a)
 
982
                
 
983
            optargfn = OPTIONS[optname]
 
984
            if optargfn:
 
985
                if optarg == None:
 
986
                    if not argv:
 
987
                        bailout('option %r needs an argument' % a)
 
988
                    else:
 
989
                        optarg = argv.pop(0)
 
990
                opts[optname] = optargfn(optarg)
 
991
            else:
 
992
                if optarg != None:
 
993
                    bailout('option %r takes no argument' % optname)
 
994
                opts[optname] = True
 
995
        else:
 
996
            args.append(a)
 
997
 
385
998
    return args, opts
386
999
 
387
1000
 
 
1001
 
 
1002
 
388
1003
def _match_argform(cmd, takes_args, args):
389
1004
    argdict = {}
390
1005
 
402
1017
                argdict[argname + '_list'] = None
403
1018
        elif ap[-1] == '+':
404
1019
            if not args:
405
 
                raise errors.BzrCommandError("command %r needs one or more %s"
406
 
                                             % (cmd, argname.upper()))
 
1020
                raise BzrCommandError("command %r needs one or more %s"
 
1021
                        % (cmd, argname.upper()))
407
1022
            else:
408
1023
                argdict[argname + '_list'] = args[:]
409
1024
                args = []
410
1025
        elif ap[-1] == '$': # all but one
411
1026
            if len(args) < 2:
412
 
                raise errors.BzrCommandError("command %r needs one or more %s"
413
 
                                             % (cmd, argname.upper()))
 
1027
                raise BzrCommandError("command %r needs one or more %s"
 
1028
                        % (cmd, argname.upper()))
414
1029
            argdict[argname + '_list'] = args[:-1]
415
 
            args[:-1] = []
 
1030
            args[:-1] = []                
416
1031
        else:
417
1032
            # just a plain arg
418
1033
            argname = ap
419
1034
            if not args:
420
 
                raise errors.BzrCommandError("command %r requires argument %s"
421
 
                               % (cmd, argname.upper()))
 
1035
                raise BzrCommandError("command %r requires argument %s"
 
1036
                        % (cmd, argname.upper()))
422
1037
            else:
423
1038
                argdict[argname] = args.pop(0)
424
1039
            
425
1040
    if args:
426
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
427
 
                                     % (cmd, args[0]))
 
1041
        raise BzrCommandError("extra argument to command %s: %s"
 
1042
                              % (cmd, args[0]))
428
1043
 
429
1044
    return argdict
430
1045
 
431
1046
 
432
1047
 
433
 
def apply_profiled(the_callable, *args, **kwargs):
434
 
    import hotshot
435
 
    import tempfile
436
 
    import hotshot.stats
437
 
    pffileno, pfname = tempfile.mkstemp()
438
 
    try:
439
 
        prof = hotshot.Profile(pfname)
440
 
        try:
441
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
442
 
        finally:
443
 
            prof.close()
444
 
        stats = hotshot.stats.load(pfname)
445
 
        stats.strip_dirs()
446
 
        stats.sort_stats('cum')   # 'time'
447
 
        ## XXX: Might like to write to stderr or the trace file instead but
448
 
        ## print_stats seems hardcoded to stdout
449
 
        stats.print_stats(20)
450
 
        return ret
451
 
    finally:
452
 
        os.close(pffileno)
453
 
        os.remove(pfname)
454
 
 
455
 
 
456
 
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
457
 
    from bzrlib.lsprof import profile
458
 
    import cPickle
459
 
    ret, stats = profile(the_callable, *args, **kwargs)
460
 
    stats.sort()
461
 
    if filename is None:
462
 
        stats.pprint()
463
 
    else:
464
 
        stats.freeze()
465
 
        cPickle.dump(stats, open(filename, 'w'), 2)
466
 
        print 'Profile data written to %r.' % filename
467
 
    return ret
468
 
 
469
 
 
470
 
def get_alias(cmd, config=None):
471
 
    """Return an expanded alias, or None if no alias exists.
472
 
 
473
 
    cmd
474
 
        Command to be checked for an alias.
475
 
    config
476
 
        Used to specify an alternative config to use,
477
 
        which is especially useful for testing.
478
 
        If it is unspecified, the global config will be used.
479
 
    """
480
 
    if config is None:
481
 
        import bzrlib.config
482
 
        config = bzrlib.config.GlobalConfig()
483
 
    alias = config.get_alias(cmd)
484
 
    if (alias):
485
 
        import shlex
486
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
487
 
    return None
488
 
 
489
 
 
490
1048
def run_bzr(argv):
491
1049
    """Execute a command.
492
1050
 
493
1051
    This is similar to main(), but without all the trappings for
494
1052
    logging and error handling.  
495
 
    
496
 
    argv
497
 
       The command-line arguments, without the program name from argv[0]
498
 
       These should already be decoded. All library/test code calling
499
 
       run_bzr should be passing valid strings (don't need decoding).
500
 
    
501
 
    Returns a command status or raises an exception.
502
 
 
503
 
    Special master options: these must come before the command because
504
 
    they control how the command is interpreted.
505
 
 
506
 
    --no-plugins
507
 
        Do not load plugin modules at all
508
 
 
509
 
    --no-aliases
510
 
        Do not allow aliases
511
 
 
512
 
    --builtin
513
 
        Only use builtin commands.  (Plugins are still allowed to change
514
 
        other behaviour.)
515
 
 
516
 
    --profile
517
 
        Run under the Python hotshot profiler.
518
 
 
519
 
    --lsprof
520
 
        Run under the Python lsprof profiler.
521
1053
    """
522
 
    argv = list(argv)
523
 
    trace.mutter("bzr arguments: %r", argv)
524
 
 
525
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
526
 
                opt_no_aliases = False
527
 
    opt_lsprof_file = None
528
 
 
529
 
    # --no-plugins is handled specially at a very early stage. We need
530
 
    # to load plugins before doing other command parsing so that they
531
 
    # can override commands, but this needs to happen first.
532
 
 
533
 
    argv_copy = []
534
 
    i = 0
535
 
    while i < len(argv):
536
 
        a = argv[i]
537
 
        if a == '--profile':
538
 
            opt_profile = True
539
 
        elif a == '--lsprof':
540
 
            opt_lsprof = True
541
 
        elif a == '--lsprof-file':
542
 
            opt_lsprof = True
543
 
            opt_lsprof_file = argv[i + 1]
544
 
            i += 1
545
 
        elif a == '--no-plugins':
546
 
            opt_no_plugins = True
547
 
        elif a == '--no-aliases':
548
 
            opt_no_aliases = True
549
 
        elif a == '--builtin':
550
 
            opt_builtin = True
551
 
        elif a in ('--quiet', '-q'):
552
 
            trace.be_quiet()
553
 
        elif a.startswith('-D'):
554
 
            debug.debug_flags.add(a[2:])
555
 
        else:
556
 
            argv_copy.append(a)
557
 
        i += 1
558
 
 
559
 
    argv = argv_copy
560
 
    if (not argv):
561
 
        from bzrlib.builtins import cmd_help
562
 
        cmd_help().run_argv_aliases([])
563
 
        return 0
564
 
 
565
 
    if argv[0] == '--version':
566
 
        from bzrlib.version import show_version
567
 
        show_version()
568
 
        return 0
569
 
        
570
 
    if not opt_no_plugins:
571
 
        from bzrlib.plugin import load_plugins
572
 
        load_plugins()
573
 
    else:
574
 
        from bzrlib.plugin import disable_plugins
575
 
        disable_plugins()
576
 
 
577
 
    alias_argv = None
578
 
 
579
 
    if not opt_no_aliases:
580
 
        alias_argv = get_alias(argv[0])
581
 
        if alias_argv:
582
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
583
 
            argv[0] = alias_argv.pop(0)
584
 
 
585
 
    cmd = argv.pop(0)
586
 
    # We want only 'ascii' command names, but the user may have typed
587
 
    # in a Unicode name. In that case, they should just get a
588
 
    # 'command not found' error later.
589
 
 
590
 
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
591
 
    run = cmd_obj.run_argv_aliases
592
 
    run_argv = [argv, alias_argv]
593
 
 
 
1054
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
1055
    
594
1056
    try:
595
 
        if opt_lsprof:
596
 
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
597
 
        elif opt_profile:
598
 
            ret = apply_profiled(run, *run_argv)
599
 
        else:
600
 
            ret = run(*run_argv)
601
 
        return ret or 0
602
 
    finally:
603
 
        # reset, in case we may do other commands later within the same process
604
 
        trace.be_quiet(False)
605
 
 
606
 
def display_command(func):
607
 
    """Decorator that suppresses pipe/interrupt errors."""
608
 
    def ignore_pipe(*args, **kwargs):
 
1057
        args, opts = parse_args(argv[1:])
 
1058
        if 'help' in opts:
 
1059
            import help
 
1060
            if args:
 
1061
                help.help(args[0])
 
1062
            else:
 
1063
                help.help()
 
1064
            return 0
 
1065
        elif 'version' in opts:
 
1066
            show_version()
 
1067
            return 0
 
1068
        cmd = str(args.pop(0))
 
1069
    except IndexError:
 
1070
        import help
 
1071
        help.help()
 
1072
        return 1
 
1073
          
 
1074
 
 
1075
    canonical_cmd, cmd_class = get_cmd_class(cmd)
 
1076
 
 
1077
    # global option
 
1078
    if 'profile' in opts:
 
1079
        profile = True
 
1080
        del opts['profile']
 
1081
    else:
 
1082
        profile = False
 
1083
 
 
1084
    # check options are reasonable
 
1085
    allowed = cmd_class.takes_options
 
1086
    for oname in opts:
 
1087
        if oname not in allowed:
 
1088
            raise BzrCommandError("option '--%s' is not allowed for command %r"
 
1089
                                  % (oname, cmd))
 
1090
 
 
1091
    # mix arguments and options into one dictionary
 
1092
    cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
 
1093
    cmdopts = {}
 
1094
    for k, v in opts.items():
 
1095
        cmdopts[k.replace('-', '_')] = v
 
1096
 
 
1097
    if profile:
 
1098
        import hotshot, tempfile
 
1099
        pffileno, pfname = tempfile.mkstemp()
609
1100
        try:
610
 
            result = func(*args, **kwargs)
611
 
            sys.stdout.flush()
612
 
            return result
613
 
        except IOError, e:
614
 
            if getattr(e, 'errno', None) is None:
615
 
                raise
616
 
            if e.errno != errno.EPIPE:
617
 
                # Win32 raises IOError with errno=0 on a broken pipe
618
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
619
 
                    raise
620
 
            pass
621
 
        except KeyboardInterrupt:
622
 
            pass
623
 
    return ignore_pipe
 
1101
            prof = hotshot.Profile(pfname)
 
1102
            ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
 
1103
            prof.close()
 
1104
 
 
1105
            import hotshot.stats
 
1106
            stats = hotshot.stats.load(pfname)
 
1107
            #stats.strip_dirs()
 
1108
            stats.sort_stats('time')
 
1109
            ## XXX: Might like to write to stderr or the trace file instead but
 
1110
            ## print_stats seems hardcoded to stdout
 
1111
            stats.print_stats(20)
 
1112
            
 
1113
            return ret.status
 
1114
 
 
1115
        finally:
 
1116
            os.close(pffileno)
 
1117
            os.remove(pfname)
 
1118
    else:
 
1119
        cmdobj = cmd_class(cmdopts, cmdargs).status 
 
1120
 
 
1121
 
 
1122
def _report_exception(summary, quiet=False):
 
1123
    import traceback
 
1124
    log_error('bzr: ' + summary)
 
1125
    bzrlib.trace.log_exception()
 
1126
 
 
1127
    if not quiet:
 
1128
        tb = sys.exc_info()[2]
 
1129
        exinfo = traceback.extract_tb(tb)
 
1130
        if exinfo:
 
1131
            sys.stderr.write('  at %s:%d in %s()\n' % exinfo[-1][:3])
 
1132
        sys.stderr.write('  see ~/.bzr.log for debug information\n')
 
1133
 
624
1134
 
625
1135
 
626
1136
def main(argv):
627
 
    import bzrlib.ui
628
 
    from bzrlib.ui.text import TextUIFactory
629
 
    bzrlib.ui.ui_factory = TextUIFactory()
630
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
631
 
    ret = run_bzr_catch_errors(argv)
632
 
    trace.mutter("return code %d", ret)
633
 
    return ret
634
 
 
635
 
 
636
 
def run_bzr_catch_errors(argv):
 
1137
    import errno
 
1138
    
 
1139
    bzrlib.open_tracefile(argv)
 
1140
 
637
1141
    try:
638
 
        return run_bzr(argv)
639
 
        # do this here inside the exception wrappers to catch EPIPE
640
 
        sys.stdout.flush()
641
 
    except (KeyboardInterrupt, Exception), e:
642
 
        # used to handle AssertionError and KeyboardInterrupt
643
 
        # specially here, but hopefully they're handled ok by the logger now
644
 
        trace.report_exception(sys.exc_info(), sys.stderr)
645
 
        if os.environ.get('BZR_PDB'):
646
 
            print '**** entering debugger'
647
 
            import pdb
648
 
            pdb.post_mortem(sys.exc_traceback)
649
 
        return 3
 
1142
        try:
 
1143
            try:
 
1144
                return run_bzr(argv)
 
1145
            finally:
 
1146
                # do this here inside the exception wrappers to catch EPIPE
 
1147
                sys.stdout.flush()
 
1148
        except BzrError, e:
 
1149
            quiet = isinstance(e, (BzrCommandError))
 
1150
            _report_exception('error: ' + e.args[0], quiet=quiet)
 
1151
            if len(e.args) > 1:
 
1152
                for h in e.args[1]:
 
1153
                    # some explanation or hints
 
1154
                    log_error('  ' + h)
 
1155
            return 1
 
1156
        except AssertionError, e:
 
1157
            msg = 'assertion failed'
 
1158
            if str(e):
 
1159
                msg += ': ' + str(e)
 
1160
            _report_exception(msg)
 
1161
            return 2
 
1162
        except KeyboardInterrupt, e:
 
1163
            _report_exception('interrupted', quiet=True)
 
1164
            return 2
 
1165
        except Exception, e:
 
1166
            quiet = False
 
1167
            if (isinstance(e, IOError) 
 
1168
                and hasattr(e, 'errno')
 
1169
                and e.errno == errno.EPIPE):
 
1170
                quiet = True
 
1171
                msg = 'broken pipe'
 
1172
            else:
 
1173
                msg = str(e).rstrip('\n')
 
1174
            _report_exception(msg, quiet)
 
1175
            return 2
 
1176
    finally:
 
1177
        bzrlib.trace.close_trace()
 
1178
 
650
1179
 
651
1180
if __name__ == '__main__':
652
1181
    sys.exit(main(sys.argv))