Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

optimize just-diff path #541

Merged
merged 19 commits into from
Mar 12, 2023
Merged

optimize just-diff path #541

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
19 commits
Select commit Hold shift + click to select a range
9e658c3
WIP
angus-c Feb 11, 2023
3f6986d
wip-fix-tests
angus-c Feb 11, 2023
9d0a3e0
basically working
angus-c Feb 12, 2023
b0d8614
need to lock indexes that don't change
angus-c Feb 12, 2023
f03bb80
new tests and all passing
angus-c Feb 12, 2023
3839674
some refactor
angus-c Feb 12, 2023
92896e4
need to call pushReplaces for new permutation
angus-c Feb 12, 2023
76415eb
optimziation test section
angus-c Feb 12, 2023
54a842c
more tests'
angus-c Feb 13, 2023
4f27a57
Left and right trim original array to optimize diffs length
angus-c Feb 13, 2023
028effb
nested left trim test not working
angus-c Feb 13, 2023
0c1ae11
issue is not all permutations are based on root
angus-c Mar 11, 2023
7d6f661
working?
angus-c Mar 11, 2023
69dc9a7
working
angus-c Mar 11, 2023
ba8a6fb
working needs cleanup
angus-c Mar 11, 2023
de35f6f
need to add more round trip tests
angus-c Mar 11, 2023
6f3cc96
more round trip tests wip
angus-c Mar 12, 2023
60d671b
DONE
angus-c Mar 12, 2023
7fd518c
mjs version
angus-c Mar 12, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
157 changes: 118 additions & 39 deletions packages/collection-diff/index.cjs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -79,18 +79,32 @@ function diff(obj1, obj2, pathConverter) {
return arr;
});

