/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2005-06-15 04:17:12 UTC
  • Revision ID: mbp@sourcefrog.net-20050615041712-ba12ff03d4ce3be0
- add deferred patch from abentley 
  to fetch remote Revision XML only once
  when branching

Show diffs side-by-side

added added

removed removed

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