@natlibfi/marc-record-validators-melinda 10.14.0 → 10.15.0-alpha.1

package/src/normalize-dashes.js

@@ -0,0 +1,69 @@
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+import {fieldToString, isControlSubfieldCode, nvdebug} from './utils';
+
+// Author(s): Nicholas Volk
+export default function () {
+
+  return {
+    description: 'Normalize various dashes to "-"',
+    validate, fix
+  };
+
+  function fix(record) {
+    nvdebug(`FIX ME`);
+    record.fields.forEach(field => {
+      fixDashes(field);
+    });
+
+    const res = {message: [], fix: [], valid: true};
+    return res;
+  }
+
+  function validate(record) {
+    const res = {message: []};
+
+    nvdebug(`VALIDATE ME`);
+    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);
+    nvdebug(` VALIDATE FIELD '${orig}'`);
+
+    const normalizedField = fixDashes(clone(field));
+    const mod = fieldToString(normalizedField);
+    if (orig === mod) { // Fail as the input is "broken"/"crap"/sumthing
+      return;
+    }
+    res.message.push(`'TODO: ${orig}' => '${mod}'`); // eslint-disable-line functional/immutable-data
+    return;
+  }
+}
+
+
+function fixDashes(field) {
+  if (!field.subfields) {
+    return field;
+  }
+
+  nvdebug(`Dashing ${fieldToString(field)}`);
+
+  field.subfields.forEach(sf => subfieldFixDashes(sf));
+
+  return field;
+
+  function subfieldFixDashes(subfield) {
+    if (isControlSubfieldCode(subfield.code)) {
+      return;
+    }
+    // Normalize dashes U+2010 ... U+2015 to '-':
+    subfield.value = subfield.value.replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/ug, '-'); // eslint-disable-line functional/immutable-data
+  }
+
+}

package/src/normalize-dashes.spec.js

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

@@ -1,22 +1,21 @@
 // Taken from project marc-record-js, file marcSortFields.js as this contains more and more Melinda-specific rules.
 
 import clone from 'clone';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 import {fieldHasSubfield, fieldToString} from './utils';
+import {sortByTag, sortAlphabetically, fieldOrderComparator as globalFieldOrderComparator} from '@natlibfi/marc-record/dist/marcFieldSort';
 import {isValidSubfield8} from './subfield8Utils';
 import {isValidSubfield6, subfield6GetOccurrenceNumber} from './subfield6Utils';
 
-
-const BIG_BAD_NUMBER = 999.99;
-
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortFields');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortFields');
 //const debugData = debug.extend('data');
-const debugDev = debug.extend('dev');
+//const debugDev = debug.extend('dev');
 
