Merge pull request #10 from blackflux/dev

[Gally]: master <- dev

README.md

@@ -15,6 +15,8 @@
 
 ## Functions
 
+For more extensive examples, please refer to the tests.
+
 ### align(obj: Object, ref: Object)
 
 Align the ordering of one object recursively to a reference object.
@@ -33,6 +35,18 @@ align(obj, ref);
 
 ### contain(tree: Object, subtree: Object)
 
+Check if `subtree` is contained in `tree` recursively.
+
+Different types are never considered _contained_.
+
+Arrays are _contained_ iff they are the same length and every
+element is _contained_ in the corresponding element.
+
+Objects are _contained_ if the keys are a subset,
+and the respective values are _contained_.
+
+All other types are contained if they match exactly (`===`).
+
 _Example:_
 <!-- eslint-disable import/no-unresolved -->
 ```js
@@ -44,3 +58,29 @@ contain({ a: [1, 2], b: 'c' }, { a: [1, 2] });
 contain({ a: [1, 2], b: 'c' }, { a: [1] });
 // => false
 ```
+
+### Merge(logic: Object = {})(...obj: Object[])
+
+Allows merging of objects. The logic defines paths that map to a field, or a function, to merge by.
+
+If a function is passed, it is invoked with the value, and the result is used as the merge identifier.
+
+The paths are defined using [object-scan](https://github.com/blackflux/object-scan) syntax.
+
+_Example:_
+<!-- eslint-disable import/no-unresolved -->
+```js
+const { Merge } = require('object-lig');
+
+Merge()(
+  { children: [{ id: 1 }, { id: 2 }] },
+  { children: [{ id: 2 }, { id: 3 }] }
+);
+// => { children: [ { id: 1 }, { id: 2 }, { id: 2 }, { id: 3 } ] }
+
+Merge({ '**[*]': 'id' })(
+  { children: [{ id: 1 }, { id: 2 }] },
+  { children: [{ id: 2 }, { id: 3 }] }
+);
+// => { children: [ { id: 1 }, { id: 2 }, { id: 3 } ] }
+```

package.json

@@ -25,6 +25,7 @@
     "eslint-plugin-markdown": "1.0.2",
     "eslint-plugin-mocha": "8.0.0",
     "js-gardener": "2.0.184",
+    "node-tdd": "2.19.1",
     "nyc": "15.1.0",
     "semantic-release": "17.3.7"
   },
@@ -105,5 +106,8 @@
   },
   "engines": {
     "node": ">= 10"
+  },
+  "dependencies": {
+    "object-scan": "13.8.0"
   }
 }

src/core/merge.js

@@ -0,0 +1,67 @@
+const objectScan = require('object-scan');
+
+module.exports = (logic_ = {}) => {
+  const logic = { '**': null, ...logic_ };
+  const last = (arr) => arr[arr.length - 1];
+  const mkChild = (ref) => {
+    if (!(ref instanceof Object)) {
+      return ref;
+    }
+    return Array.isArray(ref) ? [] : {};
+  };
+  const populate = (obj, key, fn, force = false) => {
+    if (force === true || !(key in obj)) {
+      // eslint-disable-next-line no-param-reassign
+      obj[key] = fn();
+      return true;
+    }
+    return false;
+  };
+
+  const scanner = objectScan(Object.keys(logic), {
+    reverse: false,
+    breakFn: ({
+      isMatch, property, value, matchedBy, context
+    }) => {
+      if (!isMatch) return;
+      const { stack, groups, path } = context;
+      const current = last(stack);
+      const bestNeedle = last(matchedBy);
+      const groupBy = typeof logic[bestNeedle] === 'function'
+        ? logic[bestNeedle](value)
+        : logic[bestNeedle];
+
+      if (!Array.isArray(current) || groupBy === null) {
+        if (Array.isArray(current)) {
+          current.push(mkChild(value));
+          stack.push(last(current));
+        } else {
+          populate(current, property, () => mkChild(value), !(value instanceof Object));
+          stack.push(current[property]);
+        }
+      } else {
+        const groupId = `${bestNeedle}.${groupBy}: ${path.join('.')}`;
+        populate(groups, groupId, () => ({}));
+        const groupEntryId = value[groupBy];
+        if (populate(groups[groupId], groupEntryId, () => mkChild(value))) {
+          current.push(groups[groupId][groupEntryId]);
+        }
+        path.push(`${groupBy}=${groupEntryId}`);
+        stack.push(groups[groupId][groupEntryId]);
+      }
+    },
+    filterFn: ({ matchedBy, context }) => {
+      const { stack, path } = context;
+      stack.pop();
+      if (logic[last(matchedBy)] !== null) {
+        path.pop();
+      }
+    }
+  });
+  return (...args) => {
+    const result = mkChild(args[0]);
+    const groups = {};
+    args.forEach((arg) => scanner(arg, { stack: [result], groups, path: [] }));
+    return result;
+  };
+};

