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

package/src/unicode-decomposition.js

@@ -1,159 +1,144 @@
-/**
- *
- * @licstart  The following is the entire license notice for the JavaScript code in this file.
- *
- * Melinda-related validators for @natlibfi/marc-record-validate
- *
- * Copyright (c) 2014-2017 University Of Helsinki (The National Library Of Finland)
- *
- * This file is part of marc-record-validators-melinda
- *
- * marc-record-validators-melinda 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.
- *
- * This program 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 */
 const MAP_CONVERSION = {
-	/**
+
+  /**
    * @internal Normalizations
    **/
-	'‐': '-',
-	'‑': '-',
-	'‒': '-',
-	'–': '-',
-	'—': '-',
-	'―': '-',
-	/**
+  '‐': '-',
+  '‑': '-',
+  '‒': '-',
+  '–': '-',
+  '—': '-',
+  '―': '-',
+
+  /**
+  * @internal Normalizations (MELINDA-4172, MELINDA-4175)
+  **/
+  'Ⓒ': '©',
+  'Ⓟ': '℗',
+
+  /**
    * @internal Precompose å, ä, ö, Å, Ä and Ö
    **/
-	å: 'å',
-	ä: 'ä',
-	ö: 'ö',
-	Å: 'Å',
-	Ä: 'Ä',
-	Ö: 'Ö',
-	/**
+  å: 'å',
+  ä: 'ä',
+  ö: 'ö',
+  Å: 'Å',
+  Ä: 'Ä',
+  Ö: 'Ö',
+
+  /**
    * @internal Decompose everything else (list incomplete)
    **/
-	á: 'á',
-	à: 'à',
-	â: 'â',
-	ã: 'ã',
-	é: 'é',
-	è: 'è',
-	ê: 'ê',
-	ẽ: 'ẽ',
-	ë: 'ë',
-	í: 'í',
-	ì: 'ì',
-	î: 'î',
-	ĩ: 'ĩ',
-	ï: 'ï',
-	ñ: 'ñ',
-	ó: 'ó',
-	ò: 'ò',
-	ô: 'ô',
-	õ: 'õ',
-	ś: 'ś',
-	ú: 'ú',
-	ù: 'ù',
-	û: 'û',
-	ü: 'ü',
-	ũ: 'ũ',
-	ý: 'ý',
-	ỳ: 'ỳ',
-	ŷ: 'ŷ',
-	ỹ: 'ỹ',
-	ÿ: 'ÿ',
-	Á: 'Á',
-	À: 'À',
-	Â: 'Â',
-	Ã: 'Ã',
-	É: 'É',
-	È: 'È',
-	Ê: 'Ê',
-	Ẽ: 'Ẽ',
-	Ë: 'Ë',
-	Í: 'Í',
-	Ì: 'Ì',
-	Î: 'Î',
-	Ĩ: 'Ĩ',
-	Ï: 'Ï',
-	Ñ: 'Ñ',
-	Ó: 'Ó',
-	Ò: 'Ò',
-	Ô: 'Ô',
-	Õ: 'Õ',
-	Ś: 'Ś',
-	Ú: 'Ú',
-	Ù: 'Ù',
-	Û: 'Û',
-	Ũ: 'Ũ',
-	Ü: 'Ü',
-	Ý: 'Ý',
-	Ỳ: 'Ỳ',
-	Ŷ: 'Ŷ',
-	Ỹ: 'Ỹ',
-	Ÿ: 'Ÿ'
+  á: 'á',
+  à: 'à',
+  â: 'â',
+  ã: 'ã',
+  ć: 'ć',
+  č: 'č',
+  ç: 'ç',
+  é: 'é',
+  è: 'è',
+  ê: 'ê',
+  ẽ: 'ẽ',
+  ë: 'ë',
+  í: 'í',
+  ì: 'ì',
+  î: 'î',
+  ĩ: 'ĩ',
+  ï: 'ï',
+  ñ: 'ñ',
+  ó: 'ó',
+  ò: 'ò',
+  ô: 'ô',
+  õ: 'õ',
+  ś: 'ś',
+  š: 'š',
+  ú: 'ú',
+  ù: 'ù',
+  û: 'û',
+  ü: 'ü',
+  ũ: 'ũ',
+  ý: 'ý',
+  ỳ: 'ỳ',
+  ŷ: 'ŷ',
+  ỹ: 'ỹ',
+  ÿ: 'ÿ',
+  ž: 'ž',
+  Á: 'Á',
+  À: 'À',
+  Â: 'Â',
+  Ã: 'Ã',
+  É: 'É',
+  È: 'È',
+  Ê: 'Ê',
+  Ẽ: 'Ẽ',
+  Ë: 'Ë',
+  Í: 'Í',
+  Ì: 'Ì',
+  Î: 'Î',
+  Ĩ: 'Ĩ',
+  Ï: 'Ï',
+  Ñ: 'Ñ',
+  Ó: 'Ó',
+  Ò: 'Ò',
+  Ô: 'Ô',
+  Õ: 'Õ',
+  Ś: 'Ś',
+  Ú: 'Ú',
+  Ù: 'Ù',
+  Û: 'Û',
+  Ũ: 'Ũ',
+  Ü: 'Ü',
+  Ý: 'Ý',
+  Ỳ: 'Ỳ',
+  Ŷ: 'Ŷ',
+  Ỹ: 'Ỹ',
+  Ÿ: 'Ÿ'
 };
 
