/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 [FILE...]
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, time, types, shutil, tempfile, traceback, fnmatch, difflib, os.path
66
 
from sets import Set
67
 
from pprint import pprint
68
 
from stat import *
69
 
from glob import glob
70
 
from inspect import getdoc
71
 
 
72
 
import bzrlib
73
 
from bzrlib.store import ImmutableStore
74
 
from bzrlib.trace import mutter, note, log_error
75
 
from bzrlib.errors import bailout, BzrError, BzrCheckError
76
 
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
77
 
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
78
 
from bzrlib.revision import Revision
79
 
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
80
 
     format_date
81
 
 
82
 
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
83
 
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
84
 
 
85
 
## standard representation
86
 
NONE_STRING = '(none)'
87
 
EMPTY = 'empty'
88
 
 
89
 
 
90
 
## TODO: Perhaps a different version of inventory commands that
91
 
## returns iterators...
92
 
 
93
 
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
94
 
 
95
 
## TODO: Some kind of locking on branches.  Perhaps there should be a
96
 
## parameter to the branch object saying whether we want a read or
97
 
## write lock; release it from destructor.  Perhaps don't even need a
98
 
## read lock to look at immutable objects?
99
 
 
100
 
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
101
 
## to compare output?
102
 
 
103
 
## TODO: Some kind of global code to generate the right Branch object
104
 
## to work on.  Almost, but not quite all, commands need one, and it
105
 
## can be taken either from their parameters or their working
106
 
## directory.
107
 
 
108
 
## TODO: rename command, needed soon: check destination doesn't exist
109
 
## either in working copy or tree; move working copy; update
110
 
## inventory; write out
111
 
 
112
 
## TODO: move command; check destination is a directory and will not
113
 
## clash; move it.
114
 
 
115
 
## TODO: command to show renames, one per line, as to->from
116
 
 
117
 
 
118
 
 
119
 
 
120
 
def cmd_status(all=False):
121
 
    """Display status summary.
122
 
 
123
 
    For each file there is a single line giving its file state and name.
124
 
    The name is that in the current revision unless it is deleted or
125
 
    missing, in which case the old name is shown.
126
 
    """
127
 
    #import bzrlib.status
128
 
    #bzrlib.status.tree_status(Branch('.'))
129
 
    Branch('.').show_status(show_all=all)
130
 
 
131
 
 
132
 
 
133
 
######################################################################
134
 
# examining history
135
 
def cmd_get_revision(revision_id):
136
 
    Branch('.').get_revision(revision_id).write_xml(sys.stdout)
137
 
 
138
 
 
139
 
def cmd_get_file_text(text_id):
140
 
    """Get contents of a file by hash."""
141
 
    sf = Branch('.').text_store[text_id]
142
 
    pumpfile(sf, sys.stdout)
143
 
 
144
 
 
145
 
 
146
 
######################################################################
147
 
# commands
148
 
    
149
 
 
150
 
def cmd_revno():
151
 
    """Show number of revisions on this branch"""
152
 
    print Branch('.').revno()
153
 
    
154
 
 
155
 
    
156
 
def cmd_add(file_list, verbose=False):
157
 
    """Add specified files or directories.
158
 
 
159
 
    In non-recursive mode, all the named items are added, regardless
160
 
    of whether they were previously ignored.  A warning is given if
161
 
    any of the named files are already versioned.
162
 
 
163
 
    In recursive mode (the default), files are treated the same way
164
 
    but the behaviour for directories is different.  Directories that
165
 
    are already versioned do not give a warning.  All directories,
166
 
    whether already versioned or not, are searched for files or
167
 
    subdirectories that are neither versioned or ignored, and these
168
 
    are added.  This search proceeds recursively into versioned
169
 
    directories.
170
 
 
171
 
    Therefore simply saying 'bzr add .' will version all files that
172
 
    are currently unknown.
173
 
    """
174
 
    bzrlib.add.smart_add(file_list, verbose)
175
 
    
176
 
 
177
 
def cmd_relpath(filename):
178
 
    """Show path of file relative to root"""
179
 
    print Branch(filename).relpath(filename)
180
 
 
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
 
# TODO: Maybe a 'mv' command that has the combined move/rename
199
 
# special behaviour of Unix?
200
 
 
201
 
def cmd_move(source_list, dest):
202
 
    b = Branch('.')
203
 
 
204
 
    b.move([b.relpath(s) for s in source_list], b.relpath(dest))
205
 
 
206
 
 
207
 
 
208
 