src/index.js

@@ -1,7 +1,9 @@
 const align = require('./core/align');
 const contain = require('./core/contain');
+const Merge = require('./core/merge');
 
 module.exports = {
   align,
-  contain
+  contain,
+  Merge
 };

test/core/merge.spec.js

@@ -0,0 +1,39 @@
+const expect = require('chai').expect;
+const { describe } = require('node-tdd');
+const Merge = require('../../src/core/merge');
+
+describe('Testing Merge', () => {
+  it('Testing SO question: https://stackoverflow.com/questions/65822248', ({ fixture }) => {
+    const json1 = fixture('json1');
+    const json2 = fixture('json2');
+    const merge = Merge({
+      '[*]': 'id',
+      '[*].addresses[*]': 'type'
+    });
+    expect(merge(json1, json2)).to.deep.equal(fixture('result'));
+  });
+
+  it('Testing array concat', () => {
+    const d1 = [{ a: 1 }];
+    const d2 = [{ a: 2 }];
+    expect(Merge()(d1, d2)).to.deep.equal([{ a: 1 }, { a: 2 }]);
+  });
+
+  it('Testing array merge', () => {
+    const d1 = [{ a: 1, b: 1, c: 3 }];
+    const d2 = [{ a: 1, b: 2, d: 4 }];
+    expect(Merge({ '[*]': 'a' })(d1, d2)).to.deep.equal([{ ...d1[0], ...d2[0] }]);
+  });
+
+  it('Testing merge by sum', () => {
+    const d1 = [[1, 2, 3], [2, 4], [1, 2]];
+    const d2 = [[3, 3], [1, 5], [3, 2]];
+    expect(Merge({
+      '[*]': (o) => o.reduce((a, b) => a + b, 0)
+    })(d1, d2)).to.deep.equal([
+      [1, 2, 3, 2, 4, 3, 3, 1, 5],
+      [1, 2],
+      [3, 2]
+    ]);
+  });
+});

test/core/merge.spec.js__fixtures/json1.json

@@ -0,0 +1,30 @@
+[
+  {
+    "id": 1,
+    "name": "aaa",
+    "addresses": [
+      {
+        "type": "office",
+        "city": "office city"
+      },
+      {
+        "type": "home1",
+        "city": "home1 city"
+      }
+    ]
+  },
+  {
+    "id": 2,
+    "name": "bbb",
+    "addresses": [
+      {
+        "type": "office",
+        "city": "office city"
+      },
+      {
+        "type": "home1",
+        "city": "home1 city"
+      }
+    ]
+  }
+]

test/core/merge.spec.js__fixtures/json2.json

@@ -0,0 +1,30 @@
+[
+  {
+    "id": 1,
+    "name": "aaa1",
+    "addresses": [
+      {
+        "type": "home1",
+        "city": "home1 new city"
+      },
+      {
+        "type": "home2",
+        "city": "home2 city"
+      }
+    ]
+  },
+  {
+    "id": 3,
+    "name": "ccc",
+    "addresses": [
+      {
+        "type": "home1",
+        "city": "home1 city"
+      },
+      {
+        "type": "home2",
+        "city": "home2 city"
+      }
+    ]
+  }
+]

test/core/merge.spec.js__fixtures/result.json

@@ -0,0 +1,48 @@
+[
+  {
+    "id": 1,
+    "name": "aaa1",
+    "addresses": [
+      {
+        "type": "office",
+        "city": "office city"
+      },
+      {
+        "type": "home1",
+        "city": "home1 new city"
+      },
+      {
+        "type": "home2",
+        "city": "home2 city"
+      }
+    ]
+  },
+  {
+    "id": 2,
+    "name": "bbb",
+    "addresses": [
+      {
+        "type": "office",
+        "city": "office city"
+      },
+      {
+        "type": "home1",
+        "city": "home1 city"
+      }
+    ]
+  },
+  {
+    "id": 3,
+    "name": "ccc",
+    "addresses": [
+      {
+        "type": "home1",
+        "city": "home1 city"
+      },
+      {
+        "type": "home2",
+        "city": "home2 city"
+      }
+    ]
+  }
+]

test/index.spec.js

@@ -5,7 +5,8 @@ describe('Testing index.js', () => {
   it('Testing exported', () => {
     expect(Object.keys(index)).to.deep.equal([
       'align',
-      'contain'
+      'contain',
+      'Merge'
     ]);
   });
 });