@natlibfi/marc-record-merge 6.0.0-beta.1 → 6.0.0-beta.11

package/package.json

@@ -13,46 +13,50 @@
 		"type": "git",
 		"url": "git@github.com:natlibfi/marc-record-merge-js.git"
 	},
-	"license": "LGPL-3.0+",
-	"version": "6.0.0-beta.1",
+	"license": "MIT",
+	"version": "6.0.0-beta.11",
 	"main": "./dist/index.js",
 	"engines": {
-		"node": ">=12"
+		"node": ">=14"
 	},
+	"type": "commonjs",
 	"scripts": {
+		"prepare": "npm run build",
 		"prepublishOnly": "npm run build:transpile",
-		"check-deps": "npm-check;exit 0",
 		"lint": "eslint ./src",
 		"lint:dev": "eslint ./src --fix",
-		"test:base": "cross-env NODE_ENV=test nyc mocha --require @babel/register",
-		"test": "npm run lint && npm run test:base -- src/**/*.spec.js",
-		"test:dev": "npm run lint:dev && npm run test:base -- src/**/*.spec.js && npm run coverage",
-		"coverage": "nyc check-coverage --per-file",
+		"test:base": "cross-env NODE_ENV=test mocha --require @babel/register --reporter-option maxDiffSize=15000",
+		"test": "npm run lint && npm run test:base -- --recursive src",
+		"test:dev": "npm run lint:dev && npm run coverage",
+		"coverage": "npm run coverage:unit && npm run coverage:report",
+		"coverage:unit": "nyc --silent npm run test:base",
+		"coverage:report": "nyc report",
 		"build:transpile": "babel src --copy-files --source-maps --delete-dir-on-start --out-dir=dist",
-		"build": "npm run build:transpile && npm run check-deps",
-		"watch:test": "cross-env DEBUG=1 NODE_ENV=test nodemon -w src -w test-fixtures --exec 'npm run test:dev'"
+		"build": "npm run build:transpile",
+		"dev:test": "cross-env NODE_ENV=test nodemon -w src -w test-fixtures --exec 'clear && npm run test:dev'",
+		"dev:test:debug": "cross-env DEBUG=@natlibfi/* NODE_ENV=test nodemon -w src -w test-fixtures --exec 'clear && npm run test:dev'"
 	},
 	"dependencies": {
-		"@natlibfi/fixura": "^2.0.0",
-		"@natlibfi/marc-record": "^6.0.0",
-		"debug": "^4.1.1",
-		"normalize-diacritics": "^2.11.1"
+		"@natlibfi/fixugen": "1.1.0",
+		"@natlibfi/fixura": "^2.2.5",
+		"@natlibfi/marc-record": "^7.2.2",
+		"debug": "^4.3.4",
+		"normalize-diacritics": "2.14.0"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.10.1",
-		"@babel/core": "^7.10.2",
-		"@babel/preset-env": "^7.10.2",
-		"@babel/register": "^7.10.1",
-		"@natlibfi/eslint-config-melinda-backend": "^1.0.3",
-		"babel-eslint": "^10.0.3",
-		"babel-plugin-istanbul": "^6.0.0",
+		"@babel/cli": "^7.19.3",
+		"@babel/core": "^7.19.6",
+		"@babel/eslint-parser": "^7.19.1",
+		"@babel/preset-env": "^7.19.4",
+		"@babel/register": "^7.18.9",
+		"@natlibfi/eslint-config-melinda-backend": "^2.0.1",
+		"babel-plugin-istanbul": "^6.1.1",
 		"babel-plugin-rewire": "^1.2.0",
-		"chai": "^4.2.0",
-		"cross-env": "^7.0.2",
-		"eslint": "^7.1.0",
-		"mocha": "^7.2.0",
-		"nodemon": "^2.0.4",
-		"npm-check": "^5.9.0",
+		"chai": "^4.3.6",
+		"cross-env": "^7.0.3",
+		"eslint": "^8.25.0",
+		"mocha": "^10.1.0",
+		"nodemon": "^2.0.20",
 		"nyc": "^15.1.0"
 	},
 	"eslintConfig": {
@@ -65,9 +69,7 @@
 			[
 				"@babel/preset-env",
 				{
-					"targets": {
-						"node": "12"
-					}
+					"targets": "maintained node versions"
 				}
 			]
 		],
