~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-09 05:26:51 UTC
  • Revision ID: mbp@sourcefrog.net-20050409052651-73d6952d368eb58574d2e50b
revfile add and add-delta commands print just the index for use by scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
 
1
# Copyright (C) 2004, 2005 by Martin Pool
 
2
# Copyright (C) 2005 by Canonical Ltd
 
3
 
2
4
 
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
14
16
# along with this program; if not, write to the Free Software
15
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
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: Help messages for options.
22
 
 
23
 
# TODO: Define arguments by objects, rather than just using names.
24
 
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
26
 
 
27
 
 
28
 
 
29
 
import sys
30
 
import os
31
 
from warnings import warn
32
 
from inspect import getdoc
 
19
"""Bazaar-NG -- a free distributed version-control tool
 
20
 
 
21
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
 
22
 
 
23
Current limitation include:
 
24
 
 
25
* Metadata format is not stable yet -- you may need to
 
26
  discard history in the future.
 
27
 
 
28
* Insufficient error handling.
 
29
 
 
30
* Many commands unimplemented or partially implemented.
 
31
 
 
32
* Space-inefficient storage.
 
33
 
 
34
* No merge operators yet.
 
35
 
 
36
Interesting commands::
 
37
 
 
38
  bzr help [COMMAND]
 
39
       Show help screen
 
40
  bzr version
 
41
       Show software version/licence/non-warranty.
 
42
  bzr init
 
43
       Start versioning the current directory
 
44
  bzr add FILE...
 
45
       Make files versioned.
 
46
  bzr log
 
47
       Show revision history.
 
48
  bzr diff [FILE...]
 
49
       Show changes from last revision to working copy.
 
50
  bzr commit -m 'MESSAGE'
 
51
       Store current state as new revision.
 
52
  bzr export REVNO DESTINATION
 
53
       Export the branch state at a previous version.
 
54
  bzr status
 
55
       Show summary of pending changes.
 
56
  bzr remove FILE...
 
57
       Make a file not versioned.
 
58
  bzr info
 
59
       Show statistics about this branch.
 
60
"""
 
61
 
 
62
 
 
63
 
 
64
 
 
65
import sys, os, time, types, shutil, tempfile, traceback, fnmatch, difflib, os.path
 
66
from sets import Set
 
67
from pprint import pprint
 
68
from stat import *
 
69
from glob import glob
33
70
 
34
71
import bzrlib
35
 
import bzrlib.trace
36
 
from bzrlib.trace import mutter, note, log_error, warning
37
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
38
 
from bzrlib.branch import find_branch
39
 
from bzrlib import BZRDIR
40
 
 
41
 
plugin_cmds = {}
42
 
 
43
 
 
44
 
def register_command(cmd):
45
 
    "Utility function to help register a command"
46
 
    global plugin_cmds
47
 
    k = cmd.__name__
48
 
    if k.startswith("cmd_"):
49
 
        k_unsquished = _unsquish_command_name(k)
50
 
    else:
51
 
        k_unsquished = k
52
 
    if not plugin_cmds.has_key(k_unsquished):
53
 
        plugin_cmds[k_unsquished] = cmd
54
 
        mutter('registered plugin command %s', k_unsquished)      
55
 
    else:
56
 
        log_error('Two plugins defined the same command: %r' % k)
57
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
58
 
 
59
 
 
60
 
def _squish_command_name(cmd):
61
 
    return 'cmd_' + cmd.replace('-', '_')
62
 
 
63
 
 
64
 
def _unsquish_command_name(cmd):
65
 
    assert cmd.startswith("cmd_")
66
 
    return cmd[4:].replace('_','-')
67
 
 
68
 
 
69
 
def _parse_revision_str(revstr):
70
 
    """This handles a revision string -> revno.
71
 
 
72
 
    This always returns a list.  The list will have one element for 
73
 
 
74
 
    It supports integers directly, but everything else it
75
 
    defers for passing to Branch.get_revision_info()
76
 
 
77
 
    >>> _parse_revision_str('234')
78
 
    [234]
79
 
    >>> _parse_revision_str('234..567')
80
 
    [234, 567]
81
 
    >>> _parse_revision_str('..')
82
 
    [None, None]
83
 
    >>> _parse_revision_str('..234')
84
 
    [None, 234]
85
 
    >>> _parse_revision_str('234..')
86
 
    [234, None]
87
 
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
88
 
    [234, 456, 789]
89
 
    >>> _parse_revision_str('234....789') # Error?
90
 
    [234, None, 789]
91
 
    >>> _parse_revision_str('revid:test@other.com-234234')
92
 
    ['revid:test@other.com-234234']
93
 
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
94
 
    ['revid:test@other.com-234234', 'revid:test@other.com-234235']
95
 
    >>> _parse_revision_str('revid:test@other.com-234234..23')
96
 
    ['revid:test@other.com-234234', 23]
97
 
    >>> _parse_revision_str('date:2005-04-12')
98
 
    ['date:2005-04-12']
99
 
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
100
 
    ['date:2005-04-12 12:24:33']
101
 
    >>> _parse_revision_str('date:2005-04-12T12:24:33')
102
 
    ['date:2005-04-12T12:24:33']
103
 
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
104
 
    ['date:2005-04-12,12:24:33']
105
 
    >>> _parse_revision_str('-5..23')
106
 
    [-5, 23]
107
 
    >>> _parse_revision_str('-5')
108
 
    [-5]
109
 
    >>> _parse_revision_str('123a')
110
 
    ['123a']
111
 
    >>> _parse_revision_str('abc')
112
 
    ['abc']
113
 
    """
114
 
    import re
115
 
    old_format_re = re.compile('\d*:\d*')
116
 
    m = old_format_re.match(revstr)
117
 
    if m:
118
 
        warning('Colon separator for revision numbers is deprecated.'
119
 
                ' Use .. instead')
120
 
        revs = []
121
 
        for rev in revstr.split(':'):
122
 
            if rev:
123
 
                revs.append(int(rev))
124
 
            else:
125
 
                revs.append(None)
126
 
        return revs
127
 
    revs = []
128
 
    for x in revstr.split('..'):
129
 
        if not x:
130
 
            revs.append(None)
131
 
        else:
132
 
            try:
133
 
                revs.append(int(x))
134
 
            except ValueError:
135
 
                revs.append(x)
136
 
    return revs
137
 
 
138
 
 
139
 
def get_merge_type(typestring):
140
 
    """Attempt to find the merge class/factory associated with a string."""
141
 
    from merge import merge_types
142
 
    try:
143
 
        return merge_types[typestring][0]
144
 
    except KeyError:
145
 
        templ = '%s%%7s: %%s' % (' '*12)
146
 
        lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
147
 
        type_list = '\n'.join(lines)
148
 
        msg = "No known merge type %s. Supported types are:\n%s" %\
149
 
            (typestring, type_list)