-export default async function () {
-	const PATTERN = Object.keys(MAP_CONVERSION).reduce((result, key, index, list) => {
-		return index === list.length - 1 ? new RegExp(`${result}${key})`) : `${result}${key}|`;
-	}, '(');
+export default function () {
+  const PATTERN = Object.keys(MAP_CONVERSION).reduce((result, key, index, list) => index === list.length - 1 ? new RegExp(`${result}${key})`, 'u') : `${result}${key}|`, '(');
 
-	return {
-		description: 'Unicode decomposer',
-		validate,
-		fix
-	};
+  return {
+    description: 'Unicode decomposer',
+    validate,
+    fix
+  };
 
-	async function validate(record) {
-		const codes = getFields(record.fields).map(field => {
-			if ('subfields' in field) {
-				return field.subfields.filter(subfield => PATTERN.test(subfield.value))
-					.map(subfield => subfield.code);
-			}
-			return null;
-		});
-		return codes.length < 1 ? {valid: true, messages: []} : {valid: false, messages: [`The following subfields are not properly decomposed: ${codes.join(', ')}`]};
-	}
+  function validate(record) {
+    const codes = getFields(record.fields).map(field => {
+      if ('subfields' in field) {
+        return field.subfields.filter(subfield => PATTERN.test(subfield.value))
+          .map(subfield => subfield.code);
+      }
 
-	async function fix(record) {
-		getFields(record.fields).forEach(field => {
-			field.subfields
-				.filter(subfield => PATTERN.test(subfield.value))
-				.forEach(subfield => {
-					subfield.value = convert(subfield.value);
-				});
-		});
-	}
+      return null;
+    });
+    return codes.length < 1 ? {valid: true, messages: []} : {valid: false, messages: [`The following subfields are not properly decomposed: ${codes.join(', ')}`]};
+  }
 
-	function getFields(fields) {
-		return fields.filter(field => {
-			if ('subfields' in field) {
-				return field.subfields.some(subfield => PATTERN.test(subfield.value));
-			}
-			return null;
-		});
-	}
-	function convert(value) {
-		return Object.keys(MAP_CONVERSION).reduce((result, key) => {
-			return result.includes(key) ? result.replace(new RegExp(key, 'g'), MAP_CONVERSION[key]) : result;
-		}, value);
-	}
+  function fix(record) {
+    getFields(record.fields).forEach(field => {
+      field.subfields
+        .filter(subfield => PATTERN.test(subfield.value))
+        .forEach(subfield => {
+          subfield.value = convert(subfield.value); // eslint-disable-line functional/immutable-data
+        });
+    });
+  }
+
+  function getFields(fields) {
+    return fields.filter(field => {
+      if ('subfields' in field) {
+        return field.subfields.some(subfield => PATTERN.test(subfield.value));
+      }
+
+      return null;
+    });
+  }
 }
+
+export function convert(value) {
+  return Object.keys(MAP_CONVERSION).reduce((result, key) => result.includes(key) ? result.replace(new RegExp(key, 'ug'), MAP_CONVERSION[key]) : result, value);
+}
+

package/src/unicode-decomposition.spec.js

@@ -1,35 +1,3 @@
-/**
- *
- * @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 no-undef, max-nested-callbacks, no-unused-expressions */
-
-'use strict';
-
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import {MarcRecord} from '@natlibfi/marc-record';
@@ -39,96 +7,102 @@ const {expect} = chai;
 chai.use(chaiAsPromised);
 
 describe('unicode-decomposition', () => {
-	it('Creates a validator', async () => {
-		const validator = await validatorFactory();
+  it('Creates a validator', async () => {
+    const validator = await validatorFactory();
 
-		expect(validator)
-			.to.be.an('object')
-			.that.has.any.keys('description', 'validate');
+    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');
-	});
+    expect(validator.description).to.be.a('string');
+    expect(validator.validate).to.be.a('function');
+  });
 
-	describe('#validate', () => {
-		it('Finds the record valid', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '245',
-						subfields: [{
-							code: 'a',
-							value: 'Föö, Bär'
-						}]
-					}
-				]
-			});
-			const result = await validator.validate(record);
-			expect(result).to.eql({valid: true, messages: []});
-		});
+  describe('#validate', () => {
+    it('Finds the record valid', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '245',
+            subfields: [
+              {
+                code: 'a',
+                value: 'Föö, Bär'
+              }
+            ]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
+      expect(result).to.eql({valid: true, messages: []});
+    });
 
-		it('Finds the record invalid', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '001',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{
-							code: 'a',
-							value: 'Föö, Bär'
-						}]
-					}
-				]
-			});
-			const result = await validator.validate(record);
+    it('Finds the record invalid', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '001',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [
+              {
+                code: 'a',
+                value: 'Föö, Bär'
+              }
+            ]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
 
-			expect(result).to.eql({valid: false, messages: ['The following subfields are not properly decomposed: a']});
-		});
+      expect(result).to.eql({valid: false, messages: ['The following subfields are not properly decomposed: a']});
+    });
 
