~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-24 00:44:18 UTC
  • Revision ID: mbp@sourcefrog.net-20050324004418-b4a050f656c07f5f
show space usage for various stores in the info command

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
 
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
28
 
# the profile output behind so it can be interactively examined?
29
 
 
30
 
import sys
31
 
import os
32
 
from warnings import warn
33
 
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
* No handling of subdirectories, symlinks or any non-text files.
 
29
 
 
30
* Insufficient error handling.
 
31
 
 
32
* Many commands unimplemented or partially implemented.
 
33
 
 
34
* Space-inefficient storage.
 
35
 
 
36
* No merge operators yet.
 
37
 
 
38
Interesting commands::
 
39
 
 
40
  bzr help
 
41
       Show summary help screen
 
42
  bzr version
 
43
       Show software version/licence/non-warranty.
 
44
  bzr init
 
45
       Start versioning the current directory
 
46
  bzr add FILE...
 
47
       Make files versioned.
 
48
  bzr log
 
49
       Show revision history.
 
50
  bzr diff
 
51
       Show changes from last revision to working copy.
 
52
  bzr commit -m 'MESSAGE'
 
53
       Store current state as new revision.
 
54
  bzr export REVNO DESTINATION
 
55
       Export the branch state at a previous version.
 
56
  bzr status
 
57
       Show summary of pending changes.
 
58
  bzr remove FILE...
 
59
       Make a file not versioned.
 
60
  bzr info
 
61
       Show statistics about this branch.
 
62
"""
 
63
 
 
64
 
 
65
 
 
66
__copyright__ = "Copyright 2005 Canonical Development Ltd."
 
67
__author__ = "Martin Pool <mbp@canonical.com>"
 
68
__docformat__ = "restructuredtext en"
 
69
__version__ = '0.0.0'
 
70
 
 
71
 
 
72
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
 
73
import traceback, socket, fnmatch, difflib
 
74
from os import path
 
75
from sets import Set
 
76
from pprint import pprint
 
77
from stat import *
 
78
from glob import glob
34
79
 
35
80
import bzrlib
36
 
import bzrlib.trace
37
 
from bzrlib.trace import mutter, note, log_error, warning
38
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
39
 
from bzrlib.revisionspec import RevisionSpec
40
 
from bzrlib import BZRDIR
41
 
from bzrlib.option import Option
42
 
 
43
 
plugin_cmds = {}
44
 
 
45
 
 
46
 
def register_command(cmd):
47
 
    "Utility function to help register a command"
48
 
    global plugin_cmds
49
 
    k = cmd.__name__
50
 
    if k.startswith("cmd_"):
51
 
        k_unsquished = _unsquish_command_name(k)
52
 
    else:
53
 
        k_unsquished = k
54
 
    if not plugin_cmds.has_key(k_unsquished):
55
 
        plugin_cmds[k_unsquished] = cmd
56
 
        mutter('registered plugin command %s', k_unsquished)      
57
 
    else:
58
 
        log_error('Two plugins defined the same command: %r' % k)
59
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
60
 
 
61
 
 
62
 
def _squish_command_name(cmd):
63
 
    return 'cmd_' + cmd.replace('-', '_')
64
 
 
65
 
 
66
 
def _unsquish_command_name(cmd):
67
 
    assert cmd.startswith("cmd_")
68
 
    return cmd[4:].replace('_','-')
69
 
 
70
 
 
71
 
def _builtin_commands():
72
 
    import bzrlib.builtins
73
 
    r = {}
74
 
    builtins = bzrlib.builtins.__dict__
75
 
    for name in builtins:
76
 
        if name.startswith("cmd_"):
77
 
            real_name = _unsquish_command_name(name)        
78
 
            r[real_name] = builtins[name]
79
 
    return r
80
 
 
81
 
            
82
 
 
83
 
def builtin_command_names():
84
 
    """Return list of builtin command names."""
85
 
    return _builtin_commands().keys()
86
 
    
87
 
 
88
 
def plugin_command_names():
89
 
    return plugin_cmds.keys()
90
 
 
91
 
 
92
 
def _get_cmd_dict(plugins_override=True):
93
 
    """Return name->class mapping for all commands."""
94
 
    d = _builtin_commands()
95
 
    if plugins_override:
96
 
        d.update(plugin_cmds)
97
 
    return d
98
 
 
99
 
    
100
 
def get_all_cmds(plugins_override=True):
101
 
    """Return canonical name and class for all registered commands."""
102
 
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
103
 
        yield k,v
104
 
 
105
 
 
106
 
def get_cmd_object(cmd_name, plugins_override=True):
107
 
    """Return the canonical name and command class for a command.
108
 
 
109
 
    plugins_override
110
 
        If true, plugin commands can override builtins.