def cmd_rename(from_name, to_name):
209
 
    """Change the name of an entry.
210
 
 
211
 
    usage: bzr rename FROM_NAME TO_NAME
212
 
 
213
 
    examples:
214
 
      bzr rename frob.c frobber.c
215
 
      bzr rename src/frob.c lib/frob.c
216
 
 
217
 
    It is an error if the destination name exists.
218
 
 
219
 
    See also the 'move' command, which moves files into a different
220
 
    directory without changing their name.
221
 
 
222
 
    TODO: Some way to rename multiple files without invoking bzr for each
223
 
    one?"""
224
 
    b = Branch('.')
225
 
    b.rename_one(b.relpath(from_name), b.relpath(to_name))
226
 
    
227
 
 
228
 
 
229
 
 
230
 
def cmd_renames(dir='.'):
231
 
    """Show list of renamed files.
232
 
 
233
 
    usage: bzr renames [BRANCH]
234
 
 
235
 
    TODO: Option to show renames between two historical versions.
236
 
 
237
 
    TODO: Only show renames under dir, rather than in the whole branch.
238
 
    """
239
 
    b = Branch(dir)
240
 
    old_inv = b.basis_tree().inventory
241
 
    new_inv = b.read_working_inventory()
242
 
    
243
 
    renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
244
 
    renames.sort()
245
 
    for old_name, new_name in renames:
246
 
        print "%s => %s" % (old_name, new_name)        
247
 
 
248
 
 
249
 
 
250
 
def cmd_info():
251
 
    """info: Show statistical information for this branch
252
 
 
253
 
    usage: bzr info"""
254
 
    import info
255
 
    info.show_info(Branch('.'))        
256
 
    
257
 
 
258
 
 
259
 
def cmd_remove(file_list, verbose=False):
260
 
    b = Branch(file_list[0])
261
 
    b.remove([b.relpath(f) for f in file_list], verbose=verbose)
262
 
 
263
 
 
264
 
 
265
 
def cmd_file_id(filename):
266
 
    """Print file_id of a particular file or directory.
267
 
 
268
 
    usage: bzr file-id FILE
269
 
 
270
 
    The file_id is assigned when the file is first added and remains the
271
 
    same through all revisions where the file exists, even when it is
272
 
    moved or renamed.
273
 
    """
274
 
    b = Branch(filename)
275
 
    i = b.inventory.path2id(b.relpath(filename))
276
 
    if i == None:
277
 
        bailout("%r is not a versioned file" % filename)
278
 
    else:
279
 
        print i
280
 
 
281
 
 
282
 
def cmd_file_id_path(filename):
283
 
    """Print path of file_ids to a file or directory.
284
 
 
285
 
    usage: bzr file-id-path FILE
286
 
 
287
 
    This prints one line for each directory down to the target,
288
 
    starting at the branch root."""
289
 
    b = Branch(filename)
290
 
    inv = b.inventory
291
 
    fid = inv.path2id(b.relpath(filename))
292
 
    if fid == None:
293
 
        bailout("%r is not a versioned file" % filename)
294
 
    for fip in inv.get_idpath(fid):
295
 
        print fip
296
 
 
297
 
 
298
 
def cmd_revision_history():
299
 
    for patchid in Branch('.').revision_history():
300
 
        print patchid
301
 
 
302
 
 
303
 
def cmd_directories():
304
 
    for name, ie in Branch('.').read_working_inventory().directories():
305
 
        if name == '':
306
 
            print '.'
307
 
        else:
308
 
            print name
309
 
 
310
 
 
311
 
def cmd_missing():
312
 
    for name, ie in Branch('.').working_tree().missing():
313
 
        print name
314
 
 
315
 
 
316
 
def cmd_init():
317
 
    # TODO: Check we're not already in a working directory?  At the
318
 
    # moment you'll get an ugly error.
319
 
    
320
 
    # TODO: What if we're in a subdirectory of a branch?  Would like
321
 
    # to allow that, but then the parent may need to understand that
322
 
    # the children have disappeared, or should they be versioned in
323
 
    # both?
324
 
 
325
 
    # TODO: Take an argument/option for branch name.
326
 
    Branch('.', init=True)
327
 
 
328
 
 
329
 
