← 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 08:12:31 UTC
  • Revision ID: mbp@sourcefrog.net-20050622081231-630e514240ccb87a
- new exception NotVersionedError
- raise this from Inventory.add_path if parent isnt versioned

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
 
    errors,
43
 
    option,
44
 
    osutils,
45
 
    trace,
46
 
    )
47
 
""")
48
 
 
49
 
from bzrlib.symbol_versioning import (
50
 
    deprecated_function,
51
 
    deprecated_method,
52
 
    zero_eight,
53
 
    zero_eleven,
54
 
    )
55
 
# Compatibility
56
 
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
57
27
 
58
28
 
59
29
plugin_cmds = {}
60
30
 
61
31
 
62
 
def register_command(cmd, decorate=False):
63
 
    """Utility function to help register a command
64
 
 
65
 
    :param cmd: Command subclass to register
66
 
    :param decorate: If true, allow overriding an existing command
67
 
        of the same name; the old command is returned by this function.
68
 
        Otherwise it is an error to try to override an existing command.
69
 
    """
 
32
def register_plugin_command(cmd):
 
33
    "Utility function to help register a command"
70
34
    global plugin_cmds
71
35
    k = cmd.__name__
72
36
    if k.startswith("cmd_"):
73
37
        k_unsquished = _unsquish_command_name(k)
74
38
    else:
75
39
        k_unsquished = k
76
 
    if k_unsquished not in plugin_cmds:
77
 
        plugin_cmds[k_unsquished] = cmd
78
 
        trace.mutter('registered plugin command %s', k_unsquished)
79
 
        if decorate and k_unsquished in builtin_command_names():
80
 
            return _builtin_commands()[k_unsquished]
81
 
    elif decorate:
82
 
        result = plugin_cmds[k_unsquished]
83
 
        plugin_cmds[k_unsquished] = cmd
84
 
        return result
 
40
    if not plugin_cmds.has_key(k_unsquished):
 
41
        plugin_cmds[k_unsquished] = cmd
85
42
    else:
86
 
        trace.log_error('Two plugins defined the same command: %r' % k)
87
 
        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__])
88
45
 
89
46
 
90
47
def _squish_command_name(cmd):
95
52
    assert cmd.startswith("cmd_")
96
53
    return cmd[4:].replace('_','-')
97
54
 
98
 
 
99
 
def _builtin_commands():
100
 
    import bzrlib.builtins
101
 
    r = {}
102
 
    builtins = bzrlib.builtins.__dict__
103
 
    for name in builtins:
104
 
        if name.startswith("cmd_"):
105
 
            real_name = _unsquish_command_name(name)
106
 
            r[real_name] = builtins[name]
107
 
    return r
108
 
            
109
 
 
110
 
def builtin_command_names():
111
 
    """Return list of builtin command names."""
112
 
    return _builtin_commands().keys()
113
 
    
114
 
 
115
 
def plugin_command_names():
116
 
    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
 
117
89
 
118
90
 
119
91
def _get_cmd_dict(plugins_override=True):
120
 
    """Return name->class mapping for all commands."""
121
 
    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
122
97
    if plugins_override:
123
98
        d.update(plugin_cmds)
 
99
    else:
 
100
        d2 = plugin_cmds.copy()
 
101
        d2.update(d)
 
102
        d = d2
124
103
    return d
125
104
 
126
105
    
130
109
        yield k,v
131
110
 
132
111
 
133
 
def get_cmd_object(cmd_name, plugins_override=True):
 
112
def get_cmd_class(cmd, plugins_override=True):
134
113
    """Return the canonical name and command class for a command.
135
 
 
136
 
    plugins_override
137
 
        If true, plugin commands can override builtins.
138
114
    """
139
 
    from bzrlib.externalcommand import ExternalCommand
140
 
 
141
 
    # We want only 'ascii' command names, but the user may have typed
142
 
    # in a Unicode name. In that case, they should just get a
143
 
    # 'command not found' error later.
144
 
    # In the future, we may actually support Unicode command names.
 
115
    cmd = str(cmd)                      # not unicode
145
116
 
146
117
    # first look up this command under the specified name
147
118
    cmds = _get_cmd_dict(plugins_override=plugins_override)
148
119
    try:
149
 
        return cmds[cmd_name]()
 
120
        return cmd, cmds[cmd]
150
121
    except KeyError:
151
122
        pass
152
123
 
153
124
    # look for any command which claims this as an alias
154
 
    for real_cmd_name, cmd_class in cmds.iteritems():
155
 
        if cmd_name in cmd_class.aliases:
156
 
            return cmd_class()
157
 
 
158
 
    cmd_obj = ExternalCommand.find_command(cmd_name)
159
 
    if cmd_obj:
160
 
        return cmd_obj
161
 
 
162
 
    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)
163
134
 
164
135
 
165
136
class Command(object):
166
137
    """Base class for commands.
