berkeley_library-marc 0.2.0

data/lib/berkeley_library/marc/field_info/var_fields/section.rb

@@ -0,0 +1,50 @@
+require 'berkeley_library/marc/field_info/var_fields/var_field_def'
+require 'berkeley_library/marc/field_info/var_fields/obsolescible'
+
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+        class Section
+          include Enumerable
+          include Obsolescible
+
+          attr_reader :desc
+          attr_reader :var_fields
+
+          def initialize(desc:, var_fields:)
+            @desc = desc
+            @var_fields = var_fields
+          end
+
+          def each(&block)
+            return to_enum(:each) unless block_given?
+
+            var_fields.each(&block)
+          end
+
+          def size
+            var_fields.size
+          end
+
+          def empty?
+            var_fields.empty?
+          end
+
+          def reject_obsoletes
+            Section.new(
+              desc: desc,
+              var_fields: _reject_obsolete(var_fields)
+            )
+          end
+
+          def to_s
+            blocks = ["--#{desc}--"]
+            blocks.concat(var_fields.map(&:to_s))
+            blocks.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/marc/field_info/var_fields/subfield_def.rb

@@ -0,0 +1,50 @@
+require 'berkeley_library/marc/field_info/var_fields/subfield_val'
+require 'berkeley_library/marc/field_info/var_fields/obsolescible'
+
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+        # TODO: destructure range codes in some useful way (e.g. 886a-z, 0-9)
+        class SubfieldDef
+          include Obsolescible
+
+          attr_reader :code, :desc, :values
+
+          def initialize(code:, desc:, values: [])
+            @code = code
+            @desc = desc
+            @values = values
+          end
+
+          def reject_obsoletes
+            SubfieldDef.new(code: code, desc: desc, values: _reject_obsolete(values))
+          end
+
+          def each_value(&block)
+            return to_enum(:each_value) unless block_given?
+
+            values.each(&block)
+          end
+
+          INDENT = '    '.freeze
+          private_constant :INDENT
+
+          def to_s
+            lines = ["$#{code_str} - #{desc}"]
+            values.each { |v| lines << INDENT + v.to_s }
+            lines.join("\n")
+          end
+
+          private
+
+          def code_str
+            return code.to_s unless code.is_a?(Range)
+
+            "#{code.first}-#{code.last}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/marc/field_info/var_fields/subfield_val.rb

@@ -0,0 +1,24 @@
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+        class SubfieldVal
+          # TODO: include Comparable
+          include Obsolescible
+
+          attr_reader :val
+          attr_reader :desc
+
+          def initialize(val:, desc:)
+            @val = val
+            @desc = desc
+          end
+
+          def to_s
+            "#{val} - #{desc}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/marc/field_info/var_fields/var_field_def.rb

@@ -0,0 +1,62 @@
+require 'berkeley_library/marc/field_info/var_fields/ind_def'
+require 'berkeley_library/marc/field_info/var_fields/subfield_def'
+require 'berkeley_library/marc/field_info/var_fields/instrument_or_voices_code'
+require 'berkeley_library/marc/field_info/var_fields/obsolescible'
+
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+        class VarFieldDef
+          include Obsolescible
+
+          attr_reader :tag, :desc, :indicators, :subfield_codes, :inst_or_voices_codes
+
+          def initialize(tag:, desc:, indicators: [], subfield_codes: [], inst_or_voices_codes: [])
+            @tag = tag
+            @desc = desc
+            @indicators = indicators # TODO: split out ind1/ind2 (but what about obsolete?)
+            @subfield_codes = subfield_codes
+            @inst_or_voices_codes = inst_or_voices_codes
+          end
+
+          def to_s
+            blocks = ["#{tag} - #{desc}"]
+
+            concat_indented(blocks, indicators, 'Indicators')
+            concat_indented(blocks, subfield_codes, 'Subfield Codes')
+            concat_indented(blocks, inst_or_voices_codes, 'Instrument or Voices Codes')
+
+            blocks.join("\n")
+          end
+
+          def reject_obsoletes
+            VarFieldDef.new(
+              tag: tag,
+              desc: desc,
+              indicators: _reject_obsolete(indicators),
+              subfield_codes: _reject_obsolete(subfield_codes),
+              inst_or_voices_codes: _reject_obsolete(inst_or_voices_codes)
+            )
+          end
+
+          private
+
+          INDENT = '   '.freeze
+          private_constant :INDENT
+
+          def concat_indented(blocks, values, header)
+            return if values.empty?
+
+            blocks << INDENT + header
+            values.each do |v|
+              lines = v.to_s.lines(chomp: true)
+              lines.each { |line| blocks << INDENT + INDENT + line }
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/marc/field_info/var_fields/var_field_list.rb