def cmd_diff(revision=None, file_list=None):
330
 
    """bzr diff: Show differences in working tree.
331
 
    
332
 
    usage: bzr diff [-r REV] [FILE...]
333
 
 
334
 
    --revision REV
335
 
         Show changes since REV, rather than predecessor.
336
 
 
337
 
    If files are listed, only the changes in those files are listed.
338
 
    Otherwise, all changes for the tree are listed.
339
 
 
340
 
    TODO: Given two revision arguments, show the difference between them.
341
 
 
342
 
    TODO: Allow diff across branches.
343
 
 
344
 
    TODO: Option to use external diff command; could be GNU diff, wdiff,
345
 
          or a graphical diff.
346
 
 
347
 
    TODO: If a directory is given, diff everything under that.
348
 
 
349
 
    TODO: Selected-file diff is inefficient and doesn't show you deleted files.
350
 
"""
351
 
 
352
 
    ## TODO: Shouldn't be in the cmd function.
353
 
 
354
 
    b = Branch('.')
355
 
 
356
 
    if revision == None:
357
 
        old_tree = b.basis_tree()
358
 
    else:
359
 
        old_tree = b.revision_tree(b.lookup_revision(revision))
360
 
        
361
 
    new_tree = b.working_tree()
362
 
 
363
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
364
 
    old_label = ''
365
 
    new_label = ''
366
 
 
367
 
    DEVNULL = '/dev/null'
368
 
    # Windows users, don't panic about this filename -- it is a
369
 
    # special signal to GNU patch that the file should be created or
370
 
    # deleted respectively.
371
 
 
372
 
    # TODO: Generation of pseudo-diffs for added/deleted files could
373
 
    # be usefully made into a much faster special case.
374
 
 
375
 
    # TODO: Better to return them in sorted order I think.
376
 
 
377
 
    # FIXME: If given a file list, compare only those files rather
378
 
    # than comparing everything and then throwing stuff away.
379
 
    
380
 
    for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
381
 
 
382
 
        if file_list and new_name not in file_list:
383
 
            continue
384
 
        
385
 
        # Don't show this by default; maybe do it if an option is passed
386
 
        # idlabel = '      {%s}' % fid
387
 
        idlabel = ''
388
 
 
389
 
        # FIXME: Something about the diff format makes patch unhappy
390
 
        # with newly-added files.
391
 
 
392
 
        def diffit(oldlines, newlines, **kw):
393
 
            # FIXME: difflib is wrong if there is no trailing newline.
394
 
 
395
 
            # Special workaround for Python2.3, where difflib fails if
396
 
            # both sequences are empty.
397
 
            if oldlines or newlines:
398
 
                sys.stdout.writelines(difflib.unified_diff(oldlines, newlines, **kw))
399
 
            print
400
 
        
401
 
        if file_state in ['.', '?', 'I']:
402
 
            continue
403
 
        elif file_state == 'A':
404
 
            print '*** added %s %r' % (kind, new_name)
405
 
            if kind == 'file':
406
 
                diffit([],
407
 
                       new_tree.get_file(fid).readlines(),
408
 
                       fromfile=DEVNULL,
409
 
                       tofile=new_label + new_name + idlabel)
410
 
        elif file_state == 'D':
411
 
            assert isinstance(old_name, types.StringTypes)
412
 
            print '*** deleted %s %r' % (kind, old_name)
413
 
            if kind == 'file':
414
 
                diffit(old_tree.get_file(fid).readlines(), [],
415
 
                       fromfile=old_label + old_name + idlabel,
416
 
                       tofile=DEVNULL)
417
 
        elif file_state in ['M', 'R']:
418
 
            if file_state == 'M':
419
 
                assert kind == 'file'
420
 
                assert old_name == new_name
421
 
                print '*** modified %s %r' % (kind, new_name)
422
 
            elif file_state == 'R':
423
 
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
424
 
 
425
 
            if kind == 'file':
426
 
                diffit(old_tree.get_file(fid).readlines(),
427
 
                       new_tree.get_file(fid).readlines(),
428
 
                       fromfile=old_label + old_name + idlabel,
429
 
                       tofile=new_label + new_name)
430
 
        else:
431
 
            bailout("can't represent state %s {%s}" % (file_state, fid))
432
 
 
433
 
 
434
 
 
435
 
def cmd_deleted(show_ids=False):
436
 
    """List files deleted in the working tree.
437
 
 
438
 
    TODO: Show files deleted since a previous revision, or between two revisions.
439
 
    """
440
 
    b = Branch('.')
441
 
    old = b.basis_tree()
442
 
    new = b.working_tree()
443
 
 
444
 
    ## TODO: Much more efficient way to do this: read in new
