tediparse 2.0.0

data/lib/stupidedi/either.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  class Either
+    # @return [Boolean]
+    abstract :defined?
+
+    ###########################################################################
+    # @group Filtering the Value
+
+    # @return [Either]
+    abstract :select, :args => %w(reason='select' &block)
+
+    # @return [Either]
+    abstract :reject, :args => %w(reason='reject' &block)
+
+    # @endgroup
+    ###########################################################################
+
+    ###########################################################################
+    # @group Transforming the Value
+
+    # @return [Either]
+    abstract :map, :args => %w(&block)
+
+    # @return [Either]
+    abstract :flatmap, :args => %w(&block)
+
+    # @return [Either]
+    abstract :or, :args => %w(&block)
+
+    # @return [Either]
+    abstract :explain, :args => %w(&block)
+
+    # @return [Object]
+    abstract :fetch, :args => %w(default)
+
+    # @endgroup
+    ###########################################################################
+
+    class Success < Either
+      def initialize(value)
+        @value = value
+      end
+
+      def copy(changes = {})
+        Success.new \
+          changes.fetch(:value, @value)
+      end
+
+      # @return true
+      def defined?
+        true
+      end
+
+      def fetch(default = nil)
+        @value
+      end
+
+      #########################################################################
+      # @group Filtering the Value
+
+      # @return [Either]
+      # @yieldparam value
+      # @yieldreturn [Boolean]
+      def select(reason = "select", &block)
+        if deconstruct(block)
+          self
+        else
+          failure(reason)
+        end
+      end
+
+      # @return [Either]
+      # @yieldparam value
+      # @yieldreturn [Boolean]
+      def reject(reason = "reject", &block)
+        if deconstruct(block)
+          failure(reason)
+        else
+          self
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+
+      #########################################################################
+      # @group Transforming the Value
+
+      # @return [Success]
+      # @yieldparam value
+      # @yieldreturn value
+      def map(&block)
+        copy(:value => deconstruct(block))
+      end
+
+      # @return [Either]
+      # @yieldparam value
+      # @yieldreturn [Either]
+      def flatmap(&block)
+        result = deconstruct(block)
+
+        if result.is_a?(Either)
+          result
+        else
+          raise TypeError, "block did not return an instance of Either"
+        end
+      end
+
+      # @return [Success]
+      def or
+        self
+      end
+
+      # @return [Success]
+      def explain
+        self
+      end
+
+      # @endgroup
+      #########################################################################
+
+      def tap(&block)
+        deconstruct(block); self
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(self.class) and other.select{|x| x == @value }.defined?
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("Either.success")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @value
+        end
+      end
+
+      # @return [String]
+      def inspect
+        "Either.success(#{@value.inspect})"
+      end
+
+    private
+
+      def deconstruct(block)
+        block.call(@value)
+      end
+
+      def failure(reason)
+        Either::Failure.new(reason)
+      end
+    end
+
+    class Failure < Either
+      attr_reader :reason
+
+      def initialize(reason)
+        @reason = reason
+      end
+
+      # @return [Failure]
+      def copy(changes = {})
+        Failure.new \
+          changes.fetch(:reason, @reason)
+      end
+
+      # @return false
+      def defined?
+        false
+      end
+
+      def fetch(default = nil)
+        default
+      end
+
+      #########################################################################
+      # @group Filtering the Value
+
+      # @return [Failure]
+      def select(reason = nil)
+        self
+      end
+
+      # @return [Failure]
+      def reject(reason = nil)
+        self
+      end
+
+      # @endgroup
+      #########################################################################
+
+      #########################################################################
+      # @group Transforming the Value
+
+      # @return [Failure]
+      def map
+        self
+      end
+
+      # @return [Failure]
+      def flatmap
+        self
+      end
+
+      # @return [Either]
+      # @yieldparam reason
+      # @yieldreturn [Either]
+      def or(&block)
+        result = deconstruct(block)
+
+        if result.is_a?(Either)
+          result
+        else
+          raise TypeError, "block did not return an instance of Either"
+        end
+      end
+
+      # @return [Failure]
+      # @yieldparam reason
+      # @yieldreturn reason
+      def explain(&block)
+        copy(:reason => deconstruct(block))
+      end
+
+      # @endgroup
+      #########################################################################
+
+      def tap
+        self
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(self.class) and other.reason == @reason
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("Either.failure")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @reason
+        end
+      end
+
+      # @return [String]
+      def inspect
+        "Either.failure(#{@reason.inspect})"
+      end
+
+    private
+
+      def deconstruct(block)
+        block.call(@reason)
+      end
+    end
+  end
+
+  class << Either
+    ###########################################################################
+    # @group Constructors
+
+    # @return [Success]
+    def success(value)
+      Either::Success.new(value)
+    end
+
+    # @return [Failure]
+    def failure(reason)
+      Either::Failure.new(reason)
+    end
+
+    # @endgroup
+    ###########################################################################
+  end
+
+  Either.eigenclass.send(:protected, :new)
+  Either::Success.eigenclass.send(:public, :new)
+  Either::Failure.eigenclass.send(:public, :new)
+
+end

