@natlibfi/marc-record-validators-melinda 9.0.5-alpha.1 → 9.0.7-alpha.1

package/src/isbn-issn.js

@@ -36,77 +36,80 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
     description: 'Validates ISBN and ISSN values'
   };
 
+  function stringHasSpace(str) {
+    return str.indexOf(' ') > -1;
+  }
+
+  function trimSpaces(value) {
+    return value.replace(/^\s+/u, '').replace(/\s+$/u, '').replace(/\s+/gu, ' ');
+  }
+
+  function isMultiWord(inputString) {
+    const trimmedString = trimSpaces(inputString);
+    return stringHasSpace(trimmedString);
+  }
+
+  function getFirstWord(inputString) {
+    const trimmedString = trimSpaces(inputString);
+    const arr = trimmedString.split(' ');
+    return arr[0];
+  }
+
   function invalidISBN(isbn) {
-    // If value contains space, it's not necessarily crap. (It's typically something like "1234567890 (nid.)".)
-    // Check the first word in string:
-    if (isbn.indexOf(' ') > -1) {
-      // const arr = isbn.split(' ');
-      // console.info(`invalidISBN(): Check '${arr[0]}' instead of '${isbn}'`); // eslint-disable-line no-console
-      // return invalidISBN(arr[0]);
-      return true;
-    }
+    const isbnOnly = getFirstWord(isbn);
+    const auditedIsbn = ISBN.audit(isbnOnly);
+    return !auditedIsbn.validIsbn;
+  }
 
