/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

Partially fix pull.

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))