libis-tools 0.9.9 → 0.9.10

data/lib/libis/tools/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Tools
-    VERSION = '0.9.9'
+    VERSION = '0.9.10'
   end
 end

data/libis-tools.gemspec

@@ -29,13 +29,14 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.1'
   spec.add_development_dependency 'simplecov', '~> 0.9'
   spec.add_development_dependency 'equivalent-xml', '~> 0.5'
-
+  spec.add_development_dependency 'awesome_print'
 
   spec.add_runtime_dependency 'backports', '~> 3.6'
   spec.add_runtime_dependency 'savon', '~> 2.0'
   spec.add_runtime_dependency 'nokogiri', '~> 1.6'
   spec.add_runtime_dependency 'gyoku',  '~> 1.2'
   spec.add_runtime_dependency 'nori', '~> 2.4'
-  spec.add_runtime_dependency 'recursive-open-struct', '~>0.6.4'
-
+  spec.add_runtime_dependency 'recursive-open-struct', '~> 0.6'
+  spec.add_runtime_dependency 'parslet', '~> 1.7'
+  spec.add_runtime_dependency 'simple_xlsx_reader', '~> 1.0'
 end

data/spec/config_spec.rb

@@ -64,7 +64,9 @@ describe 'Config' do
   context 'loading from file' do
 
     let(:test_file) { File.join(File.dirname(__FILE__), 'data', 'test.yml') }
-    subject(:config) { Libis::Tools::Config.clear! << test_file }
+    subject(:config) {
+      Libis::Tools::Config.clear! << test_file
+    }
 
     it 'has configuration parameters set' do
       expect(config.process).to eq 'Test Configuration'

data/spec/metadata/8389207.marc

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<record xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
+        xmlns="http://www.loc.gov/MARC21/slim" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <leader>01068nam 2200241u 4500</leader>
+  <controlfield tag="005">20150701153710.0</controlfield>
+  <controlfield tag="008">000608m17221724xx |||| | 000|0 lat c</controlfield>
+  <controlfield tag="001">9921543960101471</controlfield>
+  <datafield tag="035" ind1=" " ind2=" ">
+    <subfield code="a">(BeLVLBS)002154396LBS01-Aleph</subfield>
+  </datafield>
+  <datafield tag="035" ind1=" " ind2=" ">
+    <subfield code="a">8389207</subfield>
+  </datafield>
+  <datafield tag="245" ind1="0" ind2="0">
+    <subfield code="a">Anecdota Graeca, sacra et profana /</subfield>
+    <subfield code="c">ex codicibus manu exaratis nunc primum in lucem edita, versione Latina donata, et notis
+      illustrata a Io. Christophoro Wolfio ... Tom. I [-IIII]
+    </subfield>
+  </datafield>
+  <datafield tag="264" ind1=" " ind2="1">
+    <subfield code="a">Hamburgi</subfield>
+    <subfield code="b">apud Theodorum Christophorum Felginer,</subfield>
+    <subfield code="c">1722-1724</subfield>
+  </datafield>
+  <datafield tag="300" ind1=" " ind2=" ">
+    <subfield code="a">8o: 4 v.; [22], 298, [8]; [16], 354, [1]; [16], 299, [7]; [16], 271, [5] p.</subfield>
+  </datafield>
+  <datafield tag="336" ind1=" " ind2=" ">
+    <subfield code="a">text</subfield>
+    <subfield code="2">rdacontent</subfield>
+  </datafield>
+  <datafield tag="337" ind1=" " ind2=" ">
+    <subfield code="a">unmediated</subfield>
+    <subfield code="2">rdamedia</subfield>
+  </datafield>
+  <datafield tag="338" ind1=" " ind2=" ">
+    <subfield code="a">volume</subfield>
+    <subfield code="2">rdacarrier</subfield>
+  </datafield>
+  <datafield tag="500" ind1=" " ind2=" ">
+    <subfield code="a">Ded. Petrus Theodorus Seelmann; Erdmannus Neumeister; Thomas Claussen; Joannes Grammius
+    </subfield>
+  </datafield>
+  <datafield tag="500" ind1=" " ind2=" ">
+    <subfield code="a">Elk deel heeft eigen titelp. in roodzwartdruk, met drukkersmerk</subfield>
+  </datafield>
+  <datafield tag="650" ind1=" " ind2="7">
+    <subfield code="2">UDC</subfield>
+    <subfield code="a">276 =75</subfield>
+    <subfield code="x">Griekse patrologie</subfield>
+  </datafield>
+  <datafield tag="653" ind1=" " ind2="6">
+    <subfield code="a">Books before 1840</subfield>
+  </datafield>
+  <datafield tag="700" ind1="1" ind2=" ">
+    <subfield code="a">Wolf, Johann Christoph</subfield>
+    <subfield code="d">1683-1739</subfield>
+    <subfield code="4">aut</subfield>
+  </datafield>
+  <datafield tag="953" ind1=" " ind2=" ">
+    <subfield code="a">1701-1750</subfield>
+  </datafield>
+  <datafield tag="998" ind1=" " ind2=" ">
+    <subfield code="a">LBS01</subfield>
+    <subfield code="b">bib_200501.mrc.2.av</subfield>
+  </datafield>
+  <datafield tag="INST" ind1=" " ind2=" ">
+    <subfield code="a">32KUL_LIBIS_NETWORK</subfield>
+    <subfield code="b">P</subfield>
+    <subfield code="c">71134440820001471</subfield>
+  </datafield>
+  <datafield tag="INST" ind1=" " ind2=" ">
+    <subfield code="a">32KUL_KUL</subfield>
+    <subfield code="b">P</subfield>
+    <subfield code="c">21304345390001488</subfield>
+  </datafield>
+  <datafield tag="AVA" ind1=" " ind2=" ">
+    <subfield code="a">32KUL_KUL</subfield>
+    <subfield code="b">GBIB</subfield>
+    <subfield code="c">GBIB: Godgeleerdheid</subfield>
+    <subfield code="d">276.030.4 WOLF Anec</subfield>
+    <subfield code="e">available</subfield>
+    <subfield code="f">1</subfield>
+    <subfield code="g">0</subfield>
+    <subfield code="j">GBIB</subfield>
+    <subfield code="p">1</subfield>
+  </datafield>
+  <datafield tag="MMS" ind1=" " ind2=" ">
+    <subfield code="b">9921543960101471</subfield>
+    <subfield code="a">32KUL_LIBIS_NETWORK</subfield>
+  </datafield>
+  <datafield tag="MMS" ind1=" " ind2=" ">
+    <subfield code="b">9921543960101488</subfield>
+    <subfield code="a">32KUL_KUL</subfield>
+  </datafield>
+</record>

