/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

More work on roundtrip push support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
4
 
 
5
 
# This program is free software; you can redistribute it and/or modify
6
 
# it under the terms of the GNU General Public License as published by
7
 
# the Free Software Foundation; either version 2 of the License, or
8
 
# (at your option) any later version.
9
 
 
10
 
# This program is distributed in the hope that it will be useful,
11
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
# GNU General Public License for more details.
14
 
 
15
 
# You should have received a copy of the GNU General Public License
16
 
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
19
 
"""Bazaar-NG -- a free distributed version-control tool
20
 
 
21
 
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
22
 
 
23
 
Current limitation include:
24
 
 
25
 
* Metadata format is not stable yet -- you may need to
26
 
  discard history in the future.
27
 
 
28
 
* Insufficient error handling.
29
 
 
30
 
* Many commands unimplemented or partially implemented.
31
 
 
32
 
* Space-inefficient storage.
33
 
 
34
 
* No merge operators yet.
35
 
 
36
 
Interesting commands::
37
 
 
38
 
  bzr help [COMMAND]
39
 
       Show help screen
40
 
  bzr version
41
 
       Show software version/licence/non-warranty.
42
 
  bzr init
43
 
       Start versioning the current directory
44
 
  bzr add FILE...
45
 
       Make files versioned.
46
 
  bzr log
47
 
       Show revision history.
48
 
  bzr diff
49
 
       Show changes from last revision to working copy.
50
 
  bzr commit -m 'MESSAGE'
51
 
       Store current state as new revision.
52
 
  bzr export REVNO DESTINATION
53
 
       Export the branch state at a previous version.
54
 
  bzr status
55
 
       Show summary of pending changes.
56
 
  bzr remove FILE...
57
 
       Make a file not versioned.
58
 
  bzr info
59
 
       Show statistics about this branch.
60
 
"""
61
 
 
62
 
 
63
 
 
64
 
 
65
 
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
66
 
import traceback, socket, fnmatch, difflib
67
 
from os import path
68
 
from sets import Set
69
 
from pprint import pprint
70
 
from stat import *
71
 
from glob import glob
72
 
 
73
 
import bzrlib
74
 
from bzrlib.store import ImmutableStore
75
 
from bzrlib.trace import mutter, note, log_error
76
 
from bzrlib.errors import bailout, BzrError
77
 
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
78
 
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
79
 
from bzrlib.revision import Revision
80
 
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
81
 
     format_date
82
 
 
83
 
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
84
 
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
85
 
 
86
 
## standard representation
87
 
NONE_STRING = '(none)'
88
 
EMPTY = 'empty'
89
 
 
90
 
 
91
 
## TODO: Perhaps a different version of inventory commands that
92
 
## returns iterators...
93
 
 
94
 
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
95
 
 
96
 
## TODO: Some kind of locking on branches.  Perhaps there should be a
97
 
## parameter to the branch object saying whether we want a read or
98
 
## write lock; release it from destructor.  Perhaps don't even need a
99
 
## read lock to look at immutable objects?
100
 
 
101
 
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
102
 
## to compare output?
103
 
 
104
 
## TODO: Some kind of global code to generate the right Branch object
105
 
## to work on.  Almost, but not quite all, commands need one, and it
106
 
## can be taken either from their parameters or their working
107
 
## directory.
108
 
 
109
 
## TODO: rename command, needed soon: check destination doesn't exist
110
 
## either in working copy or tree; move working copy; update
111
 
## inventory; write out
112
 
 
113
 
## TODO: move command; check destination is a directory and will not
114
 
## clash; move it.
115
 
 
116
 
## TODO: command to show renames, one per line, as to->from
117
 
 
118
 
 
119
 
 
120
 
 
121
 
def cmd_status(all=False):
122
 
    """Display status summary.
123
 
 
124
 
    For each file there is a single line giving its file state and name.
125
 
    The name is that in the current revision unless it is deleted or
126
 
    missing, in which case the old name is shown.
127
 
 
128
 
    :todo: Don't show unchanged files unless ``--all`` is given?
129
 
    """
