tediparse 2.0.0

data/lib/stupidedi/transaction_sets/validation.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Stupidedi
+  module TransactionSets
+    module Validation
+      autoload :Ambiguity,      "stupidedi/transaction_sets/validation/ambiguity"
+      autoload :Implementation, "stupidedi/transaction_sets/validation/implementation"
+    end
+  end
+end

data/lib/stupidedi/transaction_sets.rb

@@ -0,0 +1,25 @@
+module Stupidedi
+  module TransactionSets
+    autoload :Builder,    "stupidedi/transaction_sets/builder"
+    autoload :Validation, "stupidedi/transaction_sets/validation"
+    autoload :Common,     "stupidedi/transaction_sets/common"
+
+    # Per-era transaction-set namespaces that lived under
+    # +Stupidedi::TransactionSets+ in the upstream stupidedi gem. tediparse
+    # does not ship them; reach for one by name and we surface a helpful
+    # error rather than +NameError+. Deeper guide names (X222A1, etc.) are
+    # nested under these eras, so catching at the era level is sufficient.
+    REMOVED_ERAS = %i[
+      TwoThousandOne ThirtyTen ThirtyForty ThirtyFifty FortyTen FiftyTen
+    ].freeze
+    private_constant :REMOVED_ERAS
+
+    def self.const_missing(name)
+      if REMOVED_ERAS.include?(name.to_sym)
+        raise Stupidedi::Exceptions::MissingGrammarError.new("#{self}::#{name}")
+      end
+
+      super
+    end
+  end
+end

data/lib/stupidedi/values/abstract_element_val.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class AbstractElementVal < AbstractVal
+      # (see AbstractVal#element?)
+      # @return true
+      def element?
+        true
+      end
+
+      # (see AbstractVal#size)
+      def size
+        0
+      end
+    end
+  end
+end

