/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2005-04-15 09:27:48 UTC
  • Revision ID: mbp@sourcefrog.net-20050415092748-5d5f0492f081387c
Doc

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