@natlibfi/marc-record-validators-melinda 12.1.0-alpha.1 → 13.0.0

package/src/subfield8Utils.js

@@ -1,7 +1,10 @@
 // import createDebugLogger from 'debug';
+// import {fieldToString, nvdebug} from './utils.js';
+
 // const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield8Utils');
+//const debugData = debug.extend('data');
+//const debugDev = debug.extend('dev');
 
-import {fieldToString, nvdebug} from './utils.js';
 
 const sf8Regexp = /^([1-9][0-9]*)(?:\.[0-9]+)?(?:\\[acprux])?$/u;
 
@@ -10,9 +13,9 @@ export function isValidSubfield8(subfield) {
     return false;
   }
 
-  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}'`);
+  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}'`, debugDev);
   const match = subfield.value.match(sf8Regexp);
-  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}' vs ${match.length}}`);
+  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}' vs ${match.length}}`, debugDev);
   return match && match.length > 0;
 }
 
@@ -56,7 +59,7 @@ export function fieldsGetAllSubfield8LinkingNumbers(fields) {
     field.subfields.forEach(sf => {
       const linkingNumber = getSubfield8LinkingNumber(sf);
       if (linkingNumber > 0 && !subfield8LinkingNumbers.includes(linkingNumber)) {
-        nvdebug(` LINK8: Add subfield \$8 ${linkingNumber} to seen values list`);
+        //nvdebug(` LINK8: Add subfield \$8 ${linkingNumber} to seen values list`, debugDev);
         subfield8LinkingNumbers.push(linkingNumber);
       }
     });
@@ -76,10 +79,10 @@ export function add8s(fields, record) {
     return fields;
   }
 
-  nvdebug(`Linking number(s): ${linkingNumbers.join(', ')}`);
+  //nvdebug(`Linking number(s): ${linkingNumbers.join(', ')}`, debugDev);
   linkingNumbers.forEach(number => collectLinkingNumberFields(number));
 
-  fields.forEach(f => nvdebug(`AFTER ADDING 8s: '${fieldToString(f)}'`));
+  //fields.forEach(f => nvdebug(`AFTER ADDING 8s: '${fieldToString(f)}'`, debugDev));
 
   return fields;
 
@@ -88,7 +91,7 @@ export function add8s(fields, record) {
     fields = fields.filter(f => !fieldHasLinkingNumber(f, linkingNumber));
     // Add them and their "sisters" back:
     const addableFields = record.fields.filter(f => fieldHasLinkingNumber(f, linkingNumber));
-    addableFields.forEach(f => nvdebug(`(RE-?)ADD ${fieldToString(f)}`));
+    //addableFields.forEach(f => nvdebug(`(RE-?)ADD ${fieldToString(f)}`, debugDev));
     fields = fields.concat(addableFields);
 
   }

package/src/subfieldValueNormalizations.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './subfieldValueNormalizations.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -20,7 +20,7 @@ generateTests({
   }
 });
 
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/subfieldValueNormalizations:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/subfieldValueNormalizations:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -30,12 +30,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
 
   const recordFixture = getFixture('record.json');

package/src/sync-007-and-300.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './sync-007-and-300.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -20,7 +20,7 @@ generateTests({
   }
 
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sync-007-and-300:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sync-007-and-300:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -30,12 +30,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/sync-language.js

