/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-26 05:51:17 UTC
  • Revision ID: mbp@sourcefrog.net-20050426055116-e4bede04e549e4f6
- update doc upload scripts

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