@natlibfi/marc-record-merge 5.0.0 → 6.0.0-beta.4

package/dist/reducers/select.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _chai = require("chai");
+
+var _marcRecord = require("@natlibfi/marc-record");
+
+var _select = _interopRequireWildcard(require("./select"));
+
+var _fixura = require("@natlibfi/fixura");
+
+var _fixugen = _interopRequireDefault(require("@natlibfi/fixugen"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+_marcRecord.MarcRecord.setValidationOptions({
+  subfieldValues: false
+});
+
+(0, _fixugen.default)({
+  callback,
+  path: [__dirname, '..', '..', 'test-fixtures', 'reducers', 'select'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: _fixura.READERS.JSON,
+    failWhenNotFound: false
+  }
+});
+
+function callback({
+  getFixture,
+  disabled = false,
+  tagPatternRegExp = false,
+  expectedError = false,
+  useSubsetEquality = false
+}) {
+  if (disabled) {
+    console.log('TEST DISABLED!'); // eslint-disable-line no-console
+
+    return;
+  }
+
+  const base = new _marcRecord.MarcRecord(getFixture('base.json'), {
+    subfieldValues: false
+  });
+  const source = new _marcRecord.MarcRecord(getFixture('source.json'), {
+    subfieldValues: false
+  });
+  const tagPattern = new RegExp(tagPatternRegExp, 'u');
+  const expectedRecord = getFixture('merged.json');
+  const equalityFunction = useSubsetEquality ? _select.subsetEquality : undefined; // Bypass expected error in testing
+
+  if (expectedError) {
+    (0, _chai.expect)(() => _select.default.to.throw(Error, 'control field'));
+    return;
+  }
+
+  const mergedRecord = (0, _select.default)({
+    tagPattern,
+    equalityFunction
+  })(base, source);
+  (0, _chai.expect)(mergedRecord.toObject()).to.eql(expectedRecord);
+}
+//# sourceMappingURL=select.spec.js.map

package/dist/reducers/select.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.spec.js","names":["MarcRecord","setValidationOptions","subfieldValues","generateTests","callback","path","__dirname","useMetadataFile","recurse","fixura","reader","READERS","JSON","failWhenNotFound","getFixture","disabled","tagPatternRegExp","expectedError","useSubsetEquality","console","log","base","source","tagPattern","RegExp","expectedRecord","equalityFunction","subsetEquality","undefined","expect","createReducer","to","throw","Error","mergedRecord","toObject","eql"],"sources":["../../src/reducers/select.spec.js"],"sourcesContent":["import {expect} from 'chai';\nimport {MarcRecord} from '@natlibfi/marc-record';\nimport createReducer, {subsetEquality} from './select';\nimport {READERS} from '@natlibfi/fixura';\nimport generateTests from '@natlibfi/fixugen';\n\nMarcRecord.setValidationOptions({subfieldValues: false});\n\ngenerateTests({\n  callback,\n  path: [__dirname, '..', '..', 'test-fixtures', 'reducers', 'select'],\n  useMetadataFile: true,\n  recurse: false,\n  fixura: {\n    reader: READERS.JSON,\n    failWhenNotFound: false\n  }\n});\n\nfunction callback({\n  getFixture,\n  disabled = false,\n  tagPatternRegExp = false,\n  expectedError = false,\n  useSubsetEquality = false\n}) {\n  if (disabled) {\n    console.log('TEST DISABLED!'); // eslint-disable-line no-console\n    return;\n  }\n  const base = new MarcRecord(getFixture('base.json'), {subfieldValues: false});\n  const source = new MarcRecord(getFixture('source.json'), {subfieldValues: false});\n  const tagPattern = new RegExp(tagPatternRegExp, 'u');\n  const expectedRecord = getFixture('merged.json');\n  const equalityFunction = useSubsetEquality ? subsetEquality : undefined;\n\n  // Bypass expected error in testing\n  if (expectedError) {\n    expect(() => createReducer.to.throw(Error, 'control field'));\n    return;\n  }\n\n  const mergedRecord = createReducer({tagPattern, equalityFunction})(base, source);\n  expect(mergedRecord.toObject()).to.eql(expectedRecord);\n}\n"],"mappings":";;AAAA;;AACA;;AACA;;AACA;;AACA;;;;;;;;AAEAA,sBAAA,CAAWC,oBAAX,CAAgC;EAACC,cAAc,EAAE;AAAjB,CAAhC;;AAEA,IAAAC,gBAAA,EAAc;EACZC,QADY;EAEZC,IAAI,EAAE,CAACC,SAAD,EAAY,IAAZ,EAAkB,IAAlB,EAAwB,eAAxB,EAAyC,UAAzC,EAAqD,QAArD,CAFM;EAGZC,eAAe,EAAE,IAHL;EAIZC,OAAO,EAAE,KAJG;EAKZC,MAAM,EAAE;IACNC,MAAM,EAAEC,eAAA,CAAQC,IADV;IAENC,gBAAgB,EAAE;EAFZ;AALI,CAAd;;AAWA,SAAST,QAAT,CAAkB;EAChBU,UADgB;EAEhBC,QAAQ,GAAG,KAFK;EAGhBC,gBAAgB,GAAG,KAHH;EAIhBC,aAAa,GAAG,KAJA;EAKhBC,iBAAiB,GAAG;AALJ,CAAlB,EAMG;EACD,IAAIH,QAAJ,EAAc;IACZI,OAAO,CAACC,GAAR,CAAY,gBAAZ,EADY,CACmB;;IAC/B;EACD;;EACD,MAAMC,IAAI,GAAG,IAAIrB,sBAAJ,CAAec,UAAU,CAAC,WAAD,CAAzB,EAAwC;IAACZ,cAAc,EAAE;EAAjB,CAAxC,CAAb;EACA,MAAMoB,MAAM,GAAG,IAAItB,sBAAJ,CAAec,UAAU,CAAC,aAAD,CAAzB,EAA0C;IAACZ,cAAc,EAAE;EAAjB,CAA1C,CAAf;EACA,MAAMqB,UAAU,GAAG,IAAIC,MAAJ,CAAWR,gBAAX,EAA6B,GAA7B,CAAnB;EACA,MAAMS,cAAc,GAAGX,UAAU,CAAC,aAAD,CAAjC;EACA,MAAMY,gBAAgB,GAAGR,iBAAiB,GAAGS,sBAAH,GAAoBC,SAA9D,CATC,CAWD;;EACA,IAAIX,aAAJ,EAAmB;IACjB,IAAAY,YAAA,EAAO,MAAMC,eAAA,CAAcC,EAAd,CAAiBC,KAAjB,CAAuBC,KAAvB,EAA8B,eAA9B,CAAb;IACA;EACD;;EAED,MAAMC,YAAY,GAAG,IAAAJ,eAAA,EAAc;IAACP,UAAD;IAAaG;EAAb,CAAd,EAA8CL,IAA9C,EAAoDC,MAApD,CAArB;EACA,IAAAO,YAAA,EAAOK,YAAY,CAACC,QAAb,EAAP,EAAgCJ,EAAhC,CAAmCK,GAAnC,CAAuCX,cAAvC;AACD"}

package/package.json

@@ -1,59 +1,105 @@
 {
-  "name": "@natlibfi/marc-record-merge",
-  "description": "A configurable Javascript module for merging MARC records",
-  "author": {
-    "name": "The National Library of Finland"
-  },
-  "keywords": [
-    "marc",
-    "record",
-    "merge",
-    "merging",
-    "combine",
-    "combining",
-    "bibliography",
-    "bibliographic",
-    "catalog",
-    "library",
-    "libraries"
-  ],
-  "homepage": "https://github.com/NatLibFi/marc-record-merge",
-  "bugs": {
-    "url": "https://github.com/NatLibFi/marc-record-merge/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:NatLibFi/marc-record-merge.git"
-  },
-  "license": "AGPL-3.0",
-  "version": "5.0.0",
-  "main": "./lib/main.js",
-  "scripts": {
-    "lint": "jshint .",
-    "test": "istanbul cover _mocha test/nodejs/*.spec.js",
-    "test:watch": "mocha test/nodejs/*.spec.js -w",
-    "test-browser": "npm run generate-requirejs-config && karma start",
-    "cover": "npm run test && istanbul check-coverage",
-    "check": "npm run lint && npm run cover",
-    "generate-requirejs-config": "requirejs-configurator --npm --include-dev-dependencies --exclude-peer-dependencies > test/browser/main.js",
-    "publish-to-npm": "npm install && npm run check && npm publish --access=public"
-  },
-  "dependencies": {
-    "marc-record-js": "^0.1.1",
-    "@natlibfi/es6-polyfills": "^2.0.0",
-    "@natlibfi/es6-shims": "^2.0.0"
-  },
-  "devDependencies": {
-    "chai": "^3.5.0",
-    "jshint": "^2.9.3",
-    "mocha": "^3.0.2",
-    "istanbul": "^0.4.5",
-    "karma": "^1.2.0",
-    "karma-mocha": "^1.1.1",
-    "karma-requirejs": "https://github.com/natlibfi-arlehiko/karma-requirejs#fix-npm3-dist",
-    "karma-requirejs-preprocessor": "^0.0.2",
-    "requirejs": "^2.3.2",
-    "requirejs-configurator": "https://github.com/natlibfi-arlehiko/requirejs-configurator#peer-deps",
-    "codeclimate-test-reporter": "^0.3.3"
-  }
+	"name": "@natlibfi/marc-record-merge",
+	"description": "Merge MARC records",
+	"author": {
+		"name": "The National Library of Finland"
+	},
+	"keywords": [],
+	"homepage": "https://github.com/natlibfi/marc-record-merge-js",
+	"bugs": {
+		"url": "https://github.com/natlibfi/marc-record-merge-js/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git@github.com:natlibfi/marc-record-merge-js.git"
+	},
+	"license": "MIT",
+	"version": "6.0.0-beta.4",
+	"main": "./dist/index.js",
+	"engines": {
+		"node": ">=14"
+	},
+	"type": "commonjs",
+	"scripts": {
+		"prepare": "npm run build",
+		"prepublishOnly": "npm run build:transpile",
+		"lint": "eslint ./src",
+		"lint:dev": "eslint ./src --fix",
+		"test:base": "cross-env NODE_ENV=test mocha --require @babel/register --reporter-option maxDiffSize=15000 src/reducers/*.spec.js",
+		"test": "npm run lint && npm run test:base",
+		"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 --reporter=text",
+		"build:transpile": "babel src --copy-files --source-maps --delete-dir-on-start --out-dir=dist",
+		"build": "npm run build:transpile",
+		"dev:test": "cross-env DEBUG=@natlibfi/* NODE_ENV=test nodemon -w src -w test-fixtures --exec 'clear && npm run test:dev'"
+	},
+	"dependencies": {
+		"@natlibfi/fixugen": "^1.0.2",
+		"@natlibfi/fixura": "^2.2.1",
+		"@natlibfi/marc-record": "^7.1.0-alpha.1",
+		"debug": "^4.3.4",
+		"normalize-diacritics": "^2.13.2"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.17.10",
+		"@babel/core": "^7.18.0",
+		"@babel/eslint-parser": "^7.17.0",
+		"@babel/preset-env": "^7.18.0",
+		"@babel/register": "^7.17.7",
+		"@natlibfi/eslint-config-melinda-backend": "^2.0.0",
+		"babel-plugin-istanbul": "^6.1.1",
+		"babel-plugin-rewire": "^1.2.0",
+		"chai": "^4.3.4",
+		"cross-env": "^7.0.3",
+		"eslint": "^8.16.0",
+		"mocha": "^10.0.0",
+		"nodemon": "^2.0.16",
+		"nyc": "^15.1.0"
+	},
+	"eslintConfig": {
+		"extends": [
+			"@natlibfi/melinda-backend"
+		]
+	},
+	"babel": {
+		"presets": [
+			[
+				"@babel/preset-env",
+				{
+					"targets": {
+						"node": "14"
+					}
+				}
+			]
+		],
+		"env": {
+			"test": {
+				"plugins": [
+					"rewire",
+					"istanbul"
+				]
+			}
+		}
+	},
+	"nyc": {
+		"exclude": [
+			"*/*.spec.js",
+			"*/**/*.spec.js"
+		],
+		"reporter": [
+			"lcov",
+			"html"
+		],
+		"require": [
+			"@babel/register"
+		],
+		"sourceMap": false,
+		"instrument": false,
+		"lines": 80,
+		"statements": 80,
+		"functions": 80,
+		"branches": 80
+	}
 }

package/src/index.js

@@ -0,0 +1,4 @@
+import Reducers from './reducers';
+
+export {Reducers};
+export default ({base, source, reducers}) => reducers.reduce((base, reducer) => reducer(base, source), base);

package/src/reducers/copy.js

@@ -0,0 +1,274 @@
+/* eslint-disable no-unused-vars */
+
+import {MarcRecord} from '@natlibfi/marc-record';
+import createDebugLogger from 'debug';
+
+export default ({
+  tagPattern,
+  compareTagsOnly = false,
+  compareWithoutIndicators = false,
+  subfieldsMustBeIdentical = true,
+  excludeSubfields = [],
+  dropSubfields = [],
+  copyUnless = [],
+  baseValidators = {subfieldValues: false},
+  sourceValidators = {subfieldValues: false}
+}) => (base, source) => {
+  const baseRecord = new MarcRecord(base, baseValidators);
+  const sourceRecord = new MarcRecord(source, sourceValidators);
+
+  const debug = createDebugLogger('@natlibfi/marc-record-merge');
+  const debugOptions = createDebugLogger('@natlibfi/marc-record-merge:compare-options');
+  const debugCompare = createDebugLogger('@natlibfi/marc-record-merge:compare');
+  debugOptions(`Tag Pattern: ${tagPattern}`);
+  debugOptions(`Compare tags only: ${compareTagsOnly}`);
+  debugOptions(`Compare without indicators ${compareWithoutIndicators}`);
+  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);
+
+  debug(`Base fields: `, baseFields);
+  debug(`Source fields: `, sourceFields);
+
+  const compareResultFields = compareFields(sourceFields, baseFields);
+  const droppedUnwantedSubfield = checkDropSubfields(compareResultFields);
+  const droppedUnwantedFields = checkCopyUnlessFields(droppedUnwantedSubfield);
+  debug('Fields to be copied');
+  debug(JSON.stringify(droppedUnwantedFields));
+
+  // Add fields to base;
+  droppedUnwantedFields.forEach(field => baseRecord.insertField(field));
+  return baseRecord.toObject();
+  //return copyFields(baseFields, sourceFields);
+
+  function compareFields(sourceFields, baseFields, uniqFields = []) {
+    const [sourceField, ...rest] = sourceFields;
+    if (sourceField === undefined) {
+      return uniqFields;
+    }
+
+    if (baseFields.length === 0) {
+      return compareFields(rest, baseFields, [...uniqFields, sourceField]);
+    }
+
+    // Source and base are also compared for identicalness
+    // Non-identical fields are copied from source to base as duplicates
+    const sourceComapareField = createCompareField(sourceField);
+    const baseCompareFields = baseFields.map(baseField => createCompareField(baseField));
+
+    const unique = checkCompareFields(baseCompareFields, sourceComapareField);
+
+    debugCompare(`${JSON.stringify(sourceField)} ${unique ? 'is UNIQUE' : 'not UNIQUE'}`);
+
+    if (unique) {
+      return compareFields(rest, baseFields, [...uniqFields, sourceField]);
+    }
+
+    return compareFields(rest, baseFields, uniqFields);
+
+    function checkCompareFields(baseCompareFields, sourceComapareField) {
+      const [baseCompareField, ...rest] = baseCompareFields;
+      if (baseCompareField === undefined) {
+        return true;
+      }
+
+      if (sourceComapareField.value !== baseCompareField.value) {
+        debugCompare(`Value is different ${sourceComapareField.value} !== ${baseCompareField.value}`);
+        return true;
+      }
+
+      if (sourceComapareField.ind1 !== baseCompareField.ind1) {
+        debugCompare(`Ind1 is different ${sourceComapareField.ind1} !== ${baseCompareField.ind1}`);
+        return true;
+      }
+
+      if (sourceComapareField.ind2 !== baseCompareField.ind2) {
+        debugCompare(`Ind2 is different ${sourceComapareField.ind2} !== ${baseCompareField.ind2}`);
+        return true;
+      }
+
+      if ('subfields' in sourceComapareField) {
+        const allFound = checkSubfields(sourceComapareField.subfields, baseCompareField.subfields);
+        debugCompare(`Subfields are different ${!allFound}`);
+        return allFound ? false : checkCompareFields(rest, sourceComapareField);
+      }
+
+      return false;
+    }
+
+    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;
+      }
+
+      return foundSubs.length === sourceSubfields.length;
+    }
+  }
+
+  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 params = [
+      {name: 'tag', value: field.tag},
+      {name: 'ind1', value: compareWithoutIndicators ? undefined : field.ind1},
+      {name: 'ind2', value: compareWithoutIndicators ? 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 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;
+  }
+};
+
+// function copyFields() { //eslint-disable-line no-unused-vars
+//   const sourceTags = sourceFields.map(field => field.tag);
+//   sourceTags.forEach(tag => debug(`Comparing field ${tag}`));
+
+//   /*
+//   if (combine.length > 0) {
+//     debug(`*** NOW Copy options: ${tagPattern}, ${compareTagsOnly}, ${compareWithoutIndicators}, ${subfieldsMustBeIdentical}, [${combine}], [${excludeSubfields}], [${dropSubfields}]`);
+//     combine.forEach(row => debug(` ### combine ${row} <- `));
+//     return [];
+//   }
+//   */
+
+//   // If compareTagsOnly = true, only this part is run
+//   // The field is copied from source only if it is missing completely from base
+//   if (compareTagsOnly && baseFields.length === 0) {
+//     sourceTags.forEach(tag => debug(`Missing field ${tag} copied from source to base`));
+//     sourceFields.forEach(f => base.insertField(f));
+//     return true;
+//   }
+
+//   // If compareTagsOnly = false (default)
+//   // Source and base are also compared for identicalness
+//   // Non-identical fields are copied from source to base as duplicates
+//   if (!compareTagsOnly) {
+//     const filterMissing = function (sourceField) {
+//       if ('value' in sourceField) {
+//         debug(`Checking control field ${sourceField.tag} for identicalness`);
+//         return baseFields.some(isIdenticalControlField) === false;
+//       }
+//       if ('subfields' in sourceField) {
+//         debug(`Checking data field ${sourceField.tag} for identicalness`);
+//         return baseFields.some(isIdenticalDataField) === false;
+//       }
+
+//       function normalizeControlField(field) {
+//         return field.value.toLowerCase().replace(/\s+/u, '');
+//       }
+
+//       function isIdenticalControlField(baseField) {
+//         const normalizedBaseField = normalizeControlField(baseField);
+//         const normalizedSourceField = normalizeControlField(sourceField);
+//         return normalizedSourceField === normalizedBaseField;
+//       }
+
+//       function isIdenticalDataField(baseField) {
+//         // If excluded subfields have been defined for this field, they must be ignored first
+//         // (i.e. source and base fields are considered identical if all non-excluded subfields are identical)
+//         if (excludeSubfields.length > 0 &&
+//           sourceField.tag === baseField.tag &&
+//           sourceField.ind1 === baseField.ind1 &&
+//           sourceField.ind2 === baseField.ind2) {
+//           excludeSubfields.forEach(sub => debug(`Subfield ${sub} excluded from identicalness comparison`));
+//           // Compare only those subfields that are not excluded
+//           const baseSubsToCompare = baseField.subfields.filter(subfield => excludeSubfields.indexOf(subfield.code) === -1);
+//           return baseSubsToCompare.every(isIdenticalSubfield);
+//         }
+//         // If there are no excluded subfields (default case)
+//         if (sourceField.tag === baseField.tag &&
+//           sourceField.ind1 === baseField.ind1 &&
+//           sourceField.ind2 === baseField.ind2 &&
+//           sourceField.subfields.length === baseField.subfields.length) {
+//           return baseField.subfields.every(isIdenticalSubfield);
+//         }
+//         function normalizeSubfield(subfield) {
+//           return subfield.value.toLowerCase().replace(/\s+/u, '');
+//         }
+//         function isIdenticalSubfield(baseSub) {
+//           const normBaseSub = normalizeSubfield(baseSub);
+//           return sourceField.subfields.some(sourceSub => {
+//             const normSourceSub = normalizeSubfield(sourceSub);
+//             return normSourceSub === normBaseSub;
+//           });
+//         }
+//       }
+//     };
+//     // Search for fields missing from base
+//     const missingFields = sourceFields.filter(filterMissing);
+//     missingFields.forEach(f => base.insertField(f));
+//     if (missingFields.length > 0) {
+//       const missingTags = missingFields.map(field => field.tag);
+//       missingTags.forEach(tag => debug(`Field ${tag} copied from source to base`));
+//       return base;
+//     }
+//     if (missingFields.length === 0) {
+//       debug(`No missing fields found`);
+//       return base;
+//     }
+//   }
+//   debug(`No missing fields found`);
+//   return base;
+// }

package/src/reducers/copy.spec.js

@@ -0,0 +1,48 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import {MarcRecord} from '@natlibfi/marc-record';
+import createReducer from './copy';
+import generateTests from '@natlibfi/fixugen';
+
+// import createDebugLogger from 'debug'; // <---
+// const debug = createDebugLogger('@natlibfi/marc-record-merge/copy.spec.js'); // <---
+
+generateTests({
+  callback,
+  path: [__dirname, '..', '..', 'test-fixtures', 'reducers', 'copy'],
+  useMetadataFile: true,
+  recurse: true,
+  fixura: {
+    reader: READERS.JSON,
+    failWhenNotFound: false
+  }
+});
+
+function callback({
+  getFixture,
+  tagPatternRegExp,
+  compareTagsOnly = false,
+  compareWithoutIndicators = false,
+  subfieldsMustBeIdentical = false,
+  copyUnless = undefined,
+  excludeSubfields = undefined,
+  dropSubfields = undefined,
+  disabled = false
+}) {
+  if (disabled) {
+    console.log('TEST DISABLED!'); // eslint-disable-line no-console
+    return;
+  }
+
+  const base = new MarcRecord(getFixture('base.json'), {subfieldValues: false});
+  const source = new MarcRecord(getFixture('source.json'), {subfieldValues: false});
+  const tagPattern = new RegExp(tagPatternRegExp, 'u');
+  const expectedRecord = getFixture('merged.json');
+
+  const mergedRecord = createReducer({tagPattern, compareTagsOnly, compareWithoutIndicators, copyUnless, subfieldsMustBeIdentical, excludeSubfields, dropSubfields})(base, source);
+  //debug(`***     mergedRecord: `, mergedRecord); //<--
+  //debug(`***     mergedRecord,Strfy: `, JSON.stringify(mergedRecord.toObject())); //<--
+  //debug(`***     expectedRecord: `, expectedRecord); //<--
+  //debug(`***     expectedRecord,Strfy: `, JSON.stringify(expectedRecord)); //<--
+  expect(mergedRecord).to.eql(expectedRecord);
+}

package/src/reducers/index.js

@@ -0,0 +1,4 @@
+import copy from './copy';
+import select, {strictEquality, subsetEquality} from './select';
+
+export default {copy, select, strictEquality, subsetEquality};