/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-24 07:06:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050624070638-4b1230afde50b1a8
- files are only reported as modified if their name or parent has changed,
  not if their parent is renamed

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
        from bzrlib.osutils import get_text_message
 
1077
 
 
1078
        ## Warning: shadows builtin file()
 
1079
        if not message and not file:
 
1080
            import cStringIO
 
1081
            stdout = sys.stdout
 
1082
            catcher = cStringIO.StringIO()
 
1083
            sys.stdout = catcher
 
1084
            cmd_status({"file_list":selected_list}, {})
 
1085
            info = catcher.getvalue()
 
1086
            sys.stdout = stdout
 
1087
            message = get_text_message(info)
 
1088
            
 
1089
            if message is None:
 
1090
                raise BzrCommandError("please specify a commit message",
 
1091
                                      ["use either --message or --file"])
 
1092
        elif message and file:
 
1093
            raise BzrCommandError("please specify either --message or --file")
 
1094
        
 
1095
        if file:
 
1096
            import codecs
 
1097
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
 
1098
 
 
1099
        b = Branch('.')
 
1100
        commit(b, message, verbose=verbose, specific_files=selected_list)
 
1101
 
 
1102
 
 
1103
class cmd_check(Command):
 
1104
    """Validate consistency of branch history.
 
1105
 
 
1106
    This command checks various invariants about the branch storage to
 
1107
    detect data corruption or bzr bugs.
 
1108
 
 
1109
    If given the --update flag, it will update some optional fields
 
1110
    to help ensure data consistency.
 
1111
    """
 
1112
    takes_args = ['dir?']
 
1113
 
 
1114
    def run(self, dir='.'):
 
1115
        import bzrlib.check
 
1116
        bzrlib.check.check(Branch(dir))
 
1117
 
 
1118
 
 
1119
 
 
1120
class cmd_upgrade(Command):
 
1121
    """Upgrade branch storage to current format.
 
1122
 
 
1123
    This should normally be used only after the check command tells
 
1124
    you to run it.
 
1125
    """
 
1126
    takes_args = ['dir?']
 
1127
 
 
1128
    def run(self, dir='.'):
 
1129
        from bzrlib.upgrade import upgrade
 
1130
        upgrade(Branch(dir))
 
1131
 
 
1132
 
 
1133
 
 
1134
class cmd_whoami(Command):
 
1135
    """Show bzr user id."""
 
1136
    takes_options = ['email']
 
1137
    
 
1138
    def run(self, email=False):
 
1139
        if email:
 
1140
            print bzrlib.osutils.user_email()
 
1141
        else:
 
1142
            print bzrlib.osutils.username()
 
1143
 
 
1144
 
 
1145
class cmd_selftest(Command):
 
1146
    """Run internal test suite"""
 
1147
    hidden = True
 
1148
    def run(self):
 
1149
        from bzrlib.selftest import selftest
 
1150
        return int(not selftest())
 
1151
 
 
1152
 
 
1153
class cmd_version(Command):
 
1154
    """Show version of bzr."""
 
1155
    def run(self):
 
1156
        show_version()
 
1157
 
 
1158
def show_version():
 
1159
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
1160
    # is bzrlib itself in a branch?
 
1161
    bzrrev = bzrlib.get_bzr_revision()
 
1162
    if bzrrev:
 
1163
        print "  (bzr checkout, revision %d {%s})" % bzrrev
 
1164
    print bzrlib.__copyright__
 
1165
    print "http://bazaar-ng.org/"
 
1166
    print
 
1167
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
 
1168
    print "you may use, modify and redistribute it under the terms of the GNU"
 
1169
    print "General Public License version 2 or later."
 
1170
 
 
1171
 
 
1172
class cmd_rocks(Command):
 
1173
    """Statement of optimism."""
 
1174
    hidden = True
 
1175
    def run(self):
 
1176
        print "it sure does!"
 
1177
 
 
1178
def parse_spec(spec):
 
