@natlibfi/marc-record-validators-melinda 10.2.3 → 10.3.0

package/src/removeDuplicateDataFields.js

@@ -1,7 +1,7 @@
 import createDebugLogger from 'debug';
 import {fieldHasSubfield, fieldsToString, fieldToString, nvdebug} from './utils';
 import {fieldHasOccurrenceNumber, fieldsToNormalizedString, isValidSubfield6, subfield6GetOccurrenceNumber} from './subfield6Utils';
-import {getSubfield8LinkingNumber, recordGetAllSubfield8LinkingNumbers, recordGetFieldsWithSubfield8LinkingNumber} from './subfield8Utils';
+import {fieldHasLinkingNumber, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, recordGetAllSubfield8LinkingNumbers, recordGetFieldsWithSubfield8LinkingNumber} from './subfield8Utils';
 
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
@@ -42,19 +42,6 @@ export default function () {
 }
 
 function add6s(field, record) {
-
-  /*
-  // Can't rely on nice pairs...
-  if (fieldHasSubfield(field, '6')) {
-
-    const pairs = fieldGetOccurrenceNumberPairs(field, record.fields);
-    if (pairs) {
-      return [field].concat(pairs);
-    }
-
-  }
-  */
-
   // Get all fields with given occurence number
   const sixes = field.subfields.filter(sf => isValidSubfield6(sf));
 
@@ -73,16 +60,36 @@ function add6s(field, record) {
 
 function add8s(fields, record) {
   // Not implemented yet:
-  if (fields && fields.some(f => fieldHasSubfield(f, '8'))) {
-    return [];
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
+  if (linkingNumbers.length === 0) {
+    return fields;
+  }
+
+  nvdebug(`Linking number(s): ${linkingNumbers.join(', ')}`);
+  linkingNumbers.forEach(number => collectLinkingNumberFields(number));
+
+  fields.forEach(f => nvdebug(`AFTER ADDING 8s: '${fieldToString(f)}'`));
+
+  return fields;
+
+  function collectLinkingNumberFields(linkingNumber) {
+    // Remove existing hits (to avoid field repetition):
+    fields = fields.filter(f => !fieldHasLinkingNumber(f, linkingNumber)); // eslint-disable-line functional/immutable-data, no-param-reassign
+    // Add them and their "sisters" back:
+    const addableFields = record.fields.filter(f => fieldHasLinkingNumber(f, linkingNumber));
+    addableFields.forEach(f => nvdebug(`(RE-?)ADD ${fieldToString(f)}`));
+    fields = fields.concat(addableFields); // eslint-disable-line functional/immutable-data, no-param-reassign
+
   }
-  return record ? fields : fields;
 }
 
+/*
 function numberOfLinkageSubfields(field) {
+  nvdebug(`N of Linkage Subs(${fieldToString(field)})`);
   const subfields = field.subfields.filter(sf => sf.code === '6' || sf.code === '8');
   return subfields.length;
 }
+*/
 
 
 function getAllLinkedSubfield6Fields(field, record) {
@@ -90,12 +97,48 @@ function getAllLinkedSubfield6Fields(field, record) {
   const moreFields = add8s(fields, record);
 
   // Currently we don't handle fields with more than one $6 and/or $8 subfield.
-  if (moreFields.length === 0 || moreFields.some(f => numberOfLinkageSubfields(f) > 1)) {
+  if (moreFields.length > fields.length) {
     return []; // Don't fix!
   }
   return moreFields;
 }
 
+function getAllLinkedSubfield68Fields(field, record) {
+  const fields = add6s(field, record);
+  return add8s(fields, record);
+}
+
+function isRelevantSubfield6Chain(fields) {
+  if (fields.length < 2) { // 1 non-880-field and 1+ 880 fields
+    return false;
+  }
+  const non880 = fields.filter(f => f.tag !== '880');
+  if (non880.length !== 1) {
+    return false;
+  }
+
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
+  if (linkingNumbers.length !== 0) {
+    return false;
+  }
+
+  return fields.every(f => fieldHasSubfield(f, '6'));
+}
+
+function isRelevantSubfield68Chain(fields) {
+  if (fields.length < 3) {
+    return false;
+  }
+
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
+  if (linkingNumbers.length !== 1) {
+    nvdebug(`Expected one linking number, got ${linkingNumbers.length}: ${linkingNumbers.join(', ')}`);
+    return false;
+  }
+
+  return fields.some(f => fieldHasSubfield(f, '6'));
+}
+
 function getFirstField(record, fields) {
   const fieldsAsStrings = fields.map(field => fieldToString(field));
   record.fields.forEach((field, i) => nvdebug(`${i}:\t${fieldToString(field)}`));
@@ -109,25 +152,40 @@ function getFirstField(record, fields) {
   return undefined;
 }
 
+function fieldIsFirstFieldInChain(field, chain, record) {
+  // Interpretation of first: position of field in record (however, we might have a duplicate field. See tests...)
+  const firstField = getFirstField(record, chain);
+  if (firstField) {
+    return fieldToString(field) === fieldToString(firstField);
+  }
+  return false;
+
+}
 
 function isFirstLinkedSubfield6Field(field, record) {
   if (!field.subfields) { // Is not a datafield
     return false;
   }
   const chain = getAllLinkedSubfield6Fields(field, record);
-  if (chain.length < 2) {
+  if (!isRelevantSubfield6Chain(chain)) {
+    nvdebug(`Rejected 6: ${fieldsToString(chain)}`);
     return false;
   }
 
-  // Interpretation of first: position of field in record (however, we might have a duplicate field. See tests...)
-  const firstField = getFirstField(record, chain);
-  if (firstField) {
-    return fieldToString(field) === fieldToString(firstField);
+  return fieldIsFirstFieldInChain(field, chain, record);
+}
+
+function isFirstLinkedSubfield68Field(field, record) {
+  if (!field.subfields) { // Is not a datafield
+    return false;
+  }
+  const chain = getAllLinkedSubfield68Fields(field, record);
+  if (!isRelevantSubfield68Chain(chain)) {
+    //nvdebug(`Rejected 68: ${fieldsToString(chain)}`);
+    return false;
   }
-  return false;
 
-  // Fallback:
-  //return fieldToString(field) === fieldToString(chain[0]);
+  return fieldIsFirstFieldInChain(field, chain, record);
 }
 
 export function removeIndividualDuplicateDatafields(record, fix = true) { // No $6 nor $8 in field
@@ -253,25 +311,73 @@ export function removeDuplicateSubfield8Chains(record, fix = true) {
   return removables;
 }
 
+export function removeDuplicateSubfield68Chains(record, fix = true) {
+  /* eslint-disable */
+  let seen = {};
+
+  let removables = []; // for validation
+
+  const fields = record.fields.filter(field => isFirstLinkedSubfield68Field(field, record));
+
+  fields.forEach(field => removeDuplicateDatafield68(field));
+
+  function removeDuplicateDatafield68(field) {
+    nvdebug(`removeDuplicateDatafield? $6-$8 ${fieldToString(field)} (and friends)`);
+    const fields = getAllLinkedSubfield68Fields(field, record);
+    if (!isRelevantSubfield68Chain(fields)) {
+      return;
+    }
+  
+    const fieldsAsString = fieldsToNormalizedString(fields);
+
+    const altFieldsAsString = fieldsAsString.substring(0, 1) === '7' ? `1${fieldsAsString.substring(1)}` : fieldsAsString;
+    nvdebug(` step 2 ${fieldsAsString}`);
+    if (fieldsAsString in seen || altFieldsAsString in seen) {
+      nvdebug(` step 3 ${fieldsAsString}`);
+
+      removables.push(fieldsAsString);
+
+      if (fix) {
+        nvdebug(`$68 DOUBLE REMOVAL: REMOVE ${fieldsAsString}`, debug);
+        fields.forEach(currField => record.removeField(currField));
+        return;
+      }
+
+      nvdebug(`$68 VALIDATION: DUPLICATE DETECTED ${fieldsAsString}`, debug);
+      
+    }
+    nvdebug(`$68 DOUBLE REMOVAL OR VALIDATION: ADD2SEEN ${fieldsAsString}`, debug);
+    seen[fieldsAsString] = 1;
+    return;
+  }
+  /* eslint-enable */
+  return removables;
+}
+
 export function removeDuplicateSubfield6Chains(record, fix = true) {
   /* eslint-disable */
   let seen = {};
 
   let removables = []; // for validation
 
-  record.fields.forEach(field => nvdebug(`DUPL-CHECK $CHAIN ${fieldToString(field)}, mode=${fix ? 'FIX' : 'VALIDATE'}`));
+  record.fields.forEach(field => nvdebug(`$6-DUPL-CHECK CHAIN ${fieldToString(field)}, mode=${fix ? 'FIX' : 'VALIDATE'}`));
   
   const fields = record.fields.filter(field => isFirstLinkedSubfield6Field(field, record)); // Well a
+  //fields.forEach(field => nvdebug(`$6-DUPL-CHECK CHAIN HEAD ${fieldToString(field)}, mode=${fix ? 'FIX' : 'VALIDATE'}`));
   
-  fields.forEach(field => removeDuplicateDatafield(field));
 
-  function removeDuplicateDatafield(field) {
+  fields.forEach(field => removeDuplicateDatafield6(field));
+
+  
+
+  function removeDuplicateDatafield6(field) {
     nvdebug(`removeDuplicateDatafield? $6 ${fieldToString(field)} (and friends)`);
     const fields = getAllLinkedSubfield6Fields(field, record);
-    if(fields.length === 0) {
+    if (!isRelevantSubfield6Chain(fields)) {
       return;
     }
 
+
     const fieldsAsString = fieldsToNormalizedString(fields);
     // Frequencly list for $6 subfields in 1XX/7XX fields:
     // 231115 100
@@ -310,11 +416,15 @@ export function removeDuplicateSubfield6Chains(record, fix = true) {
 
 export function removeDuplicateDatafields(record, fix = true) {
   const removables = removeIndividualDuplicateDatafields(record, fix); // Lone fields
+  // NB! Do $6+$8 before mere $8!
+  const removables68 = removeDuplicateSubfield68Chains(record, fix); // Single $6 + $8
+
   const removables8 = removeDuplicateSubfield8Chains(record, fix); // Lone subfield $8 chains
   const removables6 = removeDuplicateSubfield6Chains(record, fix); // Lone subfield $6 chains
+
   // HOW TO HANDLE $6+$8 combos?
 
-  const removablesAll = removables.concat(removables8).concat(removables6);
+  const removablesAll = removables.concat(removables68).concat(removables6).concat(removables8);
 
   return removablesAll;
 }

package/src/removeInferiorDataFields.js

@@ -0,0 +1,97 @@
+import createDebugLogger from 'debug';
+import {fieldToString, nvdebug} from './utils';
+
+// Relocated from melinda-marc-record-merge-reducers (and renamed)
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:removeSubsetDataFields');
+
+export default function () {
+  return {
+    description: 'Remove subset data fields. Certain exceptions apply, mainly too complited chained fields',
+    validate, fix
+  };
+
+  function fix(record) {
+    nvdebug('Fix record: remove subset data fields', debug);
+    const res = {message: [], fix: [], valid: true};
+    removeInferiorDatafields(record, true);
+    // This can not really fail...
+    return res;
+  }
+
+  function validate(record) {
+    // Check max, and check number of different indexes
+    nvdebug('Validate record: remove subset data fields', debug);
+
+    const duplicates = removeInferiorDatafields(record, false);
+
+    const res = {message: duplicates};
+
+    res.valid = res.message.length < 1; // eslint-disable-line functional/immutable-data
+    return res;
+  }
+}
+
+function deriveIndividualDeletables(record) {
+  /* eslint-disable */
+  let deletableStringsArray = [];
+
+  record.fields.forEach(field => fieldDeriveIndividualDeletables(field));
+
+  function fieldDeriveIndividualDeletables(field) {
+    const fieldAsString = fieldToString(field);
+
+    // Proof-of-concept rule:
+    let tmp = fieldAsString;
+    if (field.tag.match(/^[1678]00$/u)) {
+      while (tmp.match(/, ‡e [^‡]+\.$/)) {
+        tmp = tmp.replace(/, ‡e [^‡]+\.$/, '.');
+        deletableStringsArray.push(tmp);
+      }
+    }
+
+
+    // Remove keepless versions:
+    tmp = fieldAsString;
+    while (tmp.match(/ ‡9 [A-Z]+<KEEP>/)) {
+      tmp = tmp.replace(/ ‡9 [A-Z]+<KEEP>/, '');
+      deletableStringsArray.push(tmp);
+    }
+  }
+  /* eslint-enable */
+  return deletableStringsArray; // we should do uniq!
+
+}
+
+export function removeIndividualInferiorDatafields(record, fix = true) { // No $6 nor $8 in field
+  const deletableFieldsAsStrings = deriveIndividualDeletables(record);
+  const hits = record.fields.filter(field => isDeletableField(field));
+
+  const deletedFieldsAsStrings = hits.map(f => fieldToString(f));
+
+  if (fix) { // eslint-disable-line functional/no-conditional-statement
+    hits.forEach(field => {
+      nvdebug(`Remove inferior field: ${fieldToString(field)}`);
+      record.removeField(field);
+    });
+  }
+
+  return deletedFieldsAsStrings;
+
+  function isDeletableField(field) {
+    const fieldAsString = fieldToString(field);
+    return deletableFieldsAsStrings.includes(fieldAsString);
+  }
+}
+
+
+export function removeInferiorDatafields(record, fix = true) {
+  const removables = removeIndividualInferiorDatafields(record, fix); // Lone fields
+  //const removables8 = removeDuplicateSubfield8Chains(record, fix); // Lone subfield $8 chains
+  //const removables6 = removeDuplicateSubfield6Chains(record, fix); // Lone subfield $6 chains
+  // HOW TO HANDLE $6+$8 combos?
+
+  const removablesAll = removables; //.concat(removables8).concat(removables6);
+
+  return removablesAll;
+}

package/src/removeInferiorDataFields.spec.js

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

@@ -10,7 +10,7 @@ export function isValidSubfield8(subfield) {
     return false;
   }
 
-  nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}'`);
+  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}'`);
   const match = subfield.value.match(sf8Regexp);
   //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}' vs ${match.length}}`);
   return match && match.length > 0;
@@ -32,25 +32,25 @@ export function getSubfield8LinkingNumber(subfield) {
 }
 
 
+export function fieldHasLinkingNumber(field, linkingNumber) {
+  if (!field.subfields) {
+    return false;
+  }
+  return field.subfields.some(sf => getSubfield8LinkingNumber(sf) === linkingNumber);
+}
+
 export function recordGetFieldsWithSubfield8LinkingNumber(record, linkingNumber) {
   if (linkingNumber < 1) {
     return;
   }
-  return record.fields.filter(field => relevant4GFWS8I(field));
-
-  function relevant4GFWS8I(field) {
-    if (!field.subfields) {
-      return false;
-    }
-    return field.subfields.some(sf => getSubfield8LinkingNumber(sf) === linkingNumber);
-  }
+  return record.fields.filter(field => fieldHasLinkingNumber(field, linkingNumber));
 }
 
 
-export function recordGetAllSubfield8LinkingNumbers(record) {
+export function fieldsGetAllSubfield8LinkingNumbers(fields) {
   /* eslint-disable */
   let subfield8LinkingNumbers = [];
-  record.fields.forEach(field => {
+  fields.forEach(field => {
     if (!field.subfields) {
       return;
     }
@@ -66,4 +66,9 @@ export function recordGetAllSubfield8LinkingNumbers(record) {
 
   return subfield8LinkingNumbers;
   /* eslint-enable */
+
+}
+
+export function recordGetAllSubfield8LinkingNumbers(record) {
+  return fieldsGetAllSubfield8LinkingNumbers(record.fields);
 }

package/test-fixtures/punctuation2/01/expectedResult.json

@@ -0,0 +1,12 @@
+{
+  "message": [
+    "'100 1  ‡a Tuisku, Sara ‡e turkulainen ‡e testaaja' => '100 1  ‡a Tuisku, Sara, ‡e turkulainen, ‡e testaaja.'",
+    "'700 1  ‡a Reipas, R. ‡d 2000- ‡e esittäjä' => '700 1  ‡a Reipas, R., ‡d 2000- ‡e esittäjä.'",
+    "'700 1  ‡a Reippaahko, R. ‡d 2000-' => '700 1  ‡a Reippaahko, R., ‡d 2000-'",
+    "'700 1  ‡a Reippaampi, R. ‡d 2000-2050 ‡e esittäjä' => '700 1  ‡a Reippaampi, R., ‡d 2000-2050, ‡e esittäjä.'",
+    "'700 1  ‡a Reippain, R. ‡d 2000-2050' => '700 1  ‡a Reippain, R., ‡d 2000-2050.'",
+    "'700 1  ‡a Nalle, P. ‡d 1926- ‡0 (FIN11)000000000' => '700 1  ‡a Nalle, P., ‡d 1926- ‡0 (FIN11)000000000'"
+  ],
+  "valid": false
+
+}

package/test-fixtures/punctuation2/01/metadata.json

@@ -0,0 +1,6 @@
+{
+  "description":"validate 01 - fix punctuation of X00 fields. Non-X00 fields are fine",
+  "enabled": true,
+  "fix": false,
+  "only": false
+}

package/test-fixtures/punctuation2/01/record.json

@@ -0,0 +1,37 @@
+{
+  "leader": "01331cam a22003494i 4500",
+  "fields": [
+    { "tag": "001", "value": "000000001" },
+    { "tag": "041", "ind1": " ", "ind2": " ", "subfields": [ { "code": "a", "value": "fin" } ] },
+
+    { "tag": "100", "ind1": "1", "ind2": " ", "subfields": [
+        { "code": "a", "value": "Tuisku, Sara" },
+        { "code": "e", "value": "turkulainen" },
+        { "code": "e", "value": "testaaja" }
+      ]
+    },
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+        { "code": "a", "value": "Reipas, R." },
+        { "code": "d", "value": "2000-" },
+        { "code": "e", "value": "esittäjä" }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Reippaahko, R." },
+      { "code": "d", "value": "2000-" }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Reippaampi, R." },
+      { "code": "d", "value": "2000-2050" },
+      { "code": "e", "value": "esittäjä" }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Reippain, R." },
+      { "code": "d", "value": "2000-2050" }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Nalle, P." },
+      { "code": "d", "value": "1926-" },
+      { "code": "0", "value": "(FIN11)000000000"}
+    ]}
+  ]
+}

package/test-fixtures/punctuation2/02/expectedResult.json

@@ -0,0 +1,4 @@
+{
+  "message": [],
+  "valid": true
+}

package/test-fixtures/punctuation2/02/metadata.json

@@ -0,0 +1,6 @@
+{
+  "description":"field 245 punctuation test",
+  "enabled": true,
+  "fix": false,
+  "only": false
+}

package/test-fixtures/punctuation2/02/record.json

@@ -0,0 +1,14 @@
+{
+  "leader": "01331cam a22003494i 4500",
+  "fields": [
+    { "tag": "100", "ind1": "1", "ind2": "0", "subfields": [
+        { "code": "a", "value": "Sukunimi, Etunimi," },
+        { "code": "e", "value": "säveltäjä." }
+      ]
+    },
+    { "tag": "245", "ind1": "1", "ind2": "0", "subfields": [
+      { "code": "a", "value": "Only valid fields in this test /" },
+      { "code": "c", "value": "Tekijä." }
+    ]}
+  ]
+}

package/test-fixtures/punctuation2/04/expectedResult.json

@@ -0,0 +1,7 @@
+{
+  "message": [
+    "'245 10 ‡a Manun illallinen ‡c Tellervo Koivisto' => '245 10 ‡a Manun illallinen / ‡c Tellervo Koivisto'",
+    "'245 10 ‡a Manun illallinen ‡b lentopallosta hiustöyhtöön ‡c Tellervo Koivisto' => '245 10 ‡a Manun illallinen : ‡b lentopallosta hiustöyhtöön / ‡c Tellervo Koivisto'"
+  ],
+  "valid": false
+}

package/test-fixtures/punctuation2/04/metadata.json

@@ -0,0 +1,6 @@
+{
+  "description":"field 245 punctuation",
+  "enabled": true,
+  "fix": false,
+  "only": false
+}

package/test-fixtures/punctuation2/04/record.json

@@ -0,0 +1,22 @@
+{
+  "leader": "01331cam a22003494i 4500",
+  "fields": [
+    { "tag": "245", "ind1": "1", "ind2": "0", "subfields": [
+        { "code": "a", "value": "Manun illallinen" },
+        { "code": "c", "value": "Tellervo Koivisto" }
+      ]
+    },
+    {
+      "tag": "245", "ind1": "1", "ind2": "0",
+      "subfields": [
+        { "code": "a", "value": "Manun illallinen" },
+        { "code": "b", "value": "lentopallosta hiustöyhtöön" },
+        { "code": "c", "value": "Tellervo Koivisto" }
+      ]
+    },
+    { "tag": "245", "ind1": "1", "ind2": "0", "subfields": [
+      { "code": "a", "value": "OK-otsikko /" },
+      { "code": "c", "value": "Tekijä." }
+    ]}
+  ]
+}

package/test-fixtures/punctuation2/05/expectedResult.json

@@ -0,0 +1,6 @@
+{
+  "message": [
+    "'300 1  ‡a 740 sivua ‡b kuvitettu ‡c 25 cm ‡e 1 CD-levy' => '300 1  ‡a 740 sivua : ‡b kuvitettu ; ‡c 25 cm + ‡e 1 CD-levy'"
+  ],
+  "valid": false
+}

package/test-fixtures/punctuation2/05/metadata.json

@@ -0,0 +1,6 @@
+{
+  "description":"05: punc 300",
+  "enabled": true,
+  "fix": false,
+  "only": false
+}

package/test-fixtures/punctuation2/05/record.json

@@ -0,0 +1,12 @@
+{
+  "leader": "01331cam a22003494i 4500",
+  "fields": [
+    { "tag": "300", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "740 sivua" },
+      { "code": "b", "value": "kuvitettu" },
+      { "code": "c", "value": "25 cm" },
+      { "code": "e", "value": "1 CD-levy" }
+    ]}
+ 
+  ]
+}

package/test-fixtures/punctuation2/98/expectedResult.json

@@ -0,0 +1,39 @@
+{
+  "_validationOptions": {},
+  "leader": "01331cam a22003494i 4500",
+  "fields": [
+    { "tag": "001", "value": "000000001" },
+    { "tag": "041", "ind1": " ", "ind2": " ", "subfields": [ { "code": "a", "value": "fin" } ] },
+
+    { "tag": "100", "ind1": "1", "ind2": " ", "subfields": [
+        { "code": "a", "value": "Tuisku, Sara," },
+        { "code": "e", "value": "turkulainen," },
+        { "code": "e", "value": "testaaja." }
+      ]
+    },
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+        { "code": "a", "value": "Reipas, R.," },
+        { "code": "d", "value": "2000-" },
+        { "code": "e", "value": "esittäjä." }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Reippaahko, R.," },
+      { "code": "d", "value": "2000-" }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Reippaampi, R.," },
+      { "code": "d", "value": "2000-2050," },
+      { "code": "e", "value": "esittäjä." }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Reippain, R.," },
+      { "code": "d", "value": "2000-2050." }
+    ]},
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Nalle, P.," },
+      { "code": "d", "value": "1926-" },
+      { "code": "0", "value": "(FIN11)000000000"}
+    ]}
+  ]
+
+}

package/test-fixtures/punctuation2/98/metadata.json

@@ -0,0 +1,6 @@
+{
+  "description":"validate 01 - fix punctuation of X00 fields. Non-X00 fields are fine",
+  "enabled": true,
+  "fix": true,
+  "only": false
+}