« back to all changes in this revision
Viewing changes to bzrlib/weave.py
- browse files at revision 854
- compare with another revision
- download diff
- download tarball
- view history from revision 854
- Committer: Martin Pool
- Date: 2005-07-07 10:22:02 UTC
- Revision ID: mbp@sourcefrog.net-20050707102201-2d2a13a25098b101
- rearrange and clear up merged weave
- files added:
- bzrlib/statcache.py
- plugins/changeset
- files removed:
- HACKING
- bzrlib/util
- contrib/emacs
- files renamed:
- bzrlib/util/effbot/ => effbot/
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/plugins/ => plugins/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/weave.py
21
21
22
22
"""Weave - storage of related text file versions"""
23
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
24
# TODO: Perhaps have copy method for Weave instances?
52
25
53
26
# XXX: If we do weaves this way, will a merge still behave the same
54
27
# way if it's done in a different order? That's a pretty desirable
55
28
# property.
56
29
30
# TODO: How to write these to disk? One option is cPickle, which
31
# would be fast but less friendly to C, and perhaps not portable. Another is
32
57
33
# TODO: Nothing here so far assumes the lines are really \n newlines,
58
34
# rather than being split up in some other way. We could accomodate
59
35
# binaries, perhaps by naively splitting on \n or perhaps using
60
36
# something like a rolling checksum.
61
37
38
# TODO: Perhaps track SHA-1 in the header for protection? This would
39
# be redundant with it being stored in the inventory, but perhaps
40
# usefully so?
41
62
42
# TODO: Track version names as well as indexes.
63
43
44
# TODO: Probably do transitive expansion when specifying parents?
45
46
# TODO: Separate out some code to read and write weaves.
47
64
48
# TODO: End marker for each version so we can stop reading?
65
49
66
50
# TODO: Check that no insertion occurs inside a deletion that was
67
51
# active in the version of the insertion.
68
52
69
# TODO: In addition to the SHA-1 check, perhaps have some code that
70
# checks structural constraints of the weave: ie that insertions are
71
# properly nested, that there is no text outside of an insertion, that
72
# insertions or deletions are not repeated, etc.
73
74
# TODO: Parallel-extract that passes back each line along with a
75
# description of which revisions include it. Nice for checking all
76
# shas in parallel.
77
78
53
# TODO: Perhaps a special slower check() method that verifies more
54
# nesting constraints and the MD5 of each version?
55
56
57
58
try:
59
set
60
frozenset
61
except NameError:
62
from sets import Set, ImmutableSet
63
set = Set
64
frozenset = ImmutableSet
65
del Set, ImmutableSet
79
66
80
67
81
68
class WeaveError(Exception):
107
94
the version-id is used to reference it in the larger world.
108
95
109
96
The weave is represented as a list mixing edit instructions and
110
literal text. Each entry in _weave can be either a string (or
97
literal text. Each entry in _l can be either a string (or
111
98
unicode), or a tuple. If a string, it means that the given line
112
99
should be output in the currently active revisions.
113
100
151
138
should be no way to get an earlier version deleting a later
152
139
version.
153
140
154
_weave
155
Text of the weave; list of control instruction tuples and strings.
156
157
_parents
158
List of parents, indexed by version number.
159
It is only necessary to store the minimal set of parents for
160
each version; the parent's parents are implied.
141
_l
142
Text of the weave.
143
144
_v
145
List of versions, indexed by index number.
146
147
For each version we store the set (included_versions), which
148
lists the previous versions also considered active; the
149
versions included in those versions are included transitively.
150
So new versions created from nothing list []; most versions
151
have a single entry; some have more.
161
152
162
153
_sha1s
163
154
List of hex SHA-1 of each version, or None if not recorded.
164
155
"""
165
166
__slots__ = ['_weave', '_parents', '_sha1s']
167
168
156
def __init__(self):
169
self._weave = []
170
self._parents = []
157
self._l = []
158
self._v = []
171
159
self._sha1s = []
172
160
173
161
174
162
def __eq__(self, other):
175
163
if not isinstance(other, Weave):
176
164
return False
177
return self._parents == other._parents \
178
and self._weave == other._weave
165
return self._v == other._v \
166
and self._l == other._l
179
167
180
168
181
169
def __ne__(self, other):
188
176
Returns the index number of the newly added version.
189
177
190
178
parents
191
List or set of direct parent version numbers.
192
179
List or set of parent version numbers. This must normally include
180
the parents and the parent's parents, or wierd things might happen.
181
193
182
text
194
183
Sequence of lines to be added in the new version."""
195
196
self._check_versions(parents)
184
## self._check_versions(parents)
197
185
## self._check_lines(text)
198
new_version = len(self._parents)
186
idx = len(self._v)
199
187
200
188
import sha
201
189
s = sha.new()
202
map(s.update, text)
190
for l in text:
191
s.update(l)
203
192
sha1 = s.hexdigest()
204
193
del s
205
194
206
# if we abort after here the weave will be corrupt
207
self._parents.append(frozenset(parents))
195
if parents:
196
delta = self._delta(self.inclusions(parents), text)
197
198
# offset gives the number of lines that have been inserted
199
# into the weave up to the current point; if the original edit instruction
200
# says to change line A then we actually change (A+offset)
201
offset = 0
202
203
for i1, i2, newlines in delta:
204
assert 0 <= i1
205
assert i1 <= i2
206
assert i2 <= len(self._l)
207
208
# the deletion and insertion are handled separately.
209
# first delete the region.
210
if i1 != i2:
211
self._l.insert(i1+offset, ('[', idx))
212
self._l.insert(i2+offset+1, (']', idx))
213
offset += 2
214
# is this OK???
215
216
if newlines:
217
# there may have been a deletion spanning up to
218
# i2; we want to insert after this region to make sure
219
# we don't destroy ourselves
220
i = i2 + offset
221
self._l[i:i] = [('{', idx)] \
222
+ newlines \
223
+ [('}', idx)]
224
offset += 2 + len(newlines)
225
226
self._addversion(parents)
227
else:
228
# special case; adding with no parents revision; can do this
229
# more quickly by just appending unconditionally
230
self._l.append(('{', idx))
231
self._l += text
232
self._l.append(('}', idx))
233
234
self._addversion(None)
235
208
236
self._sha1s.append(sha1)
209
210
211
if not parents:
212
# special case; adding with no parents revision; can do
213
# this more quickly by just appending unconditionally.
214
# even more specially, if we're adding an empty text we
215
# need do nothing at all.
216
if text:
217
self._weave.append(('{', new_version))
218
self._weave.extend(text)
219
self._weave.append(('}', new_version))
220
221
return new_version
222
223
if len(parents) == 1:
224
pv = list(parents)[0]
225
if sha1 == self._sha1s[pv]:
226
# special case: same as the single parent
227
return new_version
228
229
230
ancestors = self.inclusions(parents)
231
232
l = self._weave
233
234
# basis a list of (origin, lineno, line)
235
basis_lineno = []
236
basis_lines = []
237
for origin, lineno, line in self._extract(ancestors):
238
basis_lineno.append(lineno)
239
basis_lines.append(line)
240
241
# another small special case: a merge, producing the same text
242
# as auto-merge
243
if text == basis_lines:
244
return new_version
245
246
# add a sentinal, because we can also match against the final line
247
basis_lineno.append(len(self._weave))
248
249
# XXX: which line of the weave should we really consider
250
# matches the end of the file? the current code says it's the
251
# last line of the weave?
252
253
#print 'basis_lines:', basis_lines
254
#print 'new_lines: ', lines
255
256
from difflib import SequenceMatcher
257
s = SequenceMatcher(None, basis_lines, text)
258
259
# offset gives the number of lines that have been inserted
260
# into the weave up to the current point; if the original edit instruction
261
# says to change line A then we actually change (A+offset)
262
offset = 0
263
264
for tag, i1, i2, j1, j2 in s.get_opcodes():
265
# i1,i2 are given in offsets within basis_lines; we need to map them
266
# back to offsets within the entire weave
267
#print 'raw match', tag, i1, i2, j1, j2
268
if tag == 'equal':
269
continue
270
271
i1 = basis_lineno[i1]
272
i2 = basis_lineno[i2]
273
274
assert 0 <= j1 <= j2 <= len(text)
275
276
#print tag, i1, i2, j1, j2
277
278
# the deletion and insertion are handled separately.
279
# first delete the region.
280
if i1 != i2:
281
self._weave.insert(i1+offset, ('[', new_version))
282
self._weave.insert(i2+offset+1, (']', new_version))
283
offset += 2
284
285
if j1 != j2:
286
# there may have been a deletion spanning up to
287
# i2; we want to insert after this region to make sure
288
# we don't destroy ourselves
289
i = i2 + offset
290
self._weave[i:i] = ([('{', new_version)]
291
+ text[j1:j2]
292
+ [('}', new_version)])
293
offset += 2 + (j2 - j1)
294
295
return new_version
237
238
return idx
296
239
297
240
298
241
def inclusions(self, versions):
299
"""Return set of all ancestors of given version(s)."""
242
"""Expand out everything included by versions."""
300
243
i = set(versions)
301
v = max(versions)
302
try:
303
while v >= 0:
304
if v in i:
305
# include all its parents
306
i.update(self._parents[v])
307
v -= 1
308
return i
309
except IndexError:
310
raise ValueError("version %d not present in weave" % v)
311
312
313
def minimal_parents(self, version):
314
"""Find the minimal set of parents for the version."""
315
included = self._parents[version]
316
if not included:
317
return []
318
319
li = list(included)
320
li.sort(reverse=True)
321
322
mininc = []
323
gotit = set()
324
325
for pv in li:
326
if pv not in gotit:
327
mininc.append(pv)
328
gotit.update(self.inclusions(pv))
329
330
assert mininc[0] >= 0
331
assert mininc[-1] < version
332
return mininc
333
244
for v in versions:
245
i.update(self._v[v])
246
return i
247
248
249
def _addversion(self, parents):
250
if parents:
251
self._v.append(frozenset(parents))
252
else:
253
self._v.append(frozenset())
334
254
335
255
336
256
def _check_lines(self, text):
339
259
340
260
for l in text:
341
261
if not isinstance(l, basestring):
342
raise ValueError("text line should be a string or unicode, not %s"
343
% type(l))
262
raise ValueError("text line should be a string or unicode, not %s" % type(l))
344
263
345
264
346
265
348
267
"""Check everything in the sequence of indexes is valid"""
349
268
for i in indexes:
350
269
try:
351
self._parents[i]
270
self._v[i]
352
271
except IndexError:
353
272
raise IndexError("invalid version number %r" % i)
354
273
361
280
"""Yield list of (index-id, line) pairs for the specified version.
362
281
363
282
The index indicates when the line originated in the weave."""
364
for origin, lineno, text in self._extract([version]):
283
included = self.inclusions([version])
284
for origin, lineno, text in self._extract(included):
365
285
yield origin, text
366
286
367
287
368
def _walk(self):
369
"""Walk the weave.
370
371
Yields sequence of
372
(lineno, insert, deletes, text)
373
for each literal line.
374
"""
375
376
istack = []
377
dset = set()
378
379
lineno = 0 # line of weave, 0-based
380
381
for l in self._weave:
382
if isinstance(l, tuple):
383
c, v = l
384
isactive = None
385
if c == '{':
386
istack.append(v)
387
elif c == '}':
388
oldv = istack.pop()
389
elif c == '[':
390
assert v not in dset
391
dset.add(v)
392
elif c == ']':
393
dset.remove(v)
394
else:
395
raise WeaveFormatError('unexpected instruction %r'
396
% v)
397
else:
398
assert isinstance(l, basestring)
399
assert istack
400
yield lineno, istack[-1], dset, l
401
lineno += 1
402
403
404
405
def _extract(self, versions):
288
def _extract(self, included):
406
289
"""Yield annotation of lines in included set.
407
290
408
291
Yields a sequence of tuples (origin, lineno, text), where
411
294
412
295
The set typically but not necessarily corresponds to a version.
413
296
"""
414
included = self.inclusions(versions)
415
416
istack = []
417
dset = set()
418
419
lineno = 0 # line of weave, 0-based
297
istack = [] # versions for which an insertion block is current
298
299
dset = set() # versions for which a deletion block is current
420
300
421
301
isactive = None
422
302
423
result = []
303
lineno = 0 # line of weave, 0-based
304
305
# TODO: Probably only need to put included revisions in the istack
306
307
# TODO: Could split this into two functions, one that updates
308
# the stack and the other that processes the results -- but
309
# I'm not sure it's really needed.
310
311
# TODO: In fact, I think we only need to store the *count* of
312
# active insertions and deletions, and we can maintain that by
313
# just by just counting as we go along.
424
314
425
315
WFE = WeaveFormatError
426
316
427
for l in self._weave:
317
for l in self._l:
428
318
if isinstance(l, tuple):
319
isactive = None # recalculate
429
320
c, v = l
430
isactive = None
431
321
if c == '{':
432
assert v not in istack
322
if istack and (istack[-1] >= v):
323
raise WFE("improperly nested insertions %d>=%d on line %d"
324
% (istack[-1], v, lineno))
433
325
istack.append(v)
434
326
elif c == '}':
435
oldv = istack.pop()
436
assert oldv == v
327
try:
328
oldv = istack.pop()
329
except IndexError:
330
raise WFE("unmatched close of insertion %d on line %d"
331
% (v, lineno))
332
if oldv != v:
333
raise WFE("mismatched close of insertion %d!=%d on line %d"
334
% (oldv, v, lineno))
437
335
elif c == '[':
438
if v in included:
439
assert v not in dset
336
# block deleted in v
337
if v in dset:
338
raise WFE("repeated deletion marker for version %d on line %d"
339
% (v, lineno))
340
if istack:
341
if istack[-1] == v:
342
raise WFE("version %d deletes own text on line %d"
343
% (v, lineno))
344
# XXX
440
345
dset.add(v)
441
else:
442
assert c == ']'
443
if v in included:
444
assert v in dset
346
elif c == ']':
347
if v in dset:
445
348
dset.remove(v)
349
else:
350
raise WFE("unmatched close of deletion %d on line %d"
351
% (v, lineno))
352
else:
353
raise WFE("invalid processing instruction %r on line %d"
354
% (l, lineno))
446
355
else:
447
356
assert isinstance(l, basestring)
448
if isactive is None:
449
isactive = (not dset) and istack and (istack[-1] in included)
357
if not istack:
358
raise WFE("literal at top level on line %d"
359
% lineno)
360
if isactive == None:
361
isactive = (istack[-1] in included) \
362
and not included.intersection(dset)
450
363
if isactive:
451
result.append((istack[-1], lineno, l))
364
origin = istack[-1]
365
yield origin, lineno, l
452
366
lineno += 1
453
367
454
368
if istack:
458
372
raise WFE("unclosed deletion blocks at end of weave",
459
373
dset)
460
374
461
return result
462
463
464
375
465
376
def get_iter(self, version):
466
377
"""Yield lines for the specified version."""
467
for origin, lineno, line in self._extract([version]):
378
for origin, lineno, line in self._extract(self.inclusions([version])):
468
379
yield line
469
380
470
381
474
385
475
386
def mash_iter(self, included):
476
387
"""Return composed version of multiple included versions."""
388
included = frozenset(included)
477
389
for origin, lineno, text in self._extract(included):
478
390
yield text
479
391
480
392
481
393
def dump(self, to_file):
482
394
from pprint import pprint
483
print >>to_file, "Weave._weave = ",
484
pprint(self._weave, to_file)
485
print >>to_file, "Weave._parents = ",
486
pprint(self._parents, to_file)
395
print >>to_file, "Weave._l = ",
396
pprint(self._l, to_file)
397
print >>to_file, "Weave._v = ",
398
pprint(self._v, to_file)
487
399
488
400
489
401
490
402
def numversions(self):
491
l = len(self._parents)
403
l = len(self._v)
492
404
assert l == len(self._sha1s)
493
405
return l
494
406
495
407
496
def __len__(self):
497
return self.numversions()
498
499
500
def check(self, progress_bar=None):
408
def check(self):
501
409
# check no circular inclusions
502
410
for version in range(self.numversions()):
503
inclusions = list(self._parents[version])
411
inclusions = list(self._v[version])
504
412
if inclusions:
505
413
inclusions.sort()
506
414
if inclusions[-1] >= version:
510
418
# try extracting all versions; this is a bit slow and parallel
511
419
# extraction could be used
512
420
import sha
513
nv = self.numversions()
514
for version in range(nv):
515
if progress_bar:
516
progress_bar.update('checking text', version, nv)
421
for version in range(self.numversions()):
517
422
s = sha.new()
518
423
for l in self.get_iter(version):
519
424
s.update(l)
524
429
"got %s, expected %s"
525
430
% (version, hd, expected))
526
431
527
# TODO: check insertions are properly nested, that there are
528
# no lines outside of insertion blocks, that deletions are
529
# properly paired, etc.
530
531
432
532
433
533
434
def merge(self, merge_versions):
566
467
If line1=line2, this is a pure insert; if newlines=[] this is a
567
468
pure delete. (Similar to difflib.)
568
469
"""
569
570
571
572
def plan_merge(self, ver_a, ver_b):
573
"""Return pseudo-annotation indicating how the two versions merge.
574
575
This is computed between versions a and b and their common
576
base.
577
578
Weave lines present in none of them are skipped entirely.
579
"""
580
inc_a = self.inclusions([ver_a])
581
inc_b = self.inclusions([ver_b])
582
inc_c = inc_a & inc_b
583
584
for lineno, insert, deleteset, line in self._walk():
585
if deleteset & inc_c:
586
# killed in parent; can't be in either a or b
587
# not relevant to our work
588
yield 'killed-base', line
589
elif insert in inc_c:
590
# was inserted in base
591
killed_a = bool(deleteset & inc_a)
592
killed_b = bool(deleteset & inc_b)
593
if killed_a and killed_b:
594
yield 'killed-both', line
595
elif killed_a:
596
yield 'killed-a', line
597
elif killed_b:
598
yield 'killed-b', line
599
else:
600
yield 'unchanged', line
601
elif insert in inc_a:
602
if deleteset & inc_a:
603
yield 'ghost-a', line
604
else:
605
# new in A; not in B
606
yield 'new-a', line
607
elif insert in inc_b:
608
if deleteset & inc_b:
609
yield 'ghost-b', line
610
else:
611
yield 'new-b', line
612
else:
613
# not in either revision
614
yield 'irrelevant', line
615
616
yield 'unchanged', '' # terminator
617
618
619
620
def weave_merge(self, plan):
621
lines_a = []
622
lines_b = []
623
ch_a = ch_b = False
624
625
for state, line in plan:
626
if state == 'unchanged' or state == 'killed-both':
627
# resync and flush queued conflicts changes if any
628
if not lines_a and not lines_b:
629
pass
630
elif ch_a and not ch_b:
631
# one-sided change:
632
for l in lines_a: yield l
633
elif ch_b and not ch_a:
634
for l in lines_b: yield l
635
elif lines_a == lines_b:
636
for l in lines_a: yield l
637
else:
638
yield '<<<<\n'
639
for l in lines_a: yield l
640
yield '====\n'
641
for l in lines_b: yield l
642
yield '>>>>\n'
643
644
del lines_a[:]
645
del lines_b[:]
646
ch_a = ch_b = False
647
648
if state == 'unchanged':
649
if line:
650
yield line
651
elif state == 'killed-a':
652
ch_a = True
653
lines_b.append(line)
654
elif state == 'killed-b':
655
ch_b = True
656
lines_a.append(line)
657
elif state == 'new-a':
658
ch_a = True
659
lines_a.append(line)
660
elif state == 'new-b':
661
ch_b = True
662
lines_b.append(line)
663
else:
664
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
665
'killed-both'), \
666
state
667
668
669
670
671
672
673
674
def weave_info(w):
470
# basis a list of (origin, lineno, line)
471
basis_lineno = []
472
basis_lines = []
473
for origin, lineno, line in self._extract(included):
474
basis_lineno.append(lineno)
475
basis_lines.append(line)
476
477
# add a sentinal, because we can also match against the final line
478
basis_lineno.append(len(self._l))
479
480
# XXX: which line of the weave should we really consider
481
# matches the end of the file? the current code says it's the
482
# last line of the weave?
483
484
from difflib import SequenceMatcher
485
s = SequenceMatcher(None, basis_lines, lines)
486
487
# TODO: Perhaps return line numbers from composed weave as well?
488
489
for tag, i1, i2, j1, j2 in s.get_opcodes():
490
##print tag, i1, i2, j1, j2
491
492
if tag == 'equal':
493
continue
494
495
# i1,i2 are given in offsets within basis_lines; we need to map them
496
# back to offsets within the entire weave
497
real_i1 = basis_lineno[i1]
498
real_i2 = basis_lineno[i2]
499
500
assert 0 <= j1
501
assert j1 <= j2
502
assert j2 <= len(lines)
503
504
yield real_i1, real_i2, lines[j1:j2]
505
506
507
508
def weave_info(filename, out):
675
509
"""Show some text information about the weave."""
676
print '%6s %40s %20s' % ('ver', 'sha1', 'parents')
677
for i in (6, 40, 20):
678
print '-' * i,
679
print
680
for i in range(w.numversions()):
681
sha1 = w._sha1s[i]
682
print '%6d %40s %s' % (i, sha1, ' '.join(map(str, w._parents[i])))
683
684
685
686
def weave_stats(weave_file):
687
from bzrlib.progress import ProgressBar
688
from bzrlib.weavefile import read_weave
689
690
pb = ProgressBar()
691
692
wf = file(weave_file, 'rb')
510
from weavefile import read_weave
511
wf = file(filename, 'rb')
693
512
w = read_weave(wf)
694
513
# FIXME: doesn't work on pipes
695
514
weave_size = wf.tell()
515
print >>out, "weave file size %d bytes" % weave_size
516
print >>out, "weave contains %d versions" % len(w._v)
696
517
697
518
total = 0
698
vers = len(w)
699
for i in range(vers):
700
pb.update('checking sizes', i, vers)
701
for line in w.get_iter(i):
702
total += len(line)
703
704
pb.clear()
705
706
print 'versions %9d' % vers
707
print 'weave file %9d bytes' % weave_size
708
print 'total contents %9d bytes' % total
709
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
710
if vers:
711
avg = total/vers
712
print 'average size %9d bytes' % avg
713
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
714
715
716
def usage():
717
print """bzr weave tool
718
719
Experimental tool for weave algorithm.
720
721
usage:
722
weave init WEAVEFILE
723
Create an empty weave file
724
weave get WEAVEFILE VERSION
725
Write out specified version.
726
weave check WEAVEFILE
727
Check consistency of all versions.
728
weave info WEAVEFILE
729
Display table of contents.
730
weave add WEAVEFILE [BASE...] < NEWTEXT
731
Add NEWTEXT, with specified parent versions.
732
weave annotate WEAVEFILE VERSION
733
Display origin of each line.
734
weave mash WEAVEFILE VERSION...
735
Display composite of all selected versions.
736
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
737
Auto-merge two versions and display conflicts.
738
739
example:
740
741
% weave init foo.weave
742
% vi foo.txt
743
% weave add foo.weave < foo.txt
744
added version 0
745
746
(create updated version)
747
% vi foo.txt
748
% weave get foo.weave 0 | diff -u - foo.txt
749
% weave add foo.weave 0 < foo.txt
750
added version 1
751
752
% weave get foo.weave 0 > foo.txt (create forked version)
753
% vi foo.txt
754
% weave add foo.weave 0 < foo.txt
755
added version 2
756
757
% weave merge foo.weave 1 2 > foo.txt (merge them)
758
% vi foo.txt (resolve conflicts)
759
% weave add foo.weave 1 2 < foo.txt (commit merged version)
760
761
"""
519
print ' %8s %8s %8s %s' % ('version', 'lines', 'bytes', 'sha1')
520
print ' -------- -------- -------- ----------------------------------------'
521
for i in range(len(w._v)):
522
text = w.get(i)
523
lines = len(text)
524
bytes = sum((len(a) for a in text))
525
sha1 = w._sha1s[i]
526
print ' %8d %8d %8d %s' % (i, lines, bytes, sha1)
527
total += bytes
528
529
print >>out, "versions total %d bytes" % total
530
print >>out, "compression ratio %.3f" % (float(total)/float(weave_size))
762
531
763
532
764
533
765
534
def main(argv):
766
535
import sys
767
536
import os
768
from weavefile import write_weave, read_weave
769
from bzrlib.progress import ProgressBar
770
771
#import psyco
772
#psyco.full()
773
537
from weavefile import write_weave_v1, read_weave
774
538
cmd = argv[1]
775
776
def readit():
777
return read_weave(file(argv[2], 'rb'))
778
779
if cmd == 'help':
780
usage()
781
elif cmd == 'add':
782
w = readit()
539
if cmd == 'add':
540
w = read_weave(file(argv[2], 'rb'))
783
541
# at the moment, based on everything in the file
784
parents = map(int, argv[3:])
542
parents = set(range(len(w._v)))
785
543
lines = sys.stdin.readlines()
786
544
ver = w.add(parents, lines)
787
write_weave(w, file(argv[2], 'wb'))
788
print 'added version %d' % ver
545
write_weave_v1(w, file(argv[2], 'wb'))
546
print 'added %d' % ver
789
547
elif cmd == 'init':
790
548
fn = argv[2]
791
549
if os.path.exists(fn):
792
550
raise IOError("file exists")
793
551
w = Weave()
794
write_weave(w, file(fn, 'wb'))
795
elif cmd == 'get': # get one version
796
w = readit()
552
write_weave_v1(w, file(fn, 'wb'))
553
elif cmd == 'get':
554
w = read_weave(file(argv[2], 'rb'))
797
555
sys.stdout.writelines(w.get_iter(int(argv[3])))
798
799
elif cmd == 'mash': # get composite
800
w = readit()
801
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
802
803
556
elif cmd == 'annotate':
804
w = readit()
557
w = read_weave(file(argv[2], 'rb'))
805
558
# newline is added to all lines regardless; too hard to get
806
559
# reasonable formatting otherwise
807
560
lasto = None
812
565
else:
813
566
print '%5d | %s' % (origin, text)
814
567
lasto = origin
815
816
568
elif cmd == 'info':
817
weave_info(readit())
818
819
elif cmd == 'stats':
820
weave_stats(argv[2])
821
569
weave_info(argv[2], sys.stdout)
822
570
elif cmd == 'check':
823
w = readit()
824
pb = ProgressBar()
825
w.check(pb)
826
pb.clear()
827
print '%d versions ok' % w.numversions()
828
829
elif cmd == 'inclusions':
830
w = readit()
831
print ' '.join(map(str, w.inclusions([int(argv[3])])))
832
833
elif cmd == 'parents':
834
w = readit()
835
print ' '.join(map(str, w._parents[int(argv[3])]))
836
837
elif cmd == 'plan-merge':
838
w = readit()
839
for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
840
if line:
841
print '%14s | %s' % (state, line),
842
843
elif cmd == 'merge':
844
w = readit()
845
p = w.plan_merge(int(argv[3]), int(argv[4]))
846
sys.stdout.writelines(w.weave_merge(p))
847
848
elif cmd == 'mash-merge':
849
if len(argv) != 5:
850
usage()
851
return 1
852
853
w = readit()
854
v1, v2 = map(int, argv[3:5])
855
856
basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
857
858
base_lines = list(w.mash_iter(basis))
859
a_lines = list(w.get(v1))
860
b_lines = list(w.get(v2))
861
862
from bzrlib.merge3 import Merge3
863
m3 = Merge3(base_lines, a_lines, b_lines)
864
865
name_a = 'version %d' % v1
866
name_b = 'version %d' % v2
867
sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
571
w = read_weave(file(argv[2], 'rb'))
572
w.check()
868
573
else:
869
574
raise ValueError('unknown command %r' % cmd)
870
575
Loggerhead is a web-based interface for Breezy
Version: 2.0.1