ruby-marc-spec 0.1.0

data/spec/marc/spec/queries/al_num_range_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe AlNumRange do
+      describe 'closed, alphabetical' do
+        it 'handles string arguments' do
+          r = AlNumRange.new('j', 'q')
+          expect(r.from).to eq('j')
+          expect(r.to).to eq('q')
+          expect(r.to_s).to eq('j-q')
+
+          %w[j m q].each { |i| expect(r).to include(i) }
+          %w[i r].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from('nequaquam vacuum')).to eq('nqqmm')
+        end
+
+        it 'handles Parslet::Slice arguments' do
+          r = AlNumRange.new(
+            Parslet::Slice.new(1, 'j'),
+            Parslet::Slice.new(3, 'q')
+          )
+          expect(r.from).to eq('j')
+          expect(r.to).to eq('q')
+          expect(r.to_s).to eq('j-q')
+
+          %w[j m q].each { |i| expect(r).to include(i) }
+          %w[i r].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from('nequaquam vacuum')).to eq('nqqmm')
+        end
+      end
+
+      describe 'closed, numeric' do
+        it 'handles int arguments' do
+          r = AlNumRange.new(3, 5)
+          expect(r.from).to eq(3)
+          expect(r.to).to eq(5)
+          expect(r.to_s).to eq('3-5')
+
+          [3, 4, 5].each { |i| expect(r).to include(i) }
+          [2, 6].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from([3, 1, 4, 1, 5, 9, 2, 6, 5])).to eq([1, 5, 9])
+        end
+
+        it 'handles string arguments' do
+          r = AlNumRange.new('3', '5')
+          expect(r.from).to eq(3)
+          expect(r.to).to eq(5)
+          expect(r.to_s).to eq('3-5')
+
+          [3, 4, 5].each { |i| expect(r).to include(i) }
+          [2, 6].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from([3, 1, 4, 1, 5, 9, 2, 6, 5])).to eq([1, 5, 9])
+        end
+      end
+
+      describe 'left open, numeric' do
+        it 'handles int arguments' do
+          r = AlNumRange.new(nil, 5)
+          expect(r.from).to be_nil
+          expect(r.to).to eq(5)
+          expect(r.to_s).to eq('#-5')
+
+          [-5, -4, -3].each { |i| expect(r).to include(i) }
+          [1, 2, -6, -7].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from([3, 1, 4, 1, 5, 9, 2, 6, 5])).to eq([1, 5, 9, 2, 6, 5])
+        end
+
+        it 'handles string arguments' do
+          r = AlNumRange.new('#', '5')
+          expect(r.from).to be_nil
+          expect(r.to).to eq(5)
+          expect(r.to_s).to eq('#-5')
+
+          [-5, -4, -3].each { |i| expect(r).to include(i) }
+          [1, 2, -6, -7].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from([3, 1, 4, 1, 5, 9, 2, 6, 5])).to eq([1, 5, 9, 2, 6, 5])
+        end
+      end
+
+      describe 'right open, numeric' do
+        it 'handles int arguments' do
+          r = AlNumRange.new(4, nil)
+          expect(r.from).to eq(4)
+          expect(r.to).to be_nil
+          expect(r.to_s).to eq('4-#')
+
+          [4, 5].each { |i| expect(r).to include(i) }
+          [1, 2].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from([3, 1, 4, 1, 5, 9, 2, 6, 5])).to eq([5, 9, 2, 6, 5])
+        end
+
+        it 'handles string arguments' do
+          r = AlNumRange.new('4', '#')
+          expect(r.from).to eq(4)
+          expect(r.to).to be_nil
+          expect(r.to_s).to eq('4-#')
+
+          [4, 5].each { |i| expect(r).to include(i) }
+          [1, 2].each { |i| expect(r).not_to include(i) }
+
+          expect(r.select_from([3, 1, 4, 1, 5, 9, 2, 6, 5])).to eq([5, 9, 2, 6, 5])
+        end
+      end
+    end
+  end
+end