1179
    """
 
1180
    >>> parse_spec(None)
 
1181
    [None, None]
 
1182
    >>> parse_spec("./")
 
1183
    ['./', None]
 
1184
    >>> parse_spec("../@")
 
1185
    ['..', -1]
 
1186
    >>> parse_spec("../f/@35")
 
1187
    ['../f', 35]
 
1188
    """
 
1189
    if spec is None:
 
1190
        return [None, None]
 
1191
    if '/@' in spec:
 
1192
        parsed = spec.split('/@')
 
1193
        assert len(parsed) == 2
 
1194
        if parsed[1] == "":
 
1195
            parsed[1] = -1
 
1196
        else:
 
1197
            parsed[1] = int(parsed[1])
 
1198
            assert parsed[1] >=0
 
1199
    else:
 
1200
        parsed = [spec, None]
 
1201
    return parsed
 
1202
 
 
1203
 
 
1204
 
 
1205
class cmd_merge(Command):
 
1206
    """Perform a three-way merge of trees.
 
1207
    
 
1208
    The SPEC parameters are working tree or revision specifiers.  Working trees
 
1209
    are specified using standard paths or urls.  No component of a directory
 
1210
    path may begin with '@'.
 
1211
    
 
1212
    Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
 
1213
 
 
1214
    Revisions are specified using a dirname/@revno pair, where dirname is the
 
1215
    branch directory and revno is the revision within that branch.  If no revno
 
1216
    is specified, the latest revision is used.
 
1217
 
 
1218
    Revision examples: './@127', 'foo/@', '../@1'
 
1219
 
 
1220
    The OTHER_SPEC parameter is required.  If the BASE_SPEC parameter is
 
1221
    not supplied, the common ancestor of OTHER_SPEC the current branch is used
 
1222
    as the BASE.
 
1223
 
 
1224
    merge refuses to run if there are any uncommitted changes, unless
 
1225
    --force is given.
 
1226
    """
 
1227
    takes_args = ['other_spec', 'base_spec?']
 
1228
    takes_options = ['force']
 
1229
 
 
1230
    def run(self, other_spec, base_spec=None, force=False):
 
1231
        from bzrlib.merge import merge
 
1232
        merge(parse_spec(other_spec), parse_spec(base_spec),
 
1233
              check_clean=(not force))
 
1234
 
 
1235
 
 
1236
class cmd_revert(Command):
 
1237
    """Reverse all changes since the last commit.
 
1238
 
 
1239
    Only versioned files are affected.
 
1240
 
 
1241
    TODO: Store backups of any files that will be reverted, so
 
1242
          that the revert can be undone.          
 
1243
    """
 
1244
    takes_options = ['revision']
 
1245
 
 
1246
    def run(self, revision=-1):
 
1247
        from bzrlib.merge import merge
 
1248
        merge(('.', revision), parse_spec('.'),
 
1249
              check_clean=False,
 
1250
              ignore_zero=True)
 
1251
 
 
1252
 
 
1253
class cmd_assert_fail(Command):
 
1254
    """Test reporting of assertion failures"""
 
1255
    hidden = True
 
1256
    def run(self):
 
1257
        assert False, "always fails"
 
1258
 
 
1259
 
 
1260
class cmd_help(Command):
 
1261
    """Show help on a command or other topic.
 
1262
 
 
1263
    For a list of all available commands, say 'bzr help commands'."""
 
1264
    takes_args = ['topic?']
 
1265
    aliases = ['?']
 
1266
    
 
1267
    def run(self, topic=None):
 
1268
        import help
 
1269
        help.help(topic)
 
1270
 
 
1271
 
 
1272
class cmd_update_stat_cache(Command):
 
1273
    """Update stat-cache mapping inodes to SHA-1 hashes.
 
1274
 
 
1275
    For testing only."""
 
1276
    hidden = True
 
1277
    def run(self):
 
1278
        import statcache
 
1279
        b = Branch('.')
 
1280
        statcache.update_cache(b.base, b.read_working_inventory())
 
1281
 
 
1282
 
 
1283
 
 
1284
class cmd_plugins(Command):
 
1285
    """List plugins"""
 
1286
    hidden = True
 
1287
    def run(self):
 
1288
        import bzrlib.plugin
 
