ruby-marc-spec 0.1.0

data/lib/marc/spec/parsing/parser.rb

@@ -0,0 +1,213 @@
+require 'parslet'
+require 'marc/spec/parsing/closed_int_range'
+require 'marc/spec/parsing/closed_lc_alpha_range'
+
+module MARC
+  module Spec
+    module Parsing
+      # rubocop:disable Style/BlockDelimiters
+      # noinspection RubyResolve
+      class Parser < Parslet::Parser
+
+        # ------------------------------------------------------------
+        # DSL extensions
+
+        def closed_int_range
+          ClosedIntRange.new
+        end
+
+        def closed_lc_alpha_range
+          ClosedLcAlphaRange.new
+        end
+
+        # ------------------------------------------------------------
+        # Parsing rules
+
+        # alphaupper        = %x41-5A
+        #                     ; A-Z
+        rule(:alpha_upper) { match['A-Z'] }
+
+        # alphalower        = %x61-7A
+        #                     ; a-z
+        rule(:alpha_lower) { match['a-z'] }
+
+        # DIGIT             =  %x30-39
+        #                     ; 0-9
+        rule(:digit) { match['0-9'] }
+
+        # VCHAR             =  %x21-7E
+        #                     ; visible (printing) characters
+        rule(:vchar) { match['\u0021-\u007e'] }
+
+        # positiveDigit     = %x31-39
+        #                     ;  "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9"
+        rule(:positive_digit) { match['1-9'] }
+
+        # positiveInteger   = "0" / positiveDigit [1*DIGIT]
+        #
+        # NOTE: yes, this is a misnomer
+        rule(:positive_integer) { str('0') | (positive_digit >> digit.repeat) }
+
+        # fieldTag          = 3(alphalower / DIGIT / ".") / 3(alphaupper / DIGIT / ".")
+        rule(:field_tag) {
+          (alpha_lower | digit | str('.')).repeat(3, 3) | (alpha_upper | digit | str('.')).repeat(3, 3)
+        }
+
+        # position          = positiveInteger / "#"
+        rule(:position) { positive_integer | str('#') }
+
+        # Extracted from range, below
+        #
+        # NOTE: #-n means from (last index - n) to end of string
+        rule(:left_open_range) { str('#').ignore.as(:from) >> str('-') >> (positive_integer | str('#').ignore).as(:to) }
+
+        # Extracted from range, below
+        #
+        # NOTE: n-# means from position n to end of string
+        rule(:right_open_range) { positive_integer.as(:from) >> str('-') >> str('#').ignore.as(:to) }
+
+        # range             = position "-" position
+        #
+        # NOTE: n-# means from position n to end of string;
+        #       #-n means from (last index - n) to end of string
+        # rule(:range) { position.as(:from) >> str('-') >> position.as(:to) }
+        rule(:range) { left_open_range | right_open_range | closed_int_range }
+
+        # positionOrRange   = range / position
+        rule(:position_or_range) { range | position.as(:pos) }
+
+        # characterSpec     = "/" positionOrRange
+        rule(:character_spec) { str('/') >> position_or_range.as(:character_spec) }
+
+        # index             = "[" positionOrRange "]"
+        rule(:index) { (str('[') >> position_or_range >> str(']')).as(:index) }
+
+        # fieldSpec         = fieldTag [index] [characterSpec]
+        rule(:field_spec) { field_tag.as(:tag) >> index.maybe >> character_spec.as(:selector).maybe }
+
+        # abrFieldSpec      = index [characterSpec] / characterSpec
+        rule(:abr_field_spec) do
+          (index >> character_spec.as(:selector).maybe) | character_spec.as(:selector)
+        end
+
+        # subfieldChar      = %x21-3F / %x5B-7B / %x7D-7E
+        #                     ; ! " # $ % & ' ( ) * + , - . / 0-9 : ; < = > ? [ \ ] ^ _ \` a-z { } ~
+        # NOTE: Not just alphanumeric; see https://github.com/MARCspec/MARCspec/issues/31
+        rule(:subfield_char) { match['\u0021-\u003f'] | match['\u005b-\u007b'] | match['\u007d-\u007e'] }
+
+        # subfieldCode      = "$" subfieldChar
+        rule(:subfield_code) { str('$').ignore >> subfield_char }
+
+        # UNDOCUMENTED -- see spec/suite/valid/validSubfieldRange.json, https://github.com/MARCspec/MARCspec-Test-Suite/issues/1
+        rule(:subfield_range) { (closed_lc_alpha_range | closed_int_range) }
+
+        # subfieldCodeRange = "$" ( (alphalower "-" alphalower) / (DIGIT "-" DIGIT) )
+        #                     ; [a-z]-[a-z] / [0-9]-[0-9]
+        #
+        # NOTE: docs don't insist the range be valid (start <= end), but tests enforce it
+        rule(:subfield_code_range) { str('$').ignore >> subfield_range }
+
+        # abrSubfieldSpec   = (subfieldCode / subfieldCodeRange) [index] [characterSpec]
+        rule(:abr_subfield_spec) do
+          ((subfield_code_range | subfield_code).as(:code) >> index.maybe >> character_spec.as(:sf_chars).maybe).as(:selector)
+        end
+
+        # subfieldSpec      = fieldTag [index] abrSubfieldSpec
+        rule(:subfield_spec) { field_tag.as(:tag) >> index.maybe >> abr_subfield_spec }
+
+        # UNDOCUMENTED -- see spec/suite/valid/validIndicators.json, https://github.com/MARCspec/MARCspec-Test-Suite/issues/1
+        rule(:indicators) { str('1') | str('2') }
+
+        # abrIndicatorSpec  = [index] "^" ("1" / "2")
+        rule(:abr_indicator_spec) { index.maybe >> str('^') >> indicators.as(:ind).as(:selector) }
+
+        # indicatorSpec     = fieldTag abrIndicatorSpec
+        rule(:indicator_spec) { field_tag.as(:tag) >> abr_indicator_spec }
+
+        # Extracted from comparisonString (some VCHARs need to be escaped,
+        # and literal \ needs special handling)
+        rule(:vchar_cs_plain) { match['\u0021-\u007e&&[^!$=?{|}~]'] }
+
+        # Extracted from comparisonString (some VCHARs need to be escaped)
+        rule(:vchar_cs_special) { match['!$=?{|}~'] }
+
+        # Extracted from comparisonString (escaped)
+        rule(:vchar_cs_esc) { (str('\\') >> vchar_cs_special) }
+
+        # Extracted from comparisonString to simplify generated tests,
+        # which don't take leading \ into account
+        rule(:comparison_string) {
+          # escape is optional in position 1, apparently
+          head = (vchar_cs_special | vchar_cs_esc) | vchar_cs_plain
+          tail = (vchar_cs_esc | vchar_cs_plain).repeat
+          head >> tail
+        }
+
+        # comparisonString  = "\" *VCHAR
+        #
+        # NOTE: generated tests only handle the body of the string, not the
+        #       leading \, so we give the full rule a separate name
+        rule(:_comparison_string) { ((str('\\s') | str('\\').ignore) >> comparison_string).as(:comparison_string) }
+
+        # operator          = "=" / "!=" / "~" / "!~" / "!" / "?"
+        #                     ; equal / unequal / includes / not includes / not exists / exists
+        rule(:operator) { (str('=') | str('!=') | str('~') | str('!~') | str('!') | str('?')) }
+
+        # abbreviation      = abrFieldSpec / abrSubfieldSpec / abrIndicatorSpec
+        rule(:abbreviation) { (abr_subfield_spec | abr_indicator_spec | abr_field_spec) }
+
+        # subTerm           = fieldSpec / subfieldSpec / indicatorSpec / comparisonString / abbreviation
+        rule(:sub_term) { subfield_spec | indicator_spec | field_spec | _comparison_string | abbreviation }
+
+        # subTermSet        = [ [subTerm] operator ] subTerm
+        rule(:sub_term_set) { (sub_term.as(:left).maybe >> operator.as(:operator)).maybe >> sub_term.as(:right) }
+
+        # Extracted from subSpec for clarity
+        rule(:_chained_sub_term_sets) { (sub_term_set >> (str('|') >> sub_term_set).repeat(1)).as(:any_condition) }
+
+        # NOTE: generated tests are properly for subSpec*, so we give the
+        #       single one a separate name
+        #
+        # subSpec           = "{" subTermSet *( "|" subTermSet ) "}"
+        rule(:_sub_spec) { str('{') >> (_chained_sub_term_sets | sub_term_set) >> str('}') }
+
+        # Extracted from SubSpec for clarity
+        rule(:_repeated_sub_specs) { _sub_spec.repeat(2).as(:all_conditions) }
+
+        # Repeated to satisfy generated tests
+        rule(:sub_spec) { _repeated_sub_specs | _sub_spec }
+
+        # Rewritten from MARCspec for clarity
+        #  (subfieldSpec *subSpec *(abrSubfieldSpec *subSpec))
+        #  -> (fieldTag [index] *(abrSubfieldSpec *subSpec))
+        rule(:_multiple_subfield_spec) {
+          (field_tag.as(:tag) >> index.maybe) >>
+            (abr_subfield_spec >> sub_spec.as(:condition).maybe).repeat(2).as(:subqueries)
+        }
+
+        # Extracted from MARCspec for clarity:
+        #   (subfieldSpec *subSpec *(abrSubfieldSpec *subSpec))
+        # Rewritten for ease of parsing:
+        #   (fieldTag [index] *(abrSubfieldSpec *subSpec))
+        rule(:_varfield_marc_spec) {
+          _multiple_subfield_spec | (subfield_spec >> sub_spec.as(:condition).maybe)
+        }
+
+        # Extracted from MARCspec for clarity
+        # indicatorSpec *subSpec
+        rule(:_indicator_marc_spec) { (indicator_spec >> sub_spec.as(:condition).maybe) }
+
+        # Extracted from MARCspec for clarity
+        # fieldSpec *subSpec
+        rule(:_fixedfield_marc_spec) { (field_spec >> sub_spec.as(:condition).maybe) }
+
+        # MARCspec          = fieldSpec *subSpec / (subfieldSpec *subSpec *(abrSubfieldSpec *subSpec)) / indicatorSpec *subSpec
+        rule(:marc_spec) { _varfield_marc_spec | _indicator_marc_spec | _fixedfield_marc_spec }
+
+        root(:marc_spec)
+      end
+
+      # rubocop:enable Style/BlockDelimiters
+    end
+  end
+end