130
 
    Branch('.').show_status(show_all=all)
131
 
 
132
 
 
133
 
 
134
 
######################################################################
135
 
# examining history
136
 
def cmd_get_revision(revision_id):
137
 
    Branch('.').get_revision(revision_id).write_xml(sys.stdout)
138
 
 
139
 
 
140
 
def cmd_get_file_text(text_id):
141
 
    """Get contents of a file by hash."""
142
 
    sf = Branch('.').text_store[text_id]
143
 
    pumpfile(sf, sys.stdout)
144
 
 
145
 
 
146
 
 
147
 
######################################################################
148
 
# commands
149
 
    
150
 
 
151
 
def cmd_revno():
152
 
    """Show number of revisions on this branch"""
153
 
    print Branch('.').revno()
154
 
    
155
 
 
156
 
    
157
 
def cmd_add(file_list, verbose=False):
158
 
    """Add specified files or directories.
159
 
 
160
 
    In non-recursive mode, all the named items are added, regardless
161
 
    of whether they were previously ignored.  A warning is given if
162
 
    any of the named files are already versioned.
163
 
 
164
 
    In recursive mode (the default), files are treated the same way
165
 
    but the behaviour for directories is different.  Directories that
166
 
    are already versioned do not give a warning.  All directories,
167
 
    whether already versioned or not, are searched for files or
168
 
    subdirectories that are neither versioned or ignored, and these
169
 
    are added.  This search proceeds recursively into versioned
170
 
    directories.
171
 
 
172
 
    Therefore simply saying 'bzr add .' will version all files that
173
 
    are currently unknown.
174
 
    """
175
 
    bzrlib.add.smart_add(file_list, verbose)
176
 
    
177
 
 
178
 
def cmd_relpath(filename):
179
 
    """Show path of file relative to root"""
180
 
    print Branch(filename).relpath(filename)
181
 
 
182
 
 
183
 
def cmd_inventory(revision=None):
184
 
    """Show inventory of the current working copy."""
185
 
    ## TODO: Also optionally show a previous inventory
186
 
    ## TODO: Format options
187
 
    b = Branch('.')
188
 
    if revision == None:
189
 
        inv = b.read_working_inventory()
190
 
    else:
191
 
        inv = b.get_revision_inventory(b.lookup_revision(revision))
192
 
        
193
 
    for path, entry in inv.iter_entries():
194
 
        print '%-50s %s' % (entry.file_id, path)
195
 
 
196
 
 
197
 
 
198
 
def cmd_info():
199
 
    """info: Show statistical information for this branch
200
 
 
201
 
usage: bzr info"""
202
 
    import info
203
 
    info.show_info(Branch('.'))        
204
 
    
205
 
 
206
 
 
207
 
def cmd_remove(file_list, verbose=False):
208
 
    b = Branch(file_list[0])
209
 
    b.remove([b.relpath(f) for f in file_list], verbose=verbose)
210
 
 
211
 
 
212
 
 
213
 
def cmd_file_id(filename):
214
 
    b = Branch(filename)
215
 
    i = b.inventory.path2id(b.relpath(filename))
216
 
    if i is None:
217
 
        bailout("%s is not a versioned file" % filename)
218
 
    else:
219
 
        print i
220
 
 
221
 
 
222
 
def cmd_find_filename(fileid):
223
 
    n = find_filename(fileid)
224
 
    if n is None:
225
 
        bailout("%s is not a live file id" % fileid)
226
 
    else:
227
 
        print n
228
 
 
229
 
 
230
 
def cmd_revision_history():
231
 
    for patchid in Branch('.').revision_history():
232
 
        print patchid
233
 
 
234
 
 
235
 
 
236
 
def cmd_init():
237
 
    # TODO: Check we're not already in a working directory?  At the
238
 
    # moment you'll get an ugly error.
239
 
    
240
 
    # TODO: What if we're in a subdirectory of a branch?  Would like
