/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-05-02 07:29:28 UTC
  • Revision ID: mbp@sourcefrog.net-20050502072928-4243b61c5272c9d9
- update doc build commands

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
    # XXX: This will fail if it's a hardlink; should use an AtomicFile class.
 
611
    f = open(b.abspath('.bzrignore'), 'at')
 
612
    f.write(name_pattern + '\n')
 
613
    f.close()
 
614
    
 
615
    inv = b.working_tree().inventory
 
616
    if inv.path2id('.bzrignore'):
 
617
        mutter('.bzrignore is already versioned')
 
618
    else:
 
619
        mutter('need to make new .bzrignore file versioned')
 
620
        b.add(['.bzrignore'])
 
621
 
 
622
 
 
623
 
 
624
def cmd_ignored():
 
625
    """List ignored files and the patterns that matched them.
 
626
      """
 
627
    tree = Branch('.').working_tree()
 
628
    for path, file_class, kind, file_id in tree.list_files():
 
629
        if file_class != 'I':
 
630
            continue
 
631
        ## XXX: Slightly inefficient since this was already calculated
 
632
        pat = tree.is_ignored(path)
 
633
        print '%-50s %s' % (path, pat)
 
634
 
 
635
 
 
636
def cmd_lookup_revision(revno):
 
637
    try:
 
638
        revno = int(revno)
 
639
    except ValueError:
 
640
        bailout("usage: lookup-revision REVNO",
 
641
                ["REVNO is a non-negative revision number for this branch"])
 
642
 
 
643
    print Branch('.').lookup_revision(revno) or NONE_STRING
 
644
 
 
645
 
 
646
 
 
647
def cmd_export(revno, dest):
 
648
    """Export past revision to destination directory."""
 
649
    b = Branch('.')
 
650
    rh = b.lookup_revision(int(revno))
 
651
    t = b.revision_tree(rh)
 
652
    t.export(dest)
 
653
 
 
654
def cmd_cat(revision, filename):
 
655
    """Print file to stdout."""
 
656
    b = Branch('.')
 
657
    b.print_file(b.relpath(filename), int(revision))
 
658
 
 
659
 
 
660
######################################################################
 
661
# internal/test commands
 
662
 
 
663
 
 
664
def cmd_uuid():
 
665
    """Print a newly-generated UUID."""
 
666
    print bzrlib.osutils.uuid()
 
667
 
 
668
 
 
669
 
 
670
def cmd_local_time_offset():
 
671
    print bzrlib.osutils.local_time_offset()
 
672
 
 
673
 
 
674
 
 
675
def cmd_commit(message=None, verbose=False):
 
676
    """Commit changes to a new revision.
 
677
 
 
678
    --message MESSAGE
 
679
        Description of changes in this revision; free form text.
 
680
        It is recommended that the first line be a single-sentence
 
681
        summary.
 
682
    --verbose
 
683
        Show status of changed files,
 
684
 
 
685
    TODO: Commit only selected files.
 
686
 
 
687
    TODO: Run hooks on tree to-be-committed, and after commit.
 
688
 
 
689
    TODO: Strict commit that fails if there are unknown or deleted files.
 
690
    """
 
691
 
 
692
    if not message:
 
693
        bailout("please specify a commit message")
 
694
    Branch('.').commit(message, verbose=verbose)
 
695
 
 
696
 
 
697
def cmd_check(dir='.'):
 
698
    """check: Consistency check of branch history.
 
699
 
 
700
    usage: bzr check [-v] [BRANCH]
 
701
 
 
702
    options:
 
703
      --verbose, -v         Show progress of checking.
 
704
 
 
705
    This command checks various invariants about the branch storage to
 
706
    detect data corruption or bzr bugs.
 
707
    """
 
708
    import bzrlib.check
 
709
    bzrlib.check.check(Branch(dir, find_root=False))
 
710
 
 
711
 
 
712
def cmd_is(pred, *rest):
 
713
    """Test whether PREDICATE is true."""
 
714
    try:
 
715
        cmd_handler = globals()['assert_' + pred.replace('-', '_')]
 
716
    except KeyError:
 
717
        bailout("unknown predicate: %s" % quotefn(pred))
 