data/lib/marc/spec/parsing.rb

@@ -0,0 +1 @@
+Dir.glob(File.expand_path('parsing/*.rb', __dir__)).sort.each(&method(:require))

data/lib/marc/spec/queries/al_num_range.rb

@@ -0,0 +1,105 @@
+require 'marc/spec/queries/position_or_range'
+
+module MARC
+  module Spec
+    module Queries
+      class AlNumRange
+        include PositionOrRange
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :from, :to
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(from, to)
+          @from, @to = parse_endpoints(from, to)
+        end
+
+        # ------------------------------------------------------------
+        # Instance methods
+
+        def select_from(seq)
+          raw_result = select_raw_from(seq)
+          seq.is_a?(String) ? wrap_string_result(raw_result) : raw_result
+        end
+
+        def include?(v)
+          return false if empty?
+          return (v < 0 && v > reverse_endpoint) if from.nil?
+          return false if v < from
+
+          to.nil? ? true : v <= to
+        end
+
+        def alphabetic?
+          lc_alpha?(from) || lc_alpha?(to)
+        end
+
+        def empty?
+          from.nil? && to.nil?
+        end
+
+        def index_range
+          @index_range ||= to_range
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          "#{from || '#'}-#{to || '#'}"
+        end
+
+        # ------------------------------------------------------------
+        # Part
+
+        protected
+
+        def equality_attrs
+          %i[from to]
+        end
+
+        private
+
+        def select_raw_from(seq)
+          return seq if from == 0 && to.nil?
+          return seq[index_range] unless alphabetic?
+          return select_raw_from(seq.chars).join if seq.respond_to?(:chars)
+          raise ArgumentError, "Can't select from non-sequence #{seq.inspect}" unless seq.respond_to?(:select)
+
+          seq.select { |x| include?(x) }
+        end
+
+        def reverse_endpoint
+          -(1 + to)
+        end
+
+        def to_range
+          return (0..-1) if empty?
+          return (reverse_endpoint..) if from.nil?
+
+          (from..to) # OK for to to be nil here
+        end
+
+        def parse_endpoints(from, to)
+          original_values = [from, to]
+          if original_values.all? { |p| lc_alpha?(p) }
+            original_values.map(&:to_s)
+          else
+            original_values.map { |p| int_or_nil(p) }
+          end
+        end
+
+        def lc_alpha?(endpoint)
+          endpoint_str = endpoint.to_s
+          endpoint_str.size == 1 &&
+            endpoint_str.ord >= 'a'.ord &&
+            endpoint_str.ord <= 'z'.ord
+        end
+      end
+    end
+  end
+end