241
 
    # to allow that, but then the parent may need to understand that
242
 
    # the children have disappeared, or should they be versioned in
243
 
    # both?
244
 
 
245
 
    # TODO: Take an argument/option for branch name.
246
 
    Branch('.', init=True)
247
 
 
248
 
 
249
 
def cmd_diff(revision=None):
250
 
    """bzr diff: Show differences in working tree.
251
 
    
252
 
usage: bzr diff [-r REV]
253
 
 
254
 
--revision REV
255
 
    Show changes since REV, rather than predecessor.
256
 
 
257
 
TODO: Given two revision arguments, show the difference between them.
258
 
 
259
 
TODO: Allow diff across branches.
260
 
 
261
 
TODO: Option to use external diff command; could be GNU diff, wdiff,
262
 
or a graphical diff.
263
 
 
264
 
TODO: Diff selected files.
265
 
"""
266
 
 
267
 
    ## TODO: Shouldn't be in the cmd function.
268
 
 
269
 
    b = Branch('.')
270
 
 
271
 
    if revision == None:
272
 
        old_tree = b.basis_tree()
273
 
    else:
274
 
        old_tree = b.revision_tree(b.lookup_revision(revision))
275
 
        
276
 
    new_tree = b.working_tree()
277
 
    old_inv = old_tree.inventory
278
 
    new_inv = new_tree.inventory
279
 
 
280
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
281
 
    old_label = ''
282
 
    new_label = ''
283
 
 
284
 
    DEVNULL = '/dev/null'
285
 
    # Windows users, don't panic about this filename -- it is a
286
 
    # special signal to GNU patch that the file should be created or
287
 
    # deleted respectively.
288
 
 
289
 
    # TODO: Generation of pseudo-diffs for added/deleted files could
290
 
    # be usefully made into a much faster special case.
291
 
 
292
 
    # TODO: Better to return them in sorted order I think.
293
 
    
294
 
    for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
295
 
        d = None
296
 
 
297
 
        # Don't show this by default; maybe do it if an option is passed
298
 
        # idlabel = '      {%s}' % fid
299
 
        idlabel = ''
300
 
 
301
 
        # FIXME: Something about the diff format makes patch unhappy
302
 
        # with newly-added files.
303
 
 
304
 
        def diffit(*a, **kw):
305
 
            sys.stdout.writelines(difflib.unified_diff(*a, **kw))
306
 
            print
307
 
        
308
 
        if file_state in ['.', '?', 'I']:
309
 
            continue
310
 
        elif file_state == 'A':
311
 
            print '*** added %s %r' % (kind, new_name)
312
 
            if kind == 'file':
313
 
                diffit([],
314
 
                       new_tree.get_file(fid).readlines(),
315
 
                       fromfile=DEVNULL,
316
 
                       tofile=new_label + new_name + idlabel)
317
 
        elif file_state == 'D':
318
 
            assert isinstance(old_name, types.StringTypes)
319
 
            print '*** deleted %s %r' % (kind, old_name)
320
 
            if kind == 'file':
321
 
                diffit(old_tree.get_file(fid).readlines(), [],
322
 
                       fromfile=old_label + old_name + idlabel,
323
 
                       tofile=DEVNULL)
324
 
        elif file_state in ['M', 'R']:
325
 
            if file_state == 'M':
326
 
                assert kind == 'file'
327
 
                assert old_name == new_name
328
 
                print '*** modified %s %r' % (kind, new_name)
329
 
            elif file_state == 'R':
330
 
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
331
 
 
332
 
            if kind == 'file':
333
 
                diffit(old_tree.get_file(fid).readlines(),
334
 
                       new_tree.get_file(fid).readlines(),
335
 
                       fromfile=old_label + old_name + idlabel,
336
 
                       tofile=new_label + new_name)
337
 
        else:
338
 
            bailout("can't represent state %s {%s}" % (file_state, fid))
339
 
 
340
 
 
341
 
 
342
 