111
 
    """
112
 
    from bzrlib.externalcommand import ExternalCommand
113
 
 
114
 
    cmd_name = str(cmd_name)            # not unicode
115
 
 
116
 
    # first look up this command under the specified name
117
 
    cmds = _get_cmd_dict(plugins_override=plugins_override)
118
 
    try:
119
 
        return cmds[cmd_name]()
 
81
from bzrlib.store import ImmutableStore
 
82
from bzrlib.trace import mutter, note, log_error
 
83
from bzrlib.errors import bailout, BzrError
 
84
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
 
85
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
 
86
from bzrlib.revision import Revision
 
87
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
 
88
     format_date
 
89
 
 
90
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
 
91
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
 
92
 
 
93
## standard representation
 
94
NONE_STRING = '(none)'
 
95
EMPTY = 'empty'
 
96
 
 
97
 
 
98
## TODO: Perhaps a different version of inventory commands that
 
99
## returns iterators...
 
100
 
 
101
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
 
102
 
 
103
## TODO: Some kind of locking on branches.  Perhaps there should be a
 
104
## parameter to the branch object saying whether we want a read or
 
105
## write lock; release it from destructor.  Perhaps don't even need a
 
106
## read lock to look at immutable objects?
 
107
 
 
108
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
 
109
## to compare output?
 
110
 
 
111
## TODO: Some kind of global code to generate the right Branch object
 
112
## to work on.  Almost, but not quite all, commands need one, and it
 
113
## can be taken either from their parameters or their working
 
114
## directory.
 
115
 
 
116
## TODO: rename command, needed soon: check destination doesn't exist
 
117
## either in working copy or tree; move working copy; update
 
118
## inventory; write out
 
119
 
 
120
## TODO: move command; check destination is a directory and will not
 
121
## clash; move it.
 
122
 
 
123
## TODO: command to show renames, one per line, as to->from
 
124
 
 
125
 
 
126
 
 
127
 
 
128
def cmd_status(all=False):
 
129
    """Display status summary.
 
130
 
 
131
    For each file there is a single line giving its file state and name.
 
132
    The name is that in the current revision unless it is deleted or
 
133
    missing, in which case the old name is shown.
 
134
 
 
135
    :todo: Don't show unchanged files unless ``--all`` is given?
 
136
    """
 
137
    Branch('.').show_status(show_all=all)
 
138
 
 
139
 
 
140
 
 
141
######################################################################
 
142
# examining history
 
143
def cmd_get_revision(revision_id):
 
144
    Branch('.').get_revision(revision_id).write_xml(sys.stdout)
 
145
 
 
146
 
 
147
def cmd_get_file_text(text_id):
 
148
    """Get contents of a file by hash."""
 
149
    sf = Branch('.').text_store[text_id]
 
150
    pumpfile(sf, sys.stdout)
 
151
 
 
152
 
 
153
 
 
154
######################################################################
 
155
# commands
 
156
    
 
157
 
 
158
def cmd_revno():
 
159
    """Show number of revisions on this branch"""
 
160
    print Branch('.').revno()
 
161
    
 
162
 
 
163
    
 
164
def cmd_add(file_list, verbose=False):
 
165
    """Add specified files or directories.
 
166
 
 
167
    In non-recursive mode, all the named items are added, regardless
 
168
    of whether they were previously ignored.  A warning is given if
 
169
    any of the named files are already versioned.
 
170
 
 
171
    In recursive mode (the default), files are treated the same way
 
172
    but the behaviour for directories is different.  Directories that
 
173
    are already versioned do not give a warning.  All directories,
 
174
    whether already versioned or not, are searched for files or
 
175
    subdirectories that are neither versioned or ignored, and these
 
176
    are added.  This search proceeds recursively into versioned
 
177
    directories.
 
178
 
 
179
    Therefore simply saying 'bzr add .' will version all files that
 
180
    are currently unknown.
 
181
    """
 
182
    if True:
 
183
        bzrlib.add.smart_add(file_list, verbose)
 
184
    else:
 
185
        # old way
 
186
        assert file_list
 
187
        b = Branch(file_list[0], find_root=True)
 
188
        b.add([b.relpath(f) for f in file_list], verbose=verbose)
 
189
 
 
190
    
 
191
 
 
192
def cmd_relpath(filename):
 
193
    print Branch(filename).relpath(filename)
 
194
 
 
195
 
 
196
def cmd_inventory(revision=None):
 
197
    """Show inventory of the current working copy."""
 
198
    ## TODO: Also optionally show a previous inventory
 
199
    ## TODO: Format options
 
200
    b = Branch('.')
 
201
    if revision == None:
 
202
        inv = b.read_working_inventory()
 
203
    else:
 
204
        inv = b.get_revision_inventory(b.lookup_revision(revision))
 
205
        
 
206
    for path, entry in inv.iter_entries():
 
207
        print '%-50s %s' % (entry.file_id, path)
 
208
 
 
209
 
 
210
 
 
211
def cmd_info():
 
212
    import info
 
213
    info.show_info(Branch('.'))        
 
214
    
 
215
 
 
216
 
 
217
def cmd_remove(file_list, verbose=False):
 
218
    b = Branch(file_list[0])
 
219
    b.remove([b.relpath(f) for f in file_list], verbose=verbose)
 
220
 
 
221
 
 
222
 
 
223
def cmd_file_id(filename):
 
224
    b = Branch(filename)
 
225
    i = b.inventory.path2id(b.relpath(filename))
 
226
    if i is None:
 
227
        bailout("%s is not a versioned file" % filename)
 
228
    else:
 
229
        print i
 
230
 
 
231
 
 
232
def cmd_find_filename(fileid):
 
233
    n = find_filename(fileid)
 
234
    if n is None:
 
235
        bailout("%s is not a live file id" % fileid)
 
236
    else:
 
237
        print n
 
238
 
 
239
 
 
240
def cmd_revision_history():
 
241
    for patchid in Branch('.').revision_history():
 
242
        print patchid
 
243
 
 
244
 
 
245
 
 
246
def cmd_init():
 
247
    # TODO: Check we're not already in a working directory?  At the
 
248
    # moment you'll get an ugly error.
 
249
    
 
250
    # TODO: What if we're in a subdirectory of a branch?  Would like
 
251
    # to allow that, but then the parent may need to understand that
 
252
    # the children have disappeared, or should they be versioned in
 
253
    # both?
 
254
 
 
255
    # TODO: Take an argument/option for branch name.
 
256
    Branch('.', init=True)
 
257
 
 
258
 
 
259
def cmd_diff(revision=None):
 
260
    """Show diff from basis to working copy.
 