@@ -0,0 +1,148 @@
+// Author(s): Nicholas Volk
+
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+
+import {fieldToString} from './utils.js';
+
+// const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sync-language');
+
+export default function () {
+
+  return {
+    description: 'Sync 008/35-37 and 041$a/$d',
+    validate, fix
+  };
+
+  function getSubfieldCodeFor041(record) {
+    const c = record?.leader[6];
+    if (c === 'i' || c === 'j') {
+      return 'd';
+    }
+    return 'a';
+  }
+
+  function transferableValue(val) {
+    if (val.match(/^[a-z]{3}$/u)) {
+      // 'zxx' is an exception to the otherwise relatively transitive 008/35-37 <=> 041$a relationship...
+      // https://wiki.helsinki.fi/xwiki/bin/view/rdasovellusohje/RDA-kuvailu%20MARC%2021%20-formaatilla/RDA-sovellusohje/008%20Kontrollikentt%C3%A4/#Hmp.35-37Kieli
+      // "008-kielikoodi on sama kuin ensimmäinen 041-kentän a- (tai d-) osakenttä. Poikkeuksen muodostaa koodi zxx:
+      //  jos tietueen 008ssa on kielikoodi zxx (ei kielellistä sisältöä, esim. soitinmusiikki), tietueessa ei voi olla 041 a- eikä d-osakenttää."
+      // So 'zxx' ain't transferable (done here), and it should be removed from 041 ($a and $d at least, not done here nor elsewhere at the moment...)
+      // Note that 'mul' and 'und' are treated (in this validator) the same as normal values.
+      if (val === 'zxx') {
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+
+  function zxxRemoval041(record, field, validateMode) {
+    const fields041 = record.fields.filter(f => f.tag === '041');
+
+    return handleZxx(fields041);
+
+    function handleZxx(fields, result = []) {
+      const [currField, ...remainingFields] = fields;
+      if ( !currField) {
+        return result;
+      }
+      // Theoretically 'zxx' might mean something in ISO-639-3 or some other language code list:
+      if (!field.subfields || field.subfields.some(sf => sf.code === '2')) {
+        return handleZxx(remainingFields, result);
+      }
+      // Presumable 'zxx' is bad in any data subfield, not just 'a' and 'd':
+      const otherSubfields = field.subfields.some(sf => !sf.code.match(/^[a-z]$/u || sf.value !== 'zxx'));
+      if (otherSubfields.length === field.subfields.length) {
+        return handleZxx(remainingFields, result);
+      }
+      const originalString = fieldToString(field);
+      if (otherSubfields.length === 0) {
+        const message = `Remove '${originalString}'`;
+        if (!validateMode) {
+          record.removeField(field);
+        }
+        return handleZxx(remainingFields, [...result, message]);
+      }
+      // Some subfields are removed:
+      if (validateMode) {
+        // NB! In validation field is not really deleted, and the non-deleted field might trigger other fixes (than won't be done to a deleted field) later on
+        const clonedField = clone(field);
+        clonedField.subfields = otherSubfields;
+        const modifiedString = fieldToString(clonedField);
+        const message = `Modify '${originalString}' => '${modifiedString}`;
+        return handleZxx(remainingFields, [...result, message]);
+      }
+      field.subfields = otherSubfields;
+      const modifiedString = fieldToString(field);
+      const message = `Modify '${originalString}' => '${modifiedString}`;
+      return handleZxx(remainingFields, [...result, message]);
+    }
+
+
+  }
+
+  function sync008And041(record, validateMode) {
+    const f008 = record.fields.find(f => f.tag === '008');
+    const f041 = record.fields.find(f => f.tag === '041');
+
+    if (!f008 || f008.value.length !== 40) { // Some sanity checks
+      return [];
+    }
+
+    const subfieldCode = getSubfieldCodeFor041(record);
+    const lang008 = f008.value.substring(35, 38);
+
+    if (!f041) {
+      // Insert missing 041
+      if (transferableValue(lang008)) {
+        const newField = {'tag': '041', 'ind1': ' ', 'ind2': ' ', 'subfields': [ {'code': subfieldCode, 'value': lang008}]};
+        if (!validateMode) {
+          record.insertField(newField);
+        }
+        return [ `Add '${fieldToString(newField)}'` ];
+      }
+      // Can't do anything, and we only report this we can fix...
+      return [];
+    }
+
+    const firstRelevantSubfield = f041.subfields.find(sf => sf.code === subfieldCode);
+
+    // NB! If $2 is set, *never* copy it's value to 008/35-37... Otherwise we might a loop in Aleph.
+    // Note that if $2 is used, 008/35-37 should actually be '|||'. Now we just aggressively leave it alone.
+    if (!firstRelevantSubfield || !transferableValue(firstRelevantSubfield.value) || f041.subfields.some(sf => sf.code === '2') || lang008 === firstRelevantSubfield.value) {
+      return []
+    }
+
+    // Update 008/35-37:
+    const cloned008 = clone(f008);
+    cloned008.value = `${f008.value.substring(0, 35)}${firstRelevantSubfield.value}${f008.value.substring(38)}`;
+
+
+    if (!validateMode) {
+      f008.value = cloned008.value;
+    }
+    return [ `Modify '${f008.value}' to '${cloned008.value}'` ];
+  }
+
+  function fix(record, validateMode = false) {
+    const zxxMessages = zxxRemoval041(record, validateMode);
+
+    const syncMessages = sync008And041(record, validateMode);
+
+    const messages = [...zxxMessages, ...syncMessages];
+
+    if (validateMode) {
+       return {message: messages, valid: messages.length === 0};
+    }
+    return {message: [], fix: messages, valid: true};
+  }
+
+
+  function validate(record) {
+    return fix(record, true);
+  }
+}
+

package/src/sync-language.test.js

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+//import createDebugLogger from 'debug';
+
+import validatorFactory from './sync-language.js';
+
+import {MarcRecord} from '@natlibfi/marc-record';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+generateTests({
+  callback,
+  path: [import.meta.dirname, '..', 'test-fixtures', 'sync-language'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
+  }
+});
+
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/drop-terms:test');
+
+async function testValidatorFactory() {
+  const validator = await validatorFactory();
+
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
+}
+
+async function callback({getFixture, fix = false}) {
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  //const expectedResult = new MarcRecord(getFixture('expectedResult.json'));
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    assert.deepEqual(result, expectedResult);
+    const originalRecord = new MarcRecord(getFixture('record.json'));
+    assert.deepEqual(record, originalRecord); // The record should now change in validation-only
+    return;
+  }
+
+  await validator.fix(record);
+  assert.deepEqual(record, new MarcRecord(expectedResult));
+}