data/lib/marc/spec/queries/applicable.rb

@@ -0,0 +1,18 @@
+require 'marc/spec/queries/part'
+
+module MARC
+  module Spec
+    module Queries
+      # Supermodule of query objects that can return a result
+      module Applicable
+        include Part
+
+        def apply(marc_obj)
+          return [] unless can_apply?(marc_obj)
+
+          do_apply(marc_obj)
+        end
+      end
+    end
+  end
+end

data/lib/marc/spec/queries/character_spec.rb

@@ -0,0 +1,81 @@
+require 'stringio'
+require 'marc/spec/queries/selector'
+
+module MARC
+  module Spec
+    module Queries
+      class CharacterSpec
+        include Selector
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :character_spec
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(character_spec = AlNumRange.new(0, nil))
+          @character_spec = ensure_type(character_spec, PositionOrRange, allow_nil: false)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          "/#{character_spec}"
+        end
+
+        # ------------------------------
+        # Applicable
+
+        def can_apply?(marc_obj)
+          # MARC leader is ControlField-like but is returned as string
+          [String, MARC::ControlField, MARC::Subfield].any? { |t| marc_obj.is_a?(t) }
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        # ------------------------------
+        # Applicable
+
+        def do_apply(control_field)
+          field_value = field_value_for(control_field)
+          field_value ? [field_value] : []
+        end
+
+        # ------------------------------
+        # Part
+
+        def equality_attrs
+          %i[character_spec]
+        end
+
+        def to_s_inspect
+          "/#{character_spec.inspect}"
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        def field_value_for(control_field)
+          value_str = string_value_from(control_field)
+          return value_str unless character_spec
+
+          character_spec.select_from(value_str)
+        end
+
+        def string_value_from(tag_result)
+          return tag_result if tag_result.is_a?(String)
+          return tag_result.value if tag_result.respond_to?(:value)
+        end
+
+      end
+    end
+  end
+end