+const BIG_BAD_NUMBER = 999999999;
 export default function () {
 
   return {
-    description: 'Sort fields',
+    description: 'Sort fields using both generic and Melinda specific rules',
     validate, fix
   };
 
@@ -84,310 +83,222 @@ export function scoreRelatorTerm(value) { // sortRelatorTerms.js validator shoul
 
 export function fieldOrderComparator(fieldA, fieldB) {
 
+  //const sorterFunctions = [sortByTag, sortByIndexTerms, sortAlphabetically, sortByRelatorTerm, sortByOccurrenceNumber, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
+
   const sorterFunctions = [sortByTag, sortByIndexTerms, sortAlphabetically, sortByRelatorTerm, sortByOccurrenceNumber, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
+  //const sorterFunctions = [sortByIndexTerms, sortByRelatorTerm, sortByOccurrenceNumber, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
 
-  for (const sortFn of sorterFunctions) { // eslint-disable-line functional/no-loop-statements
-    const result = sortFn(fieldA, fieldB);
-    debugDev(`${sortFn.name}: '${fieldToString(fieldA)}' vs '${fieldToString(fieldB)}': ${result}`);
-    if (result !== 0) {
-      return result;
-    }
-  }
+  return globalFieldOrderComparator(fieldA, fieldB, sorterFunctions);
+}
 
-  return 0;
+function sortByIndexTerms(fieldA, fieldB) { // eslint-disable-line complexity, max-statements
 
-  function sortByTag(fieldA, fieldB) {
-
-    function getSortIndex(tag) {
-      const sortIndex = {
-        LDR: '000',
-        STA: '001.1', // STA comes now after 001. However 003+001 form a combo, so I'm not sure...
-        SID: '999.1',
-        LOW: '999.2',
-        CAT: '999.3',
-        HLI: '999.4'
-      };
-
-      if (tag in sortIndex) { // <- this allows weights for numeric values as well (not that we use them yet)
-        return sortIndex[tag];
-      }
-      if (isNaN(tag)) {
-        return '999.9';
-      }
-      return tag;
-    }
+  const indexTermFields = ['600', '610', '611', '630', '648', '650', '651', '652', '653', '654', '655', '656', '657', '658', '659', '662'];
 
-    const orderA = getSortIndex(fieldA.tag);
-    const orderB = getSortIndex(fieldB.tag);
+  function scoreInd2(val) {
+    const ind2Score = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 8, '5': 5, '6': 6, '7': 7};
 
-    if (orderA > orderB) {
-      return 1;
-    }
-    if (orderA < orderB) {
-      return -1;
+    if (val in ind2Score) {
+      return ind2Score[val];
     }
+    return 9;
+  }
 
+  // ATM this is not needed.
+  // You may need this, if you change compare function order in sorterFunctions
+  // istanbul ignore next
+  if (fieldA.tag !== fieldB.tag) {
     return 0;
   }
 
-  function sortByIndexTerms(fieldA, fieldB) { // eslint-disable-line complexity, max-statements
-
-    const indexTermFields = ['600', '610', '611', '630', '648', '650', '651', '652', '653', '654', '655', '656', '657', '658', '659', '662'];
+  if (!indexTermFields.includes(fieldA.tag)) {
+    return 0;
+  }
 
-    function scoreInd2(val) {
-      const ind2Score = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 8, '5': 5, '6': 6, '7': 7};
+  // Puts ind2=4 last
+  if (scoreInd2(fieldA.ind2) > scoreInd2(fieldB.ind2)) {
+    return 1;
+  }
+  if (scoreInd2(fieldA.ind2) < scoreInd2(fieldB.ind2)) {
+    return -1;
+  }
 
-      if (val in ind2Score) {
-        return ind2Score[val];
-      }
-      return 9;
-    }
+  function scoreDictionary(dictionary) {
+    const dictionarySortIndex = {
+      'yso/fin': 0,
+      'yso/swe': 1,
+      'yso/eng': 2,
+      'slm/fin': 0.1,
+      'slm/swe': 1.1,
+      'kauno/fin': 2.1,
+      'kauno/swe': 2.2,
+      'kaunokki': 4,
+      'bella': 5
+    };
 
-    // ATM this is not needed.
-    // You may need this, if you change compare function order in sorterFunctions
-    // istanbul ignore next
-    if (fieldA.tag !== fieldB.tag) {
-      return 0;
+    if (dictionary in dictionarySortIndex) {
+      return dictionarySortIndex[dictionary];
     }
+    return BIG_BAD_NUMBER;
+  }
 
-    if (!indexTermFields.includes(fieldA.tag)) {
-      return 0;
-    }
+  const dictionaryA = selectFirstValue(fieldA, '2');
+  const dictionaryB = selectFirstValue(fieldB, '2');
 
-    /* Puts ind2=4 last */
-    if (scoreInd2(fieldA.ind2) > scoreInd2(fieldB.ind2)) {
-      return 1;
-    }
-    if (scoreInd2(fieldA.ind2) < scoreInd2(fieldB.ind2)) {
-      return -1;
-    }
+  const dictScoreA = scoreDictionary(dictionaryA);
+  const dictScoreB = scoreDictionary(dictionaryB);
+  // Use priority order for listed dictionaries:
+  if (dictScoreA > dictScoreB) {
+    return 1;
+  }
+  if (dictScoreA < dictScoreB) {
+    return -1;
+  }
+  // Unlisted dictionaries: sort $2 value alphabetically:
+  //if (dictScoreA === BIG_BAD_NUMBER) {
+  if (dictionaryA > dictionaryB) {
+    return 1;
+  }
+  if (dictionaryA < dictionaryB) {
+    return -1;
+  }
+  //}
+  return 0;
+}
 
-    function scoreDictionary(dictionary) {
-      const dictionarySortIndex = {
-        'yso/fin': 0,
-        'yso/swe': 1,
-        'yso/eng': 2,
-        'slm/fin': 0.1,
-        'slm/swe': 1.1,
-        'kauno/fin': 2.1,
-        'kauno/swe': 2.2,
-        'kaunokki': 4,
-        'bella': 5
-      };
-
-      if (dictionary in dictionarySortIndex) {
-        return dictionarySortIndex[dictionary];
-      }
-      return BIG_BAD_NUMBER;
-    }
 
-    const dictionaryA = selectFirstValue(fieldA, '2');
-    const dictionaryB = selectFirstValue(fieldB, '2');
+function preferKeep(fieldA, fieldB, keepOwner = 'FENNI') {
+  const hasKeepA = fieldHasSubfield(fieldA, '9', `${keepOwner}<KEEP>`);
+  const hasKeepB = fieldHasSubfield(fieldB, '9', `${keepOwner}<KEEP>`);
 
-    const dictScoreA = scoreDictionary(dictionaryA);
-    const dictScoreB = scoreDictionary(dictionaryB);
-    // Use priority order for listed dictionaries:
-    if (dictScoreA > dictScoreB) {
-      return 1;
-    }
-    if (dictScoreA < dictScoreB) {
-      return -1;
-    }
-    // Unlisted dictionaries: sort $2 value alphabetically:
-    //if (dictScoreA === BIG_BAD_NUMBER) {
-    if (dictionaryA > dictionaryB) {
-      return 1;
-    }
-    if (dictionaryA < dictionaryB) {
-      return -1;
-    }
-    //}
-    return 0;
+  if (hasKeepA && !hasKeepB) {
+    return -1;
+  }
+  if (!hasKeepA && hasKeepB) {
+    return 1;
   }
 
-  function preferKeep(fieldA, fieldB, keepOwner = 'FENNI') {
-    const hasKeepA = fieldHasSubfield(fieldA, '9', `${keepOwner}<KEEP>`);
-    const hasKeepB = fieldHasSubfield(fieldB, '9', `${keepOwner}<KEEP>`);
+  return 0;
+}
 
-    if (hasKeepA && !hasKeepB) {
-      return -1;
-    }
-    if (!hasKeepA && hasKeepB) {
-      return 1;
-    }
 
-    return 0;
+function preferFenniKeep(fieldA, fieldB) {
+  const fenniPreference = preferKeep(fieldA, fieldB, 'FENNI');
+  if (fenniPreference !== 0) {
+    return fenniPreference;
+  }
+  const violaPreference = preferKeep(fieldA, fieldB, 'VIOLA');
+  if (violaPreference !== 0) {
+    return violaPreference;
   }
+  return preferKeep(fieldA, fieldB, 'FIKKA');
+}
 
-  function preferFenniKeep(fieldA, fieldB) {
-    const fenniPreference = preferKeep(fieldA, fieldB, 'FENNI');
-    if (fenniPreference !== 0) {
-      return fenniPreference;
-    }
-    const violaPreference = preferKeep(fieldA, fieldB, 'VIOLA');
-    if (violaPreference !== 0) {
-      return violaPreference;
-    }
-    return preferKeep(fieldA, fieldB, 'FIKKA');
+function sortByRelatorTerm(fieldA, fieldB) {
+  // Should this be done to 6XX and 8XX fields as well? Does $t affect sorting?
+  if (!['700', '710', '711', '730'].includes(fieldA.tag)) {
+    return 0;
   }
 
-  function sortByRelatorTerm(fieldA, fieldB) {
-    // Should this be done to 6XX and 8XX fields as well? Does $t affect sorting?
-    if (!['700', '710', '711', '730'].includes(fieldA.tag)) {
+  function fieldGetMaxRelatorTermScore(field) {
+    if (!field.subfields) {
       return 0;
     }
+    const e = field.subfields.filter(sf => sf.code === 'e');
+    const scores = e.map(sf => scoreRelatorTerm(sf.value));
+    //debugDev(`RELATOR SCORE FOR '${fieldToString(field)}': ${scores.join(', ')}`);
+    return Math.max(...scores);
+  }
 
+  const scoreA = fieldGetMaxRelatorTermScore(fieldA);
+  const scoreB = fieldGetMaxRelatorTermScore(fieldB);
 
-    function fieldGetMaxRelatorTermScore(field) {
-      if (!field.subfields) {
-        return 0;
-      }
-      const e = field.subfields.filter(sf => sf.code === 'e');
-      const scores = e.map(sf => scoreRelatorTerm(sf.value));
-      //debugDev(`RELATOR SCORE FOR '${fieldToString(field)}': ${scores.join(', ')}`);
-      return Math.max(...scores);
-    }
+  if (scoreA < scoreB) {
+    return 1;
+  }
+  if (scoreA > scoreB) {
+    return -1;
+  }
+  return 0;
+}
 
-    const scoreA = fieldGetMaxRelatorTermScore(fieldA);
-    const scoreB = fieldGetMaxRelatorTermScore(fieldB);
 
-    if (scoreA < scoreB) {
-      return 1;
-    }
-    if (scoreA > scoreB) {
-      return -1;
-    }
-    return 0;
+function fieldGetMinLinkAndSequenceNumber(field) {
+  if (!field.subfields) {
+    return BIG_BAD_NUMBER;
   }
-
-  function fieldGetMinLinkAndSequenceNumber(field) {
-    if (!field.subfields) {
-      return BIG_BAD_NUMBER;
-    }
-    const relevantSubfields = field.subfields.filter(sf => isValidSubfield8(sf));
-    // If val is something like "1.2\x" parseFloat() would give a syntax erro because of hex-like escape sequnce (at least on Chrome). Thus remove tail:
-    const scores = relevantSubfields.map(sf => parseFloat(sf.value.replace(/\\.*$/u, '')));
-    if (scores.length === 0) {
-      return BIG_BAD_NUMBER;
-    }
-    return Math.min(...scores);
+  const relevantSubfields = field.subfields.filter(sf => isValidSubfield8(sf));
+  // If val is something like "1.2\x" parseFloat() would give a syntax erro because of hex-like escape sequnce (at least on Chrome). Thus remove tail:
+  const scores = relevantSubfields.map(sf => parseFloat(sf.value.replace(/\\.*$/u, '')));
+  if (scores.length === 0) {
+    return BIG_BAD_NUMBER;
   }
+  return Math.min(...scores);
+}
 
-  function sortByFieldLinkAndSequenceNumber(fieldA, fieldB) { // Sort by subfield $8 that is...
-    const scoreA = fieldGetMinLinkAndSequenceNumber(fieldA);
-    const scoreB = fieldGetMinLinkAndSequenceNumber(fieldB);
-    //debugDev(` sf-8-A-score for '${fieldToString(fieldA)}: ${scoreA}`);
-    //debugDev(` sf-8-B-score for '${fieldToString(fieldB)}: ${scoreB}`);
-    if (scoreA === scoreB) {
-      return 0;
-    }
-    if (scoreB === 0) {
-      return 1;
-    }
-    if (scoreA === 0) {
-      return -1;
-    }
-    if (scoreA > scoreB) { // smaller is better
-      return 1;
-    }
+function sortByFieldLinkAndSequenceNumber(fieldA, fieldB) { // Sort by subfield $8 that is...
+  const scoreA = fieldGetMinLinkAndSequenceNumber(fieldA);
+  const scoreB = fieldGetMinLinkAndSequenceNumber(fieldB);
+  //debugDev(` sf-8-A-score for '${fieldToString(fieldA)}: ${scoreA}`);
+  //debugDev(` sf-8-B-score for '${fieldToString(fieldB)}: ${scoreB}`);
+  if (scoreA === scoreB) {
+    return 0;
+  }
+  if (scoreB === 0) {
+    return 1;
+  }
+  if (scoreA === 0) {
     return -1;
   }
+  if (scoreA > scoreB) { // smaller is better
+    return 1;
+  }
+  return -1;
+}
 
-  function sortByOccurrenceNumber(fieldA, fieldB) { // Sort by subfield $6
 
-    function fieldGetOccurrenceNumber(field) { // should this function be exported? (based on validator sortRelatorFields.js)
-      if (!field.subfields) {
-        return 0;
-      }
-      const subfield6 = field.subfields.find(sf => isValidSubfield6(sf));
-      if (subfield6 === undefined) {
-        return 0;
-      }
-      return parseInt(subfield6GetOccurrenceNumber(subfield6), 10);
-    }
+function sortByOccurrenceNumber(fieldA, fieldB) { // Sort by subfield $6
 
-    if (fieldA.tag !== '880') {
+  function fieldGetOccurrenceNumber(field) { // should this function be exported? (based on validator sortRelatorFields.js)
+    if (!field.subfields) {
       return 0;
     }
-    const scoreA = fieldGetOccurrenceNumber(fieldA);
-    const scoreB = fieldGetOccurrenceNumber(fieldB);
-
-    //debugDev(`A: '${fieldToString(fieldA)}: ${scoreA}`);
-    //debugDev(`B: '${fieldToString(fieldB)}: ${scoreB}`);
-
-    if (scoreA === scoreB) {
+    const subfield6 = field.subfields.find(sf => isValidSubfield6(sf));
+    if (subfield6 === undefined) {
       return 0;
     }
-    if (scoreB === 0) {
-      return -1;
-    }
-    if (scoreA === 0) {
-      return 1;
-    }
-    if (scoreA > scoreB) { // smaller is better
-      return 1;
-    }
-    return -1;
+    return parseInt(subfield6GetOccurrenceNumber(subfield6), 10);
   }
 
-  function sortAlphabetically(fieldA, fieldB) {
-    const tagToSortingSubfields = {
-      // '028': ['b', 'a']?
-      'LOW': ['a'],
-      'SID': ['c']
-    };
-
-    function scoreSubfieldsAlphabetically(setOfSubfields) {
-      if (setOfSubfields.length === 0) {
-        return 0;
-      }
-      const [subfieldCode, ...remainingSubfieldCodes] = setOfSubfields;
-      const valA = selectFirstValue(fieldA, subfieldCode);
-      const valB = selectFirstValue(fieldB, subfieldCode);
-      //debugDev(`CHECKING SUBFIELD '${subfieldCode}'`);
-      if (!valA) {
-        if (!valB) {
-          return scoreSubfieldsAlphabetically(remainingSubfieldCodes);
-        }
-        return -1;
-      }
-      if (!valB) {
-        return 1;
-      }
-      //debugDev(`CHECKING SUBFIELD '${subfieldCode}': '${valA}' vs '${valB}'`);
-
-      if (valA < valB) {
-        return -1;
-      }
-      if (valB < valA) {
-        return 1;
-      }
-      return scoreSubfieldsAlphabetically(remainingSubfieldCodes);
-    }
-
-    if (fieldA.tag === fieldB.tag) {
-      if (!(fieldA.tag in tagToSortingSubfields)) {
-        return 0;
-      }
+  if (fieldA.tag !== '880') {
+    return 0;
+  }
+  const scoreA = fieldGetOccurrenceNumber(fieldA);
+  const scoreB = fieldGetOccurrenceNumber(fieldB);
 
-      const subfieldsToCheck = tagToSortingSubfields[fieldA.tag];
+  //debugDev(`A: '${fieldToString(fieldA)}: ${scoreA}`);
+  //debugDev(`B: '${fieldToString(fieldB)}: ${scoreB}`);
 
-      //debugDev(`CHECKING ${subfieldsToCheck.join(', ')}`);
-      const result = scoreSubfieldsAlphabetically(subfieldsToCheck);
-      //debugDev(`RESULT ${result}`);
-      return result;
-    }
+  if (scoreA === scoreB) {
     return 0;
   }
-
-  //-----------------------------------------------------------------------------
+  if (scoreB === 0) {
+    return -1;
+  }
+  if (scoreA === 0) {
+    return 1;
+  }
+  if (scoreA > scoreB) { // smaller is better
+    return 1;
+  }
+  return -1;
+}
 
 
-  function selectFirstValue(field, subcode) {
-    return field.subfields
-      .filter(subfield => subcode === subfield.code)
-      .map(subfield => subfield.value)
-      .slice(0, 1);
-  }
+function selectFirstValue(field, subcode) {
+  return field.subfields
+    .filter(subfield => subcode === subfield.code)
+    .map(subfield => subfield.value)
+    .slice(0, 1);
 }
 

package/test-fixtures/normalize-dashes/01/expectedResult.json

@@ -0,0 +1,6 @@
+{
+  "message" : [
+    "'TODO: 521 ## ‡a Diiba - Daaba ― Doh – Doh-Too' => '521 ## ‡a Diiba - Daaba - Doh - Doh-Too'"
+  ],
+  "valid": false
+}

package/test-fixtures/normalize-dashes/01/metadata.json

@@ -0,0 +1,6 @@
+{
+  "description": "Validate dash normalization: fails as it contains dashes of various lenghts",
+  "enabled": true,
+  "fix": false,
+  "only": false
+}

package/test-fixtures/normalize-dashes/01/record.json

@@ -0,0 +1,8 @@
+{
+  "fields" : [
+    { "tag": "005", "value": "20220202020202.0" },
+    { "tag": "521", "ind1": " ", "ind2": " ", "subfields" : [
+        { "code": "a", "value": "Diiba - Daaba \u2015 Doh \u2013 Doh-Too" }
+    ]}
+  ]
+}

package/test-fixtures/normalize-dashes/02/expectedResult.json

@@ -0,0 +1,10 @@
+{
+  "leader": "",
+  "fields" : [
+    { "tag": "005", "value": "20220202020202.0" },
+    { "tag": "500", "ind1": " ", "ind2": " ", "subfields" : [
+      { "code": "a", "value": "Diiba - Daaba - Doh - Doh-Too" }
+    ]}
+  ],
+  "_validationOptions": {}
+}

package/test-fixtures/normalize-dashes/02/metadata.json

@@ -0,0 +1,5 @@
+{
+  "description": "Fix field 521 dashes",
+  "enabled": true,
+  "fix": true
+}

package/test-fixtures/normalize-dashes/02/record.json

@@ -0,0 +1,8 @@
+{
+  "fields" : [
+    { "tag": "005", "value": "20220202020202.0" },
+    { "tag": "500", "ind1": " ", "ind2": " ", "subfields" : [
+        { "code": "a", "value": "Diiba - Daaba \u2015 Doh \u2013 Doh-Too" }
+    ]}
+  ]
+}