tediparse 2.0.0

data/lib/stupidedi/parser/generation.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    module Generation
+      # Consumes all input from `reader` and returns the updated
+      # {StateMachine} along with the result of the last attempt
+      # to read a segment.
+      #
+      # The `nondeterminism` argument specifies a limit on how many
+      # parse trees can be built simultaneously due to ambiguity in
+      # the input and/or specification. This prevents runaway memory
+      # CPU consumption (see GH-129), and will return a {Reader::Result.failure}
+      # once exceeded.
+      #
+      # The default value is 1, resulting in an error if any input
+      # is ambiguous.
+      #
+      # NOTE: The error is detected *after* the resources are already
+      # been consumed. The extra parse trees are returned (in memory)
+      # via the {StateMachine} to aide diagnosis.
+      #
+      # @return [(StateMachine, Reader::Result)]
+      def read(reader, options = {})
+        limit    = options.fetch(:nondeterminism, 1)
+        machine  = self
+        reader_e = reader.read_segment
+
+        while reader_e.defined?
+          reader_e = reader_e.flatmap do |segment_tok, reader_|
+            machine, reader__ =
+              machine.insert(segment_tok, false, reader_)
+
+            if machine.active.length <= limit
+              reader__.read_segment
+            else
+              matches = machine.active.map do |m|
+                if segment_use = m.node.zipper.node.usage
+                  "SegmentUse(#{segment_use.position}, #{segment_use.id},
+                  #{segment_use.requirement.inspect}, #{segment_use.repeat_count.inspect})".join
+                else
+                  m.node.zipper.node.inspect
+                end
+              end.join(", ")
+
+              return machine,
+                Reader::Result.failure("too much non-determinism: #{matches}", reader__.input, true)
+            end
+          end
+        end
+
+        return machine, reader_e
+      end
+
+      # @return [(StateMachine, Reader::TokenReader)]
+      def insert(segment_tok, strict, reader)
+        active = @active.flat_map do |zipper|
+          state        = zipper.node
+          instructions = state.instructions.matches(segment_tok, strict, :insert, state)
+
+          if instructions.empty?
+            zipper.append(FailureState.mksegment(segment_tok, state)).cons
+          else
+            instructions.map do |op|
+              successor = execute(op, zipper, reader, segment_tok)
+              reader    = update_reader(op, reader, successor)
+              successor
+            end
+          end
+        end
+
+        return StateMachine.new(@config, active), reader
+      end
+
+      # Three things change together when executing an {Instruction}:
+      #
+      # 1. The stack of instruction tables that indicates where a segment
+      #    would be located if it existed, or was added to the parse tree
+      #
+      # 2. The parse tree, to which we add the new syntax nodes using a
+      #    zipper.
+      #
+      # 3. The corresponding tree of states, which tie together the first
+      #    two and are also updated using a zipper
+      #
+      # @return [AbstractCursor<StateMachine>]
+      def execute(op, zipper, reader, segment_tok)
+        table = zipper.node.instructions  # 1.
+        value = zipper.node.zipper        # 2.
+        state = zipper                    # 3.
+
+        op.pop_count.times do
+          value = value.up
+          state = state.up
+        end
+
+        if op.push.nil?
+          # This instruction doesn't create a child node in the parse tree,
+          # but it might move us forward to a sibling or upward to an uncle
+          segment = AbstractState.mksegment(segment_tok, op.segment_use)
+          value   = value.append(segment)
+
+          # If we're moving upward, pop off the current table(s). If we're
+          # moving forward, shift off the previous instructions. Important
+          # that these are done in order.
+          instructions = table.pop(op.pop_count).drop(op.drop_count)
+
+          # Create a new AbstractState node that has a new InstructionTable
+          # and also points to a new AbstractVal tree (with the new segment)
+          state.append(state.node.copy(
+            :zipper       => value,
+            :instructions => instructions))
+        else
+          # Make a new sibling or uncle that will be the parent to the child
+          parent = state.node.copy \
+            :zipper       => value,
+            :children     => [],
+            :separators   => reader.try(&:separators),
+            :segment_dict => reader.try(&:segment_dict),
+            :instructions => table.pop(op.pop_count).drop(op.drop_count)
+
+          # Note, `state` is a cursor pointing at a state, while `parent`
+          # is an actual state
+          state = state.append(parent) unless state.root?
+
+          # Note, eg, op.push == TableState; op.push.push == TableState.push
+          op.push.push(state, parent, segment_tok, op.segment_use, @config)
+        end
+      end
+
+      def update_reader(op, reader, successor)
+        # We might be moving up or down past the interchange or functional
+        # group envelope, which control the set of separators and the set
+        # of all possible segments
+        unless op.push.nil? and (op.pop_count.zero? or reader.stream?)
+          unless reader.separators.eql?(successor.node.separators) \
+            and reader.segment_dict.eql?(successor.node.segment_dict)
+            reader.copy \
+              :separators   => successor.node.separators,
+              :segment_dict => successor.node.segment_dict
+          end
+        end || reader
+      end
+    end
+  end
+end

