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

package/src/ending-whitespace.js

@@ -0,0 +1,40 @@
+/**
+ * Provides interface to validate and fix record fields, which include subfields that end with whitespace character
+ * @returns {Object} Object containing interfaces required by marc-record-validators-melinda package
+ */
+export default function () {
+  return {
+    description: 'Handles subfields that ends with whitespace character',
+    validate,
+    fix
+  };
+
+  function validate(record) {
+    const nonValidFields = record.fields.filter(({subfields}) => subfields !== undefined && subfields.filter(valueEndsWithWhitespace).length > 0);
+
+    const valid = nonValidFields.length === 0;
+    const messages = nonValidFields.flatMap(({tag, subfields}) => subfields.map(sf => `Field ${tag} subfield $${sf.code} ends with whitespace`));
+
+    return valid ? {valid, messages: []} : {valid, messages};
+  }
+
+  /* eslint-disable functional/immutable-data,functional/no-conditional-statements */
+  function fix(record) {
+    record.fields.forEach(({subfields}) => {
+      if (subfields === undefined) {
+        return;
+      }
+
+      subfields.forEach(subfield => {
+        if (valueEndsWithWhitespace(subfield)) {
+          subfield.value = subfield.value.trimEnd();
+        }
+      });
+    });
+  }
+  /* eslint-enable functional/immutable-data,functional/no-conditional-statements */
+
+  function valueEndsWithWhitespace({value}) {
+    return (/\s$/u).test(value);
+  }
+}

package/src/ending-whitespace.spec.js