167
138
 
168
 
    Commands are the heart of the command-line bzr interface.
169
 
 
170
 
    The command object mostly handles the mapping of command-line
171
 
    parameters into one or more bzrlib operations, and of the results
172
 
    into textual output.
173
 
 
174
 
    Commands normally don't have any state.  All their arguments are
175
 
    passed in to the run method.  (Subclasses may take a different
176
 
    policy if the behaviour of the instance needs to depend on e.g. a
177
 
    shell plugin and not just its Python class.)
178
 
 
179
139
    The docstring for an actual command should give a single-line
180
140
    summary, then a complete description of the command.  A grammar
181
141
    description will be inserted.
182
142
 
183
 
    aliases
184
 
        Other accepted names for this command.
185
 
 
186
143
    takes_args
187
144
        List of argument forms, marked with whether they are optional,
188
145
        repeated, etc.
189
146
 
190
 
                Examples:
191
 
 
192
 
                ['to_location', 'from_branch?', 'file*']
193
 
 
194
 
                'to_location' is required
195
 
                'from_branch' is optional
196
 
                'file' can be specified 0 or more times
197
 
 
198
147
    takes_options
199
 
        List of options that may be given for this command.  These can
200
 
        be either strings, referring to globally-defined options,
201
 
        or option objects.  Retrieve through options().
 
148
        List of options that may be given for this command.
202
149
 
203
150
    hidden
204
 
        If true, this command isn't advertised.  This is typically
205
 
        for commands intended for expert users.
206
 
 
207
 
    encoding_type
208
 
        Command objects will get a 'outf' attribute, which has been
209
 
        setup to properly handle encoding of unicode strings.
210
 
        encoding_type determines what will happen when characters cannot
211
 
        be encoded
212
 
            strict - abort if we cannot decode
213
 
            replace - put in a bogus character (typically '?')
214
 
            exact - do not encode sys.stdout
215
 
 
 
151
        If true, this command isn't advertised.
216
152
    """
217
153
    aliases = []
 
154
    
218
155
    takes_args = []
219
156
    takes_options = []
220
 
    encoding_type = 'strict'
221
157
 
222
158
    hidden = False
223
159
    
224
 
    def __init__(self):
225
 
        """Construct an instance of this command."""
226
 
        if self.__doc__ == Command.__doc__:
227
 
            warn("No help message set for %r" % self)
228
 
 
229
 
    def options(self):
230
 
        """Return dict of valid options for this command.
231
 
 
232
 
        Maps from long option name to option object."""
233
 
        r = dict()
234
 
        r['help'] = option.Option.OPTIONS['help']
235
 
        for o in self.takes_options:
236
 
            if isinstance(o, basestring):
237
 
                o = option.Option.OPTIONS[o]
238
 
            r[o.name] = o
239
 
        return r
240
 
 
241
 
    def _setup_outf(self):
242
 
        """Return a file linked to stdout, which has proper encoding."""
243
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
244
 
 
245
 
        # Originally I was using self.stdout, but that looks
246
 
        # *way* too much like sys.stdout
247
 
        if self.encoding_type == 'exact':
248
 
            self.outf = sys.stdout
249
 
            return
250
 
 
251
 
        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)
252
858
 
253
859
        # use 'replace' so that we don't abort if trying to write out
254
860
        # in e.g. the default C locale.
255
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
256
 
        # For whatever reason codecs.getwriter() does not advertise its encoding
257
 
        # it just returns the encoding of the wrapped file, which is completely
258
 
        # bogus. So set the attribute, so we can find the correct encoding later.
259
 
        self.outf.encoding = output_encoding
260
 
 
261
 
    @deprecated_method(zero_eight)
262
 
    def run_argv(self, argv):
263
 
        """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")
264
1083
        
265
 
        See run_argv_aliases for the 0.8 and beyond api.