261
 
 
262
    :todo: Take one or two revision arguments, look up those trees,
 
263
           and diff them.
 
264
 
 
265
    :todo: Allow diff across branches.
 
266
 
 
267
    :todo: Mangle filenames in diff to be more relevant.
 
268
 
 
269
    :todo: Shouldn't be in the cmd function.
 
270
    """
 
271
 
 
272
    b = Branch('.')
 
273
 
 
274
    if revision == None:
 
275
        old_tree = b.basis_tree()
 
276
    else:
 
277
        old_tree = b.revision_tree(b.lookup_revision(revision))
 
278
        
 
279
    new_tree = b.working_tree()
 
280
    old_inv = old_tree.inventory
 
281
    new_inv = new_tree.inventory
 
282
 
 
283
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
 
284
    old_label = ''
 
285
    new_label = ''
 
286
 
 
287
    DEVNULL = '/dev/null'
 
288
    # Windows users, don't panic about this filename -- it is a
 
289
    # special signal to GNU patch that the file should be created or
 
290
    # deleted respectively.
 
291
 
 
292
    # TODO: Generation of pseudo-diffs for added/deleted files could
 
293
    # be usefully made into a much faster special case.
 
294
 
 
295
    # TODO: Better to return them in sorted order I think.
 
296
    
 
297
    for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
 
298
        d = None
 
299
 
 
300
        # Don't show this by default; maybe do it if an option is passed
 
301
        # idlabel = '      {%s}' % fid
 
302
        idlabel = ''
 
303
 
 
304
        # FIXME: Something about the diff format makes patch unhappy
 
305
        # with newly-added files.
 
306
 
 
307
        def diffit(*a, **kw):
 
308
            sys.stdout.writelines(difflib.unified_diff(*a, **kw))
 
309
            print
 
310
        
 
311
        if file_state in ['.', '?', 'I']:
 
312
            continue
 
313
        elif file_state == 'A':
 
314
            print '*** added %s %r' % (kind, new_name)
 
315
            if kind == 'file':
 
316
                diffit([],
 
317
                       new_tree.get_file(fid).readlines(),
 
318
                       fromfile=DEVNULL,
 
319
                       tofile=new_label + new_name + idlabel)
 
320
        elif file_state == 'D':
 
321
            assert isinstance(old_name, types.StringTypes)
 
322
            print '*** deleted %s %r' % (kind, old_name)
 
323
            if kind == 'file':
 
324
                diffit(old_tree.get_file(fid).readlines(), [],
 
325
                       fromfile=old_label + old_name + idlabel,
 
326
                       tofile=DEVNULL)
 
327
        elif file_state in ['M', 'R']:
 
328
            if file_state == 'M':
 
329
                assert kind == 'file'
 
330
                assert old_name == new_name
 
331
                print '*** modified %s %r' % (kind, new_name)
 
332
            elif file_state == 'R':
 
333
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
 
334
 
 
335
            if kind == 'file':
 
336
                diffit(old_tree.get_file(fid).readlines(),
 
337
                       new_tree.get_file(fid).readlines(),
 
338
                       fromfile=old_label + old_name + idlabel,
 
339
                       tofile=new_label + new_name)
 
340
        else:
 
341
            bailout("can't represent state %s {%s}" % (file_state, fid))
 
342
 
 
343
 
 
344
 
 
345
def cmd_root(filename=None):
 
346
    """Print the branch root."""
 
347
    print bzrlib.branch.find_branch_root(filename)
 
348
    
 
349
 
 
350
def cmd_log(timezone='original'):
 
351
    """Show log of this branch.
 
352
 
 
353
    :todo: Options for utc; to show ids; to limit range; etc.
 
354
    """
 
355
    Branch('.').write_log(show_timezone=timezone)
 
356
 
 
357
 
 
358
def cmd_ls(revision=None, verbose=False):
 
359
    """List files in a tree.
 
360
 
 
361
    :todo: Take a revision or remote path and list that tree instead.
 