1289
        from pprint import pprint
 
1290
        pprint(bzrlib.plugin.all_plugins)
 
1291
 
 
1292
 
 
1293
 
 
1294
# list of all available options; the rhs can be either None for an
 
1295
# option that takes no argument, or a constructor function that checks
 
1296
# the type.
 
1297
OPTIONS = {
 
1298
    'all':                    None,
 
1299
    'diff-options':           str,
 
1300
    'help':                   None,
 
1301
    'file':                   unicode,
 
1302
    'force':                  None,
 
1303
    'format':                 unicode,
 
1304
    'forward':                None,
 
1305
    'message':                unicode,
 
1306
    'no-recurse':             None,
 
1307
    'profile':                None,
 
1308
    'revision':               _parse_revision_str,
 
1309
    'show-ids':               None,
 
1310
    'timezone':               str,
 
1311
    'verbose':                None,
 
1312
    'version':                None,
 
1313
    'email':                  None,
 
1314
    'update':                 None,
 
1315
    }
 
1316
 
 
1317
SHORT_OPTIONS = {
 
1318
    'F':                      'file', 
 
1319
    'h':                      'help',
 
1320
    'm':                      'message',
 
1321
    'r':                      'revision',
 
1322
    'v':                      'verbose',
 
1323
}
 
1324
 
 
1325
 
 
1326
def parse_args(argv):
 
1327
    """Parse command line.
 
1328
    
 
1329
    Arguments and options are parsed at this level before being passed
 
1330
    down to specific command handlers.  This routine knows, from a
 
1331
    lookup table, something about the available options, what optargs
 
1332
    they take, and which commands will accept them.
 
1333
 
 
1334
    >>> parse_args('--help'.split())
 
1335
    ([], {'help': True})
 
1336
    >>> parse_args('--version'.split())
 
1337
    ([], {'version': True})
 
1338
    >>> parse_args('status --all'.split())
 
1339
    (['status'], {'all': True})
 
1340
    >>> parse_args('commit --message=biter'.split())
 
1341
    (['commit'], {'message': u'biter'})
 
1342
    >>> parse_args('log -r 500'.split())
 
1343
    (['log'], {'revision': 500})
 
1344
    >>> parse_args('log -r500:600'.split())
 
1345
    (['log'], {'revision': [500, 600]})
 
1346
    >>> parse_args('log -vr500:600'.split())
 
1347
    (['log'], {'verbose': True, 'revision': [500, 600]})
 
1348
    >>> parse_args('log -rv500:600'.split()) #the r takes an argument
 
1349
    Traceback (most recent call last):
 
1350
    ...
 
1351
    ValueError: invalid literal for int(): v500
 
1352
    """
 
1353
    args = []
 
1354
    opts = {}
 
1355
 
 
1356
    # TODO: Maybe handle '--' to end options?
 
1357
 
 
1358
    while argv:
 
1359
        a = argv.pop(0)
 
1360
        if a[0] == '-':
 
1361
            # option names must not be unicode
 
1362
            a = str(a)
 
1363
            optarg = None
 
1364
            if a[1] == '-':
 
1365
                mutter("  got option %r" % a)
 
1366
                if '=' in a:
 
1367
                    optname, optarg = a[2:].split('=', 1)
 
1368
                else:
 
1369
                    optname = a[2:]
 
1370
                if optname not in OPTIONS:
 
1371
                    raise BzrError('unknown long option %r' % a)
 
1372
            else:
 
1373
                shortopt = a[1:]
 
1374
                if shortopt in SHORT_OPTIONS:
 
1375
                    # Multi-character options must have a space to delimit
 
1376
                    # their value
 
1377
                    optname = SHORT_OPTIONS[shortopt]
 
1378
                else:
 
1379
                    # Single character short options, can be chained,
 
1380
                    # and have their value appended to their name
 
1381
                    shortopt = a[1:2]
 
1382
                    if shortopt not in SHORT_OPTIONS:
 
1383
                        # We didn't find the multi-character name, and we
 
1384
                        # didn't find the single char name
 
1385
                        raise BzrError('unknown short option %r' % a)
 