@@ -86,8 +88,7 @@
 			"*/**/*.spec.js"
 		],
 		"reporter": [
-			"lcov",
-			"html"
+			"text"
 		],
 		"require": [
 			"@babel/register"

package/src/index.js

@@ -1,36 +1,54 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Merge MARC records
-*
-* Copyright (C) 2015-2019 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of marc-record-merge-js
-
-* marc-record-merge-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* marc-record-merge-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
-
-import * as Reducers from './reducers';
-import {MarcRecord} from '@natlibfi/marc-record';
+import Reducers from './reducers';
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge:index');
+const debugData = debug.extend('data');
 
 export {Reducers};
+// export default ({base, source, reducers}) => reducers.reduce((base, reducer) => reducer(base, source), base);
+
+// NV: Modified the reducer loop so, that not only base, but also is carried back.
+// However, we try to be backward-compatible: normally after the reducers, only base is returned.
+
 export default ({base, source, reducers}) => {
-  const sourceRecord = MarcRecord.clone(source);
-  return reducers.reduce((baseRecord, reducer) => reducer(baseRecord, sourceRecord), MarcRecord.clone(base));
+
+  const combo = {base, source};
+  const resultCombo = reducers.reduce((combo, reducer) => {
+    const returnCombo = singleRound(reducer, combo.base, combo.source);
+    //debugData(`returnCombo after current reducer: ${JSON.stringify(returnCombo)}`);
+    return returnCombo;
+  }, combo);
+
+  debugData(`ResultCombo after reducers: ${JSON.stringify(resultCombo)}`);
+
+  // Hack to make my melinda-marc-record-merge-reducers single tests that expect both
+  // base and source to return them both:
+  if (reducers.length === 1 && resultCombo.base && resultCombo.source) {
+    debug('Single reducer, returning resultCombo');
+    debugData(JSON.stringify(resultCombo));
+
+    return resultCombo;
+  }
+  // All other tests return just base... Backward (compability) it is!
+  debug('Multiple reducers, returning just base');
+  debugData(JSON.stringify(resultCombo.base));
+  return resultCombo.base;
+
+  function singleRound(reducer, base, source) {
+    //debug(`SINGLE ROUND INPUT (base, source)`);
+    //debugData(base);
+    //debugData(base);
+    const reducerResult = reducer(base, source);
+    //debug(`reducerResult:`);
+    //debugData(reducerResult);
+    if (reducerResult.base !== undefined && reducerResult.source !== undefined) {
+      debug('NEW STYLE REDUCER RESULT v2');
+      const combo = reducerResult;
+      //debugData(combo);
+      return combo;
+    }
+    debug('OLD SCHOOL REDUCER RESULT v2');
+    //debugData({base: reducerResult, source});
+    return {base: reducerResult, source};
+  }
 };

package/src/index.spec.js

@@ -0,0 +1,45 @@
+import merger, {Reducers} from './index';
+import {inspect} from 'util';
+import createDebugLogger from 'debug';
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'index'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: false,
+    reader: READERS.JSON
+  }
+});
+
+function callback({getFixture, reducerConfigs = []}) {
+  const base = new MarcRecord(getFixture('base.json'), {subfieldValues: false});
+  const source = new MarcRecord(getFixture('source.json'), {subfieldValues: false});
+  const expectedRecord = getFixture('merged.json');
+
+  const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:index:test');
+  const debugData = debug.extend('data');
+
+  const testReducerConfigs = reducerConfigs;
+  const reducers = [...testReducerConfigs.map(conf => Reducers.copy(conf))];
+
+  debugData(`Reducers: ${inspect(reducers, {colors: true, maxArrayLength: 10, depth: 8})})}`);
+
+  const result = merger({base, source, reducers});
+
+  debug(`Merge result is: ${result.constructor.name}`);
+  debugData(`${JSON.stringify(result)}`);
+
+  // Use either result.base or a plain result as resultRecord
+  // It can also be a MarcRecord or a plain object
+  const resultRecord = result.base || result;
+  const resultRecordToRecord = new MarcRecord(resultRecord, {subfieldValues: false});
+  expect(resultRecordToRecord.toObject()).to.eql(expectedRecord);
+
+
+}

package/src/reducers/copy.js