data/lib/stupidedi/exceptions/invalid_element_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class InvalidElementError < StupidediError
+    end
+  end
+end

data/lib/stupidedi/exceptions/invalid_schema_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class InvalidSchemaError < StupidediError
+    end
+  end
+end

data/lib/stupidedi/exceptions/missing_grammar_error.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    #
+    # Raised when application code reaches for a grammar that tediparse does
+    # not ship. tediparse is the parser/writer engine only; transaction-set
+    # grammars, code lists, and implementation guides are not bundled (they
+    # are X12 IP). Users must register their own grammar against
+    # +Stupidedi::Config+ before parsing.
+    #
+    # Three places raise this:
+    #
+    # 1. +Stupidedi::Interchanges.const_missing+,
+    #    +Stupidedi::Versions.const_missing+, and
+    #    +Stupidedi::TransactionSets.const_missing+ raise it when application
+    #    code references a per-era constant by name
+    #    (e.g. +Stupidedi::Versions::FiftyTen+).
+    #
+    # 2. The three envelope parser states (+InterchangeState+,
+    #    +FunctionalGroupState+, +TransactionSetState+) surface this message
+    #    as the +reason+ on +InvalidSegmentVal+ when the relevant config
+    #    sub-registry is empty. The parser itself does not raise — it
+    #    produces a +FailureState+ — but the message is the same so users
+    #    see one consistent UX whether they hit a bare +const_missing+ or a
+    #    parse failure.
+    #
+    class MissingGrammarError < StupidediError
+      DEFAULT_MESSAGE =
+        "tediparse does not ship with X12 grammars or transaction-set " \
+        "definitions. Register your own grammar against Stupidedi::Config " \
+        "before parsing — see the README for an authoring example."
+
+      # @param context [String, nil]
+      #   When given, appended to the default message as " (while resolving
+      #   <context>)". Used by the +const_missing+ hooks to name the
+      #   per-era constant the caller reached for; left nil at parser-state
+      #   callsites where no constant name is in play.
+      def initialize(context = nil)
+        message =
+          if context
+            "#{DEFAULT_MESSAGE} (while resolving #{context})"
+          else
+            DEFAULT_MESSAGE
+          end
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/stupidedi/exceptions/output_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class OutputError < StupidediError
+    end
+  end
+end

data/lib/stupidedi/exceptions/parse_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class ParseError < StupidediError
+    end
+  end
+end

data/lib/stupidedi/exceptions/stupidedi_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class StupidediError < StandardError
+    end
+  end
+end

data/lib/stupidedi/exceptions/tokenize_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class TokenizeError < StupidediError
+    end
+  end
+end

data/lib/stupidedi/exceptions/zipper_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    class ZipperError < StupidediError
+    end
+  end
+end

data/lib/stupidedi/exceptions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Exceptions
+    autoload :StupidediError,         "stupidedi/exceptions/stupidedi_error"
+    autoload :InvalidElementError,    "stupidedi/exceptions/invalid_element_error"
+    autoload :InvalidSchemaError,     "stupidedi/exceptions/invalid_schema_error"
+    autoload :MissingGrammarError,    "stupidedi/exceptions/missing_grammar_error"
+    autoload :OutputError,            "stupidedi/exceptions/output_error"
+    autoload :ParseError,             "stupidedi/exceptions/parse_error"
+    autoload :TokenizeError,          "stupidedi/exceptions/tokenize_error"
+    autoload :ZipperError,            "stupidedi/exceptions/zipper_error"
+  end
+end

data/lib/stupidedi/inspect.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  #
+  # When an exception is raised, in some cases `#inspect` is called on a
+  # huge object graph to generate the message `"undefined method '...' for
+  # <Stupidedi::Schema::TransactionSetDef:0x...>"`. This can take several
+  # seconds, since `Object#inspect` descends recursively into each instance
+  # variable.
+  #
+  # This mixin defines an alternative default implementation for `#inspect`,
+  # which should be significantly faster than the default Ruby implementation
+  # since it does not descend into the object.
+  #
+  module Inspect
+    # @return [String]
+    def inspect
+      if self.class.name.nil? or self.class.name !~ /\S/
+        "#<\#<Class:0x#{self.class.object_id.abs.to_s(16)}>"
+      else
+        "#<#{self.class.name}"
+      end + ":0x#{object_id.abs.to_s(16)} ...>"
+    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/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.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Interchanges
+    autoload :ElementTypes, "stupidedi/interchanges/element_types"
+
+    # Per-era envelope namespaces that lived under +Stupidedi::Interchanges+
+    # in the upstream stupidedi gem. tediparse does not ship them; if user
+    # code references one by name we surface a helpful error rather than the
+    # bare +NameError+ Ruby would raise for an undefined constant.
+    REMOVED_ERAS = %i[TwoHundred ThreeHundred FourHundred FourOhOne FiveOhOne].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