1386
                    optname = SHORT_OPTIONS[shortopt]
 
1387
 
 
1388
                    if a[2:]:
 
1389
                        # There are extra things on this option
 
1390
                        # see if it is the value, or if it is another
 
1391
                        # short option
 
1392
                        optargfn = OPTIONS[optname]
 
1393
                        if optargfn is None:
 
1394
                            # This option does not take an argument, so the
 
1395
                            # next entry is another short option, pack it back
 
1396
                            # into the list
 
1397
                            argv.insert(0, '-' + a[2:])
 
1398
                        else:
 
1399
                            # This option takes an argument, so pack it
 
1400
                            # into the array
 
1401
                            optarg = a[2:]
 
1402
            
 
1403
            if optname in opts:
 
1404
                # XXX: Do we ever want to support this, e.g. for -r?
 
1405
                raise BzrError('repeated option %r' % a)
 
1406
                
 
1407
            optargfn = OPTIONS[optname]
 
1408
            if optargfn:
 
1409
                if optarg == None:
 
1410
                    if not argv:
 
1411
                        raise BzrError('option %r needs an argument' % a)
 
1412
                    else:
 
1413
                        optarg = argv.pop(0)
 
1414
                opts[optname] = optargfn(optarg)
 
1415
            else:
 
1416
                if optarg != None:
 
1417
                    raise BzrError('option %r takes no argument' % optname)
 
1418
                opts[optname] = True
 
1419
        else:
 
1420
            args.append(a)
 
1421
 
 
1422
    return args, opts
 
1423
 
 
1424
 
 
1425
 
 
1426
 
 
1427
def _match_argform(cmd, takes_args, args):
 
1428
    argdict = {}
 
1429
 
 
1430
    # step through args and takes_args, allowing appropriate 0-many matches
 
1431
    for ap in takes_args:
 
1432
        argname = ap[:-1]
 
1433
        if ap[-1] == '?':
 
1434
            if args:
 
1435
                argdict[argname] = args.pop(0)
 
1436
        elif ap[-1] == '*': # all remaining arguments
 
1437
            if args:
 
1438
                argdict[argname + '_list'] = args[:]
 
1439
                args = []
 
1440
            else:
 
1441
                argdict[argname + '_list'] = None
 
1442
        elif ap[-1] == '+':
 
1443
            if not args:
 
1444
                raise BzrCommandError("command %r needs one or more %s"
 
1445
                        % (cmd, argname.upper()))
 
1446
            else:
 
1447
                argdict[argname + '_list'] = args[:]
 
1448
                args = []
 
1449
        elif ap[-1] == '$': # all but one
 
1450
            if len(args) < 2:
 
1451
                raise BzrCommandError("command %r needs one or more %s"
 
1452
                        % (cmd, argname.upper()))
 
1453
            argdict[argname + '_list'] = args[:-1]
 
1454
            args[:-1] = []                
 
1455
        else:
 
1456
            # just a plain arg
 
1457
            argname = ap
 
1458
            if not args:
 
1459
                raise BzrCommandError("command %r requires argument %s"
 
1460
                        % (cmd, argname.upper()))
 
1461
            else:
 
1462
                argdict[argname] = args.pop(0)
 
1463
            
 
1464
    if args:
 
1465
        raise BzrCommandError("extra argument to command %s: %s"
 
1466
                              % (cmd, args[0]))
 
1467
 
 
1468
    return argdict
 
1469
 
 
1470
 
 
1471
def _parse_master_args(argv):
 