150
 
        raise BzrCommandError(msg)
151
 
    
152
 
 
153
 
def _builtin_commands():
154
 
    import bzrlib.builtins
155
 
    r = {}
156
 
    builtins = bzrlib.builtins.__dict__
157
 
    for name in builtins:
158
 
        if name.startswith("cmd_"):
159
 
            real_name = _unsquish_command_name(name)        
160
 
            r[real_name] = builtins[name]
161
 
    return r
162
 
 
163
 
            
164
 
 
165
 
def builtin_command_names():
166
 
    """Return list of builtin command names."""
167
 
    return _builtin_commands().keys()
168
 
    
169
 
 
170
 
def plugin_command_names():
171
 
    return plugin_cmds.keys()
172
 
 
173
 
 
174
 
def _get_cmd_dict(plugins_override=True):
175
 
    """Return name->class mapping for all commands."""
176
 
    d = _builtin_commands()
177
 
    if plugins_override:
178
 
        d.update(plugin_cmds)
179
 
    return d
180
 
 
181
 
    
182
 
def get_all_cmds(plugins_override=True):
183
 
    """Return canonical name and class for all registered commands."""
184
 
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
185
 
        yield k,v
186
 
 
187
 
 
188
 
def get_cmd_object(cmd_name, plugins_override=True):
189
 
    """Return the canonical name and command class for a command.
190
 
 
191
 
    plugins_override
192
 
        If true, plugin commands can override builtins.
193
 
    """
194
 
    from bzrlib.externalcommand import ExternalCommand
195
 
 
196
 
    cmd_name = str(cmd_name)            # not unicode
197
 
 
198
 
    # first look up this command under the specified name
199
 
    cmds = _get_cmd_dict(plugins_override=plugins_override)
200
 
    try:
201
 
        return cmds[cmd_name]()
202
 
    except KeyError:
203
 
        pass
204
 
 
205
 
    # look for any command which claims this as an alias
206
 
    for real_cmd_name, cmd_class in cmds.iteritems():
207
 
        if cmd_name in cmd_class.aliases:
208
 
            return cmd_class()
209
 
 
210
 
    cmd_obj = ExternalCommand.find_command(cmd_name)
211
 
    if cmd_obj:
212
 
        return cmd_obj
213
 
 
214
 
    raise BzrCommandError("unknown command %r" % cmd_name)
215
 
 
216
 
 
217
 
class Command(object):
218
 
    """Base class for commands.
219
 
 
220
 
    Commands are the heart of the command-line bzr interface.
221
 
 
222
 
    The command object mostly handles the mapping of command-line
223
 
    parameters into one or more bzrlib operations, and of the results
224
 
    into textual output.
225
 
 
226
 
    Commands normally don't have any state.  All their arguments are
227
 
    passed in to the run method.  (Subclasses may take a different
228
 
    policy if the behaviour of the instance needs to depend on e.g. a
229
 
    shell plugin and not just its Python class.)
230
 
 
231
 
    The docstring for an actual command should give a single-line
232
 
    summary, then a complete description of the command.  A grammar
233
 
    description will be inserted.
234
 
 
235
 
    aliases
236
 
        Other accepted names for this command.
237
 
 
238
 
    takes_args
239
 
        List of argument forms, marked with whether they are optional,
240
 
        repeated, etc.
241
 
 
242
 
    takes_options
243
 
        List of options that may be given for this command.
244
 
 
245
 
    hidden
246
 
        If true, this command isn't advertised.  This is typically
247
 
        for commands intended for expert users.
248
 
    """
249
 
    aliases = []
250
 
    
251
 
    takes_args = []
252
 
    takes_options = []
253
 
 
254
 
    hidden = False
255
 
    
256
 
    def __init__(self):
257
 
        """Construct an instance of this command."""
258
 
        if self.__doc__ == Command.__doc__:
259
 
            warn("No help message set for %r" % self)
260
 
 
261
 
 
262
 
    def run_argv(self, argv):
263
 
        """Parse command line and run."""
264
 
        args, opts = parse_args(argv)
265
 
 
266
 
        if 'help' in opts:  # e.g. bzr add --help
267
 
            from bzrlib.help import help_on_command
268
 
            help_on_command(self.name())
269
 
            return 0
270
 
 
271
 
        # check options are reasonable
272
 
        allowed = self.takes_options
273
 
        for oname in opts:
274
 
            if oname not in allowed:
275
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
276
 
                                      % (oname, self.name()))
277
 
 
278
 
        # mix arguments and options into one dictionary
279
 
        cmdargs = _match_argform(self.name(), self.takes_args, args)
280
 
        cmdopts = {}
281
 
        for k, v in opts.items():
282
 
            cmdopts[k.replace('-', '_')] = v
283
 
 
284
 
        all_cmd_args = cmdargs.copy()
285
 
        all_cmd_args.update(cmdopts)
286
 
 
287
 
        return self.run(**all_cmd_args)
288
 
 
289
 
    
290
 
    def run(self):
291
 
        """Actually run the command.
292
 
 
293
 
        This is invoked with the options and arguments bound to
294
 
        keyword parameters.
295
 
 
296
 
        Return 0 or None if the command was successful, or a non-zero
297
 
        shell error code if not.  It's OK for this method to allow
298
 
        an exception to raise up.
299
 
        """
300
 
        raise NotImplementedError()
301
 
 
302
 
 
303
 
    def help(self):
304
 
        """Return help message for this class."""
305
 
        if self.__doc__ is Command.__doc__:
306
 
            return None
307
 
        return getdoc(self)
308
 
 
309
 
    def name(self):
310
 
        return _unsquish_command_name(self.__class__.__name__)
311
 
 
312
 
 
313
 
def parse_spec(spec):
314
 
    """
315
 
    >>> parse_spec(None)
316
 
    [None, None]
317
 
    >>> parse_spec("./")
318
 
    ['./', None]
319
 
    >>> parse_spec("../@")
320
 
    ['..', -1]
321
 
    >>> parse_spec("../f/@35")
322
 
    ['../f', 35]
323
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
324
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
325
 
    """
326
 
    if spec is None:
327
 
        return [None, None]
328
 
    if '/@' in spec:
329
 
        parsed = spec.split('/@')
330
 
        assert len(parsed) == 2
331
 
        if parsed[1] == "":
332
 
            parsed[1] = -1
333
 
        else:
334
 
            try:
335
 
                parsed[1] = int(parsed[1])
336
 
            except ValueError:
337
 
                pass # We can allow stuff like ./@revid:blahblahblah
338
 
            else:
339
 
                assert parsed[1] >=0
340
 
    else:
341
 
        parsed = [spec, None]
342
 
    return parsed
343
 
 
344
 
 
 
72
from bzrlib.store import ImmutableStore
 
73
from bzrlib.trace import mutter, note, log_error
 
74
from bzrlib.errors import bailout, BzrError, BzrCheckError
 