data/lib/marc/spec/queries/comparison_string.rb

@@ -0,0 +1,45 @@
+require 'marc/spec/queries/part'
+
+module MARC
+  module Spec
+    module Queries
+      class ComparisonString
+        include Part
+
+        # ------------------------------------------------------------
+        # Accessors
+
+        attr_reader :str_raw, :str_exact
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(str_raw)
+          @str_raw = str_raw.to_s
+          @str_exact = unescape(@str_raw)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          "\\#{str_raw}"
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        def equality_attrs
+          [:str_raw]
+        end
+
+        def unescape(str_raw)
+          str_raw.gsub(/\\(?=[${}!=~?|])/, '').gsub(/\\s/, ' ')
+        end
+
+      end
+    end
+  end
+end

data/lib/marc/spec/queries/condition.rb

@@ -0,0 +1,133 @@
+require 'marc/spec/queries/condition_context'
+require 'marc/spec/queries/part'
+require 'marc/spec/queries/operator'
+
+module MARC
+  module Spec
+    module Queries
+      class Condition
+        include Part
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :left, :operator, :right
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        # rubocop:disable Style/KeywordParametersOrder
+        def initialize(operator = '?', left: nil, right:)
+          @operator = Operator.from_str(operator)
+          # TODO: verify left semantics for unary operators
+          #       see: https://marcspec.github.io/MARCspec/marc-spec.html#general
+          #            https://marcspec.github.io/MARCspec/marc-spec.html#subspec-interpretation
+
+          @left = left_operand(left) if binary?
+          @right = right_operand(right)
+        end
+        # rubocop:enable Style/KeywordParametersOrder
+
+        # ------------------------------------------------------------
+        # Static factory methods
+
+        class << self
+          def any_of(*conditions)
+            conditions.inject do |cc, c|
+              cc.or(c)
+            end
+          end
+
+          def all_of(*conditions)
+            conditions.inject { |cc, c| cc.and(c) }
+          end
+        end
+
+        # ------------------------------------------------------------
+        # Instance methods
+
+        def met?(condition_context)
+          # puts self
+
+          right_val = condition_context.operand_value(right)
+          # puts "\t#{right.inspect} -> #{right_val.inspect}"
+          return unary_apply(right_val) unless binary?
+
+          left_val = condition_context.operand_value(left, implicit: true)
+          # puts "\t#{left.inspect} -> #{left_val.inspect}"
+          binary_apply(left_val, right_val)
+        end
+
+        def and(other_condition)
+          return self if other_condition == self || other_condition.nil?
+
+          Condition.new('&&', left: self, right: other_condition)
+        end
+
+        def or(other_condition)
+          return self if other_condition == self || other_condition.nil?
+
+          Condition.new('||', left: self, right: other_condition)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          operator.to_expression(left, right)
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        def to_s_inspect
+          StringIO.new.tap do |out|
+            out << left.inspect if left
+            out << operator
+            out << right.inspect
+          end.string
+        end
+
+        def equality_attrs
+          %i[left operator right]
+        end
+
+        private
+
+        def binary_apply(left_val, right_val)
+          operator.apply(left_val, right_val).tap do |_result|
+            # puts "\t#{left_val} #{operator} #{right_val} => #{_result}"
+          end
+        end
+
+        def unary_apply(right_val)
+          operator.apply(right_val).tap do |_result|
+            # puts "\t#{operator} #{right_val} => #{_result}"
+          end
+        end
+
+        def right_operand(right)
+          return right if right.is_a?(ComparisonString)
+
+          operand(right)
+        end
+
+        def left_operand(left)
+          operand(left) if left
+        end
+
+        # TODO: superinterface?
+        def operand(operand)
+          return operand if operand.is_a?(Condition) || operand.is_a?(Query)
+          return Query.new(tag: operand) if operand.is_a?(Tag)
+        end
+
+        def binary?
+          operator.binary?
+        end
+      end
+    end
+  end
+end

