/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-22 06:38:18 UTC
  • Revision ID: mbp@sourcefrog.net-20050622063818-cd8d21b14bd4b636
- add plugin patch, still being integrated

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