ruby-marc-spec 0.1.0

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

@@ -0,0 +1,63 @@
+require 'stringio'
+require 'marc/spec/queries/selector'
+require 'marc/spec/queries/subfield'
+
+module MARC
+  module Spec
+    module Queries
+      class SubfieldValue
+        include Selector
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :subfield, :character_spec
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(subfield, character_spec = nil)
+          @subfield = ensure_type(subfield, Subfield)
+          @character_spec = ensure_type(character_spec, CharacterSpec, allow_nil: true)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          StringIO.new.tap do |out|
+            out << subfield
+            out << "/#{character_spec}" if character_spec
+          end.string
+        end
+
+        # ------------------------------------------------------------
+        # Protected
+
+        protected
+
+        def can_apply?(marc_obj)
+          subfield.send(:can_apply?, marc_obj)
+        end
+
+        def do_apply(data_field)
+          subfields = subfield.apply(data_field)
+          return subfields.map(&:value) unless character_spec
+
+          subfields.flat_map { |sf| character_spec.apply(sf.value) }
+        end
+
+        def to_s_inspect
+          StringIO.new.tap do |out|
+            out << subfield.inspect
+            out << "/#{character_spec.inspect}" if character_spec
+          end.string
+        end
+
+        def equality_attrs
+          %i[subfield character_spec]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'marc'
+require 'marc/spec/queries/applicable'
+
+module MARC
+  module Spec
+    module Queries
+      class Tag
+        include Applicable
+
+        # ------------------------------------------------------------
+        # Constants
+
+        LDR = 'LDR'.freeze
+
+        # ------------------------------------------------------------
+        # Attributes
+
+        attr_reader :index, :tag_re, :tag_exact
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(tag, index = nil)
+          raise ArgumentError, 'Tag cannot be nil' unless tag
+
+          @tag_exact = tag.to_s unless (@tag_re = tag_re_from(tag))
+          @index = ensure_type(index, PositionOrRange, allow_nil: true)
+        end
+
+        # ------------------------------------------------------------
+        # Public methods
+
+        def leader?
+          tag_exact == LDR
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          StringIO.new.tap do |out|
+            out << tag_str
+            out << "[#{index}]" if index
+          end.string
+        end
+
+        # ------------------------------------------------------------
+        # Protected methods
+
+        protected
+
+        # ------------------------------
+        # Applicable
+
+        def can_apply?(marc_obj)
+          marc_obj.is_a?(MARC::Record)
+        end
+
+        def do_apply(marc_record)
+          return [marc_record.leader] if leader?
+
+          all_fields = all_fields(marc_record)
+          index ? index.select_from(all_fields) : all_fields
+        end
+
+        # ------------------------------
+        # Predicate
+
+        def to_s_inspect
+          StringIO.new.tap do |out|
+            out << (tag_re ? tag_re.inspect : tag_exact)
+            out << "[#{index.inspect}]" if index
+          end.string
+        end
+
+        def equality_attrs
+          %i[tag_str index]
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        def all_fields(marc_record)
+          return marc_record.fields(tag_exact) if tag_exact
+
+          [].tap do |ff|
+            ff << marc_record.leader if LDR =~ tag_re
+            marc_record.each { |field| ff << field if field.tag =~ tag_re }
+          end
+        end
+
+        def tag_re_from(tag)
+          return tag if tag.is_a?(Regexp)
+
+          tag_s = tag.to_s
+          Regexp.compile("^#{tag_s}$") if tag_s.include?('.')
+        end
+
+        def tag_str
+          @tag_str ||= tag_exact || tag_re.source.gsub(/^\^(.*)\$$/, '\\1')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+require 'parslet'
+
+module MARC
+  module Spec
+    module Queries
+      class Transform < Parslet::Transform
+
+        # ----------------------------------------
+        # Misc. atoms
+
+        # { pos: }
+        rule(pos: simple(:pos)) { Position.new(pos) }
+
+        # { from:, to: }
+        rule(from: simple(:from), to: simple(:to)) { AlNumRange.new(from, to) }
+
+        # { comparison_string: }
+        rule(comparison_string: simple(:string)) { ComparisonString.new(string) }
+
+        # { character_spec: }
+        rule(character_spec: simple(:character_spec)) do
+          # noinspection RubyArgCount
+          CharacterSpec.new(character_spec)
+        end
+
+        # ----------------------------------------
+        # subTermSet
+
+        # { left:, operator:, right: }
+        rule(left: simple(:left), operator: simple(:operator), right: simple(:right)) do
+          Condition.new(operator, left: left, right: right)
+        end
+
+        # { operator:, right: }
+        rule(operator: simple(:operator), right: simple(:right)) do
+          Condition.new(operator, right: right)
+        end
+
+        # { right: }
+        rule(right: simple(:right)) do
+          Condition.new(right: right)
+        end
+
+        # { any_condition: }
+        rule(any_condition: sequence(:conditions)) do
+          Condition.any_of(*conditions)
+        end
+
+        # { all_conditions: }
+        rule(all_conditions: sequence(:conditions)) do
+          Condition.all_of(*conditions)
+        end
+
+        # ----------------------------------------
+        # fieldSpec
+
+        # { tag: }
+        rule(tag: simple(:tag)) do
+          Tag.new(tag)
+        end
+
+        # { tag:, index: }
+        rule(tag: simple(:tag), index: simple(:index)) do
+          Tag.new(tag, index)
+        end
+
+        # ----------------------------------------
+        # abrSubfieldSpec
+
+        # { code: }
+        rule(code: simple(:code)) do
+          Subfield.new(code)
+        end
+
+        # { code:, index: }
+        rule(code: simple(:code), index: simple(:index)) do
+          Subfield.new(code, index: index)
+        end
+
+        # { code:, sf_chars: }
+        rule(code: simple(:code), sf_chars: simple(:sf_chars)) do
+          SubfieldValue.new(Subfield.new(code), sf_chars)
+        end
+
+        # { code:, index:, sf_chars: }
+        rule(code: simple(:code), index: simple(:index), sf_chars: simple(:sf_chars)) do
+          SubfieldValue.new(Subfield.new(code, index: index), sf_chars)
+        end
+
+        # ----------------------------------------
+        # indicatorSpec
+
+        # { ind: }
+        rule(ind: simple(:ind)) do
+          IndicatorValue.new(ind)
+        end
+
+        # ----------------------------------------
+        # subSpec
+
+        # TODO: separate Subquery type?
+
+        # { selector: }
+        rule(selector: simple(:selector)) do
+          Query.new(selector: selector)
+        end
+
+        # { selector:, condition: }
+        rule(selector: simple(:selector), condition: simple(:condition)) do
+          Query.new(selector: selector, condition: condition)
+        end
+
+        # ----------------------------------------
+        # MARCSpec
+
+        # { tag:, selector: }
+        rule(tag: simple(:tag), selector: simple(:selector)) do
+          Query.new(tag: Tag.new(tag), selector: selector)
+        end
+
+        # { tag:, index:, selector: }
+        rule(tag: simple(:tag), index: simple(:index), selector: simple(:selector)) do
+          Query.new(tag: Tag.new(tag, index), selector: selector)
+        end
+
+        # { tag:, condition: }
+        rule(tag: simple(:tag), condition: simple(:condition)) do
+          Query.new(tag: Tag.new(tag), condition: condition)
+        end
+
+        # { tag:, index:, condition: }
+        rule(tag: simple(:tag), index: simple(:index), condition: simple(:condition)) do
+          Query.new(tag: Tag.new(tag, index), condition: condition)
+        end
+
+        # { tag:, subqueries: }
+        rule(tag: simple(:tag), subqueries: sequence(:subqueries)) do
+          Query.new(tag: Tag.new(tag), subqueries: subqueries)
+        end
+
+        # { tag:, selector:, condition: }
+        rule(tag: simple(:tag), selector: simple(:selector), condition: simple(:condition)) do
+          Query.new(tag: Tag.new(tag), selector: selector, condition: condition)
+        end
+
+        # { tag:, index:, selector:, condition: }
+        rule(tag: simple(:tag), index: simple(:index), selector: simple(:selector), condition: simple(:condition)) do
+          Query.new(tag: Tag.new(tag, index), selector: selector, condition: condition)
+        end
+
+      end
+    end
+  end
+end