718
        
 
719
    try:
 
720
        cmd_handler(*rest)
 
721
    except BzrCheckError:
 
722
        # by default we don't print the message so that this can
 
723
        # be used from shell scripts without producing noise
 
724
        sys.exit(1)
 
725
 
 
726
 
 
727
def cmd_whoami(email=False):
 
728
    """Show bzr user id.
 
729
 
 
730
    usage: bzr whoami
 
731
 
 
732
    options:
 
733
        --email             Show only the email address.
 
734
    
 
735
    """
 
736
    if email:
 
737
        print bzrlib.osutils.user_email()
 
738
    else:
 
739
        print bzrlib.osutils.username()
 
740
        
 
741
        
 
742
def cmd_gen_revision_id():
 
743
    print bzrlib.branch._gen_revision_id(time.time())
 
744
 
 
745
 
 
746
def cmd_selftest():
 
747
    """Run internal test suite"""
 
748
    ## -v, if present, is seen by doctest; the argument is just here
 
749
    ## so our parser doesn't complain
 
750
 
 
751
    ## TODO: --verbose option
 
752
 
 
753
    failures, tests = 0, 0
 
754
    
 
755
    import doctest, bzrlib.store, bzrlib.tests
 
756
    bzrlib.trace.verbose = False
 
757
 
 
758
    for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
 
759
        bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
 
760
        mf, mt = doctest.testmod(m)
 
761
        failures += mf
 
762
        tests += mt
 
763
        print '%-40s %3d tests' % (m.__name__, mt),
 
764
        if mf:
 
765
            print '%3d FAILED!' % mf
 
766
        else:
 
767
            print
 
768
 
 
769
    print '%-40s %3d tests' % ('total', tests),
 
770
    if failures:
 
771
        print '%3d FAILED!' % failures
 
772
    else:
 
773
        print
 
774
 
 
775
 
 
776
 
 
777
# deprecated
 
778
cmd_doctest = cmd_selftest
 
779
 
 
780
 
 
781
######################################################################
 
782
# help
 
783
 
 
784
 
 
785
def cmd_help(topic=None):
 
786
    if topic == None:
 
787
        print __doc__
 
788
    elif topic == 'commands':
 
789
        help_commands()
 
790
    else:
 
791
        # otherwise, maybe the name of a command?
 
792
        topic, cmdfn = get_cmd_handler(topic)
 
793
 
 
794
        doc = getdoc(cmdfn)
 
795
        if doc == None:
 
796
            bailout("sorry, no detailed help yet for %r" % topic)
 
797
 
 
798
        print doc
 
799
 
 
800
 
 
801
def help_commands():
 
802
    """List all commands"""
 
803
    accu = []
 
804
    for k in globals().keys():
 
805
        if k.startswith('cmd_'):
 
806
            accu.append(k[4:].replace('_','-'))
 
807
    accu.sort()
 
808
    print "bzr commands: "
 
809
    for x in accu:
 
810
        print "   " + x
 
811
    print "note: some of these commands are internal-use or obsolete"
 
812
    # TODO: Some kind of marker for internal-use commands?
 
813
    # TODO: Show aliases?
 
814
        
 
815
 
 
816
 
 
817
 
 
818
def cmd_version():
 
819
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
820
    print bzrlib.__copyright__
 
821
    print "http://bazaar-ng.org/"
 
822
    print
 
823
    print \
 
824
"""bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and
 
825
you may use, modify and redistribute it under the terms of the GNU 
 
826
General Public License version 2 or later."""
 
827
 
 
828
 
 
829
def cmd_rocks():
 
830
    """Statement of optimism."""
 
831
    print "it sure does!"
 
832
 
 
833
 
 
834
 
 
835
######################################################################
 
836
# main routine
 
837
 
 
838
 
 
839
# list of all available options; the rhs can be either None for an
 
840
# option that takes no argument, or a constructor function that checks
 
841
# the type.
 
842
OPTIONS = {
 
843
    'all':                    None,
 
844
    'help':                   None,
 
845
    'message':                unicode,
 
846
    'profile':                None,
 
847
    'revision':               int,
 
848
    'show-ids':               None,
 
849
    'timezone':               str,
 
850
    'verbose':                None,
 
851
    'version':                None,
 
852
    'email':                  None,
 
853
    }
 