75
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
 
76
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
 
77
from bzrlib.revision import Revision
 
78
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
 
79
     format_date
 
80
 
 
81
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
 
82
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
 
83
 
 
84
## standard representation
 
85
NONE_STRING = '(none)'
 
86
EMPTY = 'empty'
 
87
 
 
88
 
 
89
## TODO: Perhaps a different version of inventory commands that
 
90
## returns iterators...
 
91
 
 
92
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
 
93
 
 
94
## TODO: Some kind of locking on branches.  Perhaps there should be a
 
95
## parameter to the branch object saying whether we want a read or
 
96
## write lock; release it from destructor.  Perhaps don't even need a
 
97
## read lock to look at immutable objects?
 
98
 
 
99
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
 
100
## to compare output?
 
101
 
 
102
## TODO: Some kind of global code to generate the right Branch object
 
103
## to work on.  Almost, but not quite all, commands need one, and it
 
104
## can be taken either from their parameters or their working
 
105
## directory.
 
106
 
 
107
## TODO: rename command, needed soon: check destination doesn't exist
 
108
## either in working copy or tree; move working copy; update
 
109
## inventory; write out
 
110
 
 
111
## TODO: move command; check destination is a directory and will not
 
112
## clash; move it.
 
113
 
 
114
## TODO: command to show renames, one per line, as to->from
 
115
 
 
116
 
 
117
 
 
118
 
 
119
def cmd_status(all=False):
 
120
    """Display status summary.
 
121
 
 
122
    For each file there is a single line giving its file state and name.
 
123
    The name is that in the current revision unless it is deleted or
 
124
    missing, in which case the old name is shown.
 
125
 
 
126
    :todo: Don't show unchanged files unless ``--all`` is given?
 
127
    """
 
128
    Branch('.').show_status(show_all=all)
 
129
 
 
130
 
 
131
 
 
132
######################################################################
 
133
# examining history
 
134
def cmd_get_revision(revision_id):
 
135
    Branch('.').get_revision(revision_id).write_xml(sys.stdout)
 
136
 
 
137
 
 
138
def cmd_get_file_text(text_id):
 
139
    """Get contents of a file by hash."""
 
140
    sf = Branch('.').text_store[text_id]
 
141
    pumpfile(sf, sys.stdout)
 
142
 
 
143
 
 
144
 
 
145
######################################################################
 
146
# commands
 
147
    
 
148
 
 
149
def cmd_revno():
 
150
    """Show number of revisions on this branch"""
 
151
    print Branch('.').revno()
 
152
    
 
153
 
 
154
    
 
155
def cmd_add(file_list, verbose=False):
 
156
    """Add specified files or directories.
 
157
 
 
158
    In non-recursive mode, all the named items are added, regardless
 
159
    of whether they were previously ignored.  A warning is given if
 
160
    any of the named files are already versioned.
 
161
 
 
162
    In recursive mode (the default), files are treated the same way
 
163
    but the behaviour for directories is different.  Directories that
 
164
    are already versioned do not give a warning.  All directories,
 
165
    whether already versioned or not, are searched for files or
 
166
    subdirectories that are neither versioned or ignored, and these
 
167
    are added.  This search proceeds recursively into versioned
 
168
    directories.
 
169
 
 
170
    Therefore simply saying 'bzr add .' will version all files that
 
171
    are currently unknown.
 
172
    """
 
173
    bzrlib.add.smart_add(file_list, verbose)
 
174
    
 
175
 
 
176
def cmd_relpath(filename):
 
177
    """Show path of file relative to root"""
 
178
    print Branch(filename).relpath(filename)
 
179
 
 
180
 
 
181
 
 
182
def cmd_inventory(revision=None):
 
183
    """Show inventory of the current working copy."""
 
184
    ## TODO: Also optionally show a previous inventory
 
185
    ## TODO: Format options
 
186
    b = Branch('.')
 
187
    if revision == None:
 
188
        inv = b.read_working_inventory()
 
189
    else:
 
190
        inv = b.get_revision_inventory(b.lookup_revision(revision))
 
191
        
 
192
    for path, entry in inv.iter_entries():
 
193
        print '%-50s %s' % (entry.file_id, path)
 
194
 
 
195
 
 
196
 
 
197
# TODO: Maybe a 'mv' command that has the combined move/rename
 
198
# special behaviour of Unix?
 
199
 
 
200
def cmd_move(source_list, dest):
 
201
    b = Branch('.')
 
202
 
 
203
    b.move([b.relpath(s) for s in source_list], b.relpath(dest))
 
204
 
 
205
 
 
206
 
 
207
def cmd_rename(from_name, to_name):
 
208
    """Change the name of an entry.
 
209
 
 
210
usage: bzr rename FROM_NAME TO_NAME
 
211
 
 
212
examples:
 
213
  bzr rename frob.c frobber.c
 
214
  bzr rename src/frob.c lib/frob.c
 
215
 
 
216
It is an error if the destination name exists.
 
217
 
 
218
See also the 'move' command, which moves files into a different
 
219
directory without changing their name.
 
220
 
 
221
TODO: Some way to rename multiple files without invoking bzr for each
 
222
one?"""
 
223
    b = Branch('.')
 
224
    b.rename_one(b.relpath(from_name), b.relpath(to_name))
 
225
    
 
226
 
 
227
 
 
228
 
 
229
def cmd_renames(dir='.'):
 
230
    """Show list of renamed files.
 
231
 
 
232
usage: bzr renames [BRANCH]
 
233
 
 
234
TODO: Option to show renames between two historical versions.
 
235
 
 
236
TODO: Only show renames under dir, rather than in the whole branch.
 
237
"""
 
238
    b = Branch(dir)
 
239
    old_inv = b.basis_tree().inventory
 
240
    new_inv = b.read_working_inventory()
 
241
    
 
242
    renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
 
243
    renames.sort()
 
244
    for old_name, new_name in renames:
 
245
        print "%s => %s" % (old_name, new_name)        
 
246
 
 
247
 
 
248
 
 
249
def cmd_info():
 
250
    """info: Show statistical information for this branch
 
251
 
 
252
usage: bzr info"""
 
253
    import info
 
254
    info.show_info(Branch('.'))        
 
255
    
 
256
 
 
257
 
 
258
def cmd_remove(file_list, verbose=False):
 
259
    b = Branch(file_list[0])
 
260
    b.remove([b.relpath(f) for f in file_list], verbose=verbose)
 
261
 
 
262
 
 
263
 
 
264
def cmd_file_id(filename):
 
265
    """Print file_id of a particular file or directory.
 
266
 
 
267
usage: bzr file-id FILE
 
268
 
 
269
The file_id is assigned when the file is first added and remains the
 
270
same through all revisions where the file exists, even when it is
 
271
moved or renamed.
 
272
"""
 
273
    b = Branch(filename)
 
