stupidedi 1.1.0

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

@@ -0,0 +1,79 @@
+module Stupidedi
+  module Builder
+
+    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
+        # puts "LoopDef.instructions(#{loop_def.object_id})"
+          # @todo: Explain this optimization
+          is = if loop_def.header_segment_uses.head.repeatable?
+                sequence(loop_def.header_segment_uses)
+               else
+                 sequence(loop_def.header_segment_uses.tail)
+               end
+
+          is.concat(lsequence(loop_def.loop_defs, is.length))
+          is.concat(sequence(loop_def.trailer_segment_uses, is.length))
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,96 @@
+module Stupidedi
+  module Builder
+
+    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] ||= begin
+        # puts "TableState.instructions(#{table_def.object_id})"
+          is = sequence(table_def.header_segment_uses)
+          is.concat(lsequence(table_def.loop_defs, is.length))
+          is.concat(sequence(table_def.trailer_segment_uses, is.length))
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,112 @@
+module Stupidedi
+  module Builder
+
+    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
+        fgcode = parent.fgcode
+
+        # ST01: Transaction Set Identifier Code
+        txcode = segment_tok.element_toks.at(0).try(:value)
+
+        # ST03: Implementation Convention Reference
+        version = segment_tok.element_toks.at(2).try(:value)
+
+        # Fall back to GS08 if ST03 isn't available
+        if version.blank? or version.is_a?(Symbol)
+          # GS08: Version / Release / Industry Identifier Code
+          version = parent.version
+        end
+
+        # Fall back to GS08 if version isn't recognized
+        unless config.transaction_set.defined_at?(version, fgcode, txcode)
+          if config.transaction_set.defined_at?(parent.version, fgcode, txcode)
+            # GS08: Version / Release / Industry Identifier Code
+            version = parent.version
+          end
+        end
+
+        unless config.transaction_set.defined_at?(version, fgcode, txcode)
+          context = "#{fgcode.inspect} #{txcode.inspect} #{version.inspect}"
+
+          return FailureState.push(
+            zipper,
+            parent,
+            segment_tok,
+            "unknown transaction set #{context}")
+        end
+
+        envelope_def = config.transaction_set.at(version, fgcode, txcode)
+        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
+        # puts "TransactionSetState.instructions(#{transaction_set_def.object_id})"
+          # @todo: Explain this optimization
+          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/builder/states/transmission_state.rb

@@ -0,0 +1,59 @@
+module Stupidedi
+  module Builder
+
+    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/builder/tokenization.rb

@@ -0,0 +1,196 @@
+module Stupidedi
+  module Builder
+
+    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.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"
+          element_uses.zip(elements) do |e_use, (e_tag, e_val, e_position)|
+            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.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/builder.rb

@@ -0,0 +1,23 @@
+module Stupidedi
+  module Builder
+    autoload :ConstraintTable,      "stupidedi/builder/constraint_table"
+    autoload :Instruction,          "stupidedi/builder/instruction"
+    autoload :InstructionTable,     "stupidedi/builder/instruction_table"
+
+    autoload :BuilderDsl,           "stupidedi/builder/builder_dsl"
+    autoload :Generation,           "stupidedi/builder/generation"
+    autoload :Navigation,           "stupidedi/builder/navigation"
+    autoload :Tokenization,         "stupidedi/builder/tokenization"
+    autoload :StateMachine,         "stupidedi/builder/state_machine"
+
+    autoload :AbstractState,        "stupidedi/builder/states/abstract_state"
+    autoload :FailureState,         "stupidedi/builder/states/failure_state"
+    autoload :FunctionalGroupState, "stupidedi/builder/states/functional_group_state"
+    autoload :InitialState,         "stupidedi/builder/states/initial_state"
+    autoload :InterchangeState,     "stupidedi/builder/states/interchange_state"
+    autoload :LoopState,            "stupidedi/builder/states/loop_state"
+    autoload :TableState,           "stupidedi/builder/states/table_state"
+    autoload :TransactionSetState,  "stupidedi/builder/states/transaction_set_state"
+    autoload :TransmissionState,    "stupidedi/builder/states/transmission_state"
+  end
+end

data/lib/stupidedi/color.rb

@@ -0,0 +1,93 @@
+module Stupidedi
+  module Color
+
+    def self.ansi
+      @__ansi ||=
+        if defined?(::Term::ANSIColor)
+          Wrapper.new(::Term::ANSIColor)
+        else
+          Wrapper.new(Stub)
+        end
+    end
+
+    def ansi
+      Color.ansi
+    end
+
+    # @private
+    module Stub
+      stubs = %w(bold clear reset dark underscore blink negative concealed
+                 black red green yellow blue magenta cyan white on_black
+                 on_red on_green on_yellow on_blue on_magenta on_cyan on_white)
+
+      stubs.each do |name|
+        instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{name}(string)
+            string
+          end
+        RUBY
+      end
+    end
+
+    class Wrapper
+      def initialize(base)
+        @base = base
+      end
+
+      def noop(string)
+        string
+      end
+
+      def invalid(string)
+        red(bold(string))
+      end
+
+      def element(string)
+        black(string)
+      end
+
+      def required(string)
+        bold(string)
+      end
+
+      def optional(string)
+        dark(white(string))
+      end
+
+      def forbidden(string)
+        noop(string)
+      end
+
+      def repeated(string)
+        black(string)
+      end
+
+      def composite(string)
+        black(string)
+      end
+
+      def segment(string)
+        magenta(string)
+      end
+
+      def loop(string)
+        yellow(string)
+      end
+
+      def table(string)
+        yellow(string)
+      end
+
+      def envelope(string)
+        yellow(string)
+      end
+
+    private
+
+      def method_missing(name, *args)
+        @base.__send__(name, *args)
+      end
+    end
+
+  end
+end

data/lib/stupidedi/config/code_list_config.rb

@@ -0,0 +1,42 @@
+module Stupidedi
+  class Config
+
+    class CodeListConfig
+      include Inspect
+
+      def initialize
+        @table = Hash.new
+      end
+
+      alias customize tap
+
+      def register(id, &constructor)
+        @table[id] = constructor
+      end
+
+      def defined_at?(id)
+        @table.defined_at?(id)
+      end
+
+      def at(id)
+        @table[id].call
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "CodeListConfig"
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @table.keys.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+  end
+end