@natlibfi/marc-record-validators-melinda 3.2.0 → 3.3.14-alpha.2

package/src/indicator-fixes.spec.js

@@ -0,0 +1,52 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './indicator-fixes';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import createDebugLogger from 'debug';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'indicator-fixes'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/indicator-fixes: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/isbn-issn.js

@@ -1,106 +1,254 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* MARC record validators used in Melinda
-*
-* Copyright (C) 2014-2018 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of marc-record-validators-melinda
-*
-* marc-record-validators-melinda program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Affero 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-validators-melinda 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 Affero General Public License for more details.
-*
-* You should have received a copy of the GNU Affero 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.
-*
-*/
-
-/* eslint-disable require-await */
-'use strict';
-import {validate as validateISBN} from 'beautify-isbn';
-import validateISSN from 'issn-verify';
-
-export default async function () {
-	return {
-		description: 'Validates ISBN and ISSN values',
-		validate,
-		fix
-	};
-
-	function getInvalidFields(record) {
-		return record.get(/^(020|022)$/).filter(field => {
-			if (field.tag === '020') {
-				const subfield = field.subfields.find(sf => sf.code === 'a');
-				if (subfield) {
-					return !validateISBN(subfield.value);
-				}
-			} else {
-				const subfield = field.subfields
-					.find(sf => sf.code === 'a' || sf.code === 'l');
-
-				if (subfield) {
-					return !validateISSN(subfield.value);
-				}
-			}
-
-			return false;
-		});
-	}
-
-	async function validate(record) {
-		const fields = getInvalidFields(record);
-
-		if (fields.length === 0) {
-			return {valid: true};
-		}
-
-		return fields
-			.map(field => {
-				if (field.tag === '020') {
-					const {value} = field.subfields.find(sf => sf.code === 'a');
-					return {name: 'ISBN', value};
-				}
-
-				return {name: 'ISSN', value: getISSN()};
-
-				function getISSN() {
-					return field.subfields.find(sf => {
-						return sf.code === 'a' || sf.code === 'l';
-					}).value;
-				}
-			})
-			.reduce((acc, obj) => {
-				const {name, value} = obj;
-				acc.messages.push(`${name} ${value} is not valid`);
-				return acc;
-			}, {valid: false, messages: []});
-	}
-
-	async function fix(record) {
-		getInvalidFields(record).forEach(field => {
-			if (field.tag === '020') {
-				const subfield = field.subfields.find(sf => sf.code === 'a');
-
-				field.subfields.push({code: 'z', value: subfield.value});
-				record.removeSubfield(subfield, field);
-			} else {
-				const subfield = field.subfields
-					.find(sf => sf.code === 'a' || sf.code === 'l');
-
-				field.subfields.push({code: 'y', value: subfield.value});
-				record.removeSubfield(subfield, field);
-			}
-		});
-	}
-}
+import ISBN from 'isbn3';
+import validateISSN from '@natlibfi/issn-verify';
+
+// handleInvalid: move invalid 020$a to 020$z, and invalid 022$a to 022$y
+export default ({hyphenateISBN = false, handleInvalid = false} = {}) => {
+  return {
+    validate, fix,
+    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) {
+    const isbnOnly = getFirstWord(isbn);
+    const auditedIsbn = ISBN.audit(isbnOnly);
+    return !auditedIsbn.validIsbn;
+  }
+
+  function invalidSubfield(subfield) {
+    if (subfield.code !== 'a') {
+      return false;
+    }
+    return invalidISBN(subfield.value) || isMultiWord(subfield.value);
+  }
+
+
+  function invalidField020(field) {
+    if (field.subfields && field.subfields.some(sf => invalidSubfield(sf))) {
+      return true;
+    }
+    return false;
+  }
+
+  function subfieldsIsbnRequiresHyphenation(subfield) {
+    if (!hyphenateISBN || !['a', 'z'].includes(subfield.code)) {
+      return false;
+    }
+
+    const isbn = getFirstWord(subfield.value);
+    if (subfield.code === 'a') {
+      return requiresHyphenation(isbn);
+    }
+
+    // $z is a bit hacky: hyphenation is required only iff valid and no '-' chars
+    if (isbn.indexOf('-') > -1) {
+      return false;
+    }
+    return !invalidISBN(isbn);
+
+    function requiresHyphenation(isbn) {
+      if (!hyphenateISBN) {
+        return false;
+      }
+      // Handle old notation such as "978-952-396-001-5 (nid.)"
+      const isbn2 = getFirstWord(isbn);
+
+      if (invalidISBN(isbn2)) {
+        return false;
+      }
+
+      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 getRelevantFields(record) {
+    //return record.get(/^(?:020|022)$/u).filter(field => {
+    return record.fields.filter(field => {
+      if (!field.subfields) {
+        return false;
+      }
+      // Check ISBN:
+      if (field.tag === '020') {
+        if (invalidField020(field)) { // checks multiwordness
+          return true;
+        }
+        return fieldsIsbnRequiresHyphenation(field);
+      }
+
+      // Check ISSN:
+      if (field.tag === '022') {
+        if (invalidField022(field)) {
+          return true;
+        }
+
+        const subfield = field.subfields.find(sf => sf.code === 'a' || sf.code === 'l');
+
+        return !validateISSN(subfield.value);
+      }
+      return false;
+    });
+
+    function fieldsIsbnRequiresHyphenation(field) {
+      return field.subfields && field.subfields.some(sf => subfieldsIsbnRequiresHyphenation(sf));
+    }
+
+    function invalidField022(field) {
+      const subfieldAorL = field.subfields.find(sf => sf.code === 'a' || sf.code === 'l');
+
+      if (subfieldAorL === undefined) {
+        const subfieldY = field.subfields.find(sf => sf.code === 'y');
+        if (subfieldY) {
+          return false;
+        }
+
+        return true;
+      }
+      return false;
+    }
+  }
+
+  function validate(record) {
+    const fields = getRelevantFields(record);
+
+    if (fields.length === 0) {
+      return {valid: true};
+    }
+
+    return fields
+      .map(field => {
+        if (field.tag === '020') {
+          const subfieldA = field.subfields.find(sf => sf.code === 'a');
+          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};
+        }
+
+        return {name: 'ISSN', value: getISSN()};
+
+        function getISSN() {
+          const subfieldAorL = field.subfields.find(sf => sf.code === 'a' || sf.code === 'l');
+
+          if (subfieldAorL) {
+            return subfieldAorL.value;
+          }
+
+          return undefined;
+        }
+      })
+      .reduce((acc, obj) => {
+        const {name, value} = obj;
+        const msg = `${name} (${value}) is not valid`;
+
+        return {...acc, messages: acc.messages.concat(msg)};
+      }, {valid: false, messages: []});
+  }
+
+
+  function fix(record) {
+    getRelevantFields(record).forEach(field => {
+      if (field.tag === '020') {
+        field.subfields.forEach(subfield => fixField020Subfield(field, subfield));
+        return;
+      }
+      // 022 ISSN:
+      const subfield = field.subfields.find(sf => sf.code === 'a' || sf.code === 'l');
+      if (subfield && handleInvalid) { // eslint-disable-line functional/no-conditional-statements
+        // $a/$l => $y (bit overkill to add $z and remove $a/$l instead of just renaming)
+        field.subfields.push({code: 'y', value: subfield.value}); // eslint-disable-line functional/immutable-data
+        record.removeSubfield(subfield, field);
+      }
+    });
+
+
+    function fixField020Subfield(field, subfield) {
+      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-statements
+          subfield.value = normalizedValue; // eslint-disable-line functional/immutable-data
+        }
+      }
+
+      function handleInvalidIsbn(field, subfield) {
+        if (subfield.code !== 'a' || !handleInvalid) {
+          return;
+        }
+        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 = 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-statements
+          return numbersOnly.length === 10 ? parsedIsbn.isbn10h : parsedIsbn.isbn13h; // eslint-disable-line functional/immutable-data
+        }
+        return numbersOnly.length === 10 ? parsedIsbn.isbn10 : parsedIsbn.isbn13; // eslint-disable-line functional/immutable-data
+      }
+    }
+  }
+};