-    const auditedIsbn = ISBN.audit(isbn);
-    if (!auditedIsbn.validIsbn) {
-      console.info(`Invalid ISBN detected: ${isbn}`); // eslint-disable-line no-console
-      return true;
+  function invalidSubfield(subfield) {
+    if (subfield.code !== 'a') {
+      return false;
     }
-    return false;
+    return invalidISBN(subfield.value) || isMultiWord(subfield.value);
   }
 
 
   function invalidField020(field) {
-    if (field.subfields && field.subfields.some(sf => invalidField020a(sf) || invalidField020z(sf))) {
+    if (field.subfields && field.subfields.some(sf => invalidSubfield(sf))) {
       return true;
     }
     return false;
+  }
 
-    function invalidField020a(subfield) {
-      if (subfield.code !== 'a') {
-        return false;
-      }
-      if (invalidISBN(subfield.value)) {
-        return true;
-      }
+  function subfieldsIsbnRequiresHyphenation(subfield) {
+    if (!hyphenateISBN || !['a', 'z'].includes(subfield.code)) {
       return false;
     }
 
-    function invalidField020z(subfield) {
-      if (subfield.code !== 'z' || !hyphenateISBN || invalidISBN(subfield.value)) {
-        return false;
-      }
-      // We are only interested in $z field if it is valid ISBN that requires hyphenation:
-      return subfield.value.indexOf('-') === -1;
+    const isbn = getFirstWord(subfield.value);
+    if (subfield.code === 'a') {
+      return requiresHyphenation(isbn);
     }
-  }
 
-  function subfieldRequiresHyphenation(subfield) {
-    if (subfield.code !== 'a' && subfield.code !== 'z') {
+    // $z is a bit hacky: hyphenation is required only iff valid and no '-' chars
+    if (isbn.indexOf('-') > -1) {
       return false;
     }
-    return requiresHyphenation(subfield.value);
+    return !invalidISBN(isbn);
 
     function requiresHyphenation(isbn) {
-      if (isbn.indexOf(' ') > -1) {
-        const arr = isbn.split(' ');
-        console.info(`requiresHyphenation(): Check '${arr[0]}' instead of '${isbn}'`); // eslint-disable-line no-console
-        return requiresHyphenation(arr[0]);
+      if (!hyphenateISBN) {
+        return false;
       }
+      // Handle old notation such as "978-952-396-001-5 (nid.)"
+      const isbn2 = getFirstWord(isbn);
 
-      if (invalidISBN(isbn)) {
+      if (invalidISBN(isbn2)) {
         return false;
       }
-      console.info(`sfRH ${isbn}`); // eslint-disable-line no-console
-      const parsedIsbn = ISBN.parse(isbn);
-      if (hyphenateISBN) {
-        return !(isbn === parsedIsbn.isbn10h || isbn === parsedIsbn.isbn13h);
-      }
-      return false;
-      //return !(isbn === parsedIsbn.isbn10 || isbn === parsedIsbn.isbn13);
+
+      const parsedIsbn = ISBN.parse(isbn2);
+      // Return true only if existing ISBN is a valid and hyphenated 10 or 13 digit ISBN:
+      return !(isbn2 === parsedIsbn.isbn10h || isbn2 === parsedIsbn.isbn13h);
     }
   }
 
-  function getInvalidFields(record) {
+  function getRelevantFields(record) {
     //return record.get(/^(?:020|022)$/u).filter(field => {
     return record.fields.filter(field => {
       if (!field.subfields) {
@@ -114,10 +117,10 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
       }
       // Check ISBN:
       if (field.tag === '020') {
-        if (invalidField020(field)) {
+        if (invalidField020(field)) { // checks multiwordness
           return true;
         }
-        return fieldRequiresHyphenation(field);
+        return fieldsIsbnRequiresHyphenation(field);
       }
 
       // Check ISSN:
@@ -133,8 +136,8 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
       return false;
     });
 
-    function fieldRequiresHyphenation(field) {
-      return field.subfields && field.subfields.some(sf => subfieldRequiresHyphenation(sf));
+    function fieldsIsbnRequiresHyphenation(field) {
+      return field.subfields && field.subfields.some(sf => subfieldsIsbnRequiresHyphenation(sf));
     }
 
     function invalidField022(field) {
@@ -153,7 +156,7 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
   }
 
   function validate(record) {
-    const fields = getInvalidFields(record);
+    const fields = getRelevantFields(record);
 
     if (fields.length === 0) {
       return {valid: true};
@@ -166,6 +169,10 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
           if (subfieldA) {
             return {name: 'ISBN', value: subfieldA.value};
           }
+          const subfieldZ = field.subfields.find(sf => sf.code === 'z');
+          if (subfieldZ) {
+            return {name: 'ISBN (subfield Z)', value: subfieldZ.value};
+          }
 
           return {name: 'ISBN', value: undefined};
         }
@@ -192,7 +199,7 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
 
 
   function fix(record) {
-    getInvalidFields(record).forEach(field => {
+    getRelevantFields(record).forEach(field => {
       if (field.tag === '020') {
         field.subfields.forEach(subfield => fixField020Subfield(field, subfield));
         return;
@@ -206,50 +213,69 @@ export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
       }
     });
 
-    /*
-    function trimISBN(value) {
-      return trimSpaces(value.replace(/\s$/gu, '')); // handle "1234567890 (nid.)" => "1234567890" as well as spaces
-    }
-    */
 
     function fixField020Subfield(field, subfield) {
-      console.info(`fixField020Subfield ${subfield.code} '${subfield.value}'`); // eslint-disable-line no-console
-      if (invalidISBN(subfield.value) || subfieldRequiresHyphenation(subfield)) {
-        console.info(`  fixField020Subfield ${subfield.code} '${subfield.value}'`); // eslint-disable-line no-console
+      split020A(); // subfield and field are in the scope
+      addHyphens(subfield);
+      handleInvalidIsbn(field, subfield); // remove 020$a, add 020$z, Do this last, as it uses deletion
+      return;
+
+      function addHyphens(subfield) {
+        if (!subfieldsIsbnRequiresHyphenation(subfield)) {
+          return;
+        }
         // ISBN is valid but is missing hyphens
         const normalizedValue = normalizeIsbnValue(subfield.value);
         if (normalizedValue !== undefined) { // eslint-disable-line functional/no-conditional-statement
           subfield.value = normalizedValue; // eslint-disable-line functional/immutable-data
-        } else if (subfield.code === 'a' && handleInvalid) { // eslint-disable-line functional/no-conditional-statement
-          // $a => $z (bit overkill to add $z and remove $a instead of just renaming, but too lazy to fix/test thorougly)
-          field.subfields.push({code: 'z', value: subfield.value}); // eslint-disable-line functional/immutable-data
-          record.removeSubfield(subfield, field);
         }
       }
-      return;
 
-      function normalizeIsbnValue2(trimmedValue) {
-        //const trimmedValue = trimISBN(value); // NB! This might lose information that should be stored in $q...
-        const auditResult = ISBN.audit(trimmedValue);
-        if (auditResult.validIsbn) {
-          const parsedIsbn = ISBN.parse(trimmedValue);
-          if (hyphenateISBN) { // eslint-disable-line functional/no-conditional-statement
-            return trimmedValue.length === 10 ? parsedIsbn.isbn10h : parsedIsbn.isbn13h; // eslint-disable-line functional/immutable-data
-          }
-          // Just trim
-          return trimmedValue.length === 10 ? parsedIsbn.isbn10 : parsedIsbn.isbn13; // eslint-disable-line functional/immutable-data
+      function handleInvalidIsbn(field, subfield) {
+        if (subfield.code !== 'a' || !handleInvalid) {
+          return;
         }
-        return undefined;
+        const head = getFirstWord(subfield.value);
+        if (!invalidISBN(head)) {
+          return;
+        }
+        // $a => $z (bit overkill to add $z and remove $a instead of just renaming, but too lazy to fix/test thorougly)
+        field.subfields.push({code: 'z', value: subfield.value}); // eslint-disable-line functional/immutable-data
+        record.removeSubfield(subfield, field);
+      }
+
+      function split020A() {
+        // Move non-initial words from $a to $q:
+        if (subfield.code !== 'a') {
+          return;
+        }
+        const value = trimSpaces(subfield.value);
+        const position = value.indexOf(' ');
+        if (position === -1) {
+          return;
+        }
+        const head = getFirstWord(value);
+        if (invalidISBN(head)) { // Don't split, if first word ain't ISBN
+          return;
+        }
+        const tail = value.substring(position + 1);
+        subfield.value = head; // eslint-disable-line functional/immutable-data
+        field.subfields.push({code: 'q', value: tail}); // eslint-disable-line functional/immutable-data
       }
 
       function normalizeIsbnValue(value) {
-        const trimmedValue = value.replace(/^\s+/gu, '');
-        if (trimmedValue.indexOf(' ') === -1) {
-          return normalizeIsbnValue2(trimmedValue);
+        const trimmedValue = getFirstWord(value);
+        //const trimmedValue = trimISBN(value); // NB! This might lose information that should be stored in $q...
+        const auditResult = ISBN.audit(trimmedValue);
+        if (!auditResult.validIsbn) {
+          return undefined;
+        }
+        const numbersOnly = trimmedValue.replace(/[^0-9Xx]+/ug, '');
+        const parsedIsbn = ISBN.parse(trimmedValue);
+        if (hyphenateISBN) { // eslint-disable-line functional/no-conditional-statement
+          return numbersOnly.length === 10 ? parsedIsbn.isbn10h : parsedIsbn.isbn13h; // eslint-disable-line functional/immutable-data
         }
-        const [head] = trimmedValue.split(' ');
-        // NB! We currently drop the tail part, as it prevents us from pairing doubles. Parametrize?
-        return normalizeIsbnValue2(head);
+        return numbersOnly.length === 10 ? parsedIsbn.isbn10 : parsedIsbn.isbn13; // eslint-disable-line functional/immutable-data
       }
     }
   }

package/src/isbn-issn.spec.js

@@ -4,7 +4,7 @@
  *
  * MARC record validators used in Melinda
  *
- * Copyright (c) 2014-2020 University Of Helsinki (The National Library Of Finland)
+ * Copyright (c) 2014-2022 University Of Helsinki (The National Library Of Finland)
  *
  * This file is part of marc-record-validators-melinda
  *
@@ -84,6 +84,12 @@ describe('isbn-issn', () => {
             ind2: ' ',
             subfields: [{code: 'a', value: 'foo'}]
           },
+          {
+            tag: '020',
+            ind1: ' ',
+            ind2: ' ',
+            subfields: [{code: 'a', value: '90-68-31-372-X'}] // contains an extra hyphen
+          },
           {
             tag: '022',
             ind1: ' ',
@@ -140,16 +146,10 @@ describe('isbn-issn', () => {
       });
     });
 
-    it('Finds the record invalid (Spaces in ISBN)', async () => {
+    it('Finds the record invalid (reason: multiword)', async () => {
       const validator = await validatorFactory();
       const record = new MarcRecord({
         fields: [
-          {
-            tag: '020',
-            ind1: ' ',
-            ind2: ' ',
-            subfields: [{code: 'a', value: ' 9789519155470'}]
-          },
           {
             tag: '020',
             ind1: ' ',
@@ -160,12 +160,7 @@ describe('isbn-issn', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({
-        valid: false, messages: [
-          'ISBN ( 9789519155470) is not valid',
-          'ISBN (978-600-377-017-1 (nid.)) is not valid'
-        ]
-      });
+      expect(result).to.eql({valid: false, messages: ['ISBN (978-600-377-017-1 (nid.)) is not valid']});
     });
 
     it('Finds the record invalid (ISSN in \'l\'-subfield)', async () => {
@@ -206,6 +201,12 @@ describe('isbn-issn', () => {
             ind2: ' ',
             subfields: [{code: 'a', value: '9789519155470'}]
           },
+          {
+            tag: '020',
+            ind1: ' ',
+            ind2: ' ',
+            subfields: [{code: 'a', value: '9068-31-372-X'}] // legal digits, but bad hyphenation
+          },
           {
             tag: '020',
             ind1: ' ',
@@ -218,6 +219,7 @@ describe('isbn-issn', () => {
 
       expect(result).to.eql({valid: false, messages: [
         'ISBN (9789519155470) is not valid',
+        'ISBN (9068-31-372-X) is not valid',
         'ISBN (386006004X) is not valid'
       ]});
     });
@@ -309,15 +311,16 @@ describe('isbn-issn', () => {
             tag: '020',
             ind1: ' ',
             ind2: ' ',
-            subfields: [{code: 'a', value: '9786003770171 (nid.)'}]
+            subfields: [{code: 'a', value: '9786003770171 (nidottu)'}]
           }
         ]
       });
       await validator.fix(record);
 
       expect(record.fields).to.eql([
-        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '9786003770171'}]},
-        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '9786003770171'}]}
+        // NB! Initial space does not need to be removed. It's crap, but not this fixer's crap.
+        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: ' 9786003770171'}]},
+        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '9786003770171'}, {code: 'q', value: '(nidottu)'}]}
       ]);
     });
 
@@ -347,7 +350,9 @@ describe('isbn-issn', () => {
           subfields: [
             {code: 'a', value: '978-600-377-017-1'},
             {code: 'z', value: '978-600-377-017-1'},
-            {code: 'z', value: 'foo bar'}
+            {code: 'z', value: 'foo bar'},
+            // NB! Technically $q should come before $z subfields, but this is good enough.
+            {code: 'q', value: '(nid.)'}
           ]
         }
       ]);
@@ -361,6 +366,12 @@ describe('isbn-issn', () => {
             tag: '005',
             value: 'whatever'
           },
+          {
+            tag: '020',
+            ind1: ' ',
+            ind2: ' ',
+            subfields: [{code: 'q', value: 'sidottu'}]
+          },
           {
             tag: '024',
             ind1: ' ',
@@ -373,6 +384,7 @@ describe('isbn-issn', () => {
 
       expect(record.fields).to.eql([
         {tag: '005', value: 'whatever'},
+        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'q', value: 'sidottu'}]},
         {tag: '024', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: ' 9786003770171'}]}
       ]);
     });
@@ -389,6 +401,12 @@ describe('isbn-issn', () => {
             tag: '020', ind1: ' ', ind2: ' ',
             subfields: [{code: 'a', value: '917153086X'}]
           },
+          {
+            tag: '020',
+            ind1: ' ',
+            ind2: ' ',
+            subfields: [{code: 'a', value: '9068-31-372-X'}] // legal digits, but bad hyphenation
+          },
           {
             tag: '020', ind1: ' ', ind2: ' ',
             subfields: [{code: 'a', value: '386006004X (nid.)'}]
@@ -406,7 +424,8 @@ describe('isbn-issn', () => {
       expect(record.fields).to.eql([
         {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '978-9916-605-32-5'}]},
         {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '91-7153-086-X'}]},
-        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '3-86006-004-X'}]},
+        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '90-6831-372-X'}]}, // corrected hyphens
+        {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '3-86006-004-X'}, {code: 'q', value: '(nid.)'}]},
         {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'z', value: '978-9916-605-32-5'}]},
         {tag: '020', ind1: ' ', ind2: ' ', subfields: [{code: 'z', value: '978-9916-605-32-5'}]}
       ]);