854
 
 
855
SHORT_OPTIONS = {
 
856
    'm':                      'message',
 
857
    'r':                      'revision',
 
858
    'v':                      'verbose',
 
859
}
 
860
 
 
861
# List of options that apply to particular commands; commands not
 
862
# listed take none.
 
863
cmd_options = {
 
864
    'add':                    ['verbose'],
 
865
    'cat':                    ['revision'],
 
866
    'commit':                 ['message', 'verbose'],
 
867
    'deleted':                ['show-ids'],
 
868
    'diff':                   ['revision'],
 
869
    'inventory':              ['revision'],
 
870
    'log':                    ['timezone', 'verbose'],
 
871
    'ls':                     ['revision', 'verbose'],
 
872
    'remove':                 ['verbose'],
 
873
    'status':                 ['all'],
 
874
    'whoami':                 ['email'],
 
875
    }
 
876
 
 
877
 
 
878
cmd_args = {
 
879
    'add':                    ['file+'],
 
880
    'cat':                    ['filename'],
 
881
    'commit':                 [],
 
882
    'diff':                   ['file*'],
 
883
    'export':                 ['revno', 'dest'],
 
884
    'file-id':                ['filename'],
 
885
    'file-id-path':           ['filename'],
 
886
    'get-file-text':          ['text_id'],
 
887
    'get-inventory':          ['inventory_id'],
 
888
    'get-revision':           ['revision_id'],
 
889
    'get-revision-inventory': ['revision_id'],
 
890
    'help':                   ['topic?'],
 
891
    'ignore':                 ['name_pattern'],
 
892
    'init':                   [],
 
893
    'log':                    [],
 
894
    'lookup-revision':        ['revno'],
 
895
    'move':                   ['source$', 'dest'],
 
896
    'relpath':                ['filename'],
 
897
    'remove':                 ['file+'],
 
898
    'rename':                 ['from_name', 'to_name'],
 
899
    'renames':                ['dir?'],
 
900
    'root':                   ['filename?'],
 
901
    'status':                 [],
 
902
    }
 
903
 
 
904
 
 
905
def parse_args(argv):
 
906
    """Parse command line.
 
907
    
 
908
    Arguments and options are parsed at this level before being passed
 
909
    down to specific command handlers.  This routine knows, from a
 
910
    lookup table, something about the available options, what optargs
 
911
    they take, and which commands will accept them.
 
912
 
 
913
    >>> parse_args('--help'.split())
 
914
    ([], {'help': True})
 
915
    >>> parse_args('--version'.split())
 
916
    ([], {'version': True})
 
917
    >>> parse_args('status --all'.split())
 
918
    (['status'], {'all': True})
 
919
    >>> parse_args('commit --message=biter'.split())
 
920
    (['commit'], {'message': u'biter'})
 
921
    """
 
922
    args = []
 
923
    opts = {}
 
924
 
 
925
    # TODO: Maybe handle '--' to end options?
 
926
 
 
927
    while argv:
 
928
        a = argv.pop(0)
 
929
        if a[0] == '-':
 
930
            # option names must not be unicode
 
931
            a = str(a)
 
932
            optarg = None
 
933
            if a[1] == '-':
 
934
                mutter("  got option %r" % a)
 
935
                if '=' in a:
 
936
                    optname, optarg = a[2:].split('=', 1)
 
937
                else:
 
938
                    optname = a[2:]
 
939
                if optname not in OPTIONS:
 
940
                    bailout('unknown long option %r' % a)
 
941
            else:
 
942
                shortopt = a[1:]
 
943
                if shortopt not in SHORT_OPTIONS:
 
944
                    bailout('unknown short option %r' % a)
 
945
                optname = SHORT_OPTIONS[shortopt]
 
946
            
 
947
            if optname in opts:
 
948
                # XXX: Do we ever want to support this, e.g. for -r?
 
949
                bailout('repeated option %r' % a)
 
950
                
 
951
            optargfn = OPTIONS[optname]
 
952
            if optargfn:
 
953
                if optarg == None:
 
954
                    if not argv:
 
