@natlibfi/marc-record-validators-melinda 12.0.6 → 12.0.7

package/src/merge-fields/counterpartField.js

@@ -1,23 +1,24 @@
 // For each incoming field that
 
 import createDebugLogger from 'debug';
-import {fieldHasSubfield, fieldHasNSubfields, fieldHasMultipleSubfields, fieldToString, nvdebug, removeCopyright} from '../utils.js';
+import {fieldHasSubfield, fieldHasNSubfields, fieldHasMultipleSubfields, fieldToString, nvdebug, removeCopyright, tagIsRepeatable} from '../utils.js';
 import {cloneAndNormalizeFieldForComparison, cloneAndRemovePunctuation} from '../normalizeFieldForComparison.js';
-// This should be done via our own normalizer:
 import {normalizeControlSubfieldValue} from '../normalize-identifiers.js';
 
 import {getMergeConstraintsForTag} from './mergeConstraints.js';
 import {controlSubfieldsPermitMerge} from './controlSubfields.js';
 import {mergableIndicator1, mergableIndicator2} from './mergableIndicator.js';
 import {partsAgree} from '../normalizeSubfieldValueForComparison.js';
-import {normalizeForSamenessCheck, valueCarriesMeaning} from './worldKnowledge.js';
-import { provenanceSubfieldsPermitMerge } from './dataProvenance.js';
+import {getSynonym, normalizeForSamenessCheck, valueCarriesMeaning} from './worldKnowledge.js';
+import {provenanceSubfieldsPermitMerge} from './dataProvenance.js';
+
+// NB! We are using internal prefix '(FIN11)' instead of global (FI-ASTERI-N) here. The latter would be better but would require some work and testing.
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:mergeField:counterpart');
 //const debugData = debug.extend('data');
 const debugDev = debug.extend('dev');
 
