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

package/src/access-rights.js

@@ -0,0 +1,84 @@
+import {isElectronicMaterial} from './utils';
+
+export default function () {
+  const sf506 = [{code: 'a', value: /aineisto on käytettävissä vapaakappalekirjastoissa/ui}];
+  const sf540 = [{code: 'c', value: /laki kulttuuriaineistojen tallettamisesta ja säilyttämisestä/ui}];
+
+  function fix(record) {
+    // If printed do nothing
+
+    // If material is electronic add theis if missing
+    if (!hasTag(record, '506', sf506)) { // eslint-disable-line functional/no-conditional-statements
+      record.insertField({
+        tag: '506',
+        ind1: '1',
+        subfields: [
+          {
+            code: 'a',
+            value: 'Aineisto on käytettävissä vapaakappalekirjastoissa.'
+          }, {
+            code: 'f',
+            value: 'Online access with authorization'
+          }, {
+            code: '2',
+            value: 'star'
+          }, {
+            code: '5',
+            value: 'FI-Vapaa'
+          }, {
+            code: '9',
+            value: 'FENNI<KEEP>'
+          }
+        ]
+      });
+    }
+
+    if (!hasTag(record, '540', sf540)) { // eslint-disable-line functional/no-conditional-statements
+      record.insertField({
+        tag: '540',
+        subfields: [
+          {
+            code: 'a',
+            value: 'Aineisto on käytettävissä tutkimus- ja muihin tarkoituksiin;'
+          }, {
+            code: 'b',
+            value: 'Kansalliskirjasto;'
+          }, {
+            code: 'c',
+            value: 'Laki kulttuuriaineistojen tallettamisesta ja säilyttämisestä'
+          }, {
+            code: 'u',
+            value: 'http://www.finlex.fi/fi/laki/ajantasa/2007/20071433'
+          }, {
+            code: '5',
+            value: 'FI-Vapaa'
+          }, {
+            code: '9',
+            value: 'FENNI<KEEP>'
+          }
+        ]
+      });
+    }
+
+    return true;
+  }
+
+  function validate(record) {
+    // if not electronic skip this validator
+    if (!isElectronicMaterial(record)) {
+      return {valid: true};
+    }
+
+    return {valid: hasTag(record, '506', sf506) && hasTag(record, '540', sf540)};
+  }
+
+  return {
+    description: 'Adds access rights fields for a record (if not existing)',
+    validate,
+    fix
+  };
+
+  function hasTag(rec, tag, sfcv) {
+    return rec.fields.some(f => f.tag === tag && sfcv.every(({code, value}) => f.subfields.some(sf => sf.code === code && value.test(sf.value))));
+  }
+}

package/src/access-rights.spec.js