445
 
    ## directories with readdir, rather than stating each one.  Same
446
 
    ## level of effort but possibly much less IO.  (Or possibly not,
447
 
    ## if the directories are very large...)
448
 
 
449
 
    for path, ie in old.inventory.iter_entries():
450
 
        if not new.has_id(ie.file_id):
451
 
            if show_ids:
452
 
                print '%-50s %s' % (path, ie.file_id)
453
 
            else:
454
 
                print path
455
 
 
456
 
 
457
 
 
458
 
def cmd_parse_inventory():
459
 
    import cElementTree
460
 
    
461
 
    cElementTree.ElementTree().parse(file('.bzr/inventory'))
462
 
 
463
 
 
464
 
 
465
 
def cmd_load_inventory():
466
 
    """Load inventory for timing purposes"""
467
 
    Branch('.').basis_tree().inventory
468
 
 
469
 
 
470
 
def cmd_dump_inventory():
471
 
    Branch('.').read_working_inventory().write_xml(sys.stdout)
472
 
 
473
 
 
474
 
def cmd_dump_new_inventory():
475
 
    import bzrlib.newinventory
476
 
    inv = Branch('.').basis_tree().inventory
477
 
    bzrlib.newinventory.write_inventory(inv, sys.stdout)
478
 
 
479
 
 
480
 
def cmd_load_new_inventory():
481
 
    import bzrlib.newinventory
482
 
    bzrlib.newinventory.read_new_inventory(sys.stdin)
483
 
                
484
 
    
485
 
def cmd_dump_slacker_inventory():
486
 
    import bzrlib.newinventory
487
 
    inv = Branch('.').basis_tree().inventory
488
 
    bzrlib.newinventory.write_slacker_inventory(inv, sys.stdout)
489
 
 
490
 
 
491
 
 
492
 
def cmd_dump_text_inventory():
493
 
    import bzrlib.textinv
494
 
    inv = Branch('.').basis_tree().inventory
495
 
    bzrlib.textinv.write_text_inventory(inv, sys.stdout)
496
 
 
497
 
 
498
 
def cmd_load_text_inventory():
499
 
    import bzrlib.textinv
500
 
    inv = bzrlib.textinv.read_text_inventory(sys.stdin)
501
 
    print 'loaded %d entries' % len(inv)
502
 
    
503
 
    
504
 
 
505
 
def cmd_root(filename=None):
506
 
    """Print the branch root."""
507
 
    print bzrlib.branch.find_branch_root(filename)
508
 
    
509
 
 
510
 
def cmd_log(timezone='original', verbose=False):
511
 
    """Show log of this branch.
512
 
 
513
 
    TODO: Options for utc; to show ids; to limit range; etc.
514
 
    """
515
 
    Branch('.').write_log(show_timezone=timezone, verbose=verbose)
516
 
 
517
 
 
518
 
def cmd_ls(revision=None, verbose=False):
519
 
    """List files in a tree.
520
 
 
521
 
    TODO: Take a revision or remote path and list that tree instead.
522
 
    """
523
 
    b = Branch('.')
524
 
    if revision == None:
525
 
        tree = b.working_tree()
526
 
    else:
527
 
        tree = b.revision_tree(b.lookup_revision(revision))
528
 
        
529
 
    for fp, fc, kind, fid in tree.list_files():
530
 
        if verbose:
531
 
            if kind == 'directory':
532
 
                kindch = '/'
533
 
            elif kind == 'file':
534
 
                kindch = ''
535
 
            else:
536
 
                kindch = '???'
537
 
                
538
 
            print '%-8s %s%s' % (fc, fp, kindch)
539
 
        else:
540
 
            print fp
541
 
    
542
 
    
543
 
 
544
 
def cmd_unknowns():
545
 
    """List unknown files"""
546
 
    for f in Branch('.').unknowns():
547
 
        print quotefn(f)
548
 
 
549
 
 
550
 
 
551
 
def cmd_ignored():
552
 
    """List ignored files and the patterns that matched them.
553
 
      """
554
 
    tree = Branch('.').working_tree()
555
 
    for path, file_class, kind, file_id in tree.list_files():
556
 
        if file_class != 'I':
557
 
            continue
558
 
        ## XXX: Slightly inefficient since this was already calculated
559
 
        pat = tree.is_ignored(path)
560
 
        print '%-50s %s' % (path, pat)
561
 
 
562
 
 
563
 
def cmd_lookup_revision(revno):
564
 
    try:
565
 
        revno = int(revno)
566
 
    except ValueError:
567
 
        bailout("usage: lookup-revision REVNO",
568
 
                ["REVNO is a non-negative revision number for this branch"])
569
 
 
570
 
    print Branch('.').lookup_revision(revno) or NONE_STRING
571
 
 
572
 
 
573
 
 
574
 
def cmd_export(revno, dest):
575
 
    """Export past revision to destination directory."""
576
 
    b = Branch('.')
577
 
    rh = b.lookup_revision(int(revno))
578
 
    t = b.revision_tree(rh)
579
 
    t.export(dest)
580
 
 
581
 
def cmd_cat(revision, filename):
582
 
    """Print file to stdout."""
583
 
    b = Branch('.')
584
 
    b.print_file(b.relpath(filename), int(revision))
585
 
 
586
 
 
587
 
######################################################################
588
 
# internal/test commands
589
 
 
590
 
 
591
 
def cmd_uuid():
592
 
    """Print a newly-generated UUID."""
593
 
    print bzrlib.osutils.uuid()
594
 
 
595
 
 
596
 
 
597
 
def cmd_local_time_offset():
598
 
    print bzrlib.osutils.local_time_offset()
599
 
 
600
 
 
601
 
 
602
 
def cmd_commit(message=None, verbose=False):
603
 
    """Commit changes to a new revision.
604
 
 
605
 
    --message MESSAGE
606
 
        Description of changes in this revision; free form text.
607
 
        It is recommended that the first line be a single-sentence
608
 
        summary.
609
 
    --verbose
610
 
        Show status of changed files,
611
 
 
612
 
    TODO: Commit only selected files.
613
 
 
614
 
    TODO: Run hooks on tree to-be-committed, and after commit.
615
 
 
616
 
    TODO: Strict commit that fails if there are unknown or deleted files.
617
 
    """
618
 
 
619
 
    if not message:
620
 
        bailout("please specify a commit message")
621
 
    Branch('.').commit(message, verbose=verbose)
622
 
 
623
 
 
624
 
def cmd_check(dir='.'):
625
 
    """check: Consistency check of branch history.
626
 
 
627
 
    usage: bzr check [-v] [BRANCH]
628
 
 
629
 
    options:
630
 
      --verbose, -v         Show progress of checking.
631
 
 
632
 
    This command checks various invariants about the branch storage to
633
 
    detect data corruption or bzr bugs.
634
 
    """
635
 
    import bzrlib.check
636
 
    bzrlib.check.check(Branch(dir, find_root=False))
637
 
 
638
 
 
639
 
def cmd_is(pred, *rest):
640
 
    """Test whether PREDICATE is true."""
641
 
    try:
642
 
        cmd_handler = globals()['assert_' + pred.replace('-', '_')]
643
 
    except KeyError:
644
 
        bailout("unknown predicate: %s" % quotefn(pred))
645
 
        
646
 
    try:
647
 
        cmd_handler(*rest)
648
 
    except BzrCheckError:
649
 
        # by default we don't print the message so that this can
650
 
        # be used from shell scripts without producing noise
651
 
        sys.exit(1)
652
 
 
653
 
 
654
 
def cmd_whoami():
655
 
    """Show bzr user id.
656
 
 
657
 
    TODO: Command to show only the email-address part as parsed out.
658
 
    """
659
 
    print bzrlib.osutils.username()
660
 
 
661
 
 
662
 
def cmd_gen_revision_id():
663
 
    print bzrlib.branch._gen_revision_id(time.time())
664
 
 
665
 
 
666
 
def cmd_selftest():
667
 
    """Run internal test suite"""
668
 
    ## -v, if present, is seen by doctest; the argument is just here
669
 
    ## so our parser doesn't complain
670
 
 
671
 
    ## TODO: --verbose option
672
 
 
673
 
    failures, tests = 0, 0
674
 
    
675
 
    import doctest, bzrlib.store, bzrlib.tests
676
 
    bzrlib.trace.verbose = False
677
 
 
678
 
    for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
679
 
        bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
680
 
        mf, mt = doctest.testmod(m)
681
 
        failures += mf
682
 
        tests += mt
683
 
        print '%-40s %3d tests' % (m.__name__, mt),
684
 
        if mf:
685
 
            print '%3d FAILED!' % mf
686
 
        else:
687
 
            print
688
 
 
689
 
    print '%-40s %3d tests' % ('total', tests),
690
 
    if failures:
691
 
        print '%3d FAILED!' % failures
692
 
    else:
693
 
        print
694
 
 
695
 
 
696
 
 
697
 
# deprecated
698
 
cmd_doctest = cmd_selftest
699
 
 
700
 
 
701
 
######################################################################
702
 
# help
703
 
 
704
 
 
705
 
def cmd_help(topic=None):
706
 
    if topic == None:
707
 
        print __doc__
708
 
        return
709
 
 
710
 
    # otherwise, maybe the name of a command?
711
 
    try:
712
 
        cmdfn = globals()['cmd_' + topic.replace('-', '_')]
713
 
    except KeyError:
714
 
        bailout("no help for %r" % topic)
715
 
 
716
 
    doc = getdoc(cmdfn)
717
 
    if doc == None:
718
 
        bailout("sorry, no detailed help yet for %r" % topic)
719
 
 
720
 
    print doc
721
 
        
722
 
 
723
 
 
724
 
 
725
 
def cmd_version():
726
 
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
727
 
    print bzrlib.__copyright__
728
 
    print "http://bazaar-ng.org/"
729
 
    print
730
 
    print \
731
 
"""bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and
732
 
you may use, modify and redistribute it under the terms of the GNU 
733
 
General Public License version 2 or later."""
734
 
 
735
 
 
736
 
def cmd_rocks():
737
 
    """Statement of optimism."""
738
 
    print "it sure does!"
739
 
 
740
 
 
741
 
 
742
 
######################################################################
743
 
# main routine
744
 
 
745
 
 
746
 
# list of all available options; the rhs can be either None for an
747
 
# option that takes no argument, or a constructor function that checks
748
 
# the type.
749
 
OPTIONS = {
750
 
    'all':                    None,
751
 
    'help':                   None,
752
 
    'message':                unicode,
753
 
    'profile':                None,
754
 
    'revision':               int,
755
 
    'show-ids':               None,
756
 
    'timezone':               str,
757
 
    'verbose':                None,
758
 
    'version':                None,
759
 
    }
760
 
 
761
 
SHORT_OPTIONS = {
762
 
    'm':                      'message',
763
 
    'r':                      'revision',
764
 
    'v':                      'verbose',
765
 
}
766
 
 
767
 
# List of options that apply to particular commands; commands not
768
 
# listed take none.
769
 
cmd_options = {
770
 
    'add':                    ['verbose'],
771
 
    'cat':                    ['revision'],
772
 
    'commit':                 ['message', 'verbose'],
773
 
    'deleted':                ['show-ids'],
774
 
    'diff':                   ['revision'],
775
 
    'inventory':              ['revision'],
776
 
    'log':                    ['timezone', 'verbose'],
777
 
    'ls':                     ['revision', 'verbose'],
778
 
    'remove':                 ['verbose'],
779
 
    'status':                 ['all'],
780
 
    }
781
 
 
782
 
 
783
 
cmd_args = {
784
 
    'add':                    ['file+'],
785
 
    'cat':                    ['filename'],
786
 
    'commit':                 [],
787
 
    'diff':                   ['file*'],
788
 
    'export':                 ['revno', 'dest'],
789
 
    'file-id':                ['filename'],
790
 
    'file-id-path':           ['filename'],
791
 
    'get-file-text':          ['text_id'],
792
 
    'get-inventory':          ['inventory_id'],
793
 
    'get-revision':           ['revision_id'],
794
 
    'get-revision-inventory': ['revision_id'],
795
 
    'help':                   ['topic?'],
796
 
    'init':                   [],
797
 
    'log':                    [],
798
 
    'lookup-revision':        ['revno'],
799
 
    'move':                   ['source$', 'dest'],
800
 
    'relpath':                ['filename'],
801
 
    'remove':                 ['file+'],
802
 
    'rename':                 ['from_name', 'to_name'],
803
 
    'renames':                ['dir?'],
804
 
    'root':                   ['filename?'],
805
 
    'status':                 [],
806
 
    }
807
 
 
808
 
 
809
 
def parse_args(argv):
810
 
    """Parse command line.
811
 
    
812
 
    Arguments and options are parsed at this level before being passed
813
 
    down to specific command handlers.  This routine knows, from a
814
 
    lookup table, something about the available options, what optargs
815
 
    they take, and which commands will accept them.
816
 
 
817
 
    >>> parse_args('--help'.split())
818
 
    ([], {'help': True})
819
 
    >>> parse_args('--version'.split())
820
 
    ([], {'version': True})
821
 
    >>> parse_args('status --all'.split())
822
 
    (['status'], {'all': True})
823
 
    >>> parse_args('commit --message=biter'.split())
824
 
    (['commit'], {'message': u'biter'})
825
 
    """