function getDiff(obj1, obj2, basePath, diffs) {
// we will gather all permutations and return the one with the fewest diffs
var permutations = [{remove: [], replace: [], add: []}];

function getDiff({obj1, obj2, basePath, basePathForRemoves, permutation}) {
var obj1Keys = Object.keys(obj1);
var obj1KeysLength = obj1Keys.length;
var obj2Keys = Object.keys(obj2);
var obj2KeysLength = obj2Keys.length;
var path;

var newPermutation;

var lengthDelta = obj1.length - obj2.length;
// if both objects are arrays and obj1 length > obj2 length
// we create an additional permutation that trims obj1 from left
if (Array.isArray(obj1) && Array.isArray(obj2) && lengthDelta > 0) {
newPermutation = clonePermutation(permutation);
permutations.push(newPermutation);
}

// trim from right
for (var i = 0; i < obj1KeysLength; i++) {
var key = Array.isArray(obj1) ? Number(obj1Keys[i]) : obj1Keys[i];
if (!(key in obj2)) {
path = basePath.concat(key);
diffs.remove.push({
path = basePathForRemoves.concat(key);
permutation.remove.push({
op: 'remove',
path: pathConverter(path),
});
Expand All @@ -99,55 +113,120 @@ function diff(obj1, obj2, pathConverter) {

for (var i = 0; i < obj2KeysLength; i++) {
var key = Array.isArray(obj2) ? Number(obj2Keys[i]) : obj2Keys[i];
var obj1AtKey = obj1[key];
var obj2AtKey = obj2[key];
if (!(key in obj1)) {
path = basePath.concat(key);
var obj2Value = obj2[key];
diffs.add.push({
op: 'add',
pushReplaces({
key,
obj1,
obj2,
path: basePath.concat(key),
pathForRemoves: basePath.concat(key),
permutation,
});
}

// if we created a new permutation above it means we should also try trimming from left
if (newPermutation) {
for (var i = 0; i < lengthDelta; i++) {
path = basePathForRemoves.concat(i);
newPermutation.remove.push({
op: 'remove',
path: pathConverter(path),
value: obj2Value,
});
} else if (obj1AtKey !== obj2AtKey) {
if (
Object(obj1AtKey) !== obj1AtKey ||
Object(obj2AtKey) !== obj2AtKey
) {
path = pushReplace(path, basePath, key, diffs, pathConverter, obj2);
} else {
if (
!Object.keys(obj1AtKey).length &&
!Object.keys(obj2AtKey).length &&
String(obj1AtKey) != String(obj2AtKey)
) {
path = pushReplace(path, basePath, key, diffs, pathConverter, obj2);
} else {
getDiff(obj1[key], obj2[key], basePath.concat(key), diffs);
}
}
}
}

return diffs;
// now make a copy of obj1 with excess elements left trimmed and see if there any replaces
var obj1Trimmed = obj1.slice(lengthDelta);;
for (var i = 0; i < obj2KeysLength; i++) {
pushReplaces({
key: i,
obj1: obj1Trimmed,
obj2,
path: basePath.concat(i),
// since list of removes are reversed before presenting result,
// we need to ignore existing parent removes when doing nested removes
pathForRemoves: basePath.concat(i + lengthDelta),
permutation: newPermutation,
});
}
}
}
const finalDiffs = getDiff(obj1, obj2, [], {remove: [], replace: [], add: []});

getDiff({
obj1,
obj2,
basePath: [],
basePathForRemoves: [],
permutation: permutations[0],
});

// find the shortest permutation
var finalDiffs = permutations.sort(
(a, b) => diffStepCount(a) > diffStepCount(b) ? 1 : -1
)[0];

// reverse removes since we want to maintain indexes
return finalDiffs.remove
.reverse()
.concat(finalDiffs.replace)
.concat(finalDiffs.add);

function pushReplaces({key, obj1, obj2, path, pathForRemoves, permutation}) {
var obj1AtKey = obj1[key];
var obj2AtKey = obj2[key];

if(!(key in obj1) && obj2AtKey) {
var obj2Value = obj2AtKey;
permutation.add.push({
op: 'add',
path: pathConverter(path),
value: obj2Value,
});
} else if(obj1AtKey !== obj2AtKey) {
if(Object(obj1AtKey) !== obj1AtKey ||
Object(obj2AtKey) !== obj2AtKey || differentTypes(obj1AtKey, obj2AtKey)
) {
pushReplace(path, permutation, obj2AtKey);
} else {
if(!Object.keys(obj1AtKey).length &&
!Object.keys(obj2AtKey).length &&
String(obj1AtKey) != String(obj2AtKey)) {
pushReplace(path, permutation, obj2AtKey);
} else {
getDiff({
obj1: obj1[key],
obj2: obj2[key],
basePath: path,
basePathForRemoves: pathForRemoves,
permutation});
}
}
}
}

function pushReplace(path, diffs, newValue) {
diffs.replace.push({
op: 'replace',
path: pathConverter(path),
value: newValue,
});
}
}

function pushReplace(path, basePath, key, diffs, pathConverter, obj2) {
path = basePath.concat(key);
diffs.replace.push({
op: 'replace',
path: pathConverter(path),
value: obj2[key],
});
return path;
function clonePermutation(permutation) {
return {
remove: permutation.remove.slice(0),
replace: permutation.replace.slice(0),
add: permutation.add.slice(0),
};
}

function diffStepCount(permutation) {
return permutation.remove.length + permutation.replace.length + permutation.add.length;
}

function jsonPatchPathConverter(arrayPath) {
return [''].concat(arrayPath).join('/');
}

function differentTypes(a, b) {
return Object.prototype.toString.call(a) != Object.prototype.toString.call(b);
}
156 changes: 117 additions & 39 deletions packages/collection-diff/index.mjs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -74,18 +74,32 @@ function diff(obj1, obj2, pathConverter) {
return arr;
});

function getDiff(obj1, obj2, basePath, diffs) {
// we will gather all permutations and return the one with the fewest diffs
var permutations = [{remove: [], replace: [], add: []}];

function getDiff({obj1, obj2, basePath, basePathForRemoves, permutation}) {
var obj1Keys = Object.keys(obj1);
var obj1KeysLength = obj1Keys.length;
var obj2Keys = Object.keys(obj2);
var obj2KeysLength = obj2Keys.length;
var path;

var newPermutation;

var lengthDelta = obj1.length - obj2.length;
// if both objects are arrays and obj1 length > obj2 length
// we create an additional permutation that trims obj1 from left
if (Array.isArray(obj1) && Array.isArray(obj2) && lengthDelta > 0) {
newPermutation = clonePermutation(permutation);
permutations.push(newPermutation);
}

// trim from right
for (var i = 0; i < obj1KeysLength; i++) {
var key = Array.isArray(obj1) ? Number(obj1Keys[i]) : obj1Keys[i];
if (!(key in obj2)) {
path = basePath.concat(key);
diffs.remove.push({
path = basePathForRemoves.concat(key);
permutation.remove.push({
op: 'remove',
path: pathConverter(path),
});
Expand All @@ -94,57 +108,121 @@ function diff(obj1, obj2, pathConverter) {

for (var i = 0; i < obj2KeysLength; i++) {
var key = Array.isArray(obj2) ? Number(obj2Keys[i]) : obj2Keys[i];
var obj1AtKey = obj1[key];
var obj2AtKey = obj2[key];
if (!(key in obj1)) {
path = basePath.concat(key);
var obj2Value = obj2[key];
diffs.add.push({
op: 'add',
pushReplaces({
key,
obj1,
obj2,
path: basePath.concat(key),
pathForRemoves: basePath.concat(key),
permutation,
});
}

// if we created a new permutation above it means we should also try trimming from left
if (newPermutation) {
for (var i = 0; i < lengthDelta; i++) {
path = basePathForRemoves.concat(i);
newPermutation.remove.push({
op: 'remove',
path: pathConverter(path),
value: obj2Value,
});
} else if (obj1AtKey !== obj2AtKey) {
if (
Object(obj1AtKey) !== obj1AtKey ||
Object(obj2AtKey) !== obj2AtKey
) {
path = pushReplace(path, basePath, key, diffs, pathConverter, obj2);
} else {
if (
!Object.keys(obj1AtKey).length &&
!Object.keys(obj2AtKey).length &&
String(obj1AtKey) != String(obj2AtKey)
) {
path = pushReplace(path, basePath, key, diffs, pathConverter, obj2);
} else {
getDiff(obj1[key], obj2[key], basePath.concat(key), diffs);
}
}
}
}

return diffs;
// now make a copy of obj1 with excess elements left trimmed and see if there any replaces
var obj1Trimmed = obj1.slice(lengthDelta); for (var i = 0; i < obj2KeysLength; i++) {
pushReplaces({
key: i,
obj1: obj1Trimmed,
obj2,
path: basePath.concat(i),
// since list of removes are reversed before presenting result,
// we need to ignore existing parent removes when doing nested removes
pathForRemoves: basePath.concat(i + lengthDelta),
permutation: newPermutation,
});
}
}
}
const finalDiffs = getDiff(obj1, obj2, [], {remove: [], replace: [], add: []});

getDiff({
obj1,
obj2,
basePath: [],
basePathForRemoves: [],
permutation: permutations[0],
});

// find the shortest permutation
var finalDiffs = permutations.sort(
(a, b) => diffStepCount(a) > diffStepCount(b) ? 1 : -1
)[0];

// reverse removes since we want to maintain indexes
return finalDiffs.remove
.reverse()
.concat(finalDiffs.replace)
.concat(finalDiffs.add);

function pushReplaces({key, obj1, obj2, path, pathForRemoves, permutation}) {
var obj1AtKey = obj1[key];
var obj2AtKey = obj2[key];

if(!(key in obj1) && obj2AtKey) {
var obj2Value = obj2AtKey;
permutation.add.push({
op: 'add',
path: pathConverter(path),
value: obj2Value,
});
} else if(obj1AtKey !== obj2AtKey) {
if(Object(obj1AtKey) !== obj1AtKey ||
Object(obj2AtKey) !== obj2AtKey || differentTypes(obj1AtKey, obj2AtKey)
) {
pushReplace(path, permutation, obj2AtKey);
} else {
if(!Object.keys(obj1AtKey).length &&
!Object.keys(obj2AtKey).length &&
String(obj1AtKey) != String(obj2AtKey)) {
pushReplace(path, permutation, obj2AtKey);
} else {
getDiff({
obj1: obj1[key],
obj2: obj2[key],
basePath: path,
basePathForRemoves: pathForRemoves,
permutation});
}
}
}
}

function pushReplace(path, diffs, newValue) {
diffs.replace.push({
op: 'replace',
path: pathConverter(path),
value: newValue,
});
}
}

function pushReplace(path, basePath, key, diffs, pathConverter, obj2) {
path = basePath.concat(key);
diffs.replace.push({
op: 'replace',
path: pathConverter(path),
value: obj2[key],
});
return path;
function clonePermutation(permutation) {
return {
remove: permutation.remove.slice(0),
replace: permutation.replace.slice(0),
add: permutation.add.slice(0),
};
}

function diffStepCount(permutation) {
return permutation.remove.length + permutation.replace.length + permutation.add.length;
}

function jsonPatchPathConverter(arrayPath) {
return [''].concat(arrayPath).join('/');
}

function differentTypes(a, b) {
return Object.prototype.toString.call(a) != Object.prototype.toString.call(b);
}

export {diff, jsonPatchPathConverter};
Loading