data/lib/stupidedi/values/abstract_val.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class AbstractVal
+      include Inspect
+      include Color
+
+      # @return [SimpleElementDef, CompositeElementDef, LoopDef, SegmentDef, TableDef]
+      abstract :definition
+
+      # @return [String]
+      abstract :descriptor
+
+      # @see X222.pdf B.1.3.10 Absence of Data
+      def empty?
+        @children.all?(&:empty?)
+      end
+
+      abstract :leaf?
+
+      # Number of segments in this subtree
+      #
+      # @return [Integer]
+      def size
+        @children.sum(&:size)
+      end
+
+      # True except for {InvalidSegmentVal} and {AbstractElementVal} values
+      # that could not be parsed -- "abc" in a numeric field, for example.
+      def valid?
+        true
+      end
+
+      def invalid?
+        not valid?
+      end
+
+      # Is the element not blank?
+      def present?
+        not empty?
+      end
+
+      # Is the element not present?
+      def blank?
+        empty?
+      end
+
+      # Is this a {TransmissionVal}?
+      def transmission?
+        false
+      end
+
+      # Is this an {InterchangeVal}?
+      def interchange?
+        false
+      end
+
+      # Is this an {FunctionalGroupVal}?
+      def functional_group?
+        false
+      end
+
+      # Is this an {TransactionSetVal}?
+      def transaction_set?
+        false
+      end
+
+      # Is this a {TableVal}?
+      def table?
+        false
+      end
+
+      # Is this a {LoopVal}?
+      def loop?
+        false
+      end
+
+      # Is this a {SegmentVal} or {InvalidSegmentVal}?
+      def segment?
+        false
+      end
+
+      # Is this a {AbstractElementVal}?
+      def element?
+        false
+      end
+
+      # Is this a {CompositeElementVal}?
+      def composite?
+        false
+      end
+
+      # Is this a component {SimpleElementVal}?
+      def component?
+        false
+      end
+
+      # Is this a repeated {AbstractElementVal}?
+      def repeated?
+        false
+      end
+
+      # Is this a non-component {SimpleElementVal}?
+      def simple?
+        false
+      end
+
+      # Is this a simple element that represents a separator (delimiter)? For
+      # instance, ISA16 represents the repetition separator in version 00501.
+      def separator?
+        false
+      end
+
+      # Returns the set of characters that are used as data in this subtree, not
+      # including the separator (delimiter) elements found in the ISA segment.
+      #
+      # @return [AbstractSet<String>]
+      def characters(result = Sets.absolute([], Reader::C_BYTES.split(//)))
+        if leaf?
+          if present? and not separator?
+            result | to_x12.split(//)
+          else
+            result
+          end
+        else
+          children.inject(result){|r,c| c.characters(r) }
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/values/composite_element_val.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X222.pdf B.1.1.3.3 Composite Data Structure
+    #
+    class CompositeElementVal < AbstractElementVal
+      # @return [Array<SimpleElementVal>]
+      attr_reader :children
+
+      alias component_vals children
+
+      # @return [CompositeElementUse]
+      attr_reader :usage
+
+      def_delegators :@usage, :definition, :descriptor
+
+      def initialize(children, usage)
+        @children, @usage =
+          children, usage
+      end
+
+      # @return [CompositeElementVal]
+      def copy(changes = {})
+        CompositeElementVal.new \
+          changes.fetch(:children, @children),
+          changes.fetch(:usage, @usage)
+      end
+
+      def position
+        if @children.present?
+          @children.head.position
+        else
+          # GH-194
+          "<position unknown>"
+        end
+      end
+
+      # @return false
+      def leaf?
+        false
+      end
+
+      # (see AbstractVal#composite?)
+      # @return true
+      def composite?
+        true
+      end
+
+      # @return [SimpleElementVal]
+      def element(n)
+        unless n > 0
+          raise ArgumentError,
+            "n must be positive"
+        end
+
+        @children.at(n - 1)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = definition.bind do |d|
+          "[#{d.id}: #{d.name}]".bind do |s|
+            if usage.forbidden?
+              ansi.forbidden(s)
+            elsif usage.required?
+              ansi.required(s)
+            else
+              ansi.optional(s)
+            end
+          end
+        end
+
+        q.text(ansi.composite("CompositeElementVal#{id}"))
+
+        if empty?
+          q.text(ansi.composite(".empty"))
+        else
+          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
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == definition and
+          other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/functional_group_val.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X222.pdf B.1.1.3.13 Functional Group
+    # @see X222.pdf B.1.1.4.2 Functional Groups
+    #
+    class FunctionalGroupVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [FunctionalGroupDef]
+      attr_reader :definition
+
+      def_delegators :definition, :descriptor
+
+      # @return [Array<SegmentVal, TransactionSetVal>]
+      attr_reader :children
+
+      def_delegators "@children.head", :position
+
+      def initialize(definition, children)
+        @definition, @children =
+          definition, children
+      end
+
+      # @return [FunctionalGroupVal]
+      def copy(changes = {})
+        FunctionalGroupVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children)
+      end
+
+      # (see AbstractVal#functional_group?)
+      # @return true
+      def functional_group?
+        true
+      end
+
+      # @return [String, nil]
+      def version
+        if at(6) == "X"
+          at(7).to_s.slice(0, 3)
+        end
+      end
+
+      # @return [String, nil]
+      def release
+        if at(6) == "X"
+          at(7).to_s.slice(0, 4)
+        end
+      end
+
+      # @return [String, nil]
+      def subrelease
+        if at(6) == "X"
+          at(7).to_s.slice(0, 5)
+        end
+      end
+
+      # @return [String, nil]
+      def implementation
+        if at(6) == "X"
+          at(7).to_s.slice(6, 4)
+        end
+      end
+
+      # @return [Module]
+      def segment_dict
+        @definition.segment_dict
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.id.to_s}]")
+        end
+
+        q.text(ansi.envelope("FunctionalGroupVal#{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
+
+      # @return [String]
+      def inspect
+        ansi.envelope("Group") + "(#{@children.map(&:inspect).join(", ")})"
+      end
+
+      def ==(other)
+        eql?(other) or
+          (other.definition == @definition or
+           other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/interchange_val.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X12-5.pdf 3.2.1 Basic Interchange Service Request
+    # @see X222.pdf B.1.1.4.1 Interchange Control Structures
+    #
+    class InterchangeVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [InterchangeDef]
+      attr_reader :definition
+
+      def_delegators :definition, :descriptor
+
+      # @return [Array<SegmentVal, FunctionalGroupVal>]
+      attr_reader :children
+
+      def_delegators "@children.head", :position
+
+      def initialize(definition, children, separators)
+        @definition, @children, @separators =
+          definition, children, separators
+      end
+
+      # @return [InterchangeVal]
+      def copy(changes = {})
+        InterchangeVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children),
+          changes.fetch(:separators, @separators)
+      end
+
+      # (see AbstractVal#interchange?)
+      # @return true
+      def interchange?
+        true
+      end
+
+      # @return [Module]
+      def segment_dict
+        @definition.segment_dict
+      end
+
+      # Note these will not contain the element and segment terminator, because
+      # those are not values stored as part of the interchange. Those values are
+      # stored in the state machine and can be retrieved by calling #separators
+      # on StateMachine
+      #
+      # @return [Reader::Separators]
+      def separators
+        @separators.merge(definition.separators(@children.find(&:segment?)))
+      end
+
+      # @return [InterchangeVal]
+      def replace_separators(replacement)
+        whole              = separators.merge(replacement)
+        head, (isa, *tail) = @children.split_when(&:segment?)
+
+        # replace ISA11 and ISA16 with given separators
+        isa = definition.replace_separators(isa, whole)
+
+        copy \
+          :children   => isa.snoc(head) + tail,
+          :separators => whole
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.id.to_s}]")
+        end
+
+        q.text(ansi.envelope("InterchangeVal#{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
+
+      # @return [String]
+      def inspect
+        ansi.envelope("Interchange") + "(#{@children.map(&:inspect).join(", ")})"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == @definition and
+          other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/invalid_envelope_val.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class InvalidEnvelopeVal < AbstractVal
+      # @return [Array<SegmentVal>]
+      attr_reader :children
+
+      def_delegators "@children.head", :descriptor, :position, :reason
+
+      def initialize(children)
+        @children = children
+      end
+
+      # @return [SegmentVal]
+      def copy(changes = {})
+        InvalidEnvelopeVal.new(changes.fetch(:children, @children))
+      end
+
+      # (see AbstractVal#size)
+      def size
+        0
+      end
+
+      # @return false
+      def leaf?
+        false
+      end
+
+      def valid?
+        false
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text(ansi.segment("InvalidEnvelopeVal"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.text @children.first.reason
+          q.text ","
+          q.breakable
+
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.invalid("InvalidEnvelopeVal") <<
+          "(#{@children.map(&:inspect).join(", ")})"
+      end
+    end
+  end
+end

data/lib/stupidedi/values/invalid_segment_val.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class InvalidSegmentVal < AbstractVal
+      # @return [String]
+      attr_reader :reason
+
+      # @return [Reader::SegmentTok]
+      attr_reader :segment_tok
+
+      def_delegators :@segment_tok, :position
+
+      def initialize(reason, segment_tok, separators)
+        @reason, @segment_tok, @separators =
+          reason, segment_tok, separators
+      end
+
+      # @return [SegmentVal]
+      def copy(changes = {})
+        InvalidSegmentVal.new \
+          changes.fetch(:reason, @reason),
+          changes.fetch(:segment_tok, @segment_tok),
+          changes.fetch(:separators, @separators)
+      end
+
+      # @return [String]
+      def descriptor
+        "segment #{@segment_tok.to_x12(@separators)} #{@reason}"
+      end
+
+      # (see AbstractVal#size)
+      def size
+        0
+      end
+
+      # @return [Symbol]
+      def id
+        @segment_tok.id
+      end
+
+      # @return true
+      def leaf?
+        true
+      end
+
+      def valid?
+        false
+      end
+
+      # (see AbstractVal#segment?)
+      # @return true
+      def segment?
+        true
+      end
+
+      def empty?
+        true
+      end
+
+      # @return nil
+      def usage
+        nil
+      end
+
+      # @return nul
+      def definition
+        nil
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = ansi.invalid("[#{@segment_tok.to_x12(@separators)}]")
+        q.text(ansi.segment("InvalidSegmentVal#{id}"))
+      end
+
+      # @return [String]
+      def inspect
+        ansi.invalid(@segment_tok.id.to_s)
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other)
+      end
+    end
+  end
+end