stupidedi 1.2.20 → 1.4.1

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

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  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

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  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!
-            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"
-          element_uses.zip(elements) do |e_use, (e_tag, e_val, e_position)|
-            # element_idx.succ!
-            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.succ!
-          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/contrib/002001.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  module Contrib
-    module TwoThousandOne
-
-      autoload :Guides,
-        "stupidedi/contrib/002001/guides"
-
-      autoload :TransactionSetDefs,
-        "stupidedi/contrib/002001/transaction_set_defs"
-
-    end
-  end
-end

data/lib/stupidedi/contrib/002001/guides.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  module Contrib
-    module TwoThousandOne
-      module Guides
-
-        # GuideBuilder = Stupidedi::Guides::TwoThousandOne::GuideBuilder
-        # SegmentReqs  = Stupidedi::Guides::TwoThousandOne::SegmentReqs
-        # ElementReqs  = Stupidedi::Guides::TwoThousandOne::ElementReqs
-
-        GuideBuilder = Stupidedi::Guides::FortyTen::GuideBuilder
-        SegmentReqs  = Stupidedi::Guides::FortyTen::SegmentReqs
-        ElementReqs  = Stupidedi::Guides::FortyTen::ElementReqs
-
-        autoload :SH856, "stupidedi/contrib/002001/guides/SH856"
-        autoload :PO830, "stupidedi/contrib/002001/guides/PO830"
-        autoload :FA997, "stupidedi/contrib/002001/guides/FA997"
-      end
-    end
-  end
-end

data/lib/stupidedi/contrib/002001/guides/FA997.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  module Contrib
-    module TwoThousandOne
-      module Guides
-
-        b = GuideBuilder
-        d = Schema
-        r = SegmentReqs
-        e = ElementReqs
-        s = Versions::FunctionalGroups::TwoThousandOne::SegmentDefs
-        t = Contrib::TwoThousandOne::TransactionSetDefs
-
-        #
-        # Response to a Load Tender
-        #
-        FA997 = b.build(t::FA997,
-          d::TableDef.header("Heading",
-            b::Segment(10, s::ST, "Transaction Set Header",
-              r::Required, d::RepeatCount.bounded(1),
-              b::Element(e::Required,    "Transaction Set Identifier Code"),
-              b::Element(e::Required,    "Transaction Set Control Number")),
-
-            b::Segment(20, s::AK1, "Functional Group Response Header",
-              r::Required, d::RepeatCount.bounded(1),
-              b::Element(e::Situational, "Functional Identifier Code"),
-              b::Element(e::Required,    "Group Control Number")),
-
-            d::LoopDef.build("AK2", d::RepeatCount.bounded(999999),
-              b::Segment(30, s::AK2, "Transaction Set Response Header",
-                r::Situational, d::RepeatCount.bounded(1),
-                b::Element(e::Required,    "Transaction Set Identifier Code"),
-                b::Element(e::Required,    "Transaction Set Control Number")),
-
-              d::LoopDef.build("AK3", d::RepeatCount.bounded(999999),
-                b::Segment( 40, s::AK3, "Data Segment Note",
-                  r::Situational, d::RepeatCount.bounded(1),
-                  b::Element(e::Required,    "Segment ID Code"),
-                  b::Element(e::Required,    "Segment Position in Transaction Set"),
-                  b::Element(e::Situational, "Loop Identifier Code"),
-                  b::Element(e::Situational, "Segment Syntax Error Code")),
-
-                b::Segment( 50, s::AK4, "Data Element Note",
-                  r::Situational, d::RepeatCount.bounded(99),
-                  b::Element(e::Required,    "Position in Segment",
-                      b::Element(e::Required,    "Element Position in Segment"),
-                      b::Element(e::Situational, "Component Data Element Position in Composite")),
-                  b::Element(e::Situational, "Data Element Reference Number"),
-                  b::Element(e::Required,    "Data Element Syntax Error Code"),
-                  b::Element(e::Situational, "Copy of Bad Data Element"))),
-
-              b::Segment( 60, s::AK5, "Transaction Set Response Trailer",
-                r::Required, d::RepeatCount.bounded(1),
-                b::Element(e::Required,    "Transaction Set Acknowledgment Code"),
-                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
-                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
-                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
-                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
-                b::Element(e::Situational, "Transaction Set Syntax Error Code"))),
-
-            b::Segment( 70, s::AK9, "Functional Group Response Trailer",
-              r::Required, d::RepeatCount.bounded(1),
-              b::Element(e::Required,    "Functional Group Acknowledge Code"),
-              b::Element(e::Required,    "Number of Transaction Sets Included"),
-              b::Element(e::Required,    "Number of Received Transaction Sets"),
-              b::Element(e::Required,    "Number of Accepted Transaction Sets"),
-              b::Element(e::Situational, "Functional Group Syntax Error Code"),
-              b::Element(e::Situational, "Functional Group Syntax Error Code"),
-              b::Element(e::Situational, "Functional Group Syntax Error Code"),
-              b::Element(e::Situational, "Functional Group Syntax Error Code"),
-              b::Element(e::Situational, "Functional Group Syntax Error Code")),
-
-            b::Segment( 80, s::SE, "Transaction Set Trailer",
-              r::Required, d::RepeatCount.bounded(1),
-              b::Element(e::Required,    "Number of Included Segments"),
-              b::Element(e::Required,    "Transaction Set Control Number"))))
-
-      end
-    end
-  end
-end