data/spec/metadata/dublin_core_parser_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+require_relative '../spec_helper'
+require 'libis/tools/metadata/parsers'
+require 'parslet'
+require 'parslet/convenience'
+require 'pp'
+
+$DEBUG = false
+
+describe 'DublinCore Parser' do
+
+  subject(:parser) { Libis::Tools::Metadata::DublinCoreParser.new }
+
+  it 'parses simple DC' do
+    expect {
+      tree = parser.parse_with_debug('dc:title')
+      # pp tree
+      expect(tree).to be_a Hash
+      expect(tree[:namespace]).to eq 'dc'
+      expect(tree[:element]).to eq 'title'
+      # noinspection RubyResolve
+      expect(tree).not_to have_key :attributes
+    }.not_to raise_error
+  end
+
+  it 'must see namespace' do
+    expect {
+      parser.parse('title')
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it 'parses DC with attributes' do
+    expect {
+      tree = parser.parse_with_debug('dcterms:date xsi:type="http://example.com" foo:bar="baz"')
+      # pp tree
+      expect(tree).to be_a Hash
+      expect(tree[:namespace]).to eq 'dcterms'
+      expect(tree[:element]).to eq 'date'
+      # noinspection RubyResolve
+      expect(tree[:attributes].size).to be 2
+      expect(tree[:attributes]).to eq [
+                                          {namespace: 'xsi', name: 'type', value: 'http://example.com'},
+                                          {namespace: 'foo', name: 'bar', value: 'baz'},
+                                      ]
+    }.not_to raise_error
+  end
+
+end

data/spec/metadata/marc21_parser_data.rb

@@ -0,0 +1,382 @@
+def marc21_parser_testdata
+  [
+      {
+          title: 'select statement with numeric tag',
+          input: 'MARC 123',
+          tree: {tag: '123', ind1: nil, ind2: nil, subfield: nil, condition: nil},
+          transform: "record.select_fields('123##')"
+      }, {
+          title: 'select statement with LRK tag',
+          input: 'MARC LKR',
+          tree: {tag: 'LKR', ind1: nil, ind2: nil, subfield: nil, condition: nil},
+          transform: "record.select_fields('LKR##')"
+      }, {
+          title: 'select statement with FMT tag',
+          input: 'MARC FMT',
+          tree: {tag: 'FMT', ind1: nil, ind2: nil, subfield: nil, condition: nil},
+          transform: "record.select_fields('FMT##')"
+      }, {
+          title: 'select statement with bad magic text',
+          input: 'foo',
+          tree: :failure
+      }, {
+          title: 'select statement with bad tag',
+          input: 'MARC 1',
+          tree: :failure
+      }, {
+          title: 'select statement with bad indicator',
+          input: 'MARC 123 *',
+          tree: :failure
+      }, {
+          title: 'select statement with bad subfield',
+          input: 'MARC 123 $_',
+          tree: :failure
+      }, {
+          title: 'select statement with tag and one indicator',
+          input: 'MARC 123 #',
+          tree: {tag: '123', ind1: '#', ind2: nil, subfield: nil, condition: nil},
+          transform: "record.select_fields('123##')"
+      }, {
+          title: 'select statement with tag and indicators',
+          input: 'MARC 123 #_',
+          tree: {tag: '123', ind1: '#', ind2: '_', subfield: nil, condition: nil},
+          transform: "record.select_fields('123#_')"
+      }, {
+          title: 'select statement with tag and subfield',
+          input: 'MARC 123 $a',
+          tree: {tag: '123', ind1: nil, ind2: nil, subfield: {name: 'a'}, condition: nil},
+          transform: "record.select_fields('123##a')"
+      }, {
+          title: 'select statement with tag, indicators and subfield',
+          input: 'MARC 123 45 $6',
+          tree: {tag: '123', ind1: '4', ind2: '5', subfield: {name: '6'}, condition: nil},
+          transform: "record.select_fields('123456')"
+      }, {
+          title: 'select statement with subfield condition',
+          input: 'MARC 123 [f.match(\'a\')]',
+          tree: {
+              tag: '123', ind1: nil, ind2: nil, subfield: nil,
+              condition: {
+                  cond_format: {
+                      entry: [
+                          {cond_group: {
+                              prefix: 'f.match',
+                              lparen: '(',
+                              entry: [
+                                  {cond_group: {
+                                      prefix: nil,
+                                      lparen: "'",
+                                      entry: nil,
+                                      postfix: 'a',
+                                      rparen: "'"
+                                  }}
+                              ],
+                              postfix: nil,
+                              rparen: ')'
+                          }}
+                      ],
+                      postfix: nil
+                  }
+              }
+          },
+          transform: "record.select_fields('123##', Proc.new { |f| f.match('a') })"
+      }, {
+          title: 'select statement with regex condition',
+          input: 'MARC 123 [$0 =~ /^.+"ABC"/]',
+          tree: {
+              tag: '123', ind1: nil, ind2: nil, subfield: nil,
+              condition: {
+                  cond_format: {
+                      entry: [
+                          {subfield: {:prefix => nil, :repeat => nil, :name => '0'}},
+                          {cond_group: {
+                              prefix: ' =~ /^.+',
+                              lparen: "\"",
+                              entry: nil,
+                              postfix: 'ABC',
+                              rparen: "\""
+                          }}
+                      ],
+                      postfix: '/'
+                  }
+              }
+          },
+          transform: "record.select_fields('123##', Proc.new { |f| f.subfield('0') =~ /^.+\"ABC\"/ })"
+      }, {
+          title: 'select statement with complex regex condition',
+          input: 'MARC 690 02 {$0 =~ /^\(ODIS-(PS|ORG)\) (\d)+$$/}',
+          tree: {
+              tag: '690', ind1: '0', ind2: '2', subfield: nil,
+              condition: {
+                  cond_format: {
+                      entry: [
+                          {subfield: {prefix: nil, repeat: nil, name: '0'}},
+                          {cond_group: {prefix: " =~ /^\\",
+                                        lparen: '(',
+                                        entry: [
+                                            {cond_group: {
+                                                prefix: 'ODIS-',
+                                                lparen: '(',
+                                                entry: nil,
+                                                postfix: 'PS|ORG',
+                                                rparen: ')'}}
+                                        ],
+                                        postfix: "\\",
+                                        rparen: ')'}},
+                          {cond_group: {
+                              prefix: ' ',
+                              lparen: '(',
+                              entry: nil,
+                              postfix: "\\d",
+                              rparen: ')'}}
+                      ],
+                      postfix: '+$$/'}}
+          },
+          transform: "record.select_fields('69002', Proc.new { |f| f.subfield('0') =~ /^\\(ODIS-(PS|ORG)\\) (\\d)+$$/ })"
+      }, {
+      }, {
+          title: 'format statement with simple subfield reference',
+          input: '$a',
+          tree: {entry: [{subfield: {prefix: nil, repeat: nil, name: 'a'}}], postfix: nil},
+          transform: "f.subfield('a')"
+      }, {
+          title: 'format statement with subfield reference with repeat indicator',
+          input: '$*a',
+          tree: {entry: [{subfield: {prefix: nil, repeat: '*', name: 'a'}}], postfix: nil},
+          transform: "field_format(f.subfield_array('a'), join: ';').to_s"
+      }, {
+          title: 'format statement with subfield reference with repeat + separator indicator',
+          input: '$*"; "a',
+          tree: {entry: [{subfield: {prefix: nil, repeat: {separator: '; '}, name: 'a'}}], postfix: nil},
+          transform: "field_format(f.subfield_array('a'), join: '; ').to_s"
+      }, {
+          title: 'format statement with position reference',
+          input: '$[13]',
+          tree: {entry: [{fixfield: {prefix: nil, position: '13'}}], postfix: nil},
+          transform: 'f[13]'
+      }, {
+          title: 'format statement with range reference',
+          input: 'abc: $[5-8]',
+          tree: {entry: [{fixfield: {prefix: 'abc: ', first: '5', last: '8'}}], postfix: nil},
+          transform: "field_format(f[5,8], prefix: 'abc: ').to_s"
+      }, {
+          title: 'format statement with all range reference',
+          input: 'abc: $[*].',
+          tree: {entry: [{fixfield: {prefix: 'abc: ', all: '*'}}], postfix: '.'},
+          transform: "field_format(field_format(f[], prefix: 'abc: ').to_s, postfix: '.').to_s"
+      }, {
+          title: 'format statement with multiple subfields with prefixes',
+          input: '$a, $b - $c',
+          tree: {
+              entry: [
+                  {subfield: {prefix: nil, repeat: nil, name: 'a'}},
+                  {subfield: {prefix: ', ', repeat: nil, name: 'b'}},
+                  {subfield: {prefix: ' - ', repeat: nil, name: 'c'}},
+              ],
+              postfix: nil},
+          transform: "field_format(f.subfield('a'),field_format(f.subfield('b'), prefix: ', ').to_s,field_format(f.subfield('c'), prefix: ' - ').to_s).to_s"
+      }, {
+          title: 'format statement with multiple subfields with prefixes and postfix',
+          input: '$a, $b - $c.',
+          tree: {
+              entry: [
+                  {subfield: {prefix: nil, repeat: nil, name: 'a'}},
+                  {subfield: {prefix: ', ', repeat: nil, name: 'b'}},
+                  {subfield: {prefix: ' - ', repeat: nil, name: 'c'}},
+              ],
+              postfix: '.'},
+          transform: "field_format(f.subfield('a'),field_format(f.subfield('b'), prefix: ', ').to_s,field_format(f.subfield('c'), prefix: ' - ').to_s, postfix: '.').to_s"
+      }, {
+          title: 'format statement with multiple subfields with prefixes and group',
+          input: '$a, $b - ($c)',
+          tree: {
+              entry: [
+                  {subfield: {prefix: nil, repeat: nil, name: 'a'}},
+                  {subfield: {prefix: ', ', repeat: nil, name: 'b'}},
+                  {group: {
+                      prefix: ' - ', postfix: nil,
+                      lparen: '(', rparen: ')',
+                      entry: [{subfield: {prefix: nil, repeat: nil, name: 'c'}}]
+                  }},
+              ],
+              postfix: nil},
+          transform: "field_format(f.subfield('a'),field_format(f.subfield('b'), prefix: ', ').to_s,field_format(f.subfield('c'), prefix: ' - (', postfix: ')').to_s).to_s"
+      }, {
+          title: 'format statement with multiple subfields with prefixes and group with multiple entries',
+          input: '$a, $b - ($c, $d, ...)',
+          tree: {
+              entry: [
+                  {subfield: {prefix: nil, repeat: nil, name: 'a'}},
+                  {subfield: {prefix: ', ', repeat: nil, name: 'b'}},
+                  {group: {
+                      prefix: ' - ', postfix: ', ...',
+                      lparen: '(', rparen: ')',
+                      entry: [
+                          {subfield: {prefix: nil, repeat: nil, name: 'c'}},
+                          {subfield: {prefix: ', ', repeat: nil, name: 'd'}},
+                      ],
+                  }},
+              ],
+              postfix: nil},
+          transform: "field_format(f.subfield('a'),field_format(f.subfield('b'), prefix: ', ').to_s,field_format(f.subfield('c'),field_format(f.subfield('d'), prefix: ', ').to_s, prefix: ' - (', postfix: ', ...)').to_s).to_s"
+      }, {
+          title: 'format statement with nested groups',
+          input: '([{{($a)}}])',
+          tree: {
+              entry: [
+                  {group: {
+                      prefix: nil, postfix: nil,
+                      lparen: '(', rparen: ')',
+                      entry: [
+                          {group: {
+                              prefix: nil, postfix: nil,
+                              lparen: '[', rparen: ']',
+                              entry: [
+                                  {group: {
+                                      prefix: nil, postfix: nil,
+                                      lparen: '{', rparen: '}',
+                                      entry: [
+                                          {group: {
+                                              prefix: nil, postfix: nil,
+                                              lparen: '{', rparen: '}',
+                                              entry: [
+                                                  {group: {
+                                                      prefix: nil, postfix: nil,
+                                                      lparen: '(', rparen: ')',
+                                                      entry: [{subfield: {prefix: nil, repeat: nil, name: 'a'}}]
+                                                  }}
+                                              ]
+                                          }}
+                                      ]
+                                  }}
+                              ]
+                          }}
+                      ]
+                  }}
+              ],
+              postfix: nil},
+          transform: "field_format(field_format(field_format(field_format(field_format(f.subfield('a'), prefix: '(', postfix: ')').to_s, prefix: '{', postfix: '}').to_s, prefix: '{', postfix: '}').to_s, prefix: '[', postfix: ']').to_s, prefix: '(', postfix: ')').to_s"
+      }, {
+          title: 'format statement with missing closing bracket',
+          input: '($a',
+          tree: :failure
+      }, {
+          title: 'format statement with missing opening bracket',
+          input: '$a)',
+          tree: :failure
+      }, {
+          title: 'format statement with nested quotes',
+          input: ':"-$a, $*"+"b-".',
+          tree: {
+              entry: [
+                  {group: {
+                      prefix: ':', postfix: '-',
+                      lparen: '"', rparen: '"',
+                      entry: [
+                          {subfield: {prefix: '-', repeat: nil, name: 'a'}},
+                          {subfield: {prefix: ', ', repeat: {separator: '+'}, name: 'b'}}
+                      ],
+                  }}
+              ],
+              postfix: '.'},
+          transform: "field_format(field_format(field_format(f.subfield('a'), prefix: '-').to_s,field_format(f.subfield_array('b'), prefix: ', ', join: '+').to_s, prefix: ':\"', postfix: '-\"').to_s, postfix: '.').to_s"
+      }, {
+          title: 'format statement with double dollar prefix and postfix',
+          input: 'ab: $$$*a$$.',
+          tree: {
+              entry: [{subfield: {prefix: 'ab: $$', repeat: '*', name: 'a'}}],
+              postfix: '$$.'},
+          transform: "field_format(field_format(f.subfield_array('a'), prefix: 'ab: $$', join: ';').to_s, postfix: '$$.').to_s"
+      }, {
+          title: 'format statement with condition text',
+          input: '$0 =~ /^\(ODIS-(PS|ORG)\) (\d)+$$/',
+          tree: {
+              entry: [
+                  {subfield: {prefix: nil, repeat: nil, name: '0'}},
+                  {group: {
+                      prefix: ' =~ /^\\', postfix: '\\',
+                      lparen: '(', rparen: ')',
+                      entry: [
+                          {group: {
+                              prefix: 'ODIS-', postfix: 'PS|ORG',
+                              lparen: '(', rparen: ')',
+                              entry: nil
+                          }}
+                      ]
+                  }},
+                  {group: {
+                      prefix: ' ', postfix: '\\d',
+                      lparen: '(', rparen: ')',
+                      entry: nil
+                  }}
+              ],
+              postfix: '+$$/'},
+          transform: "field_format(f.subfield('0'),field_format(field_format(, prefix: 'ODIS-(', postfix: 'PS|ORG)').to_s, prefix: ' =~ /^\\(', postfix: '\\)').to_s,field_format(, prefix: ' (', postfix: '\\d)').to_s, postfix: '+$$/').to_s"
+      }, {
+          title: 'format statement with method call',
+          input: '$(my_method($a,$b))',
+          tree: {entry: [
+              {method_call: {
+                  prefix: nil, postfix: nil,
+                  entry: [
+                      {group: {
+                          prefix: 'my_method', postfix: nil,
+                          lparen: '(', rparen: ')',
+                          entry: [
+                              {subfield: {prefix: nil, repeat: nil, name: 'a'}},
+                              {subfield: {prefix: ',', repeat: nil, name: 'b'}}
+                          ]
+                      }}
+                  ]
+              }}
+          ],
+                 postfix: nil},
+          transform: {:format => {:entry => [{:method_call => {:prefix => nil, :entry => ["field_format(f.subfield('a'),field_format(f.subfield('b'), prefix: ',').to_s, prefix: 'my_method(', postfix: ')').to_s"], :postfix => nil}}], :postfix => nil}}
+      }, {
+          title: 'format statement with complex with method call',
+          input: "$a $b ($c) ($d) ($g), $(lookup('DOLLAR4','Name','Tag'=>'100','Code'=>$4.to_s)) ($9)",
+          tree: {entry: [
+              {subfield: {prefix: nil, repeat: nil, name: 'a'}},
+              {subfield: {prefix: ' ', repeat: nil, name: 'b'}},
+              {group: {
+                  prefix: ' ', postfix: nil,
+                  lparen: '(', rparen: ')',
+                  entry: [{subfield: {prefix: nil, repeat: nil, name: 'c'}}]}},
+              {group: {
+                  prefix: ' ', postfix: nil,
+                  lparen: '(', rparen: ')',
+                  entry: [{subfield: {prefix: nil, repeat: nil, name: 'd'}}]
+              }},
+              {group: {
+                  prefix: ' ', postfix: nil,
+                  lparen: '(', rparen: ')',
+                  entry: [{subfield: {prefix: nil, repeat: nil, name: 'g'}}]
+              }},
+              {method_call: {
+                  prefix: ', ', postfix: nil,
+                  entry: [
+                      {group: {
+                          prefix: 'lookup', postfix: '.to_s',
+                          lparen: '(', rparen: ')',
+                          entry: [
+                              {group: {prefix: nil, lparen: "'", entry: nil, postfix: 'DOLLAR4', rparen: "'"}},
+                              {group: {prefix: ',', lparen: "'", entry: nil, postfix: 'Name', rparen: "'"}},
+                              {group: {prefix: ',', lparen: "'", entry: nil, postfix: 'Tag', rparen: "'"}},
+                              {group: {prefix: '=>', lparen: "'", entry: nil, postfix: '100', rparen: "'"}},
+                              {group: {prefix: ',', lparen: "'", entry: nil, postfix: 'Code', rparen: "'"}},
+                              {subfield: {prefix: '=>', repeat: nil, name: '4'}}
+                          ]
+                      }}
+                  ]
+              }},
+              {group: {
+                  prefix: ' ', postfix: nil,
+                  lparen: '(', rparen: ')',
+                  entry: [{subfield: {prefix: nil, repeat: nil, name: '9'}}]
+              }}
+          ],
+                 postfix: nil},
+          transform: {:format => {:entry => ["f.subfield('a')", "field_format(f.subfield('b'), prefix: ' ').to_s", "field_format(f.subfield('c'), prefix: ' (', postfix: ')').to_s", "field_format(f.subfield('d'), prefix: ' (', postfix: ')').to_s", "field_format(f.subfield('g'), prefix: ' (', postfix: ')').to_s", {:method_call => {:prefix => ', ', :entry => ["field_format(field_format(, prefix: ''', postfix: 'DOLLAR4'').to_s,field_format(, prefix: ','', postfix: 'Name'').to_s,field_format(, prefix: ','', postfix: 'Tag'').to_s,field_format(, prefix: '=>'', postfix: '100'').to_s,field_format(, prefix: ','', postfix: 'Code'').to_s,field_format(f.subfield('4'), prefix: '=>').to_s, prefix: 'lookup(', postfix: '.to_s)').to_s"], :postfix => nil}}, "field_format(f.subfield('9'), prefix: ' (', postfix: ')').to_s"], :postfix => nil}}
+      }
+  ]
+end