data/spec/marc/spec/queries/character_spec_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe CharacterSpec do
+      it 'accepts a position' do
+        pos = Position.new(3)
+        # noinspection RubyArgCount
+        v = CharacterSpec.new(pos)
+        expect(v.character_spec).to eq(pos)
+        expect(v.to_s).to eq('/3')
+      end
+
+      it 'accepts a range' do
+        range = AlNumRange.new(3, 5)
+        # noinspection RubyArgCount
+        v = CharacterSpec.new(range)
+        expect(v.character_spec).to eq(range)
+        expect(v.to_s).to eq('/3-5')
+      end
+
+      it 'rejects an invalid characterspec' do
+        # noinspection RubyArgCount
+        expect { CharacterSpec.new(/([a-z]+)/) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/marc/spec/queries/comparison_string_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe ComparisonString do
+      describe :str_exact do
+        it 'decodes escapes' do
+          expecteds = {
+            'value' => 'value',
+            '!value' => '!value',
+            '\\!value' => '!value',
+            '\\svalue' => ' value',
+            'value\\!' => 'value!',
+            'a\\{b\\}\\$1\\\\23\\=\\~\\|\\?' => 'a{b}$1\\\\23=~|?',
+            'help\\sI\\sam\\strapped\\sin\\sa\\sunit\\stest\\!\\sso\\sam\\sI' =>
+              'help I am trapped in a unit test! so am I'
+          }
+          aggregate_failures do
+            expecteds.each do |str_raw, expected|
+              cstr = ComparisonString.new(str_raw)
+              expect(cstr.str_exact).to eq(expected)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/marc/spec/queries/indicator_value_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe IndicatorValue do
+      it 'accepts an int indicator' do
+        v = IndicatorValue.new(1)
+        expect(v.ind).to eq(1)
+        expect(v.to_s).to eq('^1')
+      end
+
+      it 'accepts a string indicator' do
+        v = IndicatorValue.new('1')
+        expect(v.ind).to eq(1)
+        expect(v.to_s).to eq('^1')
+      end
+
+      it 'rejects a nil indicator' do
+        expect { IndicatorValue.new(nil) }.to raise_error(ArgumentError)
+      end
+
+      it 'rejects an invalid indicator' do
+        expect { IndicatorValue.new(3) }.to raise_error(ArgumentError)
+        expect { IndicatorValue.new('3') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/marc/spec/queries/query_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe Query do
+      attr_reader :parser
+      attr_reader :xform
+      attr_reader :marc_record
+
+      before(:each) do
+        @parser = Parsing::Parser.new
+        @xform = Transform.new
+      end
+
+      def subfield_codes(df)
+        df.subfields.map(&:code)
+      end
+
+      def subfields(df, code)
+        codes = Array(code)
+        df.subfields.select { |sf| codes.include?(sf.code) }
+      end
+
+      def verify_all(examples)
+        aggregate_failures { examples.each { |query_str, expected| verify_result(query_str, expected) } }
+      end
+
+      def query_from(query_str)
+        parse_tree = parser.parse(query_str)
+        xform.apply(parse_tree)
+      end
+
+      def verify_result(query_str, expected)
+        query = query_from(query_str)
+        executor = QueryExecutor.new(marc_record, query)
+        actual = executor.execute
+
+        expect(actual).to eq(expected), -> { failure_msg_for(query_str, query, actual, expected) }
+      end
+
+      def failure_msg_for(input_str, query, actual, expected)
+        expected_str = expected.respond_to?(:map) ? expected.map(&:to_s) : expected.to_s
+        actual_str = actual.respond_to?(:map) ? actual.map(&:to_s) : actual.to_s
+        [
+          input_str.inspect,
+          "query:     \t#{query.inspect}",
+          "expected:  \t#{expected_str}",
+          "           \t#{expected.inspect}",
+          "actual:    \t#{actual_str}",
+          "           \t#{actual.inspect}"
+        ].join("\n\t")
+      end
+
+      describe :to_s do
+        it 'includes all elements' do
+          # noinspection RubyLiteralArrayInspection
+          [
+            '245$a',
+            '245$a/1-5',
+            '245^1',
+            '245$a$b',
+            '245^1{=\\0}',
+            '245$a{$b=\\t}$c$d'
+          ].each do |query_str|
+            query = query_from(query_str)
+            str = query.to_s
+            expect(str).not_to include('nil')
+            all_elements = ([query.tag, query.selector] + query.subqueries).compact
+            all_elements.each do |elem|
+              expect(str).to include(elem.to_s)
+            end
+          end
+        end
+      end
+
+      describe :to_s_inspect do
+        it 'includes all elements' do
+          # noinspection RubyLiteralArrayInspection
+          [
+            '245$a',
+            '245$a/1-5',
+            '245^1',
+            '245$a$b',
+            '245^1{=\\0}',
+            '245$a{$b=\\t}$c$d'
+          ].each do |query_str|
+            query = query_from(query_str)
+            inspect_str = query.inspect
+            expect(inspect_str).not_to include('nil')
+            all_elements = ([query.tag, query.selector] + query.subqueries).compact
+            all_elements.each do |elem|
+              expect(inspect_str).to include(elem.inspect)
+            end
+          end
+        end
+      end
+
+      describe 'non-repeated subfields' do
+        before(:each) do
+          @marc_record = MARC::XMLReader.new('spec/data/sandburg.xml').first
+        end
+
+        context 'leader' do
+          it 'finds the leader' do
+            leader = marc_record.leader
+            examples = {
+              'LDR' => [leader],
+              'LDR/11' => [leader[11]],
+              'LDR/3-12' => [leader[3..12]]
+            }
+
+            verify_all(examples)
+          end
+        end
+
+        context 'fields' do
+          it 'finds fields' do
+            examples = {
+              '035' => marc_record.fields('035'),
+              '040' => [marc_record['040']],
+              '0..' => marc_record.fields.select { |f| f.tag =~ /^0..$/ }
+            }
+            verify_all(examples)
+          end
+        end
+
+        context 'controlfield data' do
+          it 'extracts controlfield data' do
+            cf005 = marc_record['005']
+            cf005_value = cf005.value
+            examples = {
+              '005/#' => [cf005_value[-1]],
+              '005/1-#' => [cf005_value[1..]]
+            }
+            verify_all(examples)
+          end
+        end
+
+        context 'subfields' do
+          it 'finds subfields' do
+            df245 = marc_record['245']
+            df245a = subfields(df245, 'a').first
+            df245c = subfields(df245, 'c').first
+            df245ac = subfields(df245, %w[a c])
+
+            all_sf_a_or_c = marc_record.fields.each_with_object([]) do |df, sff|
+              next unless df.respond_to?(:subfields)
+
+              sff.concat(subfields(df, %w[a c]))
+            end
+
+            examples = {
+              '245$a' => [df245a],
+              '245$a$c' => df245ac,
+              '245$a-c' => df245ac,
+              '...$a$c' => all_sf_a_or_c,
+              '245$a/#-6' => [df245a.value[-7..]],
+              '245$a$c/0-4' => [df245a, df245c.value[0..4]],
+              '245$a/0-4$c/0-4' => df245ac.map { |sf| sf.value[0..4] }
+            }
+
+            verify_all(examples)
+          end
+        end
+
+        context 'subspecs' do
+          it 'can check for the existence of subfields' do
+            df245 = marc_record['245']
+            df245a = df245.subfields.find { |sf| sf.code == 'a' }
+
+            _650s = marc_record.fields('650')
+            _650s_with_x = _650s.select { |df| subfield_codes(df).include?('x') }
+
+            examples = {
+              '245$a{?245$c}' => [df245a], # left subterm is implicit, and unused
+              '245$a{245$a?245$c}' => [df245a], # left subterm is explicit, but unused
+              '245$a{!245$c}' => [],
+              '245$a{245$a!245$c}' => [],
+              # 650 subfield a if that 650 also has a subfield x
+              '650$a{?$x}' => _650s_with_x.flat_map { |df| subfields(df, 'a') },
+              # all 650 subfields a if any 650 has a subfield x
+              '650$a{?650$x}' => _650s.flat_map { |df| subfields(df, 'a') }
+            }
+            verify_all(examples)
+          end
+
+          it 'can compare subfield values' do
+            df040 = marc_record['040']
+            examples = {
+              '040{$a=$c}' => [df040],
+              '040{040$a=040$c}' => [df040]
+            }
+            verify_all(examples)
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/marc/spec/queries/subfield_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe Subfield do
+      describe :new do
+        it 'accepts a plain code' do
+          sf = Subfield.new('u')
+          expect(sf.code).to eq('u')
+          expect(sf.to_s).to eq('$u')
+        end
+
+        it 'accepts a numeric code range' do
+          code_range = AlNumRange.new(3, 5)
+          sf = Subfield.new(code_range)
+          expect(sf.code).to eq(code_range)
+          expect(sf.to_s).to eq('$3-5')
+        end
+
+        it 'accepts an alphabetic code range' do
+          code_range = AlNumRange.new('k', 'q')
+          sf = Subfield.new(code_range)
+          expect(sf.code).to eq(code_range)
+          expect(sf.to_s).to eq('$k-q')
+        end
+      end
+    end
+
+    describe :apply do
+      attr_reader :marc_record
+
+      describe 'non-repeated subfields' do
+        before(:each) do
+          @marc_record = MARC::XMLReader.new('spec/data/sandburg.xml').first
+        end
+
+        it 'finds a subfield' do
+          df245 = marc_record['245']
+          result = Subfield.new('a').apply(df245)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(1)
+
+          sf245a = result.first
+          expect(sf245a).to be_a(MARC::Subfield)
+
+          expected = df245.subfields.find { |sf| sf.code == 'a' }
+          expect(sf245a).to eq(expected)
+        end
+
+        it 'finds a range of subfields' do
+          df260 = marc_record['260']
+          range = AlNumRange.new('b', 'c')
+          result = Subfield.new(range).apply(df260)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(2)
+
+          expected = df260.subfields.select { |sf| %w[b c].include?(sf.code) }
+          expect(result).to eq(expected)
+        end
+
+      end
+
+      describe 'repeated subfields' do
+        attr_reader :df998
+
+        before(:each) do
+          @marc_record = MARC::XMLReader.new('spec/data/b23161018-sru.xml').first
+          @df998 = marc_record['998']
+        end
+
+        it 'finds repeated subfields' do
+          result = Subfield.new('g').apply(df998)
+          expect(result.size).to eq(20)
+
+          expected = df998.subfields.select { |sf| sf.code == 'g' }
+          expect(result).to eq(expected)
+        end
+
+        it 'finds repeated subfields by index' do
+          marc_record = MARC::XMLReader.new('spec/data/b23161018-sru.xml').first
+          df998 = marc_record['998']
+          result = Subfield.new('g', index: AlNumRange.new(3, 5)).apply(df998)
+          expect(result.size).to eq(3)
+
+          all_sf998g = df998.subfields.select { |sf| sf.code == 'g' }
+          expected = all_sf998g[3..5]
+          expect(result).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/marc/spec/queries/subfield_value_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe SubfieldValue do
+      describe :apply do
+        attr_reader :marc_record
+        attr_reader :df998
+
+        before(:each) do
+          @marc_record = MARC::XMLReader.new('spec/data/b23161018-sru.xml').first
+          @df998 = marc_record['998']
+        end
+
+        it 'extracts substrings from values' do
+          subfield = Subfield.new('g', index: AlNumRange.new(3, 5))
+          # noinspection RubyArgCount
+          subfield_value = SubfieldValue.new(subfield, CharacterSpec.new(AlNumRange.new(0, 9)))
+
+          result = subfield_value.apply(df998)
+          expect(result.size).to eq(3)
+
+          all_sf998g = df998.subfields.select { |sf| sf.code == 'g' }
+          selected = all_sf998g[3..5]
+          expected = selected.map { |sf| sf.value[0..9] }
+          expect(result).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/marc/spec/queries/tag_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+module MARC::Spec
+  module Queries
+    describe Tag do
+      describe :new do
+        it 'accepts a plain tag' do
+          tag = Tag.new('856')
+          expect(tag.tag_exact).to eq('856')
+          expect(tag.tag_re).to be_nil
+          expect(tag.to_s).to eq('856')
+          expect(tag.inspect).to eq('Tag<856>')
+        end
+
+        it 'accepts a wildcard' do
+          tag = Tag.new('.56')
+          expect(tag.tag_exact).to be_nil
+          expect(tag.tag_re).to eq(/^.56$/)
+          expect(tag.to_s).to eq('.56')
+          expect(tag.inspect).to eq 'Tag</^.56$/>'
+        end
+
+        it 'accepts a regexp' do
+          tag = Tag.new(/.56/)
+          expect(tag.tag_exact).to be_nil
+          expect(tag.tag_re).to eq(/.56/)
+          expect(tag.to_s).to eq('.56')
+          expect(tag.inspect).to eq 'Tag</.56/>'
+        end
+
+        it 'accepts a position index' do
+          index = Position.new(2)
+          tag = Tag.new('650', index)
+          expect(tag.index).to eq(index)
+        end
+
+        it 'accepts a range index' do
+          index = AlNumRange.new(3, nil)
+          tag = Tag.new('650', index)
+          expect(tag.index).to eq(index)
+        end
+      end
+
+      describe :apply do
+        attr_reader :marc_record
+
+        before(:each) do
+          @marc_record = MARC::XMLReader.new('spec/data/sandburg.xml').first
+        end
+
+        it 'finds the leader' do
+          result = Tag.new('LDR').apply(marc_record)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(1)
+
+          leader = result.first
+          expect(leader).to eq(marc_record.leader)
+        end
+
+        it 'finds a control field' do
+          result = Tag.new('003').apply(marc_record)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(1)
+
+          cf003 = result.first
+          expect(cf003).to be_a(MARC::ControlField)
+          expect(cf003.tag).to eq('003')
+        end
+
+        it 'finds a data field' do
+          result = Tag.new('245').apply(marc_record)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(1)
+
+          df245 = result.first
+          expect(df245).to eq(marc_record['245'])
+        end
+
+        it 'finds a repeated data field' do
+          result = Tag.new('650').apply(marc_record)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(5)
+
+          expected = marc_record.fields('650')
+          expect(result).to eq(expected)
+        end
+
+        it 'finds some repeated data fields by position index' do
+          result = Tag.new('650', Position.new(2)).apply(marc_record)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(1)
+
+          df650s = marc_record.fields('650')
+          expect(result.first).to eq(df650s[2])
+        end
+
+        it 'finds some repeated data fields by range index' do
+          result = Tag.new('650', AlNumRange.new(1, 3)).apply(marc_record)
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(3)
+
+          df650s = marc_record.fields('650')
+          expected = [1, 2, 3].map { |i| df650s[i] }
+          expect(result).to eq(expected)
+        end
+
+        describe 'wildcards' do
+          it 'finds a control field' do
+            result = Tag.new('0.3').apply(marc_record)
+            expect(result).to be_an(Array)
+            expect(result.size).to eq(1)
+
+            cf003 = result.first
+            expect(cf003).to be_a(MARC::ControlField)
+            expect(cf003.tag).to eq('003')
+          end
+
+          it 'finds a mix of control and data fields' do
+            result = Tag.new('..5').apply(marc_record)
+            expect(result).to be_an(Array)
+            expect(result.size).to eq(2)
+
+            cf005 = result.first
+            expect(cf005).to be_a(MARC::ControlField)
+            expect(cf005.tag).to eq('005')
+
+            df245 = result.last
+            expect(df245).to be_a(MARC::DataField)
+            expect(df245.tag).to eq('245')
+          end
+
+          it 'finds fields by index' do
+            result = Tag.new('2..', Position.new(1)).apply(marc_record)
+            expect(result).to be_an(Array)
+            expect(result.size).to eq(1)
+
+            df250 = result.first
+            expect(df250).to eq(marc_record['250'])
+          end
+        end
+      end
+    end
+  end
+end