sip2-ruby 0.1.0

data/test/sip2/parser_atoms_spec.rb

@@ -0,0 +1,354 @@
+require_relative '../spec_helper'
+require 'sip2/parser_atoms'
+
+include Sip2
+
+describe ParserAtoms do
+
+  include ParserAtoms
+
+  describe :digit do
+    it "matches a single digit" do
+      assert_equal "1", digit.parse("1")
+    end
+
+    it "doesn't match multiple digits" do
+      assert_raises(Parslet::ParseFailed) { digit.parse("12") }
+    end
+
+    it "doesn't match other chars" do
+      %w[a . _].each do |c|
+        assert_raises(Parslet::ParseFailed) { digit.parse(c) }
+      end
+    end
+  end
+
+  describe :year do
+    subject { year }
+
+    it "matches a normal four digit year" do
+      assert_equal "2023", subject.parse("2023")
+    end
+
+    it "doesn't match non-four-digit values" do
+      %w[123 202E 12345].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+  end
+
+  describe :month do
+    subject { month }
+
+    it "matches all normal two digit months" do
+      ("01".."12").each do |str|
+        assert_equal str, subject.parse(str)
+      end
+    end
+
+    it "doesn't match months outside the 01-12 range" do
+      %w[00 13].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+
+    it "doesn't match non-two-digit values" do
+      %w[0 1 ab 123].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+  end
+
+  describe :day do
+    subject { day }
+
+    it "matches normal two digit days" do
+      %w[01 15 23 31].each do |str|
+        assert_equal str, subject.parse(str)
+      end
+    end
+
+    it "doesn't match days outside the 01-31 range" do
+      %w[00 32 60].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+
+    it "doesn't match non-two-digit values" do
+      %w[0 1 ab 123].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+  end
+
+  describe :hour do
+    subject { hour }
+
+    it "matches normal two digit hours" do
+      %w[00 08 15 23].each do |str|
+        assert_equal str, subject.parse(str)
+      end
+    end
+
+    it "doesn't match hours outside the 00-23 range" do
+      %w[24 42].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+
+    it "doesn't match non-two-digit values" do
+      %w[0 1 ab 123].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+  end
+
+  [:second, :minute].each do |unit|
+    describe unit do
+      subject { self.send(unit) }
+
+      it "matches normal two digit #{unit}s" do
+        %w[00 08 32 59].each do |str|
+          assert_equal str, subject.parse(str)
+        end
+      end
+
+      it "doesn't match #{unit}s outside the 00-59 range" do
+        %w[60 99].each do |c|
+          assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+        end
+      end
+
+      it "doesn't match non-two-digit values" do
+        %w[0 1 ab 123].each do |c|
+          assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+        end
+      end
+    end
+  end
+
+  describe :zzzz do
+    subject { zzzz }
+
+    let(:allowed) { ["    ", "ZZZZ", "EST "] }
+    let(:disallowed) { ["zzzz", "1234", "...."] }
+
+    it "matches all allowed values" do
+      allowed.each do |v|
+        assert_equal v, subject.parse(v)
+      end
+    end
+
+    it "doesn't match disallowed values" do
+      disallowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v) }
+      end
+    end
+
+    it "only matches a 4 char values" do
+      allowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v + v) }
+      end
+    end
+
+  end
+
+  describe :bool do
+    subject { bool }
+
+    it "matches Y" do
+      assert_equal subject.parse("Y"), { bool: "Y" }
+    end
+
+    it "matches N" do
+      assert_equal subject.parse("N"), { bool: "N" }
+    end
+
+    it "doesn't match alternative bool patterns" do
+      [" ", "U", "1", "0"].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+
+    it "only matches a single char" do
+      %w[YY NN YN NY].each do |c|
+        assert_raises(Parslet::ParseFailed) { subject.parse(c) }
+      end
+    end
+  end
+
+  describe :bool do
+    subject { bool }
+
+    let(:allowed) { ["Y", "N"] }
+    let(:disallowed) { [" ", "U", "0", "1"] }
+
+    it "matches all allowed values" do
+      allowed.each do |v|
+        assert_equal subject.parse(v), { bool: v }
+      end
+    end
+
+    it "doesn't match disallowed values" do
+      disallowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v) }
+      end
+    end
+
+    it "only matches a single char" do
+      allowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v + v) }
+      end
+    end
+
+  end
+
+  describe :bool_with_space do
+    subject { bool_with_space }
+
+    let(:allowed) { ["Y", " "] }
+    let(:disallowed) { ["N", "U", "0", "1"] }
+
+    it "matches all allowed values" do
+      allowed.each do |v|
+        assert_equal subject.parse(v), { bool: v }
+      end
+    end
+
+    it "doesn't match disallowed values" do
+      disallowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v) }
+      end
+    end
+
+    it "only matches a single char" do
+      allowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v + v) }
+      end
+    end
+
+  end
+
+  describe :nillable_bool do
+    subject { nillable_bool }
+
+    let(:allowed) { ["Y", "N", "U"] }
+    let(:disallowed) { [" ", "0", "1"] }
+
+    it "matches all allowed values" do
+      allowed.each do |v|
+        assert_equal subject.parse(v), { bool: v }
+      end
+    end
+
+    it "doesn't match disallowed values" do
+      disallowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v) }
+      end
+    end
+
+    it "only matches a single char" do
+      allowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v + v) }
+      end
+    end
+
+  end
+
+  describe :numerical_bool do
+    subject { numerical_bool }
+
+    let(:allowed) { ["0", "1"] }
+    let(:disallowed) { ["Y", "N", "U", " "] }
+
+    it "matches all allowed values" do
+      allowed.each do |v|
+        assert_equal subject.parse(v), { bool: v }
+      end
+    end
+
+    it "doesn't match disallowed values" do
+      disallowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v) }
+      end
+    end
+
+    it "only matches a single char" do
+      allowed.each do |v|
+        assert_raises(Parslet::ParseFailed) { subject.parse(v + v) }
+      end
+    end
+
+  end
+
+
+  describe :timestamp do
+    subject { timestamp }
+
+    it "matches timestamps with valid dates and times" do
+      [
+        "19700101ZZZZ000000",
+        "20230823ZZZZ102930",
+        "20991231    235959",
+      ].each do |str|
+        assert_equal subject.parse(str).keys, [:year, :month, :day, :zone, :hour, :minute, :second]
+      end
+    end
+
+    it "doesn't match timestamp with *clearly* invalid dates or times" do
+      [
+        "AB010203    040506",
+        "20019903    040506",
+        "20010299    040506",
+        "20010203    990506",
+        "20010203    049906",
+        "20010203    040599",
+      ].each do |str|
+        assert_raises(Parslet::ParseFailed) { subject.parse(str) }
+      end
+    end
+
+    it "doesn't match non-18-char values" do
+      [
+        "19700101ZZZ000000",
+        "20230823ZZZZZ102930",
+        "20991231235959",
+      ].each do |str|
+        assert_raises(Parslet::ParseFailed) { subject.parse(str) }
+      end
+    end
+  end
+
+  describe :variable_length_value do
+    subject { variable_length_value }
+
+    it "requires a trailing pipe char" do
+      assert_raises(Parslet::ParseFailed) { subject.parse("foo") }
+    end
+
+    it "captures the value without the trailing pipe char" do
+      assert_equal({str: "foo"}, subject.parse("foo|"))
+    end
+
+    it "matches any kind of str in lengths from 1 to 255" do
+      ["a", "A", "Å", "1", ".", " "].product([1, 20, 255]).each do |chr, length|
+        value = (chr * length)
+        assert_equal({str: value}, subject.parse(value + "|"))
+      end
+    end
+
+    it "matches a single pipe (empty value)" do
+      assert_equal({str: []}, subject.parse("|"))
+    end
+
+    it "doesn't match strings longer than 255" do
+      assert_raises(Parslet::ParseFailed) { subject.parse("A" * 256 + "|") }
+    end
+
+    it "doesn't allow a pipe char in the data" do
+      assert_raises(Parslet::ParseFailed) { subject.parse("||") }
+    end
+
+  end
+
+end