955
                        bailout('option %r needs an argument' % a)
 
956
                    else:
 
957
                        optarg = argv.pop(0)
 
958
                opts[optname] = optargfn(optarg)
 
959
            else:
 
960
                if optarg != None:
 
961
                    bailout('option %r takes no argument' % optname)
 
962
                opts[optname] = True
 
963
        else:
 
964
            args.append(a)
 
965
 
 
966
    return args, opts
 
967
 
 
968
 
 
969
 
 
970
def _match_args(cmd, args):
 
971
    """Check non-option arguments match required pattern.
 
972
 
 
973
    >>> _match_args('status', ['asdasdsadasd'])
 
974
    Traceback (most recent call last):
 
975
    ...
 
976
    BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
 
977
    >>> _match_args('add', ['asdasdsadasd'])
 
978
    {'file_list': ['asdasdsadasd']}
 
979
    >>> _match_args('add', 'abc def gj'.split())
 
980
    {'file_list': ['abc', 'def', 'gj']}
 
981
    """
 
982
    # match argument pattern
 
983
    argform = cmd_args.get(cmd, [])
 
984
    argdict = {}
 
985
    # TODO: Need a way to express 'cp SRC... DEST', where it matches
 
986
    # all but one.
 
987
 
 
988
    # step through args and argform, allowing appropriate 0-many matches
 
989
    for ap in argform:
 
990
        argname = ap[:-1]
 
991
        if ap[-1] == '?':
 
992
            if args:
 
993
                argdict[argname] = args.pop(0)
 
994
        elif ap[-1] == '*': # all remaining arguments
 
995
            if args:
 
996
                argdict[argname + '_list'] = args[:]
 
997
                args = []
 
998
            else:
 
999
                argdict[argname + '_list'] = None
 
1000
        elif ap[-1] == '+':
 
1001
            if not args:
 
1002
                bailout("command %r needs one or more %s"
 
1003
                        % (cmd, argname.upper()))
 
1004
            else:
 
1005
                argdict[argname + '_list'] = args[:]
 
1006
                args = []
 
1007
        elif ap[-1] == '$': # all but one
 
1008
            if len(args) < 2:
 
1009
                bailout("command %r needs one or more %s"
 
1010
                        % (cmd, argname.upper()))
 
1011
            argdict[argname + '_list'] = args[:-1]
 
1012
            args[:-1] = []                
 
1013
        else:
 
1014
            # just a plain arg
 
1015
            argname = ap
 
1016
            if not args:
 
1017
                bailout("command %r requires argument %s"
 
1018
                        % (cmd, argname.upper()))
 
1019
            else:
 
1020
                argdict[argname] = args.pop(0)
 
1021
            
 
1022
    if args:
 
1023
        bailout("extra arguments to command %s: %r"
 
1024
                % (cmd, args))
 
1025
 
 
1026
    return argdict
 
1027
 
 
1028
 
 
1029
 
 
1030
def run_bzr(argv):
 
1031
    """Execute a command.
 
1032
 
 
1033
    This is similar to main(), but without all the trappings for
 
1034
    logging and error handling.  
 
1035
    """
 
1036
 
 
1037
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
1038
    
 
1039
    try:
 
1040
        args, opts = parse_args(argv[1:])
 
1041
        if 'help' in opts:
 
1042
            # TODO: pass down other arguments in case they asked for
 
1043
            # help on a command name?
 
1044
            if args:
 
1045
                cmd_help(args[0])
 
1046
            else:
 
1047
                cmd_help()
 
1048
            return 0
 
1049
        elif 'version' in opts:
 
1050
            cmd_version()
 
1051
            return 0
 
1052
        cmd = str(args.pop(0))
 
1053
    except IndexError:
 
1054
        log_error('usage: bzr COMMAND')
 
1055
        log_error('  try "bzr help"')
 
1056
        return 1
 
1057
 
 
1058
    canonical_cmd, cmd_handler = get_cmd_handler(cmd)
 
1059
 
 
1060
    # global option
 
1061
    if 'profile' in opts:
 
1062
        profile = True
 
1063
        del opts['profile']
 
1064
    else:
 
1065
        profile = False
 
