ruby-marc-spec 0.1.0

data/spec/generated/char_indicator_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+module MARC
+  module Spec
+    module Parsing
+      context 'suite' do
+        describe :char_indicator do
+          let(:parser) { Parser.new }
+          let(:reporter) { Parslet::ErrorReporter::Deepest.new }
+
+          describe 'marc_spec: valid field tag and charspec' do
+            # /invalid/wildCombination_invalidCharIndicator.json
+
+            describe 'last position' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'first position' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'position ten' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../9^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../9^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'position eleven' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../10^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../10^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'position 101' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../100^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../100^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'range from first position to second' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0-1^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0-1^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'range from first position to last' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0-#^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0-#^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'range from first position to first position, is like first position' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0-0^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../0-0^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'range from last position to last position, is like last position' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#-#^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#-#^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'range from last position to position one (index reverted), is like last position' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#-0^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#-0^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+            describe 'range from last position to position two (index reverted)' do
+
+              it '&& indicator 1 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#-1^1', trace: true, reporter: reporter)
+              end
+
+              it '&& indicator 2 -> invalid' do
+                # /invalid/wildCombination_invalidCharIndicator.json
+                expect(parser.marc_spec).not_to parse('.../#-1^2', trace: true, reporter: reporter)
+              end
+
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/generated/char_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+module MARC
+  module Spec
+    module Parsing
+      context 'suite' do
+        describe :char do
+          let(:parser) { Parser.new }
+          let(:reporter) { Parslet::ErrorReporter::Deepest.new }
+
+          describe 'marc_spec: valid field tag and charspec' do
+            # /valid/wildCombination_validChar.json
+            it 'first position -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../0', trace: true, reporter: reporter)
+            end
+
+            it 'last position -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../#', trace: true, reporter: reporter)
+            end
+
+            it 'position 101 -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../100', trace: true, reporter: reporter)
+            end
+
+            it 'position eleven -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../10', trace: true, reporter: reporter)
+            end
+
+            it 'position ten -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../9', trace: true, reporter: reporter)
+            end
+
+            it 'range from first position to first position, is like first position -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../0-0', trace: true, reporter: reporter)
+            end
+
+            it 'range from first position to last -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../0-#', trace: true, reporter: reporter)
+            end
+
+            it 'range from first position to second -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../0-1', trace: true, reporter: reporter)
+            end
+
+            it 'range from last position to last position, is like last position -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../#-#', trace: true, reporter: reporter)
+            end
+
+            it 'range from last position to position one (index reverted), is like last position -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../#-0', trace: true, reporter: reporter)
+            end
+
+            it 'range from last position to position two (index reverted) -> valid' do
+              # /valid/wildCombination_validChar.json
+              expect(parser.marc_spec).to parse('.../#-1', trace: true, reporter: reporter)
+            end
+
+          end
+          describe 'marc_spec: valid field tag and invalid charspec' do
+            # /invalid/wildCombination_invalidChar.json
+            it 'empty string -> invalid' do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../', trace: true, reporter: reporter)
+            end
+
+            it 'missing ending position -> invalid' do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../#-', trace: true, reporter: reporter)
+            end
+
+            it 'missing starting position -> invalid' do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../-2', trace: true, reporter: reporter)
+            end
+
+            it "only digits, one hyphen and the char '#' are allowed -> invalid" do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../1-X', trace: true, reporter: reporter)
+              expect(parser.marc_spec).not_to parse('.../?', trace: true, reporter: reporter)
+            end
+
+            it 'only one hyphen allwed -> invalid' do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../1-2-', trace: true, reporter: reporter)
+            end
+
+            it 'this matches pattern, but starting position number must not be higher than ending position number -> invalid' do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../2-1', trace: true, reporter: reporter)
+            end
+
+            it 'whitespace is not allowed -> invalid' do
+              # /invalid/wildCombination_invalidChar.json
+              expect(parser.marc_spec).not_to parse('.../1- 2', trace: true, reporter: reporter)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/generated/comparison_string_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+module MARC
+  module Spec
+    module Parsing
+      context 'suite' do
+        describe :comparison_string do
+          let(:parser) { Parser.new }
+          let(:reporter) { Parslet::ErrorReporter::Deepest.new }
+
+          describe 'comparison strings are strings and match pattern' do
+            # /invalid/invalidComparisonString.json
+            it 'subfield with single digit subfieldtag -> valid' do
+              # /valid/validComparisonString.json
+              expect(parser.comparison_string).to parse('te\\}st', trace: true, reporter: reporter)
+            end
+
+            it 'subfield with single lowercase alpha subfieldtag -> valid' do
+              # /valid/validComparisonString.json
+              expect(parser.comparison_string).to parse('test\\$', trace: true, reporter: reporter)
+              expect(parser.comparison_string).to parse('test\\{', trace: true, reporter: reporter)
+            end
+
+            it 'subfieldrange with lowercase subfieldtags -> valid' do
+              # /valid/validComparisonString.json
+              expect(parser.comparison_string).to parse('test\\!', trace: true, reporter: reporter)
+              expect(parser.comparison_string).to parse('\\=test', trace: true, reporter: reporter)
+              expect(parser.comparison_string).to parse('test\\~', trace: true, reporter: reporter)
+              expect(parser.comparison_string).to parse('test\\?', trace: true, reporter: reporter)
+              expect(parser.comparison_string).to parse('tes\\st\\|', trace: true, reporter: reporter)
+            end
+
+            it "unescaped character '$' -> invalid" do
+              # /invalid/invalidComparisonString.json
+              expect(parser.comparison_string).not_to parse('test$', trace: true, reporter: reporter)
+            end
+
+            it "unescaped character '=' at beginning is valid -> valid" do
+              # /valid/validComparisonString.json
+              expect(parser.comparison_string).to parse('=test', trace: true, reporter: reporter)
+            end
+
+            it "unescaped character '?' -> invalid" do
+              # /invalid/invalidComparisonString.json
+              expect(parser.comparison_string).not_to parse('test?', trace: true, reporter: reporter)
+            end
+
+            it "unescaped character '{' -> invalid" do
+              # /invalid/invalidComparisonString.json
+              expect(parser.comparison_string).not_to parse('test{', trace: true, reporter: reporter)
+            end
+
+            it "unescaped character '}' -> invalid" do
+              # /invalid/invalidComparisonString.json
+              expect(parser.comparison_string).not_to parse('te}st', trace: true, reporter: reporter)
+            end
+
+            it "unescaped character '~' -> invalid" do
+              # /invalid/invalidComparisonString.json
+              expect(parser.comparison_string).not_to parse('test~', trace: true, reporter: reporter)
+            end
+
+            it 'whitespaces are not allowed -> invalid' do
+              # /invalid/invalidComparisonString.json
+              expect(parser.comparison_string).not_to parse('te st\\?', trace: true, reporter: reporter)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/generated/field_tag_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+module MARC
+  module Spec
+    module Parsing
+      context 'suite' do
+        describe :field_tag do
+          let(:parser) { Parser.new }
+          let(:reporter) { Parslet::ErrorReporter::Deepest.new }
+
+          describe 'field tags are strings and match pattern' do
+            # /invalid/invalidFieldTag.json
+            it 'all digits -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('300', trace: true, reporter: reporter)
+            end
+
+            it 'all lowercase chars -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('abc', trace: true, reporter: reporter)
+            end
+
+            it 'all uppercase chars -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('ABC', trace: true, reporter: reporter)
+            end
+
+            it 'all uppercase chars special leader -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('LDR', trace: true, reporter: reporter)
+            end
+
+            it 'all wildcards -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('...', trace: true, reporter: reporter)
+            end
+
+            it 'invalid char # -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('24#', trace: true, reporter: reporter)
+            end
+
+            it 'invalid char ? -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('?00', trace: true, reporter: reporter)
+            end
+
+            it 'invalid whitespace -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('24 ', trace: true, reporter: reporter)
+              expect(parser.field_tag).not_to parse('2 5', trace: true, reporter: reporter)
+              expect(parser.field_tag).not_to parse(' 45', trace: true, reporter: reporter)
+            end
+
+            it 'mix of digit, lowercase and uppercase chars -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('a0C', trace: true, reporter: reporter)
+            end
+
+            it 'mix of lowercase and uppercase chars -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('abC', trace: true, reporter: reporter)
+            end
+
+            it 'mix of wildcard, lowercase and uppercase chars -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('a.C', trace: true, reporter: reporter)
+            end
+
+            it 'mix one lowercase char and two digits -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('a00', trace: true, reporter: reporter)
+            end
+
+            it 'mix two lowercase chars and one digit -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('aa0', trace: true, reporter: reporter)
+            end
+
+            it 'one digit two wildcards right -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('2..', trace: true, reporter: reporter)
+            end
+
+            it 'one lowercase and two wildcards right -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('a..', trace: true, reporter: reporter)
+            end
+
+            it 'one uppercase char two wildcards right -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('A..', trace: true, reporter: reporter)
+            end
+
+            it 'one wildcard between uppercase chars -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('A.C', trace: true, reporter: reporter)
+            end
+
+            it 'one wildcard left and two lowercase chars -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('.bc', trace: true, reporter: reporter)
+            end
+
+            it 'one wildcard left two uppercase chars -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('.BC', trace: true, reporter: reporter)
+            end
+
+            it 'one wildcard left with two digits -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('.00', trace: true, reporter: reporter)
+            end
+
+            it 'too many chars -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('ABCD', trace: true, reporter: reporter)
+            end
+
+            it 'too many wildcards -> invalid' do
+              # /invalid/invalidFieldTag.json
+              expect(parser.field_tag).not_to parse('....', trace: true, reporter: reporter)
+            end
+
+            it 'two digits wildcard right -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('20.', trace: true, reporter: reporter)
+            end
+
+            it 'two wildcards and one lowercase char right -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('..c', trace: true, reporter: reporter)
+            end
+
+            it 'two wildcards left one uppercase char -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('..C', trace: true, reporter: reporter)
+            end
+
+            it 'two wildcards left with digit -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('..0', trace: true, reporter: reporter)
+            end
+
+            it 'wildcard between digits -> valid' do
+              # /valid/validFieldTag.json
+              expect(parser.field_tag).to parse('1.0', trace: true, reporter: reporter)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end