266
 
        """
267
 
        return self.run_argv_aliases(argv)
268
 
 
269
 
    def run_argv_aliases(self, argv, alias_argv=None):
270
 
        """Parse the command line and run with extra aliases in alias_argv."""
271
 
        if argv is None:
272
 
            warn("Passing None for [] is deprecated from bzrlib 0.10", 
273
 
                 DeprecationWarning, stacklevel=2)
274
 
            argv = []
275
 
        args, opts = parse_args(self, argv, alias_argv)
276
 
        if 'help' in opts:  # e.g. bzr add --help
277
 
            from bzrlib.help import help_on_command
278
 
            help_on_command(self.name())
279
 
            return 0
280
 
        # mix arguments and options into one dictionary
281
 
        cmdargs = _match_argform(self.name(), self.takes_args, args)
282
 
        cmdopts = {}
283
 
        for k, v in opts.items():
284
 
            cmdopts[k.replace('-', '_')] = v
285
 
 
286
 
        all_cmd_args = cmdargs.copy()
287
 
        all_cmd_args.update(cmdopts)
288
 
 
289
 
        self._setup_outf()
290
 
 
291
 
        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']
292
1126
    
293
 
    def run(self):
294
 
        """Actually run the command.
295
 
 
296
 
        This is invoked with the options and arguments bound to
297
 
        keyword parameters.
298
 
 
299
 
        Return 0 or None if the command was successful, or a non-zero
300
 
        shell error code if not.  It's OK for this method to allow
301
 
        an exception to raise up.
302
 
        """
303
 
        raise NotImplementedError('no implementation of command %r' 
304
 
                                  % self.name())
305
 
 
306
 
    def help(self):
307
 
        """Return help message for this class."""
308
 
        from inspect import getdoc
309
 
        if self.__doc__ is Command.__doc__:
310
 
            return None
311
 
        return getdoc(self)
312
 
 
313
 
    def name(self):
314
 
        return _unsquish_command_name(self.__class__.__name__)
315
 
 
316
 
    def plugin_name(self):
317
 
        """Get the name of the plugin that provides this command.
318
 
 
319
 
        :return: The name of the plugin or None if the command is builtin.
320
 
        """
321
 
        mod_parts = self.__module__.split('.')
322
 
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
323
 
            return mod_parts[2]
 
1127
    def run(self, email=False):
 
1128
        if email:
 
1129
            print bzrlib.osutils.user_email()
324
1130
        else:
325
 
            return None
326
 
 
327
 
 
328
 
# Technically, this function hasn't been use in a *really* long time
329
 
# but we are only deprecating it now.
330
 
@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
 
331
1167
def parse_spec(spec):
332
1168
    """
333
1169
    >>> parse_spec(None)
338
1174
    ['..', -1]
339
1175
    >>> parse_spec("../f/@35")
340
1176
    ['../f', 35]
341
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
342
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
343
1177
    """
344
1178
    if spec is None:
345
1179
        return [None, None]
349
1183
        if parsed[1] == "":
350
1184
            parsed[1] = -1
351
1185
        else:
352
 
            try:
353
 
                parsed[1] = int(parsed[1])
354
 
            except ValueError:
355
 
                pass # We can allow stuff like ./@revid:blahblahblah
356
 
            else:
357
 
                assert parsed[1] >=0
 
1186
            parsed[1] = int(parsed[1])
 
1187
            assert parsed[1] >=0
358
1188
    else:
359
1189
        parsed = [spec, None]
360
1190
    return parsed
361
1191
 
362
 
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):
363
1306
    """Parse command line.
364
1307
    
365
1308
    Arguments and options are parsed at this level before being passed
366
1309
    down to specific command handlers.  This routine knows, from a
367
1310
    lookup table, something about the available options, what optargs