data/lib/marc/spec/queries/condition_context.rb

@@ -0,0 +1,49 @@
+require 'marc/spec/queries/comparison_string'
+require 'marc/spec/queries/condition'
+require 'marc/spec/queries/query'
+
+module MARC
+  module Spec
+    module Queries
+      class ConditionContext
+        attr_reader :context_field, :context_result, :executor
+
+        def initialize(context_field, context_result, executor)
+          @context_field = context_field
+          @context_result = context_result
+          @executor = executor
+        end
+
+        def operand_value(operand, implicit: false)
+          return context_result if implicit && operand.nil?
+
+          raw_value = operand_value_raw(operand)
+          is_boolean = [true, false].include?(raw_value)
+          is_boolean ? raw_value : as_string(raw_value)
+        end
+
+        private
+
+        def operand_value_raw(operand)
+          return unless operand
+
+          case operand
+          when ComparisonString
+            operand.str_exact
+          when Condition
+            operand.met?(self)
+          when Query
+            operand.execute(executor, [context_field], context_result)
+          end
+        end
+
+        def as_string(op_val)
+          return unless op_val
+          return op_val if op_val.is_a?(String)
+          return op_val.value if op_val.respond_to?(:value) && !op_val.is_a?(MARC::DataField)
+          return op_val.map { |v| as_string(v) } if op_val.is_a?(Array)
+        end
+      end
+    end
+  end
+end