stupidedi 1.1.0

data/lib/stupidedi/reader/segment_dict.rb

@@ -0,0 +1,175 @@
+module Stupidedi
+  module Reader
+
+    class SegmentDict
+      include Inspect
+
+      # Return the top element from the stack. This will throw an exception
+      # if the stack is {#empty?}
+      abstract :top
+
+      # Return the remainder of the stack. This will throw an exception if
+      # the stack is {#empty?}
+      #
+      # @return [SegmentDict]
+      abstract :pop
+
+      # Returns a new SegmentDict with +top+ pushed to the top of the stack
+      #
+      # @return [SegmentDict]
+      abstract :push, :args => %w(top)
+
+      # Searches the stack for the definition of the given segment identifier
+      abstract :at, :args => %w(segment_id)
+
+      # Returns true if a node in the stack has a definition for the given
+      # segment identifier
+      abstract :defined_at?, :args => %w(segment_id)
+
+      # True if the stack of dictionaries is empty
+      abstract :empty?
+
+      # @private
+      class NonEmpty < SegmentDict
+        attr_reader :top
+
+        # @return [SegmentDict]
+        attr_reader :pop
+
+        def initialize(top, pop = SegmentDict.empty)
+          @top, @pop = top, pop
+        end
+
+        # @return [SegmentDict]
+        def copy(changes = {})
+          NonEmpty.new \
+            changes.fetch(:top, @top),
+            changes.fetch(:pop, @pop)
+        end
+
+        def push(top)
+          if top.is_a?(Module)
+            copy(:top => Constants.new(top), :pop => self)
+          else
+            copy(:top => top, :pop => self)
+          end
+        end
+
+        def at(segment_id)
+          if @top.defined_at?(segment_id)
+            @top.at(segment_id)
+          else
+            @pop.at(segment_id)
+          end
+        end
+
+        def defined_at?(segment_id)
+          @top.defined_at?(segment_id) or
+          @pop.defined_at?(segment_id)
+        end
+
+        def empty?
+          false
+        end
+
+        # @return [void]
+        def pretty_print(q)
+          q.text "SegmentDict"
+          q.group(2, "(", ")") do
+            q.breakable ""
+
+            node = self
+            until node.empty?
+              unless q.current_group.first?
+                q.text ","
+                q.breakable
+              end
+              q.pp node.top
+              node = node.pop
+            end
+          end
+        end
+      end
+
+      # @private
+      Empty = Class.new(SegmentDict) do
+        def top
+          raise TypeError, "empty stack"
+        end
+
+        def pop
+          raise TypeError, "stack underflow"
+        end
+
+        def push(top)
+          if top.is_a?(Module)
+            NonEmpty.new(Constants.new(top), self)
+          else
+            NonEmpty.new(top, self)
+          end
+        end
+
+        def defined_at?(segment_id)
+          false
+        end
+
+        def at(segment_id)
+          raise TypeError, "empty stack"
+        end
+
+        def empty?
+          true
+        end
+
+        # @return [void]
+        def pretty_print(q)
+          q.text "SegmentDict.empty"
+        end
+      end.new
+
+      # @private
+      class Constants
+        def initialize(namespace)
+          @namespace = namespace
+          @constants = Hash.new
+          namespace.constants.each{|c| @constants[c.to_sym] = true }
+        end
+
+        def at(segment_id)
+          @namespace.const_get(segment_id)
+        end
+
+        def defined_at?(segment_id)
+          @constants.include?(segment_id.to_sym)
+        end
+
+        # @return [void]
+        def pretty_print(q)
+          q.text("#{@namespace.name}.constants")
+        end
+      end
+    end
+
+    class << SegmentDict
+      # @group Constructors
+      #########################################################################
+
+      # @return [SegmentDict::Empty]
+      def empty
+        SegmentDict::Empty
+      end
+
+      # @return [SegmentDict::NonEmpty]
+      def build(top)
+        SegmentDict::Empty.push(top)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+    SegmentDict.eigenclass.send(:protected, :new)
+    SegmentDict::NonEmpty.eigenclass.send(:public, :new)
+
+  end
+end

data/lib/stupidedi/reader/separators.rb