826
 
    args = []
827
 
    opts = {}
828
 
 
829
 
    # TODO: Maybe handle '--' to end options?
830
 
 
831
 
    while argv:
832
 
        a = argv.pop(0)
833
 
        if a[0] == '-':
834
 
            optarg = None
835
 
            if a[1] == '-':
836
 
                mutter("  got option %r" % a)
837
 
                if '=' in a:
838
 
                    optname, optarg = a[2:].split('=', 1)
839
 
                else:
840
 
                    optname = a[2:]
841
 
                if optname not in OPTIONS:
842
 
                    bailout('unknown long option %r' % a)
843
 
            else:
844
 
                shortopt = a[1:]
845
 
                if shortopt not in SHORT_OPTIONS:
846
 
                    bailout('unknown short option %r' % a)
847
 
                optname = SHORT_OPTIONS[shortopt]
848
 
            
849
 
            if optname in opts:
850
 
                # XXX: Do we ever want to support this, e.g. for -r?
851
 
                bailout('repeated option %r' % a)
852
 
                
853
 
            optargfn = OPTIONS[optname]
854
 
            if optargfn:
855
 
                if optarg == None:
856
 
                    if not argv:
857
 
                        bailout('option %r needs an argument' % a)
858
 
                    else:
859
 
                        optarg = argv.pop(0)
860
 
                opts[optname] = optargfn(optarg)
861
 
            else:
862
 
                if optarg != None:
863
 
                    bailout('option %r takes no argument' % optname)
864
 
                opts[optname] = True
865
 
        else:
866
 
            args.append(a)
867
 
 
868
 
    return args, opts
869
 
 
870
 
 
871
 
 
872
 
def _match_args(cmd, args):
873
 
    """Check non-option arguments match required pattern.
874
 
 
875
 
    >>> _match_args('status', ['asdasdsadasd'])
876
 
    Traceback (most recent call last):
877
 
    ...
878
 
    BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
879
 
    >>> _match_args('add', ['asdasdsadasd'])
880
 
    {'file_list': ['asdasdsadasd']}
881
 
    >>> _match_args('add', 'abc def gj'.split())
882
 
    {'file_list': ['abc', 'def', 'gj']}
883
 
    """
884
 
    # match argument pattern
885
 
    argform = cmd_args.get(cmd, [])
886
 
    argdict = {}
887
 
    # TODO: Need a way to express 'cp SRC... DEST', where it matches
888
 
    # all but one.
889
 
 
890
 
    # step through args and argform, allowing appropriate 0-many matches
891
 
    for ap in argform:
892
 
        argname = ap[:-1]
893
 
        if ap[-1] == '?':
894
 
            if args:
895
 
                argdict[argname] = args.pop(0)
896
 
        elif ap[-1] == '*': # all remaining arguments
897
 
            if args:
898
 
                argdict[argname + '_list'] = args[:]
899
 
                args = []
900
 
            else:
901
 
                argdict[argname + '_list'] = None
902
 
        elif ap[-1] == '+':
903
 
            if not args:
904
 
                bailout("command %r needs one or more %s"
905
 
                        % (cmd, argname.upper()))
906
 
            else:
907
 
                argdict[argname + '_list'] = args[:]
908
 
                args = []
909
 
        elif ap[-1] == '$': # all but one
910
 
            if len(args) < 2:
911
 
                bailout("command %r needs one or more %s"
912
 
                        % (cmd, argname.upper()))
913
 
            argdict[argname + '_list'] = args[:-1]
914
 
            args[:-1] = []                
915
 
        else:
916
 
            # just a plain arg
917
 
            argname = ap
918
 
            if not args:
919
 
                bailout("command %r requires argument %s"
920
 
                        % (cmd, argname.upper()))
921
 
            else:
922
 
                argdict[argname] = args.pop(0)
923
 
            
924
 
    if args:
925
 
        bailout("extra arguments to command %s: %r"
926
 
                % (cmd, args))
927
 
 
928
 
    return argdict
929
 
 
930
 
 
931
 
 
932
 
def run_bzr(argv):
933
 
    """Execute a command.
934
 
 
935
 
    This is similar to main(), but without all the trappings for
936
 
    logging and error handling.  
937
 
    """