1472
    """Parse the arguments that always go with the original command.
 
1473
    These are things like bzr --no-plugins, etc.
 
1474
 
 
1475
    There are now 2 types of option flags. Ones that come *before* the command,
 
1476
    and ones that come *after* the command.
 
1477
    Ones coming *before* the command are applied against all possible commands.
 
1478
    And are generally applied before plugins are loaded.
 
1479
 
 
1480
    The current list are:
 
1481
        --builtin   Allow plugins to load, but don't let them override builtin commands,
 
1482
                    they will still be allowed if they do not override a builtin.
 
1483
        --no-plugins    Don't load any plugins. This lets you get back to official source
 
1484
                        behavior.
 
1485
        --profile   Enable the hotspot profile before running the command.
 
1486
                    For backwards compatibility, this is also a non-master option.
 
1487
        --version   Spit out the version of bzr that is running and exit.
 
1488
                    This is also a non-master option.
 
1489
        --help      Run help and exit, also a non-master option (I think that should stay, though)
 
1490
 
 
1491
    >>> argv, opts = _parse_master_args(['bzr', '--test'])
 
1492
    Traceback (most recent call last):
 
1493
    ...
 
1494
    BzrCommandError: Invalid master option: 'test'
 
1495
    >>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
 
1496
    >>> print argv
 
1497
    ['command']
 
1498
    >>> print opts['version']
 
1499
    True
 
1500
    >>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
 
1501
    >>> print argv
 
1502
    ['command', '--more-options']
 
1503
    >>> print opts['profile']
 
1504
    True
 
1505
    >>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
 
1506
    >>> print argv
 
1507
    ['command']
 
1508
    >>> print opts['no-plugins']
 
1509
    True
 
1510
    >>> print opts['profile']
 
1511
    False
 
1512
    >>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
 
1513
    >>> print argv
 
1514
    ['command', '--profile']
 
1515
    >>> print opts['profile']
 
1516
    False
 
1517
    """
 
1518
    master_opts = {'builtin':False,
 
1519
        'no-plugins':False,
 
1520
        'version':False,
 
1521
        'profile':False,
 
1522
        'help':False
 
1523
    }
 
1524
 
 
1525
    # This is the point where we could hook into argv[0] to determine
 
1526
    # what front-end is supposed to be run
 
1527
    # For now, we are just ignoring it.
 
1528
    cmd_name = argv.pop(0)
 
1529
    for arg in argv[:]:
 
1530
        if arg[:2] != '--': # at the first non-option, we return the rest
 
1531
            break
 
1532
        arg = arg[2:] # Remove '--'
 
1533
        if arg not in master_opts:
 
1534
            # We could say that this is not an error, that we should
 
1535
            # just let it be handled by the main section instead
 
1536
            raise BzrCommandError('Invalid master option: %r' % arg)
 
1537
        argv.pop(0) # We are consuming this entry
 
1538
        master_opts[arg] = True
 
1539
    return argv, master_opts
 
1540
 
 
1541
 
 
1542
 
 
1543
def run_bzr(argv):
 
1544
    """Execute a command.
 
1545
 
 
1546
    This is similar to main(), but without all the trappings for
 
1547
    logging and error handling.  
 
1548
    """
 
1549
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
1550
    
 
1551
    try:
 
1552
        # some options like --builtin and --no-plugins have special effects
 
1553
        argv, master_opts = _parse_master_args(argv)
 
1554
        if not master_opts['no-plugins']:
 
1555
            bzrlib.load_plugins()
 
1556
 
 
1557
        args, opts = parse_args(argv)
 
1558
 
 
1559
        if master_opts['help']:
 
1560
            from bzrlib.help import help
 
1561
            if argv:
 
1562
                help(argv[0])
 
1563
            else:
 
1564
                help()
 
1565
            return 0            
 
1566
            
 
1567
        if 'help' in opts:
 
1568
            from bzrlib.help import help
 
1569
            if args:
 
1570
                help(args[0])
 
1571
            else:
 
1572
                help()
 
1573
            return 0
 
1574
        elif 'version' in opts:
 
1575
            show_version()
 
1576
            return 0
 
1577
        elif args and args[0] == 'builtin':
 
1578
            include_plugins=False
 
1579
            args = args[1:]
 
1580
        cmd = str(args.pop(0))
 
1581
    except IndexError:
 
1582
        import help
 
1583
        help.help()
 
1584
        return 1
 
1585
          
 
1586
 
 
1587
    plugins_override = not (master_opts['builtin'])
 
1588
    canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
 
1589
 
 
1590
    profile = master_opts['profile']
 
1591
    # For backwards compatibility, I would rather stick with --profile being a
 
