stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/interchanges/00501/segment_defs/TA1.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Interchanges
+    module FiveOhOne
+      module SegmentDefs
+        s = Schema
+        e = ElementDefs
+        r = ElementReqs
+
+        TA1 = s::SegmentDef.build(:TA1, "Interchange Acknowledgement",
+          "",
+          e::I12.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+          e::I08.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+          e::I09.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+          e::I17.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+          e::I18.simple_use(r::Mandatory, s::RepeatCount.bounded(1)))
+      end
+    end
+  end
+end

data/lib/stupidedi/interchanges/00501/segment_defs/TA3.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Interchanges
+    module FiveOhOne
+      module SegmentDefs
+        s = Schema
+        e = ElementDefs
+        r = ElementReqs
+
+        # @todo
+        TA3 = s::SegmentDef.build(:TA3, "Interchange Delivery Notice", "")
+      end
+    end
+  end
+end

data/lib/stupidedi/interchanges/element_types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Interchanges
+    module ElementTypes
+      autoload :SpecialAN,    "stupidedi/interchanges/element_types/special_val"
+      autoload :SpecialVal,   "stupidedi/interchanges/element_types/special_val"
+      autoload :Separator,    "stupidedi/interchanges/element_types/separator_val"
+      autoload :SeparatorVal, "stupidedi/interchanges/element_types/separator_val"
+    end
+  end
+end

data/lib/stupidedi/interchanges/element_types/separator_val.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Interchanges
+    module ElementTypes
+      class Separator < Versions::Common::ElementTypes::AN
+        def companion
+          SeparatorVal
+        end
+      end
+
+      class SeparatorVal < Values::SimpleElementVal
+        def_delegators :@value, :to_s, :length, :==
+
+        def initialize(value, usage, position)
+          @value = value
+          super(usage, position)
+        end
+
+        # @return [SeparatorVal]
+        def copy(changes = {})
+          SeparatorVal.new \
+            changes.fetch(:value, @value),
+            changes.fetch(:usage, usage),
+            changes.fetch(:position, position)
+        end
+
+        def valid?
+          true
+        end
+
+        def empty?
+          @value.blank?
+        end
+
+        def too_short?
+          @value.length < 1
+        end
+
+        def too_long?
+          @value.length > 1
+        end
+
+        def separator?
+          true
+        end
+
+        # @return [String]
+        def to_x12(truncate = true)
+          @value.to_s
+        end
+
+        def inspect
+          id = definition.try{|d| ansi.bold("[#{d.id}]") }
+          ansi.element("SeparatorVal.value#{id}") + "(#{@value || "nil"})"
+        end
+      end
+
+      class << SeparatorVal
+        # @group Constructors
+        ###################################################################
+
+        # @raise NoMethodError
+        def empty(usage, position)
+          SeparatorVal.new(nil, usage, position)
+        end
+
+        # @return [SeparatorVal]
+        def value(character, usage, position)
+          SeparatorVal.new(character, usage, position)
+        end
+
+        # @endgroup
+        ###################################################################
+      end
+    end
+  end
+end

data/lib/stupidedi/interchanges/element_types/special_val.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Interchanges
+    module ElementTypes
+      AN        = Versions::Common::ElementTypes::AN
+      StringVal = Versions::Common::ElementTypes::StringVal
+
+      #
+      # The specifications declare ISA02 and ISA04 are required elements, but
+      # they only have "meaningful information" when ISA01 and ISA03 qualifiers
+      # aren't "00".
+      #
+      # Without specifications regarding what should be entered in these
+      # required elements, our best option is to defer to convention, which
+      # seems to be that these elements should have 10 spaces -- which means
+      # they're blank. So we can't really make these elements required! Even
+      # stupider, these are the only blank elements that should be written out
+      # space-padded to the min_length -- every other element should be
+      # collapsed to an empty string.
+      #
+      # So this "Special" class overrides to_x12 for empty values, but it
+      # otherwise looks and acts like a normal AN and StringVal
+      #
+      class SpecialAN < AN
+        def companion
+          SpecialVal
+        end
+      end
+
+      class SpecialVal < StringVal
+        class Empty < StringVal::Empty
+          # @return [String]
+          def to_x12
+            " " * definition.min_length
+          end
+        end
+
+        class NonEmpty < StringVal::NonEmpty
+          def too_short?
+            false
+          end
+        end
+      end
+    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