368
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
369
1331
    """
370
 
    # TODO: make it a method of the Command?
371
 
    parser = option.get_optparser(command.options())
372
 
    if alias_argv is not None:
373
 
        args = alias_argv + argv
374
 
    else:
375
 
        args = argv
376
 
 
377
 
    options, args = parser.parse_args(args)
378
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
379
 
                 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
 
380
1401
    return args, opts
381
1402
 
382
1403
 
 
1404
 
 
1405
 
383
1406
def _match_argform(cmd, takes_args, args):
384
1407
    argdict = {}
385
1408
 
397
1420
                argdict[argname + '_list'] = None
398
1421
        elif ap[-1] == '+':
399
1422
            if not args:
400
 
                raise errors.BzrCommandError("command %r needs one or more %s"
401
 
                                             % (cmd, argname.upper()))
 
1423
                raise BzrCommandError("command %r needs one or more %s"
 
1424
                        % (cmd, argname.upper()))
402
1425
            else:
403
1426
                argdict[argname + '_list'] = args[:]
404
1427
                args = []
405
1428
        elif ap[-1] == '$': # all but one
406
1429
            if len(args) < 2:
407
 
                raise errors.BzrCommandError("command %r needs one or more %s"
408
 
                                             % (cmd, argname.upper()))
 
1430
                raise BzrCommandError("command %r needs one or more %s"
 
1431
                        % (cmd, argname.upper()))
409
1432
            argdict[argname + '_list'] = args[:-1]
410
 
            args[:-1] = []
 
1433
            args[:-1] = []                
411
1434
        else:
412
1435
            # just a plain arg
413
1436
            argname = ap
414
1437
            if not args:
415
 
                raise errors.BzrCommandError("command %r requires argument %s"
416
 
                               % (cmd, argname.upper()))
 
1438
                raise BzrCommandError("command %r requires argument %s"
 
1439
                        % (cmd, argname.upper()))
417
1440
            else:
418
1441
                argdict[argname] = args.pop(0)
419
1442
            
420
1443
    if args:
421
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
422
 
                                     % (cmd, args[0]))
 
1444
        raise BzrCommandError("extra argument to command %s: %s"
 
1445
                              % (cmd, args[0]))
423
1446
 
424
1447
    return argdict
425
1448
 
426
1449
 
427
 
 
428
 
def apply_profiled(the_callable, *args, **kwargs):
429
 
    import hotshot
430
 
    import tempfile
431
 
    import hotshot.stats
432
 
    pffileno, pfname = tempfile.mkstemp()
433
 
    try:
434
 
        prof = hotshot.Profile(pfname)
435
 
        try:
436
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
437
 
        finally:
438
 
            prof.close()
439
 
        stats = hotshot.stats.load(pfname)
440
 
        stats.strip_dirs()
441
 
        stats.sort_stats('cum')   # 'time'
442
 
        ## XXX: Might like to write to stderr or the trace file instead but
443
 
        ## print_stats seems hardcoded to stdout
444
 
        stats.print_stats(20)
445
 
        return ret
446
 
    finally:
447
 
        os.close(pffileno)
448
 
        os.remove(pfname)
449
 
 
450
 
 
451
 
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
452
 
    from bzrlib.lsprof import profile
453
 
    import cPickle
454
 
    ret, stats = profile(the_callable, *args, **kwargs)
455
 
    stats.sort()
456
 
    if filename is None:
457
 
        stats.pprint()
458
 
    else:
459
 
        stats.freeze()
460
 
        cPickle.dump(stats, open(filename, 'w'), 2)
461
 
        print 'Profile data written to %r.' % filename
462
 
    return ret
463
 
 
464
 
 
465
 
def get_alias(cmd):
466
 
    """Return an expanded alias, or None if no alias exists"""
467
 
    import bzrlib.config
468
 
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
469
 
    if (alias):
470
 
        return alias.split(' ')
471
 
    return None
 
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
 
1496
    """
 
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
 
472
1520
 
473
1521
 
474
1522
def run_bzr(argv):
476
1524
 
477
1525
    This is similar to main(), but without all the trappings for
478
1526
    logging and error handling.  
479
 
    
480
 
    argv
481
 
       The command-line arguments, without the program name from argv[0]
482
 
       These should already be decoded. All library/test code calling
