« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 294
- compare with another revision
- download diff
- download tarball
- view history from revision 294
- Committer: Martin Pool
- Date: 2005-04-28 07:24:55 UTC
- Revision ID: mbp@sourcefrog.net-20050428072453-7b99afa993a1e549
todo
- files added:
- bzrlib/remotebranch.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
2
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
18
import sys
19
import os
20
21
import bzrlib
22
from bzrlib import BZRDIR
23
from bzrlib.commands import Command
24
from bzrlib.branch import Branch
25
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
26
from bzrlib.errors import DivergedBranches
27
from bzrlib.option import Option
28
from bzrlib.revisionspec import RevisionSpec
29
import bzrlib.trace
30
from bzrlib.trace import mutter, note, log_error, warning
31
from bzrlib.workingtree import WorkingTree
32
33
34
class cmd_status(Command):
35
"""Display status summary.
36
37
This reports on versioned and unknown files, reporting them
38
grouped by state. Possible states are:
39
40
added
41
Versioned in the working copy but not in the previous revision.
42
43
removed
44
Versioned in the previous revision but removed or deleted
45
in the working copy.
46
47
renamed
48
Path of this file changed from the previous revision;
49
the text may also have changed. This includes files whose
50
parent directory was renamed.
51
52
modified
53
Text has changed since the previous revision.
54
55
unchanged
56
Nothing about this file has changed since the previous revision.
57
Only shown with --all.
58
59
unknown
60
Not versioned and not matching an ignore pattern.
61
62
To see ignored files use 'bzr ignored'. For details in the
63
changes to file texts, use 'bzr diff'.
64
65
If no arguments are specified, the status of the entire working
66
directory is shown. Otherwise, only the status of the specified
67
files or directories is reported. If a directory is given, status
68
is reported for everything inside that directory.
69
70
If a revision argument is given, the status is calculated against
71
that revision, or between two revisions if two are provided.
72
"""
73
74
# XXX: FIXME: bzr status should accept a -r option to show changes
75
# relative to a revision, or between revisions
76
77
# TODO: --no-recurse, --recurse options
78
79
takes_args = ['file*']
80
takes_options = ['all', 'show-ids']
81
aliases = ['st', 'stat']
82
83
def run(self, all=False, show_ids=False, file_list=None, revision=None):
84
if file_list:
85
b, relpath = Branch.open_containing(file_list[0])
86
if relpath == '' and len(file_list) == 1:
87
file_list = None
88
else:
89
# generate relative paths.
90
# note that if this is a remote branch, we would want
91
# relpath against the transport. RBC 20051018
92
tree = WorkingTree(b.base, b)
93
file_list = [tree.relpath(x) for x in file_list]
94
else:
95
b = Branch.open_containing('.')[0]
96
97
from bzrlib.status import show_status
98
show_status(b, show_unchanged=all, show_ids=show_ids,
99
specific_files=file_list, revision=revision)
100
101
102
class cmd_cat_revision(Command):
103
"""Write out metadata for a revision.
104
105
The revision to print can either be specified by a specific
106
revision identifier, or you can use --revision.
107
"""
108
109
hidden = True
110
takes_args = ['revision_id?']
111
takes_options = ['revision']
112
113
def run(self, revision_id=None, revision=None):
114
115
if revision_id is not None and revision is not None:
116
raise BzrCommandError('You can only supply one of revision_id or --revision')
117
if revision_id is None and revision is None:
118
raise BzrCommandError('You must supply either --revision or a revision_id')
119
b = Branch.open_containing('.')[0]
120
if revision_id is not None:
121
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
122
elif revision is not None:
123
for rev in revision:
124
if rev is None:
125
raise BzrCommandError('You cannot specify a NULL revision.')
126
revno, rev_id = rev.in_history(b)
127
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
128
129
130
class cmd_revno(Command):
131
"""Show current revision number.
132
133
This is equal to the number of revisions on this branch."""
134
def run(self):
135
print Branch.open_containing('.')[0].revno()
136
137
138
class cmd_revision_info(Command):
139
"""Show revision number and revision id for a given revision identifier.
140
"""
141
hidden = True
142
takes_args = ['revision_info*']
143
takes_options = ['revision']
144
def run(self, revision=None, revision_info_list=[]):
145
146
revs = []
147
if revision is not None:
148
revs.extend(revision)
149
if revision_info_list is not None:
150
for rev in revision_info_list:
151
revs.append(RevisionSpec(rev))
152
if len(revs) == 0:
153
raise BzrCommandError('You must supply a revision identifier')
154
155
b = Branch.open_containing('.')[0]
156
157
for rev in revs:
158
revinfo = rev.in_history(b)
159
if revinfo.revno is None:
160
print ' %s' % revinfo.rev_id
161
else:
162
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
163
164
165
class cmd_add(Command):
166
"""Add specified files or directories.
167
168
In non-recursive mode, all the named items are added, regardless
169
of whether they were previously ignored. A warning is given if
170
any of the named files are already versioned.
171
172
In recursive mode (the default), files are treated the same way
173
but the behaviour for directories is different. Directories that
174
are already versioned do not give a warning. All directories,
175
whether already versioned or not, are searched for files or
176
subdirectories that are neither versioned or ignored, and these
177
are added. This search proceeds recursively into versioned
178
directories. If no names are given '.' is assumed.
179
180
Therefore simply saying 'bzr add' will version all files that
181
are currently unknown.
182
183
Adding a file whose parent directory is not versioned will
184
implicitly add the parent, and so on up to the root. This means
185
you should never need to explictly add a directory, they'll just
186
get added when you add a file in the directory.
187
"""
188
takes_args = ['file*']
189
takes_options = ['no-recurse', 'quiet']
190
191
def run(self, file_list, no_recurse=False, quiet=False):
192
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
193
if quiet:
194
reporter = add_reporter_null
195
else:
196
reporter = add_reporter_print
197
smart_add(file_list, not no_recurse, reporter)
198
199
200
class cmd_mkdir(Command):
201
"""Create a new versioned directory.
202
203
This is equivalent to creating the directory and then adding it.
204
"""
205
takes_args = ['dir+']
206
207
def run(self, dir_list):
208
b = None
209
210
for d in dir_list:
211
os.mkdir(d)
212
if not b:
213
b = Branch.open_containing(d)[0]
214
b.add([d])
215
print 'added', d
216
217
218
class cmd_relpath(Command):
219
"""Show path of a file relative to root"""
220
takes_args = ['filename']
221
hidden = True
222
223
def run(self, filename):
224
branch, relpath = Branch.open_containing(filename)
225
print relpath
226
227
228
class cmd_inventory(Command):
229
"""Show inventory of the current working copy or a revision."""
230
takes_options = ['revision', 'show-ids']
231
232
def run(self, revision=None, show_ids=False):
233
b = Branch.open_containing('.')[0]
234
if revision is None:
235
inv = b.read_working_inventory()
236
else:
237
if len(revision) > 1:
238
raise BzrCommandError('bzr inventory --revision takes'
239
' exactly one revision identifier')
240
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
241
242
for path, entry in inv.entries():
243
if show_ids:
244
print '%-50s %s' % (path, entry.file_id)
245
else:
246
print path
247
248
249
class cmd_move(Command):
250
"""Move files to a different directory.
251
252
examples:
253
bzr move *.txt doc
254
255
The destination must be a versioned directory in the same branch.
256
"""
257
takes_args = ['source$', 'dest']
258
def run(self, source_list, dest):
259
b = Branch.open_containing('.')[0]
260
261
# TODO: glob expansion on windows?
262
tree = WorkingTree(b.base, b)
263
b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
264
265
266
class cmd_rename(Command):
267
"""Change the name of an entry.
268
269
examples:
270
bzr rename frob.c frobber.c
271
bzr rename src/frob.c lib/frob.c
272
273
It is an error if the destination name exists.
274
275
See also the 'move' command, which moves files into a different
276
directory without changing their name.
277
"""
278
# TODO: Some way to rename multiple files without invoking
279
# bzr for each one?"""
280
takes_args = ['from_name', 'to_name']
281
282
def run(self, from_name, to_name):
283
b = Branch.open_containing('.')[0]
284
tree = WorkingTree(b.base, b)
285
b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
286
287
288
class cmd_mv(Command):
289
"""Move or rename a file.
290
291
usage:
292
bzr mv OLDNAME NEWNAME
293
bzr mv SOURCE... DESTINATION
294
295
If the last argument is a versioned directory, all the other names
296
are moved into it. Otherwise, there must be exactly two arguments
297
and the file is changed to a new name, which must not already exist.
298
299
Files cannot be moved between branches.
300
"""
301
takes_args = ['names*']
302
def run(self, names_list):
303
if len(names_list) < 2:
304
raise BzrCommandError("missing file argument")
305
b = Branch.open_containing(names_list[0])[0]
306
tree = WorkingTree(b.base, b)
307
rel_names = [tree.relpath(x) for x in names_list]
308
309
if os.path.isdir(names_list[-1]):
310
# move into existing directory
311
for pair in b.move(rel_names[:-1], rel_names[-1]):
312
print "%s => %s" % pair
313
else:
314
if len(names_list) != 2:
315
raise BzrCommandError('to mv multiple files the destination '
316
'must be a versioned directory')
317
b.rename_one(rel_names[0], rel_names[1])
318
print "%s => %s" % (rel_names[0], rel_names[1])
319
320
321
322
323
class cmd_pull(Command):
324
"""Pull any changes from another branch into the current one.
325
326
If the location is omitted, the last-used location will be used.
327
Both the revision history and the working directory will be
328
updated.
329
330
This command only works on branches that have not diverged. Branches are
331
considered diverged if both branches have had commits without first
332
pulling from the other.
333
334
If branches have diverged, you can use 'bzr merge' to pull the text changes
335
from one into the other.
336
"""
337
takes_options = ['remember']
338
takes_args = ['location?']
339
340
def run(self, location=None, remember=False):
341
from bzrlib.merge import merge
342
import tempfile
343
from shutil import rmtree
344
import errno
345
346
br_to = Branch.open_containing('.')[0]
347
stored_loc = br_to.get_parent()
348
if location is None:
349
if stored_loc is None:
350
raise BzrCommandError("No pull location known or specified.")
351
else:
352
print "Using saved location: %s" % stored_loc
353
location = stored_loc
354
cache_root = tempfile.mkdtemp()
355
br_from = Branch.open(location)
356
br_from.lock_read()
357
try:
358
br_from.setup_caching(cache_root)
359
location = br_from.base
360
old_revno = br_to.revno()
361
old_revision_history = br_to.revision_history()
362
try:
363
br_to.update_revisions(br_from)
364
except DivergedBranches:
365
raise BzrCommandError("These branches have diverged."
366
" Try merge.")
367
new_revision_history = br_to.revision_history()
368
if new_revision_history != old_revision_history:
369
merge(('.', -1), ('.', old_revno), check_clean=False)
370
if stored_loc is None or remember:
371
br_to.set_parent(location)
372
finally:
373
br_from.unlock()
374
rmtree(cache_root)
375
376
377
378
class cmd_branch(Command):
379
"""Create a new copy of a branch.
380
381
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
382
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
383
384
To retrieve the branch as of a particular revision, supply the --revision
385
parameter, as in "branch foo/bar -r 5".
386
387
--basis is to speed up branching from remote branches. When specified, it
388
copies all the file-contents, inventory and revision data from the basis
389
branch before copying anything from the remote branch.
390
"""
391
takes_args = ['from_location', 'to_location?']
392
takes_options = ['revision', 'basis']
393
aliases = ['get', 'clone']
394
395
def run(self, from_location, to_location=None, revision=None, basis=None):
396
from bzrlib.clone import copy_branch
397
import tempfile
398
import errno
399
from shutil import rmtree
400
cache_root = tempfile.mkdtemp()
401
if revision is None:
402
revision = [None]
403
elif len(revision) > 1:
404
raise BzrCommandError(
405
'bzr branch --revision takes exactly 1 revision value')
406
try:
407
br_from = Branch.open(from_location)
408
except OSError, e:
409
if e.errno == errno.ENOENT:
410
raise BzrCommandError('Source location "%s" does not'
411
' exist.' % to_location)
412
else:
413
raise
414
br_from.lock_read()
415
try:
416
br_from.setup_caching(cache_root)
417
if basis is not None:
418
basis_branch = Branch.open_containing(basis)[0]
419
else:
420
basis_branch = None
421
if len(revision) == 1 and revision[0] is not None:
422
revision_id = revision[0].in_history(br_from)[1]
423
else:
424
revision_id = None
425
if to_location is None:
426
to_location = os.path.basename(from_location.rstrip("/\\"))
427
try:
428
os.mkdir(to_location)
429
except OSError, e:
430
if e.errno == errno.EEXIST:
431
raise BzrCommandError('Target directory "%s" already'
432
' exists.' % to_location)
433
if e.errno == errno.ENOENT:
434
raise BzrCommandError('Parent of "%s" does not exist.' %
435
to_location)
436
else:
437
raise
438
try:
439
copy_branch(br_from, to_location, revision_id, basis_branch)
440
except bzrlib.errors.NoSuchRevision:
441
rmtree(to_location)
442
msg = "The branch %s has no revision %d." % (from_location, revision[0])
443
raise BzrCommandError(msg)
444
except bzrlib.errors.UnlistableBranch:
445
msg = "The branch %s cannot be used as a --basis"
446
finally:
447
br_from.unlock()
448
rmtree(cache_root)
449
450
451
class cmd_renames(Command):
452
"""Show list of renamed files.
453
"""
454
# TODO: Option to show renames between two historical versions.
455
456
# TODO: Only show renames under dir, rather than in the whole branch.
457
takes_args = ['dir?']
458
459
def run(self, dir='.'):
460
b = Branch.open_containing(dir)[0]
461
old_inv = b.basis_tree().inventory
462
new_inv = b.read_working_inventory()
463
464
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
465
renames.sort()
466
for old_name, new_name in renames:
467
print "%s => %s" % (old_name, new_name)
468
469
470
class cmd_info(Command):
471
"""Show statistical information about a branch."""
472
takes_args = ['branch?']
473
474
def run(self, branch=None):
475
import info
476
b = Branch.open_containing(branch)[0]
477
info.show_info(b)
478
479
480
class cmd_remove(Command):
481
"""Make a file unversioned.
482
483
This makes bzr stop tracking changes to a versioned file. It does
484
not delete the working copy.
485
"""
486
takes_args = ['file+']
487
takes_options = ['verbose']
488
aliases = ['rm']
489
490
def run(self, file_list, verbose=False):
491
b = Branch.open_containing(file_list[0])[0]
492
tree = WorkingTree(b.base, b)
493
tree.remove([tree.relpath(f) for f in file_list], verbose=verbose)
494
495
496
class cmd_file_id(Command):
497
"""Print file_id of a particular file or directory.
498
499
The file_id is assigned when the file is first added and remains the
500
same through all revisions where the file exists, even when it is
501
moved or renamed.
502
"""
503
hidden = True
504
takes_args = ['filename']
505
def run(self, filename):
506
b, relpath = Branch.open_containing(filename)
507
i = b.inventory.path2id(relpath)
508
if i == None:
509
raise BzrError("%r is not a versioned file" % filename)
510
else:
511
print i
512
513
514
class cmd_file_path(Command):
515
"""Print path of file_ids to a file or directory.
516
517
This prints one line for each directory down to the target,
518
starting at the branch root."""
519
hidden = True
520
takes_args = ['filename']
521
def run(self, filename):
522
b, relpath = Branch.open_containing(filename)
523
inv = b.inventory
524
fid = inv.path2id(relpath)
525
if fid == None:
526
raise BzrError("%r is not a versioned file" % filename)
527
for fip in inv.get_idpath(fid):
528
print fip
529
530
531
class cmd_revision_history(Command):
532
"""Display list of revision ids on this branch."""
533
hidden = True
534
def run(self):
535
for patchid in Branch.open_containing('.')[0].revision_history():
536
print patchid
537
538
539
class cmd_ancestry(Command):
540
"""List all revisions merged into this branch."""
541
hidden = True
542
def run(self):
543
b = find_branch('.')
544
for revision_id in b.get_ancestry(b.last_revision()):
545
print revision_id
546
547
548
class cmd_directories(Command):
549
"""Display list of versioned directories in this branch."""
550
def run(self):
551
for name, ie in Branch.open_containing('.')[0].read_working_inventory().directories():
552
if name == '':
553
print '.'
554
else:
555
print name
556
557
558
class cmd_init(Command):
559
"""Make a directory into a versioned branch.
560
561
Use this to create an empty branch, or before importing an
562
existing project.
563
564
Recipe for importing a tree of files:
565
cd ~/project
566
bzr init
567
bzr add -v .
568
bzr status
569
bzr commit -m 'imported project'
570
"""
571
def run(self):
572
Branch.initialize('.')
573
574
575
class cmd_diff(Command):
576
"""Show differences in working tree.
577
578
If files are listed, only the changes in those files are listed.
579
Otherwise, all changes for the tree are listed.
580
581
examples:
582
bzr diff
583
bzr diff -r1
584
bzr diff -r1..2
585
"""
586
# TODO: Allow diff across branches.
587
# TODO: Option to use external diff command; could be GNU diff, wdiff,
588
# or a graphical diff.
589
590
# TODO: Python difflib is not exactly the same as unidiff; should
591
# either fix it up or prefer to use an external diff.
592
593
# TODO: If a directory is given, diff everything under that.
594
595
# TODO: Selected-file diff is inefficient and doesn't show you
596
# deleted files.
597
598
# TODO: This probably handles non-Unix newlines poorly.
599
600
takes_args = ['file*']
601
takes_options = ['revision', 'diff-options']
602
aliases = ['di', 'dif']
603
604
def run(self, revision=None, file_list=None, diff_options=None):
605
from bzrlib.diff import show_diff
606
607
if file_list:
608
b = Branch.open_containing(file_list[0])[0]
609
tree = WorkingTree(b.base, b)
610
file_list = [tree.relpath(f) for f in file_list]
611
if file_list == ['']:
612
# just pointing to top-of-tree
613
file_list = None
614
else:
615
b = Branch.open_containing('.')[0]
616
617
if revision is not None:
618
if len(revision) == 1:
619
show_diff(b, revision[0], specific_files=file_list,
620
external_diff_options=diff_options)
621
elif len(revision) == 2:
622
show_diff(b, revision[0], specific_files=file_list,
623
external_diff_options=diff_options,
624
revision2=revision[1])
625
else:
626
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
627
else:
628
show_diff(b, None, specific_files=file_list,
629
external_diff_options=diff_options)
630
631
632
633
634
class cmd_deleted(Command):
635
"""List files deleted in the working tree.
636
"""
637
# TODO: Show files deleted since a previous revision, or
638
# between two revisions.
639
# TODO: Much more efficient way to do this: read in new
640
# directories with readdir, rather than stating each one. Same
641
# level of effort but possibly much less IO. (Or possibly not,
642
# if the directories are very large...)
643
def run(self, show_ids=False):
644
b = Branch.open_containing('.')[0]
645
old = b.basis_tree()
646
new = b.working_tree()
647
for path, ie in old.inventory.iter_entries():
648
if not new.has_id(ie.file_id):
649
if show_ids:
650
print '%-50s %s' % (path, ie.file_id)
651
else:
652
print path
653
654
655
class cmd_modified(Command):
656
"""List files modified in working tree."""
657
hidden = True
658
def run(self):
659
from bzrlib.delta import compare_trees
660
661
b = Branch.open_containing('.')[0]
662
td = compare_trees(b.basis_tree(), b.working_tree())
663
664
for path, id, kind, text_modified, meta_modified in td.modified:
665
print path
666
667
668
669
class cmd_added(Command):
670
"""List files added in working tree."""
671
hidden = True
672
def run(self):
673
b = Branch.open_containing('.')[0]
674
wt = b.working_tree()
675
basis_inv = b.basis_tree().inventory
676
inv = wt.inventory
677
for file_id in inv:
678
if file_id in basis_inv:
679
continue
680
path = inv.id2path(file_id)
681
if not os.access(b.abspath(path), os.F_OK):
682
continue
683
print path
684
685
686
687
class cmd_root(Command):
688
"""Show the tree root directory.
689
690
The root is the nearest enclosing directory with a .bzr control
691
directory."""
692
takes_args = ['filename?']
693
def run(self, filename=None):
694
"""Print the branch root."""
695
b = Branch.open_containing(filename)[0]
696
print b.base
697
698
699
class cmd_log(Command):
700
"""Show log of this branch.
701
702
To request a range of logs, you can use the command -r begin:end
703
-r revision requests a specific revision, -r :end or -r begin: are
704
also valid.
705
"""
706
707
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
708
709
takes_args = ['filename?']
710
takes_options = [Option('forward',
711
help='show from oldest to newest'),
712
'timezone', 'verbose',
713
'show-ids', 'revision',
714
Option('line', help='format with one line per revision'),
715
'long',
716
Option('message',
717
help='show revisions whose message matches this regexp',
718
type=str),
719
Option('short', help='use moderately short format'),
720
]
721
722
def run(self, filename=None, timezone='original',
723
verbose=False,
724
show_ids=False,
725
forward=False,
726
revision=None,
727
message=None,
728
long=False,
729
short=False,
730
line=False):
731
from bzrlib.log import log_formatter, show_log
732
import codecs
733
assert message is None or isinstance(message, basestring), \
734
"invalid message argument %r" % message
735
direction = (forward and 'forward') or 'reverse'
736
737
if filename:
738
b, fp = Branch.open_containing(filename)
739
if fp != '':
740
file_id = b.read_working_inventory().path2id(fp)
741
else:
742
file_id = None # points to branch root
743
else:
744
b, relpath = Branch.open_containing('.')
745
file_id = None
746
747
if revision is None:
748
rev1 = None
749
rev2 = None
750
elif len(revision) == 1:
751
rev1 = rev2 = revision[0].in_history(b).revno
752
elif len(revision) == 2:
753
rev1 = revision[0].in_history(b).revno
754
rev2 = revision[1].in_history(b).revno
755
else:
756
raise BzrCommandError('bzr log --revision takes one or two values.')
757
758
if rev1 == 0:
759
rev1 = None
760
if rev2 == 0:
761
rev2 = None
762
763
mutter('encoding log as %r' % bzrlib.user_encoding)
764
765
# use 'replace' so that we don't abort if trying to write out
766
# in e.g. the default C locale.
767
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
768
769
log_format = 'long'
770
if short:
771
log_format = 'short'
772
if line:
773
log_format = 'line'
774
lf = log_formatter(log_format,
775
show_ids=show_ids,
776
to_file=outf,
777
show_timezone=timezone)
778
779
show_log(b,
780
lf,
781
file_id,
782
verbose=verbose,
783
direction=direction,
784
start_revision=rev1,
785
end_revision=rev2,
786
search=message)
787
788
789
790
class cmd_touching_revisions(Command):
791
"""Return revision-ids which affected a particular file.
792
793
A more user-friendly interface is "bzr log FILE"."""
794
hidden = True
795
takes_args = ["filename"]
796
def run(self, filename):
797
b, relpath = Branch.open_containing(filename)[0]
798
inv = b.read_working_inventory()
799
file_id = inv.path2id(relpath)
800
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
801
print "%6d %s" % (revno, what)
802
803
804
class cmd_ls(Command):
805
"""List files in a tree.
806
"""
807
# TODO: Take a revision or remote path and list that tree instead.
808
hidden = True
809
def run(self, revision=None, verbose=False):
810
b, relpath = Branch.open_containing('.')[0]
811
if revision == None:
812
tree = b.working_tree()
813
else:
814
tree = b.revision_tree(revision.in_history(b).rev_id)
815
for fp, fc, kind, fid, entry in tree.list_files():
816
if verbose:
817
kindch = entry.kind_character()
818
print '%-8s %s%s' % (fc, fp, kindch)
819
else:
820
print fp
821
822
823
824
class cmd_unknowns(Command):
825
"""List unknown files."""
826
def run(self):
827
from bzrlib.osutils import quotefn
828
for f in Branch.open_containing('.')[0].unknowns():
829
print quotefn(f)
830
831
832
833
class cmd_ignore(Command):
834
"""Ignore a command or pattern.
835
836
To remove patterns from the ignore list, edit the .bzrignore file.
837
838
If the pattern contains a slash, it is compared to the whole path
839
from the branch root. Otherwise, it is compared to only the last
840
component of the path. To match a file only in the root directory,
841
prepend './'.
842
843
Ignore patterns are case-insensitive on case-insensitive systems.
844
845
Note: wildcards must be quoted from the shell on Unix.
846
847
examples:
848
bzr ignore ./Makefile
849
bzr ignore '*.class'
850
"""
851
# TODO: Complain if the filename is absolute
852
takes_args = ['name_pattern']
853
854
def run(self, name_pattern):
855
from bzrlib.atomicfile import AtomicFile
856
import os.path
857
858
b, relpath = Branch.open_containing('.')
859
ifn = b.abspath('.bzrignore')
860
861
if os.path.exists(ifn):
862
f = open(ifn, 'rt')
863
try:
864
igns = f.read().decode('utf-8')
865
finally:
866
f.close()
867
else:
868
igns = ''
869
870
# TODO: If the file already uses crlf-style termination, maybe
871
# we should use that for the newly added lines?
872
873
if igns and igns[-1] != '\n':
874
igns += '\n'
875
igns += name_pattern + '\n'
876
877
try:
878
f = AtomicFile(ifn, 'wt')
879
f.write(igns.encode('utf-8'))
880
f.commit()
881
finally:
882
f.close()
883
884
inv = b.working_tree().inventory
885
if inv.path2id('.bzrignore'):
886
mutter('.bzrignore is already versioned')
887
else:
888
mutter('need to make new .bzrignore file versioned')
889
b.add(['.bzrignore'])
890
891
892
893
class cmd_ignored(Command):
894
"""List ignored files and the patterns that matched them.
895
896
See also: bzr ignore"""
897
def run(self):
898
tree = Branch.open_containing('.')[0].working_tree()
899
for path, file_class, kind, file_id, entry in tree.list_files():
900
if file_class != 'I':
901
continue
902
## XXX: Slightly inefficient since this was already calculated
903
pat = tree.is_ignored(path)
904
print '%-50s %s' % (path, pat)
905
906
907
class cmd_lookup_revision(Command):
908
"""Lookup the revision-id from a revision-number
909
910
example:
911
bzr lookup-revision 33
912
"""
913
hidden = True
914
takes_args = ['revno']
915
916
def run(self, revno):
917
try:
918
revno = int(revno)
919
except ValueError:
920
raise BzrCommandError("not a valid revision-number: %r" % revno)
921
922
print Branch.open_containing('.')[0].get_rev_id(revno)
923
924
925
class cmd_export(Command):
926
"""Export past revision to destination directory.
927
928
If no revision is specified this exports the last committed revision.
929
930
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
931
given, try to find the format with the extension. If no extension
932
is found exports to a directory (equivalent to --format=dir).
933
934
Root may be the top directory for tar, tgz and tbz2 formats. If none
935
is given, the top directory will be the root name of the file."""
936
# TODO: list known exporters
937
takes_args = ['dest']
938
takes_options = ['revision', 'format', 'root']
939
def run(self, dest, revision=None, format=None, root=None):
940
import os.path
941
b = Branch.open_containing('.')[0]
942
if revision is None:
943
rev_id = b.last_revision()
944
else:
945
if len(revision) != 1:
946
raise BzrError('bzr export --revision takes exactly 1 argument')
947
rev_id = revision[0].in_history(b).rev_id
948
t = b.revision_tree(rev_id)
949
arg_root, ext = os.path.splitext(os.path.basename(dest))
950
if ext in ('.gz', '.bz2'):
951
new_root, new_ext = os.path.splitext(arg_root)
952
if new_ext == '.tar':
953
arg_root = new_root
954
ext = new_ext + ext
955
if root is None:
956
root = arg_root
957
if not format:
958
if ext in (".tar",):
959
format = "tar"
960
elif ext in (".tar.gz", ".tgz"):
961
format = "tgz"
962
elif ext in (".tar.bz2", ".tbz2"):
963
format = "tbz2"
964
else:
965
format = "dir"
966
t.export(dest, format, root)
967
968
969
class cmd_cat(Command):
970
"""Write a file's text from a previous revision."""
971
972
takes_options = ['revision']
973
takes_args = ['filename']
974
975
def run(self, filename, revision=None):
976
if revision is None:
977
raise BzrCommandError("bzr cat requires a revision number")
978
elif len(revision) != 1:
979
raise BzrCommandError("bzr cat --revision takes exactly one number")
980
b, relpath = Branch.open_containing(filename)
981
b.print_file(relpath, revision[0].in_history(b).revno)
982
983
984
class cmd_local_time_offset(Command):
985
"""Show the offset in seconds from GMT to local time."""
986
hidden = True
987
def run(self):
988
print bzrlib.osutils.local_time_offset()
989
990
991
992
class cmd_commit(Command):
993
"""Commit changes into a new revision.
994
995
If no arguments are given, the entire tree is committed.
996
997
If selected files are specified, only changes to those files are
998
committed. If a directory is specified then the directory and everything
999
within it is committed.
1000
1001
A selected-file commit may fail in some cases where the committed
1002
tree would be invalid, such as trying to commit a file in a
1003
newly-added directory that is not itself committed.
1004
"""
1005
# TODO: Run hooks on tree to-be-committed, and after commit.
1006
1007
# TODO: Strict commit that fails if there are deleted files.
1008
# (what does "deleted files" mean ??)
1009
1010
# TODO: Give better message for -s, --summary, used by tla people
1011
1012
# XXX: verbose currently does nothing
1013
1014
takes_args = ['selected*']
1015
takes_options = ['message', 'verbose',
1016
Option('unchanged',
1017
help='commit even if nothing has changed'),
1018
Option('file', type=str,
1019
argname='msgfile',
1020
help='file containing commit message'),
1021
Option('strict',
1022
help="refuse to commit if there are unknown "
1023
"files in the working tree."),
1024
]
1025
aliases = ['ci', 'checkin']
1026
1027
def run(self, message=None, file=None, verbose=True, selected_list=None,
1028
unchanged=False, strict=False):
1029
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1030
StrictCommitFailed)
1031
from bzrlib.msgeditor import edit_commit_message
1032
from bzrlib.status import show_status
1033
from cStringIO import StringIO
1034
1035
b = Branch.open_containing('.')[0]
1036
tree = WorkingTree(b.base, b)
1037
if selected_list:
1038
selected_list = [tree.relpath(s) for s in selected_list]
1039
if message is None and not file:
1040
catcher = StringIO()
1041
show_status(b, specific_files=selected_list,
1042
to_file=catcher)
1043
message = edit_commit_message(catcher.getvalue())
1044
1045
if message is None:
1046
raise BzrCommandError("please specify a commit message"
1047
" with either --message or --file")
1048
elif message and file:
1049
raise BzrCommandError("please specify either --message or --file")
1050
1051
if file:
1052
import codecs
1053
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1054
1055
if message == "":
1056
raise BzrCommandError("empty commit message specified")
1057
1058
try:
1059
b.commit(message, specific_files=selected_list,
1060
allow_pointless=unchanged, strict=strict)
1061
except PointlessCommit:
1062
# FIXME: This should really happen before the file is read in;
1063
# perhaps prepare the commit; get the message; then actually commit
1064
raise BzrCommandError("no changes to commit",
1065
["use --unchanged to commit anyhow"])
1066
except ConflictsInTree:
1067
raise BzrCommandError("Conflicts detected in working tree. "
1068
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1069
except StrictCommitFailed:
1070
raise BzrCommandError("Commit refused because there are unknown "
1071
"files in the working tree.")
1072
1073
1074
class cmd_check(Command):
1075
"""Validate consistency of branch history.
1076
1077
This command checks various invariants about the branch storage to
1078
detect data corruption or bzr bugs.
1079
"""
1080
takes_args = ['dir?']
1081
takes_options = ['verbose']
1082
1083
def run(self, dir='.', verbose=False):
1084
from bzrlib.check import check
1085
check(Branch.open_containing(dir)[0], verbose)
1086
1087
1088
class cmd_scan_cache(Command):
1089
hidden = True
1090
def run(self):
1091
from bzrlib.hashcache import HashCache
1092
1093
c = HashCache('.')
1094
c.read()
1095
c.scan()
1096
1097
print '%6d stats' % c.stat_count
1098
print '%6d in hashcache' % len(c._cache)
1099
print '%6d files removed from cache' % c.removed_count
1100
print '%6d hashes updated' % c.update_count
1101
print '%6d files changed too recently to cache' % c.danger_count
1102
1103
if c.needs_write:
1104
c.write()
1105
1106
1107
1108
class cmd_upgrade(Command):
1109
"""Upgrade branch storage to current format.
1110
1111
The check command or bzr developers may sometimes advise you to run
1112
this command.
1113
1114
This version of this command upgrades from the full-text storage
1115
used by bzr 0.0.8 and earlier to the weave format (v5).
1116
"""
1117
takes_args = ['dir?']
1118
1119
def run(self, dir='.'):
1120
from bzrlib.upgrade import upgrade
1121
upgrade(dir)
1122
1123
1124
class cmd_whoami(Command):
1125
"""Show bzr user id."""
1126
takes_options = ['email']
1127
1128
def run(self, email=False):
1129
try:
1130
b = bzrlib.branch.Branch.open_containing('.')[0]
1131
config = bzrlib.config.BranchConfig(b)
1132
except NotBranchError:
1133
config = bzrlib.config.GlobalConfig()
1134
1135
if email:
1136
print config.user_email()
1137
else:
1138
print config.username()
1139
1140
1141
class cmd_selftest(Command):
1142
"""Run internal test suite.
1143
1144
This creates temporary test directories in the working directory,
1145
but not existing data is affected. These directories are deleted
1146
if the tests pass, or left behind to help in debugging if they
1147
fail.
1148
1149
If arguments are given, they are regular expressions that say
1150
which tests should run.
1151
"""
1152
# TODO: --list should give a list of all available tests
1153
hidden = True
1154
takes_args = ['testspecs*']
1155
takes_options = ['verbose',
1156
Option('one', help='stop when one test fails'),
1157
]
1158
1159
def run(self, testspecs_list=None, verbose=False, one=False):
1160
import bzrlib.ui
1161
from bzrlib.selftest import selftest
1162
# we don't want progress meters from the tests to go to the
1163
# real output; and we don't want log messages cluttering up
1164
# the real logs.
1165
save_ui = bzrlib.ui.ui_factory
1166
bzrlib.trace.info('running tests...')
1167
try:
1168
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1169
if testspecs_list is not None:
1170
pattern = '|'.join(testspecs_list)
1171
else:
1172
pattern = ".*"
1173
result = selftest(verbose=verbose,
1174
pattern=pattern,
1175
stop_on_failure=one)
1176
if result:
1177
bzrlib.trace.info('tests passed')
1178
else:
1179
bzrlib.trace.info('tests failed')
1180
return int(not result)
1181
finally:
1182
bzrlib.ui.ui_factory = save_ui
1183
1184
1185
def show_version():
1186
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1187
# is bzrlib itself in a branch?
1188
bzrrev = bzrlib.get_bzr_revision()
1189
if bzrrev:
1190
print " (bzr checkout, revision %d {%s})" % bzrrev
1191
print bzrlib.__copyright__
1192
print "http://bazaar-ng.org/"
1193
print
1194
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1195
print "you may use, modify and redistribute it under the terms of the GNU"
1196
print "General Public License version 2 or later."
1197
1198
1199
class cmd_version(Command):
1200
"""Show version of bzr."""
1201
def run(self):
1202
show_version()
1203
1204
class cmd_rocks(Command):
1205
"""Statement of optimism."""
1206
hidden = True
1207
def run(self):
1208
print "it sure does!"
1209
1210
1211
class cmd_find_merge_base(Command):
1212
"""Find and print a base revision for merging two branches.
1213
"""
1214
# TODO: Options to specify revisions on either side, as if
1215
# merging only part of the history.
1216
takes_args = ['branch', 'other']
1217
hidden = True
1218
1219
def run(self, branch, other):
1220
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1221
1222
branch1 = Branch.open_containing(branch)[0]
1223
branch2 = Branch.open_containing(other)[0]
1224
1225
history_1 = branch1.revision_history()
1226
history_2 = branch2.revision_history()
1227
1228
last1 = branch1.last_revision()
1229
last2 = branch2.last_revision()
1230
1231
source = MultipleRevisionSources(branch1, branch2)
1232
1233
base_rev_id = common_ancestor(last1, last2, source)
1234
1235
print 'merge base is revision %s' % base_rev_id
1236
1237
return
1238
1239
if base_revno is None:
1240
raise bzrlib.errors.UnrelatedBranches()
1241
1242
print ' r%-6d in %s' % (base_revno, branch)
1243
1244
other_revno = branch2.revision_id_to_revno(base_revid)
1245
1246
print ' r%-6d in %s' % (other_revno, other)
1247
1248
1249
1250
class cmd_merge(Command):
1251
"""Perform a three-way merge.
1252
1253
The branch is the branch you will merge from. By default, it will
1254
merge the latest revision. If you specify a revision, that
1255
revision will be merged. If you specify two revisions, the first
1256
will be used as a BASE, and the second one as OTHER. Revision
1257
numbers are always relative to the specified branch.
1258
1259
By default bzr will try to merge in all new work from the other
1260
branch, automatically determining an appropriate base. If this
1261
fails, you may need to give an explicit base.
1262
1263
Examples:
1264
1265
To merge the latest revision from bzr.dev
1266
bzr merge ../bzr.dev
1267
1268
To merge changes up to and including revision 82 from bzr.dev
1269
bzr merge -r 82 ../bzr.dev
1270
1271
To merge the changes introduced by 82, without previous changes:
1272
bzr merge -r 81..82 ../bzr.dev
1273
1274
merge refuses to run if there are any uncommitted changes, unless
1275
--force is given.
1276
"""
1277
takes_args = ['branch?']
1278
takes_options = ['revision', 'force', 'merge-type']
1279
1280
def run(self, branch=None, revision=None, force=False,
1281
merge_type=None):
1282
from bzrlib.merge import merge
1283
from bzrlib.merge_core import ApplyMerge3
1284
if merge_type is None:
1285
merge_type = ApplyMerge3
1286
if branch is None:
1287
branch = Branch.open_containing('.')[0].get_parent()
1288
if branch is None:
1289
raise BzrCommandError("No merge location known or specified.")
1290
else:
1291
print "Using saved location: %s" % branch
1292
if revision is None or len(revision) < 1:
1293
base = [None, None]
1294
other = [branch, -1]
1295
else:
1296
if len(revision) == 1:
1297
base = [None, None]
1298
other = [branch, revision[0].in_history(branch).revno]
1299
else:
1300
assert len(revision) == 2
1301
if None in revision:
1302
raise BzrCommandError(
1303
"Merge doesn't permit that revision specifier.")
1304
b = Branch.open(branch)
1305
1306
base = [branch, revision[0].in_history(b).revno]
1307
other = [branch, revision[1].in_history(b).revno]
1308
1309
try:
1310
merge(other, base, check_clean=(not force), merge_type=merge_type)
1311
except bzrlib.errors.AmbiguousBase, e:
1312
m = ("sorry, bzr can't determine the right merge base yet\n"
1313
"candidates are:\n "
1314
+ "\n ".join(e.bases)
1315
+ "\n"
1316
"please specify an explicit base with -r,\n"
1317
"and (if you want) report this to the bzr developers\n")
1318
log_error(m)
1319
1320
1321
class cmd_revert(Command):
1322
"""Reverse all changes since the last commit.
1323
1324
Only versioned files are affected. Specify filenames to revert only
1325
those files. By default, any files that are changed will be backed up
1326
first. Backup files have a '~' appended to their name.
1327
"""
1328
takes_options = ['revision', 'no-backup']
1329
takes_args = ['file*']
1330
aliases = ['merge-revert']
1331
1332
def run(self, revision=None, no_backup=False, file_list=None):
1333
from bzrlib.merge import merge
1334
from bzrlib.commands import parse_spec
1335
1336
if file_list is not None:
1337
if len(file_list) == 0:
1338
raise BzrCommandError("No files specified")
1339
if revision is None:
1340
revno = -1
1341
elif len(revision) != 1:
1342
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1343
else:
1344
b = Branch.open_containing('.')[0]
1345
revno = revision[0].in_history(b).revno
1346
merge(('.', revno), parse_spec('.'),
1347
check_clean=False,
1348
ignore_zero=True,
1349
backup_files=not no_backup,
1350
file_list=file_list)
1351
if not file_list:
1352
Branch.open_containing('.')[0].set_pending_merges([])
1353
1354
1355
class cmd_assert_fail(Command):
1356
"""Test reporting of assertion failures"""
1357
hidden = True
1358
def run(self):
1359
assert False, "always fails"
1360
1361
1362
class cmd_help(Command):
1363
"""Show help on a command or other topic.
1364
1365
For a list of all available commands, say 'bzr help commands'."""
1366
takes_options = ['long']
1367
takes_args = ['topic?']
1368
aliases = ['?']
1369
1370
def run(self, topic=None, long=False):
1371
import help
1372
if topic is None and long:
1373
topic = "commands"
1374
help.help(topic)
1375
1376
1377
class cmd_shell_complete(Command):
1378
"""Show appropriate completions for context.
1379
1380
For a list of all available commands, say 'bzr shell-complete'."""
1381
takes_args = ['context?']
1382
aliases = ['s-c']
1383
hidden = True
1384
1385
def run(self, context=None):
1386
import shellcomplete
1387
shellcomplete.shellcomplete(context)
1388
1389
1390
class cmd_fetch(Command):
1391
"""Copy in history from another branch but don't merge it.
1392
1393
This is an internal method used for pull and merge."""
1394
hidden = True
1395
takes_args = ['from_branch', 'to_branch']
1396
def run(self, from_branch, to_branch):
1397
from bzrlib.fetch import Fetcher
1398
from bzrlib.branch import Branch
1399
from_b = Branch(from_branch)
1400
to_b = Branch(to_branch)
1401
Fetcher(to_b, from_b)
1402
1403
1404
1405
class cmd_missing(Command):
1406
"""What is missing in this branch relative to other branch.
1407
"""
1408
# TODO: rewrite this in terms of ancestry so that it shows only
1409
# unmerged things
1410
1411
takes_args = ['remote?']
1412
aliases = ['mis', 'miss']
1413
# We don't have to add quiet to the list, because
1414
# unknown options are parsed as booleans
1415
takes_options = ['verbose', 'quiet']
1416
1417
def run(self, remote=None, verbose=False, quiet=False):
1418
from bzrlib.errors import BzrCommandError
1419
from bzrlib.missing import show_missing
1420
1421
if verbose and quiet:
1422
raise BzrCommandError('Cannot pass both quiet and verbose')
1423
1424
b = Branch.open_containing('.')[0]
1425
parent = b.get_parent()
1426
if remote is None:
1427
if parent is None:
1428
raise BzrCommandError("No missing location known or specified.")
1429
else:
1430
if not quiet:
1431
print "Using last location: %s" % parent
1432
remote = parent
1433
elif parent is None:
1434
# We only update parent if it did not exist, missing
1435
# should not change the parent
1436
b.set_parent(remote)
1437
br_remote = Branch.open_containing(remote)[0]
1438
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1439
1440
1441
class cmd_plugins(Command):
1442
"""List plugins"""
1443
hidden = True
1444
def run(self):
1445
import bzrlib.plugin
1446
from inspect import getdoc
1447
for plugin in bzrlib.plugin.all_plugins:
1448
if hasattr(plugin, '__path__'):
1449
print plugin.__path__[0]
1450
elif hasattr(plugin, '__file__'):
1451
print plugin.__file__
1452
else:
1453
print `plugin`
1454
1455
d = getdoc(plugin)
1456
if d:
1457
print '\t', d.split('\n')[0]
1458
1459
1460
class cmd_testament(Command):
1461
"""Show testament (signing-form) of a revision."""
1462
takes_options = ['revision', 'long']
1463
takes_args = ['branch?']
1464
def run(self, branch='.', revision=None, long=False):
1465
from bzrlib.testament import Testament
1466
b = Branch.open_containing(branch)[0]
1467
b.lock_read()
1468
try:
1469
if revision is None:
1470
rev_id = b.last_revision()
1471
else:
1472
rev_id = revision[0].in_history(b).rev_id
1473
t = Testament.from_revision(b, rev_id)
1474
if long:
1475
sys.stdout.writelines(t.as_text_lines())
1476
else:
1477
sys.stdout.write(t.as_short_text())
1478
finally:
1479
b.unlock()
1480
1481
1482
class cmd_annotate(Command):
1483
"""Show the origin of each line in a file.
1484
1485
This prints out the given file with an annotation on the left side
1486
indicating which revision, author and date introduced the change.
1487
1488
If the origin is the same for a run of consecutive lines, it is
1489
shown only at the top, unless the --all option is given.
1490
"""
1491
# TODO: annotate directories; showing when each file was last changed
1492
# TODO: annotate a previous version of a file
1493
# TODO: if the working copy is modified, show annotations on that
1494
# with new uncommitted lines marked
1495
aliases = ['blame', 'praise']
1496
takes_args = ['filename']
1497
takes_options = [Option('all', help='show annotations on all lines'),
1498
Option('long', help='show date in annotations'),
1499
]
1500
1501
def run(self, filename, all=False, long=False):
1502
from bzrlib.annotate import annotate_file
1503
b, relpath = Branch.open_containing(filename)
1504
b.lock_read()
1505
try:
1506
tree = WorkingTree(b.base, b)
1507
tree = b.revision_tree(b.last_revision())
1508
file_id = tree.inventory.path2id(relpath)
1509
file_version = tree.inventory[file_id].revision
1510
annotate_file(b, file_version, file_id, long, all, sys.stdout)
1511
finally:
1512
b.unlock()
1513
1514
1515
class cmd_re_sign(Command):
1516
"""Create a digital signature for an existing revision."""
1517
# TODO be able to replace existing ones.
1518
1519
hidden = True # is this right ?
1520
takes_args = ['revision_id?']
1521
takes_options = ['revision']
1522
1523
def run(self, revision_id=None, revision=None):
1524
import bzrlib.config as config
1525
import bzrlib.gpg as gpg
1526
if revision_id is not None and revision is not None:
1527
raise BzrCommandError('You can only supply one of revision_id or --revision')
1528
if revision_id is None and revision is None:
1529
raise BzrCommandError('You must supply either --revision or a revision_id')
1530
b = Branch.open_containing('.')[0]
1531
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1532
if revision_id is not None:
1533
b.sign_revision(revision_id, gpg_strategy)
1534
elif revision is not None:
1535
for rev in revision:
1536
if rev is None:
1537
raise BzrCommandError('You cannot specify a NULL revision.')
1538
revno, rev_id = rev.in_history(b)
1539
b.sign_revision(rev_id, gpg_strategy)
1540
1541
1542
# these get imported and then picked up by the scan for cmd_*
1543
# TODO: Some more consistent way to split command definitions across files;
1544
# we do need to load at least some information about them to know of
1545
# aliases.
1546
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
Loggerhead is a web-based interface for Breezy
Version: 2.0.1