-		describe('#fix', () => {
-			it('Should fix the record', async () => {
-				const validator = await validatorFactory();
+    describe('#fix', () => {
+      it('Should fix the record', async () => {
+        const validator = await validatorFactory();
 
-				const record = new MarcRecord({
-					fields: [{
-						tag: '245',
-						subfields: [
-							{
-								code: 'a',
-								value: 'Föö, Bär'
-							},
-							{
-								code: 'b',
-								value: '== Fubar'
-							}
-						]
-					}]
-				});
+        const record = new MarcRecord({
+          fields: [
+            {
+              tag: '245',
+              subfields: [
+                {
+                  code: 'a',
+                  value: 'Föö, Bär'
+                },
+                {
+                  code: 'b',
+                  value: '== Fubar'
+                }
+              ]
+            }
+          ]
+        });
 
-				const recordOriginal = record.toObject();
-				const fieldModified = {
-					tag: '245',
-					ind1: ' ',
-					ind2: ' ',
-					subfields: [
-						{
-							code: 'a',
-							value: 'Föö, Bär'
-						},
-						{
-							code: 'b',
-							value: '== Fubar'
-						}
-					]
-				};
-				await validator.fix(record);
+        const recordOriginal = record.toObject();
+        const fieldModified = {
+          tag: '245',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [
+            {
+              code: 'a',
+              value: 'Föö, Bär'
+            },
+            {
+              code: 'b',
+              value: '== Fubar'
+            }
+          ]
+        };
+        await validator.fix(record);
 
-				expect(recordOriginal).to.not.eql(record);
-				expect(record.fields).to.eql([fieldModified]);
-			});
-		});
-	});
+        expect(recordOriginal).to.not.eql(record);
+        expect(record.fields).to.eql([fieldModified]);
+      });
+    });
+  });
 });

package/src/update-field-540.js