def cmd_deleted(show_ids=False):
343
 
    """List files deleted in the working tree.
344
 
 
345
 
TODO: Show files deleted since a previous revision, or between two revisions.
346
 
    """
347
 
    b = Branch('.')
348
 
    old = b.basis_tree()
349
 
    new = b.working_tree()
350
 
 
351
 
    ## TODO: Much more efficient way to do this: read in new
352
 
    ## directories with readdir, rather than stating each one.  Same
353
 
    ## level of effort but possibly much less IO.  (Or possibly not,
354
 
    ## if the directories are very large...)
355
 
 
356
 
    for path, ie in old.inventory.iter_entries():
357
 
        if not new.has_id(ie.file_id):
358
 
            if show_ids:
359
 
                print '%-50s %s' % (path, ie.file_id)
360
 
            else:
361
 
                print path
362
 
 
363
 
 
364
 
 
365
 
def cmd_parse_inventory():
366
 
    import cElementTree
367
 
    
368
 
    cElementTree.ElementTree().parse(file('.bzr/inventory'))
369
 
 
370
 
 
371
 
 
372
 
def cmd_load_inventory():
373
 
    inv = Branch('.').basis_tree().inventory
374
 
 
375
 
 
376
 
 
377
 
def cmd_dump_new_inventory():
378
 
    import bzrlib.newinventory
379
 
    inv = Branch('.').basis_tree().inventory
380
 
    bzrlib.newinventory.write_inventory(inv, sys.stdout)
381
 
 
382
 
 
383
 
def cmd_load_new_inventory():
384
 
    import bzrlib.newinventory
385
 
    bzrlib.newinventory.read_new_inventory(sys.stdin)
386
 
                
387
 
    
388
 
def cmd_dump_slacker_inventory():
389
 
    import bzrlib.newinventory
390
 
    inv = Branch('.').basis_tree().inventory
391
 
    bzrlib.newinventory.write_slacker_inventory(inv, sys.stdout)
392
 
                
393
 
    
394
 
 
395
 
def cmd_root(filename=None):
396
 
    """Print the branch root."""
397
 
    print bzrlib.branch.find_branch_root(filename)
398
 
    
399
 
 
400
 
def cmd_log(timezone='original'):
401
 
    """Show log of this branch.
402
 
 
403
 
    :todo: Options for utc; to show ids; to limit range; etc.
404
 
    """
405
 
    Branch('.').write_log(show_timezone=timezone)
406
 
 
407
 
 
408
 
def cmd_ls(revision=None, verbose=False):
409
 
    """List files in a tree.
410
 
 
411
 
    :todo: Take a revision or remote path and list that tree instead.
412
 
    """
413
 
    b = Branch('.')
414
 
    if revision == None:
415
 
        tree = b.working_tree()
416
 
    else:
417
 
        tree = b.revision_tree(b.lookup_revision(revision))
418
 
        
419
 
    for fp, fc, kind, fid in tree.list_files():
420
 
        if verbose:
421
 
            if kind == 'directory':
422
 
                kindch = '/'
423
 
            elif kind == 'file':
424
 
                kindch = ''
425
 
            else:
426
 
                kindch = '???'
427
 
                
428
 
            print '%-8s %s%s' % (fc, fp, kindch)
429
 
        else:
430
 
            print fp
431
 
    
432
 
    
433
 
 
434
 
def cmd_unknowns():
435
 
    """List unknown files"""
436
 
    for f in Branch('.').unknowns():
437
 
        print quotefn(f)
438
 
 
439
 
 
440
 
 
441
 
def cmd_ignored(verbose=True):
442
 
    """List ignored files and the patterns that matched them.
443
 
      """
444
 
    tree = Branch('.').working_tree()
445
 
    for path, file_class, kind, id in tree.list_files():
446
 
        if file_class != 'I':
447
 
            continue
448
 
        ## XXX: Slightly inefficient since this was already calculated
449
 
        pat = tree.is_ignored(path)
