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

package/src/fields-present.js

@@ -1,53 +1,23 @@
-/**
- *
- * @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.
- *
- */
+export default function (tagPatterns) {
+  if (Array.isArray(tagPatterns)) {
+    return {
+      description:
+        'Checks whether the configured fields are present in the record',
+      validate
+    };
+  }
 
-/* eslint-disable require-await */
-'use strict';
+  throw new Error('No tag pattern array provided');
 
-export default async function (tagPatterns) {
-	if (Array.isArray(tagPatterns)) {
-		return {
-			description:
-				'Checks whether the configured fields are present in the record',
-			validate
-		};
-	}
-	throw new Error('No tag pattern array provided');
+  function validate(record) {
+    const missingFields = tagPatterns.map(pattern => {
+      const result = record.fields.find(field => pattern.test(field.tag));
+      return result ? undefined : pattern;
+    });
+    const isEmpty = missingFields.every(index => index === undefined);
+    let errorMessage = ['The following tag patterns are not present in the record tag field: ']; // eslint-disable-line functional/no-let
+    errorMessage = errorMessage.concat(missingFields).join(' ');
 
-	async function validate(record) {
-		const missingFields = tagPatterns.map(pattern => {
-			const result = record.fields.find(field => pattern.test(field.tag));
-			return result ? undefined : pattern;
-		});
-		const isEmpty = missingFields.every(index => index === undefined);
-		let errorMessage = ['The following tag patterns are not present in the record tag field: '];
-		errorMessage = errorMessage.concat(missingFields).join(' ');
-
-		return isEmpty ? {valid: true, messages: []} : {valid: false, messages: [errorMessage]};
-	}
+    return isEmpty ? {valid: true, messages: []} : {valid: false, messages: [errorMessage]};
+  }
 }

package/src/fields-present.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,69 +7,100 @@ const {expect} = chai;
 chai.use(chaiAsPromised);
 
 describe('fields-present', () => {
-	it('Creates a validator', async () => {
-		const validator = await validatorFactory([/^500$/, /^400$/]);
+  it('Creates a validator', async () => {
+    const validator = await validatorFactory([/^500$/u, /^400$/u]);
+
+    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');
-	});
+  it('Throws an error when tagPatterns not provided', () => {
+    try {
+      validatorFactory();
+    } catch (error) {
+      expect(error).to.be.an('error').with.property('message', 'No tag pattern array provided');
+    }
+  });
 
-	it('Throws an error when tagPatterns not provided', async () => {
-		await expect(validatorFactory()).to.be.rejectedWith(Error, 'No tag pattern array provided');
-	});
+  describe('#validate', () => {
+    it('Finds the record valid', async () => {
+      const tagPatterns = [/^5..$/u, /^FOO$/u];
+      const validator = await validatorFactory(tagPatterns);
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '500',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          },
+          {
+            tag: 'FOO',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
 
-	describe('#validate', () => {
-		it('Finds the record valid', async () => {
-			const tagPatterns = [/^5..$/, /^FOO$/];
-			const validator = await validatorFactory(tagPatterns);
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '500',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					},
-					{
-						tag: 'FOO',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					}
-				]
-			});
-			const result = await validator.validate(record);
+      expect(result).to.eql({valid: true, messages: []});
+    });
+    it('Finds the record valid', async () => {
+      const tagPatterns = [/^(020|022|024)$/u]; // eslint-disable-line
+      const validator = await validatorFactory(tagPatterns);
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '020',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          },
+          {
+            tag: '040',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
 
-			expect(result).to.eql({valid: true, messages: []});
-		});
-		it('Finds the record invalid', async () => {
-			const tagPatterns = [/^5..$/, /^FOO$/];
-			const validator = await validatorFactory(tagPatterns);
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '001',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					},
-					{
-						tag: 'BAR',
-						ind1: '1',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					}
-				]
-			});
-			const result = await validator.validate(record);
+      expect(result).to.eql({valid: true, messages: []});
+    });
+    it('Finds the record invalid', async () => {
+      const tagPatterns = [/^5..$/u, /^FOO$/u];
+      const validator = await validatorFactory(tagPatterns);
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '001',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          },
+          {
+            tag: '500',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          },
+          {
+            tag: 'BAR',
+            ind1: '1',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
 
-			expect(result).to.eql({valid: false, messages: [
-				'The following tag patterns are not present in the record tag field:  /^5..$/ /^FOO$/'
-			]});
-		});
-	});
+      expect(result).to.eql({valid: false, messages: ['The following tag patterns are not present in the record tag field:   /^FOO$/u']});
+    });
+  });
 });