@@ -0,0 +1,99 @@
+//import createDebugLogger from 'debug';
+import {fieldToString} from './utils';
+
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/update-field-540');
+
+// Author(s): Nicholas Volk
+export default function () {
+
+  return {
+    description: 'Validator for field 540 (modernization as per MELKEHITYS-2431)',
+    validate, fix
+  };
+
+  function fix(record) {
+    const fixedFields = getFieldsThatUseOldFormat(record, true);
+
+    const fixedFieldsAsStrings = fixedFields.map(f => fieldToString(f));
+
+    return {message: [], fix: fixedFieldsAsStrings, valid: true};
+  }
+
+  function validate(record) {
+    const yeOldeFields = getFieldsThatUseOldFormat(record, false);
+    if (yeOldeFields.length === 0) {
+      return {'message': [], 'valid': true};
+    }
+    const messages = yeOldeFields.map(f => fieldToString(f));
+
+    return {'message': messages, 'valid': false};
+  }
+
+}
+
+
+const licences = [
+  {'license': 'CC BY 4.0', 'url': 'https://creativecommons.org/licenses/by/4.0/deed.fi'},
+  {'license': 'CC BY-NC 4.0', 'url': 'https://creativecommons.org/licenses/by-nc/4.0/deed.fi'},
+  {'license': 'CC BY-NC-ND 4.0', 'url': 'https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fi'},
+  {'license': 'CC BY-NC-SA 4.0', 'url': 'https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fi'},
+  {'license': 'CC BY-ND 4.0', 'url': 'https://creativecommons.org/licenses/by-nd/4.0/deed.fi'},
+  {'license': 'CC BY-SA 4.0', 'url': 'https://creativecommons.org/licenses/by-sa/4.0/deed.fi'},
+  {'license': 'CC0 1.0', 'url': 'https://creativecommons.org/publicdomain/zero/1.0/deed.fi'}, // not seen/unused
+  {'license': 'Public domain', 'url': 'https://creativecommons.org/publicdomain/mark/1.0/deed.fi'}
+];
+
+function findSubfieldIndex(field, subfield) {
+  subfield.nvtmp = 1; // eslint-disable-line functional/immutable-data
+  const index = field.subfields.findIndex(sf => sf.nvtmp === 1);
+  delete subfield.nvtmp; // eslint-disable-line functional/immutable-data
+  return index;
+}
+
+function validLicenseInSubfieldC(subfieldC, license) {
+  if (subfieldC.code !== 'c') {
+    return false;
+  }
+  //nvdebug(`Compare ${subfieldC.value} vs ${license.license}`);
+  return license.license === subfieldC.value;
+}
+
+function validUrlInSubfieldU(subfieldU, license) {
+  if (subfieldU.code !== 'u') {
+    return false;
+  }
+  //nvdebug(`Compare ${subfieldU.value} vs ${license.url}`);
+  return license.url === subfieldU.value;
+}
+
+
+function fixC(field, subfieldC) {
+  // MELINDA-2431_
+  subfieldC.code = 'f'; // eslint-disable-line functional/immutable-data
+  const index = findSubfieldIndex(field, subfieldC);
+  field.subfields.splice(index + 1, 0, {'code': '2', 'value': 'cc'}); // eslint-disable-line functional/immutable-data
+}
+
+function fieldHasOldCcLicense(field, fix) {
+  if (field.tag !== '540') {
+    return false;
+  }
+  //nvdebug(`NORM 540: ${fieldToString(field)}`);
+  const validLicense = licences.find(license => field.subfields.some(sf => validLicenseInSubfieldC(sf, license)) && field.subfields.some(sf => validUrlInSubfieldU(sf, license)));
+  if (!validLicense) {
+    return false;
+  }
+  //nvdebug(` Found valid license`);
+  if (fix) { // eslint-disable-line functional/no-conditional-statements
+    const subfieldsC = field.subfields.filter(sf => validLicenseInSubfieldC(sf, validLicense));
+    subfieldsC.forEach(c => fixC(field, c));
+  }
+
+  return true;
+}
+
+
+function getFieldsThatUseOldFormat(record, fix) {
+  return record.fields.filter(f => fieldHasOldCcLicense(f, fix));
+}
+

package/src/update-field-540.spec.js

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