@@ -0,0 +1,85 @@
+module Stupidedi
+  module Reader
+
+    #
+    # Stores the separators used to tokenize X12 from an input stream and
+    # serialize it to an output stream.
+    #
+    # @see X222.pdf B.1.1.2.5 Delimiters
+    #
+    class Separators
+
+      # @return [String]
+      attr_accessor :component  # :
+
+      # @return [String]
+      attr_accessor :repetition # ^
+
+      # @return [String]
+      attr_accessor :element    # *
+
+      # @return [String]
+      attr_accessor :segment    # ~
+
+      def initialize(component, repetition, element, segment)
+        @component, @repetition, @element, @segment =
+          component, repetition, element, segment
+      end
+
+      # @return [Separators]
+      def copy(changes = {})
+        Separators.new \
+          changes.fetch(:component, @component),
+          changes.fetch(:repetition, @repetition),
+          changes.fetch(:element, @element),
+          changes.fetch(:segment, @segment)
+      end
+
+      # Creates a new value that has the separators from `other`, when they
+      # are not nil, and will use separators from `self` otherwise.
+      def merge(other)
+        Separators.new \
+          other.component  || @component,
+          other.repetition || @repetition,
+          other.element    || @element,
+          other.segment    || @segment
+      end
+
+      # @return [AbstractSet<String>]
+      def characters
+        chars =
+          [@component, @repetition, @element, @segment].select(&:present?)
+
+        Sets.absolute(chars.join.split(//), Reader::C_BYTES.split(//))
+      end
+
+      # @return [String]
+      def inspect
+        "Separators(#{@component.inspect}, #{@repetition.inspect}, #{@element.inspect}, #{@segment.inspect})"
+      end
+    end
+
+    class << Separators
+      # @group Constructors
+      #########################################################################
+
+      # @return [Separators]
+      def empty
+        new(nil, nil, nil, nil)
+      end
+
+      # @return [Separators]
+      def build(hash)
+        Separators.new \
+          hash[:component],
+          hash[:repetition],
+          hash[:element],
+          hash[:segment]
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/reader/stream_reader.rb

@@ -0,0 +1,172 @@
+module Stupidedi
+  module Reader
+
+    #
+    # The {StreamReader} is intended to scan the input for a valid ISA segment,
+    # after which the {TokenReader} class can be used to tokenize the remaining
+    # input.
+    #
+    # Because X12 specifications have no bearing on what happens outside the
+    # interchange envelope (from `IEA` to `ISA`), out-of-band data like blank
+    # lines, human readable text, etc can occur between interchanges. This
+    # reader is designed to deal with that problem.
+    #
+    class StreamReader
+      include Inspect
+
+      attr_reader :input
+
+      def initialize(input)
+        @input = input
+      end
+
+      # @return true
+      def stream?
+        true
+      end
+
+      # True if there is no remaining input
+      def empty?
+        @input.empty?
+      end
+
+      # Read a single character
+      #
+      # @return [Either<Result<Character, StreamReader>>]
+      def read_character
+        unless @input.empty?
+          result(@input.at(0), advance(1))
+        else
+          failure("less than one character available")
+        end
+      end
+
+      # Skip a single character
+      #
+      # @return [Either<StreamReader>]
+      def consume_character
+        unless @input.empty?
+          success(advance(1))
+        else
+          failure("less than one character available")
+        end
+      end
+
+      # This method is unaware of subtle differences between interchange
+      # versions, so it really only tokenizes 16 elements, plus the element
+      # terminator and segment separators. It does not presume to understand
+      # the meaning of the elements, like the repetition separator or the
+      # component separator, because these are interchange version-dependent.
+      #
+      # @return [Either<Result<SegmentTok TokenReader>>]
+      def read_segment
+        consume_isa.flatmap do |rest|
+          # The character after "ISA" is defined to be the element separator
+          rest.read_character.flatmap do |char, aR|
+            separators = Separators.new(nil, nil, char, nil)
+            remaining  = success(TokenReader.new(aR.input, separators))
+            elements   = []
+
+            # Read 15 simple elements into an array. Consume/discard the element
+            # separator that follows each one.
+            15.times do
+              remaining =
+                remaining.flatmap(&:read_simple_element).flatmap do |e, eR|
+                  elements << e
+
+                  # Throw away the following element separator
+                  eR.consume_prefix(separators.element)
+                end
+            end
+
+            # We have to assume the last (16th) element is fixed-length because
+            # it is not terminated by an element separator. The {read_character}
+            # method defined by TokenReader skips past control characters.
+            remaining.flatmap do |w|
+              w.read_character.flatmap do |isa16, cR|
+                elements << SimpleElementTok.build(isa16, w.input, cR.input)
+
+                # The character after the last element is defined to be the
+                # segment terminator. The {read_character} method here, defined
+                # by StreamReader, does not skip past control character, so the
+                # separator could be a control character.
+                cR.stream.read_character.flatmap do |char, dR|
+                  if char == separators.element
+                    failure("element separator and segment terminator must be distinct", dR.input)
+                  else
+                    separators.segment = char
+
+                    token = SegmentTok.build(:ISA, elements,
+                      rest.input.position, dR.input.position)
+
+                    result(token, TokenReader.new(dR.input, separators))
+                  end
+                end
+              end
+            end
+          end.or do |reason|
+            # We read "ISA" but failed to tokenize the input that followed. This
+            # was probably a random occurrence of the sequence "ISA", so we'll
+            # skip past it and try again.
+            #
+            # @todo: We should log this as a warning, because we could otherwise
+            # be silently discarding an entire interchange if the ISA segment
+            # was bogus
+            rest.read_segment
+          end
+        end
+      end
+
+    protected
+
+      # Consume the next occurence of "ISA"
+      #
+      # @return [Either<StreamReader>]
+      def consume_isa
+        position = 0
+        buffer   = "   "
+
+        # @todo: This would probably more optimal if it was written like
+        # consume("I") >>= consume_prefix("S") >>= consume_prefix("A")
+        while @input.defined_at?(position)
+          character = @input.at(position)
+          position += 1
+
+          unless Reader.is_control_character?(character)
+            # Slide the "window" forward one character
+            buffer = buffer.slice!(1..-1) << character.upcase
+
+            if buffer == "ISA"
+              return success(advance(position))
+            end
+          end
+        end
+
+        failure("reached end of input before finding ISA segment identifier")
+      end
+
+    private
+
+      def advance(n)
+        unless @input.defined_at?(n-1)
+          raise IndexError, "less than #{n} characters available"
+        else
+          StreamReader.new(@input.drop(n))
+        end
+      end
+
+      def failure(message, remainder = input)
+        Reader::Failure.new(message, remainder, false)
+      end
+
+      def success(value)
+        Either.success(value)
+      end
+
+      def result(value, remainder)
+        Reader::Success.new(value, remainder)
+      end
+
+    end
+  end
+end