@@ -0,0 +1,43 @@
+require 'berkeley_library/marc/field_info/var_fields/section'
+require 'berkeley_library/marc/field_info/var_fields/obsolescible'
+
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+        class VarFieldList
+          include Enumerable
+          include Obsolescible
+
+          attr_reader :desc, :sections
+
+          def initialize(desc:, sections:)
+            @desc = desc
+            @sections = sections
+          end
+
+          def each(&block)
+            return to_enum(:each) unless block_given?
+
+            sections.each { |section| section.each(&block) }
+          end
+
+          def size
+            sections.sum(&:size)
+          end
+
+          def reject_obsoletes
+            VarFieldList.new(
+              desc: desc,
+              sections: _reject_obsolete(sections)
+            )
+          end
+
+          def to_s
+            sections.map(&:to_s).join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/marc/field_info/var_fields/var_field_parser.rb

@@ -0,0 +1,136 @@
+require 'parslet'
+
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+
+        # rubocop:disable Style/BlockDelimiters
+        class VarFieldParser < Parslet::Parser
+
+          # ------------------------------------------------------------
+          # structural
+
+          rule(:blank) { match('[[:blank:]]') }
+
+          rule(:nonhyphen) { match('[\t[:print:]&&[^-]]') }
+
+          rule(:nonterminal_hyphen) { match('-(?!-?$)') }
+
+          rule(:printable) { nonhyphen | nonterminal_hyphen }
+
+          rule(:ln_br) { str("\r\n") | match('[\n\v\f\r\u0085\u2028\u2029]') }
+
+          rule(:eof) { any.absent? }
+
+          rule(:eol) { blank.repeat(0) >> ln_br }
+
+          rule(:text) { printable.repeat(0) }
+
+          rule(:comment) { blank.repeat(0) >> str('//') >> blank.repeat(0) >> text.as(:comment) }
+
+          # non-captured
+          rule(:nc) { (eol | comment).repeat(0) }
+
+          rule(:indent) { (eol | comment).repeat(1) >> blank.repeat(1) }
+
+          # ------------------------------------------------------------
+          # indicators
+
+          rule(:ind_header) { str('Indicators') }
+
+          rule(:ind1_header) { str('First - ') >> text.as(:desc) }
+
+          rule(:ind2_header) { str('Second - ') >> text.as(:desc) }
+
+          rule(:ind_val) {
+            # Yes, caps should be invalid; yes, TIND does it anyway
+            match('[0-9a-zA-Z#]')
+          }
+
+          # Relatively rare -- e.g. 130
+          rule(:ind_val_range) { match('[0-9]') >> str('-') >> match('[0-9]') }
+
+          rule(:ind_def) { (ind_val_range | ind_val).as(:val) >> str(' - ') >> text.as(:desc) }
+
+          rule(:ind1) { ind1_header >> (indent >> ind_def).repeat(0).as(:ind1) }
+
+          rule(:ind2) { ind2_header >> (indent >> ind_def).repeat(0).as(:ind2) }
+
+          rule(:indicators) do
+            # TODO: enforce that we only get multiples when all but one are obsolete
+            ind_header >> (indent >> (ind1 | ind2)).repeat(0)
+          end
+
+          # ------------------------------------------------------------
+          # subfield definitions
+
+          rule(:sf_header) { str('Subfield Codes') }
+
+          rule(:sf_code) { match('[0-9a-z]') }
+
+          # rare (e.g. 034a)
+          rule(:subfield_value) { match('[^$ \t]').repeat(1).as(:val) >> str(' - ') >> text.as(:desc) }
+
+          rule(:subfield_def) {
+            str('$') >>
+              (
+                (sf_code.as(:code1) >> str('-') >> sf_code.as(:code2)) | # range - rarely used (e.g. 886a-z, 0-9)
+                  sf_code.as(:code) # single code - typical case
+              ) >>
+              (str(' - ') | str(' ')) >> text.as(:desc) >> # 880 doesn't have -, probably a typo
+              (indent >> subfield_value).repeat(0).as(:values)
+          }
+
+          rule(:subfield_codes) { sf_header.maybe >> (indent >> subfield_def).repeat(1) }
+
+          # instrument or voices codes (only for 048)
+
+          rule(:ivc_header) { str('Instrument or Voices Codes') }
+
+          rule(:ivc_value) { match('[a-z]').repeat(2, 2).as(:val) >> str(' - ') >> text.as(:desc) }
+
+          rule(:ivc_def) { ivc_header >> (indent >> ivc_value).repeat(1) }
+
+          # ------------------------------------------------------------
+          # variable fields
+
+          rule(:vf_header) { match('[0-9]').repeat(3, 3).as(:tag) >> str(' - ') >> text.as(:desc) }
+
+          rule(:vf) {
+            vf_header >> (
+              indent >> indicators.as(:indicators) >>
+                indent >> subfield_codes.as(:subfield_codes) >>
+                (indent >> ivc_def).as(:inst_or_voices_codes).maybe
+            ).maybe
+          }
+
+          # ------------------------------------------------------------
+          # sections
+
+          rule(:section_header) { str('--') >> text.as(:desc) >> str('--') }
+
+          rule(:section) { section_header.maybe >> (nc >> vf).repeat(1).as(:var_fields) >> nc }
+
+          # ------------------------------------------------------------
+          # entire list
+
+          rule(:list) { (comment >> eol).repeat(0).as(:doc_comments) >> nc >> section.repeat(1).as(:sections) }
+
+          root(:list)
+
+          # ------------------------------------------------------------
+          # Parser
+
+          def parse(io, options = nil)
+            opts = { reporter: Parslet::ErrorReporter::Deepest.new }
+            opts.merge!(options) if options
+
+            super(io, opts)
+          end
+        end
+        # rubocop:enable Style/BlockDelimiters
+      end
+    end
+  end
+end