package/src/fixed-fields.js

@@ -1,110 +1,77 @@
-/**
-*
-* @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.
-*
-*/
+export default function (configuration) {
+  if (Array.isArray(configuration)) {
+    return {
+      description:
+        'Validates fixed fields',
+      validate
+    };
+  }
 
-/* eslint-disable require-await */
-'use strict';
+  throw new Error('No configuration provided');
 
-export default async function (configuration) {
-	if (Array.isArray(configuration)) {
-		return {
-			description:
-			'Validates fixed fields',
-			validate
-		};
-	}
-	throw new Error('No configuration provided');
+  function validate(record) {
+    const messages = configuration.reduce((messages, item) => {
+      let results; // eslint-disable-line functional/no-let
 
-	async function validate(record) {
-		const messages = configuration.reduce((messages, item) => {
-			let results;
+      if (item.leader) { // eslint-disable-line functional/no-conditional-statements
+        results = validateField(record.leader, item);
+      } else { // eslint-disable-line functional/no-conditional-statements
+        results = record.get(item.tag)
+          .map(f => validateField(f.value, item, f.tag));
+      }
 
-			if (item.leader) {
-				results = validateField(record.leader, item);
-			} else {
-				results = record.get(item.tag)
-					.map(f => validateField(f.value, item, f.tag));
-			}
+      if (results && results.length > 0) {
+        return messages.concat(...results).reduce((acc, item) => acc.includes(item) ? acc : acc.concat(item), []);
+      }
 
-			if (results && results.length > 0) {
-				return messages.concat(...results).reduce((acc, item) => {
-					return acc.includes(item) ? acc : acc.concat(item);
-				}, []);
-			}
+      return messages;
+    }, []);
 
-			return messages;
-		}, []);
+    return {valid: messages.length === 0, messages};
 
-		return {valid: messages.length === 0, messages};
+    function validateField(value, spec, tag) {
+      const messagePrefix = tag ? `Field ${tag}` : 'Leader';
 
-		function validateField(value, spec, tag) {
-			const messagePrefix = tag ? `Field ${tag}` : 'Leader';
+      if (typeof spec.length === 'number') {
+        if (value.length !== spec.length) {
+          return [`${messagePrefix} has invalid length`];
+        }
+      }
 
-			if (typeof spec.length === 'number') {
-				if (value.length !== spec.length) {
-					return [`${messagePrefix} has invalid length`];
-				}
-			}
+      if (spec.rules) {
+        return spec.rules.reduce((messages, rule, ruleIndex) => {
+          const indexes = getIndexes(rule.position);
+          const positions = value.split('').reduce((positions, char, index) => {
+            if (indexes.includes(index) && (!rule.dependencies || rule.dependencies.every(checkDependency))) {
+              if (!rule.pattern.test(char)) {
+                return positions.concat(index);
+              }
+            }
 
-			if (spec.rules) {
-				return spec.rules.reduce((messages, rule, ruleIndex) => {
-					const indexes = getIndexes(rule.position);
-					const positions = value.split('').reduce((positions, char, index) => {
-						if (indexes.includes(index) && (!rule.dependencies || rule.dependencies.every(checkDependency))) {
-							if (!rule.pattern.test(char)) {
-								return positions.concat(index);
-							}
-						}
+            return positions;
 
-						return positions;
+            function checkDependency(dependency) {
+              const indexes = getIndexes(dependency.position);
+              return value.split('').every((char, index) => !indexes.includes(index) || dependency.pattern.test(char));
+            }
+          }, []);
 
-						function checkDependency(dependency) {
-							const indexes = getIndexes(dependency.position);
-							return value.split('').every((char, index) => {
-								return !indexes.includes(index) || dependency.pattern.test(char);
-							});
-						}
-					}, []);
+          if (positions.length > 0) {
+            return messages.concat(`${messagePrefix} has invalid values at positions: ${positions.join()} (Rule index ${ruleIndex})`);
+          }
 
-					if (positions.length > 0) {
-						return messages.concat(`${messagePrefix} has invalid values at positions: ${positions.join()} (Rule index ${ruleIndex})`);
-					}
+          return messages;
 
-					return messages;
+          function getIndexes(arg) {
+            if (Array.isArray(arg)) {
+              const indexes = [...new Array(arg[1] + 1).keys()];
+              return indexes.slice(arg[0], arg[1] + 1);
+            }
 
-					function getIndexes(arg) {
-						if (Array.isArray(arg)) {
-							const indexes = [...new Array(arg[1] + 1).keys()];
-							return indexes.slice(arg[0], arg[1] + 1);
-						}
-						return [arg];
-					}
-				}, []);
-			}
-		}
-	}
+            return [arg];
+          }
+        }, []);
+      }
+    }
+  }
 }

package/src/fixed-fields.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';
@@ -38,105 +6,93 @@ import validatorFactory from '../src/fixed-fields';
 const {expect} = chai;
 chai.use(chaiAsPromised);
 
-describe('language', () => {
-	it('Creates a validator', async () => {
-		const validator = await validatorFactory([]);
+describe('fixed-fields: language', () => {
+  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');
+  });
 
-	it('Throws an error when configuration is not provided', async () => {
-		await expect(validatorFactory()).to.be.rejectedWith(Error, 'No configuration provided');
-	});
+  it('Throws an error when configuration is not provided', () => {
+    try {
+      validatorFactory();
+    } catch (error) {
+      expect(error).to.be.an('error').with.property('message', 'No configuration provided');
+    }
+  });
 
-	describe('#validate', () => {
-		it('Finds the record valid', async () => {
-			const validator = await validatorFactory([
-				{leader: true, length: 6, rules: [
-					{position: [0, 6], pattern: /[abcdefg]/}
-				]},
-				{tag: /^FOO$/, length: 12, rules: [
-					{position: 0, pattern: /f/}
-				]},
-				{tag: /^BAR$/, length: 6, rules: [
-					{position: 0, pattern: /[fb]/},
-					{position: 1, pattern: /a/, dependencies: [
-						{position: 0, pattern: /b/}
-					]},
-					{position: [2, 3], pattern: /u/, dependencies: [
-						{position: 0, pattern: /[^b]/}
-					]}
-				]}
-			]);
-			const record = new MarcRecord({
-				leader: 'bacgfe',
-				fields: [
-					{
-						tag: 'FOO',
-						value: 'foobarfoobar'
-					},
-					{
-						tag: 'BAR',
-						value: 'bauuoo'
-					}
-				]
-			});
-			const result = await validator.validate(record);
+  describe('#validate', () => {
+    it('Finds the record valid', async () => {
+      const validator = await validatorFactory([
+        {leader: true, length: 6, rules: [{position: [0, 6], pattern: /[abcdefg]/u}]},
+        {tag: /^FOO$/u, length: 12, rules: [{position: 0, pattern: /f/u}]},
+        {tag: /^BAR$/u, length: 6, rules: [
+          {position: 0, pattern: /[fb]/u},
+          {position: 1, pattern: /a/u, dependencies: [{position: 0, pattern: /b/u}]},
+          {position: [2, 3], pattern: /u/u, dependencies: [{position: 0, pattern: /[^b]/u}]}
+        ]}
+      ]);
+      const record = new MarcRecord({
+        leader: 'bacgfe',
+        fields: [
+          {
+            tag: 'FOO',
+            value: 'foobarfoobar'
+          },
+          {
+            tag: 'BAR',
+            value: 'bauuoo'
+          }
+        ]
+      });
+      const result = await validator.validate(record);
 
-			expect(result).to.be.an('object').and.to.include({valid: true});
-		});
+      expect(result).to.be.an('object').and.to.include({valid: true});
+    });
 
-		it('Finds the record invalid', async () => {
-			const validator = await validatorFactory([
-				{leader: true, length: 6, rules: [
-					{position: [0, 6], pattern: /[abcdefg]/}
-				]},
-				{tag: /^FOO$/, length: 12, rules: [
-					{position: 0, pattern: /f/}
-				]},
-				{tag: /^BAR$/, length: 6, rules: [
-					{position: 0, pattern: /[fb]/},
-					{position: 1, pattern: /a/, dependencies: [
-						{position: 0, pattern: /b/}
-					]},
-					{position: [2, 3], pattern: /u/, dependencies: [
-						{position: 0, pattern: /[^a]/}
-					]}
-				]},
-				{tag: /^FUBAR$/, length: 5}
-			]);
-			const record = new MarcRecord({
-				leader: 'bacxfe',
-				fields: [
-					{
-						tag: 'FOO',
-						value: 'barfoofoobar'
-					},
-					{
-						tag: 'BAR',
-						value: 'burfoo'
-					},
-					{
-						tag: 'FUBAR',
-						value: 'foo'
-					}
-				]
-			});
+    it('Finds the record invalid', async () => {
+      const validator = await validatorFactory([
+        {leader: true, length: 6, rules: [{position: [0, 6], pattern: /[abcdefg]/u}]},
+        {tag: /^FOO$/u, length: 12, rules: [{position: 0, pattern: /f/u}]},
+        {tag: /^BAR$/u, length: 6, rules: [
+          {position: 0, pattern: /[fb]/u},
+          {position: 1, pattern: /a/u, dependencies: [{position: 0, pattern: /b/u}]},
+          {position: [2, 3], pattern: /u/u, dependencies: [{position: 0, pattern: /[^a]/u}]}
+        ]},
+        {tag: /^FUBAR$/u, length: 5}
+      ]);
+      const record = new MarcRecord({
+        leader: 'bacxfe',
+        fields: [
+          {
+            tag: 'FOO',
+            value: 'barfoofoobar'
+          },
+          {
+            tag: 'BAR',
+            value: 'burfoo'
+          },
+          {
+            tag: 'FUBAR',
+            value: 'foo'
+          }
+        ]
+      });
 
-			const result = await validator.validate(record);
+      const result = await validator.validate(record);
 
-			expect(result).to.eql({valid: false, messages: [
-				'Leader has invalid values at positions: 3 (Rule index 0)',
-				'Field FOO has invalid values at positions: 0 (Rule index 0)',
-				'Field BAR has invalid values at positions: 1 (Rule index 1)',
-				'Field BAR has invalid values at positions: 2,3 (Rule index 2)',
-				'Field FUBAR has invalid length'
-			]});
-		});
-	});
+      expect(result).to.eql({valid: false, messages: [
+        'Leader has invalid values at positions: 3 (Rule index 0)',
+        'Field FOO has invalid values at positions: 0 (Rule index 0)',
+        'Field BAR has invalid values at positions: 1 (Rule index 1)',
+        'Field BAR has invalid values at positions: 2,3 (Rule index 2)',
+        'Field FUBAR has invalid length'
+      ]});
+    });
+  });
 });