/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 09:34:11 UTC
  • Revision ID: mbp@sourcefrog.net-20050622093411-117a9269549f7c03
- fix up register_command() names

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