@@ -0,0 +1,44 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './ending-whitespace';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'ending-whitespace'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+
+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, fix = false}) {
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+
+  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/field-521-fix.js

@@ -0,0 +1,92 @@
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+import {fieldToString} from './utils';
+
+// Author(s): Nicholas Volk
+export default function () {
+
+  return {
+    description: 'Various fixes for field 521',
+    validate, fix
+  };
+
+  function fix(record) {
+    record.fields.forEach(field => {
+      fix521(field);
+    });
+    // Fix always succeeds (even when it really does not):
+    const res = {message: [], fix: [], valid: true};
+    return res;
+  }
+
+  function validate(record) {
+    const res = {message: []};
+
+    // Actual parsing of all fields
+    /*
+    if (!record.fields) {
+      return false;
+    }
+    */
+
+    record.fields?.forEach(field => {
+      validateField(field, res);
+    });
+
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+
+  function validateField(field, res) {
+    const orig = fieldToString(field);
+
+    const normalizedField = fix521(clone(field));
+    const mod = fieldToString(normalizedField);
+    if (orig !== mod) { // Fail as the input is "broken"/"crap"/sumthing
+      res.message.push(`'TODO: ${orig}' => '${mod}'`); // eslint-disable-line functional/immutable-data
+      return;
+    }
+    return;
+  }
+}
+
+function fixSubfieldA(a) {
+  a.value = a.value. // eslint-disable-line functional/immutable-data
+    // MET-332:
+    replace(/^(Ikäsuositus) ([0-9])/u, '$1: $2'); // eslint-disable-line prefer-named-capture-group, functional/immutable-data
+}
+
+function fixSubfieldAInternalPunctuation(field) {
+  const a = field.subfields.filter(sf => sf.code === 'a');
+
+  a.forEach(sf => fixSubfieldA(sf));
+}
+
+function getIndicator1(field) {
+  const [a] = field.subfields.filter(sf => sf.code === 'a');
+  if (a) {
+    if (a.value.match(/^Ikäsuositus/u)) {
+      return '1';
+    }
+  }
+  return undefined;
+}
+
+function fixIndicator1(field) {
+  const value = getIndicator1(field);
+  if (value) {
+    field.ind1 = value; // eslint-disable-line functional/immutable-data
+    return;
+  }
+
+}
+
+function fix521(field) {
+  if (field.tag !== '521' || !field.subfields) {
+    return field;
+  }
+  fixIndicator1(field);
+  fixSubfieldAInternalPunctuation(field);
+  return field;
+}
+

package/src/field-521-fix.spec.js

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

@@ -1,220 +1,202 @@
-/**
- *
- * @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 {forEach, every, some} from 'lodash';
-import {isRegExp} from 'util';
-
 // Configuration specification
 const confSpec = {
-	tag: { // Pattern to match the field's tags
-		type: 'RegExp',
-		mandatory: true
-	},
-	value: { // Regular expression object for matching a controlfields value. Mutual exclusive with
-		type: 'RegExp',
-		excl: [
-			'subfields', 'ind1', 'ind2'
-		]
-	},
-	ind1: { // Pattern to match the field's ind1 property.
-		type: 'RegExp', // Array<Indicator>
-		excl: [
-			'value'
-		]
-	},
-	ind2: { // Pattern to match the field's ind2 property.
-		type: 'RegExp', // Array<Indicator>
-		excl: [
-			'value'
-		]
-	},
-	subfields: { // An array of objects with the following properties
-		code: {
-			type: 'RegExp',
-			mandatory: true
-		},
-		value: {
-			type: 'RegExp',
-			mandatory: true
-		}
-	}
+  tag: { // Pattern to match the field's tags
+    type: 'RegExp',
+    mandatory: true
+  },
+  value: { // Regular expression object for matching a controlfields value. Mutual exclusive with
+    type: 'RegExp',
+    excl: ['subfields', 'ind1', 'ind2']
+  },
+  ind1: { // Pattern to match the field's ind1 property.
+    type: 'RegExp', // Array<Indicator>
+    excl: ['value']
+  },
+  ind2: { // Pattern to match the field's ind2 property.
+    type: 'RegExp', // Array<Indicator>
+    excl: ['value']
+  },
+  subfields: { // An array of objects with the following properties
+    code: {
+      type: 'RegExp',
+      mandatory: true
+    },
+    value: {
+      type: 'RegExp',
+      mandatory: true
+    }
+  },
+  dependencies: {
+    leader: {
+      type: 'RegExp'
+    }
+  }
 };
 
-export default async function (config) {
-	if (!Array.isArray(config)) {
-		throw new TypeError('Configuration array not provided');
-	}
-
-	configValid(config);
-
-	return {
-		description:
-			'Checks whether the configured field-specific objects are valid in the record',
-		validate: async record => (
-			excludeFields(record, config, false)
-		),
-		fix: async record =>
-			excludeFields(record, config, true)
-	};
-
-	/// /////////////////////////////////////////
-	// These check that configuration is valid
-	function configValid(config) {
-		let excluded = [];
-		config.forEach(obj => {
-			excluded = []; // Validate fields: check that they are valid to confSpec (exists, correct data type), concat excluded elements
-			checkMandatory(confSpec, obj);
-
-			forEach(obj, (val, key) => {
-				configMatchesSpec(val, key, confSpec);
-				// Concat all excluded elements to array
-				if (confSpec[key].excl) {
-					excluded = excluded.concat(confSpec[key].excl);
-				}
-			});
-
-			// Check that no excluded elements are in use
-			forEach(obj, (val, key) => {
-				if (excluded.includes(key)) {
-					throw new Error('Configuration not valid - excluded element');
-				}
-			});
-		});
-	}
-
-	// Recursive validator
-	function configMatchesSpec(data, key, spec) {
-		// Field not found in configuration spec
-		if (!spec[key]) {
-			throw new Error('Configuration not valid - unidentified value: ' + key);
-		}
-
-		// If configuration type does not match type in configuration spec
-		if (typeof data !== spec[key].type &&
-			(spec[key].type === 'RegExp' && !(isRegExp(data)))) {
-			throw new Error('Configuration not valid - invalid data type for: ' + key);
-		}
-
-		// Check subfields recursively
-		if (key === 'subfields') {
-			forEach(data, subObj => {
-				// Console.log("subObj: ", subObj, " type: ", typeof subObj, !(Array.isArray(subObj)))
-				if (typeof subObj === 'object' && !(Array.isArray(subObj))) {
-					checkMandatory(spec[key], subObj);
-
-					forEach(subObj, (subVal, subKey) => {
-						configMatchesSpec(subVal, subKey, spec[key]);
-					});
-				} else {
-					throw new TypeError('Configuration not valid - subfield: ' + subObj + ' not object');
-				}
-			});
-		}
-	}
-
-	function checkMandatory(spec, obj) {
-		// Check if all mandatory fields are present
-		forEach(spec, (val, key) => {
-			if (val.mandatory && typeof (obj[key]) === 'undefined') {
-				throw new Error('Configuration not valid - missing mandatory element: ' + key);
-			}
-		});
-	}
-	/// /////////////////////////////////////////
-
-	/// /////////////////////////////////////////
-	// These check that record is valid
-	function subFieldCheck(confField, element) {
-		// Parse trough every configuration subfield, check if one matches some subobjects fields
-		return some(confField, subField => {
-			return some(element.subfields, elemSub => {
-				// Check if subfield matches configuration spec
-				if (subField.code && elemSub.code && (subField.code.test(elemSub.code)) &&
-					subField.value && elemSub.value && (subField.value.test(elemSub.value))) {
-					return true;
-				}
-			});
-		});
-	}
-
-	function excludeFields(record, conf, fix) {
-		var res = {};
-		res.message = [];
-		res.valid = true;
-
-		// Parse trough every element of config array
-		forEach(conf, confObj => {
-			var found = record.get(confObj.tag); // Find matching record fields based on mandatory tag
-
-			// Check if some of found record fields matches all configuration fields
-			forEach(found, element => {
-				// Compare each found element against each configuration object
-				if (every(confObj, (confField, confKey) => {
-					// This is already checked on .get()
-					if (confKey === 'tag') {
-						return true;
-					}
-
-					// Check subfield configurations
-					if (confKey === 'subfields') {
-						return subFieldCheck(confField, element);
-					}
-
-					// Configuration object is RegExp and record value matches it
-					if (element[confKey] && isRegExp(confField) && confField.test(element[confKey])) {
-						return true;
-
-					// Configuration object not found from found element
-					}
-					return false;
-				})) {
-					// All configuration fields match, element should be excluded.
-					if (fix) {
-						record.removeField(element);
-					} else {
-						res.message.push('Field $' + element.tag + ' should be excluded');
-					}
-				}
-			});
-		});
-
-		// Fix does not send response
-		if (!fix) {
-			if (res.message.length > 0) {
-				res.valid = false;
-			}
-			return res;
-		}
-		// Res.fix.push('Field $' + element.tag + ' excluded');
-	}
-	/// /////////////////////////////////////////
+function forEach(obj, fun) {
+  Object.entries(obj).forEach(fun);
+}
+
+function isRegExp(re) {
+  const result = re instanceof RegExp;
+  return result;
+}
+
+export default function (config) {
+  if (!Array.isArray(config)) {
+    throw new TypeError('Configuration array not provided');
+  }
+
+  // Transform RegExp-only elements to objects
+  const objOnlyConfigs = config.map(e => isRegExp(e) ? {tag: e} : e);
+  configValid(objOnlyConfigs);
+
+  return {
+    description:
+      'Checks that the record does not contain the configured fields',
+    validate: record => excludeFields(record, objOnlyConfigs, false),
+    fix: record => excludeFields(record, objOnlyConfigs, true)
+  };
+
+  /// /////////////////////////////////////////
+  // These check that configuration is valid
+  function configValid(config) {
+    config.forEach(obj => {
+      const excluded = []; // Validate fields: check that they are valid to confSpec (exists, correct data type), concat excluded elements
+
+      checkMandatory(confSpec, obj);
+
+      forEach(obj, ([key, val]) => {
+        configMatchesSpec(val, key, confSpec);
+        // Concat all excluded elements to array
+        if (confSpec[key].excl) { // eslint-disable-line functional/no-conditional-statements
+          excluded.push(...confSpec[key].excl); // eslint-disable-line functional/immutable-data
+        }
+      });
+
+      // Check that no excluded elements are in use
+      forEach(obj, ([key]) => {
+        if (excluded.includes(key)) {
+          throw new Error('Configuration not valid - excluded element');
+        }
+      });
+    });
+  }
+
+  // Recursive validator
+  function configMatchesSpec(data, key, spec) {
+    // Field not found in configuration spec
+    if (!spec[key]) {
+      throw new Error(`Configuration not valid - unidentified value: ${key}`);
+    }
+
+    // If configuration type does not match type in configuration spec
+    if (typeof data !== spec[key].type &&
+      (spec[key].type === 'RegExp' && !isRegExp(data))) {
+      throw new Error(`Configuration not valid - invalid data type for: ${key}`);
+    }
+
+    // Check subfields recursively
+    if (key === 'subfields') { // eslint-disable-line functional/no-conditional-statements
+      forEach(data, ([, subObj]) => {
+        // Console.log("subObj: ", subObj, " type: ", typeof subObj, !(Array.isArray(subObj)))
+        if (typeof subObj === 'object' && !Array.isArray(subObj)) { // eslint-disable-line functional/no-conditional-statements
+          checkMandatory(spec[key], subObj);
+
+          forEach(subObj, ([subKey, subVal]) => {
+            configMatchesSpec(subVal, subKey, spec[key]);
+          });
+        } else {
+          throw new TypeError(`Configuration not valid - subfield: ${subObj} not object`);
+        }
+      });
+    }
+
+    if (key === 'dependencies') { // eslint-disable-line functional/no-conditional-statements
+      forEach(data, ([, subObj]) => {
+        if (!(typeof subObj === 'object' && !Array.isArray(subObj) && Object.keys(subObj).length === 1 && isRegExp(subObj.leader))) {
+          throw new TypeError('Configuration not valid - Invalid dependencies config');
+        }
+      });
+    }
+  }
+
+  function checkMandatory(spec, obj) {
+    // Check if all mandatory fields are present
+    forEach(spec, ([key, val]) => {
+      if (val.mandatory && typeof obj[key] === 'undefined') {
+        throw new Error(`Configuration not valid - missing mandatory element: ${key}`);
+      }
+    });
+  }
+  /// /////////////////////////////////////////
+
+  /// /////////////////////////////////////////
+  // These check that record is valid
+  function subFieldCheck(confField, element) {
+    // Parse trough every configuration subfield, check if one matches some subobjects fields
+    return Object.values(confField).some(subField => Object.values(element.subfields)
+      // Check if subfield matches configuration spec
+      .some(elemSub => subField.code && elemSub.code && subField.code.test(elemSub.code) &&
+        subField.value && elemSub.value && subField.value.test(elemSub.value)));
+  }
+
+  function excludeFields(record, conf, fix) {
+    const res = {message: [], valid: true};
+
+    // Parse trough every element of config array
+    forEach(conf, ([, confObj]) => {
+      const found = record.get(confObj.tag); // Find matching record fields based on mandatory tag
+      const excluded = [];
+
+      // Check if some of found record fields matches all configuration fields
+      found.forEach(element => {
+        // Compare each found element against each configuration object
+        if (Object.entries(confObj).every(([confKey, confField]) => {
+          // This is already checked on .get()
+          if (confKey === 'tag') {
+            return true;
+          }
+
+          if (confKey === 'dependencies') {
+            return confObj.dependencies.every(dependency => dependency.leader.test(record.leader));
+          }
+
+          // Check subfield configurations
+          if (confKey === 'subfields') {
+            return subFieldCheck(confField, element);
+          }
+
+          // Configuration object is RegExp and record value matches it
+          if (element[confKey] && isRegExp(confField) && confField.test(element[confKey])) {
+            return true;
+
+            // Configuration object not found from found element
+          }
+
+          return false;
+        })) {
+          // All configuration fields match, element should be excluded.
+          if (fix) { // eslint-disable-line functional/no-conditional-statements
+            excluded.push(element); // eslint-disable-line functional/immutable-data
+          } else { // eslint-disable-line functional/no-conditional-statements
+            res.message.push(`Field $${element.tag} should be excluded`); // eslint-disable-line functional/immutable-data
+          }
+        }
+      });
+
+      excluded.forEach(field => record.removeField(field));
+    });
+
+    // Fix does not send response
+    if (!fix) {
+      if (res.message.length > 0) { // eslint-disable-line functional/no-conditional-statements
+        res.valid = false; // eslint-disable-line functional/immutable-data
+      }
+
+      return res;
+    }
+    // Res.fix.push('Field $' + element.tag + ' excluded');
+  }
+  /// /////////////////////////////////////////
 }