data/lib/berkeley_library/marc/field_info/var_fields/var_field_transform.rb

@@ -0,0 +1,160 @@
+require 'parslet'
+require 'berkeley_library/marc/field_info/var_fields/var_field_list'
+
+module BerkeleyLibrary
+  module Marc
+    module FieldInfo
+      module VarFields
+        # TODO: flag [OBSOLETE], (R), (NR)
+        # rubocop:disable Style/BlockDelimiters
+        class VarFieldTransform < Parslet::Transform
+
+          class AnyValue
+            attr_reader :val, :desc
+
+            def initialize(val:, desc:)
+              @val = val
+              @desc = desc
+            end
+
+            def to_ind_val_def
+              IndValDef.new(val: val, desc: desc)
+            end
+
+            def to_subfield_val
+              SubfieldVal.new(val: val, desc: desc)
+            end
+
+            def to_ivc
+              InstrumentOrVoicesCode.new(val: val, desc: desc)
+            end
+          end
+
+          # ------------------------------------------------------------
+          # structural elements
+
+          # comment
+          rule(comment: simple(:comment)) {
+            comment
+          }
+
+          # value
+          rule(val: simple(:val), desc: simple(:desc)) {
+            AnyValue.new(val: val, desc: desc)
+          }
+
+          # ------------------------------------------------------------
+          # indicators
+
+          # ind1
+          rule(desc: simple(:desc), ind1: sequence(:val_defs)) {
+            IndDef.new(pos: 1, desc: desc, val_defs: val_defs.map(&:to_ind_val_def))
+          }
+
+          # ind2
+          rule(desc: simple(:desc), ind2: sequence(:val_defs)) {
+            IndDef.new(pos: 2, desc: desc, val_defs: val_defs.map(&:to_ind_val_def))
+          }
+
+          # ------------------------------------------------------------
+          # subfield definitions
+
+          # sf_code_def (single code)
+          rule(code: simple(:code), desc: simple(:desc), values: sequence(:values)) {
+            SubfieldDef.new(code: code, desc: desc, values: values.map(&:to_subfield_val))
+          }
+
+          # sf_code_def (range code, e.g. 886a-z, 0-9)
+          rule(code1: simple(:code1), code2: simple(:code2), desc: simple(:desc), values: sequence(:values)) {
+            SubfieldDef.new(code: (code1.to_s..code2.to_s), desc: desc, values: values.map(&:to_subfield_val))
+          }
+
+          # ------------------------------------------------------------
+          # variable fields
+
+          rule(
+            tag: simple(:tag),
+            desc: simple(:desc),
+            indicators: sequence(:indicators),
+            subfield_codes: sequence(:subfield_codes),
+            inst_or_voices_codes: sequence(:inst_or_voices_codes)
+          ) {
+            VarFieldDef.new(
+              tag: tag,
+              desc: desc,
+              indicators: indicators,
+              subfield_codes: subfield_codes,
+              # instrument or voices codes (only for 048)
+              inst_or_voices_codes: inst_or_voices_codes.map(&:to_ivc)
+            )
+          }
+
+          rule(
+            tag: simple(:tag),
+            desc: simple(:desc),
+            indicators: sequence(:indicators),
+            subfield_codes: sequence(:subfield_codes)
+          ) {
+            VarFieldDef.new(
+              tag: tag,
+              desc: desc,
+              indicators: indicators,
+              subfield_codes: subfield_codes
+            )
+          }
+
+          # TODO: reinstate these?
+          # rule(
+          #   tag: simple(:tag),
+          #   desc: simple(:desc),
+          #   indicators: sequence(:indicators)
+          # ) {
+          #   VarFieldDef.new(
+          #     tag: tag,
+          #     desc: desc,
+          #     indicators: indicators
+          #   )
+          # }
+
+          # rule(
+          #   tag: simple(:tag),
+          #   desc: simple(:desc),
+          #   subfield_codes: sequence(:subfield_codes)
+          # ) {
+          #   VarFieldDef.new(
+          #     tag: tag,
+          #     desc: desc,
+          #     subfield_codes: subfield_codes
+          #   )
+          # }
+
+          rule(
+            tag: simple(:tag),
+            desc: simple(:desc)
+          ) {
+            VarFieldDef.new(
+              tag: tag,
+              desc: desc
+            )
+          }
+
+          # ------------------------------------------------------------
+          # Sections
+
+          rule(desc: simple(:desc), var_fields: sequence(:var_fields)) {
+            Section.new(desc: desc, var_fields: var_fields)
+          }
+
+          # ------------------------------------------------------------
+          # List
+
+          rule(doc_comments: sequence(:doc_comments), sections: sequence(:sections)) {
+            desc = doc_comments.reject { |c| c.start_with?('TODO:') }.join("\n") # TODO: is "\n" best?
+            VarFieldList.new(desc: desc, sections: sections)
+          }
+        end
+        # rubocop:enable Style/BlockDelimiters
+      end
+    end
+  end
+end