450
 
        print '%-50s %s' % (path, pat)
451
 
 
452
 
 
453
 
def cmd_lookup_revision(revno):
454
 
    try:
455
 
        revno = int(revno)
456
 
    except ValueError:
457
 
        bailout("usage: lookup-revision REVNO",
458
 
                ["REVNO is a non-negative revision number for this branch"])
459
 
 
460
 
    print Branch('.').lookup_revision(revno) or NONE_STRING
461
 
 
462
 
 
463
 
 
464
 
def cmd_export(revno, dest):
465
 
    """Export past revision to destination directory."""
466
 
    b = Branch('.')
467
 
    rh = b.lookup_revision(int(revno))
468
 
    t = b.revision_tree(rh)
469
 
    t.export(dest)
470
 
 
471
 
 
472
 
 
473
 
######################################################################
474
 
# internal/test commands
475
 
 
476
 
 
477
 
def cmd_uuid():
478
 
    """Print a newly-generated UUID."""
479
 
    print bzrlib.osutils.uuid()
480
 
 
481
 
 
482
 
 
483
 
def cmd_local_time_offset():
484
 
    print bzrlib.osutils.local_time_offset()
485
 
 
486
 
 
487
 
 
488
 
def cmd_commit(message=None, verbose=False):
489
 
    """Commit changes to a new revision.
490
 
 
491
 
--message MESSAGE
492
 
    Description of changes in this revision; free form text.
493
 
    It is recommended that the first line be a single-sentence
494
 
    summary.
495
 
--verbose
496
 
    Show status of changed files,
497
 
 
498
 
TODO: Commit only selected files.
499
 
 
500
 
TODO: Run hooks on tree to-be-committed, and after commit.
501
 
 
502
 
TODO: Strict commit that fails if there are unknown or deleted files.
503
 
"""
504
 
 
505
 
    if not message:
506
 
        bailout("please specify a commit message")
507
 
    Branch('.').commit(message, verbose=verbose)
508
 
 
509
 
 
510
 
def cmd_check(dir='.'):
511
 
    """check: Consistency check of branch history.
512
 
 
513
 
usage: bzr check [-v] [BRANCH]
514
 
 
515
 
options:
516
 
  --verbose, -v         Show progress of checking.
517
 
 
518
 
This command checks various invariants about the branch storage to
519
 
detect data corruption or bzr bugs.
520
 
"""
521
 
    import bzrlib.check
522
 
    bzrlib.check.check(Branch(dir, find_root=False))
523
 
 
524
 
 
525
 
def cmd_is(pred, *rest):
526
 
    """Test whether PREDICATE is true."""
527
 
    try:
528
 
        cmd_handler = globals()['assert_' + pred.replace('-', '_')]
529
 
    except KeyError:
530
 
        bailout("unknown predicate: %s" % quotefn(pred))
531
 
        
532
 
    try:
533
 
        cmd_handler(*rest)
534
 
    except BzrCheckError:
535
 
        # by default we don't print the message so that this can
536
 
        # be used from shell scripts without producing noise
537
 
        sys.exit(1)
538
 
 
539
 
 
540
 
def cmd_username():
541
 
    print bzrlib.osutils.username()
542
 
 
543
 
 
544
 
def cmd_user_email():
545
 
    print bzrlib.osutils.user_email()
546
 
 
547
 
 
548
 
def cmd_gen_revision_id():
549
 
    import time
550
 
    print bzrlib.branch._gen_revision_id(time.time())
551
 
 
552
 
 
553
 
def cmd_selftest(verbose=False):
554
 
    """Run internal test suite"""
555
 
    ## -v, if present, is seen by doctest; the argument is just here
556
 
    ## so our parser doesn't complain
557
 
 
558
 
    ## TODO: --verbose option
559
 
 
560
 
    failures, tests = 0, 0
561
 
    
562
 
    import doctest, bzrlib.store, bzrlib.tests
563
 
    bzrlib.trace.verbose = False
564
 
 
565
 
    for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