package/src/punctuation/index.js

@@ -86,6 +86,10 @@ export default function () {
       debug(`Handling subfield ${subfield.code}`);
       let portion = getPortion(subfield, rulesForField); // eslint-disable-line functional/no-let
 
+      if (portion === false) {
+        return;
+      }
+
       if (portion === 'CF' || portion === 'NC') {
         return;
       }
@@ -140,7 +144,7 @@ export default function () {
     const [portion] = rules.filter(rule => rule.namePortion === subfield.code).map(rule => rule.portion);
 
     if (portion === undefined) {
-      throw new Error(`Unknown subfield code ${subfield.code}`);
+      return false;
     }
 
     return portion.toUpperCase();

package/src/resolvable-ext-references-melinda.spec.js

@@ -63,7 +63,8 @@ describe('resolvable-ext-references-melinda', () => {
 
   it('Throws an error when prefixPattern not provided', async () => {
     const validator = await testContext.default({endpoint, prefixPattern, fields});
-    await expect(validator.validate()).to.be.rejectedWith(Error, 'Cannot read property \'fields\' of undefined');
+    // Cannot read property 'fields' of undefined or Cannot read properties of undefined (reading 'fields')'
+    await expect(validator.validate()).to.be.rejectedWith(Error, /^Cannot read propert/u);
   });
 
   describe('#validate', () => {