-const irrelevantSubfieldsInNameAndTitlePartComparison = '5689';
+// NB! FIN11 $0 pairing is handled in this code. We might want to support others, esp. FIN13 as well.
 
 const counterpartRegexps = { // NB! tag is from source!
   // Note that in the normal case, all source 1XX fields have been converted to 7XX fields.
@@ -36,17 +37,6 @@ const counterpartRegexpsSingle = {
   '940': /^[29]40$/u, '973': /^[79]73$/u
 };
 
-/*
-function differentPublisherSubfields(field1, field2) {
-  if (field1.tag === '260' && field2.tag === '264' && field2.ind2 === '3') {
-    return true;
-  }
-  if (field1.tag === '264' && field1.ind2 === '3' && field2.tag === '260') {
-    return true;
-  }
-  return false;
-}
-*/
 
 export function splitToNameAndQualifier(value) {
   if (value.match(/^.* \([^()]+\)$/u)) {
@@ -57,7 +47,7 @@ export function splitToNameAndQualifier(value) {
   return [value, undefined];
 }
 
-export function splitToNameAndQualifierAndProcessName(name) {
+function splitToNameAndQualifierAndProcessName(name) {
   //const nameOnly = name.replace(/(?: \([^)]+\)| abp?| Kustannus| Kustannus Oy|, kustannusosakeyhtiö| oyj?| ry)$/ugi, '');
   const [qualifierlessName, qualifier] = splitToNameAndQualifier(name);
 
@@ -101,7 +91,7 @@ export function splitToNameAndQualifierAndProcessName(name) {
 }
 
 export function canContainOptionalQualifier(tag, subfieldCode) {
-  // We have made 300$a NON-repeatable (against specs), as we newer want there to repeat (probably near-duplicates)
+  // We have made 300$a NON-repeatable (against specs), as we never want them to be repeated (probably near-duplicates)
   if (tag === '300' && subfieldCode === 'a') {
     return true;
   }
@@ -113,6 +103,7 @@ export function canContainOptionalQualifier(tag, subfieldCode) {
 }
 
 function withAndWithoutQualifierAgree(value1, value2, tag, subfieldCode) {
+  // Split value to name and qualifier parts. Names must be equal, and qualifiers must be equal, iff both values contain them.
   if (!canContainOptionalQualifier(tag, subfieldCode)) {
     return false;
   }
@@ -133,11 +124,8 @@ function withAndWithoutQualifierAgree(value1, value2, tag, subfieldCode) {
   }
 
   return false;
-
-
 }
 
-
 function corporateNamesAgree(value1, value2, tag, subfieldCode) {
   if (subfieldCode !== 'a' || !['110', '610', '710', '810'].includes(tag)) {
     return false;
@@ -158,166 +146,34 @@ function corporateNamesAgree(value1, value2, tag, subfieldCode) {
   // Currently all prefixes and suffixes are publisher information, so there's no point comparing them any further...
 
   return true;
-
-  /*
-  function isKustantaja(nameData) {
-    if (nameData.suffix.match(/^(?:Kustannus|Kustannus oy|kustannusosakeyhtiö)$/iu)) {
-      return true;
-    }
-    if (nameData.prefix.match(/^Kustannus Oy$/i)) {
-      return true;
-    }
-    return false;
-  }
-  */
-}
-
-
-function pairableValue(tag, subfieldCode, value1, value2) {
-  // This function could just return true or false.
-  // I thought of preference when I wrote this, but preference implemented *here* (modularity). mergeFields.js should handle preference.
-  if (withAndWithoutQualifierAgree(value1, value2, tag, subfieldCode)) {
-    // 300$a "whatever" and "whatever (123 sivua)"
-    return value1;
-  }
-  if (partsAgree(value1, value2, tag, subfieldCode) || corporateNamesAgree(value1, value2, tag, subfieldCode)) {
-    // Pure baseness: here we assume that base's value1 is better than source's value2.
-    return value1;
-  }
-
-  return undefined;
 }
 
-
 function counterpartExtraNormalize(tag, subfieldCode, value) {
-
   // Remove trailing punctuation:
   value = value.replace(/(\S)(?:,|\.|\?|!|\. -| *:| *;| =| \/)$/u, '$1');
   // Remove brackets:
   value = value.replace(/^\(([^()]+)\)$/u, '$1'); // Remove initial '(' and final ')' if both exist.
   value = value.replace(/^\[([^[\]]+)\]$/u, '$1'); // Remove initial '[' and final ']' if both exist.
   // Mainly for field 260$c:
-  value = removeCopyright(value);
-
-  value = value.replace(/http:\/\//ug, 'https://'); // MET-501: http vs https
-  value = normalizeForSamenessCheck(tag, subfieldCode, value);
-
-  return value;
-}
-
-function uniqueKeyMatches(baseField, sourceField, forcedKeyString = null) {
-  // NB! Assume that field1 and field2 have same relevant subfields.
-  // What to do if if base
-  // const keySubfieldsAsString = forcedKeyString || getUniqueKeyFields(field1);
-  const keySubfieldsAsString = forcedKeyString || getMergeConstraintsForTag(baseField.tag, 'key');
-  //return mandatorySubfieldComparison(baseField, sourceField, keySubfieldsAsString);
-  return optionalSubfieldComparison(baseField, sourceField, keySubfieldsAsString);
-}
-
-
-function optionalSubfieldComparison(originalBaseField, originalSourceField, keySubfieldsAsString) {
-  // Here "optional subfield" means a subfield, that needs not to be present, but if present, it must be identical...
-  // (Think of a better name...)
-  // We use clones here, since these changes done below are not intented to appear on the actual records.
-  const field1 = cloneAndNormalizeFieldForComparison(originalBaseField);
-  const field2 = cloneAndNormalizeFieldForComparison(originalSourceField);
-
-  if (keySubfieldsAsString === null) { // does not currently happen
-    // If keySubfieldsAsString is undefined, (practically) everything is the string.
-    // When everything is the string, the strings need to be (practically) identical.
-    // (NB! Here order matters. We should probably make it matter everywhere.)
-    // (However, keySubfieldsAsString === '' will always succeed. Used by 040 at least.)
-    // NB! substring(6) skips "TAG II" (I=indicator. Thus we skip indicators)
-    return fieldToString(field1).substring(6) === fieldToString(field2).substring(6);
-  }
-  const subfieldArray = keySubfieldsAsString.split('');
-
-  // Long forgotten, but my educated guess about this: if 'key' is defined in merge constraints
-  // for this field, then at least one of the subfield codes in 'key' must be present in both fields.
-  // However, this is not necessarily right.
-  if (subfieldArray.length > 0 && !subfieldArray.some(sfCode => hasCommonNominator(sfCode))) {
-    return false;
+  if (tag === '260' && subfieldCode === 'c') {
+    value = removeCopyright(value);
   }
+  value = value.replace(/http:\/\//ug, 'https://'); // MET-501: http vs https
+  value = getSynonym(tag, subfieldCode, value);
+  value = normalizeForSamenessCheck(tag, subfieldCode, value); // Better to remove trailing punctuation before calling this...
 
 
-  return subfieldArray.every(subfieldCode => testOptionalSubfield(originalBaseField.tag, subfieldCode));
-
-
-  function hasCommonNominator(subfieldCode) {
-    //nvdebug(`hasCommonNominator(${subfieldCode})? '${fieldToString(originalBaseField)}' vs '${fieldToString(originalSourceField)}'`, debugDev);
-
-    // If base has $a and source has $b, there's no common nominator, thus fail...
-    const subfields1 = field1.subfields.filter(subfield => subfield.code === subfieldCode && valueCarriesMeaning(field1.tag, subfield.code, subfield.value));
-    const subfields2 = field2.subfields.filter(subfield => subfield.code === subfieldCode && valueCarriesMeaning(field2.tag, subfield.code, subfield.value));
-
-    return subfields1.length > 0 && subfields2.length > 0;
-  }
-
-  function testOptionalSubfield(tag, subfieldCode) {
-    // NB! Don't compare non-meaningful subfields
-    const subfields1 = field1.subfields.filter(subfield => subfield.code === subfieldCode && valueCarriesMeaning(field1.tag, subfield.code, subfield.value));
-    const subfields2 = field2.subfields.filter(subfield => subfield.code === subfieldCode && valueCarriesMeaning(field2.tag, subfield.code, subfield.value));
-
-    // If one side is empty, all is good
-    if (subfields1.length === 0 || subfields2.length === 0) {
-      return true;
-    }
-
-    //nvdebugSubfieldArray(subfields1, 'SF1', debugDev);
-    //nvdebugSubfieldArray(subfields2, 'SF2', debugDev);
-
-    // When pairing we can use stronger normalizations than the generic one:
-    const subfieldValues1 = subfields1.map(sf => counterpartExtraNormalize(tag, subfieldCode, sf.value));
-    const subfieldValues2 = subfields2.map(sf => counterpartExtraNormalize(tag, subfieldCode, sf.value));
-
-    //nvdebug(`SF1 NORM: ${subfieldValues1.join(' --')}`, debugDev);
-    //nvdebug(`SF2 NORM: ${subfieldValues2.join(' --')}`, debugDev);
-
-    // If one set is a subset of the other, all is probably good (how about 653$a, 505...)
-    if (subfieldValues1.every(val => subfieldValues2.includes(val)) || subfieldValues2.every(val => subfieldValues1.includes(val))) {
-      return true;
-    }
-
-    if (subfieldValues1.length === 1 && subfieldValues2.length === 1) {
-      return pairableValue(field1.tag, subfieldCode, subfieldValues1[0], subfieldValues2[0]) !== undefined;
-    }
-
-    return false;
-
-  }
+  return value;
 }
 
+function hasCommonNominator(field1, field2, subfieldCode) {
+  //nvdebug(`hasCommonNominator(${subfieldCode})? '${fieldToString(originalBaseField)}' vs '${fieldToString(originalSourceField)}'`, debugDev);
 
-function mandatorySubfieldComparison(originalField1, originalField2, keySubfieldsAsString) {
-  // NB! We use clones here, since these changes done below are not intented to appear on the actual records.
-  const field1 = cloneAndNormalizeFieldForComparison(originalField1);
-  const field2 = cloneAndNormalizeFieldForComparison(originalField2);
-  if (keySubfieldsAsString === null) { // does not currently happen
-    // If keySubfieldsAsString is undefined, (practically) everything is the string.
-    // When everything is the string, the strings need to be (practically) identical.
-    // (NB! Here order matters. We should probably make it matter everywhere.)
-    // (However, keySubfieldsAsString === '' will always succeed. Used by 040 at least.)
-    return fieldToString(field1) === fieldToString(field2);
-  }
-  const subfieldArray = keySubfieldsAsString.split('');
-
-  //const differentSubfieldCodes = differentPublisherSubfields(originalField1, originalField2);
-
-  return subfieldArray.every(subfieldCode => mandatorySingleSubfieldComparison(subfieldCode));
-
-  function mandatorySingleSubfieldComparison(subfieldCode) {
-    //const otherSubfieldCode = getOtherSubfieldCode(subfieldCode);
-    const subfieldValues1 = field1.subfields.filter(subfield => subfield.code === subfieldCode).map(sf => sf.value);
-    const subfieldValues2 = field2.subfields.filter(subfield => subfield.code === subfieldCode).map(sf => sf.value);
-    // Assume that at least 1 instance must exist and that all instances must match
-    if (subfieldValues1.length !== subfieldValues2.length) {
-      debugDev(`mSC: Unique key: subfield ${subfieldCode} issues...`);
-      return false;
-    }
-
-    return subfieldValues1.every(value => subfieldValues2.includes(value));
-  }
+  // If base has $a and source has $b, there's no common nominator, thus fail...
+  const subfields1 = field1.subfields.filter(subfield => subfield.code === subfieldCode && valueCarriesMeaning(field1.tag, subfield.code, subfield.value));
+  const subfields2 = field2.subfields.filter(subfield => subfield.code === subfieldCode && valueCarriesMeaning(field2.tag, subfield.code, subfield.value));
 
+  return subfields1.length > 0 && subfields2.length > 0;
 }
 
 function tagToRegexp(tag, internalMerge = false) {
@@ -334,7 +190,7 @@ function tagToRegexp(tag, internalMerge = false) {
 }
 
 function areRequiredSubfieldsPresent(field) {
-  const subfieldString = getMergeConstraintsForTag(field.tag, 'required');
+  const subfieldString = getMergeConstraintsForTag(field.tag, 'required').join('');
   if (subfieldString === null) {
     return true;
   } // nothing is required
@@ -349,18 +205,31 @@ function areRequiredSubfieldsPresent(field) {
   });
 }
 
-function arePairedSubfieldsInBalance(field1, field2) {
-  const subfieldString = getMergeConstraintsForTag(field1.tag, 'paired');
-  if (subfieldString === null) {
-    return true;
+function getUnbalancedPairedSubfieldCode(field1, field2) {
+  const fullSubfieldString = getMergeConstraintsForTag(field1.tag, 'paired').join('') || '';
+
+  if (fullSubfieldString === '') {
+    return false;
+  }
+
+  // If the two fields share the FIN11 ID (WE SHOULD SUPPORT FIN13 AS WELL) there's no need to check the 'paired' constraint regarding related subfields.
+  // Meaning that it this is FIN11 match we should not bother checking whether something like 100$b/c/d/q is there. (NB! Note that 'required' check is not alleviated in this way)
+  // (I'm not saying that 100$b/c/d/q  are in 'paired' contraint, I'm just illustrating the issue here)
+  const pairable = pairableIdentifier(field1, field2, '(FIN11)');
+  const subfieldString = pairable ? removeNameRelatedSubfieldCodes(fullSubfieldString, field1.tag) : fullSubfieldString;
+  debug(`CHECK ${pairable ? 'PAIRABLE ' : ''}${field1.tag} PAIRS: '${fullSubfieldString}' => '${subfieldString}'`);
+
+  if (subfieldString === '') {
+    return false;
   }
   const subfieldArray = subfieldString.split('');
 
-  return subfieldArray.every(sfcode => fieldHasNSubfields(field1, sfcode) === fieldHasNSubfields(field2, sfcode));
+  return subfieldArray.find(sfcode => fieldHasNSubfields(field1, sfcode) !== fieldHasNSubfields(field2, sfcode));
 }
 
 function syntacticallyMergablePair(baseField, sourceField, config) {
   // Indicators must typically be equal (there are exceptions such as non-filing characters though):
+  nvdebug("CHECK SYNTAX");
   if (!mergableIndicator1(baseField, sourceField, config)) {
     nvdebug(`non-mergable (reason: indicator1): ${JSON.stringify(config)}`, debugDev);
     return false;
@@ -390,8 +259,9 @@ function syntacticallyMergablePair(baseField, sourceField, config) {
   }
 
   // Stuff of Hacks! Eg. require that both fields either have or have not X00$t:
-  if (!arePairedSubfieldsInBalance(baseField, sourceField)) {
-    nvdebug('required subfield pair check failed.', debugDev);
+  const subfieldCodeThatFailsToPair = getUnbalancedPairedSubfieldCode(baseField, sourceField);
+  if (subfieldCodeThatFailsToPair) {
+    nvdebug(`non-mergable (reason: required subfield pair check failed for code: '${subfieldCodeThatFailsToPair}')`, debugDev);
     return false;
   }
 
@@ -400,6 +270,7 @@ function syntacticallyMergablePair(baseField, sourceField, config) {
 
 function mergablePair(baseField, sourceField, config) {
   if (!syntacticallyMergablePair(baseField, sourceField, config)) {
+    nvdebug('non-mergable (reason: syntax)', debugDev);
     return false;
   }
 
@@ -413,41 +284,56 @@ function mergablePair(baseField, sourceField, config) {
   return true;
 }
 
+function removeNameRelatedSubfieldCodes(codestring, tag) {
+  // If we have $0 (FIN11) match, we are not interested in the core name subfields. Remove them from the subfield codes string.
+  const removables = getNameRelatedSubfieldCodes(tag); // These are different for X00, X10 and X11...
+  return removeCharsFromString(codestring, removables);
 
-function pairableAsteriIDs(baseField, sourceField) {
-  //nvdebug(`ASTERI1 ${fieldToString(baseField)}`, debugDev); // eslint-disable-line
-  //nvdebug(`ASTERI2 ${fieldToString(sourceField)}`, debugDev); // eslint-disable-line
+  function removeCharsFromString(string, removableCharsAsString) {
+    const removableChars = removableCharsAsString.split('');
+    return string.split('').filter(c => !removableChars.includes(c)).join('');
+  }
 
-  // Check that relevant control subfield(s) exist in both records (as controlSubfieldsPermitMerge() doesn't check it):
-  const fin11a = getAsteriIDs(baseField);
-  if (fin11a.length === 0) {
-    return false;
+  function getNameRelatedSubfieldCodes(tag) {
+    if (['100', '600', '700', '800'].includes(tag)) {
+      return 'abcdq';
+    }
+    if (['110', '610', '710', '810'].includes(tag)) {
+      return 'abcdn';
+    }
+    if (['111', '611', '711', '811'].includes(tag)) {
+      return 'acden';
+    }
+    return '';
   }
-  const fin11b = getAsteriIDs(sourceField);
-  if (fin11b.length === 0) {
+}
+
+function pairableIdentifier(field1, field2, prefix) {
+  const normalizedPrefix = prefix;
+  nvdebug(`PREF '${prefix}' => '${normalizedPrefix}'`);
+
+  const prefixLength = normalizedPrefix.length;
+  const identifiers1 = getIdentifiers(field1);
+  if (identifiers1.length !== 1) {
     return false;
   }
-  //nvdebug(`ASTERI WP3:\n${fin11a.join(", ")}\n${fin11b.join(", ")}`, debugDev); // eslint-disable-line
-
-  // Check that found control subfields agree. Use pre-existing generic function to reduce code.
-  // (NB! We could optimize and just return true here, as control subfield check is done elsewhere as well.
-  // However, explicitly checking them here makes the code more robust.)
-  if (!controlSubfieldsPermitMerge(baseField, sourceField)) {
+  const identifiers2 = getIdentifiers(field2);
+  if (identifiers2.length !== 1) {
     return false;
   }
-  //console.log(`ASTERI PAIR ${fieldToString(sourceField)}`); // eslint-disable-line
-  return true;
 
-  // NB! This boldly assumes that the default prefix for Asteri is '(FIN11)', not '(FI-ASTERI-N)' nor a finaf urn...
-  function getAsteriIDs(field) {
+  return identifiers1[0] === identifiers2[0];
+
+  function getIdentifiers(field) {
     return field.subfields.filter(sf => sf.code === '0')
       .map(sf => normalizeControlSubfieldValue(sf.value))
-      .filter(val => val.substring(0, 7) === '(FIN11)');
+      .filter(val => val.substring(0, prefixLength) === normalizedPrefix);
   }
 }
 
 
 function hasRepeatableSubfieldThatShouldBeTreatedAsNonRepeatable(field) {
+  // 700$s?
   if (field.tag === '260' || field.tag === '264') {
     return ['a', 'b', 'c', 'e', 'f', 'g'].some(subfieldCode => fieldHasMultipleSubfields(field, subfieldCode));
   }
@@ -461,134 +347,149 @@ function hasRepeatableSubfieldThatShouldBeTreatedAsNonRepeatable(field) {
   return false;
 }
 
-function pairableName(baseField, sourceField) {
-  // 100$a$t: remove $t and everything after that
-  const reducedField1 = fieldToNamePart(baseField);
-  const reducedField2 = fieldToNamePart(sourceField);
+function getRelevantSubfieldValues(field, subfieldCode) {
+  const values = field.subfields.filter(sf => sf.code === subfieldCode).map(sf => counterpartExtraNormalize(field.tag, subfieldCode, sf.value));
 
-  const string1 = fieldToString(reducedField1);
-  const string2 = fieldToString(reducedField2);
+  return values.filter(v => valueCarriesMeaning(field.tag, subfieldCode, v));
+}
 
-  //nvdebug(`IN: pairableName():\n '${string1}' vs\n '${string2}'`, debugDev);
-  if (string1 === string2) {
+function pairableValue(tag, subfieldCode, value1, value2) {
+  if (value1 === value2) {
     return true;
   }
 
-  // Essentially these are too hard to handle with field-merge (eg. multi-505$g)
-  if (hasRepeatableSubfieldThatShouldBeTreatedAsNonRepeatable(reducedField1) || hasRepeatableSubfieldThatShouldBeTreatedAsNonRepeatable(reducedField2)) {
-    return false;
-  }
-
-  // Compare the remaining subsets...
-  // First check that name matches...
-  if (uniqueKeyMatches(reducedField1, reducedField2)) {
-    nvdebug(`    name match: '${fieldToString(reducedField1)}'`, debugDev);
+  // This function could just return true or false.
+  // I thought of preference when I wrote this, but preference implemented *here* (modularity). mergeFields.js should handle preference.
+  if (withAndWithoutQualifierAgree(value1, value2, tag, subfieldCode)) {
+    // 300$a "whatever" and "whatever (123 sivua)"
     return true;
   }
-
-  // However, name mismatch is not critical! If Asteri ID matches, it's still a match! *NOT* sure whether this a good idea.
-  // 2023-01-24 Disable this. Caretaker can fix these later on. Not a job for merge. We can't be sure that $0 pair is corrent, nor which version (base or source) to use.
-  // 2023-03-07: Enable this again!
-  if (pairableAsteriIDs(baseField, sourceField)) {
-    //nvdebug(`    name match based on ASTERI $0'`, debugDev);
+  if (partsAgree(value1, value2, tag, subfieldCode) || corporateNamesAgree(value1, value2, tag, subfieldCode)) {
+    // Pure baseness: here we assume that base's value1 is better than source's value2.
     return true;
   }
 
-  nvdebug(`    name mismatch:`, debugDev);
-  nvdebug(`     '${fieldToString(reducedField1)}' vs`, debugDev);
-  nvdebug(`     '${fieldToString(reducedField2)}'`, debugDev);
   return false;
 }
 
+function pairableValueInArray(tag, subfieldCode, val, arr) {
+  return arr.some(val2 => pairableValue(tag, subfieldCode, val, val2));
+}
 
-function semanticallyMergablePair(baseField, sourceField) {
-  // On rare occasions a field contains also a title part. For these name part (= normally everything) and title part
-  // must be checked separately:
-  if (!titlePartsMatch(baseField, sourceField)) {
-    nvdebug(` ${baseField.tag} is unmergable: Title part mismatch.`, debugDev);
-    return false;
-  }
 
-  // Hmm... we should check lifespan here, $d YYYY
+function tightSubfieldMatch(field1, field2, subfieldCode, mustHave = false) {
+  nvdebug(`${subfieldCode} F1: ${fieldToString(field1)}`);
+  nvdebug(`${subfieldCode} F2: ${fieldToString(field2)}`);
+  const values1 = getRelevantSubfieldValues(field1, subfieldCode);
+  const values2 = getRelevantSubfieldValues(field2, subfieldCode);
 
-  // Handle the field specific "unique key" (=set of fields that make the field unique
-  if (!pairableName(baseField, sourceField)) {
-    nvdebug('Unmergable: Name part mismatch', debugDev);
+  if(!mustHave) {
+    if (values1.length === 0 || values2.length === 0) {
+      return true;
+    }
+  }
+
+  if (values1.length !== values2.length) {
     return false;
   }
-  //debug(' Semantic checks passed! We are MERGABLE!');
 
-  return true;
+  nvdebug(`Compare $${subfieldCode} contents:\n  '${values1.join("'\n  '")}' vs\n  '${values2.join("'\n  '")}'`);
+  return values1.every(v => pairableValueInArray(field1.tag, subfieldCode, v, values2)) && values2.every(v => pairableValueInArray(field1.tag, subfieldCode, v, values1));
 }
 
-
-function namePartThreshold(field) {
-  // Threshold is only applicaple to some tags..
-  if (!(/[10]0$/u).test(field.tag)) {
-    return -1;
+function looseSubfieldMatch(field1, field2, subfieldCode) {
+  const values1 = getRelevantSubfieldValues(field1, subfieldCode);
+  const values2 = getRelevantSubfieldValues(field2, subfieldCode);
+  if (values1.length === 0 || values2.length === 0) {
+    return true;
   }
-  const t = field.subfields.findIndex(currSubfield => currSubfield.code === 't');
-  const u = t; // field.subfields.findIndex(currSubfield => currSubfield.code === 'u');
-  if (t === -1) {
-    return u;
+  // Subsets are fine:
+  if (values1.every(v => pairableValueInArray(field1.tag, subfieldCode, v, values2))) {
+    return true;
   }
-  if (u === -1) {
-    return t;
+  if (values2.every(v => pairableValueInArray(field1.tag, subfieldCode, v, values1))) {
+    return true;
   }
-  return t > u ? u : t;
+  return false;
 }
 
-function fieldToNamePart(field) {
-  const index = namePartThreshold(field);
-  const relevantSubfields = field.subfields.filter((sf, i) => i < index || index === -1).filter(sf => !irrelevantSubfieldsInNameAndTitlePartComparison.includes(sf.code));
+function semanticallyMergablePair(baseField, sourceField) {
+  const field1 = cloneAndNormalizeFieldForComparison(baseField);
+  const field2 = cloneAndNormalizeFieldForComparison(sourceField);
 
-  const subsetField = {'tag': field.tag, 'ind1': field.ind1, 'ind2': field.ind2, subfields: relevantSubfields};
+  const string1 = fieldToString(field1);
+  const string2 = fieldToString(field2);
 
-  /*
-  if (index > -1) {
-    debugDev(`Name subset: ${fieldToString(subsetField)}`);
+  nvdebug(`IN ${baseField.tag}: pairableName():\n '${string1}' vs\n '${string2}'`, debugDev);
+  if (string1 === string2) {
+    return true;
   }
-  */
 
-  // Ummm... Sometimes $0 comes after $t but belongs to name part
+  const mergeConstraints = getMergeConstraintsForTag(field1.tag); // The tag doe
+  if (mergeConstraints.length === 0) { // We have no constraints defined for this tag -> fail
+    return false;
+  }
 
-  return subsetField;
-}
+  // Essentially these are too hard to handle with field-merge (eg. multi-505$g)
+  if (hasRepeatableSubfieldThatShouldBeTreatedAsNonRepeatable(field1) || hasRepeatableSubfieldThatShouldBeTreatedAsNonRepeatable(field2)) {
+    nvdebug(`Unmergable: data is too complex to be automatically safely merged`, debugDev);
+    return false;
+  }
 
-function fieldToTitlePart(field) {
-  // Take everything after 1st subfield $t...
-  const index = field.subfields.findIndex(currSubfield => currSubfield.code === 't');
-  const relevantSubfields = field.subfields.filter((sf, i) => i >= index).filter(sf => !irrelevantSubfieldsInNameAndTitlePartComparison.includes(sf.code));
-  const subsetField = {'tag': field.tag, 'ind1': field.ind1, 'ind2': field.ind2, subfields: relevantSubfields};
-  debugDev(`Title subset: ${fieldToString(subsetField)}`);
-  return subsetField;
-}
+  const asteriMatch = pairableIdentifier(field1, field2, '(FIN11)'); // If there's a match, there's no need to check the name (Caretaker will handle these.)
+  // WE COULD REMOVE THESE FIELDS IN MERGE, SO THAT WE WON'T GET FUNNY NAMES).
 
-function containsTitlePart(field) {
-  return fieldCanHaveTitlePart(field) && fieldHasSubfield(field, 't');
+  // NB! Currently we should get only one mergeContraint. However, should we support multiple merge contraints (= multiple profiles)?
+  const allRequired = mergeConstraints[0].required || ''; // getMergeConstraintsForTag(field1.tag, 'required') || '';
+  const reallyRequired = asteriMatch ? removeNameRelatedSubfieldCodes(allRequired, field1.tag) : allRequired;
 
-  function fieldCanHaveTitlePart(field) {
-    return ['100', '110', '111', '700', '710', '711'].includes(field.tag);
+  //nvdebug(`WP1: '${allRequired}' => ${reallyRequired}`);
+  if (!reallyRequired.split('').every(c => tightSubfieldMatch(field1, field2, c, true))) {
+    return false;
   }
-}
 
-function titlePartsMatch(field1, field2) {
-  if (!containsTitlePart(field1)) {
-    return !containsTitlePart(field2);
+  const allPaired = mergeConstraints[0].paired || ''; // getMergeConstraintsForTag(field1.tag, 'paired') || '';
+  const reallyPaired = asteriMatch ? removeNameRelatedSubfieldCodes(allPaired, field1.tag) : allPaired;
+  //nvdebug(`WP2: '${allPaired}' => ${reallyPaired}`);
+  if (!reallyPaired.split('').every(c => tightSubfieldMatch(field1, field2, c, false))) {
+    return false;
   }
-  if (!containsTitlePart(field2)) {
+
+  const allKeys = mergeConstraints[0].key || ''; // getMergeConstraintsForTag(field1.tag, 'key') || '';
+  const relevantKeys = asteriMatch ? removeNameRelatedSubfieldCodes(allKeys, field1.tag) : allKeys
+  //nvdebug(`WP3: keys='${allKeys}' => ${relevantKeys}`);
+  if (!relevantKeys.split('').every(c => looseSubfieldMatch(field1, field2, c))) {
     return false;
   }
+  //nvdebug('WP4');
+
+  // required/paired/keys checks did not fail. Now check that did they really succeed
+  if (allRequired.length > 0) { // I think we should use all here
+    return true;
+  }
 
-  debugDev(`TITLE PARTS NEED TO BE COMPARED`);
+  if (reallyPaired.length > 0 && field1.subfields.some(sf => reallyPaired.includes(sf.code))) {
+    return true;
+  }
 
-  // 100$a$t: remove $t and everything after that
-  const subset1 = fieldToTitlePart(field1);
-  const subset2 = fieldToTitlePart(field2);
-  // Easter Egg, ffs. Hardcoded exception
-  return mandatorySubfieldComparison(subset1, subset2, 'dfhklmnoprstxvg');
-}
+  if(!tagIsRepeatable(field1.tag) || relevantKeys.length == 0) {
+    return true;
+  }
 
+  // Raison d'être is long forgotten, but my educated guess about this: if 'key' is defined in merge constraints
+  // for this field, then at least one of the subfield codes in 'key' must be present in both fields.
+  // However, this is not necessarily right.
+  if (relevantKeys.length > 0) {
+    if (field1.subfields.some(sf => relevantKeys.includes(sf.code)) || field2.subfields.some(sf => relevantKeys.includes(sf.code))) { 
+      return relevantKeys.split('').some(code => hasCommonNominator(field1, field2, code));
+    }
+  }
+
+  nvdebug(`    name mismatch (${keys}):`, debugDev);
+  nvdebug(`     '${fieldToString(baseField)}' vs`, debugDev);
+  nvdebug(`     '${fieldToString(sourceField)}'`, debugDev);
+  return false;
+}
 
 function getAlternativeNamesFrom9XX(record, field) {
   // Should we support 6XX and 8XX as well? Prolly not...
@@ -647,7 +548,6 @@ function getCounterpartIndex(field, counterpartCands, altNames, config) {
 
 
 function field264Exception(baseField, sourceRecord, sourceField, config) {
-  nvdebug('Field 264 exception as per MET-456', debugDev);
   if (baseField.tag !== '264') {
     return false;
   }
@@ -675,6 +575,7 @@ function getCounterpartCandidates(field, record) {
   function isCopyrightField264(field) {
     return field.tag === '264' && field.ind2 === '4';
   }
+
   function isNotCopyrightYear(field) {
     if (field.tag === '264') {
       return !isCopyrightField264(field);
@@ -710,19 +611,10 @@ export function getCounterpart(baseRecord, sourceRecord, field, config) {
 
   const normalizedField = cloneAndNormalizeFieldForComparison(field); // mainly strip punctuation here
 
-  nvdebug(`Norm to: '${fieldToString(normalizedField)}'`, debugDev);
+  nvdebug(` Normalize incoming field to: '${fieldToString(normalizedField)}'`, debugDev);
 
   const uniqueAlternativeNames = getUniqueAlernativeNames();
 
-  function getUniqueAlernativeNames() {
-    if (baseIsSource(baseRecord, sourceRecord)) {
-      return [];
-    }
-    // Try to look for alternative names from base and source record's 9XX fields:
-    const alternativeNames = getAlternativeNamesFrom9XX(baseRecord, field).concat(getAlternativeNamesFrom9XX(sourceRecord, field));
-    return alternativeNames.filter((name, i) => alternativeNames.indexOf(name) === i);
-  }
-
   //nvdebug(` S: ${fieldToString(normalizedField)}`, debugDev);
   // Then find (the index of) the first mathing candidate field and return it.
   const index = getCounterpartIndex(normalizedField, counterpartCands, uniqueAlternativeNames, config);
@@ -737,5 +629,14 @@ export function getCounterpart(baseRecord, sourceRecord, field, config) {
   }
 
   return null;
+
+  function getUniqueAlernativeNames() {
+    if (baseIsSource(baseRecord, sourceRecord)) {
+      return [];
+    }
+    // Try to look for alternative names from base and source record's 9XX fields:
+    const alternativeNames = getAlternativeNamesFrom9XX(baseRecord, field).concat(getAlternativeNamesFrom9XX(sourceRecord, field));
+    return alternativeNames.filter((name, i) => alternativeNames.indexOf(name) === i);
+  }
 }