data/lib/marc/spec/queries.rb

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

data/lib/marc/spec.rb

@@ -0,0 +1,32 @@
+Dir.glob(File.expand_path('spec/*.rb', __dir__)).sort.each(&method(:require))
+
+module MARC
+  module Spec
+    class << self
+      def find(query_string, marc_record)
+        root = parse_query(query_string)
+        executor = Queries::QueryExecutor.new(marc_record, root)
+        executor.execute
+      end
+
+      def parse_query(query_string)
+        parse_tree = parser.parse(query_string, reporter: reporter)
+        xform.apply(parse_tree)
+      end
+
+      private
+
+      def parser
+        @parser ||= Parsing::Parser.new
+      end
+
+      def xform
+        @xform ||= Queries::Transform.new
+      end
+
+      def reporter
+        @reporter ||= Parslet::ErrorReporter::Contextual.new
+      end
+    end
+  end
+end

data/rakelib/.rubocop.yml

@@ -0,0 +1,19 @@
+inherit_from: ../.rubocop.yml
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false

data/rakelib/bundle.rake

@@ -0,0 +1,8 @@
+namespace :bundle do
+  desc 'Updates the ruby-advisory-db then runs bundle-audit'
+  task :audit do
+    require 'bundler/audit/cli'
+    Bundler::Audit::CLI.start ['update']
+    Bundler::Audit::CLI.start %w[check --ignore CVE-2015-9284]
+  end
+end