1066
 
 
1067
    # check options are reasonable
 
1068
    allowed = cmd_options.get(canonical_cmd, [])
 
1069
    for oname in opts:
 
1070
        if oname not in allowed:
 
1071
            bailout("option %r is not allowed for command %r"
 
1072
                    % (oname, cmd))
 
1073
 
 
1074
    # TODO: give an error if there are any mandatory options which are
 
1075
    # not specified?  Or maybe there shouldn't be any "mandatory
 
1076
    # options" (it is an oxymoron)
 
1077
 
 
1078
    # mix arguments and options into one dictionary
 
1079
    cmdargs = _match_args(canonical_cmd, args)
 
1080
    for k, v in opts.items():
 
1081
        cmdargs[k.replace('-', '_')] = v
 
1082
 
 
1083
    if profile:
 
1084
        import hotshot
 
1085
        pffileno, pfname = tempfile.mkstemp()
 
1086
        try:
 
1087
            prof = hotshot.Profile(pfname)
 
1088
            ret = prof.runcall(cmd_handler, **cmdargs) or 0
 
1089
            prof.close()
 
1090
 
 
1091
            import hotshot.stats
 
1092
            stats = hotshot.stats.load(pfname)
 
1093
            #stats.strip_dirs()
 
1094
            stats.sort_stats('time')
 
1095
            ## XXX: Might like to write to stderr or the trace file instead but
 
1096
            ## print_stats seems hardcoded to stdout
 
1097
            stats.print_stats(20)
 
1098
            
 
1099
            return ret
 
1100
 
 
1101
        finally:
 
1102
            os.close(pffileno)
 
1103
            os.remove(pfname)
 
1104
    else:
 
1105
        return cmd_handler(**cmdargs) or 0
 
1106
 
 
1107
 
 
1108
 
 
1109
def _report_exception(e, summary, quiet=False):
 
1110
    import traceback
 
1111
    log_error('bzr: ' + summary)
 
1112
    bzrlib.trace.log_exception(e)
 
1113
 
 
1114
    if not quiet:
 
1115
        tb = sys.exc_info()[2]
 
1116
        exinfo = traceback.extract_tb(tb)
 
1117
        if exinfo:
 
1118
            sys.stderr.write('  at %s:%d in %s()\n' % exinfo[-1][:3])
 
1119
        sys.stderr.write('  see ~/.bzr.log for debug information\n')
 
1120
 
 
1121
 
 
1122
def cmd_assert_fail():
 
1123
    assert False, "always fails"
 
1124
 
 
1125
 
 
1126
def main(argv):
 
1127
    import errno
 
1128
    
 
1129
    bzrlib.trace.create_tracefile(argv)
 
1130
 
 
1131
    try:
 
1132
        try:
 
1133
            ret = run_bzr(argv)
 
1134
            # do this here to catch EPIPE
 
1135
            sys.stdout.flush()
 
1136
            return ret
 
1137
        except BzrError, e:
 
1138
            _report_exception(e, 'error: ' + e.args[0])
 
1139
            if len(e.args) > 1:
 
1140
                for h in e.args[1]:
 
1141
                    # some explanation or hints
 
1142
                    log_error('  ' + h)
 
1143
            return 1
 
1144
        except AssertionError, e:
 
1145
            msg = 'assertion failed'
 
1146
            if str(e):
 
1147
                msg += ': ' + str(e)
 
1148
            _report_exception(e, msg)
 
1149
            return 2
 
1150
        except KeyboardInterrupt, e:
 
1151
            _report_exception(e, 'interrupted', quiet=True)
 
1152
            return 2
 
1153
        except Exception, e:
 
1154
            quiet = False
 
1155
            if isinstance(e, IOError) and e.errno == errno.EPIPE:
 
1156
                quiet = True
 
1157
                msg = 'broken pipe'
 
1158
            else:
 
1159
                msg = str(e).rstrip('\n')
 
1160
            _report_exception(e, msg, quiet)
 
1161
            return 2
 
1162
    finally:
 
1163
        bzrlib.trace.close_trace()
 
1164
 
 
1165
 
 
1166
if __name__ == '__main__':
 
1167
    sys.exit(main(sys.argv))