tediparse 2.0.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class InterchangeState < 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 [InterchangeState]
+      def copy(changes = {})
+        InterchangeState.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 << InterchangeState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        # ISA12: Interchange Control Version Number
+        version = segment_tok.element_toks.at(11).try(:value)
+
+        unless config.interchange.defined_at?(version)
+          reason =
+            if config.interchange.empty?
+              Stupidedi::Exceptions::MissingGrammarError::DEFAULT_MESSAGE
+            else
+              "unknown interchange version #{version.inspect}"
+            end
+
+          return FailureState.push(zipper, parent, segment_tok, reason)
+        end
+
+        # Construct a SegmentVal and InterchangeVal around it
+        envelope_def = config.interchange.at(version)
+        envelope_val = envelope_def.empty(parent.separators)
+        segment_use  = envelope_def.entry_segment_use
+        segment_val  = mksegment(segment_tok, segment_use)
+
+        separators =
+          parent.separators.merge(envelope_def.separators(segment_val))
+
+        zipper.append_child new(
+          separators,
+          parent.segment_dict.push(envelope_val.segment_dict),
+          parent.instructions.push(instructions(envelope_def)),
+          parent.zipper.append(envelope_val).append_child(segment_val),
+          [])
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Array<Instruction>]
+      def instructions(interchange_def)
+        @__instructions ||= Hash.new
+        @__instructions[interchange_def] ||= begin
+          is = if interchange_def.header_segment_uses.head.repeatable?
+                 sequence(interchange_def.header_segment_uses)
+               else
+                 sequence(interchange_def.header_segment_uses.tail)
+               end
+
+          is << Instruction.new(:GS, nil, 0, is.length, FunctionalGroupState)
+          is.concat(sequence(interchange_def.trailer_segment_uses, is.length))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class LoopState < 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 [LoopState]
+      def copy(changes = {})
+        LoopState.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 << LoopState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        loop_def    = segment_use.parent
+        loop_val    = loop_def.empty
+        segment_val = mksegment(segment_tok, segment_use)
+
+        zipper.append_child new(
+          parent.separators,
+          parent.segment_dict,
+          parent.instructions.push(instructions(loop_def)),
+          parent.zipper.append(loop_val).append_child(segment_val),
+          [])
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Array<Instruction>]
+      def instructions(loop_def)
+        @__instructions ||= Hash.new
+        @__instructions[loop_def] ||= begin
+          # When first segment is repeatable, then `successors` should include
+          # an {Instruction} for it; but when it's non-repeatable, there should
+          # be no successor instruction for that segment.
+          skip_first = !loop_def.entry_segment_use.repeatable?
+          interleaved_sequence(loop_def.children, 0, skip_first: skip_first)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class TableState < 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 [TableState]
+      def copy(changes = {})
+        TableState.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 << TableState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        case segment_use.parent
+        when Schema::TableDef
+          table_def   = segment_use.parent
+          table_val   = table_def.empty
+          segment_val = mksegment(segment_tok, segment_use)
+
+          itable = InstructionTable.build(instructions(table_def))
+          itable = itable.drop(itable.at(segment_use).drop_count)
+
+          zipper.append_child new(
+            parent.separators,
+            parent.segment_dict,
+            parent.instructions.push(itable.instructions),
+            parent.zipper.append(table_val).append_child(segment_val),
+            [])
+
+        when Schema::LoopDef
+          table_def = segment_use.parent.parent
+          table_val = table_def.empty
+
+          itable = InstructionTable.build(instructions(table_def))
+          itable = itable.drop(itable.at(segment_use).drop_count)
+
+          zipper = zipper.append_child new(
+            parent.separators,
+            parent.segment_dict,
+            parent.instructions.push(itable.instructions),
+            parent.zipper.append(table_val).dangle.last,
+            [])
+
+          LoopState.push(zipper, zipper.node, segment_tok, segment_use, config)
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Array<Instruction>]
+      def instructions(table_def)
+        @__instructions ||= Hash.new
+        @__instructions[table_def] ||= interleaved_sequence(table_def.children)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class TransactionSetState < 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 [TransactionSetState]
+      def copy(changes = {})
+        TransactionSetState.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 << TransactionSetState
+      # @group Constructors
+      #########################################################################
+
+      # @return [TransactionSetState]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        # GS01: Functional Identifier Code
+        gs01 = parent.gs01
+
+        # ST01: Transaction Set Identifier Code
+        st01 = segment_tok.element_toks.at(0).try(:value)
+
+        # ST03: Implementation Convention Reference
+        #
+        # The implementation convention reference (ST03) is used by the
+        # translation routines of the interchange partners to select the
+        # appropriate implementation convention to match the transaction set
+        # definition. When used, this implementation convention reference takes
+        # precedence over the implementation reference specified in the GS08
+        st03 = segment_tok.element_toks.at(2).try(:value)
+
+        # Fall back to GS08 if ST03 isn't available
+        if st03.blank? or st03.is_a?(Symbol)
+          # GS08: Version / Release / Industry Identifier Code
+          st03 = parent.gs08
+        end
+
+        # Fall back to GS08 if ST03 isn't recognized
+        # unless config.transaction_set.defined_at?(st03, gs01, st01)
+        #   if config.transaction_set.defined_at?(parent.gs08, gs01, st01)
+        #     st03 = parent.gs08
+        #   end
+        # end
+
+        unless config.transaction_set.defined_at?(st03, gs01, st01)
+          reason =
+            if config.transaction_set.empty?
+              Stupidedi::Exceptions::MissingGrammarError::DEFAULT_MESSAGE
+            else
+              context = "#{st03.inspect} #{gs01.inspect} #{st01.inspect}"
+              "unknown transaction set #{context}"
+            end
+
+          return FailureState.push(zipper, parent, segment_tok, reason)
+        end
+
+        envelope_def = config.transaction_set.at(st03, gs01, st01)
+        envelope_val = envelope_def.empty
+        segment_use  = envelope_def.entry_segment_use
+
+        zipper = zipper.append_child \
+          TransactionSetState.new(
+            parent.separators,
+            parent.segment_dict,
+            parent.instructions.push(instructions(envelope_def)),
+            parent.zipper.append(envelope_val).dangle.last,
+            [])
+
+        TableState.push(zipper, zipper.node, segment_tok, segment_use, config)
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Array<Instruction>]
+      def instructions(transaction_set_def)
+        @__instructions ||= Hash.new
+        @__instructions[transaction_set_def] ||= begin
+          # When first segment is repeatable, then `successors` should include
+          # an {Instruction} for it; but when it's non-repeatable, there should
+          # be no successor instruction for that segment.
+          if transaction_set_def.table_defs.head.repeatable?
+            tsequence(transaction_set_def.table_defs)
+          else
+            tsequence(transaction_set_def.table_defs.tail)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class TransmissionState < 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 [TransmissionState]
+      def copy(changes = {})
+        TransmissionState.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 << TransmissionState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        zipper = zipper.append_child new(
+          parent.separators,
+          parent.segment_dict,
+          parent.instructions.push([
+            Instruction.new(:ISA, nil, 0, 0, InterchangeState)]),
+          parent.zipper.dangle.last,
+          [])
+
+        InterchangeState.push(zipper, zipper.node, segment_tok, segment_use, config)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/parser/tokenization.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    module Tokenization
+      #########################################################################
+      # @group Element Constructors
+
+      # Generates a repeated element (simple or composite)
+      #
+      # @return [void]
+      def repeated(*elements)
+        [:repeated, elements, Reader::Position.caller(2)]
+      end
+
+      # Generates a composite element
+      #
+      # @return [void]
+      def composite(*components)
+        [:composite, components, Reader::Position.caller(2)]
+      end
+
+      #########################################################################
+      # @group Element Placeholders
+
+      # Generates a blank element
+      #
+      # @return [void]
+      def blank
+        [:blank, nil, Reader::Position.caller(2)]
+      end
+
+      # Generates a blank element and asserts that the element's usage
+      # requirement is `NOT USED`
+      #
+      # @see Schema::ElementReq#forbidden?
+      #
+      # @return [void]
+      def not_used
+        [:not_used, nil, Reader::Position.caller(2)]
+      end
+
+      # Generates the only possible value an element may have, which may
+      # be blank. An exception is thrown if the element's usage requirement
+      # is optional, or if there are more than one allowed non-blank values.
+      #
+      # @see Schema::SimpleElementUse#allowed_values
+      # @see Schema::ElementReq#forbidden?
+      #
+      # @return [void]
+      def default
+        [:default, nil, Reader::Position.caller(2)]
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Reader::SegmentTok]
+      def mksegment_tok(segment_dict, id, elements, position)
+        id = id.to_sym
+        element_toks = []
+
+        unless segment_dict.defined_at?(id)
+          element_idx  = "00"
+          elements.each do |e_tag, e_val, e_position|
+            element_idx = element_idx.succ
+
+            # If the element is a regular Ruby value "ABC", the way this
+            # proc's arguments are assigned would be e_tag = "ABC", and
+            # e_val and e_position are nil. If the argument is a placeholder
+            # like #blank, #not_used, or #default is used, those methods return
+            # a triple that is deconstructed such that e_val is also nil.
+            #
+            # However, for #composite or #repeated, the triple is deconstructed
+            # such that e_val is an Array of other values, and isn't #nil?
+            unless e_val.nil?
+              raise ArgumentError,
+                "#{id}#{element_idx} is assumed to be a simple element"
+            end
+
+            element_toks << mksimple_tok(e_tag, e_position || position)
+          end
+        else
+          segment_def  = segment_dict.at(id)
+          element_uses = segment_def.element_uses
+
+          if elements.length > element_uses.length
+            raise ArgumentError,
+              "#{id} segment has only #{element_uses.length} elements"
+          end
+
+          element_idx  = "00"
+          elements.zip(element_uses) do |(e_tag, e_val, e_position), e_use|
+            element_idx = element_idx.succ
+            designator = "#{id}#{element_idx}"
+
+            if e_use.repeatable?
+              # Repeatable composite or non-composite
+              unless [:repeated, :blank, :not_used, nil].include?(e_tag)
+                raise ArgumentError,
+                  "#{designator} is a repeatable element"
+              end
+
+              element_toks << mkrepeated_tok(e_val || [], e_use, designator, e_position || position)
+            elsif e_use.composite?
+              unless [:composite, :not_used, :blank, nil].include?(e_tag)
+                raise ArgumentError,
+                  "#{id}#{element_idx} is a non-repeatable composite element"
+              end
+
+              element_toks << mkcomposite_tok(e_val || [], e_use, designator, e_position || position)
+            else
+              # The actual value is in e_tag
+              unless e_val.nil?
+                raise ArgumentError,
+                  "#{id}#{element_idx} is a non-repeatable simple element"
+              end
+
+              element_toks << mksimple_tok(e_tag, e_position || position)
+            end
+          end
+        end
+
+        Reader::SegmentTok.new(id, element_toks, position, nil)
+      end
+
+      # @return [Reader::RepeatedElementTok]
+      def mkrepeated_tok(elements, element_use, designator, position)
+        element_toks = []
+
+        if element_use.composite?
+          elements.each do |e_tag, e_val, e_position|
+            unless [:composite, :not_used, :blank, nil].include?(e_tag)
+              raise ArgumentError,
+                "#{designator} is a composite element"
+            end
+
+            element_toks << mkcomposite_tok(e_val || [], element_use, designator, e_position || position)
+          end
+        else
+          elements.each do |e_tag, e_val, e_position|
+            unless e_val.nil?
+              raise ArgumentError,
+                "#{designator} is a simple element"
+            end
+
+            element_toks << mksimple_tok(e_tag, e_position || position)
+          end
+        end
+
+        Reader::RepeatedElementTok.build(element_toks, position)
+      end
+
+      # @return [Reader::CompositeElementTok]
+      def mkcomposite_tok(components, composite_use, designator, position)
+        component_uses = composite_use.definition.component_uses
+
+        if components.length > component_uses.length
+          raise ArgumentError,
+            "#{designator} has only #{component_uses.length} components"
+        end
+
+        component_idx  = "0"
+        component_toks = []
+        component_uses.zip(components) do |c_use, (c_tag, c_val, c_position)|
+          component_idx = component_idx.succ
+          unless c_val.nil?
+            raise ArgumentError,
+              "#{designator}-#{component_idx} is a component element"
+          end
+
+          component_toks << mkcomponent_tok(c_tag, c_position || position)
+        end
+
+        Reader::CompositeElementTok.build(component_toks, position, nil)
+      end
+
+      # @return [Reader::ComponentElementTok]
+      def mkcomponent_tok(value, position)
+        Reader::ComponentElementTok.build(value, position, nil)
+      end
+
+      # @return [Reader::SimpleElementTok]
+      def mksimple_tok(value, position)
+        Reader::SimpleElementTok.build(value, position, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Parser
+    autoload :ConstraintTable,      "stupidedi/parser/constraint_table"
+    autoload :Instruction,          "stupidedi/parser/instruction"
+    autoload :InstructionTable,     "stupidedi/parser/instruction_table"
+
+    autoload :BuilderDsl,           "stupidedi/parser/builder_dsl"
+    autoload :Generation,           "stupidedi/parser/generation"
+    autoload :Navigation,           "stupidedi/parser/navigation"
+    autoload :Tokenization,         "stupidedi/parser/tokenization"
+    autoload :StateMachine,         "stupidedi/parser/state_machine"
+    autoload :IdentifierStack,      "stupidedi/parser/identifier_stack"
+
+    autoload :AbstractState,        "stupidedi/parser/states/abstract_state"
+    autoload :FailureState,         "stupidedi/parser/states/failure_state"
+    autoload :FunctionalGroupState, "stupidedi/parser/states/functional_group_state"
+    autoload :InitialState,         "stupidedi/parser/states/initial_state"
+    autoload :InterchangeState,     "stupidedi/parser/states/interchange_state"
+    autoload :LoopState,            "stupidedi/parser/states/loop_state"
+    autoload :TableState,           "stupidedi/parser/states/table_state"
+    autoload :TransactionSetState,  "stupidedi/parser/states/transaction_set_state"
+    autoload :TransmissionState,    "stupidedi/parser/states/transmission_state"
+  end
+
+  class << Parser
+    # @return [StateMachine]
+    def build(*args)
+      Parser::StateMachine.build(*args)
+    end
+  end
+end