ruby-marc-spec 0.1.0

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

@@ -0,0 +1,80 @@
+require 'marc/spec/queries/al_num_range'
+require 'marc/spec/queries/position'
+require 'marc/spec/queries/comparison_string'
+require 'marc/spec/queries/condition'
+
+require 'marc/spec/queries/character_spec'
+require 'marc/spec/queries/indicator_value'
+require 'marc/spec/queries/operator'
+require 'marc/spec/queries/query'
+require 'marc/spec/queries/subfield'
+require 'marc/spec/queries/subfield_value'
+require 'marc/spec/queries/tag'
+
+module MARC
+  module Spec
+    module Queries
+      module DSL
+
+        def all_c(*c)
+          Condition.all_of(*c)
+        end
+
+        def any_c(*c)
+          Condition.any_of(*c)
+        end
+
+        def vfv(sf)
+          sf
+        end
+
+        def rng(from, to = nil)
+          AlNumRange.new(from, to)
+        end
+
+        def q(t = nil, s: nil, c: nil, sq: [])
+          Query.new(tag: t, selector: s, condition: c, subqueries: sq)
+        end
+
+        def pos(p)
+          Position.new(p)
+        end
+
+        def cstr(s)
+          ComparisonString.new(s)
+        end
+
+        def c(*args)
+          case args.size
+          when 2
+            Condition.new(args[0], right: args[1])
+          when 3
+            Condition.new(args[1], left: args[0], right: args[2])
+          end
+        end
+
+        def cspec(chars)
+          # noinspection RubyArgCount
+          CharacterSpec.new(chars)
+        end
+
+        def indv(ind)
+          IndicatorValue.new(ind)
+        end
+
+        def sf(code, index = nil)
+          Subfield.new(code, index: index)
+        end
+
+        def sfv(sf, cspc = nil)
+          cspc = cspec(cspc) if cspc.is_a?(PositionOrRange)
+          SubfieldValue.new(sf, cspc)
+        end
+
+        def tag(t, index = nil)
+          Tag.new(t, index)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'marc/spec/queries/selector'
+
+module MARC
+  module Spec
+    module Queries
+      class IndicatorValue
+        include Selector
+
+        # ------------------------------------------------------------
+        # Constants
+
+        VALID_INDICATORS = [1, 2].freeze
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :tag, :ind
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(ind)
+          @ind = valid_indicator(ind)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          "^#{ind}"
+        end
+
+        # ------------------------------
+        # Applicable
+
+        def can_apply?(marc_obj)
+          %i[indicator1 indicator2].all? { |m| marc_obj.respond_to?(m) }
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        # ------------------------------
+        # Applicable
+
+        def do_apply(marc_obj)
+          ind_val = ind_val_for(marc_obj)
+          ind_val ? [ind_val] : []
+        end
+
+        def equality_attrs
+          %i[ind]
+        end
+
+        private
+
+        def ind_val_for(data_field)
+          case ind
+          when 1
+            data_field.indicator1
+          when 2
+            data_field.indicator2
+          end
+        end
+
+        def valid_indicator(ind_val)
+          ind = int_or_nil(ind_val)
+          return ind if VALID_INDICATORS.include?(ind)
+
+          raise ArgumentError, "Not a valid indicator: #{ind_val.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'typesafe_enum'
+
+module MARC
+  module Spec
+    module Queries
+      # NOTE: && and || are not defined in the MARCspec standard but are
+      #       implementation details of repeated (AND) and chained (OR) subspecs
+      #       -- see https://marcspec.github.io/MARCspec/marc-spec.html#general
+      class Operator < TypesafeEnum::Base
+
+        # ------------------------------------------------------------
+        # Enum instances
+
+        new(:EQ, '=') do
+          def apply(lr, rr)
+            return false if rr.nil?
+            return rarr_eq?(lr, rr) if rr.is_a?(Array)
+            return larr_eq?(lr, rr) if lr.is_a?(Array)
+
+            lr == rr
+          end
+
+          def larr_eq?(larr, rr)
+            larr.any? { |l| apply(l, rr) }
+          end
+
+          def rarr_eq?(lr, rarr)
+            rarr.any? { |r| apply(lr, r) }
+          end
+        end
+
+        new(:NEQ, '!=') do
+          def apply(lr, rr)
+            !Operator::EQ.apply(lr, rr)
+          end
+        end
+
+        new(:INCL, '~') do
+          def apply(lr, rr)
+            return false if [lr, rr].any?(&:nil?) # TODO: is this right?
+            return rarr_incl?(lr, rr) if rr.is_a?(Array)
+            return larr_incl?(lr, rr) if lr.is_a?(Array)
+
+            lr.include?(rr)
+          end
+
+          def larr_incl?(larr, rr)
+            larr.any? { |l| apply(l, rr) }
+          end
+
+          def rarr_incl?(lr, rarr)
+            rarr.any? { |r| apply(lr, r) }
+          end
+        end
+
+        new(:NINCL, '!~') do
+          def apply(lr, rr)
+            !Operator::INCL.apply(lr, rr)
+          end
+        end
+
+        new(:NEXIST, '!') do
+          def apply(right)
+            right.is_a?(Array) ? right.empty? : right.nil?
+          end
+        end
+
+        new(:EXIST, '?') do
+          def apply(right)
+            !Operator::NEXIST.apply(right)
+          end
+        end
+
+        new(:AND, '&&') do
+          def apply(left, right)
+            left && right
+          end
+        end
+
+        new(:OR, '||') do
+          def apply(left, right)
+            left || right
+          end
+        end
+
+        # ------------------------------------------------------------
+        # Class methods
+
+        class << self
+          def from_str(op_str)
+            Operator.find_by_value(op_str.to_s).tap do |op|
+              raise ArgumentError, "No such operator: #{op_str}" unless op
+            end
+          end
+        end
+
+        # ------------------------------------------------------------
+        # Operator
+
+        def binary?
+          ![Operator::EXIST, Operator::NEXIST].include?(self)
+        end
+
+        def logical?
+          [Operator::AND, Operator::OR].include?(self)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          op_str
+        end
+
+        # @return [String]
+        def op_str
+          # noinspection RubyMismatchedReturnType
+          value
+        end
+
+        def to_expression(left, right)
+          return ["(#{left})", self, "(#{right})"].join if logical?
+
+          [left, self, right].join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module MARC
+  module Spec
+    module Queries
+      # Supermodule of partial query
+      module Part
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def inspect
+          "#{class_name(self)}<#{to_s_inspect}>"
+        end
+
+        def eql?(other)
+          return false unless other.class == self.class
+
+          equality_attrs.all? do |attr|
+            send(attr) == other.send(attr)
+          end
+        end
+
+        alias :== eql?
+
+        def hash
+          @hash_val ||= begin
+            equality_vals = equality_attrs.map { |attr| send(attr) }
+            equality_vals.inject(31 + self.class.hash) { |r, v| 31 * r + v.hash }
+          end
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        def to_s_inspect
+          to_s
+        end
+
+        def ensure_type(v, type, allow_nil: false)
+          return if allow_nil && v.nil?
+          return v if v.is_a?(type)
+
+          raise ArgumentError, "Not a #{class_name(type)}: #{v.inspect}"
+        end
+
+        def int_or_nil(v)
+          return nil if v.nil? || v == '#'
+
+          Integer(v)
+        end
+
+        private
+
+        def class_name(t)
+          return class_name(t.class) unless t.is_a?(Class) || t.is_a?(Module)
+
+          t.name.sub(/^.*::/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'marc/spec/queries/position_or_range'
+
+module MARC
+  module Spec
+    module Queries
+      class Position
+        include PositionOrRange
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :position
+
+        def initialize(position)
+          @position = int_or_nil(position)
+        end
+
+        # ------------------------------------------------------------
+        # Instance methods
+
+        # @overload select_from(seq)
+        #   Selects the value at the specified position and returns it as a
+        #   single-element array, for compatibility with AlNumRange
+        #   @param seq [Array] the input array
+        #   @return [Array] a single-element array containing the result, or
+        #     an empty array if the index is out of bounds
+        # @overload select_from(seq)
+        #   Selects the character at the specified position
+        #   @param seq [String] the input array
+        #   @return [String, nil] a single-element array, or nil if the index
+        #     is out of bounds
+        def select_from(seq)
+          # we use raw_result[-1] instead of raw_result.last b/c seq might be a string
+          raw_result = seq[position.nil? ? -1 : position]
+          seq.is_a?(String) ? wrap_string_result(raw_result) : wrap_array_result(raw_result)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          (position || '#').to_s
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        # ------------------------------
+        # Part
+
+        def equality_attrs
+          [:position]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'marc/spec/queries/applicable'
+
+module MARC
+  module Spec
+    module Queries
+      # Marker interface for positions and ranges
+      # TODO: unify Position and AlNumRange?
+      module PositionOrRange
+        include Part
+
+        protected
+
+        def wrap_string_result(result)
+          result unless result.nil? || result.empty?
+        end
+
+        # NOTE: We can't use `Array()` because we don't want to indiscriminately call `to_ary` / `to_a`
+        def wrap_array_result(result)
+          return [] unless result
+          return result if result.is_a?(Array)
+
+          [result]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'marc/spec/queries/part'
+
+module MARC
+  module Spec
+    module Queries
+      class Query
+        include Part
+
+        attr_reader :tag, :selector, :condition, :subqueries
+
+        # TODO: separate factory methods for possible cases? (see transform.rb)
+        # TODO: separate query (w/o subqueries) from wrapper w/subqueries?
+        def initialize(tag: nil, selector: nil, condition: nil, subqueries: [])
+          @tag = ensure_type(tag, Tag, allow_nil: true)
+          # TODO: do we need the Selector interface at all?
+          @selector = ensure_type(selector, Applicable, allow_nil: true)
+          @condition = ensure_type(condition, Condition, allow_nil: true)
+          @subqueries = subqueries.map { |sq| ensure_type(sq, Query) }
+        end
+
+        def to_s
+          StringIO.new.tap do |out|
+            out << tag if tag
+            out << selector if selector
+            out << "{#{condition}}" if condition
+            out << subqueries.join
+          end.string
+        end
+
+        # TODO: don't support nested subqueries
+        def execute(executor, context_fields, context_result = nil)
+          fields = tag ? executor.apply_tag(tag) : context_fields
+          return [] if fields.empty?
+
+          field_results = root_results(fields, executor, context_result)
+          return field_results if subqueries.empty?
+
+          fields.each_with_object([]) do |field, results|
+            subqueries.each do |subquery|
+              subquery_results = subquery.execute(executor, [field])
+              results.concat(subquery_results)
+            end
+          end
+        end
+
+        protected
+
+        def equality_attrs
+          %i[tag selector condition subqueries]
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def to_s_inspect
+          StringIO.new.tap do |out|
+            out << tag.inspect if tag
+            out << selector.inspect if selector
+            out << "{#{condition.inspect}}" if condition
+            out << subqueries.map(&:inspect).join
+          end.string
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def root_results(fields, executor, context_result)
+          field_results = results_for_fields(executor, fields)
+          # TODO: something less ridiculous
+          return field_results unless field_results.empty? && select_from_context?(context_result)
+
+          selector.apply(context_result)
+        end
+
+        def select_from_context?(context_result)
+          tag.nil? && context_result && selector.can_apply?(context_result)
+        end
+
+        def results_for_fields(executor, fields)
+          fields.each_with_object([]) do |field, results|
+            field_results = results_for_field(executor, field)
+            results.concat(field_results)
+          end
+        end
+
+        def results_for_field(executor, field)
+          results = executor.apply_selector(selector, field)
+          return results unless condition
+
+          results.select { |result| executor.condition_met?(condition, field, result) }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'marc'
+require 'marc/spec/queries/query'
+
+module MARC
+  module Spec
+    module Queries
+      class QueryExecutor
+        include Part
+
+        attr_reader :marc_record, :root_query, :root_tag, :root_fields
+
+        def initialize(marc_record, root, cache = {})
+          @marc_record = ensure_type(marc_record, MARC::Record)
+          @root_query = as_query(root)
+          @cache = cache
+
+          @root_tag = root_query.tag || Tag.new('...')
+          @root_fields = apply_tag(root_tag)
+        end
+
+        def execute
+          root_query.execute(self, root_fields)
+        end
+
+        def apply_tag(tag)
+          cache[tag] ||= tag.apply(marc_record)
+        end
+
+        def apply_selector(selector, field)
+          return [field] unless selector
+
+          cache_key = [selector, field]
+          cache[cache_key] ||= selector.apply(field)
+        end
+
+        def condition_met?(condition, context_field, context_result)
+          cond_ctx = ConditionContext.new(context_field, context_result, self)
+          condition.met?(cond_ctx)
+        end
+
+        private
+
+        def as_query(root)
+          return root if root.is_a?(Query)
+          return Query.new(tag: root) if root.is_a?(Tag)
+        end
+
+        attr_reader :cache
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'marc/spec/queries/applicable'
+
+module MARC
+  module Spec
+    module Queries
+      # Marker interface for query objects that select data from fields
+      module Selector
+        include Applicable
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'stringio'
+require 'marc/spec/queries/selector'
+
+module MARC
+  module Spec
+    module Queries
+      class Subfield
+        include Selector
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :code, :index
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(code, index: nil)
+          @code = parse_code(code)
+          @index = ensure_type(index, PositionOrRange, allow_nil: true)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          StringIO.new.tap do |out|
+            out << '$'
+            out << code
+            out << "[#{index}]" if index
+          end.string
+        end
+
+        # ------------------------------
+        # Applicable
+
+        def can_apply?(marc_obj)
+          marc_obj.respond_to?(:subfields)
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        # ------------------------------
+        # Applicable
+
+        def do_apply(data_field)
+          subfields = all_subfields(data_field)
+          raw_result = index ? index.select_from(subfields) : subfields
+          Array(raw_result)
+        end
+
+        # ------------------------------
+        # Predicate
+
+        def to_s_inspect
+          StringIO.new.tap do |out|
+            out << '$'
+            out << code.inspect
+            out << "[#{index.inspect}]" if index
+          end.string
+        end
+
+        def equality_attrs
+          %i[code index]
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        def all_subfields(data_field)
+          data_field.subfields.select { |sf| code.include?(sf.code) }
+        end
+
+        def parse_code(code)
+          raise ArgumentError, 'Code cannot be nil' if code.nil?
+
+          code.is_a?(AlNumRange) ? code : code.to_s
+        end
+
+      end
+    end
+  end
+end