@@ -0,0 +1,126 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from '../src/access-rights';
+
+describe('access-rights', async () => {
+  // Fields
+  const f337 = {
+    tag: '337',
+    ind1: ' ',
+    ind2: ' ',
+    subfields: [
+      {code: 'b', value: 'c'},
+      {code: '2', value: 'rdamedia'}
+    ]
+  };
+
+  const ldf5061 = {
+    tag: '506',
+    ind1: '1',
+    ind2: ' ',
+    subfields: [
+      {code: 'a', value: 'Aineisto on käytettävissä vapaakappalekirjastoissa.'},
+      {code: 'f', value: 'Online access with authorization'},
+      {code: '2', value: 'star'},
+      {code: '5', value: 'FI-Vapaa'},
+      {code: '9', value: 'FENNI<KEEP>'}
+    ]
+  };
+
+  const ldf540 = {
+    tag: '540',
+    ind1: ' ',
+    ind2: ' ',
+    subfields: [
+      {code: 'a', value: 'Aineisto on käytettävissä tutkimus- ja muihin tarkoituksiin;'},
+      {code: 'b', value: 'Kansalliskirjasto;'},
+      {code: 'c', value: 'Laki kulttuuriaineistojen tallettamisesta ja säilyttämisestä'},
+      {code: 'u', value: 'http://www.finlex.fi/fi/laki/ajantasa/2007/20071433'},
+      {code: '5', value: 'FI-Vapaa'},
+      {code: '9', value: 'FENNI<KEEP>'}
+    ]
+  };
+
+  const f5060 = {
+    tag: '506',
+    ind1: '0',
+    ind2: ' ',
+    subfields: [
+      {code: 'a', value: 'Aineisto on vapaasti saatavissa.'},
+      {code: 'f', value: 'Unrestricted online access'},
+      {code: '2', value: 'star'},
+      {code: '9', value: 'FENNI<KEEP>'}
+    ]
+  };
+
+  const f540 = {
+    tag: '540',
+    ind1: ' ',
+    ind2: ' ',
+    subfields: [{code: 'c', value: 'This publication is copyrighted. You may download, display and print it for Your own personal use. Commercial use is prohibited.'}]
+  };
+
+  it('Creates a validator', async () => {
+    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');
+  });
+
+  // Tests
+  const test = await (async () => {
+    const validator = await validatorFactory();
+    return {
+      validate: async (valid, ...recfields) => {
+        const result = await validator.validate(new MarcRecord({fields: recfields}));
+        expect(result).to.eql({valid});
+      },
+
+      fix: async (recfields, resfields) => {
+        const record = new MarcRecord({fields: recfields});
+        await validator.fix(record);
+        expect(record.fields).to.eql(resfields);
+      }
+    };
+  })();
+
+  describe('#validate', () => {
+    it('Finds the record valid; Legal deposit fields 5061 and 540', async () => {
+      await test.validate(true, ldf5061, ldf540);
+    });
+
+    it('Finds the record invalid; Missing 5061', async () => {
+      await test.validate(false, f337, f5060, ldf540);
+    });
+
+    it('Finds the record invalid; Missing 540', async () => {
+      await test.validate(false, f337, ldf5061, f540);
+    });
+
+    it('Finds the record invalid; Missing 5061 and 540', async () => {
+      await test.validate(false, f337, f5060, f540);
+    });
+  });
+
+  describe('#fix', () => {
+    it('Legal deposit fields 5061 and 540; Nothing to add', async () => {
+      await test.fix([ldf5061, ldf540], [ldf5061, ldf540]);
+    });
+
+    it('540 but missing 5061; Adds 5061', async () => {
+      await test.fix([f5060, ldf540], [f5060, ldf5061, ldf540]);
+    });
+
+    it('5061 but missing 540; Adds 540', async () => {
+      await test.fix([ldf5061, f540], [ldf5061, ldf540, f540]);
+    });
+
+    it('Both, 5061 and 540, missing; Adds 5061 and 540', async () => {
+      await test.fix([f5060, f540], [f5060, ldf5061, ldf540, f540]);
+    });
+  });
+});

package/src/double-commas.js

@@ -1,50 +1,13 @@
-/**
- *
- * @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';
-
-export default async function () {
-	return {
-		description: 'Handle double commas in 700$e-subfields',
-		validate: async record => ({
-			valid: !record
-				.get(/^700$/)
-				.some(f =>
-					f.subfields.every(sf => sf.code === 'e' && /,,/.test(sf.value))
-				)
-		}),
-		fix: async record =>
-			record.get(/^700$/).forEach(f =>
-				f.subfields.filter(sf => sf.code === 'e').forEach(sf => {
-					sf.value = sf.value.replace(/,,/, ',');
-				})
-			)
-	};
+export default function () {
+  return {
+    description: 'Handle double commas in 700$e-subfields',
+    validate: record => ({
+      valid: !record
+        .get(/^700$/u)
+        .some(f => f.subfields.every(sf => sf.code === 'e' && (/,,/u).test(sf.value)))
+    }),
+    fix: record => record.get(/^700$/u).forEach(f => f.subfields.filter(sf => sf.code === 'e').forEach(sf => {
+      sf.value = sf.value.replace(/,,/u, ','); // eslint-disable-line functional/immutable-data
+    }))
+  };
 }

package/src/double-commas.spec.js

@@ -1,88 +1,56 @@
-/**
- *
- * @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 {expect} from 'chai';
 import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from '../src/double-commas';
 
 describe('double-commas', () => {
-	it('Creates a validator', async () => {
-		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');
-	});
-
-	describe('#validate', () => {
-		it('Finds the record valid', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [{tag: '700', subfields: [{code: 'e', value: 'foo,bar'}]}]
-			});
-			const result = await validator.validate(record);
-
-			expect(result).to.eql({valid: true});
-		});
-		it('Finds the record invalid', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [{tag: '700', subfields: [{code: 'e', value: 'foo,,bar'}]}]
-			});
-			const result = await validator.validate(record);
-
-			expect(result).to.eql({valid: false});
-		});
-	});
-
-	describe('#fix', () => {
-		it('Fixes the record', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [{tag: '700', subfields: [{code: 'e', value: 'foo,,bar'}]}]
-			});
-			await validator.fix(record);
-
-			expect(record.fields).to.eql([
-				{
-					tag: '700',
-					ind1: ' ',
-					ind2: ' ',
-					subfields: [{code: 'e', value: 'foo,bar'}]
-				}
-			]);
-		});
-	});
+  it('Creates a validator', async () => {
+    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');
+  });
+
+  describe('#validate', () => {
+    it('Finds the record valid', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [{tag: '700', subfields: [{code: 'e', value: 'foo,bar'}]}]
+      });
+      const result = await validator.validate(record);
+
+      expect(result).to.eql({valid: true});
+    });
+    it('Finds the record invalid', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [{tag: '700', subfields: [{code: 'e', value: 'foo,,bar'}]}]
+      });
+      const result = await validator.validate(record);
+
+      expect(result).to.eql({valid: false});
+    });
+  });
+
+  describe('#fix', () => {
+    it('Fixes the record', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [{tag: '700', subfields: [{code: 'e', value: 'foo,,bar'}]}]
+      });
+      await validator.fix(record);
+
+      expect(record.fields).to.eql([
+        {
+          tag: '700',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'e', value: 'foo,bar'}]
+        }
+      ]);
+    });
+  });
 });

package/src/duplicates-ind1.js

@@ -1,81 +1,41 @@
-/**
- *
- * @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 (tagPattern) {
+  if (tagPattern instanceof RegExp) {
+    return {
+      description:
+        'Handles data fields that only differ in the first indicator',
+      validate,
+      fix
+    };
+  }
 
-/* eslint-disable require-await */
-'use strict';
-import {omit} from 'lodash';
+  throw new Error('No tagPattern provided');
 