@@ -1,88 +1,270 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Merge MARC records
-*
-* Copyright (C) 2015-2019 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of marc-record-merge-js
-
-* marc-record-merge-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* marc-record-merge-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
-// Import createDebugLogger from 'debug';
-
-export default (pattern) => (base, source) => {
-//  Const debug = createDebugLogger('@natlibfi/marc-record-merge');
-  const baseFields = base.get(pattern);
-  const sourceFields = source.get(pattern);
-  return copyFields();
-
-  function copyFields() {
-    // Test 01: If base does not contain the field at all, it is copied from source to base
-    if (baseFields.length === 0) {
-      sourceFields.forEach(f => base.insertField(f));
-      return base;
-    }
-    const filterMissing = function(sourceField) {
-      // Test 02: Identical control fields are not copied
-      if ('value' in sourceField) {
-        return baseFields.some(isIdenticalControlField) === false;
-      }
-      // Test 04: Identical data fields in base and source, not copied
-      // Test 05: Different data fields are copied from source to base
-      if ('subfields' in sourceField) {
-        return baseFields.some(isIdenticalDataField) === false;
-      }
+/* eslint-disable max-statements */
+/* eslint-disable no-unused-vars */
 
-      function normalizeControlField(field) {
-        return field.value.toLowerCase().replace(/\s+/u, '');
-      }
+import {MarcRecord} from '@natlibfi/marc-record';
+import createDebugLogger from 'debug';
 
-      function isIdenticalControlField(baseField) {
-        const normalizedBaseField = normalizeControlField(baseField);
-        const normalizedSourceField = normalizeControlField(sourceField);
-        return normalizedSourceField === normalizedBaseField;
-      }
-      function isIdenticalDataField(baseField) {
-        if (sourceField.tag === baseField.tag &&
-          sourceField.ind1 === baseField.ind1 &&
-          sourceField.ind2 === baseField.ind2 &&
-          sourceField.subfields.length === baseField.subfields.length) {
-          return baseField.subfields.every(isIdenticalSubfield);
+export default ({
+  tagPattern,
+  compareTagsOnly = false,
+  compareWithoutTag = false,
+  compareWithoutIndicators = false,
+  compareWithoutIndicator1 = false,
+  compareWithoutIndicator2 = false,
+  subfieldsMustBeIdentical = true,
+  excludeSubfields = [],
+  dropSubfields = [],
+  copyUnless = [],
+  baseValidators = {subfieldValues: false},
+  sourceValidators = {subfieldValues: false},
+  swapTag = [],
+  swapSubfieldCode = [],
+  doNotCopyIfFieldPresent = false
+}) => (base, source) => {
+
+  const debug = createDebugLogger('@natlibfi/marc-record-merge:copy');
+  const debugData = debug.extend('data');
+  const debugOptions = createDebugLogger('@natlibfi/marc-record-merge:compare-options');
+  const debugCompare = createDebugLogger('@natlibfi/marc-record-merge:compare');
+
+  debugData(`base: ${JSON.stringify(base)}`);
+  debugData(`source: ${JSON.stringify(source)}`);
+
+  const {baseRecord, sourceRecord} = getRecordsFromParameters(base, source, baseValidators, sourceValidators);
+
+  function getRecordsFromParameters(base, source, baseValidators, sourceValidators) {
+    // records if we got an object ({base, source}) as a parameter
+    if (source === undefined && base.base !== undefined && base.source !== undefined) {
+      const baseRecord = new MarcRecord(base.base, baseValidators);
+      const sourceRecord = new MarcRecord(base.source, sourceValidators);
+      return {baseRecord, sourceRecord};
+    }
+    // records if we got an non-object (base, source) as a parameter
+    const baseRecord = new MarcRecord(base, baseValidators);
+    const sourceRecord = new MarcRecord(source, sourceValidators);
+    return {baseRecord, sourceRecord};
+  }
+
+  const ignoreInd1 = compareWithoutIndicators || compareWithoutIndicator1;
+  const ignoreInd2 = compareWithoutIndicators || compareWithoutIndicator2;
+
+  debugOptions(`Tag Pattern: ${tagPattern}`);
+  debugOptions(`Compare tags only: ${compareTagsOnly}`);
+  debugOptions(`Omit indicator 1 from comparison: ${ignoreInd1}`);
+  debugOptions(`Omit indicator 2 from comparison: ${ignoreInd2}`);
+  debugOptions(`Copy if identical: ${subfieldsMustBeIdentical}`);
+  debugOptions(`Exclude subfields: [${excludeSubfields}]`);
+  debugOptions(`Drop subfields [${dropSubfields}]`);
+  debugOptions(`Copy unless contains subfields: ${JSON.stringify(copyUnless)}`);
+
+  const baseFields = baseRecord.get(tagPattern);
+  const sourceFields = sourceRecord.get(tagPattern);
+  const doNotCopy = doNotCopyIfFieldPresent ? baseRecord.get(doNotCopyIfFieldPresent).length > 0 : false;
+
+  if (doNotCopy) {
+    return baseRecord.toObject();
+  }
+  debug(`FFS: ${compareWithoutIndicator1}, ${compareWithoutIndicators}, ${ignoreInd1}`);
+  debug(`Base fields: `, baseFields);
+  debug(`Source fields: `, sourceFields);
+
+  // Logic steps
+  const baseCompareFields = baseFields.map(baseField => createCompareField(baseField));
+  const compareResultFields = compareFields(sourceFields, baseCompareFields);
+  const droppedUnwantedSubfield = checkDropSubfields(compareResultFields);
+  const droppedUnwantedFields = checkCopyUnlessFields(droppedUnwantedSubfield);
+  const swappedSubfields = checkSwapSubfieldCodes(droppedUnwantedFields);
+  const swappedTags = checkSwapTag(swappedSubfields);
+  const uniqueFields = [...new Set(swappedTags.map(field => JSON.stringify(field)))].map(field => JSON.parse(field));
+  debug('Fields to be copied');
+  debug(JSON.stringify(uniqueFields));
+
+  // Add fields to base;
+  uniqueFields.forEach(field => baseRecord.insertField(field));
+  debugData(`baseRecord before return: ${JSON.stringify(baseRecord)}`);
+  //return baseRecord;
+  return baseRecord.toObject();
+
+  function compareFields(sourceFields, baseCompareFields, uniqFields = []) {
+    const [sourceField, ...rest] = sourceFields;
+    if (sourceField === undefined) {
+      return uniqFields;
+    }
+
+    if (baseCompareFields.length === 0) {
+      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);
+    }
+
+    // Source and base are also compared for identicalness
+    // Non-identical fields are copied from source to base as duplicates
+    const sourceCompareField = createCompareField(sourceField);
+    const unique = checkCompareFields(baseCompareFields, sourceCompareField);
+
+    debugCompare(`${JSON.stringify(sourceField)} ${unique ? 'is UNIQUE' : 'not UNIQUE'}`);
+
+    if (unique) {
+      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);
+    }
+
+    return compareFields(rest, baseCompareFields, uniqFields);
+
+    function checkCompareFields(baseCompareFields, sourceCompareField) {
+      let unique = true; // eslint-disable-line functional/no-let
+
+      baseCompareFields.forEach(baseCompareField => {
+        debugCompare(`Comparing ${JSON.stringify(sourceCompareField)} to ${JSON.stringify(baseCompareField)}}`);
+
+        if (sourceCompareField.value !== baseCompareField.value) {
+          debugCompare(`Value is different ${sourceCompareField.value} !== ${baseCompareField.value}`);
+          return;
         }
-        function normalizeSubfield(subfield) {
-          return subfield.value.toLowerCase().replace(/\s+/u, '');
+
+        if (sourceCompareField.ind1 !== baseCompareField.ind1) {
+          debugCompare(`Ind1 is different ${sourceCompareField.ind1} !== ${baseCompareField.ind1}`);
+          return;
         }
-        function isIdenticalSubfield(baseSub) {
-          const normBaseSub = normalizeSubfield(baseSub);
-          return sourceField.subfields.some(sourceSub => {
-            const normSourceSub = normalizeSubfield(sourceSub);
-            return normSourceSub === normBaseSub;
-          });
+
+        if (sourceCompareField.ind2 !== baseCompareField.ind2) {
+          debugCompare(`Ind2 is different ${sourceCompareField.ind2} !== ${baseCompareField.ind2}`);
+          return;
         }
+
+        if ('subfields' in sourceCompareField) {
+          const allFound = checkSubfields(sourceCompareField.subfields, baseCompareField.subfields);
+          debugCompare(`Subfields are different ${!allFound}`);
+          if (!allFound) {
+            return;
+          }
+
+          unique = false;
+          return;
+        }
+
+        unique = false;
+        return;
+      });
+
+      return unique;
+    }
+
+    function checkSubfields(sourceSubfields, baseSubfields) {
+      const foundSubs = sourceSubfields.filter(sSub => baseSubfields.some(bSub => sSub.code === bSub.code && sSub.value === bSub.value));
+
+      if (subfieldsMustBeIdentical) {
+        return foundSubs.length === sourceSubfields.length && foundSubs.length === baseSubfields.length;
       }
-    };
-    // Search for fields missing from base
-    const missingFields = sourceFields.filter(filterMissing);
-    // Test 03: Add missing control field to base
-    // Test 05: Add missing data field to base
-    missingFields.forEach(f => base.insertField(f));
-    return base; // This is returned by copyFields
+
+      return foundSubs.length === sourceSubfields.length;
+    }
+  }
+
+  // compare objects have only fields that matter in comparison
+  function createCompareField(field) {
+    if (compareTagsOnly) {
+      return {tag: field.tag};
+    }
+
+    if ('value' in field) {
+      return {tag: field.tag, value: field.value};
+    }
+
+    const [filteredField] = checkDropSubfields([field]);
+    const [foundRule] = swapTag.filter(rule => new RegExp(rule.from, 'u').test(field.tag));
+    const replacementTag = foundRule ? foundRule.to : undefined;
+
+    const params = [
+      {name: 'tag', value: compareWithoutTag ? replacementTag : field.tag},
+      {name: 'ind1', value: ignoreInd1 ? undefined : field.ind1},
+      {name: 'ind2', value: ignoreInd2 ? undefined : field.ind2},
+      {name: 'subfields', value: createCompareSubfields(filteredField.subfields)}
+    ].map(param => [param.name, param.value]);
+
+    return Object.fromEntries(params);
+
+    function createCompareSubfields(subfields) {
+      const nonExcludedSubfields = subfields.filter(sub => !excludeSubfields.some(code => code === sub.code));
+      const normalizedSubfields = nonExcludedSubfields.map(sub => ({code: sub.code, value: normalizeSubfieldValue(sub.value)}));
+
+      return normalizedSubfields;
+
+      function normalizeSubfieldValue(value) {
+        return value.toLowerCase().replace(/\s+/ug, '');
+      }
+    }
+  }
+
+  function checkSwapTag(fields) {
+    if (swapTag.length > 0) {
+      return fields.map(field => ({...field, tag: swapTagsFunc(field.tag)}));
+    }
+
+    return fields;
+
+    function swapTagsFunc(tag) {
+      const [foundRule] = swapTag.filter(rule => new RegExp(rule.from, 'u').test(tag));
+
+      if (foundRule === undefined) {
+        return tag;
+      }
+
+      return foundRule.to;
+    }
+  }
+
+  function checkSwapSubfieldCodes(fields) {
+    if (swapSubfieldCode.length > 0) {
+      return fields.map(field => ({...field, subfields: swapSubfieldCodesFunc(field.subfields)}));
+    }
+
+    return fields;
+
+    function swapSubfieldCodesFunc(subfields) {
+      return subfields.map(sub => {
+        const [foundRule] = swapSubfieldCode.filter(rule => rule.from === sub.code);
+
+        if (foundRule === undefined) {
+          return sub;
+        }
+
+        return {code: foundRule.to, value: sub.value};
+      });
+    }
+  }
+
+  function checkDropSubfields(fields) {
+    if (dropSubfields.length > 0) {
+      return fields.map(field => ({...field, subfields: dropSubfieldsFunc(field.subfields)}))
+        .filter(field => field.subfields.length > 0);
+    }
+
+    return fields;
+
+    function dropSubfieldsFunc(subfields) {
+      return subfields.filter(sub => { // eslint-disable-line
+        return !dropSubfields.some(({code, value = false, condition = false}) => {
+          if (code !== sub.code) {
+            return false;
+          }
+
+          if (!condition && value) {
+            return value === sub.value;
+          }
+
+          if (condition === 'unless' && value) {
+            return !new RegExp(value, 'u').test(sub.value);
+          }
+
+          return true;
+        });
+      });
+    }
+  }
+
+  function checkCopyUnlessFields(fields) {
+    if (copyUnless.length > 0) {
+      return fields.filter(({subfields}) => copyUnless.some(filter => !subfields.some(sub => sub.code === filter.code && new RegExp(filter.value, 'u').test(sub.value))));
+    }
+
+    return fields;
   }
 };