data/lib/stupidedi/parser/builder_dsl.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class BuilderDsl
+      include Inspect
+      include Tokenization
+
+      # @private
+      SEGMENT_ID = /^[A-Z][A-Z0-9]{1,2}$/
+
+      # @return [StateMachine]
+      attr_reader :machine
+
+      # @return [Boolean]
+      attr_writer :strict
+
+      # @return [DslReader]
+      attr_reader :reader
+
+      def_delegators :@machine, :pretty_print, :segment, :element, :zipper, :successors, :empty?, :first?, :last?, :deterministic?
+
+      def initialize(machine, strict = true)
+        @machine = machine
+        @strict  = strict
+        @reader  = DslReader.new(Reader::Separators.empty,
+                                 Reader::SegmentDict.empty)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        SEGMENT_ID =~ name.to_s || super
+      end
+
+      def strict?
+        @strict
+      end
+
+      # @return [BuilderDsl]
+      def segment!(name, position, *elements)
+        segment_tok     = mksegment_tok(@reader.segment_dict, name, elements, position)
+        machine, reader = @machine.insert(segment_tok, @strict, @reader)
+
+        if @strict
+          unless machine.deterministic?
+            matches = machine.active.map do |m|
+              segment_def = m.node.zipper.node.definition
+              "#{segment_def.id} #{segment_def.name}"
+            end.join(", ")
+
+            raise Exceptions::ParseError,
+              "non-deterministic machine state: #{matches}"
+          end
+
+          # Validate the new segment (recursively, including its children)
+          machine.active.each{|m| critique(m.node.zipper) }
+
+          # We want to detect when we've ended a syntax node (or more), like
+          # starting a new interchange will end all previously "open" syntax
+          # nodes. So we compare the state before adding `segment_tok` to the
+          # corresponding state after we've added `segment_tok`.
+
+          machine.prev.tap do |prev|
+            prev.active.zip(machine.active) do |p, q|
+              # If the new state `q` is a descendent of `p`, we know that `p`
+              # and all of its ancestors are unterminated. However, if `q` is
+              # not a descendent of `p`, but is a descendent of one of `p`s
+              # descendents, then `p` and perhaps some of its ancestors were
+              # terminated when the state transitioned to `q`.
+              qancestors = Set.new
+
+              # Operate on the syntax tree (instead of the state tree)
+              q = q.node.zipper
+              p = p.node.zipper
+
+              while q.respond_to?(:parent)
+                qancestors << q.parent
+                q = q.parent
+              end
+
+              while p.respond_to?(:parent)
+                break if qancestors.include?(p)
+
+                # Now that we're sure that this syntax node (loop, table, etc)
+                # is done being constructed, we can perform more validations.
+                critique(p)
+                p = p.parent
+              end
+            end
+          end
+        end
+
+        @machine = machine
+        @reader  = reader
+
+        self
+      end
+
+    private
+
+      def method_missing(name, *args)
+        if SEGMENT_ID =~ name.to_s
+          segment!(name, Reader::Position.caller(2), *args)
+        else
+          super
+        end
+      end
+
+      # The `zipper` argument should be a _completed_ syntax node, meaning all
+      # children have already been added. This is invariably true for segments,
+      # because the {StateMachine} does not accept smaller units of syntax.
+      def critique(zipper, recursive = false, position = false)
+        if zipper.node.simple? or zipper.node.component?
+          if zipper.node.invalid?
+            raise Exceptions::ParseError,
+              "invalid #{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+          elsif zipper.node.blank?
+            if zipper.node.usage.required?
+              raise Exceptions::ParseError,
+                "required #{zipper.node.descriptor} is blank at #{zipper.node.position.inspect}"
+            end
+          elsif zipper.node.usage.forbidden?
+            raise Exceptions::ParseError,
+              "forbidden #{zipper.node.descriptor} is present at #{zipper.node.position.inspect}"
+          elsif not zipper.node.allowed?
+            raise Exceptions::ParseError,
+              "value #{zipper.node.to_s} is not allowed in #{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+          elsif zipper.node.too_long?
+            raise Exceptions::ParseError,
+              "value is too long in #{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+          elsif zipper.node.too_short?
+            raise Exceptions::ParseError,
+              "value is too short in #{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+          end
+
+        elsif zipper.node.composite?
+          if zipper.node.blank?
+            if zipper.node.usage.required?
+              # GH-194: Normally the position of a composit element is the
+              # position of it's first child; but an empty composit element
+              # doesn't have children. So the closest position is of the parent
+              raise Exceptions::ParseError,
+                "required #{zipper.node.descriptor} is blank at #{zipper.parent.node.position.inspect}"
+            end
+          elsif zipper.node.usage.forbidden?
+            raise Exceptions::ParseError,
+              "forbidden #{zipper.node.descriptor} is present at #{zipper.node.position.inspect}"
+          else
+            if zipper.node.present?
+              zipper.children.each_with_index do |z, i|
+                critique(z)
+              end
+
+              d = zipper.node.definition
+              d.syntax_notes.each do |s|
+                unless s.satisfied?(zipper)
+                  raise Exceptions::ParseError,
+                    "for #{zipper.node.descriptor}, #{s.reason(zipper)} at #{zipper.node.position.inspect}"
+                end
+              end
+            end
+          end
+
+        elsif zipper.node.repeated?
+          unless zipper.node.usage.repeat_count.include?(zipper.node.children.length)
+            raise Exceptions::ParseError,
+              "repeating #{zipper.node.descriptor} occurs too many times at #{zipper.node.position.inspect}"
+          end
+
+          zipper.children.each{|z| critique(z) }
+
+        elsif zipper.node.segment?
+          if zipper.node.invalid?
+            if zipper.up.node.invalid?
+              # parent is an InvalidEnvelopeVal
+              raise Exceptions::ParseError,
+                "#{zipper.first.node.reason} at #{zipper.first.node.position.inspect}"
+            else
+              raise Exceptions::ParseError,
+                "#{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+            end
+          else
+            zipper.children.each_with_index do |z, i|
+              critique(z)
+            end
+
+            d = zipper.node.definition
+            d.syntax_notes.each do |s|
+              raise Exceptions::ParseError,
+                "for #{zipper.node.descriptor}, #{s.reason(zipper)} at #{zipper.node.position.inspect}" \
+                unless s.satisfied?(zipper)
+            end
+          end
+
+        elsif zipper.node.loop?
+          critique_occurences zipper, recursive
+
+        elsif zipper.node.table?
+          critique_occurences zipper, recursive
+
+        elsif zipper.node.transaction_set?
+          critique_occurences zipper, recursive
+
+        elsif zipper.node.functional_group?
+          critique_occurences zipper, recursive
+
+        elsif zipper.node.interchange?
+          critique_occurences zipper, recursive
+
+        elsif zipper.node.transmission?
+          if recursive
+            zipper.children.each_with_index do |z, i|
+              critique(z, recursive)
+            end
+          end
+        end
+      end
+
+      def critique_occurences(zipper, recursive)
+        occurences = Hash.new{|h,k| h[k] = 0 }
+
+        zipper.children.each do |child|
+          if child.node.respond_to?(:usage)
+            occurences[child.node.usage] += 1
+          elsif child.node.invalid?
+            raise Exceptions::ParseError,
+              "#{child.node.descriptor} at #{child.node.position.inspect}"
+          else
+            occurences[child.node.definition] += 1
+          end
+
+          if recursive
+            critique(child, "", recursive)
+          end
+        end
+
+        zipper.node.definition.children.each do |child|
+          bound = child.repeat_count
+          count = occurences.at(child)
+
+          if count.zero? and child.required?
+            raise Exceptions::ParseError,
+              "required #{child.descriptor} is missing from #{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+          elsif bound < count
+            raise Exceptions::ParseError,
+              "#{child.descriptor} occurs too many times in #{zipper.node.descriptor} at #{zipper.node.position.inspect}"
+          end
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+    class << BuilderDsl
+      # @group Constructors
+      #########################################################################
+
+      # @return [BuilderDsl]
+      def build(config, strict = true)
+        new(StateMachine.build(config), strict)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+    # @private
+    class DslReader
+      # @return [Reader::Separators]
+      attr_reader :separators
+
+      # @return [Reader::SegmentDict]
+      attr_reader :segment_dict
+
+      def initialize(separators, segment_dict)
+        @separators, @segment_dict = separators, segment_dict
+      end
+
+      # @return [DslReader]
+      def copy(changes = {})
+        @separators   = changes.fetch(:separators, @separators)
+        @segment_dict = changes.fetch(:segment_dict, @segment_dict)
+        self
+      end
+
+      def stream?
+        false
+      end
+    end
+  end
+end