-export default async function (tagPattern) {
-	if (tagPattern instanceof RegExp) {
-		return {
-			description:
-				'Handles data fields that only differ in the first indicator',
-			validate,
-			fix
-		};
-	}
-	throw new Error('No tagPattern provided');
+  function validate(record) {
+    const invalid = iterateFields(record)
+      .find(obj => obj.validation === true);
+    return invalid ? {valid: false, messages: [`Multiple ${invalid.obj.tag} fields which only differ in the first indicator`]} : {valid: true, messages: []};
+  }
 
-	async function validate(record) {
-		const invalid = iterateFields(record)
-			.find(obj => obj.validation === true);
-		return invalid ? {valid: false, messages: [`Multiple ${invalid.obj.tag} fields which only differ in the first indicator`]} : {valid: true, messages: []};
-	}
+  function fix(record) {
+    iterateFields(record)
+      .filter(item => item.validation === false)
+      .map(({validation, ...item}) => item) // eslint-disable-line no-unused-vars
+      .forEach(({obj}) => record.removeField(obj));
+  }
 
-	async function fix(record) {
-		iterateFields(record)
-			.filter(item => item.validation === false)
-			.map(item => omit(item, ['validation']))
-			.forEach(field => record.removeField(field));
-	}
+  function iterateFields(record) {
+    return record.fields.map(obj => ({validation: matches(obj, record.fields), obj}));
+  }
 
-	function iterateFields(record) {
-		return record.fields.map(obj => {
-			return {validation: matches(obj, record.fields), obj};
-		});
-	}
+  function matches(field, fields) {
+    return tagPattern.test(field.tag) && field.ind1 === ' ' && hasDuplicate(field, fields);
+  }
 
-	function matches(field, fields) {
-		return tagPattern.test(field.tag) && field.ind1 === ' ' && hasDuplicate(field, fields);
-	}
-
-	function hasDuplicate(fieldA, fields) {
-		return fields.some(
-			fieldB =>
-				fieldA !== fieldB &&
-				fieldA.tag === fieldB.tag &&
-				fieldA.ind1 !== fieldB.ind1 &&
-				fieldA.subfields.length === fieldB.subfields.length &&
-				fieldA.subfields.every(aSf =>
-					fieldB.subfields.some(
-						bSf => aSf.code === bSf.code && aSf.value === bSf.value
-					)
-				)
-		);
-	}
+  function hasDuplicate(fieldA, fields) {
+    return fields.some(fieldB => fieldA !== fieldB &&
+      fieldA.tag === fieldB.tag &&
+      fieldA.ind1 !== fieldB.ind1 &&
+      fieldA.subfields.length === fieldB.subfields.length &&
+      fieldA.subfields.every(aSf => fieldB.subfields.some(bSf => aSf.code === bSf.code && aSf.value === bSf.value)));
+  }
 }