@natlibfi/marc-record-validators-melinda 11.4.8 → 11.5.0-alpha.1

package/src/disambiguateSeriesStatements.js

@@ -0,0 +1,228 @@
+import createDebugLogger from 'debug';
+import {fieldToString, nvdebug, subfieldToString} from './utils';
+import {MARCXML} from '@natlibfi/marc-record-serializers';
+import {Error} from '@natlibfi/melinda-commons';
+import clone from 'clone';
+import {default as createNatlibfiSruClient} from '@natlibfi/sru-client';
+import {fieldFixPunctuation} from './punctuation2';
+
+//const {default: createNatlibfiSruClient} = natlibfiSruClient;
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:disambiguateSeriesStatements');
+
+const ELECTRONIC = 1;
+const PRINTED = 2;
+const NEITHER_OR_UNKNOWN = 0;
+const SRU_API_URL = 'https://sru.api.melinda.kansalliskirjasto.fi/bib';
+
+// Author(s): Nicholas Volk
+export default function () {
+  const sruClient = createSruClient(SRU_API_URL);
+
+  return {
+    description: 'Disambiguate between printed and electonic series statements (490 with multiple $xs)',
+    validate, fix
+  };
+
+  async function fix(record) {
+    const recordType = getRecordType(record);
+
+    const relevantFields = getRelevantFields(record.fields);
+    const message = await fix490x(recordType, relevantFields, true);
+
+    return {message, fix: [], valid: true};
+  }
+
+  async function validate(record) {
+    const recordType = getRecordType(record);
+
+    const relevantFields = getRelevantFields(record.fields);
+    const message = await fix490x(recordType, relevantFields, false);
+
+    return {message, valid: message.length === 0};
+  }
+
+
+  function getValidIssnSubfields(field) {
+    const subfields = field.subfields?.filter(sf => sf.code === 'x' && sf.value.match(/^[0-9]{4}-[0-9][0-9][0-9][0-9Xx][^0-9Xx]*$/u));
+    return subfields;
+  }
+
+  function isRelevantField(field) {
+    if (field.tag !== '490') {
+      return false;
+    }
+    return getValidIssnSubfields(field).length > 1;
+  }
+
+  function getRelevantFields(fields) {
+    return fields.filter(f => isRelevantField(f));
+  }
+
+  async function fix490x(recordType, fields, reallyFix, message = []) {
+
+    if (recordType === NEITHER_OR_UNKNOWN) {
+      return message;
+    }
+    const [currField, ...remainingFields] = fields;
+
+    if (!currField) {
+      return message;
+    }
+
+    const validXs = getValidIssnSubfields(currField);
+
+    const deletableXs = await getRemovableSubfields(validXs, recordType);
+
+    if (deletableXs.length === 0 || deletableXs.length === validXs.length) {
+      return fix490x(recordType, remainingFields, reallyFix, message);
+    }
+
+    const deletableStrings = deletableXs.map(sf => subfieldToString(sf));
+    nvdebug(`Field has removable ISSNS: '${deletableStrings.join(', ')}`, debug);
+
+    // fixer:
+    if (reallyFix) {
+      currField.subfields = currField.subfields.filter(sf => !deletableStrings.includes(subfieldToString(sf))); // eslint-disable-line functional/immutable-data
+      fieldFixPunctuation(currField);
+      return fix490x(recordType, remainingFields, reallyFix, message);
+    }
+    // validators:
+    const clonedField = clone(currField);
+    const originalString = fieldToString(clonedField);
+    clonedField.subfields = clonedField.subfields.filter(sf => !deletableStrings.includes(subfieldToString(sf))); // eslint-disable-line functional/immutable-data
+
+    const newMessage = `Replace '${originalString}' with '${fieldToString(clonedField)}'`;
+
+    return fix490x(recordType, remainingFields, reallyFix, [...message, newMessage]);
+  }
+
+  async function getRemovableSubfields(validXs, recordType, removables = []) {
+    const [currSubfield, ...remainingXs] = validXs;
+
+    if (!currSubfield) {
+      return removables;
+    }
+
+    const isRemoveable = await isRemovableSubfield(currSubfield, recordType);
+    if (isRemoveable) {
+      return getRemovableSubfields(remainingXs, recordType, [...removables, currSubfield]);
+    }
+    return getRemovableSubfields(remainingXs, recordType, removables);
+  }
+
+  async function isRemovableSubfield(subfield, recordType) {
+    //console.info(` isRemovableField() in...`); // eslint-disable-line no-console
+    const issn = subfield.value.substring(0, 9); // Strip punctuation (ISSN consists of nine letter, eg. "1234-5678")
+
+    //console.info(` got ISSN ${issn}`); // eslint-disable-line no-console
+    const issnRecords = await issnToRecords(issn);
+    //console.info(` ISSN returned ${issnRecords.length} record(s)`); // eslint-disable-line no-console
+
+    // !isMismatchingRecord !== isMatchingRecord as NEITHER_OR_UNKNOWN record type is neutral. Thus double negative "not mismatch". Sorry about that.
+    if (issnRecords.some(r => !isMismatchingRecord(r))) {
+      return false;
+    }
+    return true;
+
+    function isMismatchingRecord(r) {
+      const issnRecordType = getRecordType(r);
+      if (issnRecordType === NEITHER_OR_UNKNOWN) {
+        return false;
+      }
+      return issnRecordType !== recordType;
+    }
+  }
+
+  async function issnToRecords(issn) {
+    //console.log('issnToRecords() in...'); // eslint-disable-line no-console
+    const records = await search(sruClient, `bath.issn=${issn}`);
+    //console.log(`ISSN2RECORDS got ${records.length} record(s)!`); // eslint-disable-line no-console
+    return records;
+  }
+
+  function getRecordType(record) {
+    const f337 = record.get('337');
+    if (f337.length !== 1) {
+      return NEITHER_OR_UNKNOWN;
+    }
+
+    const b = f337[0].subfields.filter(sf => sf.code === 'b');
+    if (b.length !== 1) {
+      return NEITHER_OR_UNKNOWN;
+    }
+
+    if (b[0].value === 'c') {
+      return ELECTRONIC;
+    }
+
+    if (b[0].value === 'n') {
+      return PRINTED;
+    }
+
+    return NEITHER_OR_UNKNOWN;
+  }
+
+}
+
+// All the code below is copypasted from melinda-ui-artikkelit project file src/services/sruServices/sruClient.js
+
+export function createSruClient(sruApiUrl) {
+
+  const sruClientOptions = {
+    url: sruApiUrl,
+    recordSchema: 'marcxml',
+    retrieveAll: false,
+    maxRecordsPerRequest: 100
+  };
+
+  return createNatlibfiSruClient(sruClientOptions);
+}
+
+
+/*******************************************************************************/
+/* Search and retrieve (copypaste from melinda-ui-artikkelit)                  */
+
+export function search(sruClient, query, one = false) {
+
+  return new Promise((resolve, reject) => {
+    const promises = [];
+
+    const noValidation = {
+      fields: false,
+      subfields: false,
+      subfieldValues: false
+    };
+
+    // console.info(`SRU query: $${searchUrl}`);
+
+    sruClient.searchRetrieve(query)
+      .on('record', xmlString => {
+        promises.push(MARCXML.from(xmlString, noValidation)); // eslint-disable-line functional/immutable-data
+      })
+      .on('end', async () => {
+        try {
+
+          if (promises.length > 0) {
+
+            if (one) {
+              const [firstPromise] = promises;
+              const firstRecord = await firstPromise;
+              return resolve(firstRecord);
+            }
+
+            const records = await Promise.all(promises);
+            return resolve(records);
+          }
+          reject(new Error(404, 'No records found with search and retrieve'));
+
+        } catch (error) {
+          reject(error);
+        }
+      })
+      .on('error', error => {
+        reject(error);
+      });
+  });
+}
+