362
    """
 
363
    b = Branch('.')
 
364
    if revision == None:
 
365
        tree = b.working_tree()
 
366
    else:
 
367
        tree = b.revision_tree(b.lookup_revision(revision))
 
368
        
 
369
    for fp, fc, kind, fid in tree.list_files():
 
370
        if verbose:
 
371
            if kind == 'directory':
 
372
                kindch = '/'
 
373
            elif kind == 'file':
 
374
                kindch = ''
 
375
            else:
 
376
                kindch = '???'
 
377
                
 
378
            print '%-8s %s%s' % (fc, fp, kindch)
 
379
        else:
 
380
            print fp
 
381
    
 
382
    
 
383
 
 
384
def cmd_unknowns():
 
385
    """List unknown files"""
 
386
    for f in Branch('.').unknowns():
 
387
        print quotefn(f)
 
388
 
 
389
 
 
390
def cmd_lookup_revision(revno):
 
391
    try:
 
392
        revno = int(revno)
 
393
    except ValueError:
 
394
        bailout("usage: lookup-revision REVNO",
 
395
                ["REVNO is a non-negative revision number for this branch"])
 
396
 
 
397
    print Branch('.').lookup_revision(revno) or NONE_STRING
 
398
 
 
399
 
 
400
 
 
401
def cmd_export(revno, dest):
 
402
    """Export past revision to destination directory."""
 
403
    b = Branch('.')
 
404
    rh = b.lookup_revision(int(revno))
 
405
    t = b.revision_tree(rh)
 
406
    t.export(dest)
 
407
 
 
408
 
 
409
 
 
410
######################################################################
 
411
# internal/test commands
 
412
 
 
413
 
 
414
def cmd_uuid():
 
415
    """Print a newly-generated UUID."""
 
416
    print bzrlib.osutils.uuid()
 
417
 
 
418
 
 
419
 
 
420
def cmd_local_time_offset():
 
421
    print bzrlib.osutils.local_time_offset()
 
422
 
 
423
 
 
424
 
 
425
def cmd_commit(message=None, verbose=False):
 
426
    if not message:
 
427
        bailout("please specify a commit message")
 
428
    Branch('.').commit(message, verbose=verbose)
 
429
 
 
430
 
 
431
def cmd_check():
 
432
    """Check consistency of the branch."""
 
433
    check()
 
434
 
 
435
 
 
436
def cmd_is(pred, *rest):
 
437
    """Test whether PREDICATE is true."""
 
438
    try:
 
439
        cmd_handler = globals()['assert_' + pred.replace('-', '_')]
120
440
    except KeyError:
121
 
        pass
122
 
 
123
 
    # look for any command which claims this as an alias
124
 
    for real_cmd_name, cmd_class in cmds.iteritems():
125
 
        if cmd_name in cmd_class.aliases:
126
 
            return cmd_class()
127
 
 
128
 
    cmd_obj = ExternalCommand.find_command(cmd_name)
129
 
    if cmd_obj:
130
 
        return cmd_obj
131
 
 
132
 
    raise BzrCommandError("unknown command %r" % cmd_name)
133
 
 
134
 
 
135
 
class Command(object):
136
 
    """Base class for commands.
137
 
 
138
 
    Commands are the heart of the command-line bzr interface.
139
 
 
140
 
    The command object mostly handles the mapping of command-line
141
 
    parameters into one or more bzrlib operations, and of the results
142
 
    into textual output.
143
 
 
144
 
    Commands normally don't have any state.  All their arguments are
145
 
    passed in to the run method.  (Subclasses may take a different
146
 
    policy if the behaviour of the instance needs to depend on e.g. a
147
 
    shell plugin and not just its Python class.)
148
 
 
149
 
    The docstring for an actual command should give a single-line
150
 
    summary, then a complete description of the command.  A grammar
151
 
    description will be inserted.
152
 
 
153
 
    aliases
154
 
        Other accepted names for this command.
155
 
 
156
 
    takes_args
157
 
        List of argument forms, marked with whether they are optional,
158
 
        repeated, etc.
159
 
 
160
 
    takes_options
161
 
        List of options that may be given for this command.  These can
162
 
        be either strings, referring to globally-defined options,
163
 
        or option objects.  Retrieve through options().
164
 
 
165
 
    hidden
166
 
        If true, this command isn't advertised.  This is typically
167
 
        for commands intended for expert users.
168
 
    """
169
 
    aliases = []
170
 
    takes_args = []
171
 
    takes_options = []
172
 
 
173
 
    hidden = False
174
 
    
175
 
    def __init__(self):
176
 
        """Construct an instance of this command."""
177
 
        if self.__doc__ == Command.__doc__:
178
 
            warn("No help message set for %r" % self)
179
 
 
180
 
    def options(self):
181
 
        """Return dict of valid options for this command.
182
 
 
183
 
        Maps from long option name to option object."""
184
 
        r = dict()
185
 
        r['help'] = Option.OPTIONS['help']
186
 
        for o in self.takes_options:
187
 
            if not isinstance(o, Option):
188
 
                o = Option.OPTIONS[o]
189
 
            r[o.name] = o
190
 
        return r
191
 
 
192
 
    def run_argv(self, argv):
193
 
        """Parse command line and run."""
194
 
        args, opts = parse_args(self, argv)
195
 
        if 'help' in opts:  # e.g. bzr add --help
196
 
            from bzrlib.help import help_on_command
197
 
            help_on_command(self.name())
198
 
            return 0
199
 
        # XXX: This should be handled by the parser
200
 
        allowed_names = self.options().keys()
201
 
        for oname in opts:
202
 
            if oname not in allowed_names:
203
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
204
 
                                      % (oname, self.name()))
205
 
        # mix arguments and options into one dictionary
206
 
        cmdargs = _match_argform(self.name(), self.takes_args, args)
207
 
        cmdopts = {}
208
 
        for k, v in opts.items():
209
 
            cmdopts[k.replace('-', '_')] = v
210
 
 
211
 
        all_cmd_args = cmdargs.copy()
212
 
        all_cmd_args.update(cmdopts)
213
 
 
214
 
        return self.run(**all_cmd_args)
215
 
 
216
 
    
217
 
    def run(self):
218
 
        """Actually run the command.
