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

package/src/reducers/copy.js

@@ -1,140 +1,274 @@
-/**
-*
-* @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.
-*
-*/
-
-/**
- * Test 01: If base does not contain the field at all, it is copied from source to base
- * Test 02: Identical control fields are not copied
- * Test 03: Add missing control field to base
- * Test 04: Identical data fields in base and source, not copied
- * Test 05: Different data fields are copied from source to base (multiple fields)
- * Test 06: compareTagsOnly: Field is copied from source only if it is missing in base, a different instance is not copied
- * Test 07: excludeSubfields: Ignore excluded subfields in comparing identicalness
- * Test 08: dropSubfields: Drop subfields from source before copying
- * Test 09: compareTagsOnly for repeatable fields, 2x each 260/264
- * */
+/* eslint-disable no-unused-vars */
+
+import {MarcRecord} from '@natlibfi/marc-record';
 import createDebugLogger from 'debug';
 
-export default ({tagPattern, compareTagsOnly = false, excludeSubfields = [], dropSubfields = []}) => (base, source) => {
+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 baseFields = base.get(tagPattern);
-  // Check whether there are subfields to drop from source before copying
-  const sourceFields = checkDropSubfields(source.get(tagPattern));
-  return copyFields();
+  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);
 
-  function copyFields() {
-    const sourceTags = sourceFields.map(field => field.tag);
-    sourceTags.forEach(tag => debug(`Comparing field ${tag}`));
+  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 compareTagsOnly = true, only this part is run
-    // The field is copied from source only if it is missing completely from base
     if (baseFields.length === 0) {
-      sourceTags.forEach(tag => debug(`Missing field ${tag} copied from source to base`));
-      sourceFields.forEach(f => base.insertField(f));
-      return base;
+      return compareFields(rest, baseFields, [...uniqFields, sourceField]);
     }
 
-    // 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;
+    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;
       }
-      if (missingFields.length === 0) {
-        debug(`No missing fields found`);
-        return base;
+
+      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, '');
       }
     }
-    debug(`No missing fields found`);
-    return base;
   }
 
   function checkDropSubfields(fields) {
     if (dropSubfields.length > 0) {
-      dropSubfields.forEach(sub => debug(`Subfield ${sub} dropped from source field before copying`));
-      return fields.map((field) => ({...field, subfields: field.subfields.filter((subfield) => dropSubfields.indexOf(subfield.code) === -1)}));
+      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))));
     }
-    debug(`No subfields to drop`);
+
     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

@@ -1,72 +1,48 @@
-/**
-*
-* @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 chai from 'chai';
-import fs from 'fs';
-import path from 'path';
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
 import {MarcRecord} from '@natlibfi/marc-record';
 import createReducer from './copy';
-import fixturesFactory, {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
 
-MarcRecord.setValidationOptions({subfieldValues: false});
+// import createDebugLogger from 'debug'; // <---
+// const debug = createDebugLogger('@natlibfi/marc-record-merge/copy.spec.js'); // <---
 
-describe('reducers/copy', () => {
-  const {expect} = chai;
-  const fixturesPath = path.join(__dirname, '..', '..', 'test-fixtures', 'reducers', 'copy');
+generateTests({
+  callback,
+  path: [__dirname, '..', '..', 'test-fixtures', 'reducers', 'copy'],
+  useMetadataFile: true,
+  recurse: true,
+  fixura: {
+    reader: READERS.JSON,
+    failWhenNotFound: false
+  }
+});
 
-  fs.readdirSync(fixturesPath).forEach(subDir => {
-    const {getFixture} = fixturesFactory({root: [fixturesPath, subDir], reader: READERS.JSON, failWhenNotFound: false});
-    it(subDir, () => {
-      const base = new MarcRecord(getFixture('base.json'));
-      const source = new MarcRecord(getFixture('source.json'));
-      const tagPattern = new RegExp(getFixture({components: ['tagPattern.txt'], reader: READERS.TEXT}), 'u');
-      const compareTagsOnly = getCompareTagsOnly();
-      const excludeSubfields = getExcludeSubfields();
-      const dropSubfields = getDropSubfields();
-      const expectedRecord = getFixture('merged.json');
-      const mergedRecord = createReducer({tagPattern, compareTagsOnly, excludeSubfields, dropSubfields})(base, source);
-      expect(mergedRecord.toObject()).to.eql(expectedRecord);
+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;
+  }
 
-      // Non-repeatable MARC fields are copied from source only if they are missing from base
-      function getCompareTagsOnly() {
-        const functionName = getFixture({components: ['compareTagsOnly.txt'], reader: READERS.TEXT});
-        return functionName === 'true' ? 'true' : undefined;
-      }
-      // Check whether excludeSubfields.json exists and if it does, return its contents. If not, do nothing.
-      function getExcludeSubfields() {
-        const subfieldsToExclude = getFixture({components: ['excludeSubfields.json'], reader: READERS.JSON});
-        return subfieldsToExclude ? subfieldsToExclude : undefined;
-      }
+  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');
 
-      // Check whether dropSubfields.json exists and if it does, return its contents. If not, do nothing.
-      function getDropSubfields() {
-        const subfieldsToDrop = getFixture({components: ['dropSubfields.json'], reader: READERS.JSON});
-        return subfieldsToDrop ? subfieldsToDrop : undefined;
-      }
-    });
-  });
-});
+  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

@@ -1,30 +1,3 @@
-/**
-*
-* @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 copy from './copy';
 import select, {strictEquality, subsetEquality} from './select';
 

package/src/reducers/select.js

@@ -1,49 +1,3 @@
-/**
-*
-* @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.
-*
-*/
-/**
- * Test 01: The field is a control field (contains 'value') --> error message
- * Test 02: If there are multiple fields, return base
- * Test 03: Base and source tags are equal for one field --> return base
- * Test 04: Base and source tags are not equal --> return base
- *  Note: to test for this, tagPattern has to allow two tags,
- *  otherwise the unequal tag does not even pass source.get(tagPattern)
- * Test 05: Normalize subfield values (base and source are equal) --> return base
- * Test 06: Two subfields, both equal --> return base
- * Test 07: Two subfields, same codes, values of source are subsets of values of base --> replaceBasefieldWithSourcefield
- * Test 08: Two subfields, one is a subset, one has a different code --> return base
- * Test 09: Two subfields, same codes, values are not subsets --> return base
- * Test 10: sourceField is a proper superset of baseField (subfields a and b are equal, c is new) --> replaceBasefieldWithSourcefield
- * Test 11: sourceField is not a proper superset of baseField (different values in a and b, also new subfield c) --> return base
- * Test 12: sourceField is a proper superset of baseField (base values a and b are subsets of source values a and b, c is new in source) --> replaceBasefieldWithSourcefield
- * Test 13: Opposite of test 12, baseField is a proper superset of sourceField --> return base
- * Test 14: Normalization test with Cyrillic characters
- */
-
 import {normalizeSync} from 'normalize-diacritics';
 import createDebugLogger from 'debug';
 
@@ -58,7 +12,7 @@ export function subsetEquality(subfieldA, subfieldB) {
 }
 // EqualityFunction can be either strictEquality or subsetEquality
 export default ({tagPattern, equalityFunction = strictEquality}) => (base, source) => {
-  const debug = createDebugLogger('@natlibfi/marc-record-merge');
+  const debug = createDebugLogger('@natlibfi/marc-record-merge:select');
   const baseFields = base.get(tagPattern);
   const sourceFields = source.get(tagPattern);
   const fieldTag = sourceFields.map(field => field.tag);