package/src/disambiguateSeriesStatements.spec.js

@@ -0,0 +1,52 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './disambiguateSeriesStatements';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import createDebugLogger from 'debug';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'disambiguate-series-statements'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/disambiguateSeriesStatements:test');
+
+async function testValidatorFactory() {
+  const validator = await validatorFactory();
+
+  expect(validator)
+    .to.be.an('object')
+    .that.has.any.keys('description', 'validate');
+
+  expect(validator.description).to.be.a('string');
+  expect(validator.validate).to.be.a('function');
+}
+
+async function callback({getFixture, enabled = true, fix = false}) {
+  if (enabled === false) {
+    debug('TEST SKIPPED!');
+    return;
+  }
+
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    expect(result).to.eql(expectedResult);
+    return;
+  }
+
+  await validator.fix(record);
+  expect(record).to.eql(expectedResult);
+}

package/src/fix-country-codes.spec.js

@@ -17,7 +17,7 @@ generateTests({
     before: () => testValidatorFactory()
   }
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/fix-country-codestest');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/fix-country-codes:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();

package/src/index.js

@@ -5,6 +5,7 @@ import AddMissingField337 from './addMissingField337';
 import AddMissingField338 from './addMissingField338';
 import Cyrillux from './cyrillux';
 import CyrilluxUsemarconReplacement from './cyrillux-usemarcon-replacement';
+import DisambiguateSeriesStatements from './disambiguateSeriesStatements';
 import DoubleCommas from './double-commas';
 import DuplicatesInd1 from './duplicates-ind1';
 import EmptyFields from './empty-fields';
@@ -64,6 +65,7 @@ export {
   AddMissingField338,
   Cyrillux,
   CyrilluxUsemarconReplacement,
+  DisambiguateSeriesStatements,
   DoubleCommas,
   DuplicatesInd1,
   EmptyFields,

package/src/merge-fields/mergeField.js

@@ -1,8 +1,8 @@
 //import {MarcRecord} from '@natlibfi/marc-record';
 import createDebugLogger from 'debug';
-import {fieldHasSubfield, fieldToString, fieldsToString, fieldsAreIdentical, nvdebug, hasCopyright, removeCopyright, subfieldToString} from '../utils';
+import {fieldToString, fieldsToString, fieldsAreIdentical, nvdebug, hasCopyright, removeCopyright, subfieldToString} from '../utils';
 import {fieldGetOccurrenceNumberPairs} from '../subfield6Utils.js';
-import {cloneAndNormalizeFieldForComparison, cloneAndRemovePunctuation} from '../normalizeFieldForComparison';
+import {cloneAndNormalizeFieldForComparison, cloneAndRemovePunctuation, isEnnakkotietoSubfieldG} from '../normalizeFieldForComparison';
 import {mergeOrAddSubfield} from './mergeOrAddSubfield';
 import {mergeIndicators} from './mergeIndicator';
 import {mergableTag} from './mergableTag';
@@ -25,7 +25,7 @@ const debugDev = debug.extend('dev');
 
 // NB! Can be do this via config.json?
 function removeEnnakkotieto(field) {
-  const tmp = field.subfields.filter(subfield => subfield.code !== 'g' || subfield.value !== 'ENNAKKOTIETO.');
+  const tmp = field.subfields.filter(subfield => !isEnnakkotietoSubfieldG(subfield));
   // remove only iff some other subfield remains
   if (tmp.length > 0) { // eslint-disable-line functional/no-conditional-statements
     field.subfields = tmp; // eslint-disable-line functional/immutable-data
@@ -60,7 +60,7 @@ function mergeField2(baseRecord, baseField, sourceField, config, candFieldPairs8
   // If a base ennakkotieto is merged with real data, remove ennakkotieto subfield:
   // (If our prepub normalizations are ok, this should not be needed.
   //  However, it's simple and works well enough, so let's keep it here.)
-  if (fieldHasSubfield(baseField, 'g', 'ENNAKKOTIETO.') && !fieldHasSubfield(sourceField, 'g', 'ENNAKKOTIETO.')) { // eslint-disable-line functional/no-conditional-statements
+  if (baseField.subfields?.find(sf => isEnnakkotietoSubfieldG(sf)) && !sourceField.subfields?.find(sf => isEnnakkotietoSubfieldG(sf))) { // eslint-disable-line functional/no-conditional-statements
     removeEnnakkotieto(baseField);
     baseField.merged = 1; // eslint-disable-line functional/immutable-data
   }

package/src/merge-fields/mergeOrAddSubfield.js

@@ -1,5 +1,5 @@
 import createDebugLogger from 'debug';
-import {cloneAndNormalizeFieldForComparison} from '../normalizeFieldForComparison.js';
+import {cloneAndNormalizeFieldForComparison, isEnnakkotietoSubfieldG} from '../normalizeFieldForComparison.js';
 import {normalizeAs, normalizeControlSubfieldValue} from '../normalize-identifiers';
 import {fieldHasSubfield, fieldToString, isControlSubfieldCode, nvdebug, subfieldIsRepeatable, subfieldToString} from '../utils.js';
 import {mergeSubfield} from './mergeSubfield.js';
@@ -26,10 +26,10 @@ function catalogingSourceModifyingAgencyCandIsOriginalCatalogingSourceAgencyInTa
 }
 
 function ennakkotietoInSubfieldG(candSubfieldData) {
-  if (candSubfieldData.code === 'g' && ['ENNAKKOTIETO.', 'ENNAKKOTIETO'].includes(candSubfieldData.originalValue)) {
+  if (isEnnakkotietoSubfieldG({'code': candSubfieldData.code, 'value': candSubfieldData.originalValue})) {
     // Skip just ‡g subfield or the whole field?
     // We decided to skip just this subfield. We want at least $0 and maybe even more from ennakkotieto.
-    debugDev('Skip ‡g ENNAKKOTIETO.');
+    debugDev(`Skip '‡g ${candSubfieldData.originalValue}'`);
     return true;
   }
   return false;

package/src/merge-fields.spec.js

@@ -17,7 +17,7 @@ generateTests({
     before: () => testValidatorFactory()
   }
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/merge-field:test');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/merge-fields:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();

package/src/normalize-identifiers.js

@@ -2,7 +2,7 @@
 //import createDebugLogger from 'debug';
 import clone from 'clone';
 import {fieldToString} from './utils';
-//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normalizeIdentifiers');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normalize-identifiers');
 
 /*
 function nvdebug(message, func) {

package/src/normalizeFieldForComparison.js

@@ -14,10 +14,17 @@ import {fieldNormalizeControlNumbers/*, normalizeControlSubfieldValue*/} from '.
 import createDebugLogger from 'debug';
 import {normalizePartData, subfieldContainsPartData} from './normalizeSubfieldValueForComparison';
 
-const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:normalize');
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:normalizeFieldForComparison');
 //const debugData = debug.extend('data');
 const debugDev = debug.extend('dev');
 
+export function isEnnakkotietoSubfieldG(subfield) {
+  if (subfield.code !== 'g') {
+    return false;
+  }
+  return subfield.value.match(/^ENNAKKOTIETO\.?$/gu);
+}
+
 function debugFieldComparison(oldField, newField) { // NB: Debug-only function!
   /*
   // We may drop certain subfields:
@@ -62,12 +69,10 @@ function containsCorporateName(tag = '???', subfieldCode = undefined) {
 
 function skipAllSubfieldNormalizations(value, subfieldCode, tag) {
 
-
-  if (subfieldCode === 'g' && value === 'ENNAKKOTIETO.') {
+  if (isEnnakkotietoSubfieldG({'code': subfieldCode, value})) {
     return true;
   }
 
-
   if (tag === '035' && ['a', 'z'].includes(subfieldCode)) { // A
     return true;
   }

package/src/normalizeSubfieldValueForComparison.js

@@ -3,7 +3,7 @@ import createDebugLogger from 'debug';
 
 // Normalizes at least 490$v and 773$g which contain information such as "Raita 5" vs "5", and "Osa 3" vs "Osa III".
 
-const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:normalizePart');
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:normalizeSubfieldValueForComparison');
 //const debugData = debug.extend('data');
 const debugDev = debug.extend('dev');
 

package/src/prepublicationUtils.js

@@ -24,7 +24,12 @@ export function encodingLevelIsBetterThanPrepublication(encodingLevel) {
 }
 
 
-function containsSubstringInSubfieldA(field, substring) {
+function containsSubstringInSubfieldA(field, substring, ignoreCase = false) {
+  if (ignoreCase) {
+    const lowercasedSubstring = substring.toLowerCase();
+    return field.subfields.some(sf => sf.code === 'a' && sf.value.toLowerCase().includes(lowercasedSubstring));
+
+  }
   return field.subfields.some(sf => sf.code === 'a' && sf.value.includes(substring));
 }
 
@@ -36,14 +41,16 @@ export function fieldRefersToKoneellisestiTuotettuTietue(field) {
 
 
 export function fieldRefersToTarkistettuEnnakkotieto(field) {
-  return containsSubstringInSubfieldA(field, 'TARKISTETTU ENNAKKOTIETO');
+  return containsSubstringInSubfieldA(field, 'TARKISTETTU ENNAKKOTIETO', true);
 }
 
 
 export function fieldRefersToEnnakkotieto(field) {
   // NB! This no longer matches 'TARKISTETTU ENNAKKOTIETO' case! Bug or Feature?
-  if (containsSubstringInSubfieldA(field, 'ENNAKKOTIETO') && !fieldRefersToTarkistettuEnnakkotieto(field)) {
-    return true;
+  if (!fieldRefersToTarkistettuEnnakkotieto(field)) {
+    if (containsSubstringInSubfieldA(field, 'ENNAKKOTIETO', true)) {
+      return true;
+    }
   }
   // MRA-420: "EI VIELÄ ILMESTYNYT" is a Helmet note, that is semantically similar to ENNAKKOTIETO:
   return containsSubstringInSubfieldA(field, 'EI VIELÄ ILMESTYNYT');
@@ -75,6 +82,7 @@ export function firstFieldHasBetterPrepubEncodingLevel(field1, field2) {
 
 /*
 function hasEnnakkotietoSubfield(field) {
+  // NB! This has apparently changed to lower case 'ennakkotieto'...
   return field.subfields.some(sf => ['g', '9'].includes(sf.code) && sf.value.includes('ENNAKKOTIETO'));
 }
 */
@@ -229,8 +237,11 @@ export function isEnnakkotietoSubfield(subfield) {
     return false;
   }
   // Length <= 13 allows punctuation, but does not require it:
-  if (subfield.value.substr(0, 12) === 'ENNAKKOTIETO' && subfield.value.length <= 13) {
-    return true;
+  if (subfield.value.length <= 13) {
+    const coreString = subfield.value.substr(0, 12);
+    if (coreString === 'ENNAKKOTIETO' || coreString === 'ennakkotieto') { // Lowercase term first seen in MET-575
+      return true;
+    }
   }
   return false;
 }

package/src/removeInferiorDataFields.js

@@ -12,7 +12,7 @@ import {fixComposition, precomposeFinnishLetters} from './normalize-utf8-diacrit
 // NB! This validator handles only full fields, and does not support subfield $8 removal.
 // Also, having multiple $8 subfields in same fields is not supported.
 // If this functionality is needed, see removeDuplicateDatafields.js for examples of subfield-only stuff.
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:removeSubsetDataFields');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:removeInferiorDataFields');
 
 export default function () {
   return {
@@ -233,7 +233,25 @@ function deriveIndividualDeletables(record) {
 
   const deletableStringsArray = processTodoList(todoList);
 
-  return uniqArray(deletableStringsArray);
+  const inferiorTerms = getInferiorTerms(record);
+
+  return uniqArray([...deletableStringsArray, ...inferiorTerms]);
+
+  function getInferiorTerms(record) {
+    const inputFields = record.fields.filter(f => ['648', '650', '651'].includes(f.tag) && f.subfields);
+    const result = inputFields.flatMap(f => fieldToInferiorFields(f));
+
+    // console.log(result.join('\n')); // eslint-disable-line no-console
+    return result;
+  }
+
+  function fieldToInferiorFields(field) {
+    const aArray = field.subfields.filter(sf => sf.code === 'a');
+    if (field.tag === '650') {
+      return aArray.flatMap(sf => [`653 ## ‡a ${sf.value}`, `653 #0 ‡a ${sf.value}`]);
+    }
+    return aArray.map(sf => `653 ## ‡a ${sf.value}`);
+  }
 
   function processTodoList(thingsToDo, deletables = []) {
     const [currString, ...stillToDo] = thingsToDo;
@@ -297,10 +315,10 @@ function deriveIndividualDeletables(record) {
       return processTodoList([...stillToDo, ...moreToDo], [...deletables, tmp]);
     }
 
+    // MET-575 (merge: applies in postprocessing)
+    const inferiorTerms = getPrepublicationTerms(currString);
 
-    const ennakkotieto653 = currString.match(/^653./u) ? [`${currString} ‡g ENNAKKOTIETO`] : []; // MET-528
-
-    const newDeletables = [...deletables, ...subsets, ...accentless, ...d490, ...ennakkotieto653];
+    const newDeletables = [...deletables, ...subsets, ...accentless, ...d490, ...inferiorTerms];
 
     if (subsets.length) {
       return processTodoList([...stillToDo, ...moreToDo], newDeletables);
@@ -323,6 +341,15 @@ function deriveIndividualDeletables(record) {
     return [accentless];
   }
 
+  function getPrepublicationTerms(fieldAsString) {
+    if (fieldAsString.match(/^653./u)) {
+      // MET-528 (extented by MET-575)
+      return [`${fieldAsString} ‡g ENNAKKOTIETO`, `${fieldAsString} ‡g ennakkotieto`, `${fieldAsString} ‡g ENNAKKOTIETO.`, `${fieldAsString} ‡g ennakkotieto.`];
+    }
+
+    return [];
+  }
+
 }
 
 function fieldToNormalizedString(field) {

package/src/sortRelatorTerms.js

@@ -86,7 +86,7 @@ function swapRelatorTermSubfields(field, typeOfMaterial = undefined) {
 
   const subfieldCode = tagToRelatorTermSubfieldCode(field.tag);
 
-  console.log(`Processing ${fieldToString(field)}`); // eslint-disable-line no-console
+  //console.log(`Processing ${fieldToString(field)}`); // eslint-disable-line no-console
 
   const swapPosition = field.subfields.findIndex((subfield, index) => isSwappable(subfield, index));
 
@@ -96,10 +96,10 @@ function swapRelatorTermSubfields(field, typeOfMaterial = undefined) {
     return;
   }
 
-  console.log(`END ${fieldToString(field)}`); // eslint-disable-line no-console
+  //console.log(`END ${fieldToString(field)}`); // eslint-disable-line no-console
 
   function swapRelatorTermPair(index) {
-    console.log(` SWAP`); // eslint-disable-line no-console
+    //console.log(` SWAP`); // eslint-disable-line no-console
 
     // Swap:
     const tmp = field.subfields[index - 1];
@@ -123,7 +123,7 @@ function swapRelatorTermSubfields(field, typeOfMaterial = undefined) {
       return false;
     }
     const prevScore = scoreRelatorTerm(prevSubfield.value, typeOfMaterial);
-    console.log(`PREV: ${prevSubfield.value}/${prevScore}, CURR: ${sf.value}/${currScore}`); // eslint-disable-line no-console
+    // console.log(`PREV: ${prevSubfield.value}/${prevScore}, CURR: ${sf.value}/${currScore}`); // eslint-disable-line no-console
     // If this subfield maps to a Work, then subfields can be swapped, even if we don't have a score for the prev subfield!
     if (prevScore === 0 && currScore < WORST_WORK) {
       return false;

package/src/translate-terms.js

@@ -3,13 +3,12 @@ import createDebugLogger from 'debug';
 import {fieldHasSubfield, fieldToString, nvdebug} from './utils';
 
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortSubfields');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:translate-terms');
 const defaultTags = ['648', '650', '651', '655'];
 
 const swapLanguageCode = {'fin': 'swe', 'fi': 'sv', 'sv': 'fi', 'swe': 'fin'};
 const changeAbbrHash = {'fi': 'fin', 'fin': 'fi', 'sv': 'swe', 'swe': 'sv'};
 
-//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/translate-term');
 const termCache = {};
 
 // Author(s): Nicholas Volk

package/test-fixtures/disambiguate-series-statements/f01/expectedResult.json

@@ -0,0 +1,16 @@
+{
+  "_validationOptions": {},
+  "leader": "12345cam a22123454i 4500",
+  "fields": [
+    { "tag": "008", "value": "012345s7890    fi ||||             mul |"},
+    { "tag": "337", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "tietokonekäyttöinen"},
+      {"code": "b", "value": "c"},
+      {"code": "2", "value": "rdamedia"}
+    ]},
+    { "tag": "490", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "Sisu"},
+      {"code": "x", "value": "1797-7746"}
+    ]}
+  ]
+}

package/test-fixtures/disambiguate-series-statements/f01/metadata.json

@@ -0,0 +1,5 @@
+{
+  "description": "Fixer 01: remove 490$x printed ISSN as record is electronic",
+  "only": false,
+  "fix": true
+}

package/test-fixtures/disambiguate-series-statements/f01/record.json

@@ -0,0 +1,16 @@
+{
+  "leader": "12345cam a22123454i 4500",
+  "fields": [
+    { "tag": "008", "value": "012345s7890    fi ||||             mul |"},
+    { "tag": "337", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "tietokonekäyttöinen"},
+      {"code": "b", "value": "c"},
+      {"code": "2", "value": "rdamedia"}
+    ]},
+    { "tag": "490", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "Sisu"},
+      {"code": "x", "value": "1797-7746"},
+      {"code": "x", "value": "1797-5905"}
+    ]}
+  ]
+}

package/test-fixtures/disambiguate-series-statements/f02/expectedResult.json

@@ -0,0 +1,16 @@
+{
+  "_validationOptions": {},
+  "leader": "12345cam a22123454i 4500",
+  "fields": [
+    { "tag": "008", "value": "012345s7890    fi ||||             mul |"},
+    { "tag": "337", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "käytettävissä ilman laitetta"},
+      {"code": "b", "value": "n"},
+      {"code": "2", "value": "rdamedia"}
+    ]},
+    { "tag": "490", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "Sisu"},
+      {"code": "x", "value": "1797-5905"}
+    ]}
+  ]
+}

package/test-fixtures/disambiguate-series-statements/f02/metadata.json

@@ -0,0 +1,5 @@
+{
+  "description": "Fixer 02: remove 490$x eletronic ISSN as record is printed",
+  "only": false,
+  "fix": true
+}