1592
    # master/global option
 
1593
    if 'profile' in opts:
 
1594
        profile = True
 
1595
        del opts['profile']
 
1596
 
 
1597
    # check options are reasonable
 
1598
    allowed = cmd_class.takes_options
 
1599
    for oname in opts:
 
1600
        if oname not in allowed:
 
1601
            raise BzrCommandError("option '--%s' is not allowed for command %r"
 
1602
                                  % (oname, cmd))
 
1603
 
 
1604
    # mix arguments and options into one dictionary
 
1605
    cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
 
1606
    cmdopts = {}
 
1607
    for k, v in opts.items():
 
1608
        cmdopts[k.replace('-', '_')] = v
 
1609
 
 
1610
    if profile:
 
1611
        import hotshot, tempfile
 
1612
        pffileno, pfname = tempfile.mkstemp()
 
1613
        try:
 
1614
            prof = hotshot.Profile(pfname)
 
1615
            ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
 
1616
            prof.close()
 
1617
 
 
1618
            import hotshot.stats
 
1619
            stats = hotshot.stats.load(pfname)
 
1620
            #stats.strip_dirs()
 
1621
            stats.sort_stats('time')
 
1622
            ## XXX: Might like to write to stderr or the trace file instead but
 
1623
            ## print_stats seems hardcoded to stdout
 
1624
            stats.print_stats(20)
 
1625
            
 
1626
            return ret.status
 
1627
 
 
1628
        finally:
 
1629
            os.close(pffileno)
 
1630
            os.remove(pfname)
 
1631
    else:
 
1632
        return cmd_class(cmdopts, cmdargs).status 
 
1633
 
 
1634
 
 
1635
def _report_exception(summary, quiet=False):
 
1636
    import traceback
 
1637
    log_error('bzr: ' + summary)
 
1638
    bzrlib.trace.log_exception()
 
1639
 
 
1640
    if not quiet:
 
1641
        tb = sys.exc_info()[2]
 
1642
        exinfo = traceback.extract_tb(tb)
 
1643
        if exinfo:
 
1644
            sys.stderr.write('  at %s:%d in %s()\n' % exinfo[-1][:3])
 
1645
        sys.stderr.write('  see ~/.bzr.log for debug information\n')
 
1646
 
 
1647
 
 
1648
 
 
1649
def main(argv):
 
1650
    import errno
 
1651
    
 
1652
    bzrlib.open_tracefile(argv)
 
1653
 
 
1654
    try:
 
1655
        try:
 
1656
            try:
 
1657
                return run_bzr(argv)
 
1658
            finally:
 
1659
                # do this here inside the exception wrappers to catch EPIPE
 
1660
                sys.stdout.flush()
 
1661
        except BzrError, e:
 
1662
            quiet = isinstance(e, (BzrCommandError))
 
1663
            _report_exception('error: ' + e.args[0], quiet=quiet)
 
1664
            if len(e.args) > 1:
 
1665
                for h in e.args[1]:
 
1666
                    # some explanation or hints
 
1667
                    log_error('  ' + h)
 
1668
            return 1
 
1669
        except AssertionError, e:
 
1670
            msg = 'assertion failed'
 
1671
            if str(e):
 
1672
                msg += ': ' + str(e)
 
1673
            _report_exception(msg)
 
1674
            return 2
 
1675
        except KeyboardInterrupt, e:
 
1676
            _report_exception('interrupted', quiet=True)
 
1677
            return 2
 
1678
        except Exception, e:
 
1679
            quiet = False
 
1680
            if (isinstance(e, IOError) 
 
1681
                and hasattr(e, 'errno')
 
1682
                and e.errno == errno.EPIPE):
 
1683
                quiet = True
 
1684
                msg = 'broken pipe'
 
1685
            else:
 
1686
                msg = str(e).rstrip('\n')
 
1687
            _report_exception(msg, quiet)
 
1688
            return 2
 
1689
    finally:
 
1690
        bzrlib.trace.close_trace()
 
1691
 
 
1692
 
 
1693
if __name__ == '__main__':
 
1694
    sys.exit(main(sys.argv))