stupidedi 1.1.0

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

@@ -0,0 +1,332 @@
+module Stupidedi
+  module Builder
+
+    class AbstractState
+      include Inspect
+
+      # @return [Reader::Separators]
+      abstract :separators
+
+      # @return [Reader::SegmentDict]
+      abstract :segment_dict
+
+      # @return [Zipper::AbstractCursor]
+      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.text "[#{zipper.node.class.name.split('::').last}]"
+      # q.text "[#{zipper.node.definition.id}]"
+
+        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.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_tok|
+              mksimple(designator, element_use, element_tok)
+            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_tok|
+              mkcomposite(designator, element_use, element_tok)
+            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.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`
+      #
+      # @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 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|
+              if b.repeatable? and b.entry_segment_uses.length > 1
+                raise Exceptions::InvalidSchemaError,
+                  "@todo"
+              end
+
+              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/builder/states/failure_state.rb

@@ -0,0 +1,69 @@
+module Stupidedi
+  module Builder
+
+    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, @zipper)
+      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)
+
+        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 \
+          "unexpected segment", segment_tok
+
+        new(parent.separators,
+            parent.segment_dict,
+            parent.instructions,
+            parent.zipper.append(segment_val),
+            [])
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

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

@@ -0,0 +1,97 @@
+module Stupidedi
+  module Builder
+
+    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
+
+      # @return [String]
+      attr_reader :fgcode
+
+      # @return [String]
+      attr_reader :version
+
+      def initialize(separators, segment_dict, instructions, zipper, children, fgcode, version)
+        @separators, @segment_dict, @instructions, @zipper, @children, @fgcode, @version =
+          separators, segment_dict, instructions, zipper, children, fgcode, version
+      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(:fgcode, @fgcode),
+          changes.fetch(:version, @version)
+      end
+    end
+
+    class << FunctionalGroupState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        # GS08: Version / Release / Industry Identifier Code
+        version = segment_tok.element_toks.at(7).try(:value)
+        gscode  = version.try(:slice, 0, 6)
+
+        # GS01: Functional Identifier Code
+        fgcode = segment_tok.element_toks.at(0).try(:value)
+
+        unless config.functional_group.defined_at?(gscode)
+          return FailureState.push(
+            zipper,
+            parent,
+            segment_tok,
+            "unknown functional group version #{gscode.inspect}")
+        end
+
+        envelope_def = config.functional_group.at(gscode)
+        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),
+          [], fgcode, version)
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Array<Instruction>]
+      def instructions(functional_group_def)
+        @__instructions ||= Hash.new
+        @__instructions[functional_group_def] ||= begin
+        # puts "FunctionalGroupState.instructions(#{functional_group_def.object_id})"
+          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/builder/states/initial_state.rb

@@ -0,0 +1,63 @@
+module Stupidedi
+  module Builder
+
+    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
+        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.build(build)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,94 @@
+module Stupidedi
+  module Builder
+
+    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)
+          return FailureState.push(
+            zipper,
+            parent,
+            segment_tok,
+            "unknown interchange version #{version.inspect}")
+        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
+        # puts "InterchangeState.instructions(#{interchange_def.object_id})"
+          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