forked from rojo-rbx/rojo
442 lines
14 KiB
Lua
442 lines
14 KiB
Lua
--[[
|
|
Based on DiffMatchPatch by Neil Fraser.
|
|
https://github.com/google/diff-match-patch
|
|
]]
|
|
|
|
export type DiffAction = number
|
|
export type Diff = { actionType: DiffAction, value: string }
|
|
export type Diffs = { Diff }
|
|
|
|
local StringDiff = {
|
|
ActionTypes = table.freeze({
|
|
Equal = 0,
|
|
Delete = 1,
|
|
Insert = 2,
|
|
}),
|
|
}
|
|
|
|
function StringDiff.findDiffs(text1: string, text2: string): Diffs
|
|
-- Validate inputs
|
|
if type(text1) ~= "string" or type(text2) ~= "string" then
|
|
error(
|
|
string.format(
|
|
"Invalid inputs to StringDiff.findDiffs, expected strings and got (%s, %s)",
|
|
type(text1),
|
|
type(text2)
|
|
),
|
|
2
|
|
)
|
|
end
|
|
|
|
-- Shortcut if the texts are identical
|
|
if text1 == text2 then
|
|
return { { actionType = StringDiff.ActionTypes.Equal, value = text1 } }
|
|
end
|
|
|
|
-- Trim off any shared prefix and suffix
|
|
-- These are easy to detect and can be dealt with quickly without needing a complex diff
|
|
-- and later we simply add them as Equal to the start and end of the diff
|
|
local sharedPrefix, sharedSuffix
|
|
local prefixLength = StringDiff._sharedPrefix(text1, text2)
|
|
if prefixLength > 0 then
|
|
-- Store the prefix
|
|
sharedPrefix = string.sub(text1, 1, prefixLength)
|
|
-- Now trim it off
|
|
text1 = string.sub(text1, prefixLength + 1)
|
|
text2 = string.sub(text2, prefixLength + 1)
|
|
end
|
|
|
|
local suffixLength = StringDiff._sharedSuffix(text1, text2)
|
|
if suffixLength > 0 then
|
|
-- Store the suffix
|
|
sharedSuffix = string.sub(text1, -suffixLength)
|
|
-- Now trim it off
|
|
text1 = string.sub(text1, 1, -suffixLength - 1)
|
|
text2 = string.sub(text2, 1, -suffixLength - 1)
|
|
end
|
|
|
|
-- Compute the diff on the middle block where the changes lie
|
|
local diffs = StringDiff._computeDiff(text1, text2)
|
|
|
|
-- Restore the prefix and suffix
|
|
if sharedPrefix then
|
|
table.insert(diffs, 1, { actionType = StringDiff.ActionTypes.Equal, value = sharedPrefix })
|
|
end
|
|
if sharedSuffix then
|
|
table.insert(diffs, { actionType = StringDiff.ActionTypes.Equal, value = sharedSuffix })
|
|
end
|
|
|
|
-- Cleanup the diff
|
|
diffs = StringDiff._reorderAndMerge(diffs)
|
|
|
|
return diffs
|
|
end
|
|
|
|
function StringDiff._sharedPrefix(text1: string, text2: string): number
|
|
-- Uses a binary search to find the largest common prefix between the two strings
|
|
-- Performance analysis: http://neil.fraser.name/news/2007/10/09/
|
|
|
|
-- Shortcut common cases
|
|
if (#text1 == 0) or (#text2 == 0) or (string.byte(text1, 1) ~= string.byte(text2, 1)) then
|
|
return 0
|
|
end
|
|
|
|
local pointerMin = 1
|
|
local pointerMax = math.min(#text1, #text2)
|
|
local pointerMid = pointerMax
|
|
local pointerStart = 1
|
|
while pointerMin < pointerMid do
|
|
if string.sub(text1, pointerStart, pointerMid) == string.sub(text2, pointerStart, pointerMid) then
|
|
pointerMin = pointerMid
|
|
pointerStart = pointerMin
|
|
else
|
|
pointerMax = pointerMid
|
|
end
|
|
pointerMid = math.floor(pointerMin + (pointerMax - pointerMin) / 2)
|
|
end
|
|
|
|
return pointerMid
|
|
end
|
|
|
|
function StringDiff._sharedSuffix(text1: string, text2: string): number
|
|
-- Uses a binary search to find the largest common suffix between the two strings
|
|
-- Performance analysis: http://neil.fraser.name/news/2007/10/09/
|
|
|
|
-- Shortcut common cases
|
|
if (#text1 == 0) or (#text2 == 0) or (string.byte(text1, -1) ~= string.byte(text2, -1)) then
|
|
return 0
|
|
end
|
|
|
|
local pointerMin = 1
|
|
local pointerMax = math.min(#text1, #text2)
|
|
local pointerMid = pointerMax
|
|
local pointerEnd = 1
|
|
while pointerMin < pointerMid do
|
|
if string.sub(text1, -pointerMid, -pointerEnd) == string.sub(text2, -pointerMid, -pointerEnd) then
|
|
pointerMin = pointerMid
|
|
pointerEnd = pointerMin
|
|
else
|
|
pointerMax = pointerMid
|
|
end
|
|
pointerMid = math.floor(pointerMin + (pointerMax - pointerMin) / 2)
|
|
end
|
|
|
|
return pointerMid
|
|
end
|
|
|
|
function StringDiff._computeDiff(text1: string, text2: string): Diffs
|
|
-- Assumes that the prefix and suffix have already been trimmed off
|
|
-- and shortcut returns have been made so these texts must be different
|
|
|
|
local text1Length, text2Length = #text1, #text2
|
|
|
|
if text1Length == 0 then
|
|
-- It's simply inserting all of text2 into text1
|
|
return { { actionType = StringDiff.ActionTypes.Insert, value = text2 } }
|
|
end
|
|
|
|
if text2Length == 0 then
|
|
-- It's simply deleting all of text1
|
|
return { { actionType = StringDiff.ActionTypes.Delete, value = text1 } }
|
|
end
|
|
|
|
local longText = if text1Length > text2Length then text1 else text2
|
|
local shortText = if text1Length > text2Length then text2 else text1
|
|
local shortTextLength = #shortText
|
|
|
|
-- Shortcut if the shorter string exists entirely inside the longer one
|
|
local indexOf = if shortTextLength == 0 then nil else string.find(longText, shortText, 1, true)
|
|
if indexOf ~= nil then
|
|
local diffs = {
|
|
{ actionType = StringDiff.ActionTypes.Insert, value = string.sub(longText, 1, indexOf - 1) },
|
|
{ actionType = StringDiff.ActionTypes.Equal, value = shortText },
|
|
{ actionType = StringDiff.ActionTypes.Insert, value = string.sub(longText, indexOf + shortTextLength) },
|
|
}
|
|
-- Swap insertions for deletions if diff is reversed
|
|
if text1Length > text2Length then
|
|
diffs[1].actionType, diffs[3].actionType = StringDiff.ActionTypes.Delete, StringDiff.ActionTypes.Delete
|
|
end
|
|
return diffs
|
|
end
|
|
|
|
if shortTextLength == 1 then
|
|
-- Single character string
|
|
-- After the previous shortcut, the character can't be an equality
|
|
return {
|
|
{ actionType = StringDiff.ActionTypes.Delete, value = text1 },
|
|
{ actionType = StringDiff.ActionTypes.Insert, value = text2 },
|
|
}
|
|
end
|
|
|
|
return StringDiff._bisect(text1, text2)
|
|
end
|
|
|
|
function StringDiff._bisect(text1: string, text2: string): Diffs
|
|
-- Find the 'middle snake' of a diff, split the problem in two
|
|
-- and return the recursively constructed diff
|
|
-- See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations
|
|
|
|
-- Cache the text lengths to prevent multiple calls
|
|
local text1Length = #text1
|
|
local text2Length = #text2
|
|
|
|
local _sub, _element
|
|
local maxD = math.ceil((text1Length + text2Length) / 2)
|
|
local vOffset = maxD
|
|
local vLength = 2 * maxD
|
|
local v1 = table.create(vLength)
|
|
local v2 = table.create(vLength)
|
|
|
|
-- Setting all elements to -1 is faster in Lua than mixing integers and nil
|
|
for x = 0, vLength - 1 do
|
|
v1[x] = -1
|
|
v2[x] = -1
|
|
end
|
|
v1[vOffset + 1] = 0
|
|
v2[vOffset + 1] = 0
|
|
local delta = text1Length - text2Length
|
|
|
|
-- If the total number of characters is odd, then
|
|
-- the front path will collide with the reverse path
|
|
local front = (delta % 2 ~= 0)
|
|
|
|
-- Offsets for start and end of k loop
|
|
-- Prevents mapping of space beyond the grid
|
|
local k1Start = 0
|
|
local k1End = 0
|
|
local k2Start = 0
|
|
local k2End = 0
|
|
for d = 0, maxD - 1 do
|
|
-- Walk the front path one step
|
|
for k1 = -d + k1Start, d - k1End, 2 do
|
|
local k1_offset = vOffset + k1
|
|
local x1
|
|
if (k1 == -d) or ((k1 ~= d) and (v1[k1_offset - 1] < v1[k1_offset + 1])) then
|
|
x1 = v1[k1_offset + 1]
|
|
else
|
|
x1 = v1[k1_offset - 1] + 1
|
|
end
|
|
local y1 = x1 - k1
|
|
while
|
|
(x1 <= text1Length)
|
|
and (y1 <= text2Length)
|
|
and (string.sub(text1, x1, x1) == string.sub(text2, y1, y1))
|
|
do
|
|
x1 = x1 + 1
|
|
y1 = y1 + 1
|
|
end
|
|
v1[k1_offset] = x1
|
|
if x1 > text1Length + 1 then
|
|
-- Ran off the right of the graph
|
|
k1End = k1End + 2
|
|
elseif y1 > text2Length + 1 then
|
|
-- Ran off the bottom of the graph
|
|
k1Start = k1Start + 2
|
|
elseif front then
|
|
local k2_offset = vOffset + delta - k1
|
|
if k2_offset >= 0 and k2_offset < vLength and v2[k2_offset] ~= -1 then
|
|
-- Mirror x2 onto top-left coordinate system
|
|
local x2 = text1Length - v2[k2_offset] + 1
|
|
if x1 > x2 then
|
|
-- Overlap detected
|
|
return StringDiff._bisectSplit(text1, text2, x1, y1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Walk the reverse path one step
|
|
for k2 = -d + k2Start, d - k2End, 2 do
|
|
local k2_offset = vOffset + k2
|
|
local x2
|
|
if (k2 == -d) or ((k2 ~= d) and (v2[k2_offset - 1] < v2[k2_offset + 1])) then
|
|
x2 = v2[k2_offset + 1]
|
|
else
|
|
x2 = v2[k2_offset - 1] + 1
|
|
end
|
|
local y2 = x2 - k2
|
|
while
|
|
(x2 <= text1Length)
|
|
and (y2 <= text2Length)
|
|
and (string.sub(text1, -x2, -x2) == string.sub(text2, -y2, -y2))
|
|
do
|
|
x2 = x2 + 1
|
|
y2 = y2 + 1
|
|
end
|
|
v2[k2_offset] = x2
|
|
if x2 > text1Length + 1 then
|
|
-- Ran off the left of the graph
|
|
k2End = k2End + 2
|
|
elseif y2 > text2Length + 1 then
|
|
-- Ran off the top of the graph
|
|
k2Start = k2Start + 2
|
|
elseif not front then
|
|
local k1_offset = vOffset + delta - k2
|
|
if k1_offset >= 0 and k1_offset < vLength and v1[k1_offset] ~= -1 then
|
|
local x1 = v1[k1_offset]
|
|
local y1 = vOffset + x1 - k1_offset
|
|
-- Mirror x2 onto top-left coordinate system
|
|
x2 = text1Length - x2 + 1
|
|
if x1 > x2 then
|
|
-- Overlap detected
|
|
return StringDiff._bisectSplit(text1, text2, x1, y1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Number of diffs equals number of characters, no commonality at all
|
|
return {
|
|
{ actionType = StringDiff.ActionTypes.Delete, value = text1 },
|
|
{ actionType = StringDiff.ActionTypes.Insert, value = text2 },
|
|
}
|
|
end
|
|
|
|
function StringDiff._bisectSplit(text1: string, text2: string, x: number, y: number): Diffs
|
|
-- Given the location of the 'middle snake',
|
|
-- split the diff in two parts and recurse
|
|
|
|
local text1a = string.sub(text1, 1, x - 1)
|
|
local text2a = string.sub(text2, 1, y - 1)
|
|
local text1b = string.sub(text1, x)
|
|
local text2b = string.sub(text2, y)
|
|
|
|
-- Compute both diffs serially
|
|
local diffs = StringDiff.findDiffs(text1a, text2a)
|
|
local diffsB = StringDiff.findDiffs(text1b, text2b)
|
|
|
|
-- Merge diffs
|
|
table.move(diffsB, 1, #diffsB, #diffs + 1, diffs)
|
|
return diffs
|
|
end
|
|
|
|
function StringDiff._reorderAndMerge(diffs: Diffs): Diffs
|
|
-- Reorder and merge like edit sections and merge equalities
|
|
-- Any edit section can move as long as it doesn't cross an equality
|
|
|
|
-- Add a dummy entry at the end
|
|
table.insert(diffs, { actionType = StringDiff.ActionTypes.Equal, value = "" })
|
|
|
|
local pointer = 1
|
|
local countDelete, countInsert = 0, 0
|
|
local textDelete, textInsert = "", ""
|
|
local commonLength
|
|
while diffs[pointer] do
|
|
local actionType = diffs[pointer].actionType
|
|
if actionType == StringDiff.ActionTypes.Insert then
|
|
countInsert = countInsert + 1
|
|
textInsert = textInsert .. diffs[pointer].value
|
|
pointer = pointer + 1
|
|
elseif actionType == StringDiff.ActionTypes.Delete then
|
|
countDelete = countDelete + 1
|
|
textDelete = textDelete .. diffs[pointer].value
|
|
pointer = pointer + 1
|
|
elseif actionType == StringDiff.ActionTypes.Equal then
|
|
-- Upon reaching an equality, check for prior redundancies
|
|
if countDelete + countInsert > 1 then
|
|
if (countDelete > 0) and (countInsert > 0) then
|
|
-- Factor out any common prefixies
|
|
commonLength = StringDiff._sharedPrefix(textInsert, textDelete)
|
|
if commonLength > 0 then
|
|
local back_pointer = pointer - countDelete - countInsert
|
|
if
|
|
(back_pointer > 1) and (diffs[back_pointer - 1].actionType == StringDiff.ActionTypes.Equal)
|
|
then
|
|
diffs[back_pointer - 1].value = diffs[back_pointer - 1].value
|
|
.. string.sub(textInsert, 1, commonLength)
|
|
else
|
|
table.insert(diffs, 1, {
|
|
actionType = StringDiff.ActionTypes.Equal,
|
|
value = string.sub(textInsert, 1, commonLength),
|
|
})
|
|
pointer = pointer + 1
|
|
end
|
|
textInsert = string.sub(textInsert, commonLength + 1)
|
|
textDelete = string.sub(textDelete, commonLength + 1)
|
|
end
|
|
-- Factor out any common suffixies
|
|
commonLength = StringDiff._sharedSuffix(textInsert, textDelete)
|
|
if commonLength ~= 0 then
|
|
diffs[pointer].value = string.sub(textInsert, -commonLength) .. diffs[pointer].value
|
|
textInsert = string.sub(textInsert, 1, -commonLength - 1)
|
|
textDelete = string.sub(textDelete, 1, -commonLength - 1)
|
|
end
|
|
end
|
|
-- Delete the offending records and add the merged ones
|
|
pointer = pointer - countDelete - countInsert
|
|
for _ = 1, countDelete + countInsert do
|
|
table.remove(diffs, pointer)
|
|
end
|
|
if #textDelete > 0 then
|
|
table.insert(diffs, pointer, { actionType = StringDiff.ActionTypes.Delete, value = textDelete })
|
|
pointer = pointer + 1
|
|
end
|
|
if #textInsert > 0 then
|
|
table.insert(diffs, pointer, { actionType = StringDiff.ActionTypes.Insert, value = textInsert })
|
|
pointer = pointer + 1
|
|
end
|
|
pointer = pointer + 1
|
|
elseif (pointer > 1) and (diffs[pointer - 1].actionType == StringDiff.ActionTypes.Equal) then
|
|
-- Merge this equality with the previous one
|
|
diffs[pointer - 1].value = diffs[pointer - 1].value .. diffs[pointer].value
|
|
table.remove(diffs, pointer)
|
|
else
|
|
pointer = pointer + 1
|
|
end
|
|
countInsert, countDelete = 0, 0
|
|
textDelete, textInsert = "", ""
|
|
end
|
|
end
|
|
if diffs[#diffs].value == "" then
|
|
-- Remove the dummy entry at the end
|
|
diffs[#diffs] = nil
|
|
end
|
|
|
|
-- Second pass: look for single edits surrounded on both sides by equalities
|
|
-- which can be shifted sideways to eliminate an equality
|
|
-- e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
|
|
local changes = false
|
|
pointer = 2
|
|
-- Intentionally ignore the first and last element (don't need checking)
|
|
while pointer < #diffs do
|
|
local prevDiff, nextDiff = diffs[pointer - 1], diffs[pointer + 1]
|
|
if
|
|
(prevDiff.actionType == StringDiff.ActionTypes.Equal)
|
|
and (nextDiff.actionType == StringDiff.ActionTypes.Equal)
|
|
then
|
|
-- This is a single edit surrounded by equalities
|
|
local currentDiff = diffs[pointer]
|
|
local currentText = currentDiff.value
|
|
local prevText = prevDiff.value
|
|
local nextText = nextDiff.value
|
|
if #prevText == 0 then
|
|
table.remove(diffs, pointer - 1)
|
|
changes = true
|
|
elseif string.sub(currentText, -#prevText) == prevText then
|
|
-- Shift the edit over the previous equality
|
|
currentDiff.value = prevText .. string.sub(currentText, 1, -#prevText - 1)
|
|
nextDiff.value = prevText .. nextDiff.value
|
|
table.remove(diffs, pointer - 1)
|
|
changes = true
|
|
elseif string.sub(currentText, 1, #nextText) == nextText then
|
|
-- Shift the edit over the next equality
|
|
prevDiff.value = prevText .. nextText
|
|
currentDiff.value = string.sub(currentText, #nextText + 1) .. nextText
|
|
table.remove(diffs, pointer + 1)
|
|
changes = true
|
|
end
|
|
end
|
|
pointer = pointer + 1
|
|
end
|
|
|
|
-- If shifts were made, the diffs need reordering and another shift sweep
|
|
if changes then
|
|
return StringDiff._reorderAndMerge(diffs)
|
|
end
|
|
|
|
return diffs
|
|
end
|
|
|
|
return StringDiff
|