566
 
        bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
567
 
        mf, mt = doctest.testmod(m)
568
 
        failures += mf
569
 
        tests += mt
570
 
        print '%-40s %3d tests' % (m.__name__, mt),
571
 
        if mf:
572
 
            print '%3d FAILED!' % mf
573
 
        else:
574
 
            print
575
 
 
576
 
    print '%-40s %3d tests' % ('total', tests),
577
 
    if failures:
578
 
        print '%3d FAILED!' % failures
579
 
    else:
580
 
        print
581
 
 
582
 
 
583
 
 
584
 
# deprecated
585
 
cmd_doctest = cmd_selftest
586
 
 
587
 
 
588
 
######################################################################
589
 
# help
590
 
 
591
 
 
592
 
def cmd_help(topic=None):
593
 
    if topic == None:
594
 
        print __doc__
595
 
        return
596
 
 
597
 
    # otherwise, maybe the name of a command?
598
 
    try:
599
 
        cmdfn = globals()['cmd_' + topic.replace('-', '_')]
600
 
    except KeyError:
601
 
        bailout("no help for %r" % topic)
602
 
 
603
 
    doc = cmdfn.__doc__
604
 
    if doc == None:
605
 
        bailout("sorry, no detailed help yet for %r" % topic)
606
 
 
607
 
    print doc
608
 
        
609
 
 
610
 
 
611
 
 
612
 
def cmd_version():
613
 
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
614
 
    print bzrlib.__copyright__
615
 
    print "http://bazaar-ng.org/"
616
 
    print
617
 
    print \
618
 
"""bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and
619
 
you may use, modify and redistribute it under the terms of the GNU 
620
 
General Public License version 2 or later."""
621
 
 
622
 
 
623
 
def cmd_rocks():
624
 
    """Statement of optimism."""
625
 
    print "it sure does!"
626
 
 
627
 
 
628
 
 
629
 
######################################################################
630
 
# main routine
631
 
 
632
 
 
633
 
# list of all available options; the rhs can be either None for an
634
 
# option that takes no argument, or a constructor function that checks
635
 
# the type.
636
 
OPTIONS = {
637
 
    'all':                    None,
638
 
    'help':                   None,
639
 
    'message':                unicode,
640
 
    'profile':                None,
641
 
    'revision':               int,
642
 
    'show-ids':               None,
643
 
    'timezone':               str,
644
 
    'verbose':                None,
645
 
    'version':                None,
646
 
    }
647
 
 
648
 
SHORT_OPTIONS = {
649
 
    'm':                      'message',
650
 
    'r':                      'revision',
651
 
    'v':                      'verbose',
652
 
}
653
 
 
654
 
# List of options that apply to particular commands; commands not
655
 
# listed take none.
656
 
cmd_options = {
657
 
    'add':                    ['verbose'],
658
 
    'commit':                 ['message', 'verbose'],
659
 
    'deleted':                ['show-ids'],
660
 
    'diff':                   ['revision'],
661
 
    'inventory':              ['revision'],
662
 
    'log':                    ['timezone'],
663
 
    'ls':                     ['revision', 'verbose'],
664
 
    'remove':                 ['verbose'],
665
 
    'status':                 ['all'],
666
 
    }
667
 
 
668
 
 
669
 
cmd_args = {
670
 
    'add':                    ['file+'],
671
 
    'commit':                 [],
672
 
    'diff':                   [],
673
 
    'export':                 ['revno', 'dest'],
674
 
    'file-id':                ['filename'],
675
 
    'get-file-text':          ['text_id'],
676
 
    'get-inventory':          ['inventory_id'],
677
 
    'get-revision':           ['revision_id'],
678
 
    'get-revision-inventory': ['revision_id'],
679
 
    'help':                   ['topic?'],
680
 
    'init':                   [],
681
 
    'log':                    [],
682
 
    'lookup-revision':        ['revno'],
683
 
    'relpath':                ['filename'],
684
 
    'remove':                 ['file+'],
685
 
    'root':                   ['filename?'],
686
 
    'status':                 [],
687
 
    }