938
 
 
939
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
940
 
    
941
 
    try:
942
 
        args, opts = parse_args(argv[1:])
943
 
        if 'help' in opts:
944
 
            # TODO: pass down other arguments in case they asked for
945
 
            # help on a command name?
946
 
            if args:
947
 
                cmd_help(args[0])
948
 
            else:
949
 
                cmd_help()
950
 
            return 0
951
 
        elif 'version' in opts:
952
 
            cmd_version()
953
 
            return 0
954
 
        cmd = args.pop(0)
955
 
    except IndexError:
956
 
        log_error('usage: bzr COMMAND')
957
 
        log_error('  try "bzr help"')
958
 
        return 1
959
 
 
960
 
    try:
961
 
        cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
962
 
    except KeyError:
963
 
        bailout("unknown command " + `cmd`)
964
 
 
965
 
    # global option
966
 
    if 'profile' in opts:
967
 
        profile = True
968
 
        del opts['profile']
969
 
    else:
970
 
        profile = False
971
 
 
972
 
    # check options are reasonable
973
 
    allowed = cmd_options.get(cmd, [])
974
 
    for oname in opts:
975
 
        if oname not in allowed:
976
 
            bailout("option %r is not allowed for command %r"
977
 
                    % (oname, cmd))
978
 
 
979
 
    # TODO: give an error if there are any mandatory options which are
980
 
    # not specified?  Or maybe there shouldn't be any "mandatory
981
 
    # options" (it is an oxymoron)
982
 
 
983
 
    # mix arguments and options into one dictionary
984
 
    cmdargs = _match_args(cmd, args)
985
 
    for k, v in opts.items():
986
 
        cmdargs[str(k.replace('-', '_'))] = v
987
 
 
988
 
    if profile:
989
 
        import hotshot
990
 
        pffileno, pfname = tempfile.mkstemp()
991
 
        try:
992
 
            prof = hotshot.Profile(pfname)
993
 
            ret = prof.runcall(cmd_handler, **cmdargs) or 0
994
 
            prof.close()
995
 
 
996
 
            import hotshot.stats
997
 
            stats = hotshot.stats.load(pfname)
998
 
            #stats.strip_dirs()
999
 
            stats.sort_stats('time')
1000
 
            ## XXX: Might like to write to stderr or the trace file instead but
1001
 
            ## print_stats seems hardcoded to stdout
1002
 
            stats.print_stats(20)
1003
 
            
1004
 
            return ret
1005
 
 
1006
 
        finally:
1007
 
            os.close(pffileno)
1008
 
            os.remove(pfname)
1009
 
    else:
1010
 
        return cmd_handler(**cmdargs) or 0
1011
 
 
1012
 
 
1013
 
 
1014
 
def main(argv):
1015
 
    ## TODO: Handle command-line options; probably know what options are valid for
1016
 
    ## each command
1017
 
 
1018
 
    ## TODO: If the arguments are wrong, give a usage message rather
1019
 
    ## than just a backtrace.
1020
 
 
1021
 
    bzrlib.trace.create_tracefile(argv)
1022
 
 
1023
 
    try:
1024
 
        try:
1025
 
            ret = run_bzr(argv)
1026
 
            return ret
1027
 
        except BzrError, e:
1028
 
            log_error('bzr: error: ' + e.args[0])
1029
 
            if len(e.args) > 1:
1030
 
                for h in e.args[1]:
1031
 
                    log_error('  ' + h)
1032
 
            traceback.print_exc(None, bzrlib.trace._tracefile)
1033
 
            log_error('(see ~/.bzr.log for debug information)')
1034
 
            return 1
1035
 
        except Exception, e:
1036
 
            log_error('bzr: exception: %s' % str(e).rstrip('\n'))
1037
 
            log_error('(see $HOME/.bzr.log for debug information)')
1038
 
            traceback.print_exc(None, bzrlib.trace._tracefile)
1039
 
            ## traceback.print_exc(None, sys.stderr)
1040
 
            return 1
1041
 
    finally:
1042
 
        bzrlib.trace.close_trace()
1043
 
 
1044
 
    ## TODO: Trap AssertionError
1045
 
 
1046
 
    # TODO: Maybe nicer handling of IOError especially for broken pipe.
1047
 
 
1048
 
 
1049
 
 
1050
 
if __name__ == '__main__':
1051
 
    sys.exit(main(sys.argv))
1052
 
    ##import profile
1053
 
    ##profile.run('main(sys.argv)')