tediparse 2.0.0

data/lib/stupidedi/parser/state_machine.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class StateMachine
+      include Inspect
+      include Navigation
+      include Generation
+      include Tokenization
+
+      # @return [Config]
+      attr_reader :config
+
+      # @return [Array<Zipper::AbstractCursor<StateMachine::AbstractState>>]
+      attr_reader :active
+
+      def initialize(config, active)
+        @config, @active = config, active
+      end
+
+      def copy(changes = {})
+        StateMachine.new \
+          changes.fetch(:config, @config),
+          changes.fetch(:active, @active)
+      end
+
+      # @return [Reader::Separators]
+      def separators
+        @active.head.node.separators
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "StateMachine[#{@active.length}]"
+        q.group 2, "(", ")" do
+          q.breakable ""
+          @active.each do |s|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp s.node.zipper.node
+          end
+        end
+      end
+    end
+
+    class << StateMachine
+      # @group Constructors
+      #########################################################################
+
+      # @return [StateMachine]
+      def build(config, zipper = Zipper::Tree)
+        StateMachine.new(config, InitialState.start(zipper).cons)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/parser/states/abstract_state.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class AbstractState
+      include Inspect
+
+      # @return [Reader::Separators]
+      abstract :separators
+
+      # @return [Reader::SegmentDict]
+      abstract :segment_dict
+
+      # @return [Zipper::AbstractCursor<Values::SegmentVal>]
+      abstract :zipper
+
+      # @return [Array<AbstractState>]
+      abstract :children
+
+      # @return [InstructionTable]
+      abstract :instructions
+
+      def leaf?
+        false
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text self.class.name.split("::").last
+        q.group(2, "(", ")") do
+          q.breakable ""
+
+          children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << AbstractState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      abstract :push, :args => %w(zipper parent segment_tok segment_use config)
+
+      # @group SegmentVal Construction
+      #########################################################################
+
+      # @return [Values::SegmentVal]
+      def mksegment(segment_tok, segment_use)
+        segment_def  = segment_use.definition
+        element_uses = segment_def.element_uses
+        element_toks = segment_tok.element_toks
+
+        position     = segment_tok.position
+        element_vals = []
+        element_idx  = "00"
+        element_uses.zip(element_toks) do |element_use, element_tok|
+          element_idx = element_idx.succ
+          position = element_tok.position if element_tok
+
+          element_vals <<
+            if element_tok.nil?
+              if element_use.repeatable?
+                Values::RepeatedElementVal.empty(element_use)
+              else
+                element_use.empty(position)
+              end
+            else
+              mkelement("#{segment_def.id}#{element_idx}", element_use, element_tok)
+            end
+        end
+
+        segment_use.value(element_vals, segment_tok.position)
+      end
+
+      # @return [Values::SimpleElementVal, Values::CompositeElementVal, Values::RepeatedElementVal]
+      def mkelement(designator, element_use, element_tok)
+        if element_use.simple?
+          if element_use.repeatable?
+            element_toks = element_tok.element_toks
+            element_vals = element_toks.map do |element_tok1|
+              mksimple(designator, element_use, element_tok1)
+            end
+
+            mkrepeated(designator, element_use, element_vals)
+          else
+            mksimple(designator, element_use, element_tok)
+          end
+        else
+          if element_use.repeatable?
+            element_toks = element_tok.element_toks
+            element_vals = element_toks.map do |element_tok1|
+              mkcomposite(designator, element_use, element_tok1)
+            end
+
+            mkrepeated(designator, element_use, element_vals)
+          else
+            mkcomposite(designator, element_use, element_tok)
+          end
+        end
+      end
+
+      # @return [Values::RepeatedElementVal]
+      def mkrepeated(designator, element_use, element_vals)
+        # @todo: Position
+        Values::RepeatedElementVal.build(element_vals, element_use)
+      end
+
+      # @return [Values::CompositeElementVal]
+      def mkcomposite(designator, composite_use, composite_tok)
+        composite_def  = composite_use.definition
+        component_uses = composite_def.component_uses
+        component_toks = composite_tok.component_toks
+
+        position       = composite_tok.position
+        component_vals = []
+        component_idx  = "00"
+        component_uses.zip(component_toks) do |component_use, component_tok|
+          component_idx = component_idx.succ
+          position = component_tok.position if component_tok
+
+          component_vals <<
+            if component_tok.nil?
+              component_use.empty(position)
+            else
+              mksimple("#{designator}-#{component_idx}", component_use, component_tok)
+            end
+        end
+
+        composite_use.value(component_vals, composite_tok.position)
+      end
+
+      # @return [Values::SimpleElementVal]
+      def mksimple(designator, element_use, element_tok)
+        # We don't validate that element_tok is simple because the TokenReader
+        # will always produce a SimpleElementTok given a SimpleElementUse from
+        # the SegmentDef. On the other hand, the BuilderDsl API will throw an
+        # exception if the programmer constructs the wrong kind of element
+        # according to the SegmentDef.
+
+        if element_tok.value == :default
+          allowed_vals = element_use.allowed_values
+
+          if element_use.requirement.forbidden?
+            element_use.empty(element_tok.position)
+          elsif allowed_vals.empty?
+            element_use.empty(element_tok.position)
+          elsif allowed_vals.size == 1
+            element_use.value(allowed_vals.first, element_tok.position)
+          else
+            raise Exceptions::ParseError,
+              "#{designator} cannot be inferred"
+          end
+        elsif element_tok.value == :not_used
+          if element_use.requirement.forbidden?
+            element_use.empty(element_tok.position)
+          else
+            raise Exceptions::ParseError,
+              "#{designator} is not forbidden"
+          end
+        elsif element_tok.value == :blank
+          element_use.empty(element_tok.position)
+        else
+          element_use.value(element_tok.value, element_tok.position)
+        end
+      end
+
+      # @group Instruction Generation
+      #########################################################################
+
+      # Builds a sequence of {Instruction} values that corresponds to the given
+      # sequence of `segment_uses`
+      #
+      # @return [Array<Instruction>]
+      def sequence(segment_uses, offset = 0)
+        instructions = []
+        buffer       = []
+        last         = nil
+
+        segment_uses.each do |s|
+          unless last.nil? or s.position == last.position
+            drop_count =
+              if buffer.length == 1 and not last.repeatable?
+                offset
+              else
+                offset - buffer.length
+              end
+
+            buffer.each do |u|
+              instructions << Instruction.new(nil, u, 0, drop_count, nil)
+            end
+
+            buffer.clear
+          end
+
+          buffer << s
+          last    = s
+          offset += 1
+        end
+
+        # Flush the buffer one last time
+        unless buffer.empty?
+          drop_count =
+            if buffer.length == 1 and not last.repeatable?
+              offset
+            else
+              offset - buffer.length
+            end
+
+          buffer.each do |u|
+            instructions << Instruction.new(nil, u, 0, drop_count, nil)
+          end
+        end
+
+        instructions
+      end
+
+      # Builds a sequence of {Instruction} values that corresponds to the given
+      # sequence of `loop_defs`
+      #
+      # @deprecated Use {#interleaved_sequence} instead, which handles mixed
+      #   SegmentUse and LoopDef children.
+      # @return [Array<Instruction>]
+      def lsequence(loop_defs, offset = 0)
+        instructions = []
+        buffer       = []
+        last         = nil
+
+        loop_defs.each do |l|
+          unless last.nil? or l.entry_segment_use.position == last.entry_segment_use.position
+            drop_count =
+              if buffer.length == 1 and not last.repeatable?
+                offset
+              else
+                offset - buffer.length
+              end
+
+            buffer.each do |u|
+              instructions << Instruction.new(nil, u, 0, drop_count, LoopState)
+            end
+            buffer.clear
+          end
+
+          buffer << l.entry_segment_use
+          last    = l
+          offset += 1
+        end
+
+        # Flush the buffer one last time
+        unless buffer.nil?
+          drop_count =
+            if buffer.length == 1 and not last.repeatable?
+              offset
+            else
+              offset - buffer.length
+            end
+
+          buffer.each do |u|
+            instructions << Instruction.new(nil, u, 0, drop_count, LoopState)
+          end
+        end
+
+        instructions
+      end
+
+      # Builds a sequence of {Instruction} values that corresponds to a mixed
+      # sequence of SegmentUse and LoopDef children (supporting interleaved patterns).
+      #
+      # @param children [Array<Schema::SegmentUse, Schema::LoopDef>]
+      # @param offset [Integer]
+      # @param skip_first [Boolean] if true, skip the first child (for non-repeatable entry segments)
+      # @return [Array<Instruction>]
+      def interleaved_sequence(children, offset = 0, skip_first: false)
+        children = children.drop(1) if skip_first
+
+        instructions = []
+        buffer       = []
+        last_pos     = nil
+
+        children.each do |child|
+          current_pos = child.is_a?(Schema::SegmentUse) ? child.position : child.entry_segment_use.position
+          is_repeatable = child.is_a?(Schema::SegmentUse) ? child.repeatable? : child.repeatable?
+
+          unless last_pos.nil? or current_pos == last_pos
+            drop_count =
+              if buffer.length == 1 and not buffer.first[:repeatable]
+                offset
+              else
+                offset - buffer.length
+              end
+
+            buffer.each do |item|
+              instructions << Instruction.new(nil, item[:segment_use], 0, drop_count, item[:push])
+            end
+
+            buffer.clear
+          end
+
+          segment_use = child.is_a?(Schema::SegmentUse) ? child : child.entry_segment_use
+          push_state = child.is_a?(Schema::SegmentUse) ? nil : LoopState
+
+          buffer << { segment_use: segment_use, push: push_state, repeatable: is_repeatable }
+          last_pos = current_pos
+          offset  += 1
+        end
+
+        # Flush the buffer one last time
+        unless buffer.empty?
+          drop_count =
+            if buffer.length == 1 and not buffer.first[:repeatable]
+              offset
+            else
+              offset - buffer.length
+            end
+
+          buffer.each do |item|
+            instructions << Instruction.new(nil, item[:segment_use], 0, drop_count, item[:push])
+          end
+        end
+
+        instructions
+      end
+
+      # Builds a sequence of {Instruction} values that corresponds to the given
+      # sequence of `table_defs`
+      #
+      # @return [Array<Instruction>]
+      def tsequence(table_defs, offset = 0)
+        instructions = []
+        buffer       = []
+        last         = nil
+
+        table_defs.each do |t|
+          unless last.nil? or t.position == last.position
+            drop_count =
+              if buffer.length == 1 and not last.repeatable?
+                offset
+              else
+                offset - buffer.inject(0){|n,b| n + b.entry_segment_uses.length }
+              end
+
+            buffer.each do |b|
+              b.entry_segment_uses.each do |u|
+                instructions << Instruction.new(nil, u, 0, drop_count, TableState)
+              end
+            end
+
+            buffer.clear
+          end
+
+          last    = t
+          offset += t.entry_segment_uses.length
+          buffer << t
+        end
+
+        unless buffer.empty?
+          drop_count =
+            if buffer.length == 1 and not last.repeatable?
+              offset
+            else
+              offset - buffer.inject(0){|n,b| n + b.entry_segment_uses.length }
+            end
+
+          buffer.each do |b|
+            b.entry_segment_uses.each do |u|
+              instructions << Instruction.new(nil, u, 0, drop_count, TableState)
+            end
+          end
+        end
+
+        instructions
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/parser/states/failure_state.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class FailureState < AbstractState
+      # @return [Reader::Separators]
+      attr_reader :separators
+
+      # @return [Reader::SegmentDict]
+      attr_reader :segment_dict
+
+      # @return [Zipper::AbstractCursor]
+      attr_reader :zipper
+
+      # @return [InstructionTable]
+      attr_reader :instructions
+
+      # @return [Array<FailureState>]
+      attr_reader :children
+
+      def initialize(separators, segment_dict, instructions, zipper, children)
+        @separators, @segment_dict, @instructions, @zipper, @children =
+          separators, segment_dict, instructions, zipper, children
+      end
+
+      def copy(changes = {})
+        FailureState.new \
+          changes.fetch(:separators, @separators),
+          changes.fetch(:segment_dict, @segment_dict),
+          changes.fetch(:instructions, @instructions),
+          changes.fetch(:zipper, @zipper),
+          changes.fetch(:children, @children)
+      end
+    end
+
+    class << FailureState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, reason)
+        envelope_val = Values::InvalidEnvelopeVal.new([])
+        segment_val  = Values::InvalidSegmentVal.new(reason, segment_tok, parent.separators)
+
+        zipper.append_child new(
+          parent.separators,
+          parent.segment_dict,
+          parent.instructions.push([]),
+          parent.zipper.append(envelope_val).append_child(segment_val),
+          [])
+      end
+
+      def mksegment(segment_tok, parent)
+        segment_val = Values::InvalidSegmentVal.new \
+          "cannot occur here", segment_tok, parent.separators
+
+        new(parent.separators,
+            parent.segment_dict,
+            parent.instructions,
+            parent.zipper.append(segment_val),
+            [])
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/parser/states/functional_group_state.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class FunctionalGroupState < AbstractState
+      # @return [Reader::Separators]
+      attr_reader :separators
+
+      # @return [Reader::SegmentDict]
+      attr_reader :segment_dict
+
+      # @return [InstructionTable]
+      attr_reader :instructions
+
+      # @return [Zipper::AbstractCursor]
+      attr_reader :zipper
+
+      # @return [Array<AbstractState>]
+      attr_reader :children
+
+      # GS01: Functional Identifier Code
+      # @return [String]
+      attr_reader :gs01
+
+      # GS08: Version / Release / Industry Identifier Code
+      # @return [String]
+      attr_reader :gs08
+
+      def initialize(separators, segment_dict, instructions, zipper, children, gs01, gs08)
+        @separators, @segment_dict, @instructions, @zipper, @children, @gs01, @gs08 =
+          separators, segment_dict, instructions, zipper, children, gs01, gs08
+      end
+
+      # @return [FunctionalGroupState]
+      def copy(changes = {})
+        FunctionalGroupState.new \
+          changes.fetch(:separators, @separators),
+          changes.fetch(:segment_dict, @segment_dict),
+          changes.fetch(:instructions, @instructions),
+          changes.fetch(:zipper, @zipper),
+          changes.fetch(:children, @children),
+          changes.fetch(:gs01, @gs01),
+          changes.fetch(:gs08, @gs08)
+      end
+    end
+
+    class << FunctionalGroupState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        # GS08: Version / Release / Industry Identifier Code
+        gs08         = segment_tok.element_toks.at(7).try(:value)
+        gs08_version = gs08.try(:slice, 0, 6)
+
+        # GS01: Functional Identifier Code
+        gs01 = segment_tok.element_toks.at(0).try(:value)
+
+        unless config.functional_group.defined_at?(gs08_version)
+          reason =
+            if config.functional_group.empty?
+              Stupidedi::Exceptions::MissingGrammarError::DEFAULT_MESSAGE
+            else
+              "unknown functional group version #{gs08_version.inspect}"
+            end
+
+          return FailureState.push(zipper, parent, segment_tok, reason)
+        end
+
+        envelope_def = config.functional_group.at(gs08_version)
+        envelope_val = envelope_def.empty
+        segment_use  = envelope_def.entry_segment_use
+        segment_val  = mksegment(segment_tok, segment_use)
+
+        zipper.append_child new(
+          parent.separators,
+          parent.segment_dict.push(envelope_val.segment_dict),
+          parent.instructions.push(instructions(envelope_def)),
+          parent.zipper.append(envelope_val).append_child(segment_val),
+          [], gs01, gs08)
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Array<Instruction>]
+      def instructions(functional_group_def)
+        @__instructions ||= Hash.new
+        @__instructions[functional_group_def] ||= begin
+          is = sequence(functional_group_def.header_segment_uses.tail)
+          is << Instruction.new(:ST, nil, 0, is.length, TransactionSetState)
+          is.concat(sequence(functional_group_def.trailer_segment_uses, is.length))
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/parser/states/initial_state.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class InitialState < AbstractState
+      # @return [Reader::Separators]
+      attr_reader :separators
+
+      # @return [Reader::SegmentDict]
+      attr_reader :segment_dict
+
+      # @return [InstructionTable]
+      attr_reader :instructions
+
+      # @return [Zipper::AbstractCursor]
+      attr_reader :zipper
+
+      # @return [Array<AbstractState>]
+      attr_reader :children
+
+      def initialize(separators, segment_dict, instructions, zipper, children)
+        @separators, @segment_dict, @instructions, @zipper, @children =
+          separators, segment_dict, instructions, zipper, children
+      end
+
+      # @return [InitialState]
+      def copy(changes = {})
+        InitialState.new \
+          changes.fetch(:separators, @separators),
+          changes.fetch(:segment_dict, @segment_dict),
+          changes.fetch(:instructions, @instructions),
+          changes.fetch(:zipper, @zipper),
+          changes.fetch(:children, @children)
+      end
+    end
+
+    class << InitialState
+      # @return [InitialState]
+      def build(zipper)
+        new(
+          Reader::Separators.empty,
+          Reader::SegmentDict.empty,
+
+          InstructionTable.build(
+            # We initially accept only a single segment. When reading the "ISA"
+            # segment, we push a new InterchangeState.
+            Instruction.new(:ISA, nil, 0, 0, TransmissionState).cons),
+
+          # Create a new parse tree with a Transmission as the root, and descend
+          # to the placeholder where the first child node will be placed.
+          zipper.build(Values::TransmissionVal.new),
+          [])
+      end
+
+      # @return [Zipper::AbstractCursor]
+      def start(zipper)
+        zipper.build(build(zipper))
+      end
+    end
+  end
+end