219
 
 
220
 
        This is invoked with the options and arguments bound to
221
 
        keyword parameters.
222
 
 
223
 
        Return 0 or None if the command was successful, or a non-zero
224
 
        shell error code if not.  It's OK for this method to allow
225
 
        an exception to raise up.
226
 
        """
227
 
        raise NotImplementedError()
228
 
 
229
 
 
230
 
    def help(self):
231
 
        """Return help message for this class."""
232
 
        if self.__doc__ is Command.__doc__:
233
 
            return None
234
 
        return getdoc(self)
235
 
 
236
 
    def name(self):
237
 
        return _unsquish_command_name(self.__class__.__name__)
238
 
 
239
 
 
240
 
def parse_spec(spec):
241
 
    """
242
 
    >>> parse_spec(None)
243
 
    [None, None]
244
 
    >>> parse_spec("./")
245
 
    ['./', None]
246
 
    >>> parse_spec("../@")
247
 
    ['..', -1]
248
 
    >>> parse_spec("../f/@35")
249
 
    ['../f', 35]
250
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
251
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
252
 
    """
253
 
    if spec is None:
254
 
        return [None, None]
255
 
    if '/@' in spec:
256
 
        parsed = spec.split('/@')
257
 
        assert len(parsed) == 2
258
 
        if parsed[1] == "":
259
 
            parsed[1] = -1
 
441
        bailout("unknown predicate: %s" % quotefn(pred))
 
442
        
 
443
    try:
 
444
        cmd_handler(*rest)
 
445
    except BzrCheckError:
 
446
        # by default we don't print the message so that this can
 
447
        # be used from shell scripts without producing noise
 
448
        sys.exit(1)
 
449
 
 
450
 
 
451
def cmd_username():
 
452
    print bzrlib.osutils.username()
 
453
 
 
454
 
 
455
def cmd_user_email():
 
456
    print bzrlib.osutils.user_email()
 
457
 
 
458
 
 
459
def cmd_gen_revision_id():
 
460
    import time
 
461
    print bzrlib.branch._gen_revision_id(time.time())
 
462
 
 
463
 
 
464
def cmd_selftest(verbose=False):
 
465
    """Run internal test suite"""
 
466
    ## -v, if present, is seen by doctest; the argument is just here
 
467
    ## so our parser doesn't complain
 
468
 
 
469
    ## TODO: --verbose option
 
470
 
 
471
    failures, tests = 0, 0
 
472
    
 
473
    import doctest, bzrlib.store, bzrlib.tests
 
474
    bzrlib.trace.verbose = False
 
475
 
 
476
    for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
 
477
        bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
 
478
        mf, mt = doctest.testmod(m)
 
479
        failures += mf
 
480
        tests += mt
 
481
        print '%-40s %3d tests' % (m.__name__, mt),
 
482
        if mf:
 
483
            print '%3d FAILED!' % mf
260
484
        else:
261
 
            try:
262
 
                parsed[1] = int(parsed[1])
263
 
            except ValueError:
264
 
                pass # We can allow stuff like ./@revid:blahblahblah
265
 
            else:
266
 
                assert parsed[1] >=0
 
485
            print
 
486
 
 
487
    print '%-40s %3d tests' % ('total', tests),
 
488
    if failures:
 
489
        print '%3d FAILED!' % failures
267
490
    else:
268
 
        parsed = [spec, None]
269
 
    return parsed
270
 
 
271
 
def parse_args(command, argv):
 
491
        print
 
492
 
 
493
 
 
494
 
 
495
# deprecated
 
496
cmd_doctest = cmd_selftest
 
497
 
 
498
 
 
499
######################################################################
 
500
# help
 
501
 
 
502
 
 
503
def cmd_help():
 
504
    # TODO: Specific help for particular commands
 
505
    print __doc__
 
506
 
 
507
 
 
508
def cmd_version():
 
509
    print "bzr (bazaar-ng) %s" % __version__
 
510
    print __copyright__
 
511
    print "http://bazaar-ng.org/"
 
512
    print
 
513
    print \
 
514
"""bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and
 
515
you may use, modify and redistribute it under the terms of the GNU 
 
