« back to all changes in this revision
Viewing changes to bzrlib/weave.py
- browse files at revision 542
- compare with another revision
- download diff
- download tarball
- view history from revision 542
- Committer: Martin Pool
- Date: 2005-05-19 08:31:06 UTC
- Revision ID: mbp@sourcefrog.net-20050519083106-ebe71562d3bda4a7
- fix typo
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/weave.py
1
#! /usr/bin/python
2
3
# Copyright (C) 2005 Canonical Ltd
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
# Author: Martin Pool <mbp@canonical.com>
20
21
22
"""Weave - storage of related text file versions"""
23
24
# before intset (r923) 2000 versions in 41.5s
25
# with intset (r926) 2000 versions in 93s !!!
26
# better to just use plain sets.
27
28
# making _extract build and return a list, rather than being a generator
29
# takes 37.94s
30
31
# with python -O, r923 does 2000 versions in 36.87s
32
33
# with optimizations to avoid mutating lists - 35.75! I guess copying
34
# all the elements every time costs more than the small manipulations.
35
# a surprisingly small change.
36
37
# r931, which avoids using a generator for extract, does 36.98s
38
39
# with memoized inclusions, takes 41.49s; not very good
40
41
# with slots, takes 37.35s; without takes 39.16, a bit surprising
42
43
# with the delta calculation mixed in with the add method, rather than
44
# separated, takes 36.78s
45
46
# with delta folded in and mutation of the list, 36.13s
47
48
# with all this and simplification of add code, 33s
49
50
51
52
53
54
# TODO: Perhaps have copy method for Weave instances?
55
56
# XXX: If we do weaves this way, will a merge still behave the same
57
# way if it's done in a different order? That's a pretty desirable
58
# property.
59
60
# TODO: Nothing here so far assumes the lines are really \n newlines,
61
# rather than being split up in some other way. We could accomodate
62
# binaries, perhaps by naively splitting on \n or perhaps using
63
# something like a rolling checksum.
64
65
# TODO: End marker for each version so we can stop reading?
66
67
# TODO: Check that no insertion occurs inside a deletion that was
68
# active in the version of the insertion.
69
70
# TODO: In addition to the SHA-1 check, perhaps have some code that
71
# checks structural constraints of the weave: ie that insertions are
72
# properly nested, that there is no text outside of an insertion, that
73
# insertions or deletions are not repeated, etc.
74
75
# TODO: Parallel-extract that passes back each line along with a
76
# description of which revisions include it. Nice for checking all
77
# shas in parallel.
78
79
# TODO: Using a single _extract routine and then processing the output
80
# is probably inefficient. It's simple enough that we can afford to
81
# have slight specializations for different ways its used: annotate,
82
# basis for add, get, etc.
83
84
# TODO: Perhaps the API should work only in names to hide the integer
85
# indexes from the user?
86
87
88
89
import sha
90
91
from cStringIO import StringIO
92
93
from bzrlib.osutils import sha_strings
94
95
96
class WeaveError(Exception):
97
"""Exception in processing weave"""
98
99
100
class WeaveFormatError(WeaveError):
101
"""Weave invariant violated"""
102
103
104
class Weave(object):
105
"""weave - versioned text file storage.
106
107
A Weave manages versions of line-based text files, keeping track
108
of the originating version for each line.
109
110
To clients the "lines" of the file are represented as a list of strings.
111
These strings will typically have terminal newline characters, but
112
this is not required. In particular files commonly do not have a newline
113
at the end of the file.
114
115
Texts can be identified in either of two ways:
116
117
* a nonnegative index number.
118
119
* a version-id string. (not implemented yet)
120
121
Typically the index number will be valid only inside this weave and
122
the version-id is used to reference it in the larger world.
123
124
The weave is represented as a list mixing edit instructions and
125
literal text. Each entry in _weave can be either a string (or
126
unicode), or a tuple. If a string, it means that the given line
127
should be output in the currently active revisions.
128
129
If a tuple, it gives a processing instruction saying in which
130
revisions the enclosed lines are active. The tuple has the form
131
(instruction, version).
132
133
The instruction can be '{' or '}' for an insertion block, and '['
134
and ']' for a deletion block respectively. The version is the
135
integer version index. There is no replace operator, only deletes
136
and inserts. For '}', the end of an insertion, there is no
137
version parameter because it always closes the most recently
138
opened insertion.
139
140
Constraints/notes:
141
142
* A later version can delete lines that were introduced by any
143
number of ancestor versions; this implies that deletion
144
instructions can span insertion blocks without regard to the
145
insertion block's nesting.
146
147
* Similarly, deletions need not be properly nested with regard to
148
each other, because they might have been generated by
149
independent revisions.
150
151
* Insertions are always made by inserting a new bracketed block
152
into a single point in the previous weave. This implies they
153
can nest but not overlap, and the nesting must always have later
154
insertions on the inside.
155
156
* It doesn't seem very useful to have an active insertion
157
inside an inactive insertion, but it might happen.
158
159
* Therefore, all instructions are always"considered"; that
160
is passed onto and off the stack. An outer inactive block
161
doesn't disable an inner block.
162
163
* Lines are enabled if the most recent enclosing insertion is
164
active and none of the enclosing deletions are active.
165
166
* There is no point having a deletion directly inside its own
167
insertion; you might as well just not write it. And there
168
should be no way to get an earlier version deleting a later
169
version.
170
171
_weave
172
Text of the weave; list of control instruction tuples and strings.
173
174
_parents
175
List of parents, indexed by version number.
176
It is only necessary to store the minimal set of parents for
177
each version; the parent's parents are implied.
178
179
_sha1s
180
List of hex SHA-1 of each version.
181
182
_names
183
List of symbolic names for each version. Each should be unique.
184
185
_name_map
186
For each name, the version number.
187
188
_weave_name
189
Descriptive name of this weave; typically the filename if known.
190
Set by read_weave.
191
"""
192
193
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
194
'_weave_name']
195
196
def __init__(self, weave_name=None):
197
self._weave = []
198
self._parents = []
199
self._sha1s = []
200
self._names = []
201
self._name_map = {}
202
self._weave_name = weave_name
203
204
205
def __eq__(self, other):
206
if not isinstance(other, Weave):
207
return False
208
return self._parents == other._parents \
209
and self._weave == other._weave \
210
and self._sha1s == other._sha1s
211
212
213
def __ne__(self, other):
214
return not self.__eq__(other)
215
216
217
def lookup(self, name):
218
try:
219
return self._name_map[name]
220
except KeyError:
221
raise WeaveError("name %s not present in weave %s" %
222
(name, self._weave_name))
223
224
225
def idx_to_name(self, version):
226
return self._names[version]
227
228
229
def _check_repeated_add(self, name, parents, text):
230
"""Check that a duplicated add is OK.
231
232
If it is, return the (old) index; otherwise raise an exception.
233
"""
234
idx = self.lookup(name)
235
if sorted(self._parents[idx]) != sorted(parents):
236
raise WeaveError("name \"%s\" already present in weave "
237
"with different parents" % name)
238
new_sha1 = sha_strings(text)
239
if new_sha1 != self._sha1s[idx]:
240
raise WeaveError("name \"%s\" already present in weave "
241
"with different text" % name)
242
return idx
243
244
245
246
def add(self, name, parents, text):
247
"""Add a single text on top of the weave.
248
249
Returns the index number of the newly added version.
250
251
name
252
Symbolic name for this version.
253
(Typically the revision-id of the revision that added it.)
254
255
parents
256
List or set of direct parent version numbers.
257
258
text
259
Sequence of lines to be added in the new version."""
260
261
assert isinstance(name, basestring)
262
if name in self._name_map:
263
return self._check_repeated_add(name, parents, text)
264
265
self._check_versions(parents)
266
## self._check_lines(text)
267
new_version = len(self._parents)
268
269
sha1 = sha_strings(text)
270
271
# if we abort after here the (in-memory) weave will be corrupt because only
272
# some fields are updated
273
self._parents.append(parents[:])
274
self._sha1s.append(sha1)
275
self._names.append(name)
276
self._name_map[name] = new_version
277
278
279
if not parents:
280
# special case; adding with no parents revision; can do
281
# this more quickly by just appending unconditionally.
282
# even more specially, if we're adding an empty text we
283
# need do nothing at all.
284
if text:
285
self._weave.append(('{', new_version))
286
self._weave.extend(text)
287
self._weave.append(('}', None))
288
289
return new_version
290
291
if len(parents) == 1:
292
pv = list(parents)[0]
293
if sha1 == self._sha1s[pv]:
294
# special case: same as the single parent
295
return new_version
296
297
298
ancestors = self.inclusions(parents)
299
300
l = self._weave
301
302
# basis a list of (origin, lineno, line)
303
basis_lineno = []
304
basis_lines = []
305
for origin, lineno, line in self._extract(ancestors):
306
basis_lineno.append(lineno)
307
basis_lines.append(line)
308
309
# another small special case: a merge, producing the same text
310
# as auto-merge
311
if text == basis_lines:
312
return new_version
313
314
# add a sentinal, because we can also match against the final line
315
basis_lineno.append(len(self._weave))
316
317
# XXX: which line of the weave should we really consider
318
# matches the end of the file? the current code says it's the
319
# last line of the weave?
320
321
#print 'basis_lines:', basis_lines
322
#print 'new_lines: ', lines
323
324
from difflib import SequenceMatcher
325
s = SequenceMatcher(None, basis_lines, text)
326
327
# offset gives the number of lines that have been inserted
328
# into the weave up to the current point; if the original edit instruction
329
# says to change line A then we actually change (A+offset)
330
offset = 0
331
332
for tag, i1, i2, j1, j2 in s.get_opcodes():
333
# i1,i2 are given in offsets within basis_lines; we need to map them
334
# back to offsets within the entire weave
335
#print 'raw match', tag, i1, i2, j1, j2
336
if tag == 'equal':
337
continue
338
339
i1 = basis_lineno[i1]
340
i2 = basis_lineno[i2]
341
342
assert 0 <= j1 <= j2 <= len(text)
343
344
#print tag, i1, i2, j1, j2
345
346
# the deletion and insertion are handled separately.
347
# first delete the region.
348
if i1 != i2:
349
self._weave.insert(i1+offset, ('[', new_version))
350
self._weave.insert(i2+offset+1, (']', new_version))
351
offset += 2
352
353
if j1 != j2:
354
# there may have been a deletion spanning up to
355
# i2; we want to insert after this region to make sure
356
# we don't destroy ourselves
357
i = i2 + offset
358
self._weave[i:i] = ([('{', new_version)]
359
+ text[j1:j2]
360
+ [('}', None)])
361
offset += 2 + (j2 - j1)
362
363
return new_version
364
365
366
def inclusions(self, versions):
367
"""Return set of all ancestors of given version(s)."""
368
i = set(versions)
369
v = max(versions)
370
try:
371
while v >= 0:
372
if v in i:
373
# include all its parents
374
i.update(self._parents[v])
375
v -= 1
376
return i
377
except IndexError:
378
raise ValueError("version %d not present in weave" % v)
379
380
381
def parents(self, version):
382
return self._parents[version]
383
384
385
def minimal_parents(self, version):
386
"""Find the minimal set of parents for the version."""
387
included = self._parents[version]
388
if not included:
389
return []
390
391
li = list(included)
392
li.sort(reverse=True)
393
394
mininc = []
395
gotit = set()
396
397
for pv in li:
398
if pv not in gotit:
399
mininc.append(pv)
400
gotit.update(self.inclusions(pv))
401
402
assert mininc[0] >= 0
403
assert mininc[-1] < version
404
return mininc
405
406
407
408
def _check_lines(self, text):
409
if not isinstance(text, list):
410
raise ValueError("text should be a list, not %s" % type(text))
411
412
for l in text:
413
if not isinstance(l, basestring):
414
raise ValueError("text line should be a string or unicode, not %s"
415
% type(l))
416
417
418
419
def _check_versions(self, indexes):
420
"""Check everything in the sequence of indexes is valid"""
421
for i in indexes:
422
try:
423
self._parents[i]
424
except IndexError:
425
raise IndexError("invalid version number %r" % i)
426
427
428
def annotate(self, index):
429
return list(self.annotate_iter(index))
430
431
432
def annotate_iter(self, version):
433
"""Yield list of (index-id, line) pairs for the specified version.
434
435
The index indicates when the line originated in the weave."""
436
for origin, lineno, text in self._extract([version]):
437
yield origin, text
438
439
440
def _walk(self):
441
"""Walk the weave.
442
443
Yields sequence of
444
(lineno, insert, deletes, text)
445
for each literal line.
446
"""
447
448
istack = []
449
dset = set()
450
451
lineno = 0 # line of weave, 0-based
452
453
for l in self._weave:
454
if isinstance(l, tuple):
455
c, v = l
456
isactive = None
457
if c == '{':
458
istack.append(v)
459
elif c == '}':
460
istack.pop()
461
elif c == '[':
462
assert v not in dset
463
dset.add(v)
464
elif c == ']':
465
dset.remove(v)
466
else:
467
raise WeaveFormatError('unexpected instruction %r'
468
% v)
469
else:
470
assert isinstance(l, basestring)
471
assert istack
472
yield lineno, istack[-1], dset, l
473
lineno += 1
474
475
476
477
def _extract(self, versions):
478
"""Yield annotation of lines in included set.
479
480
Yields a sequence of tuples (origin, lineno, text), where
481
origin is the origin version, lineno the index in the weave,
482
and text the text of the line.
483
484
The set typically but not necessarily corresponds to a version.
485
"""
486
for i in versions:
487
if not isinstance(i, int):
488
raise ValueError(i)
489
490
included = self.inclusions(versions)
491
492
istack = []
493
dset = set()
494
495
lineno = 0 # line of weave, 0-based
496
497
isactive = None
498
499
result = []
500
501
WFE = WeaveFormatError
502
503
for l in self._weave:
504
if isinstance(l, tuple):
505
c, v = l
506
isactive = None
507
if c == '{':
508
assert v not in istack
509
istack.append(v)
510
elif c == '}':
511
istack.pop()
512
elif c == '[':
513
if v in included:
514
assert v not in dset
515
dset.add(v)
516
else:
517
assert c == ']'
518
if v in included:
519
assert v in dset
520
dset.remove(v)
521
else:
522
assert isinstance(l, basestring)
523
if isactive is None:
524
isactive = (not dset) and istack and (istack[-1] in included)
525
if isactive:
526
result.append((istack[-1], lineno, l))
527
lineno += 1
528
529
if istack:
530
raise WFE("unclosed insertion blocks at end of weave",
531
istack)
532
if dset:
533
raise WFE("unclosed deletion blocks at end of weave",
534
dset)
535
536
return result
537
538
539
540
def get_iter(self, version):
541
"""Yield lines for the specified version."""
542
for origin, lineno, line in self._extract([version]):
543
yield line
544
545
546
def get_text(self, version):
547
assert isinstance(version, int)
548
s = StringIO()
549
s.writelines(self.get_iter(version))
550
return s.getvalue()
551
552
553
def get(self, index):
554
return list(self.get_iter(index))
555
556
557
def mash_iter(self, included):
558
"""Return composed version of multiple included versions."""
559
for origin, lineno, text in self._extract(included):
560
yield text
561
562
563
def dump(self, to_file):
564
from pprint import pprint
565
print >>to_file, "Weave._weave = ",
566
pprint(self._weave, to_file)
567
print >>to_file, "Weave._parents = ",
568
pprint(self._parents, to_file)
569
570
571
572
def numversions(self):
573
l = len(self._parents)
574
assert l == len(self._sha1s)
575
return l
576
577
578
def __len__(self):
579
return self.numversions()
580
581
582
def check(self, progress_bar=None):
583
# check no circular inclusions
584
for version in range(self.numversions()):
585
inclusions = list(self._parents[version])
586
if inclusions:
587
inclusions.sort()
588
if inclusions[-1] >= version:
589
raise WeaveFormatError("invalid included version %d for index %d"
590
% (inclusions[-1], version))
591
592
# try extracting all versions; this is a bit slow and parallel
593
# extraction could be used
594
nv = self.numversions()
595
for version in range(nv):
596
if progress_bar:
597
progress_bar.update('checking text', version, nv)
598
s = sha.new()
599
for l in self.get_iter(version):
600
s.update(l)
601
hd = s.hexdigest()
602
expected = self._sha1s[version]
603
if hd != expected:
604
raise WeaveError("mismatched sha1 for version %d; "
605
"got %s, expected %s"
606
% (version, hd, expected))
607
608
# TODO: check insertions are properly nested, that there are
609
# no lines outside of insertion blocks, that deletions are
610
# properly paired, etc.
611
612
613
614
def merge(self, merge_versions):
615
"""Automerge and mark conflicts between versions.
616
617
This returns a sequence, each entry describing alternatives
618
for a chunk of the file. Each of the alternatives is given as
619
a list of lines.
620
621
If there is a chunk of the file where there's no diagreement,
622
only one alternative is given.
623
"""
624
625
# approach: find the included versions common to all the
626
# merged versions
627
raise NotImplementedError()
628
629
630
631
def _delta(self, included, lines):
632
"""Return changes from basis to new revision.
633
634
The old text for comparison is the union of included revisions.
635
636
This is used in inserting a new text.
637
638
Delta is returned as a sequence of
639
(weave1, weave2, newlines).
640
641
This indicates that weave1:weave2 of the old weave should be
642
replaced by the sequence of lines in newlines. Note that
643
these line numbers are positions in the total weave and don't
644
correspond to the lines in any extracted version, or even the
645
extracted union of included versions.
646
647
If line1=line2, this is a pure insert; if newlines=[] this is a
648
pure delete. (Similar to difflib.)
649
"""
650
651
652
653
def plan_merge(self, ver_a, ver_b):
654
"""Return pseudo-annotation indicating how the two versions merge.
655
656
This is computed between versions a and b and their common
657
base.
658
659
Weave lines present in none of them are skipped entirely.
660
"""
661
inc_a = self.inclusions([ver_a])
662
inc_b = self.inclusions([ver_b])
663
inc_c = inc_a & inc_b
664
665
for lineno, insert, deleteset, line in self._walk():
666
if deleteset & inc_c:
667
# killed in parent; can't be in either a or b
668
# not relevant to our work
669
yield 'killed-base', line
670
elif insert in inc_c:
671
# was inserted in base
672
killed_a = bool(deleteset & inc_a)
673
killed_b = bool(deleteset & inc_b)
674
if killed_a and killed_b:
675
yield 'killed-both', line
676
elif killed_a:
677
yield 'killed-a', line
678
elif killed_b:
679
yield 'killed-b', line
680
else:
681
yield 'unchanged', line
682
elif insert in inc_a:
683
if deleteset & inc_a:
684
yield 'ghost-a', line
685
else:
686
# new in A; not in B
687
yield 'new-a', line
688
elif insert in inc_b:
689
if deleteset & inc_b:
690
yield 'ghost-b', line
691
else:
692
yield 'new-b', line
693
else:
694
# not in either revision
695
yield 'irrelevant', line
696
697
yield 'unchanged', '' # terminator
698
699
700
701
def weave_merge(self, plan):
702
lines_a = []
703
lines_b = []
704
ch_a = ch_b = False
705
706
for state, line in plan:
707
if state == 'unchanged' or state == 'killed-both':
708
# resync and flush queued conflicts changes if any
709
if not lines_a and not lines_b:
710
pass
711
elif ch_a and not ch_b:
712
# one-sided change:
713
for l in lines_a: yield l
714
elif ch_b and not ch_a:
715
for l in lines_b: yield l
716
elif lines_a == lines_b:
717
for l in lines_a: yield l
718
else:
719
yield '<<<<\n'
720
for l in lines_a: yield l
721
yield '====\n'
722
for l in lines_b: yield l
723
yield '>>>>\n'
724
725
del lines_a[:]
726
del lines_b[:]
727
ch_a = ch_b = False
728
729
if state == 'unchanged':
730
if line:
731
yield line
732
elif state == 'killed-a':
733
ch_a = True
734
lines_b.append(line)
735
elif state == 'killed-b':
736
ch_b = True
737
lines_a.append(line)
738
elif state == 'new-a':
739
ch_a = True
740
lines_a.append(line)
741
elif state == 'new-b':
742
ch_b = True
743
lines_b.append(line)
744
else:
745
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
746
'killed-both'), \
747
state
748
749
750
751
752
753
754
755
def weave_toc(w):
756
"""Show the weave's table-of-contents"""
757
print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
758
for i in (6, 50, 10, 10):
759
print '-' * i,
760
print
761
for i in range(w.numversions()):
762
sha1 = w._sha1s[i]
763
name = w._names[i]
764
parent_str = ' '.join(map(str, w._parents[i]))
765
print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
766
767
768
769
def weave_stats(weave_file):
770
from bzrlib.progress import ProgressBar
771
from bzrlib.weavefile import read_weave
772
773
pb = ProgressBar()
774
775
wf = file(weave_file, 'rb')
776
w = read_weave(wf)
777
# FIXME: doesn't work on pipes
778
weave_size = wf.tell()
779
780
total = 0
781
vers = len(w)
782
for i in range(vers):
783
pb.update('checking sizes', i, vers)
784
for line in w.get_iter(i):
785
total += len(line)
786
787
pb.clear()
788
789
print 'versions %9d' % vers
790
print 'weave file %9d bytes' % weave_size
791
print 'total contents %9d bytes' % total
792
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
793
if vers:
794
avg = total/vers
795
print 'average size %9d bytes' % avg
796
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
797
798
799
def usage():
800
print """bzr weave tool
801
802
Experimental tool for weave algorithm.
803
804
usage:
805
weave init WEAVEFILE
806
Create an empty weave file
807
weave get WEAVEFILE VERSION
808
Write out specified version.
809
weave check WEAVEFILE
810
Check consistency of all versions.
811
weave toc WEAVEFILE
812
Display table of contents.
813
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
814
Add NEWTEXT, with specified parent versions.
815
weave annotate WEAVEFILE VERSION
816
Display origin of each line.
817
weave mash WEAVEFILE VERSION...
818
Display composite of all selected versions.
819
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
820
Auto-merge two versions and display conflicts.
821
822
example:
823
824
% weave init foo.weave
825
% vi foo.txt
826
% weave add foo.weave ver0 < foo.txt
827
added version 0
828
829
(create updated version)
830
% vi foo.txt
831
% weave get foo.weave 0 | diff -u - foo.txt
832
% weave add foo.weave ver1 0 < foo.txt
833
added version 1
834
835
% weave get foo.weave 0 > foo.txt (create forked version)
836
% vi foo.txt
837
% weave add foo.weave ver2 0 < foo.txt
838
added version 2
839
840
% weave merge foo.weave 1 2 > foo.txt (merge them)
841
% vi foo.txt (resolve conflicts)
842
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
843
844
"""
845
846
847
848
def main(argv):
849
import sys
850
import os
851
from weavefile import write_weave, read_weave
852
from bzrlib.progress import ProgressBar
853
854
try:
855
import psyco
856
psyco.full()
857
except ImportError:
858
pass
859
860
if len(argv) < 2:
861
usage()
862
return 0
863
864
cmd = argv[1]
865
866
def readit():
867
return read_weave(file(argv[2], 'rb'))
868
869
if cmd == 'help':
870
usage()
871
elif cmd == 'add':
872
w = readit()
873
# at the moment, based on everything in the file
874
name = argv[3]
875
parents = map(int, argv[4:])
876
lines = sys.stdin.readlines()
877
ver = w.add(name, parents, lines)
878
write_weave(w, file(argv[2], 'wb'))
879
print 'added version %r %d' % (name, ver)
880
elif cmd == 'init':
881
fn = argv[2]
882
if os.path.exists(fn):
883
raise IOError("file exists")
884
w = Weave()
885
write_weave(w, file(fn, 'wb'))
886
elif cmd == 'get': # get one version
887
w = readit()
888
sys.stdout.writelines(w.get_iter(int(argv[3])))
889
890
elif cmd == 'mash': # get composite
891
w = readit()
892
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
893
894
elif cmd == 'annotate':
895
w = readit()
896
# newline is added to all lines regardless; too hard to get
897
# reasonable formatting otherwise
898
lasto = None
899
for origin, text in w.annotate(int(argv[3])):
900
text = text.rstrip('\r\n')
901
if origin == lasto:
902
print ' | %s' % (text)
903
else:
904
print '%5d | %s' % (origin, text)
905
lasto = origin
906
907
elif cmd == 'toc':
908
weave_toc(readit())
909
910
elif cmd == 'stats':
911
weave_stats(argv[2])
912
913
elif cmd == 'check':
914
w = readit()
915
pb = ProgressBar()
916
w.check(pb)
917
pb.clear()
918
print '%d versions ok' % w.numversions()
919
920
elif cmd == 'inclusions':
921
w = readit()
922
print ' '.join(map(str, w.inclusions([int(argv[3])])))
923
924
elif cmd == 'parents':
925
w = readit()
926
print ' '.join(map(str, w._parents[int(argv[3])]))
927
928
elif cmd == 'plan-merge':
929
w = readit()
930
for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
931
if line:
932
print '%14s | %s' % (state, line),
933
934
elif cmd == 'merge':
935
w = readit()
936
p = w.plan_merge(int(argv[3]), int(argv[4]))
937
sys.stdout.writelines(w.weave_merge(p))
938
939
elif cmd == 'mash-merge':
940
if len(argv) != 5:
941
usage()
942
return 1
943
944
w = readit()
945
v1, v2 = map(int, argv[3:5])
946
947
basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
948
949
base_lines = list(w.mash_iter(basis))
950
a_lines = list(w.get(v1))
951
b_lines = list(w.get(v2))
952
953
from bzrlib.merge3 import Merge3
954
m3 = Merge3(base_lines, a_lines, b_lines)
955
956
name_a = 'version %d' % v1
957
name_b = 'version %d' % v2
958
sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
959
else:
960
raise ValueError('unknown command %r' % cmd)
961
962
963
964
def profile_main(argv):
965
import tempfile, hotshot, hotshot.stats
966
967
prof_f = tempfile.NamedTemporaryFile()
968
969
prof = hotshot.Profile(prof_f.name)
970
971
ret = prof.runcall(main, argv)
972
prof.close()
973
974
stats = hotshot.stats.load(prof_f.name)
975
#stats.strip_dirs()
976
stats.sort_stats('cumulative')
977
## XXX: Might like to write to stderr or the trace file instead but
978
## print_stats seems hardcoded to stdout
979
stats.print_stats(20)
980
981
return ret
982
983
984
if __name__ == '__main__':
985
import sys
986
if '--profile' in sys.argv:
987
args = sys.argv[:]
988
args.remove('--profile')
989
sys.exit(profile_main(args))
990
else:
991
sys.exit(main(sys.argv))
992
Loggerhead is a web-based interface for Breezy
Version: 2.0.1