tediparse 2.0.0

data/lib/stupidedi/color.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  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
+      METHODS = %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)
+
+      METHODS.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,45 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  class Config
+    class CodeListConfig
+      include Inspect
+
+      def initialize
+        @table = Hash.new
+      end
+
+      def customize(&block)
+        tap(&block)
+      end
+
+      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

data/lib/stupidedi/config/functional_group_config.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  class Config
+    #
+    # The functional group segments (GS/GE) and the segments contained by that
+    # functional group are versioned separately from the interchange control
+    # segments (ISA/ISE). The functional group version is informally referred to
+    # as the EDI version (5010, 4010, etc). Each version indicates the segment
+    # dictionary being used and the grammar of the functional group. Only the GS
+    # and GE segments are described in the HIPAA guides, but the functional
+    # group header and footer may consist of other segments.
+    #
+    # Because the interchange and functional group are versioned independently,
+    # it may be possible, for instance, to send a 4010 transaction set within a
+    # 5010 envelope, depending on forward- and backward-comatibility.
+    #
+    # @see http://x12.org/rfis/ "Relations Between the ISA and GS Segments.PDF"
+    #
+    class FunctionalGroupConfig
+      include Inspect
+
+      # @return [Hash<String, FunctionalGroupDef>]
+      attr_reader :table
+
+      def_delegators :@table, :defined_at?, :empty?
+
+      def initialize
+        @table = Hash.new
+      end
+
+      def customize(&block)
+        tap(&block)
+      end
+
+      # @return [void]
+      def register(version, definition = nil, &constructor)
+        if block_given?
+          @table[version] = constructor
+        elsif definition.nil?
+          raise ArgumentError,
+            "FunctionalGroupConfig#register(#{version.inspect}) was called " \
+            "with no definition and no block"
+        else
+          @table[version] = definition
+        end
+      end
+
+      # @return [FunctionalGroupDef]
+      def at(version)
+        x = @table[version]
+        x.is_a?(Proc) ? x.call : x
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "FunctionalGroupConfig"
+        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

data/lib/stupidedi/config/interchange_config.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  class Config
+    #
+    # The interchange control segments (ISA/ISE) are versioned independently
+    # from the functional group segments (GS/GE). Because different interchange
+    # versions can have unique grammars, this table serves as an indirection.
+    #
+    # Opinion: The interchange version is encoded within the ISA segment, whose
+    # definition is recursively dependent on the interchange version. Worse yet,
+    # the version is encoded as the fourteenth element (in versions 00501 and
+    # 00401), instead of say, the 1st element.
+    #
+    # This seems to indicate the versioning was an afterthought. The same
+    # thought process was applied when versioning the functional group segments,
+    # which has the version encoded in GS08.
+    #
+    # The best we can do to cope with this is to presume the ISA and GS segments
+    # have an underlying grammar that won't change between versions. We do this
+    # by parsing 12 things following "ISA", using the 12th thing as the version
+    # number, and then starting over at "ISA" and parsing with actual grammar.
+    # Then the grammar can specify which elements specify delimiters and all the
+    # other parts of the interchange header, like the TA1 segment.
+    #
+    # @see http://x12.org/rfis/ "Relations Between the ISA and GS Segments.PDF"
+    #
+    class InterchangeConfig
+      include Inspect
+
+      # @return [Hash<String, InterchangeDef>]
+      attr_reader :table
+
+      def_delegators :@table, :defined_at?, :empty?
+
+      def initialize
+        @table = Hash.new
+      end
+
+      def customize(&block)
+        tap(&block)
+      end
+
+      #
+      # @example
+      #   table = InterchangeConfig.new
+      #
+      #   table.register("DEMO01") { MyApp::Envelopes::Demo }
+      #
+      # @return [void]
+      def register(version, definition = nil, &constructor)
+        if block_given?
+          @table[version] = constructor
+        elsif definition.nil?
+          raise ArgumentError,
+            "InterchangeConfig#register(#{version.inspect}) was called " \
+            "with no definition and no block"
+        else
+          @table[version] = definition
+        end
+      end
+
+      # @return [InterchangeDef]
+      def at(version)
+        x = @table[version]
+        x.is_a?(Proc) ? x.call : x
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "InterchangeConfig"
+        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