516
General Public License version 2 or later."""
 
517
 
 
518
 
 
519
def cmd_rocks():
 
520
    """Statement of optimism."""
 
521
    print "it sure does!"
 
522
 
 
523
 
 
524
 
 
525
######################################################################
 
526
# main routine
 
527
 
 
528
 
 
529
# list of all available options; the rhs can be either None for an
 
530
# option that takes no argument, or a constructor function that checks
 
531
# the type.
 
532
OPTIONS = {
 
533
    'all':                    None,
 
534
    'help':                   None,
 
535
    'message':                unicode,
 
536
    'revision':               int,
 
537
    'show-ids':               None,
 
538
    'timezone':               str,
 
539
    'verbose':                None,
 
540
    'version':                None,
 
541
    }
 
542
 
 
543
SHORT_OPTIONS = {
 
544
    'm':                      'message',
 
545
    'r':                      'revision',
 
546
    'v':                      'verbose',
 
547
}
 
548
 
 
549
# List of options that apply to particular commands; commands not
 
550
# listed take none.
 
551
cmd_options = {
 
552
    'add':                    ['verbose'],
 
553
    'commit':                 ['message', 'verbose'],
 
554
    'diff':                   ['revision'],
 
555
    'inventory':              ['revision'],
 
556
    'log':                    ['show-ids', 'timezone'],
 
557
    'ls':                     ['revision', 'verbose'],
 
558
    'remove':                 ['verbose'],
 
559
    'status':                 ['all'],
 
560
    }
 
561
 
 
562
 
 
563
cmd_args = {
 
564
    'init':                   [],
 
565
    'add':                    ['file+'],
 
566
    'commit':                 [],
 
567
    'diff':                   [],
 
568
    'file-id':                ['filename'],
 
569
    'root':                   ['filename?'],
 
570
    'relpath':                ['filename'],
 
571
    'get-file-text':          ['text_id'],
 
572
    'get-inventory':          ['inventory_id'],
 
573
    'get-revision':           ['revision_id'],
 
574
    'get-revision-inventory': ['revision_id'],
 
575
    'log':                    [],
 
576
    'lookup-revision':        ['revno'],
 
577
    'export':                 ['revno', 'dest'],
 
578
    'remove':                 ['file+'],
 
579
    'status':                 [],
 
580
    }
 
581
 
 
582
 
 
583
def parse_args(argv):
272
584
    """Parse command line.
273
585
    
274
586
    Arguments and options are parsed at this level before being passed
275
587
    down to specific command handlers.  This routine knows, from a
276
588
    lookup table, something about the available options, what optargs
277
589
    they take, and which commands will accept them.
 
590
 
 
591
    >>> parse_args('--help'.split())
 
592
    ([], {'help': True})
 
593
    >>> parse_args('--version'.split())
 
594
    ([], {'version': True})
 
595
    >>> parse_args('status --all'.split())
 
596
    (['status'], {'all': True})
 
597
    >>> parse_args('commit --message=biter'.split())
 
598
    (['commit'], {'message': u'biter'})
278
599
    """
279
 
    # TODO: chop up this beast; make it a method of the Command
280
600
    args = []
281
601
    opts = {}
282
602
 
283
 
    cmd_options = command.options()
284
 
    argsover = False
 
603
    # TODO: Maybe handle '--' to end options?
 
604
 
285
605
    while argv:
286
606
        a = argv.pop(0)
287
 
        if argsover:
288
 
            args.append(a)
289
 
            continue
290
 
        elif a == '--':
291
 
            # We've received a standalone -- No more flags
292
 
            argsover = True
293
 
            continue
294
607
        if a[0] == '-':
295
 
            # option names must not be unicode
296
 
            a = str(a)
297
608
            optarg = None
298
609
            if a[1] == '-':
299
610
                mutter("  got option %r" % a)
301
612
                    optname, optarg = a[2:].split('=', 1)
302
613
                else:
303
614
                    optname = a[2:]
304
 
                if optname not in cmd_options:
305
 
                    raise BzrCommandError('unknown long option %r for command %s' 
306
 
                            % (a, command.name))
 
615
                if optname not in OPTIONS:
 
616
                    bailout('unknown long option %r' % a)
307
617
            else:
308
618
                shortopt = a[1:]
309
 
                if shortopt in Option.SHORT_OPTIONS:
310
 
                    # Multi-character options must have a space to delimit
311
 
                    # their value
312
 
                    # ^^^ what does this mean? mbp 20051014
313
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
314
 
                else:
315
 
                    # Single character short options, can be chained,
316
 
                    # and have their value appended to their name
317
 
                    shortopt = a[1:2]
318
 
                    if shortopt not in Option.SHORT_OPTIONS:
319
 
                        # We didn't find the multi-character name, and we
320
 
                        # didn't find the single char name
321
 
                        raise BzrError('unknown short option %r' % a)
322
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
323
 
 
324
 
                    if a[2:]:
325
 
                        # There are extra things on this option
326
 
                        # see if it is the value, or if it is another
327
 
                        # short option
328
 
                        optargfn = Option.OPTIONS[optname].type
329
 
                        if optargfn is None:
330
 
                            # This option does not take an argument, so the
331
 
                            # next entry is another short option, pack it back
332
 
                            # into the list
333
 
                            argv.insert(0, '-' + a[2:])
334
 
                        else:
335
 
                            # This option takes an argument, so pack it
336
 
                            # into the array
337
 
                            optarg = a[2:]
 
619
                if shortopt not in SHORT_OPTIONS:
 
620
                    bailout('unknown short option %r' % a)
 
621
                optname = SHORT_OPTIONS[shortopt]
338
622
            
339
623
            if optname in opts:
340
624
                # XXX: Do we ever want to support this, e.g. for -r?
341
 
                raise BzrError('repeated option %r' % a)
 
625
                bailout('repeated option %r' % a)
342
626
                
343
 
            option_obj = cmd_options[optname]
344
 
            optargfn = option_obj.type
 
627
            optargfn = OPTIONS[optname]
345
628
            if optargfn:
346
629
                if optarg == None:
347
630
                    if not argv:
348
 
                        raise BzrError('option %r needs an argument' % a)
 
631
                        bailout('option %r needs an argument' % a)
349
632
                    else:
350
633
                        optarg = argv.pop(0)
351
634
                opts[optname] = optargfn(optarg)
 
635
                mutter("    option argument %r" % opts[optname])
352
636
            else:
353
637
                if optarg != None:
354
 
                    raise BzrError('option %r takes no argument' % optname)
 
638
                    bailout('option %r takes no argument' % optname)
355
639
                opts[optname] = True
356
640
        else:
357
641
            args.append(a)
 
642
 
358
643
    return args, opts
359
644
 
360
645
 
361
 
def _match_argform(cmd, takes_args, args):
 
646
 
 
647
def _match_args(cmd, args):
 
648
    """Check non-option arguments match required pattern.
 
