/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: mbp at sourcefrog
  • Date: 2005-04-09 06:36:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050409063640-728d43dff50e91d8c09c83e3
update rsync exclude patterns

Show diffs side-by-side

added added

removed removed

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