/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-28 10:01:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050428100144-e9d4ccfe5fb236df
- new 'bzr ignored' command!

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