data/rakelib/coverage.rake

@@ -0,0 +1,11 @@
+require 'ci/reporter/rake/rspec'
+
+# Configure CI::Reporter report generation
+ENV['GENERATE_REPORTS'] ||= 'true'
+ENV['CI_REPORTS'] = 'artifacts/rspec'
+
+desc 'Run all specs in spec directory, with coverage'
+task coverage: ['ci:setup:rspec'] do
+  ENV['COVERAGE'] ||= 'true'
+  Rake::Task[:spec].invoke
+end

data/rakelib/gem.rake

@@ -0,0 +1,54 @@
+require 'rubygems/gem_runner'
+require 'marc/spec/module_info'
+
+module MARC::Spec
+  class << self
+    def project_root
+      @project_root ||= File.expand_path('..', __dir__)
+    end
+
+    def artifacts_dir
+      return project_root unless ENV['CI']
+
+      @artifacts_dir ||= File.join(project_root, 'artifacts')
+    end
+
+    def gemspec_file
+      @gemspec_file ||= begin
+        gemspec_files = Dir.glob(File.expand_path('*.gemspec', project_root))
+        raise ArgumentError, "Too many .gemspecs: #{gemspec_files.join(', ')}" if gemspec_files.size > 1
+        raise ArgumentError, 'No .gemspec file found' if gemspec_files.empty?
+
+        gemspec_files[0]
+      end
+    end
+
+    def gemspec_basename
+      File.basename(gemspec_file)
+    end
+
+    def output_file
+      @output_file ||= begin
+        gem_name = File.basename(gemspec_file, '.*')
+        version = MARC::Spec::ModuleInfo::VERSION
+        basename = "#{gem_name}-#{version}.gem"
+        File.join(artifacts_dir, basename)
+      end
+    end
+
+    def output_file_relative
+      return File.basename(output_file) unless ENV['CI']
+
+      @output_file_relative ||= begin
+        artifacts_dir_relative = File.basename(artifacts_dir)
+        File.join(artifacts_dir_relative, File.basename(output_file))
+      end
+    end
+  end
+end
+
+desc "Build #{MARC::Spec.gemspec_basename} as #{MARC::Spec.output_file_relative}"
+task :gem do
+  args = ['build', MARC::Spec.gemspec_file, "--output=#{MARC::Spec.output_file}"]
+  Gem::GemRunner.new.run(args)
+end

data/rakelib/parser_specs/formatter.rb

@@ -0,0 +1,31 @@
+require 'rubocop'
+
+module ParserSpecs
+  module Formatter
+    include RuboCop::Cop::Util
+
+    def validity(v)
+      v ? 'valid' : 'invalid'
+    end
+
+    def quote(s)
+      to_string_literal(String.new(s))
+    end
+
+    def decamelize(str)
+      return unless str
+
+      str.gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
+    end
+
+    def indent(str, indent, omit_first: true)
+      return str.gsub(/^/, indent) unless omit_first
+
+      str.gsub(/(\n)/, "\\1#{indent}")
+    end
+
+    class << self
+      include Formatter
+    end
+  end
+end