688
 
 
689
 
 
690
 
def parse_args(argv):
691
 
    """Parse command line.
692
 
    
693
 
    Arguments and options are parsed at this level before being passed
694
 
    down to specific command handlers.  This routine knows, from a
695
 
    lookup table, something about the available options, what optargs
696
 
    they take, and which commands will accept them.
697
 
 
698
 
    >>> parse_args('--help'.split())
699
 
    ([], {'help': True})
700
 
    >>> parse_args('--version'.split())
701
 
    ([], {'version': True})
702
 
    >>> parse_args('status --all'.split())
703
 
    (['status'], {'all': True})
704
 
    >>> parse_args('commit --message=biter'.split())
705
 
    (['commit'], {'message': u'biter'})
706
 
    """
707
 
    args = []
708
 
    opts = {}
709
 
 
710
 
    # TODO: Maybe handle '--' to end options?
711
 
 
712
 
    while argv:
713
 
        a = argv.pop(0)
714
 
        if a[0] == '-':
715
 
            optarg = None
716
 
            if a[1] == '-':
717
 
                mutter("  got option %r" % a)
718
 
                if '=' in a:
719
 
                    optname, optarg = a[2:].split('=', 1)
720
 
                else:
721
 
                    optname = a[2:]
722
 
                if optname not in OPTIONS:
723
 
                    bailout('unknown long option %r' % a)
724
 
            else:
725
 
                shortopt = a[1:]
726
 
                if shortopt not in SHORT_OPTIONS:
727
 
                    bailout('unknown short option %r' % a)
728
 
                optname = SHORT_OPTIONS[shortopt]
729
 
            
730
 
            if optname in opts:
731
 
                # XXX: Do we ever want to support this, e.g. for -r?
732
 
                bailout('repeated option %r' % a)
733
 
                
734
 
            optargfn = OPTIONS[optname]
735
 
            if optargfn:
736
 
                if optarg == None:
737
 
                    if not argv:
738
 
                        bailout('option %r needs an argument' % a)
739
 
                    else:
740
 
                        optarg = argv.pop(0)
741
 
                opts[optname] = optargfn(optarg)
742
 
            else:
743
 
                if optarg != None:
744
 
                    bailout('option %r takes no argument' % optname)
745
 
                opts[optname] = True
746
 
        else:
747
 
            args.append(a)
748
 
 
749
 
    return args, opts
750
 
 
751
 
 
752
 
 
753
 
def _match_args(cmd, args):
754
 
    """Check non-option arguments match required pattern.
755
 
 
756
 
    >>> _match_args('status', ['asdasdsadasd'])
757
 
    Traceback (most recent call last):
758
 
    ...
759
 
    BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
760
 
    >>> _match_args('add', ['asdasdsadasd'])
761
 
    {'file_list': ['asdasdsadasd']}
762
 
    >>> _match_args('add', 'abc def gj'.split())
763
 
    {'file_list': ['abc', 'def', 'gj']}
764
 
    """
765
 
    # match argument pattern
766
 
    argform = cmd_args.get(cmd, [])
767
 
    argdict = {}
768
 
    # TODO: Need a way to express 'cp SRC... DEST', where it matches
769
 
    # all but one.
770
 
 
771
 
    # step through args and argform, allowing appropriate 0-many matches
772
 
    for ap in argform:
773
 
        argname = ap[:-1]
774
 
        if ap[-1] == '?':
775
 
            if args:
776
 
                argdict[argname] = args.pop(0)
777
 
        elif ap[-1] == '*':
778
 
            assert 0
779
 
        elif ap[-1] == '+':
780
 
            if not args:
781
 
                bailout("command %r needs one or more %s"
782
 
                        % (cmd, argname.upper()))
783
 
            else:
784
 
                argdict[argname + '_list'] = args[:]
785
 
                args = []
786
 
        else:
787
 
            # just a plain arg