649
 
 
650
    >>> _match_args('status', ['asdasdsadasd'])
 
651
    Traceback (most recent call last):
 
652
    ...
 
653
    BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
 
654
    >>> _match_args('add', ['asdasdsadasd'])
 
655
    {'file_list': ['asdasdsadasd']}
 
656
    >>> _match_args('add', 'abc def gj'.split())
 
657
    {'file_list': ['abc', 'def', 'gj']}
 
658
    """
 
659
    # match argument pattern
 
660
    argform = cmd_args.get(cmd, [])
362
661
    argdict = {}
 
662
    # TODO: Need a way to express 'cp SRC... DEST', where it matches
 
663
    # all but one.
363
664
 
364
 
    # step through args and takes_args, allowing appropriate 0-many matches
365
 
    for ap in takes_args:
 
665
    # step through args and argform, allowing appropriate 0-many matches
 
666
    for ap in argform:
366
667
        argname = ap[:-1]
367
668
        if ap[-1] == '?':
368
669
            if args:
369
670
                argdict[argname] = args.pop(0)
370
 
        elif ap[-1] == '*': # all remaining arguments
371
 
            if args:
372
 
                argdict[argname + '_list'] = args[:]
373
 
                args = []
374
 
            else:
375
 
                argdict[argname + '_list'] = None
 
671
        elif ap[-1] == '*':
 
672
            assert 0
376
673
        elif ap[-1] == '+':
377
674
            if not args:
378
 
                raise BzrCommandError("command %r needs one or more %s"
 
675
                bailout("command %r needs one or more %s"
379
676
                        % (cmd, argname.upper()))
380
677
            else:
381
678
                argdict[argname + '_list'] = args[:]
382
679
                args = []
383
 
        elif ap[-1] == '$': # all but one
384
 
            if len(args) < 2:
385
 
                raise BzrCommandError("command %r needs one or more %s"
386
 
                        % (cmd, argname.upper()))
387
 
            argdict[argname + '_list'] = args[:-1]
388
 
            args[:-1] = []                
389
680
        else:
390
681
            # just a plain arg
391
682
            argname = ap
392
683
            if not args:
393
 
                raise BzrCommandError("command %r requires argument %s"
 
684
                bailout("command %r requires argument %s"
394
685
                        % (cmd, argname.upper()))
395
686
            else:
396
687
                argdict[argname] = args.pop(0)
397
688
            
398
689
    if args:
399
 
        raise BzrCommandError("extra argument to command %s: %s"
400
 
                              % (cmd, args[0]))
 
690
        bailout("extra arguments to command %s: %r"
 
691
                % (cmd, args))
401
692
 
402
693
    return argdict
403
694
 
404
695
 
405
696
 
406
 
def apply_profiled(the_callable, *args, **kwargs):
407
 
    import hotshot
408
 
    import tempfile
409
 
    import hotshot.stats
410
 
    pffileno, pfname = tempfile.mkstemp()
411
 
    try:
412
 
        prof = hotshot.Profile(pfname)
413
 
        try:
414
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
415
 
        finally:
416
 
            prof.close()
417
 
        stats = hotshot.stats.load(pfname)
418
 
        stats.strip_dirs()
419
 
        stats.sort_stats('cum')   # 'time'
420
 
        ## XXX: Might like to write to stderr or the trace file instead but
421
 
        ## print_stats seems hardcoded to stdout
422
 
        stats.print_stats(20)
423
 
        return ret
424
 
    finally:
425
 
        os.close(pffileno)
426
 
        os.remove(pfname)
427
 
 
428
 
 
429
697
def run_bzr(argv):
430
698
    """Execute a command.
431
699
 
432
700
    This is similar to main(), but without all the trappings for
433
 
    logging and error handling.  
434
 
    
435
 
    argv
436
 
       The command-line arguments, without the program name from argv[0]
437
 
    
438
 
    Returns a command status or raises an exception.
439
 
 
440
 
    Special master options: these must come before the command because
441
 
    they control how the command is interpreted.
442
 
 
443
 
    --no-plugins
444
 
        Do not load plugin modules at all
445
 
 
446
 
    --builtin
447
 
        Only use builtin commands.  (Plugins are still allowed to change
448
 
        other behaviour.)
449
 
 
450
 
    --profile
451
 
        Run under the Python profiler.
 
701
    logging and error handling.