274
    i = b.inventory.path2id(b.relpath(filename))
 
275
    if i == None:
 
276
        bailout("%r is not a versioned file" % filename)
 
277
    else:
 
278
        print i
 
279
 
 
280
 
 
281
def cmd_file_id_path(filename):
 
282
    """Print path of file_ids to a file or directory.
 
283
 
 
284
usage: bzr file-id-path FILE
 
285
 
 
286
This prints one line for each directory down to the target,
 
287
starting at the branch root."""
 
288
    b = Branch(filename)
 
289
    inv = b.inventory
 
290
    fid = inv.path2id(b.relpath(filename))
 
291
    if fid == None:
 
292
        bailout("%r is not a versioned file" % filename)
 
293
    for fip in inv.get_idpath(fid):
 
294
        print fip
 
295
 
 
296
 
 
297
def cmd_revision_history():
 
298
    for patchid in Branch('.').revision_history():
 
299
        print patchid
 
300
 
 
301
 
 
302
def cmd_directories():
 
303
    for name, ie in Branch('.').read_working_inventory().directories():
 
304
        if name == '':
 
305
            print '.'
 
306
        else:
 
307
            print name
 
308
 
 
309
 
 
310
def cmd_missing():
 
311
    for name, ie in Branch('.').working_tree().missing():
 
312
        print name
 
313
 
 
314
 
 
315
def cmd_init():
 
316
    # TODO: Check we're not already in a working directory?  At the
 
317
    # moment you'll get an ugly error.
 
318
    
 
319
    # TODO: What if we're in a subdirectory of a branch?  Would like
 
320
    # to allow that, but then the parent may need to understand that
 
321
    # the children have disappeared, or should they be versioned in
 
322
    # both?
 
323
 
 
324
    # TODO: Take an argument/option for branch name.
 
325
    Branch('.', init=True)
 
326
 
 
327
 
 
328
def cmd_diff(revision=None, file_list=None):
 
329
    """bzr diff: Show differences in working tree.
 
330
    
 
331
usage: bzr diff [-r REV] [FILE...]
 
332
 
 
333
--revision REV
 
334
    Show changes since REV, rather than predecessor.
 
335
 
 
336
If files are listed, only the changes in those files are listed.
 
337
Otherwise, all changes for the tree are listed.
 
338
 
 
339
TODO: Given two revision arguments, show the difference between them.
 
340
 
 
341
TODO: Allow diff across branches.
 
342
 
 
343
TODO: Option to use external diff command; could be GNU diff, wdiff,
 
344
or a graphical diff.
 
345
 
 
346
TODO: If a directory is given, diff everything under that.
 
347
 
 
348
TODO: Selected-file diff is inefficient and doesn't show you deleted files.
 
349
"""
 
350
 
 
351
    ## TODO: Shouldn't be in the cmd function.
 
352
 
 
353
    b = Branch('.')
 
354
 
 
355
    if revision == None:
 
356
        old_tree = b.basis_tree()
 
357
    else:
 
358
        old_tree = b.revision_tree(b.lookup_revision(revision))
 
359
        
 
360
    new_tree = b.working_tree()
 
361
 
 
362
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
 
363
    old_label = ''
 
364
    new_label = ''
 
365
 
 
366
    DEVNULL = '/dev/null'
 
367
    # Windows users, don't panic about this filename -- it is a
 
368
    # special signal to GNU patch that the file should be created or
 
369
    # deleted respectively.
 
370
 
 
371
    # TODO: Generation of pseudo-diffs for added/deleted files could
 
372
    # be usefully made into a much faster special case.
 
373
 
 
374
    # TODO: Better to return them in sorted order I think.
 
375
 
 
376
    # FIXME: If given a file list, compare only those files rather
 
377
    # than comparing everything and then throwing stuff away.
 
378
    
 
379
    for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
 
380
 
 
381
        if file_list and new_name not in file_list:
 
382
            continue
 
383
        
 
384
        # Don't show this by default; maybe do it if an option is passed
 
385
        # idlabel = '      {%s}' % fid
 
386
        idlabel = ''
 
387
 
 
388
        # FIXME: Something about the diff format makes patch unhappy
 
389
        # with newly-added files.
 
390
 
 
391
        def diffit(oldlines, newlines, **kw):
 
392
            # FIXME: difflib is wrong if there is no trailing newline.
 
393
 
 
394
            # Special workaround for Python2.3, where difflib fails if
 
395
            # both sequences are empty.
 
396
            if oldlines or newlines:
 
397
                sys.stdout.writelines(difflib.unified_diff(oldlines, newlines, **kw))
 
398
            print
 
399
        
 
400
        if file_state in ['.', '?', 'I']:
 
401
            continue
 
402
        elif file_state == 'A':
 
403
            print '*** added %s %r' % (kind, new_name)
 
404
            if kind == 'file':
 
405
                diffit([],
 
406
                       new_tree.get_file(fid).readlines(),
 
407
                       fromfile=DEVNULL,
 
408
                       tofile=new_label + new_name + idlabel)
 
409
        elif file_state == 'D':
 
410
            assert isinstance(old_name, types.StringTypes)
 
411
            print '*** deleted %s %r' % (kind, old_name)
 
412
            if kind == 'file':
 
413
                diffit(old_tree.get_file(fid).readlines(), [],
 
414
                       fromfile=old_label + old_name + idlabel,
 
415
                       tofile=DEVNULL)
 
416
        elif file_state in ['M', 'R']:
 
417
            if file_state == 'M':
 
418
                assert kind == 'file'
 
419
                assert old_name == new_name
 
420
                print '*** modified %s %r' % (kind, new_name)
 
421
            elif file_state == 'R':
 
422
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
 
423
 
 
424
            if kind == 'file':
 
425
                diffit(old_tree.get_file(fid).readlines(),
 
426
                       new_tree.get_file(fid).readlines(),
 
427
                       fromfile=old_label + old_name + idlabel,
 
428
                       tofile=new_label + new_name)
 
429
        else:
 
430
            bailout("can't represent state %s {%s}" % (file_state, fid))
 
431
 
 
432
 
 
433
 
 
434
def cmd_deleted(show_ids=False):
 
435
    """List files deleted in the working tree.
 
436
 
 
437
TODO: Show files deleted since a previous revision, or between two revisions.
 
438
    """
 
439
    b = Branch('.')
 
440
    old = b.basis_tree()
 
441
    new = b.working_tree()
 
442
 
 
443
    ## TODO: Much more efficient way to do this: read in new
 
444
    ## directories with readdir, rather than stating each one.  Same
 
445
    ## level of effort but possibly much less IO.  (Or possibly not,
 
446
    ## if the directories are very large...)
 
447
 
 
448
    for path, ie in old.inventory.iter_entries():
 
449
        if not new.has_id(ie.file_id):
 
450
            if show_ids:
 
451
                print '%-50s %s' % (path, ie.file_id)
 