788
 
            argname = ap
789
 
            if not args:
790
 
                bailout("command %r requires argument %s"
791
 
                        % (cmd, argname.upper()))
792
 
            else:
793
 
                argdict[argname] = args.pop(0)
794
 
            
795
 
    if args:
796
 
        bailout("extra arguments to command %s: %r"
797
 
                % (cmd, args))
798
 
 
799
 
    return argdict
800
 
 
801
 
 
802
 
 
803
 
def run_bzr(argv):
804
 
    """Execute a command.
805
 
 
806
 
    This is similar to main(), but without all the trappings for
807
 
    logging and error handling.
808
 
    """
809
 
    try:
810
 
        args, opts = parse_args(argv[1:])
811
 
        if 'help' in opts:
812
 
            # TODO: pass down other arguments in case they asked for
813
 
            # help on a command name?
814
 
            cmd_help()
815
 
            return 0
816
 
        elif 'version' in opts:
817
 
            cmd_version()
818
 
            return 0
819
 
        cmd = args.pop(0)
820
 
    except IndexError:
821
 
        log_error('usage: bzr COMMAND\n')
822
 
        log_error('  try "bzr help"\n')
823
 
        return 1
824
 
 
825
 
    try:
826
 
        cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
827
 
    except KeyError:
828
 
        bailout("unknown command " + `cmd`)
829
 
 
830
 
    # global option
831
 
    if 'profile' in opts:
832
 
        profile = True
833
 
        del opts['profile']
834
 
    else:
835
 
        profile = False
836
 
 
837
 
    # check options are reasonable
838
 
    allowed = cmd_options.get(cmd, [])
839
 
    for oname in opts:
840
 
        if oname not in allowed:
841
 
            bailout("option %r is not allowed for command %r"
842
 
                    % (oname, cmd))
843
 
 
844
 
    # mix arguments and options into one dictionary
845
 
    cmdargs = _match_args(cmd, args)
846
 
    for k, v in opts.items():
847
 
        cmdargs[k.replace('-', '_')] = v
848
 
 
849
 
    if profile:
850
 
        import hotshot
851
 
        prof = hotshot.Profile('.bzr.profile')
852
 
        ret = prof.runcall(cmd_handler, **cmdargs) or 0
853
 
        prof.close()
854
 
 
855
 
        import hotshot.stats
856
 
        stats = hotshot.stats.load('.bzr.profile')
857
 
        #stats.strip_dirs()
858
 
        stats.sort_stats('time')
859
 
        stats.print_stats(20)
860
 
    else:
861
 
        return cmd_handler(**cmdargs) or 0
862
 
 
863
 
 
864
 
 
865
 
def main(argv):
866
 
    ## TODO: Handle command-line options; probably know what options are valid for
867
 
    ## each command
868
 
 
869
 
    ## TODO: If the arguments are wrong, give a usage message rather
870
 
    ## than just a backtrace.
871
 
 
872
 
    bzrlib.trace.create_tracefile(argv)
873
 
    
874
 
    try:
875
 
        ret = run_bzr(argv)
876
 
        return ret
877
 
    except BzrError, e:
878
 
        log_error('bzr: error: ' + e.args[0] + '\n')
879
 
        if len(e.args) > 1:
880
 
            for h in e.args[1]:
881
 
                log_error('  ' + h + '\n')
882
 
        return 1
883
 
    except Exception, e:
884
 
        log_error('bzr: exception: %s\n' % e)
885
 
        log_error('    see .bzr.log for details\n')
886
 
        traceback.print_exc(None, bzrlib.trace._tracefile)
887
 
        traceback.print_exc(None, sys.stderr)
888
 
        return 1
889
 
 
890
 
    # TODO: Maybe nicer handling of IOError?
891
 
 
892
 
 
893
 
 
894
 
if __name__ == '__main__':
895
 
    sys.exit(main(sys.argv))
896
 
    ##import profile
897
 
    ##profile.run('main(sys.argv)')
898