452
702
    """
453
 
    # Load all of the transport methods
454
 
    import bzrlib.transport.local, bzrlib.transport.http
455
 
    
456
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
457
 
 
458
 
    opt_profile = opt_no_plugins = opt_builtin = False
459
 
 
460
 
    # --no-plugins is handled specially at a very early stage. We need
461
 
    # to load plugins before doing other command parsing so that they
462
 
    # can override commands, but this needs to happen first.
463
 
 
464
 
    for a in argv:
465
 
        if a == '--profile':
466
 
            opt_profile = True
467
 
        elif a == '--no-plugins':
468
 
            opt_no_plugins = True
469
 
        elif a == '--builtin':
470
 
            opt_builtin = True
471
 
        else:
472
 
            break
473
 
        argv.remove(a)
474
 
 
475
 
    if (not argv) or (argv[0] == '--help'):
476
 
        from bzrlib.help import help
477
 
        if len(argv) > 1:
478
 
            help(argv[1])
479
 
        else:
480
 
            help()
481
 
        return 0
482
 
 
483
 
    if argv[0] == '--version':
484
 
        from bzrlib.builtins import show_version
485
 
        show_version()
486
 
        return 0
487
 
        
488
 
    if not opt_no_plugins:
489
 
        from bzrlib.plugin import load_plugins
490
 
        load_plugins()
491
 
 
492
 
    cmd = str(argv.pop(0))
493
 
 
494
 
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
495
 
 
496
 
    if opt_profile:
497
 
        ret = apply_profiled(cmd_obj.run_argv, argv)
498
 
    else:
499
 
        ret = cmd_obj.run_argv(argv)
500
 
    return ret or 0
 
703
    try:
 
704
        args, opts = parse_args(argv[1:])
 
705
        if 'help' in opts:
 
706
            # TODO: pass down other arguments in case they asked for
 
707
            # help on a command name?
 
708
            cmd_help()
 
709
            return 0
 
710
        elif 'version' in opts:
 
711
            cmd_version()
 
712
            return 0
 
713
        cmd = args.pop(0)
 
714
    except IndexError:
 
715
        log_error('usage: bzr COMMAND\n')
 
716
        log_error('  try "bzr help"\n')
 
717
        return 1
 
718
            
 
719
    try:
 
720
        cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
 
721
    except KeyError:
 
722
        bailout("unknown command " + `cmd`)
 
723
 
 
724
    # TODO: special --profile option to turn on the Python profiler
 
725
 
 
726
    # check options are reasonable
 
727
    allowed = cmd_options.get(cmd, [])
 
728
    for oname in opts:
 
729
        if oname not in allowed:
 
730
            bailout("option %r is not allowed for command %r"
 
731
                    % (oname, cmd))
 
732
 
 
733
    cmdargs = _match_args(cmd, args)
 
734
    cmdargs.update(opts)
 
735
 
 
736
    ret = cmd_handler(**cmdargs) or 0
 
737
 
501
738
 
502
739
 
503
740
def main(argv):
504
 
    import bzrlib.ui
505
 
    bzrlib.trace.log_startup(argv)
506
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
507
 
 
508
 
    return run_bzr_catch_errors(argv[1:])
509
 
 
510
 
 
511
 
def run_bzr_catch_errors(argv):
 
741
    ## TODO: Handle command-line options; probably know what options are valid for
 
742
    ## each command
 
743
 
 
744
    ## TODO: If the arguments are wrong, give a usage message rather
 
745
    ## than just a backtrace.
 
746
 
 
747
    bzrlib.trace.create_tracefile(argv)
 
748
    
512
749
    try:
513
 
        try:
514
 
            return run_bzr(argv)
515
 
        finally:
516
 
            # do this here inside the exception wrappers to catch EPIPE
517
 
            sys.stdout.flush()
518
 
    except BzrCommandError, e:
519
 
        # command line syntax error, etc
520
 
        log_error(str(e))
521
 
        return 1
 
750
        ret = run_bzr(argv)
 
751
        return ret
522
752
    except BzrError, e:
523
 
        bzrlib.trace.log_exception()
 
753
        log_error('bzr: error: ' + e.args[0] + '\n')
 
754
        if len(e.args) > 1:
 
755
            for h in e.args[1]:
 
756
                log_error('  ' + h + '\n')
524
757
        return 1
525
 
    except AssertionError, e:
526
 
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
527
 
        return 3
528
 
    except KeyboardInterrupt, e:
529
 
        bzrlib.trace.log_exception('interrupted')
530
 
        return 2
531
758
    except Exception, e:
532
 
        import errno
533
 
        if (isinstance(e, IOError) 
534
 
            and hasattr(e, 'errno')
535
 
            and e.errno == errno.EPIPE):
536
 
            bzrlib.trace.note('broken pipe')
537
 
            return 2
538
 
        else:
539
 
            ## import pdb
540
 
            ## pdb.pm()
541
 
            bzrlib.trace.log_exception()
542
 
            return 2
 
759
        log_error('bzr: exception: %s\n' % e)
 
760
        log_error('    see .bzr.log for details\n')
 
761
        traceback.print_exc(None, bzrlib.trace._tracefile)
 
762
        traceback.print_exc(None, sys.stderr)
 
763
        return 1
 
764
 
 
765
    # TODO: Maybe nicer handling of IOError?
 
766
 
 
767
 
543
768
 
544
769
if __name__ == '__main__':
545
770
    sys.exit(main(sys.argv))
 
771
    ##import profile
 
772
    ##profile.run('main(sys.argv)')
 
773