452
            else:
 
453
                print path
 
454
 
 
455
 
 
456
 
 
457
def cmd_parse_inventory():
 
458
    import cElementTree
 
459
    
 
460
    cElementTree.ElementTree().parse(file('.bzr/inventory'))
 
461
 
 
462
 
 
463
 
 
464
def cmd_load_inventory():
 
465
    """Load inventory for timing purposes"""
 
466
    Branch('.').basis_tree().inventory
 
467
 
 
468
 
 
469
def cmd_dump_inventory():
 
470
    Branch('.').read_working_inventory().write_xml(sys.stdout)
 
471
 
 
472
 
 
473
def cmd_dump_new_inventory():
 
474
    import bzrlib.newinventory
 
475
    inv = Branch('.').basis_tree().inventory
 
476
    bzrlib.newinventory.write_inventory(inv, sys.stdout)
 
477
 
 
478
 
 
479
def cmd_load_new_inventory():
 
480
    import bzrlib.newinventory
 
481
    bzrlib.newinventory.read_new_inventory(sys.stdin)
 
482
                
 
483
    
 
484
def cmd_dump_slacker_inventory():
 
485
    import bzrlib.newinventory
 
486
    inv = Branch('.').basis_tree().inventory
 
487
    bzrlib.newinventory.write_slacker_inventory(inv, sys.stdout)
 
488
                
 
489
    
 
490
 
 
491
def cmd_root(filename=None):
 
492
    """Print the branch root."""
 
493
    print bzrlib.branch.find_branch_root(filename)
 
494
    
 
495
 
 
496
def cmd_log(timezone='original'):
 
497
    """Show log of this branch.
 
498
 
 
499
    :todo: Options for utc; to show ids; to limit range; etc.
 
500
    """
 
501
    Branch('.').write_log(show_timezone=timezone)
 
502
 
 
503
 
 
504
def cmd_ls(revision=None, verbose=False):
 
505
    """List files in a tree.
 
506
 
 
507
    :todo: Take a revision or remote path and list that tree instead.
 
508
    """
 
509
    b = Branch('.')
 
510
    if revision == None:
 
511
        tree = b.working_tree()
 
512
    else:
 
513
        tree = b.revision_tree(b.lookup_revision(revision))
 
514
        
 
515
    for fp, fc, kind, fid in tree.list_files():
 
516
        if verbose:
 
517
            if kind == 'directory':
 
518
                kindch = '/'
 
519
            elif kind == 'file':
 
520
                kindch = ''
 
521
            else:
 
522
                kindch = '???'
 
523
                
 
524
            print '%-8s %s%s' % (fc, fp, kindch)
 
525
        else:
 
526
            print fp
 
527
    
 
528
    
 
529
 
 
530
def cmd_unknowns():
 
531
    """List unknown files"""
 
532
    for f in Branch('.').unknowns():
 
533
        print quotefn(f)
 
534
 
 
535
 
 
536
 
 
537
def cmd_ignored():
 
538
    """List ignored files and the patterns that matched them.
 
539
      """
 
540
    tree = Branch('.').working_tree()
 
541
    for path, file_class, kind, file_id in tree.list_files():
 
542
        if file_class != 'I':
 
543
            continue
 
544
        ## XXX: Slightly inefficient since this was already calculated
 
545
        pat = tree.is_ignored(path)
 
546
        print '%-50s %s' % (path, pat)
 
547
 
 
548
 
 
549
def cmd_lookup_revision(revno):
 
550
    try:
 
551
        revno = int(revno)
 
552
    except ValueError:
 
553
        bailout("usage: lookup-revision REVNO",
 
554
                ["REVNO is a non-negative revision number for this branch"])
 
555
 
 
556
    print Branch('.').lookup_revision(revno) or NONE_STRING
 
557
 
 
558
 
 
559
 
 
560
def cmd_export(revno, dest):
 
561
    """Export past revision to destination directory."""
 
562
    b = Branch('.')
 
563
    rh = b.lookup_revision(int(revno))
 
564
    t = b.revision_tree(rh)
 
565
    t.export(dest)
 
566
 
 
567
def cmd_cat(revision, filename):
 
568
    """Print file to stdout."""
 
569
    b = Branch('.')
 
570
    b.print_file(b.relpath(filename), int(revision))
 
571
 
 
572
 
 
573
######################################################################
 
574
# internal/test commands
 
575
 
 
576
 
 
577
def cmd_uuid():
 
578
    """Print a newly-generated UUID."""
 
579
    print bzrlib.osutils.uuid()
 
580
 
 
581
 
 
582
 
 
583
def cmd_local_time_offset():
 
584
    print bzrlib.osutils.local_time_offset()
 
585
 
 
586
 
 
587
 
 
588
def cmd_commit(message=None, verbose=False):
 
589
    """Commit changes to a new revision.
 
590
 
 
591
--message MESSAGE
 
592
    Description of changes in this revision; free form text.
 
593
    It is recommended that the first line be a single-sentence
 
594
    summary.
 
595
--verbose
 
596
    Show status of changed files,
 
597
 
 
598
TODO: Commit only selected files.
 
599
 
 
600
TODO: Run hooks on tree to-be-committed, and after commit.
 
601
 
 
602
TODO: Strict commit that fails if there are unknown or deleted files.
 
603
"""
 
604
 
 
605
    if not message:
 
606
        bailout("please specify a commit message")
 
607
    Branch('.').commit(message, verbose=verbose)
 
608
 
 
609
 
 
610
def cmd_check(dir='.'):
 
611
    """check: Consistency check of branch history.
 
612
 
 
613
usage: bzr check [-v] [BRANCH]
 
614
 
 
615
options:
 
616
  --verbose, -v         Show progress of checking.
 
617
 
 
618
This command checks various invariants about the branch storage to
 
619
detect data corruption or bzr bugs.
 
620
"""
 
621
    import bzrlib.check
 
622
    bzrlib.check.check(Branch(dir, find_root=False))
 
623
 
 
624
 
 
625
def cmd_is(pred, *rest):
 
626
    """Test whether PREDICATE is true."""
 
627
    try:
 
628
        cmd_handler = globals()['assert_' + pred.replace('-', '_')]
 
629
    except KeyError:
 
630
        bailout("unknown predicate: %s" % quotefn(pred))
 
631
        
 
632
    try:
 
633
        cmd_handler(*rest)
 
634
    except BzrCheckError:
 
635
        # by default we don't print the message so that this can
 
636
        # be used from shell scripts without producing noise
 
637
        sys.exit(1)
 
638
 
 
639
 
 
640
def cmd_username():
 
641
    print bzrlib.osutils.username()
 
642
 
 
643
 
 
644
def cmd_user_email():
 
645
    print bzrlib.osutils.user_email()
 
646
 
 
647
 
 
648
def cmd_gen_revision_id():
 