data/test/sip2/parser_test.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+class Sip2::ParserTest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Sip2::Parser::VERSION
+  end
+
+  def test_it_does_something_useful
+    assert false
+  end
+end

data/test/sip2_spec.rb

@@ -0,0 +1,145 @@
+require_relative 'spec_helper'
+require_relative 'fixture_helper'
+
+include FixtureHelper
+
+require 'sip2'
+
+describe Sip2 do
+
+  describe "::parse" do
+    describe "Known messages" do
+      KNOWN_MESSAGES_FIXTURE_CODES.each do |code|
+
+        describe code do
+
+          msg = sip2_fixture(code)
+
+          it "accepts the message" do
+            assert_kind_of Array, Sip2.parse(msg)
+            assert_kind_of Hash, Sip2.parse(msg).first
+          end
+
+          it "sets :message_code to the message code" do
+            assert_equal code, Sip2.parse(msg).first[:message_code]
+          end
+
+          it "set :message_name" do
+            assert_kind_of String, Sip2.parse(msg).first[:message_name]
+          end
+        end
+      end
+    end
+
+    describe "Unknown message" do
+      UNKNOWN_MESSAGES_FIXTURE_CODES.each do |code|
+
+        describe code do
+
+          msg = sip2_fixture(code)
+
+          it "accepts the message" do
+            assert_kind_of Array, Sip2.parse(msg)
+            assert_kind_of Hash, Sip2.parse(msg).first
+          end
+
+          it "sets :message_code to the message code" do
+            assert_equal code, Sip2.parse(msg).first[:message_code]
+          end
+
+          it "sets :message_name to 'Unknown Message'" do
+            assert_equal "Unknown Message", Sip2.parse(msg).first[:message_name]
+          end
+
+          it "sets :message_data to what's between the code and the terminator" do
+            expected = msg.sub(/^#{Regexp.escape(code)}/, "").chomp
+            assert_equal(expected, Sip2.parse(msg).first[:message_data])
+          end
+        end
+      end
+    end
+
+    describe "Invalid message" do
+      it "does not accept invalid message identifiers" do
+        ["", "X", "!Y", "!Yfoo"].each do |msg|
+          assert_raises(Parslet::ParseFailed) {
+            Sip2.parse(sprintf("%s\r", msg))
+          }
+        end
+      end
+
+      it "does not acceptg valid message identifiers with invalid data" do
+        ["98", "99abc"].each do |msg|
+          assert_raises(Parslet::ParseFailed) {
+            Sip2.parse(sprintf("%s\r", msg))
+          }
+        end
+      end
+
+      it "requires the message terminator for both known and unknown messages" do
+        ["XXfoo", "9900302.00"].each do |msg|
+          assert_kind_of Array, Sip2.parse(sprintf("%s\r", msg))
+          assert_raises(Parslet::ParseFailed) {
+            Sip2.parse(sprintf("%s", msg))
+          }
+        end
+      end
+    end
+
+    describe "multiple messages" do
+      let(:messages) {
+        [
+          "9900302.00\r",
+          "XXfoo\r",
+        ]
+      }
+
+      it "reads multiple messages into an array of hashes" do
+        result = Sip2.parse(messages.join)
+
+        assert_kind_of Array, result
+        assert_kind_of Hash, result.first
+        assert_kind_of Hash, result.last
+      end
+
+      it "allows for an extra newline character (lf) between messages" do
+        result = Sip2.parse(messages.join("\n"))
+
+        assert_kind_of Array, result
+        assert_kind_of Hash, result.first
+        assert_kind_of Hash, result.last
+      end
+    end
+
+    describe "Messages with unexpected fields" do
+      let(:messages) {
+        [
+          "9900302.00XXSomeExtraValue|\r",
+        ]
+      }
+
+      it "reads a single unexpected field into an array" do
+        result = Sip2.parse("9900302.00XXSome Unexpected Value|\r")
+
+        assert_equal(
+          [{ code: "XX", value: "Some Unexpected Value" }],
+          result.first[:unexpected_fields]
+        )
+      end
+
+      it "reads multiple unexpected fields into an array" do
+        result = Sip2.parse("9900302.00XXSome Unexpected Value|ZZAnother Unexpected Value|\r")
+
+        assert_equal(
+          [
+            { code: "XX", value: "Some Unexpected Value" },
+            { code: "ZZ", value: "Another Unexpected Value" },
+          ],
+          result.first[:unexpected_fields]
+        )
+      end
+
+    end
+  end 
+
+end

data/test/spec_helper.rb

@@ -0,0 +1,4 @@
+require_relative '../environment'
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use!

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "sip2/parser"
+
+require "minitest/autorun"

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: sip2-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Sandbecker
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.19'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      A library and executables for parsing and encoding SIP2 messages (a standard
+      for data exchange between Library Automation Systems and Library Systems).
+email:
+- daniel.sandbecker@hb.se
+executables:
+- sip2-to-json
+- json-to-sip2
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/json-to-sip2
+- bin/sip2-to-json
+- lib/sip2.rb
+- lib/sip2/checksum_encoder.rb
+- lib/sip2/field_parser_rules.rb
+- lib/sip2/fields.rb
+- lib/sip2/message.rb
+- lib/sip2/message/base_message.rb
+- lib/sip2/message/unknown_message.rb
+- lib/sip2/message_parser_rules.rb
+- lib/sip2/messages.rb
+- lib/sip2/parser.rb
+- lib/sip2/parser_atoms.rb
+- lib/sip2/transformer.rb
+- lib/sip2/types.rb
+- lib/sip2/version.rb
+- sip2-ruby.gemspec
+- test/fixture_helper.rb
+- test/fixtures/09.sip2
+- test/fixtures/10.sip2
+- test/fixtures/17.sip2
+- test/fixtures/18.sip2
+- test/fixtures/98-with-unexpected.sip2
+- test/fixtures/98.sip2
+- test/fixtures/99-with-unexpected.sip2
+- test/fixtures/99.sip2
+- test/fixtures/XX.sip2
+- test/fixtures/alma/09.sip2
+- test/fixtures/alma/10.sip2
+- test/fixtures/alma/17.sip2
+- test/fixtures/alma/18.sip2
+- test/fixtures/alma/98.sip2
+- test/fixtures/alma/99.sip2
+- test/round_trip_spec.rb
+- test/sip2/message_parser_rules_spec.rb
+- test/sip2/parser_atoms_spec.rb
+- test/sip2/parser_test.rb
+- test/sip2_spec.rb
+- test/spec_helper.rb
+- test/test_helper.rb
+homepage: https://github.com/ub-library/sip2-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ub-library/sip2-ruby
+  source_code_uri: https://github.com/ub-library/sip2-ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: Parse and encode SIP2 messages
+test_files: []