data/lib/stupidedi/parser/identifier_stack.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    # @todo: Documentation
+    #
+    class IdentifierStack
+      def initialize(start)
+        @state = Empty.new(Sequence.new(start))
+      end
+
+      # Returns a new interchange control number (ISA13, IEA02)
+      #
+      # @return [String]
+      def isa(*args)
+        @state = @state.isa(*args)
+        @state.id
+      end
+
+      # Returns a new functional Group Control Number (GS06, GE02)
+      #
+      # @return [String]
+      def gs(*args)
+        @state = @state.gs(*args)
+        @state.id
+      end
+
+      # Returns a new Transaction Set Control Number (ST02)
+      #
+      # @return [String]
+      def st(*args)
+        @state = @state.st(*args)
+        @state.id
+      end
+
+      # Returns a new Hierarchical ID Number (HL01)
+      #
+      # @return [String]
+      def hl(*args)
+        @state = @state.hl(*args)
+        @state.id
+      end
+
+      # Returns the last identifier created
+      def pop
+        @state.id.tap { @state = @state.pop }
+      end
+
+      def pop_isa
+        @state.id.tap { @state = @state.pop_isa }
+      end
+
+      def pop_gs
+        @state.id.tap { @state = @state.pop_gs }
+      end
+
+      def pop_st
+        @state.id.tap { @state = @state.pop_st }
+      end
+
+      def pop_hl
+        @state.id.tap { @state = @state.pop_hl }
+      end
+
+      def respond_to?(name)
+        @state.respond_to?(name)
+      end
+
+      def method_missing(name, *args)
+        @state.__send__(name, *args)
+      end
+
+      #########################################################################
+      # State Representations
+
+      class Sequence
+        def initialize(start)
+          @value = start
+        end
+
+        def succ!
+          self.tap { @value += 1 }
+        end
+
+        def value
+          @value
+        end
+      end
+
+      class Empty
+        def initialize(sequence)
+          @count, @sequence = 0, sequence
+        end
+
+        def isa
+          ISA.new(self, @sequence).tap { @count += 1; @sequence.succ! }
+        end
+
+        # Returns number of interchanges (@note this is not needed by X12)
+        #
+        # @return [Integer]
+        def count
+          @count
+        end
+      end
+
+      class ISA
+        attr_reader :id
+
+        def initialize(parent, sequence)
+          @count, @parent, @sequence, @id = 0, parent, sequence, sequence.value
+        end
+
+        def gs(start = nil)
+          sequence = start.try{|n| Sequence.new(n) } || @sequence
+          GS.new(self, sequence).tap { @count += 1; sequence.succ! }
+        end
+
+        # Number of Transaction Sets Included (IEA01)
+        #
+        # @return [Integer]
+        def count
+          @count
+        end
+
+        def pop_isa
+          @parent
+        end
+
+        def pop
+          warn "DEPRECATION WARNING: IdentifierStack#pop is deprecated, use pop_isa (when removing an ISA identifier from the stack)"
+          pop_isa
+        end
+      end
+
+      class GS
+        attr_reader :id
+
+        def initialize(parent, sequence)
+          @count, @parent, @sequence, @id = 0, parent, sequence, sequence.value
+        end
+
+        def st(start = nil)
+          sequence = start.try{|n| Sequence.new(n) } || @sequence
+          ST.new(self, sequence).tap { @count += 1; sequence.succ! }
+        end
+
+        # Number of Transaction Sets Included (GE01)
+        #
+        # @return [Integer]
+        def count
+          @count
+        end
+
+        def pop_gs
+          @parent
+        end
+
+        def pop
+          warn "DEPRECATION WARNING: IdentifierStack#pop is deprecated, use pop_gs (when removing an GS identifier from the stack)"
+          pop_gs
+        end
+      end
+
+      class ST
+        def initialize(parent, sequence)
+          @parent, @id = parent, sequence.value
+          @hl_sequence = Sequence.new(0)
+          @lx_sequence = Sequence.new(0)
+        end
+
+        def id
+          "%04d" % @id
+        end
+
+        def hl
+          HL.new(self, @hl_sequence.succ!, @lx_sequence)
+        end
+
+        def lx
+          @lx_sequence.succ!.value
+        end
+
+        # Number of Included Segments (SE01)
+        #
+        # @return [Integer]
+        def count(builder)
+          m = Either.success(builder.machine)
+
+          while m.defined?
+            if m.flatmap(&:segment).map{|s| s.node.id == :ST }.fetch(false)
+              return m.flatmap{|n| n.distance(builder.machine) }.fetch(0) + 2
+            else
+              m = m.flatmap(&:parent)
+            end
+          end
+        end
+
+        def pop_st
+          @parent
+        end
+
+        def pop
+          warn "DEPRECATION WARNING: IdentifierStack#pop is deprecated, use pop_st (when removing an ST identifier from the stack)"
+          pop_st
+        end
+      end
+
+      class HL
+        attr_reader :id
+
+        def initialize(parent, hl_sequence, lx_sequence)
+          @parent, @id, @hl_sequence, @lx_sequence =
+            parent, hl_sequence.value, hl_sequence, lx_sequence
+        end
+
+        def hl
+          HL.new(self, @hl_sequence.succ!, @lx_sequence)
+        end
+
+        def lx
+          @lx_sequence.succ!.value
+        end
+
+        # Parent HL number (HL02)
+        #
+        # @return [Integer]
+        def parent_hl
+          if @parent.is_a?(HL)
+            @parent.id
+          else
+            raise RuntimeError, "this HL*#{@id} does not have a parent HL"
+          end
+        end
+
+        def pop_hl
+          @parent
+        end
+
+        def pop
+          warn "DEPRECATION WARNING: IdentifierStack#pop is deprecated, use pop_ht (when removing an HL identifier from the stack)"
+          pop_hl
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/parser/instruction.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class Instruction
+      include Inspect
+
+      # The segment identifier to which this {Instruction} applies
+      #
+      # @return [Symbol]
+      attr_reader :segment_id
+
+      # The segment use contains helpful information about the context of the
+      # segment within a definition tree (eg the parent structure's definition).
+      # It also enumerates the allowed values for segment qualifiers, which is
+      # used to minimize non-determinism.
+      #
+      # @return [Schema::SegmentUse]
+      attr_reader :segment_use
+
+      # This indicates the number of levels to ascend and terminate within the
+      # tree before storing the segment.
+      #
+      # @return [Integer]
+      attr_reader :pop_count
+
+      # This controls the allowed order in which structures may occur, by
+      # indicating the number of instructions to remove from the beginning of
+      # the instruction table.
+      #
+      # Repeatable structures have a value that ensures that their instruction
+      # remains in the successor table.
+      #
+      # Sibling structures that have the same position (as defined by their
+      # {Schema::SegmentUse}) will have equal drop_count values such that all of
+      # the sibling instructions remain in the successor table when any one of
+      # them is executed.
+      #
+      # @return [Integer]
+      attr_reader :drop_count
+
+      # This indicates that a child node should be added to the tree, which
+      # will then contain the segment.
+      #
+      # When a segment indicates the start of a child structure, the class
+      # indicated by this attribute is expected to respond to `push` by
+      # creating a new {AbstractState}.
+      #
+      # @return [Zipper::AbstractCursor]
+      attr_reader :push
+
+      def initialize(segment_id, segment_use, pop, drop, push)
+        @segment_id, @segment_use, @pop_count, @drop_count, @push =
+          segment_id || segment_use.definition.id, segment_use, pop, drop, push
+      end
+
+      def hash
+        [Instruction, state].hash
+      end
+
+      # @return [Instruction]
+      def copy(changes = {})
+        Instruction.new \
+          changes.fetch(:segment_id, @segment_id),
+          changes.fetch(:segment_use, @segment_use),
+          changes.fetch(:pop_count, @pop_count),
+          changes.fetch(:drop_count, @drop_count),
+          changes.fetch(:push, @push)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = "% 3s" % @segment_id.to_s
+
+        unless @segment_use.nil?
+          width = 18
+          name  = @segment_use.definition.name
+
+          # Truncate the segment name to `width` characters
+          if name.length > width - 2
+            id = id + ": #{name.slice(0, width - 2)}.."
+          else
+            id = id + ": #{name.ljust(width)}"
+          end
+        end
+
+        q.text "Instruction[#{"% 3s" % id}]"
+
+        q.group(6, "(", ")") do
+          q.breakable ""
+
+          unless @segment_use.nil?
+            q.text "position: #{@segment_use.position},"
+            q.breakable
+          end
+
+          q.text "pop: #{@pop_count},"
+          q.breakable
+
+          q.text "drop: #{@drop_count}"
+        end
+      end
+
+    private
+
+      def state
+        [@segment_id, @segment_use, @pop_count, @drop_count, @push].hash
+      end
+    end
+  end
+end