218
208
return self._parents == other._parents \
219
209
and self._weave == other._weave \
220
210
and self._sha1s == other._sha1s
222
213
def __ne__(self, other):
223
214
return not self.__eq__(other)
225
@deprecated_method(zero_eight)
226
def idx_to_name(self, index):
227
"""Old public interface, the public interface is all names now."""
230
def _idx_to_name(self, version):
231
return self._names[version]
233
@deprecated_method(zero_eight)
217
def maybe_lookup(self, name_or_index):
218
"""Convert possible symbolic name to index, or pass through indexes."""
219
if isinstance(name_or_index, (int, long)):
222
return self.lookup(name_or_index)
234
225
def lookup(self, name):
235
"""Backwards compatability thunk:
237
Return name, as name is valid in the api now, and spew deprecation
242
def _lookup(self, name):
243
226
"""Convert symbolic version name to index."""
245
228
return self._name_map[name]
247
raise RevisionNotPresent(name, self._weave_name)
249
@deprecated_method(zero_eight)
250
def iter_names(self):
251
"""Deprecated convenience function, please see VersionedFile.names()."""
252
return iter(self.names())
254
@deprecated_method(zero_eight)
256
"""See Weave.versions for the current api."""
257
return self.versions()
260
"""See VersionedFile.versions."""
261
return self._names[:]
263
def has_version(self, version_id):
264
"""See VersionedFile.has_version."""
265
return self._name_map.has_key(version_id)
267
__contains__ = has_version
269
def get_delta(self, version_id):
270
"""See VersionedFile.get_delta."""
271
return self.get_deltas([version_id])[version_id]
273
def get_deltas(self, version_ids):
274
"""See VersionedFile.get_deltas."""
275
version_ids = self.get_ancestry(version_ids)
276
for version_id in version_ids:
277
if not self.has_version(version_id):
278
raise RevisionNotPresent(version_id, self)
279
# try extracting all versions; parallel extraction is used
280
nv = self.num_versions()
286
last_parent_lines = {}
288
parent_inclusions = {}
293
# its simplest to generate a full set of prepared variables.
295
name = self._names[i]
296
sha1s[name] = self.get_sha1(name)
297
parents_list = self.get_parents(name)
299
parent = parents_list[0]
300
parents[name] = parent
301
parent_inclusions[name] = inclusions[parent]
304
parent_inclusions[name] = set()
305
# we want to emit start, finish, replacement_length, replacement_lines tuples.
306
diff_hunks[name] = []
307
current_hunks[name] = [0, 0, 0, []] # #start, finish, repl_length, repl_tuples
308
parent_linenums[name] = 0
310
parent_noeols[name] = False
311
last_parent_lines[name] = None
312
new_inc = set([name])
313
for p in self._parents[i]:
314
new_inc.update(inclusions[self._idx_to_name(p)])
315
# debug only, known good so far.
316
#assert set(new_inc) == set(self.get_ancestry(name)), \
317
# 'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
318
inclusions[name] = new_inc
320
nlines = len(self._weave)
322
for lineno, inserted, deletes, line in self._walk_internal():
323
# a line is active in a version if:
324
# insert is in the versions inclusions
326
# deleteset & the versions inclusions is an empty set.
327
# so - if we have a included by mapping - version is included by
328
# children, we get a list of children to examine for deletes affect
329
# ing them, which is less than the entire set of children.
330
for version_id in version_ids:
331
# The active inclusion must be an ancestor,
332
# and no ancestors must have deleted this line,
333
# because we don't support resurrection.
334
parent_inclusion = parent_inclusions[version_id]
335
inclusion = inclusions[version_id]
336
parent_active = inserted in parent_inclusion and not (deletes & parent_inclusion)
337
version_active = inserted in inclusion and not (deletes & inclusion)
338
if not parent_active and not version_active:
339
# unrelated line of ancestry
341
elif parent_active and version_active:
343
parent_linenum = parent_linenums[version_id]
344
if current_hunks[version_id] != [parent_linenum, parent_linenum, 0, []]:
345
diff_hunks[version_id].append(tuple(current_hunks[version_id]))
347
current_hunks[version_id] = [parent_linenum, parent_linenum, 0, []]
348
parent_linenums[version_id] = parent_linenum
351
noeols[version_id] = True
354
elif parent_active and not version_active:
356
current_hunks[version_id][1] += 1
357
parent_linenums[version_id] += 1
358
last_parent_lines[version_id] = line
359
elif not parent_active and version_active:
361
# noeol only occurs at the end of a file because we
362
# diff linewise. We want to show noeol changes as a
363
# empty diff unless the actual eol-less content changed.
366
if last_parent_lines[version_id][-1] != '\n':
367
parent_noeols[version_id] = True
368
except (TypeError, IndexError):
371
if theline[-1] != '\n':
372
noeols[version_id] = True
376
parent_should_go = False
378
if parent_noeols[version_id] == noeols[version_id]:
379
# no noeol toggle, so trust the weaves statement
380
# that this line is changed.
382
if parent_noeols[version_id]:
383
theline = theline + '\n'
384
elif parent_noeols[version_id]:
385
# parent has no eol, we do:
386
# our line is new, report as such..
388
elif noeols[version_id]:
389
# append a eol so that it looks like
391
theline = theline + '\n'
392
if parents[version_id] is not None:
393
#if last_parent_lines[version_id] is not None:
394
parent_should_go = True
395
if last_parent_lines[version_id] != theline:
398
#parent_should_go = False
400
current_hunks[version_id][2] += 1
401
current_hunks[version_id][3].append((inserted, theline))
403
# last hunk last parent line is not eaten
404
current_hunks[version_id][1] -= 1
405
if current_hunks[version_id][1] < 0:
406
current_hunks[version_id][1] = 0
407
# import pdb;pdb.set_trace()
408
# assert current_hunks[version_id][1] >= 0
412
version = self._idx_to_name(i)
413
if current_hunks[version] != [0, 0, 0, []]:
414
diff_hunks[version].append(tuple(current_hunks[version]))
416
for version_id in version_ids:
417
result[version_id] = (
421
diff_hunks[version_id],
425
def get_parents(self, version_id):
426
"""See VersionedFile.get_parent."""
427
return map(self._idx_to_name, self._parents[self._lookup(version_id)])
429
def _check_repeated_add(self, name, parents, text, sha1):
230
raise WeaveError("name %r not present in weave %r" %
231
(name, self._weave_name))
234
def idx_to_name(self, version):
235
return self._names[version]
238
def _check_repeated_add(self, name, parents, text):
430
239
"""Check that a duplicated add is OK.
432
241
If it is, return the (old) index; otherwise raise an exception.
434
idx = self._lookup(name)
435
if sorted(self._parents[idx]) != sorted(parents) \
436
or sha1 != self._sha1s[idx]:
437
raise RevisionAlreadyPresent(name, self._weave_name)
243
idx = self.lookup(name)
244
if sorted(self._parents[idx]) != sorted(parents):
245
raise WeaveError("name \"%s\" already present in weave "
246
"with different parents" % name)
247
new_sha1 = sha_strings(text)
248
if new_sha1 != self._sha1s[idx]:
249
raise WeaveError("name \"%s\" already present in weave "
250
"with different text" % name)
440
@deprecated_method(zero_eight)
441
def add_identical(self, old_rev_id, new_rev_id, parents):
442
"""Please use Weave.clone_text now."""
443
return self.clone_text(new_rev_id, old_rev_id, parents)
445
def _add_lines(self, version_id, parents, lines, parent_texts):
446
"""See VersionedFile.add_lines."""
447
return self._add(version_id, lines, map(self._lookup, parents))
449
@deprecated_method(zero_eight)
450
def add(self, name, parents, text, sha1=None):
451
"""See VersionedFile.add_lines for the non deprecated api."""
452
return self._add(name, text, map(self._maybe_lookup, parents), sha1)
454
def _add(self, version_id, lines, parents, sha1=None):
255
def add(self, name, parents, text):
455
256
"""Add a single text on top of the weave.
457
258
Returns the index number of the newly added version.
460
261
Symbolic name for this version.
461
262
(Typically the revision-id of the revision that added it.)
464
265
List or set of direct parent version numbers.
467
Sequence of lines to be added in the new version.
470
assert isinstance(version_id, basestring)
471
self._check_lines_not_unicode(lines)
472
self._check_lines_are_lines(lines)
474
sha1 = sha_strings(lines)
475
if version_id in self._name_map:
476
return self._check_repeated_add(version_id, parents, lines, sha1)
268
Sequence of lines to be added in the new version."""
270
assert isinstance(name, basestring)
271
if name in self._name_map:
272
return self._check_repeated_add(name, parents, text)
274
parents = map(self.maybe_lookup, parents)
478
275
self._check_versions(parents)
479
## self._check_lines(lines)
276
## self._check_lines(text)
480
277
new_version = len(self._parents)
279
sha1 = sha_strings(text)
482
281
# if we abort after here the (in-memory) weave will be corrupt because only
483
282
# some fields are updated
484
# XXX: FIXME implement a succeed-or-fail of the rest of this routine.
485
# - Robert Collins 20060226
486
283
self._parents.append(parents[:])
487
284
self._sha1s.append(sha1)
488
self._names.append(version_id)
489
self._name_map[version_id] = new_version
285
self._names.append(name)
286
self._name_map[name] = new_version
841
assert l.__class__ in (str, unicode)
533
assert isinstance(l, basestring)
842
534
if isactive is None:
843
535
isactive = (not dset) and istack and (istack[-1] in included)
845
537
result.append((istack[-1], lineno, l))
848
raise WeaveFormatError("unclosed insertion blocks "
849
"at end of weave: %s" % istack)
541
raise WFE("unclosed insertion blocks at end of weave",
851
raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
544
raise WFE("unclosed deletion blocks at end of weave",
855
@deprecated_method(zero_eight)
856
551
def get_iter(self, name_or_index):
857
"""Deprecated, please do not use. Lookups are not not needed.
859
Please use get_lines now.
861
return iter(self.get_lines(self._maybe_lookup(name_or_index)))
863
@deprecated_method(zero_eight)
864
def maybe_lookup(self, name_or_index):
865
"""Deprecated, please do not use. Lookups are not not needed."""
866
return self._maybe_lookup(name_or_index)
868
def _maybe_lookup(self, name_or_index):
869
"""Convert possible symbolic name to index, or pass through indexes.
873
if isinstance(name_or_index, (int, long)):
876
return self._lookup(name_or_index)
878
@deprecated_method(zero_eight)
879
def get(self, version_id):
880
"""Please use either Weave.get_text or Weave.get_lines as desired."""
881
return self.get_lines(version_id)
883
def get_lines(self, version_id):
884
"""See VersionedFile.get_lines()."""
885
int_index = self._maybe_lookup(version_id)
886
result = [line for (origin, lineno, line) in self._extract([int_index])]
887
expected_sha1 = self._sha1s[int_index]
888
measured_sha1 = sha_strings(result)
889
if measured_sha1 != expected_sha1:
890
raise errors.WeaveInvalidChecksum(
891
'file %s, revision %s, expected: %s, measured %s'
892
% (self._weave_name, version_id,
893
expected_sha1, measured_sha1))
896
def get_sha1(self, version_id):
897
"""See VersionedFile.get_sha1()."""
898
return self._sha1s[self._lookup(version_id)]
900
@deprecated_method(zero_eight)
552
"""Yield lines for the specified version."""
553
incls = [self.maybe_lookup(name_or_index)]
554
for origin, lineno, line in self._extract(incls):
558
def get_text(self, version):
559
assert isinstance(version, int)
561
s.writelines(self.get_iter(version))
565
def get(self, name_or_index):
566
return list(self.get_iter(name_or_index))
569
def mash_iter(self, included):
570
"""Return composed version of multiple included versions."""
571
for origin, lineno, text in self._extract(included):
575
def dump(self, to_file):
576
from pprint import pprint
577
print >>to_file, "Weave._weave = ",
578
pprint(self._weave, to_file)
579
print >>to_file, "Weave._parents = ",
580
pprint(self._parents, to_file)
901
584
def numversions(self):
902
"""How many versions are in this weave?
904
Deprecated in favour of num_versions.
906
return self.num_versions()
908
def num_versions(self):
909
"""How many versions are in this weave?"""
910
585
l = len(self._parents)
911
586
assert l == len(self._sha1s)
914
__len__ = num_versions
591
return self.numversions()
916
594
def check(self, progress_bar=None):
917
# TODO evaluate performance hit of using string sets in this routine.
918
# TODO: check no circular inclusions
919
# TODO: create a nested progress bar
920
for version in range(self.num_versions()):
595
# check no circular inclusions
596
for version in range(self.numversions()):
921
597
inclusions = list(self._parents[version])
923
599
inclusions.sort()
925
601
raise WeaveFormatError("invalid included version %d for index %d"
926
602
% (inclusions[-1], version))
928
# try extracting all versions; parallel extraction is used
929
nv = self.num_versions()
934
# For creating the ancestry, IntSet is much faster (3.7s vs 0.17s)
935
# The problem is that set membership is much more expensive
936
name = self._idx_to_name(i)
937
sha1s[name] = sha.new()
939
new_inc = set([name])
940
for p in self._parents[i]:
941
new_inc.update(inclusions[self._idx_to_name(p)])
943
assert set(new_inc) == set(self.get_ancestry(name)), \
944
'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
945
inclusions[name] = new_inc
947
nlines = len(self._weave)
949
update_text = 'checking weave'
951
short_name = os.path.basename(self._weave_name)
952
update_text = 'checking %s' % (short_name,)
953
update_text = update_text[:25]
955
for lineno, insert, deleteset, line in self._walk_internal():
604
# try extracting all versions; this is a bit slow and parallel
605
# extraction could be used
606
nv = self.numversions()
607
for version in range(nv):
957
progress_bar.update(update_text, lineno, nlines)
959
for name, name_inclusions in inclusions.items():
960
# The active inclusion must be an ancestor,
961
# and no ancestors must have deleted this line,
962
# because we don't support resurrection.
963
if (insert in name_inclusions) and not (deleteset & name_inclusions):
964
sha1s[name].update(line)
967
version = self._idx_to_name(i)
968
hd = sha1s[version].hexdigest()
969
expected = self._sha1s[i]
609
progress_bar.update('checking text', version, nv)
611
for l in self.get_iter(version):
614
expected = self._sha1s[version]
970
615
if hd != expected:
971
raise errors.WeaveInvalidChecksum(
972
"mismatched sha1 for version %s: "
973
"got %s, expected %s"
974
% (version, hd, expected))
616
raise WeaveError("mismatched sha1 for version %d; "
617
"got %s, expected %s"
618
% (version, hd, expected))
976
620
# TODO: check insertions are properly nested, that there are
977
621
# no lines outside of insertion blocks, that deletions are
978
622
# properly paired, etc.
980
def _join(self, other, pb, msg, version_ids, ignore_missing):
981
"""Worker routine for join()."""
982
if not other.versions():
983
return # nothing to update, easy
986
# versions is never none, InterWeave checks this.
989
# two loops so that we do not change ourselves before verifying it
991
# work through in index order to make sure we get all dependencies
994
# get the selected versions only that are in other.versions.
995
version_ids = set(other.versions()).intersection(set(version_ids))
996
# pull in the referenced graph.
997
version_ids = other.get_ancestry(version_ids)
998
pending_graph = [(version, other.get_parents(version)) for
999
version in version_ids]
1000
for name in topo_sort(pending_graph):
1001
other_idx = other._name_map[name]
1002
# returns True if we have it, False if we need it.
1003
if not self._check_version_consistent(other, other_idx, name):
1004
names_to_join.append((other_idx, name))
1013
for other_idx, name in names_to_join:
1014
# TODO: If all the parents of the other version are already
1015
# present then we can avoid some work by just taking the delta
1016
# and adjusting the offsets.
1017
new_parents = self._imported_parents(other, other_idx)
1018
sha1 = other._sha1s[other_idx]
1023
pb.update(msg, merged, len(names_to_join))
1025
lines = other.get_lines(other_idx)
1026
self._add(name, lines, new_parents, sha1)
1028
mutter("merged = %d, processed = %d, file_id=%s; deltat=%d"%(
1029
merged, processed, self._weave_name, time.time()-time0))
1031
def _imported_parents(self, other, other_idx):
1032
"""Return list of parents in self corresponding to indexes in other."""
1034
for parent_idx in other._parents[other_idx]:
1035
parent_name = other._names[parent_idx]
1036
if parent_name not in self._name_map:
1037
# should not be possible
1038
raise WeaveError("missing parent {%s} of {%s} in %r"
1039
% (parent_name, other._name_map[other_idx], self))
1040
new_parents.append(self._name_map[parent_name])
1043
def _check_version_consistent(self, other, other_idx, name):
1044
"""Check if a version in consistent in this and other.
1046
To be consistent it must have:
1049
* the same direct parents (by name, not index, and disregarding
1052
If present & correct return True;
1053
if not present in self return False;
1054
if inconsistent raise error."""
1055
this_idx = self._name_map.get(name, -1)
1057
if self._sha1s[this_idx] != other._sha1s[other_idx]:
1058
raise errors.WeaveTextDiffers(name, self, other)
1059
self_parents = self._parents[this_idx]
1060
other_parents = other._parents[other_idx]
1061
n1 = set([self._names[i] for i in self_parents])
1062
n2 = set([other._names[i] for i in other_parents])
1063
if not self._compatible_parents(n1, n2):
1064
raise WeaveParentMismatch("inconsistent parents "
1065
"for version {%s}: %s vs %s" % (name, n1, n2))
1071
@deprecated_method(zero_eight)
1072
def reweave(self, other, pb=None, msg=None):
1073
"""reweave has been superceded by plain use of join."""
1074
return self.join(other, pb, msg)
1076
def _reweave(self, other, pb, msg):
1077
"""Reweave self with other - internal helper for join().
1079
:param other: The other weave to merge
1080
:param pb: An optional progress bar, indicating how far done we are
1081
:param msg: An optional message for the progress
1083
new_weave = _reweave(self, other, pb=pb, msg=msg)
1084
self._copy_weave_content(new_weave)
1086
def _copy_weave_content(self, otherweave):
1087
"""adsorb the content from otherweave."""
1088
for attr in self.__slots__:
1089
if attr != '_weave_name':
1090
setattr(self, attr, copy(getattr(otherweave, attr)))
1093
class WeaveFile(Weave):
1094
"""A WeaveFile represents a Weave on disk and writes on change."""
1096
WEAVE_SUFFIX = '.weave'
1098
def __init__(self, name, transport, filemode=None, create=False, access_mode='w'):
1099
"""Create a WeaveFile.
1101
:param create: If not True, only open an existing knit.
1103
super(WeaveFile, self).__init__(name, access_mode)
1104
self._transport = transport
1105
self._filemode = filemode
1107
_read_weave_v5(self._transport.get(name + WeaveFile.WEAVE_SUFFIX), self)
1108
except errors.NoSuchFile:
1114
def _add_lines(self, version_id, parents, lines, parent_texts):
1115
"""Add a version and save the weave."""
1116
result = super(WeaveFile, self)._add_lines(version_id, parents, lines,
1121
def _clone_text(self, new_version_id, old_version_id, parents):
1122
"""See VersionedFile.clone_text."""
1123
super(WeaveFile, self)._clone_text(new_version_id, old_version_id, parents)
1126
def copy_to(self, name, transport):
1127
"""See VersionedFile.copy_to()."""
1128
# as we are all in memory always, just serialise to the new place.
1130
write_weave_v5(self, sio)
1132
transport.put(name + WeaveFile.WEAVE_SUFFIX, sio, self._filemode)
1134
def create_empty(self, name, transport, filemode=None):
1135
return WeaveFile(name, transport, filemode, create=True)
1138
"""Save the weave."""
1139
self._check_write_ok()
1141
write_weave_v5(self, sio)
1143
self._transport.put(self._weave_name + WeaveFile.WEAVE_SUFFIX,
1149
"""See VersionedFile.get_suffixes()."""
1150
return [WeaveFile.WEAVE_SUFFIX]
1152
def join(self, other, pb=None, msg=None, version_ids=None,
1153
ignore_missing=False):
1154
"""Join other into self and save."""
1155
super(WeaveFile, self).join(other, pb, msg, version_ids, ignore_missing)
1159
@deprecated_function(zero_eight)
1160
def reweave(wa, wb, pb=None, msg=None):
1161
"""reweaving is deprecation, please just use weave.join()."""
1162
_reweave(wa, wb, pb, msg)
1164
def _reweave(wa, wb, pb=None, msg=None):
1165
"""Combine two weaves and return the result.
1167
This works even if a revision R has different parents in
1168
wa and wb. In the resulting weave all the parents are given.
1170
This is done by just building up a new weave, maintaining ordering
1171
of the versions in the two inputs. More efficient approaches
1172
might be possible but it should only be necessary to do
1173
this operation rarely, when a new previously ghost version is
1176
:param pb: An optional progress bar, indicating how far done we are
1177
:param msg: An optional message for the progress
1181
queue_a = range(wa.num_versions())
1182
queue_b = range(wb.num_versions())
1183
# first determine combined parents of all versions
1184
# map from version name -> all parent names
1185
combined_parents = _reweave_parent_graphs(wa, wb)
1186
mutter("combined parents: %r", combined_parents)
1187
order = topo_sort(combined_parents.iteritems())
1188
mutter("order to reweave: %r", order)
1193
for idx, name in enumerate(order):
1195
pb.update(msg, idx, len(order))
1196
if name in wa._name_map:
1197
lines = wa.get_lines(name)
1198
if name in wb._name_map:
1199
lines_b = wb.get_lines(name)
1200
if lines != lines_b:
1201
mutter('Weaves differ on content. rev_id {%s}', name)
1202
mutter('weaves: %s, %s', wa._weave_name, wb._weave_name)
1204
lines = list(difflib.unified_diff(lines, lines_b,
1205
wa._weave_name, wb._weave_name))
1206
mutter('lines:\n%s', ''.join(lines))
1207
raise errors.WeaveTextDiffers(name, wa, wb)
1209
lines = wb.get_lines(name)
1210
wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
1213
def _reweave_parent_graphs(wa, wb):
1214
"""Return combined parent ancestry for two weaves.
1216
Returned as a list of (version_name, set(parent_names))"""
1218
for weave in [wa, wb]:
1219
for idx, name in enumerate(weave._names):
1220
p = combined.setdefault(name, set())
1221
p.update(map(weave._idx_to_name, weave._parents[idx]))
626
def merge(self, merge_versions):
627
"""Automerge and mark conflicts between versions.
629
This returns a sequence, each entry describing alternatives
630
for a chunk of the file. Each of the alternatives is given as
633
If there is a chunk of the file where there's no diagreement,
634
only one alternative is given.
637
# approach: find the included versions common to all the
639
raise NotImplementedError()
643
def _delta(self, included, lines):
644
"""Return changes from basis to new revision.
646
The old text for comparison is the union of included revisions.
648
This is used in inserting a new text.
650
Delta is returned as a sequence of
651
(weave1, weave2, newlines).
653
This indicates that weave1:weave2 of the old weave should be
654
replaced by the sequence of lines in newlines. Note that
655
these line numbers are positions in the total weave and don't
656
correspond to the lines in any extracted version, or even the
657
extracted union of included versions.
659
If line1=line2, this is a pure insert; if newlines=[] this is a
660
pure delete. (Similar to difflib.)
665
def plan_merge(self, ver_a, ver_b):
666
"""Return pseudo-annotation indicating how the two versions merge.
668
This is computed between versions a and b and their common
671
Weave lines present in none of them are skipped entirely.
673
inc_a = self.inclusions([ver_a])
674
inc_b = self.inclusions([ver_b])
675
inc_c = inc_a & inc_b
677
for lineno, insert, deleteset, line in self._walk():
678
if deleteset & inc_c:
679
# killed in parent; can't be in either a or b
680
# not relevant to our work
681
yield 'killed-base', line
682
elif insert in inc_c:
683
# was inserted in base
684
killed_a = bool(deleteset & inc_a)
685
killed_b = bool(deleteset & inc_b)
686
if killed_a and killed_b:
687
yield 'killed-both', line
689
yield 'killed-a', line
691
yield 'killed-b', line
693
yield 'unchanged', line
694
elif insert in inc_a:
695
if deleteset & inc_a:
696
yield 'ghost-a', line
700
elif insert in inc_b:
701
if deleteset & inc_b:
702
yield 'ghost-b', line
706
# not in either revision
707
yield 'irrelevant', line
709
yield 'unchanged', '' # terminator
713
def weave_merge(self, plan):
718
for state, line in plan:
719
if state == 'unchanged' or state == 'killed-both':
720
# resync and flush queued conflicts changes if any
721
if not lines_a and not lines_b:
723
elif ch_a and not ch_b:
725
for l in lines_a: yield l
726
elif ch_b and not ch_a:
727
for l in lines_b: yield l
728
elif lines_a == lines_b:
729
for l in lines_a: yield l
732
for l in lines_a: yield l
734
for l in lines_b: yield l
741
if state == 'unchanged':
744
elif state == 'killed-a':
747
elif state == 'killed-b':
750
elif state == 'new-a':
753
elif state == 'new-b':
757
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
1225
767
def weave_toc(w):
added
removed
bzrlib/weave.py