483
 
       run_bzr should be passing valid strings (don't need decoding).
484
 
    
485
 
    Returns a command status or raises an exception.
486
 
 
487
 
    Special master options: these must come before the command because
488
 
    they control how the command is interpreted.
489
 
 
490
 
    --no-plugins
491
 
        Do not load plugin modules at all
492
 
 
493
 
    --no-aliases
494
 
        Do not allow aliases
495
 
 
496
 
    --builtin
497
 
        Only use builtin commands.  (Plugins are still allowed to change
498
 
        other behaviour.)
499
 
 
500
 
    --profile
501
 
        Run under the Python hotshot profiler.
502
 
 
503
 
    --lsprof
504
 
        Run under the Python lsprof profiler.
505
1527
    """
506
 
    argv = list(argv)
507
 
 
508
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
509
 
                opt_no_aliases = False
510
 
    opt_lsprof_file = None
511
 
 
512
 
    # --no-plugins is handled specially at a very early stage. We need
513
 
    # to load plugins before doing other command parsing so that they
514
 
    # can override commands, but this needs to happen first.
515
 
 
516
 
    argv_copy = []
517
 
    i = 0
518
 
    while i < len(argv):
519
 
        a = argv[i]
520
 
        if a == '--profile':
521
 
            opt_profile = True
522
 
        elif a == '--lsprof':
523
 
            opt_lsprof = True
524
 
        elif a == '--lsprof-file':
525
 
            opt_lsprof = True
526
 
            opt_lsprof_file = argv[i + 1]
527
 
            i += 1
528
 
        elif a == '--no-plugins':
529
 
            opt_no_plugins = True
530
 
        elif a == '--no-aliases':
531
 
            opt_no_aliases = True
532
 
        elif a == '--builtin':
533
 
            opt_builtin = True
534
 
        elif a in ('--quiet', '-q'):
535
 
            trace.be_quiet()
536
 
        else:
537
 
            argv_copy.append(a)
538
 
        i += 1
539
 
 
540
 
    argv = argv_copy
541
 
    if (not argv):
542
 
        from bzrlib.builtins import cmd_help
543
 
        cmd_help().run_argv_aliases([])
544
 
        return 0
545
 
 
546
 
    if argv[0] == '--version':
547
 
        from bzrlib.version import show_version
548
 
        show_version()
549
 
        return 0
550
 
        
551
 
    if not opt_no_plugins:
552
 
        from bzrlib.plugin import load_plugins
553
 
        load_plugins()
554
 
    else:
555
 
        from bzrlib.plugin import disable_plugins
556
 
        disable_plugins()
557
 
 
558
 
    alias_argv = None
559
 
 
560
 
    if not opt_no_aliases:
561
 
        alias_argv = get_alias(argv[0])
562
 
        if alias_argv:
563
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
564
 
            argv[0] = alias_argv.pop(0)
565
 
 
566
 
    cmd = argv.pop(0)
567
 
    # We want only 'ascii' command names, but the user may have typed
568
 
    # in a Unicode name. In that case, they should just get a
569
 
    # 'command not found' error later.
570
 
 
571
 
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
572
 
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
573
 
        run = cmd_obj.run_argv
574
 
        run_argv = [argv]
575
 
    else:
576
 
        run = cmd_obj.run_argv_aliases
577
 
        run_argv = [argv, alias_argv]
578
 
 
 
1528
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
1529
    
579
1530
    try:
580
 
        if opt_lsprof:
581
 
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
582
 
        elif opt_profile:
583
 
            ret = apply_profiled(run, *run_argv)
584
 
        else:
585
 
            ret = run(*run_argv)
586
 
        return ret or 0
587
 
    finally:
588
 
        # reset, in case we may do other commands later within the same process
589
 
        trace.be_quiet(False)
590
 
 
591
 
def display_command(func):
592
 
    """Decorator that suppresses pipe/interrupt errors."""
593
 
    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()
594
1592
        try:
595
 
            result = func(*args, **kwargs)
596
 
            sys.stdout.flush()
597
 
            return result
598
 
        except IOError, e:
599
 
            if getattr(e, 'errno', None) is None:
600
 
                raise
601
 
            if e.errno != errno.EPIPE:
602
 
                # Win32 raises IOError with errno=0 on a broken pipe
603
 
                if sys.platform != 'win32' or e.errno != 0:
604
 
                    raise
605
 
            pass
606
 
        except KeyboardInterrupt:
607
 
            pass
608
 
    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
 
609
1626
 
610
1627
 
611
1628
def main(argv):
612
 
    import bzrlib.ui
613
 
    from bzrlib.ui.text import TextUIFactory
614
 
    bzrlib.ui.ui_factory = TextUIFactory()
615
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
616
 
    ret = run_bzr_catch_errors(argv)
617
 
    trace.mutter("return code %d", ret)
618
 
    return ret
619
 
 
620
 
 
621
 
def run_bzr_catch_errors(argv):
 
1629
    import errno
 
1630
    
 
1631
    bzrlib.open_tracefile(argv)
 
1632
 
622
1633
    try:
623
 
        return run_bzr(argv)
624
 
        # do this here inside the exception wrappers to catch EPIPE
625
 
        sys.stdout.flush()
626
 
    except (KeyboardInterrupt, Exception), e:
627
 
        # used to handle AssertionError and KeyboardInterrupt
628
 
        # specially here, but hopefully they're handled ok by the logger now
629
 
        trace.report_exception(sys.exc_info(), sys.stderr)
630
 
        if os.environ.get('BZR_PDB'):
631
 
            print '**** entering debugger'
632
 
            import pdb
633
 
            pdb.post_mortem(sys.exc_traceback)
634
 
        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
 
635
1671
 
636
1672
if __name__ == '__main__':
637
1673
    sys.exit(main(sys.argv))