« 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/meta_store.py
- plugins/changeset
- files removed:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- contrib/emacs
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/selftest/testplugins.py => bzrlib/selftest/plugins.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/util/effbot/ => effbot/
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/plugins/ => plugins/
- bzrlib/selftest/test_weave.py => tools/testweave.py
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/weave.py
21
21
22
22
"""Weave - storage of related text file versions"""
23
23
24
# TODO: Perhaps have copy method for Weave instances?
24
25
25
26
# XXX: If we do weaves this way, will a merge still behave the same
26
27
# way if it's done in a different order? That's a pretty desirable
27
28
# property.
28
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
29
33
# TODO: Nothing here so far assumes the lines are really \n newlines,
30
34
# rather than being split up in some other way. We could accomodate
31
35
# binaries, perhaps by naively splitting on \n or perhaps using
32
36
# something like a rolling checksum.
33
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
42
# TODO: Track version names as well as indexes.
43
44
# TODO: Probably do transitive expansion when specifying parents?
45
46
# TODO: Separate out some code to read and write weaves.
47
34
48
# TODO: End marker for each version so we can stop reading?
35
49
36
50
# TODO: Check that no insertion occurs inside a deletion that was
37
51
# active in the version of the insertion.
38
52
39
# TODO: In addition to the SHA-1 check, perhaps have some code that
40
# checks structural constraints of the weave: ie that insertions are
41
# properly nested, that there is no text outside of an insertion, that
42
# insertions or deletions are not repeated, etc.
43
44
# TODO: Parallel-extract that passes back each line along with a
45
# description of which revisions include it. Nice for checking all
46
# shas or calculating stats in parallel.
47
48
# TODO: Using a single _extract routine and then processing the output
49
# is probably inefficient. It's simple enough that we can afford to
50
# have slight specializations for different ways its used: annotate,
51
# basis for add, get, etc.
52
53
# TODO: Probably the API should work only in names to hide the integer
54
# indexes from the user.
55
56
# TODO: Is there any potential performance win by having an add()
57
# variant that is passed a pre-cooked version of the single basis
58
# version?
59
60
# TODO: Reweave can possibly be made faster by remembering diffs
61
# where the basis and destination are unchanged.
62
63
# FIXME: Sometimes we will be given a parents list for a revision
64
# that includes some redundant parents (i.e. already a parent of
65
# something in the list.) We should eliminate them. This can
66
# be done fairly efficiently because the sequence numbers constrain
67
# the possible relationships.
68
69
70
import sha
71
from difflib import SequenceMatcher
72
73
from bzrlib.trace import mutter
74
from bzrlib.errors import WeaveError, WeaveFormatError, WeaveParentMismatch, \
75
WeaveRevisionNotPresent, WeaveRevisionAlreadyPresent
76
from bzrlib.tsort import topo_sort
77
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
66
67
68
class WeaveError(Exception):
69
"""Exception in processing weave"""
70
71
72
class WeaveFormatError(WeaveError):
73
"""Weave invariant violated"""
74
78
75
79
76
class Weave(object):
80
77
"""weave - versioned text file storage.
97
94
the version-id is used to reference it in the larger world.
98
95
99
96
The weave is represented as a list mixing edit instructions and
100
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
101
98
unicode), or a tuple. If a string, it means that the given line
102
99
should be output in the currently active revisions.
103
100
108
105
The instruction can be '{' or '}' for an insertion block, and '['
109
106
and ']' for a deletion block respectively. The version is the
110
107
integer version index. There is no replace operator, only deletes
111
and inserts. For '}', the end of an insertion, there is no
112
version parameter because it always closes the most recently
113
opened insertion.
108
and inserts.
114
109
115
110
Constraints/notes:
116
111
143
138
should be no way to get an earlier version deleting a later
144
139
version.
145
140
146
_weave
147
Text of the weave; list of control instruction tuples and strings.
148
149
_parents
150
List of parents, indexed by version number.
151
It is only necessary to store the minimal set of parents for
152
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.
153
152
154
153
_sha1s
155
List of hex SHA-1 of each version.
156
157
_names
158
List of symbolic names for each version. Each should be unique.
159
160
_name_map
161
For each name, the version number.
162
163
_weave_name
164
Descriptive name of this weave; typically the filename if known.
165
Set by read_weave.
154
List of hex SHA-1 of each version, or None if not recorded.
166
155
"""
167
168
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
169
'_weave_name']
170
171
def __init__(self, weave_name=None):
172
self._weave = []
173
self._parents = []
156
def __init__(self):
157
self._l = []
158
self._v = []
174
159
self._sha1s = []
175
self._names = []
176
self._name_map = {}
177
self._weave_name = weave_name
178
179
180
def copy(self):
181
"""Return a deep copy of self.
182
183
The copy can be modified without affecting the original weave."""
184
other = Weave()
185
other._weave = self._weave[:]
186
other._parents = self._parents[:]
187
other._sha1s = self._sha1s[:]
188
other._names = self._names[:]
189
other._name_map = self._name_map.copy()
190
other._weave_name = self._weave_name
191
return other
160
192
161
193
162
def __eq__(self, other):
194
163
if not isinstance(other, Weave):
195
164
return False
196
return self._parents == other._parents \
197
and self._weave == other._weave \
198
and self._sha1s == other._sha1s
165
return self._v == other._v \
166
and self._l == other._l
167
199
168
200
201
169
def __ne__(self, other):
202
170
return not self.__eq__(other)
203
171
204
def __contains__(self, name):
205
return self._name_map.has_key(name)
206
207
def maybe_lookup(self, name_or_index):
208
"""Convert possible symbolic name to index, or pass through indexes."""
209
if isinstance(name_or_index, (int, long)):
210
return name_or_index
211
else:
212
return self.lookup(name_or_index)
213
214
215
def lookup(self, name):
216
"""Convert symbolic version name to index."""
217
try:
218
return self._name_map[name]
219
except KeyError:
220
raise WeaveRevisionNotPresent(name, self)
221
222
def names(self):
223
return self._names[:]
224
225
def iter_names(self):
226
"""Yield a list of all names in this weave."""
227
return iter(self._names)
228
229
def idx_to_name(self, version):
230
return self._names[version]
231
232
def _check_repeated_add(self, name, parents, text, sha1):
233
"""Check that a duplicated add is OK.
234
235
If it is, return the (old) index; otherwise raise an exception.
236
"""
237
idx = self.lookup(name)
238
if sorted(self._parents[idx]) != sorted(parents) \
239
or sha1 != self._sha1s[idx]:
240
raise WeaveRevisionAlreadyPresent(name, self)
241
return idx
242
243
def add(self, name, parents, text, sha1=None):
172
173
def add(self, parents, text):
244
174
"""Add a single text on top of the weave.
245
175
246
176
Returns the index number of the newly added version.
247
177
248
name
249
Symbolic name for this version.
250
(Typically the revision-id of the revision that added it.)
251
252
178
parents
253
List or set of direct parent version numbers.
254
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
255
182
text
256
Sequence of lines to be added in the new version.
257
258
sha -- SHA-1 of the file, if known. This is trusted to be
259
correct if supplied.
260
"""
261
from bzrlib.osutils import sha_strings
262
263
assert isinstance(name, basestring)
264
if sha1 is None:
265
sha1 = sha_strings(text)
266
if name in self._name_map:
267
return self._check_repeated_add(name, parents, text, sha1)
268
269
parents = map(self.maybe_lookup, parents)
270
self._check_versions(parents)
183
Sequence of lines to be added in the new version."""
184
## self._check_versions(parents)
271
185
## self._check_lines(text)
272
new_version = len(self._parents)
273
274
275
# if we abort after here the (in-memory) weave will be corrupt because only
276
# some fields are updated
277
self._parents.append(parents[:])
186
idx = len(self._v)
187
188
import sha
189
s = sha.new()
190
for l in text:
191
s.update(l)
192
sha1 = s.hexdigest()
193
del s
194
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
278
236
self._sha1s.append(sha1)
279
self._names.append(name)
280
self._name_map[name] = new_version
281
282
283
if not parents:
284
# special case; adding with no parents revision; can do
285
# this more quickly by just appending unconditionally.
286
# even more specially, if we're adding an empty text we
287
# need do nothing at all.
288
if text:
289
self._weave.append(('{', new_version))
290
self._weave.extend(text)
291
self._weave.append(('}', None))
292
293
return new_version
294
295
if len(parents) == 1:
296
pv = list(parents)[0]
297
if sha1 == self._sha1s[pv]:
298
# special case: same as the single parent
299
return new_version
300
301
302
ancestors = self.inclusions(parents)
303
304
l = self._weave
305
306
# basis a list of (origin, lineno, line)
307
basis_lineno = []
308
basis_lines = []
309
for origin, lineno, line in self._extract(ancestors):
310
basis_lineno.append(lineno)
311
basis_lines.append(line)
312
313
# another small special case: a merge, producing the same text
314
# as auto-merge
315
if text == basis_lines:
316
return new_version
317
318
# add a sentinal, because we can also match against the final line
319
basis_lineno.append(len(self._weave))
320
321
# XXX: which line of the weave should we really consider
322
# matches the end of the file? the current code says it's the
323
# last line of the weave?
324
325
#print 'basis_lines:', basis_lines
326
#print 'new_lines: ', lines
327
328
s = SequenceMatcher(None, basis_lines, text)
329
330
# offset gives the number of lines that have been inserted
331
# into the weave up to the current point; if the original edit instruction
332
# says to change line A then we actually change (A+offset)
333
offset = 0
334
335
for tag, i1, i2, j1, j2 in s.get_opcodes():
336
# i1,i2 are given in offsets within basis_lines; we need to map them
337
# back to offsets within the entire weave
338
#print 'raw match', tag, i1, i2, j1, j2
339
if tag == 'equal':
340
continue
341
342
i1 = basis_lineno[i1]
343
i2 = basis_lineno[i2]
344
345
assert 0 <= j1 <= j2 <= len(text)
346
347
#print tag, i1, i2, j1, j2
348
349
# the deletion and insertion are handled separately.
350
# first delete the region.
351
if i1 != i2:
352
self._weave.insert(i1+offset, ('[', new_version))
353
self._weave.insert(i2+offset+1, (']', new_version))
354
offset += 2
355
356
if j1 != j2:
357
# there may have been a deletion spanning up to
358
# i2; we want to insert after this region to make sure
359
# we don't destroy ourselves
360
i = i2 + offset
361
self._weave[i:i] = ([('{', new_version)]
362
+ text[j1:j2]
363
+ [('}', None)])
364
offset += 2 + (j2 - j1)
365
366
return new_version
367
368
def add_identical(self, old_rev_id, new_rev_id, parents):
369
"""Add an identical text to old_rev_id as new_rev_id."""
370
old_lines = self.get(self.lookup(old_rev_id))
371
self.add(new_rev_id, parents, old_lines)
237
238
return idx
239
372
240
373
241
def inclusions(self, versions):
374
"""Return set of all ancestors of given version(s)."""
242
"""Expand out everything included by versions."""
375
243
i = set(versions)
376
for v in xrange(max(versions), 0, -1):
377
if v in i:
378
# include all its parents
379
i.update(self._parents[v])
244
for v in versions:
245
i.update(self._v[v])
380
246
return i
381
## except IndexError:
382
## raise ValueError("version %d not present in weave" % v)
383
384
385
def parents(self, version):
386
return self._parents[version]
387
388
389
def parent_names(self, version):
390
"""Return version names for parents of a version."""
391
return map(self.idx_to_name, self._parents[self.lookup(version)])
392
393
394
def minimal_parents(self, version):
395
"""Find the minimal set of parents for the version."""
396
included = self._parents[version]
397
if not included:
398
return []
399
400
li = list(included)
401
li.sort(reverse=True)
402
403
mininc = []
404
gotit = set()
405
406
for pv in li:
407
if pv not in gotit:
408
mininc.append(pv)
409
gotit.update(self.inclusions(pv))
410
411
assert mininc[0] >= 0
412
assert mininc[-1] < version
413
return mininc
414
247
248
249
def _addversion(self, parents):
250
if parents:
251
self._v.append(frozenset(parents))
252
else:
253
self._v.append(frozenset())
415
254
416
255
417
256
def _check_lines(self, text):
420
259
421
260
for l in text:
422
261
if not isinstance(l, basestring):
423
raise ValueError("text line should be a string or unicode, not %s"
424
% type(l))
262
raise ValueError("text line should be a string or unicode, not %s" % type(l))
425
263
426
264
427
265
429
267
"""Check everything in the sequence of indexes is valid"""
430
268
for i in indexes:
431
269
try:
432
self._parents[i]
270
self._v[i]
433
271
except IndexError:
434
272
raise IndexError("invalid version number %r" % i)
435
273
436
274
437
def annotate(self, name_or_index):
438
return list(self.annotate_iter(name_or_index))
439
440
441
def annotate_iter(self, name_or_index):
275
def annotate(self, index):
276
return list(self.annotate_iter(index))
277
278
279
def annotate_iter(self, version):
442
280
"""Yield list of (index-id, line) pairs for the specified version.
443
281
444
282
The index indicates when the line originated in the weave."""
445
incls = [self.maybe_lookup(name_or_index)]
446
for origin, lineno, text in self._extract(incls):
283
included = self.inclusions([version])
284
for origin, lineno, text in self._extract(included):
447
285
yield origin, text
448
286
449
def _walk(self):
450
"""Walk the weave.
451
452
Yields sequence of
453
(lineno, insert, deletes, text)
454
for each literal line.
455
"""
456
457
istack = []
458
dset = set()
459
460
lineno = 0 # line of weave, 0-based
461
462
for l in self._weave:
463
if isinstance(l, tuple):
464
c, v = l
465
isactive = None
466
if c == '{':
467
istack.append(v)
468
elif c == '}':
469
istack.pop()
470
elif c == '[':
471
assert v not in dset
472
dset.add(v)
473
elif c == ']':
474
dset.remove(v)
475
else:
476
raise WeaveFormatError('unexpected instruction %r' % v)
477
else:
478
assert isinstance(l, basestring)
479
assert istack
480
yield lineno, istack[-1], dset, l
481
lineno += 1
482
483
484
485
def _extract(self, versions):
287
288
def _extract(self, included):
486
289
"""Yield annotation of lines in included set.
487
290
488
291
Yields a sequence of tuples (origin, lineno, text), where
491
294
492
295
The set typically but not necessarily corresponds to a version.
493
296
"""
494
for i in versions:
495
if not isinstance(i, int):
496
raise ValueError(i)
497
498
included = self.inclusions(versions)
499
500
istack = []
501
dset = set()
502
503
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
504
300
505
301
isactive = None
506
302
507
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.
508
314
509
315
WFE = WeaveFormatError
510
316
511
for l in self._weave:
317
for l in self._l:
512
318
if isinstance(l, tuple):
319
isactive = None # recalculate
513
320
c, v = l
514
isactive = None
515
321
if c == '{':
516
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))
517
325
istack.append(v)
518
326
elif c == '}':
519
istack.pop()
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))
520
335
elif c == '[':
521
if v in included:
522
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
523
345
dset.add(v)
524
else:
525
assert c == ']'
526
if v in included:
527
assert v in dset
346
elif c == ']':
347
if v in dset:
528
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))
529
355
else:
530
356
assert isinstance(l, basestring)
531
if isactive is None:
532
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)
533
363
if isactive:
534
result.append((istack[-1], lineno, l))
364
origin = istack[-1]
365
yield origin, lineno, l
535
366
lineno += 1
367
536
368
if istack:
537
raise WeaveFormatError("unclosed insertion blocks "
538
"at end of weave: %s" % istack)
369
raise WFE("unclosed insertion blocks at end of weave",
370
istack)
539
371
if dset:
540
raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
541
% dset)
542
return result
543
544
545
def get_iter(self, name_or_index):
372
raise WFE("unclosed deletion blocks at end of weave",
373
dset)
374
375
376
def get_iter(self, version):
546
377
"""Yield lines for the specified version."""
547
incls = [self.maybe_lookup(name_or_index)]
548
for origin, lineno, line in self._extract(incls):
378
for origin, lineno, line in self._extract(self.inclusions([version])):
549
379
yield line
550
380
551
381
552
def get_text(self, name_or_index):
553
return ''.join(self.get_iter(name_or_index))
554
assert isinstance(version, int)
555
556
557
def get_lines(self, name_or_index):
558
return list(self.get_iter(name_or_index))
559
560
561
get = get_lines
382
def get(self, index):
383
return list(self.get_iter(index))
562
384
563
385
564
386
def mash_iter(self, included):
565
387
"""Return composed version of multiple included versions."""
566
included = map(self.maybe_lookup, included)
388
included = frozenset(included)
567
389
for origin, lineno, text in self._extract(included):
568
390
yield text
569
391
570
392
571
393
def dump(self, to_file):
572
394
from pprint import pprint
573
print >>to_file, "Weave._weave = ",
574
pprint(self._weave, to_file)
575
print >>to_file, "Weave._parents = ",
576
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)
577
399
578
400
579
401
580
402
def numversions(self):
581
l = len(self._parents)
403
l = len(self._v)
582
404
assert l == len(self._sha1s)
583
405
return l
584
406
585
407
586
def __len__(self):
587
return self.numversions()
588
589
590
def check(self, progress_bar=None):
408
def check(self):
591
409
# check no circular inclusions
592
410
for version in range(self.numversions()):
593
inclusions = list(self._parents[version])
411
inclusions = list(self._v[version])
594
412
if inclusions:
595
413
inclusions.sort()
596
414
if inclusions[-1] >= version:
599
417
600
418
# try extracting all versions; this is a bit slow and parallel
601
419
# extraction could be used
602
nv = self.numversions()
603
for version in range(nv):
604
if progress_bar:
605
progress_bar.update('checking text', version, nv)
420
import sha
421
for version in range(self.numversions()):
606
422
s = sha.new()
607
423
for l in self.get_iter(version):
608
424
s.update(l)
613
429
"got %s, expected %s"
614
430
% (version, hd, expected))
615
431
616
# TODO: check insertions are properly nested, that there are
617
# no lines outside of insertion blocks, that deletions are
618
# properly paired, etc.
619
620
432
621
433
622
434
def merge(self, merge_versions):
629
441
If there is a chunk of the file where there's no diagreement,
630
442
only one alternative is given.
631
443
"""
444
632
445
# approach: find the included versions common to all the
633
446
# merged versions
634
447
raise NotImplementedError()
654
467
If line1=line2, this is a pure insert; if newlines=[] this is a
655
468
pure delete. (Similar to difflib.)
656
469
"""
657
raise NotImplementedError()
658
659
660
def plan_merge(self, ver_a, ver_b):
661
"""Return pseudo-annotation indicating how the two versions merge.
662
663
This is computed between versions a and b and their common
664
base.
665
666
Weave lines present in none of them are skipped entirely.
667
"""
668
inc_a = self.inclusions([ver_a])
669
inc_b = self.inclusions([ver_b])
670
inc_c = inc_a & inc_b
671
672
for lineno, insert, deleteset, line in self._walk():
673
if deleteset & inc_c:
674
# killed in parent; can't be in either a or b
675
# not relevant to our work
676
yield 'killed-base', line
677
elif insert in inc_c:
678
# was inserted in base
679
killed_a = bool(deleteset & inc_a)
680
killed_b = bool(deleteset & inc_b)
681
if killed_a and killed_b:
682
yield 'killed-both', line
683
elif killed_a:
684
yield 'killed-a', line
685
elif killed_b:
686
yield 'killed-b', line
687
else:
688
yield 'unchanged', line
689
elif insert in inc_a:
690
if deleteset & inc_a:
691
yield 'ghost-a', line
692
else:
693
# new in A; not in B
694
yield 'new-a', line
695
elif insert in inc_b:
696
if deleteset & inc_b:
697
yield 'ghost-b', line
698
else:
699
yield 'new-b', line
700
else:
701
# not in either revision
702
yield 'irrelevant', line
703
704
yield 'unchanged', '' # terminator
705
706
707
708
def weave_merge(self, plan):
709
lines_a = []
710
lines_b = []
711
ch_a = ch_b = False
712
713
for state, line in plan:
714
if state == 'unchanged' or state == 'killed-both':
715
# resync and flush queued conflicts changes if any
716
if not lines_a and not lines_b:
717
pass
718
elif ch_a and not ch_b:
719
# one-sided change:
720
for l in lines_a: yield l
721
elif ch_b and not ch_a:
722
for l in lines_b: yield l
723
elif lines_a == lines_b:
724
for l in lines_a: yield l
725
else:
726
yield '<<<<<<<\n'
727
for l in lines_a: yield l
728
yield '=======\n'
729
for l in lines_b: yield l
730
yield '>>>>>>>\n'
731
732
del lines_a[:]
733
del lines_b[:]
734
ch_a = ch_b = False
735
736
if state == 'unchanged':
737
if line:
738
yield line
739
elif state == 'killed-a':
740
ch_a = True
741
lines_b.append(line)
742
elif state == 'killed-b':
743
ch_b = True
744
lines_a.append(line)
745
elif state == 'new-a':
746
ch_a = True
747
lines_a.append(line)
748
elif state == 'new-b':
749
ch_b = True
750
lines_b.append(line)
751
else:
752
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
753
'killed-both'), \
754
state
755
756
757
def join(self, other):
758
"""Integrate versions from other into this weave.
759
760
The resulting weave contains all the history of both weaves;
761
any version you could retrieve from either self or other can be
762
retrieved from self after this call.
763
764
It is illegal for the two weaves to contain different values
765
or different parents for any version. See also reweave().
766
"""
767
if other.numversions() == 0:
768
return # nothing to update, easy
769
# two loops so that we do not change ourselves before verifying it
770
# will be ok
771
# work through in index order to make sure we get all dependencies
772
for other_idx, name in enumerate(other._names):
773
if self._check_version_consistent(other, other_idx, name):
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':
774
493
continue
775
for other_idx, name in enumerate(other._names):
776
# TODO: If all the parents of the other version are already
777
# present then we can avoid some work by just taking the delta
778
# and adjusting the offsets.
779
new_parents = self._imported_parents(other, other_idx)
780
lines = other.get_lines(other_idx)
781
sha1 = other._sha1s[other_idx]
782
self.add(name, new_parents, lines, sha1)
783
784
785
def _imported_parents(self, other, other_idx):
786
"""Return list of parents in self corresponding to indexes in other."""
787
new_parents = []
788
for parent_idx in other._parents[other_idx]:
789
parent_name = other._names[parent_idx]
790
if parent_name not in self._names:
791
# should not be possible
792
raise WeaveError("missing parent {%s} of {%s} in %r"
793
% (parent_name, other._name_map[other_idx], self))
794
new_parents.append(self._name_map[parent_name])
795
return new_parents
796
797
def _check_version_consistent(self, other, other_idx, name):
798
"""Check if a version in consistent in this and other.
799
800
To be consistent it must have:
801
802
* the same text
803
* the same direct parents (by name, not index, and disregarding
804
order)
805
806
If present & correct return True;
807
if not present in self return False;
808
if inconsistent raise error."""
809
this_idx = self._name_map.get(name, -1)
810
if this_idx != -1:
811
if self._sha1s[this_idx] != other._sha1s[other_idx]:
812
raise WeaveError("inconsistent texts for version {%s} "
813
"when joining weaves"
814
% (name))
815
self_parents = self._parents[this_idx]
816
other_parents = other._parents[other_idx]
817
n1 = [self._names[i] for i in self_parents]
818
n2 = [other._names[i] for i in other_parents]
819
n1.sort()
820
n2.sort()
821
if n1 != n2:
822
raise WeaveParentMismatch("inconsistent parents "
823
"for version {%s}: %s vs %s" % (name, n1, n2))
824
else:
825
return True # ok!
826
else:
827
return False
828
829
def reweave(self, other):
830
"""Reweave self with other."""
831
new_weave = reweave(self, other)
832
for attr in self.__slots__:
833
setattr(self, attr, getattr(new_weave, attr))
834
835
836
def reweave(wa, wb):
837
"""Combine two weaves and return the result.
838
839
This works even if a revision R has different parents in
840
wa and wb. In the resulting weave all the parents are given.
841
842
This is done by just building up a new weave, maintaining ordering
843
of the versions in the two inputs. More efficient approaches
844
might be possible but it should only be necessary to do
845
this operation rarely, when a new previously ghost version is
846
inserted.
847
"""
848
wr = Weave()
849
ia = ib = 0
850
queue_a = range(wa.numversions())
851
queue_b = range(wb.numversions())
852
# first determine combined parents of all versions
853
# map from version name -> all parent names
854
combined_parents = _reweave_parent_graphs(wa, wb)
855
mutter("combined parents: %r", combined_parents)
856
order = topo_sort(combined_parents.iteritems())
857
mutter("order to reweave: %r", order)
858
for name in order:
859
if name in wa._name_map:
860
lines = wa.get_lines(name)
861
if name in wb._name_map:
862
assert lines == wb.get_lines(name)
863
else:
864
lines = wb.get_lines(name)
865
wr.add(name, combined_parents[name], lines)
866
return wr
867
868
869
def _reweave_parent_graphs(wa, wb):
870
"""Return combined parent ancestry for two weaves.
871
872
Returned as a list of (version_name, set(parent_names))"""
873
combined = {}
874
for weave in [wa, wb]:
875
for idx, name in enumerate(weave._names):
876
p = combined.setdefault(name, set())
877
p.update(map(weave.idx_to_name, weave._parents[idx]))
878
return combined
879
880
881
def weave_toc(w):
882
"""Show the weave's table-of-contents"""
883
print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
884
for i in (6, 50, 10, 10):
885
print '-' * i,
886
print
887
for i in range(w.numversions()):
888
sha1 = w._sha1s[i]
889
name = w._names[i]
890
parent_str = ' '.join(map(str, w._parents[i]))
891
print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
892
893
894
895
def weave_stats(weave_file, pb):
896
from bzrlib.weavefile import read_weave
897
898
wf = file(weave_file, 'rb')
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):
509
"""Show some text information about the weave."""
510
from weavefile import read_weave
511
wf = file(filename, 'rb')
899
512
w = read_weave(wf)
900
513
# FIXME: doesn't work on pipes
901
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)
902
517
903
518
total = 0
904
vers = len(w)
905
for i in range(vers):
906
pb.update('checking sizes', i, vers)
907
for origin, lineno, line in w._extract([i]):
908
total += len(line)
909
910
pb.clear()
911
912
print 'versions %9d' % vers
913
print 'weave file %9d bytes' % weave_size
914
print 'total contents %9d bytes' % total
915
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
916
if vers:
917
avg = total/vers
918
print 'average size %9d bytes' % avg
919
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
920
921
922
def usage():
923
print """bzr weave tool
924
925
Experimental tool for weave algorithm.
926
927
usage:
928
weave init WEAVEFILE
929
Create an empty weave file
930
weave get WEAVEFILE VERSION
931
Write out specified version.
932
weave check WEAVEFILE
933
Check consistency of all versions.
934
weave toc WEAVEFILE
935
Display table of contents.
936
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
937
Add NEWTEXT, with specified parent versions.
938
weave annotate WEAVEFILE VERSION
939
Display origin of each line.
940
weave mash WEAVEFILE VERSION...
941
Display composite of all selected versions.
942
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
943
Auto-merge two versions and display conflicts.
944
weave diff WEAVEFILE VERSION1 VERSION2
945
Show differences between two versions.
946
947
example:
948
949
% weave init foo.weave
950
% vi foo.txt
951
% weave add foo.weave ver0 < foo.txt
952
added version 0
953
954
(create updated version)
955
% vi foo.txt
956
% weave get foo.weave 0 | diff -u - foo.txt
957
% weave add foo.weave ver1 0 < foo.txt
958
added version 1
959
960
% weave get foo.weave 0 > foo.txt (create forked version)
961
% vi foo.txt
962
% weave add foo.weave ver2 0 < foo.txt
963
added version 2
964
965
% weave merge foo.weave 1 2 > foo.txt (merge them)
966
% vi foo.txt (resolve conflicts)
967
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
968
969
"""
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))
970
531
971
532
972
533
973
534
def main(argv):
974
535
import sys
975
536
import os
976
try:
977
import bzrlib
978
except ImportError:
979
# in case we're run directly from the subdirectory
980
sys.path.append('..')
981
import bzrlib
982
from bzrlib.weavefile import write_weave, read_weave
983
from bzrlib.progress import ProgressBar
984
985
try:
986
import psyco
987
psyco.full()
988
except ImportError:
989
pass
990
991
if len(argv) < 2:
992
usage()
993
return 0
994
537
from weavefile import write_weave_v1, read_weave
995
538
cmd = argv[1]
996
997
def readit():
998
return read_weave(file(argv[2], 'rb'))
999
1000
if cmd == 'help':
1001
usage()
1002
elif cmd == 'add':
1003
w = readit()
539
if cmd == 'add':
540
w = read_weave(file(argv[2], 'rb'))
1004
541
# at the moment, based on everything in the file
1005
name = argv[3]
1006
parents = map(int, argv[4:])
542
parents = set(range(len(w._v)))
1007
543
lines = sys.stdin.readlines()
1008
ver = w.add(name, parents, lines)
1009
write_weave(w, file(argv[2], 'wb'))
1010
print 'added version %r %d' % (name, ver)
544
ver = w.add(parents, lines)
545
write_weave_v1(w, file(argv[2], 'wb'))
546
print 'added %d' % ver
1011
547
elif cmd == 'init':
1012
548
fn = argv[2]
1013
549
if os.path.exists(fn):
1014
550
raise IOError("file exists")
1015
551
w = Weave()
1016
write_weave(w, file(fn, 'wb'))
1017
elif cmd == 'get': # get one version
1018
w = readit()
552
write_weave_v1(w, file(fn, 'wb'))
553
elif cmd == 'get':
554
w = read_weave(file(argv[2], 'rb'))
1019
555
sys.stdout.writelines(w.get_iter(int(argv[3])))
1020
1021
elif cmd == 'mash': # get composite
1022
w = readit()
1023
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
1024
1025
elif cmd == 'diff':
1026
from difflib import unified_diff
1027
w = readit()
1028
fn = argv[2]
1029
v1, v2 = map(int, argv[3:5])
1030
lines1 = w.get(v1)
1031
lines2 = w.get(v2)
1032
diff_gen = unified_diff(lines1, lines2,
1033
'%s version %d' % (fn, v1),
1034
'%s version %d' % (fn, v2))
1035
sys.stdout.writelines(diff_gen)
1036
1037
556
elif cmd == 'annotate':
1038
w = readit()
557
w = read_weave(file(argv[2], 'rb'))
1039
558
# newline is added to all lines regardless; too hard to get
1040
559
# reasonable formatting otherwise
1041
560
lasto = None
1046
565
else:
1047
566
print '%5d | %s' % (origin, text)
1048
567
lasto = origin
1049
1050
elif cmd == 'toc':
1051
weave_toc(readit())
1052
1053
elif cmd == 'stats':
1054
weave_stats(argv[2], ProgressBar())
1055
568
elif cmd == 'info':
569
weave_info(argv[2], sys.stdout)
1056
570
elif cmd == 'check':
1057
w = readit()
1058
pb = ProgressBar()
1059
w.check(pb)
1060
pb.clear()
1061
print '%d versions ok' % w.numversions()
1062
1063
elif cmd == 'inclusions':
1064
w = readit()
1065
print ' '.join(map(str, w.inclusions([int(argv[3])])))
1066
1067
elif cmd == 'parents':
1068
w = readit()
1069
print ' '.join(map(str, w._parents[int(argv[3])]))
1070
1071
elif cmd == 'plan-merge':
1072
w = readit()
1073
for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
1074
if line:
1075
print '%14s | %s' % (state, line),
1076
1077
elif cmd == 'merge':
1078
w = readit()
1079
p = w.plan_merge(int(argv[3]), int(argv[4]))
1080
sys.stdout.writelines(w.weave_merge(p))
1081
1082
elif cmd == 'mash-merge':
1083
if len(argv) != 5:
1084
usage()
1085
return 1
1086
1087
w = readit()
1088
v1, v2 = map(int, argv[3:5])
1089
1090
basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
1091
1092
base_lines = list(w.mash_iter(basis))
1093
a_lines = list(w.get(v1))
1094
b_lines = list(w.get(v2))
1095
1096
from bzrlib.merge3 import Merge3
1097
m3 = Merge3(base_lines, a_lines, b_lines)
1098
1099
name_a = 'version %d' % v1
1100
name_b = 'version %d' % v2
1101
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()
1102
573
else:
1103
574
raise ValueError('unknown command %r' % cmd)
1104
575
1105
576
1106
1107
def profile_main(argv):
1108
import tempfile, hotshot, hotshot.stats
1109
1110
prof_f = tempfile.NamedTemporaryFile()
1111
1112
prof = hotshot.Profile(prof_f.name)
1113
1114
ret = prof.runcall(main, argv)
1115
prof.close()
1116
1117
stats = hotshot.stats.load(prof_f.name)
1118
#stats.strip_dirs()
1119
stats.sort_stats('cumulative')
1120
## XXX: Might like to write to stderr or the trace file instead but
1121
## print_stats seems hardcoded to stdout
1122
stats.print_stats(20)
1123
1124
return ret
1125
1126
1127
577
if __name__ == '__main__':
1128
578
import sys
1129
if '--profile' in sys.argv:
1130
args = sys.argv[:]
1131
args.remove('--profile')
1132
sys.exit(profile_main(args))
1133
else:
1134
sys.exit(main(sys.argv))
1135
579
sys.exit(main(sys.argv))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1