649
    print bzrlib.branch._gen_revision_id(time.time())
 
650
 
 
651
 
 
652
def cmd_selftest():
 
653
    """Run internal test suite"""
 
654
    ## -v, if present, is seen by doctest; the argument is just here
 
655
    ## so our parser doesn't complain
 
656
 
 
657
    ## TODO: --verbose option
 
658
 
 
659
    failures, tests = 0, 0
 
660
    
 
661
    import doctest, bzrlib.store, bzrlib.tests
 
662
    bzrlib.trace.verbose = False
 
663
 
 
664
    for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
 
665
        bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
 
666
        mf, mt = doctest.testmod(m)
 
667
        failures += mf
 
668
        tests += mt
 
669
        print '%-40s %3d tests' % (m.__name__, mt),
 
670
        if mf:
 
671
            print '%3d FAILED!' % mf
 
672
        else:
 
673
            print
 
674
 
 
675
    print '%-40s %3d tests' % ('total', tests),
 
676
    if failures:
 
677
        print '%3d FAILED!' % failures
 
678
    else:
 
679
        print
 
680
 
 
681
 
 
682
 
 
683
# deprecated
 
684
cmd_doctest = cmd_selftest
 
685
 
 
686
 
 
687
######################################################################
 
688
# help
 
689
 
 
690
 
 
691
def cmd_help(topic=None):
 
692
    if topic == None:
 
693
        print __doc__
 
694
        return
 
695
 
 
696
    # otherwise, maybe the name of a command?
 
697
    try:
 
698
        cmdfn = globals()['cmd_' + topic.replace('-', '_')]
 
699
    except KeyError:
 
700
        bailout("no help for %r" % topic)
 
701
 
 
702
    doc = cmdfn.__doc__
 
703
    if doc == None:
 
704
        bailout("sorry, no detailed help yet for %r" % topic)
 
705
 
 
706
    print doc
 
707
        
 
708
 
 
709
 
 
710
 
 
711
def cmd_version():
 
712
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
713
    print bzrlib.__copyright__
 
714
    print "http://bazaar-ng.org/"
 
715
    print
 
716
    print \
 
717
"""bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and
 
718
you may use, modify and redistribute it under the terms of the GNU 
 
719
General Public License version 2 or later."""
 
720
 
 
721
 
 
722
def cmd_rocks():
 
723
    """Statement of optimism."""
 
724
    print "it sure does!"
 
725
 
 
726
 
 
727
 
 
728
######################################################################
 
729
# main routine
345
730
 
346
731
 
347
732
# list of all available options; the rhs can be either None for an
349
734
# the type.
350
735
OPTIONS = {
351
736
    'all':                    None,
352
 
    'diff-options':           str,
353
737
    'help':                   None,
354
 
    'file':                   unicode,
355
 
    'force':                  None,
356
 
    'format':                 unicode,
357
 
    'forward':                None,
358
738
    'message':                unicode,
359
 
    'no-recurse':             None,
360
739
    'profile':                None,
361
 
    'revision':               _parse_revision_str,
362
 
    'short':                  None,
 
740
    'revision':               int,
363
741
    'show-ids':               None,
364
742
    'timezone':               str,
365
743
    'verbose':                None,
366
744
    'version':                None,
367
 
    'email':                  None,
368
 
    'unchanged':              None,
369
 
    'update':                 None,
370
 
    'long':                   None,
371
 
    'root':                   str,
372
 
    'no-backup':              None,
373
 
    'merge-type':             get_merge_type,
374
 
    'pattern':                str,
375
745
    }
376
746
 
377
747
SHORT_OPTIONS = {
378
 
    'F':                      'file', 
379
 
    'h':                      'help',
380
748
    'm':                      'message',
381
749
    'r':                      'revision',
382
750
    'v':                      'verbose',
383
 
    'l':                      'long',
384
751
}
385
752
 
 
753
# List of options that apply to particular commands; commands not
 
754
# listed take none.
 
755
cmd_options = {
 
756
    'add':                    ['verbose'],
 
757
    'cat':                    ['revision'],
 
758
    'commit':                 ['message', 'verbose'],
 
759
    'deleted':                ['show-ids'],
 
760
    'diff':                   ['revision'],
 
761
    'inventory':              ['revision'],
 
762
    'log':                    ['timezone'],
 
763
    'ls':                     ['revision', 'verbose'],
 
764
    'remove':                 ['verbose'],
 
765
    'status':                 ['all'],
 
766
    }
 
767
 
 
768
 
 
769
cmd_args = {
 
770
    'add':                    ['file+'],
 
771
    'cat':                    ['filename'],
 
772
    'commit':                 [],
 
773
    'diff':                   ['file*'],
 
774
    'export':                 ['revno', 'dest'],
 
775
    'file-id':                ['filename'],
 
776
    'file-id-path':           ['filename'],
 
777
    'get-file-text':          ['text_id'],
 
778
    'get-inventory':          ['inventory_id'],
 
779
    'get-revision':           ['revision_id'],
 
780
    'get-revision-inventory': ['revision_id'],
 
781
    'help':                   ['topic?'],
 
782
    'init':                   [],
 
783
    'log':                    [],
 
784
    'lookup-revision':        ['revno'],
 
785
    'move':                   ['source$', 'dest'],
 
786
    'relpath':                ['filename'],
 
787
    'remove':                 ['file+'],
 
788
    'rename':                 ['from_name', 'to_name'],
 
789
    'renames':                ['dir?'],
 
790
    'root':                   ['filename?'],
 
791
    'status':                 [],
 
792
    }
 
793
 
386
794
 
387
795
def parse_args(argv):
388
796
    """Parse command line.
394
802
 
395
803
    >>> parse_args('--help'.split())
396
804
    ([], {'help': True})
397
 
    >>> parse_args('help -- --invalidcmd'.split())
398
 
    (['help', '--invalidcmd'], {})
399
805
    >>> parse_args('--version'.split())
400
806
    ([], {'version': True})
401
807
    >>> parse_args('status --all'.split())
402
808
    (['status'], {'all': True})
403
809
    >>> parse_args('commit --message=biter'.split())
404
810
    (['commit'], {'message': u'biter'})
405
 
    >>> parse_args('log -r 500'.split())
406
 
    (['log'], {'revision': [500]})
407
 
    >>> parse_args('log -r500..600'.split())
408
 
    (['log'], {'revision': [500, 600]})
409
 
    >>> parse_args('log -vr500..600'.split())
410
 
    (['log'], {'verbose': True, 'revision': [500, 600]})
411
 
    >>> parse_args('log -rv500..600'.split()) #the r takes an argument
412
 
    (['log'], {'revision': ['v500', 600]})
413
811
    """
414
812
    args = []
415
813
    opts = {}
416
814
 
417
 
    argsover = False
 
815
    # TODO: Maybe handle '--' to end options?
 
816
 
418
817
    while argv:
419
818
        a = argv.pop(0)
420
 
        if not argsover and a[0] == '-':
421
 
            # option names must not be unicode
422
 
            a = str(a)
 
819
        if a[0] == '-':
423
820
            optarg = None
424
821
            if a[1] == '-':
425
 
                if a == '--':
426
 
                    # We've received a standalone -- No more flags
427
 
                    argsover = True
428
 
                    continue
429
822
                mutter("  got option %r" % a)
430
823
                if '=' in a:
431
824
                    optname, optarg = a[2:].split('=', 1)
432
825
                else:
433
826
                    optname = a[2:]
434
827
                if optname not in OPTIONS:
435
 
                    raise BzrError('unknown long option %r' % a)
 
828
                    bailout('unknown long option %r' % a)
436
829
            else:
437
830
                shortopt = a[1:]
438
 
                if shortopt in SHORT_OPTIONS:
439
 
                    # Multi-character options must have a space to delimit
440
 
                    # their value
441
 
                    optname = SHORT_OPTIONS[shortopt]
442
 
                else:
443
 
                    # Single character short options, can be chained,
444
 
                    # and have their value appended to their name
445
 
                    shortopt = a[1:2]
446
 
                    if shortopt not in SHORT_OPTIONS:
447
 
                        # We didn't find the multi-character name, and we
448
 
                        # didn't find the single char name
449
 
                        raise BzrError('unknown short option %r' % a)
450
 
                    optname = SHORT_OPTIONS[shortopt]
451
 
 
452
 
                    if a[2:]:
453
 
                        # There are extra things on this option
454
 
                        # see if it is the value, or if it is another
455
 
                        # short option
456
 
                        optargfn = OPTIONS[optname]
457
 
                        if optargfn is None:
458
 
                            # This option does not take an argument, so the
459
 
                            # next entry is another short option, pack it back
460
 
                            # into the list
461
 
                            argv.insert(0, '-' + a[2:])
462
 
                        else:
463
 
                            # This option takes an argument, so pack it
464
 
                            # into the array
465
 
                            optarg = a[2:]
 
831
                if shortopt not in SHORT_OPTIONS:
 
832
                    bailout('unknown short option %r' % a)
 
833
                optname = SHORT_OPTIONS[shortopt]
466
834
            
467
835
            if optname in opts:
468
836
                # XXX: Do we ever want to support this, e.g. for -r?
469
 
                raise BzrError('repeated option %r' % a)
 
837
                bailout('repeated option %r' % a)
470
838
                
471
839
            optargfn = OPTIONS[optname]
472
840
            if optargfn:
473
841
                if optarg == None:
474
842
                    if not argv:
475
 
                        raise BzrError('option %r needs an argument' % a)
 
843
                        bailout('option %r needs an argument' % a)
476
844
                    else:
477
845
                        optarg = argv.pop(0)
478
846
                opts[optname] = optargfn(optarg)
479
847
            else:
480
848
                if optarg != None:
481
 
                    raise BzrError('option %r takes no argument' % optname)
 
849
                    bailout('option %r takes no argument' % optname)
482
850
                opts[optname] = True
483
851
        else:
484
852
            args.append(a)
487
855
 
488
856
 
489
857
 
 
858
def _match_args(cmd, args):
 
859
    """Check non-option arguments match required pattern.
490
860
 
491
 
def _match_argform(cmd, takes_args, args):
 
861
    >>> _match_args('status', ['asdasdsadasd'])
 
862
    Traceback (most recent call last):
 
863
    ...
 
864
    BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
 
865
    >>> _match_args('add', ['asdasdsadasd'])
 
866
    {'file_list': ['asdasdsadasd']}
 
867
    >>> _match_args('add', 'abc def gj'.split())
 
868
    {'file_list': ['abc', 'def', 'gj']}
 
869
    """
 
870
    # match argument pattern
 
871
    argform = cmd_args.get(cmd, [])
492
872
    argdict = {}
 
873
    # TODO: Need a way to express 'cp SRC... DEST', where it matches
 
874
    # all but one.
493
875
 
494
 
    # step through args and takes_args, allowing appropriate 0-many matches
495
 
    for ap in takes_args:
 
876
    # step through args and argform, allowing appropriate 0-many matches
 
877
    for ap in argform:
496
878
        argname = ap[:-1]
497
879
        if ap[-1] == '?':
498
880
            if args:
505
887
                argdict[argname + '_list'] = None
506
888
        elif ap[-1] == '+':
507
889
            if not args:
508
 
                raise BzrCommandError("command %r needs one or more %s"
 
890
                bailout("command %r needs one or more %s"
509
891
                        % (cmd, argname.upper()))
510
892
            else:
511
893
                argdict[argname + '_list'] = args[:]
512
894
                args = []
513
895
        elif ap[-1] == '$': # all but one
514
896
            if len(args) < 2:
515
 
                raise BzrCommandError("command %r needs one or more %s"
 
897
                bailout("command %r needs one or more %s"
516
898
                        % (cmd, argname.upper()))
517
899
            argdict[argname + '_list'] = args[:-1]
518
900
            args[:-1] = []                
520
902
            # just a plain arg
521
903
            argname = ap
522
904
            if not args:
523
 
                raise BzrCommandError("command %r requires argument %s"
 
905
                bailout("command %r requires argument %s"
524
906
                        % (cmd, argname.upper()))
525
907
            else:
526
908
                argdict[argname] = args.pop(0)
527
909
            
528
910
    if args:
529
 
        raise BzrCommandError("extra argument to command %s: %s"
530
 
                              % (cmd, args[0]))
 
911
        bailout("extra arguments to command %s: %r"
 
912
                % (cmd, args))
531
913
 
532
914
    return argdict
533
915
 
534
916
 
535
917
 
536
 
def apply_profiled(the_callable, *args, **kwargs):
537
 
    import hotshot
538
 
    import tempfile
539
 
    pffileno, pfname = tempfile.mkstemp()
540
 
    try:
541
 
        prof = hotshot.Profile(pfname)
542
 
        try:
543
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
544
 
        finally:
545
 
            prof.close()
 
918
def run_bzr(argv):
 
919
    """Execute a command.
 
920
 
 
921
    This is similar to main(), but without all the trappings for
 
922
    logging and error handling.
 
923
    """
 
924
    try:
 
925
        args, opts = parse_args(argv[1:])
 
926
        if 'help' in opts:
 
927
            # TODO: pass down other arguments in case they asked for
 
928
            # help on a command name?
 
929
            if args:
 
930
                cmd_help(args[0])
 
931
            else:
 
932
                cmd_help()
 
933
            return 0
 
934
        elif 'version' in opts:
 
935
            cmd_version()
 
936
            return 0
 
937
        cmd = args.pop(0)
 
938
    except IndexError:
 
939
        log_error('usage: bzr COMMAND\n')
 
940
        log_error('  try "bzr help"\n')
 
941
        return 1
 
942
 
 
943
    try:
 
944
        cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
 
945
    except KeyError:
 
946
        bailout("unknown command " + `cmd`)
 
947
 
 
948
    # global option
 
949
    if 'profile' in opts:
 
950
        profile = True
 
951
        del opts['profile']
 
952
    else:
 
953
        profile = False
 
954
 
 
955
    # check options are reasonable
 
956
    allowed = cmd_options.get(cmd, [])
 
957
    for oname in opts:
 
958
        if oname not in allowed:
 
959
            bailout("option %r is not allowed for command %r"
 
960
                    % (oname, cmd))
 
961
 
 
962
    # TODO: give an error if there are any mandatory options which are
 
963
    # not specified?  Or maybe there shouldn't be any "mandatory
 
964
    # options" (it is an oxymoron)
 
965
 
 
966
    # mix arguments and options into one dictionary
 
967
    cmdargs = _match_args(cmd, args)
 
968
    for k, v in opts.items():
 
969
        cmdargs[k.replace('-', '_')] = v
 
970
 
 
971
    if profile:
 
972
        import hotshot
 
973
        prof = hotshot.Profile('.bzr.profile')
 
974
        ret = prof.runcall(cmd_handler, **cmdargs) or 0
 
975
        prof.close()
546
976
 
547
977
        import hotshot.stats
548
 
        stats = hotshot.stats.load(pfname)
 
978
        stats = hotshot.stats.load('.bzr.profile')
549
979
        #stats.strip_dirs()
550
980
        stats.sort_stats('time')
551
 
        ## XXX: Might like to write to stderr or the trace file instead but
552
 
        ## print_stats seems hardcoded to stdout
553
981
        stats.print_stats(20)
554
982
 
555
983
        return ret
556
 
    finally:
557
 
        os.close(pffileno)
558
 
        os.remove(pfname)
559
 
 
560
 
 
561
 
def run_bzr(argv):
562
 
    """Execute a command.
563
 
 
564
 
    This is similar to main(), but without all the trappings for
565
 
    logging and error handling.  
566
 
    
567
 
    argv
568
 
       The command-line arguments, without the program name from argv[0]
569
 
    
570
 
    Returns a command status or raises an exception.
571
 
 
572
 
    Special master options: these must come before the command because
573
 
    they control how the command is interpreted.
574
 
 
575
 
    --no-plugins
576
 
        Do not load plugin modules at all
577
 
 
578
 
    --builtin
579
 
        Only use builtin commands.  (Plugins are still allowed to change
580
 
        other behaviour.)
581
 
 
582
 
    --profile
583
 
        Run under the Python profiler.
584
 
    """
585
 
    
586
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
587
 
 
588
 
    opt_profile = opt_no_plugins = opt_builtin = False
589
 
 
590
 
    # --no-plugins is handled specially at a very early stage. We need
591
 
    # to load plugins before doing other command parsing so that they
592
 
    # can override commands, but this needs to happen first.
593
 
 
594
 
    for a in argv:
595
 
        if a == '--profile':
596
 
            opt_profile = True
597
 
        elif a == '--no-plugins':
598
 
            opt_no_plugins = True
599
 
        elif a == '--builtin':
600
 
            opt_builtin = True
601
 
        else:
602
 
            break
603
 
        argv.remove(a)
604
 
 
605
 
    if (not argv) or (argv[0] == '--help'):
606
 
        from bzrlib.help import help
607
 
        if len(argv) > 1:
608
 
            help(argv[1])
609
 
        else:
610
 
            help()
611
 
        return 0
612
 
 
613
 
    if argv[0] == '--version':
614
 
        from bzrlib.builtins import show_version
615
 
        show_version()
616
 
        return 0
617
 
        
618
 
    if not opt_no_plugins:
619
 
        from bzrlib.plugin import load_plugins
620
 
        load_plugins()
621
 
 
622
 
    cmd = str(argv.pop(0))
623
 
 
624
 
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
625
 
 
626
 
    if opt_profile:
627
 
        ret = apply_profiled(cmd_obj.run_argv, argv)
628
984
    else:
629
 
        ret = cmd_obj.run_argv(argv)
630
 
    return ret or 0
 
985
        return cmd_handler(**cmdargs) or 0
 
986
 
631
987
 
632
988
 
633
989
def main(argv):
634
 
    import bzrlib.ui
635
 
    bzrlib.trace.log_startup(argv)
636
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
637
 
 
 
990
    ## TODO: Handle command-line options; probably know what options are valid for
 
991
    ## each command
 
992
 
 
993
    ## TODO: If the arguments are wrong, give a usage message rather
 
994
    ## than just a backtrace.
 
995
 
 
996
    bzrlib.trace.create_tracefile(argv)
 
997
    
638
998
    try:
639
 
        try:
640
 
            return run_bzr(argv[1:])
641
 
        finally:
642
 
            # do this here inside the exception wrappers to catch EPIPE
643
 
            sys.stdout.flush()
644
 
    except BzrCommandError, e:
645
 
        # command line syntax error, etc
646
 
        log_error(str(e))
647
 
        return 1
 
999
        ret = run_bzr(argv)
 
1000
        return ret
648
1001
    except BzrError, e:
649
 
        bzrlib.trace.log_exception()
 
1002
        log_error('bzr: error: ' + e.args[0] + '\n')
 
1003
        if len(e.args) > 1:
 
1004
            for h in e.args[1]:
 
1005
                log_error('  ' + h + '\n')
 
1006
        traceback.print_exc(None, bzrlib.trace._tracefile)
 
1007
        log_error('(see $HOME/.bzr.log for debug information)\n')
650
1008
        return 1
651
 
    except AssertionError, e:
652
 
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
653
 
        return 3
654
 
    except KeyboardInterrupt, e:
655
 
        bzrlib.trace.note('interrupted')
656
 
        return 2
657
1009
    except Exception, e:
658
 
        import errno
659
 
        if (isinstance(e, IOError) 
660
 
            and hasattr(e, 'errno')
661
 
            and e.errno == errno.EPIPE):
662
 
            bzrlib.trace.note('broken pipe')
663
 
            return 2
664
 
        else:
665
 
            bzrlib.trace.log_exception()
666
 
            return 2
 
1010
        log_error('bzr: exception: %s\n' % e)
 
1011
        log_error('(see $HOME/.bzr.log for debug information)\n')
 
1012
        traceback.print_exc(None, bzrlib.trace._tracefile)
 
1013
        ## traceback.print_exc(None, sys.stderr)
 
1014
        return 1
 
1015
 
 
1016
    # TODO: Maybe nicer handling of IOError?
 
1017
 
667
1018
 
668
1019
 
669
1020
if __name__ == '__main__':
670
1021
    sys.exit(main(sys.argv))
 
1022
    ##import profile
 
1023
    ##profile.run('main(sys.argv)')
 
1024