data/lib/stupidedi/config/transaction_set_config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  class Config
+    #
+    # The implementation version specified in GS08 (or ST03) indicates which
+    # implementation guide governs the transaction.
+    #
+    # Note we can't look only at ST01 to link "837" to our definition of
+    # 837P from the HIPAA guide without also considering "005010X222", because
+    # thereare several different "837"s (including "005010X223", etc)
+    #
+    class TransactionSetConfig
+      include Inspect
+
+      # @return [Hash<[GS08/ST03, GS01, ST01], TransactionSetDef>]
+      attr_reader :table
+
+      def initialize
+        @table = Hash.new
+      end
+
+      def customize(&block)
+        tap(&block)
+      end
+
+      # @return [void]
+      def register(gs08, gs01, st01, definition = nil, &constructor)
+        if block_given?
+          @table[Array[gs08, gs01, st01]] = constructor
+        elsif definition.nil?
+          raise ArgumentError,
+            "TransactionSetConfig#register(#{gs08.inspect}, #{gs01.inspect}, " \
+            "#{st01.inspect}) was called with no definition and no block"
+        else
+          @table[Array[gs08, gs01, st01]] = definition
+        end
+      end
+
+      # @return [TransactionSetDef]
+      def at(gs08, gs01, st01)
+        x = @table[Array[gs08, gs01, st01]]
+        x.is_a?(Proc) ? x.call : x
+      end
+
+      def defined_at?(gs08, gs01, st01)
+        @table.defined_at?([gs08, gs01, st01])
+      end
+
+      def empty?
+        @table.empty?
+      end
+
+      # @return [void]
+      # :nocov:
+      def pretty_print(q)
+        q.text "TransactionSetConfig"
+        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
+      # :nocov:
+    end
+  end
+end

data/lib/stupidedi/config.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  class Config
+    autoload :CodeListConfig,         "stupidedi/config/code_list_config"
+    autoload :FunctionalGroupConfig,  "stupidedi/config/functional_group_config"
+    autoload :InterchangeConfig,      "stupidedi/config/interchange_config"
+    autoload :TransactionSetConfig,   "stupidedi/config/transaction_set_config"
+
+    include Inspect
+
+    # @return [InterchangeConfig]
+    attr_reader :interchange
+
+    # @return [FunctionalGroupConfig]
+    attr_reader :functional_group
+
+    # @return [TransactionSetConfig]
+    attr_reader :transaction_set
+
+    # @return [CodeListConfig]
+    attr_reader :code_list
+
+    def initialize
+      @interchange      = InterchangeConfig.new
+      @functional_group = FunctionalGroupConfig.new
+      @transaction_set  = TransactionSetConfig.new
+      @code_list        = CodeListConfig.new
+    end
+
+    def customize(&block)
+      tap(&block)
+    end
+
+    # @return [void]
+    def pretty_print(q)
+      q.text "Config"
+      q.group 2, "(", ")" do
+        q.breakable ""
+
+        q.pp @interchange
+        q.text ","
+        q.breakable
+
+        q.pp @functional_group
+        q.text ","
+        q.breakable
+
+        q.pp @transaction_set
+        q.text ","
+        q.breakable
+
+        q.pp @code_list
+      end
+    end
+  end
+
+  class << Config
+    ###########################################################################
+    # @group Constructors
+
+    # Returns an empty Config.
+    #
+    # tediparse does not ship with X12 grammars or transaction-set definitions
+    # — those are X12 IP that the gem is not licensed to redistribute. This
+    # method is preserved for source compatibility with upstream stupidedi
+    # callers; an empty Config means parser-driven lookups produce a
+    # FailureState whose reason is
+    # +Stupidedi::Exceptions::MissingGrammarError::DEFAULT_MESSAGE+.
+    #
+    # Register your own grammar with +#customize+ before parsing. See the
+    # README and +spec/support/synthetic/demo.rb+ for an authoring example.
+    #
+    # @return [Config]
+    def default
+      new
+    end
+
+    # See {.default}. Preserved for source compatibility; returns an empty
+    # Config built atop +base+ so existing call sites that compose
+    # configurations (e.g. +Config.hipaa(my_base)+) keep working.
+    #
+    # @return [Config]
+    def hipaa(base = default)
+      base
+    end
+
+    # See {.default}. Preserved for source compatibility; returns the +base+
+    # unmodified.
+    #
+    # @return [Config]
+    def contrib(base = default)
+      base
+    end
+
+    # @endgroup
+    ###########################################################################
+  end
+end