data/rakelib/parser_specs/parser_specs.rb.txt.erb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+module MARC
+  module Spec
+    module Parsing
+      context 'suite' do
+        describe <%= ":#{name}" %> do
+          let(:parser) { Parser.new }
+          let(:reporter) { Parslet::ErrorReporter::Deepest.new }
+          <% suites.sort.each do |suite| %>
+          describe <%= quote(suite.description) %> do
+            # <%= suite.json_path %><% (suite.tests_by_group[nil] || []).sort.each do |test| %>
+            it <%= quote("#{test.description} -> #{validity(test.valid)}") %> do
+              # <%= test.json_path %><% test.rspec_assertions.each do |asrt| %>
+              <%= asrt %><% end %>
+            end
+            <% end %>
+            <% suite.tests_by_group.each do |group, tests| %>
+              <% next unless group %>
+            describe <%= quote(group) %> do
+              <% tests.sort.each do |test| %>
+              it <%= quote("#{test.detail} -> #{validity(test.valid)}") %> do
+                # <%= test.json_path %><% test.rspec_assertions.each do |asrt| %>
+                <%= asrt %><% end %>
+              end
+              <% end %>
+            end
+            <% end %>
+          end<% end %>
+        end
+      end
+    end
+  end
+end

data/rakelib/parser_specs/rule.rb

@@ -0,0 +1,95 @@
+require 'json'
+require 'ostruct'
+require_relative 'formatter'
+require_relative 'suite'
+
+module ParserSpecs
+  class Rule
+    include Formatter
+
+    RULE_RE = %r{/(?<wild>wildCombination_)?(?<valid>valid|invalid)(?<rule>[A-Z][[:alpha:]]+)\.json$}.freeze
+
+    TEMPLATE_PATH = File.expand_path('parser_specs.rb.txt.erb', __dir__)
+
+    attr_reader :name
+
+    def initialize(name, suites = [])
+      @name = name
+      suites.each { |s| add_suite(s) }
+    end
+
+    def to_s
+      name
+    end
+
+    def suites
+      @suites ||= []
+    end
+
+    def add_suite(s)
+      return (suites << s) unless (existing = suites.find { |s1| s1.merge?(s) })
+
+      existing.merge(s)
+    end
+
+    def write_rspec_to(dir)
+      basename = "#{name}_spec.rb"
+      spec_path = File.join(dir, basename)
+
+      # ideally we could just run the ERB as-is, but it's hard to write
+      # a legible template that doesn't introduce some unwanted whitespace
+      spec_src = Rule.template.result(binding)
+        .gsub(/ +$/, '')
+        .gsub(/\n\n+/, "\n\n")
+
+      puts "writing #{basename}"
+      File.write(spec_path, spec_src)
+    end
+
+    class << self
+      include Formatter
+
+      def all_from_json(json_root)
+        Dir.glob(File.join(json_root, '*valid/*.json')).sort.each_with_object([]) do |json_path, rules|
+          rule_name, wild = extract_rule_metadata(json_path)
+
+          suite_data = JSON.parse(File.read(json_path), object_class: OpenStruct, symbolize_names: true)
+          suite = Suite.from_ostruct(suite_data, rule_name, wild, json_path.sub(json_root, ''))
+
+          add_suite(rules, rule_name, suite)
+        end
+      end
+
+      def template
+        @template ||= begin
+          template_src = File.read(TEMPLATE_PATH)
+          ERB.new(template_src, trim_mode: '-')
+        end
+      end
+
+      private
+
+      def extract_rule_metadata(json_path)
+        raise ArgumentError, "#{json_path} does not match #{RULE_RE.source}" unless (match_data = RULE_RE.match(json_path))
+
+        [normalize_rule_name(match_data[:rule]), !match_data[:wild].nil?]
+      end
+
+      def add_suite(rules, rule_name, suite)
+        if (existing = rules.find { |r| r.name == rule_name })
+          existing.add_suite(suite)
+        else
+          rules << Rule.new(rule_name, [suite])
+        end
+      end
+
+      def normalize_rule_name(name)
+        return unless name
+
+        decamelize(name).tap do |n|
+          return 'subfield_char' if n == 'subfield_tag' # suite doesn't match spec
+        end
+      end
+    end
+  end
+end