stupidedi 1.1.0

data/lib/stupidedi/config/editor_config.rb

@@ -0,0 +1,51 @@
+module Stupidedi
+  class Config
+
+    class EditorConfig
+      include Inspect
+
+      def initialize
+        @table = Hash.new
+      end
+
+      alias customize tap
+
+      # Is the edit or rewrite rule enabled?
+      def enabled?(id)
+        true
+      end
+
+      # Is `value` a valid string (AN)?
+      def an?(value)
+        true # @todo
+      end
+
+      # @param [Class]  definition
+      # @param [String] definition
+      def register(definition, &constructor)
+        @table[definition] = constructor
+      end
+
+      # @param [Class] definition
+      def defined_at?(definition)
+        @table.defined_at?(definition) or
+        @table.defined_at?(definition.class.name)
+      end
+
+      # @param [Class] definition
+      def at(definition)
+        (@table.at(definition) || @table.at(definition.class.name)).call
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "EditorConfig"
+        q.group(2, "(", ")") do
+          q.breakable ""
+          # ...
+        end
+      end
+    end
+
+  end
+end

data/lib/stupidedi/config/functional_group_config.rb

@@ -0,0 +1,62 @@
+module Stupidedi
+  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
+
+      delegate :defined_at?, :to => :@table
+
+      def initialize
+        @table = Hash.new
+      end
+
+      alias customize tap
+
+      # @return [void]
+      def register(version, definition = nil, &constructor)
+        if block_given?
+          @table[version] = constructor
+        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,79 @@
+module Stupidedi
+  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
+
+      delegate :defined_at?, :to => :@table
+
+      def initialize
+        @table = Hash.new
+      end
+
+      alias customize tap
+
+      #
+      # @example
+      #   table = InterchangeConfig.new
+      #
+      #   table.register("00602") { SixOhTwo::InterchangeDef }
+      #   table.register("00501") { FiveOhOne::InterchangeDef }
+      #   table.register("00401") { FourOhOne::InterchangeDef }
+      #   table.register("00304") { ThreeOhFour::InterchangeDef }
+      #
+      # @return [void]
+      def register(version, definition = nil, &constructor)
+        if block_given?
+          @table[version] = constructor
+        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,91 @@
+module Stupidedi
+  class Config
+
+    #
+    # The implementation version specified in GS08 and ST03 indicates which
+    # implementation guide governs the transaction. Because each guide may
+    # define multiple transaction sets (eg X212 and X279), the functional code
+    # and transaction set code are needed to lookup a definition.
+    #
+    # In english, we can't just look at ST01 and link "837" to our definition of
+    # 837P from the HIPAA guide.
+    #
+    class TransactionSetConfig
+      include Inspect
+
+      def initialize
+        @table = Hash.new
+      end
+
+      alias customize tap
+
+      # @example
+      #   table = TransactionSetConfig.new
+      #
+      #   table.register("005010X212", "HR", "276") { Hipaa::X212::HR276 }
+      #   table.register("005010X212", "HN", "277") { Hipaa::X212::HN277 }
+      #
+      #   table.register("005010X217", "HI", "278") { Hipaa::X217::HI278 }
+      #   table.register("005010X218", "RA", "820") { Hipaa::X218::RA820 }
+      #   table.register("005010X220", "BE", "834") { Hipaa::X220::BE834 }
+      #   table.register("005010X221", "HP", "835") { Hipaa::X221::HP835 }
+      #
+      #   table.register("005010X222", "HC", "837") { Hipaa::X222::HC837 }
+      #   table.register("005010X223", "HC", "837") { Hipaa::X223::HC837 }
+      #   table.register("005010X224", "HC", "837") { Hipaa::X224::HC837 }
+      #
+      #   table.register("005010X230", "FA", "997") { Hipaa::X230::FA997 }
+      #   table.register("005010X231", "FA", "999") { Hipaa::X231::FA999 }
+      #
+      #   table.register("005010X279", "HS", "270") { Hipaa::X279::HS270 }
+      #   table.register("005010X279", "HB", "271") { Hipaa::X279::HB271 }
+      #
+      #   table.register("005010", "HR", "276") { Standards::HR276 }
+      #   table.register("005010", "HS", "270") { Standards::HS270 }
+      #   table.register("005010", "HB", "271") { Standards::HB271 }
+      #   table.register("005010", "HN", "277") { Standards::HN277 }
+      #   table.register("005010", "HI", "278") { Standards::HI278 }
+      #   table.register("005010", "RA", "820") { Standards::RA820 }
+      #   table.register("005010", "BE", "834") { Standards::BE834 }
+      #   table.register("005010", "HP", "835") { Standards::HP835 }
+      #   table.register("005010", "HC", "837") { Standards::HC837 }
+      #   table.register("005010", "FA", "997") { Standards::FA997 }
+      #   table.register("005010", "FA", "999") { Standards::FA999 }
+      #
+      # @return [void]
+      def register(version, function, transaction, definition = nil, &constructor)
+        if block_given?
+          @table[Array[version, nil, transaction]] = constructor
+        else
+          @table[Array[version, nil, transaction]] = definition
+        end
+      end
+
+      # @return [TransactionSetDef]
+      def at(version, function, transaction)
+        x = @table[Array[version, nil, transaction]]
+        x.is_a?(Proc) ? x.call : x
+      end
+
+      def defined_at?(version, function, transaction)
+        @table.defined_at?([version, nil, transaction])
+      end
+
+      # @return [void]
+      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
+    end
+
+  end
+end

data/lib/stupidedi/config.rb

@@ -0,0 +1,101 @@
+module Stupidedi
+
+  class Config
+    autoload :CodeListConfig,         "stupidedi/config/code_list_config"
+    autoload :EditorConfig,           "stupidedi/config/editor_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
+
+    # @return [EditorConfig]
+    attr_reader :editor
+
+    def initialize
+      @interchange      = InterchangeConfig.new
+      @functional_group = FunctionalGroupConfig.new
+      @transaction_set  = TransactionSetConfig.new
+      @code_list        = CodeListConfig.new
+      @editor           = EditorConfig.new
+    end
+
+    alias customize tap
+
+    # @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
+        q.text ","
+        q.breakable
+
+        q.pp @editor
+      end
+    end
+  end
+
+  class << Config
+    ###########################################################################
+    # @group Constructors
+
+    # @return [Config]
+    def default
+      new.customize do |c|
+        c.interchange.customize do |x|
+          x.register("00501") { Stupidedi::Versions::Interchanges::FiveOhOne::InterchangeDef }
+        end
+
+        c.functional_group.customize do |x|
+          x.register("005010") { Stupidedi::Versions::FunctionalGroups::FiftyTen::FunctionalGroupDef }
+        end
+
+        c.transaction_set.customize do |x|
+          x.register("005010", "HN", "277") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HN277 }
+          x.register("005010", "HP", "835") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HP835 }
+          x.register("005010", "HC", "837") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HC837 }
+          x.register("005010", "FA", "999") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::FA999 }
+
+          x.register("005010X214", "HN", "277") { Stupidedi::Guides::FiftyTen::X214::HN277  }
+          x.register("005010X221", "HP", "835") { Stupidedi::Guides::FiftyTen::X221::HP835  }
+          x.register("005010X222", "HC", "837") { Stupidedi::Guides::FiftyTen::X222::HC837P }
+          x.register("005010X231", "FA", "999") { Stupidedi::Guides::FiftyTen::X231::FA999  }
+
+          x.register("005010X221A1", "HP", "835") { Stupidedi::Guides::FiftyTen::X221A1::HP835  }
+          x.register("005010X222A1", "HC", "837") { Stupidedi::Guides::FiftyTen::X222A1::HC837P }
+          x.register("005010X231A1", "FA", "999") { Stupidedi::Guides::FiftyTen::X231A1::FA999  }
+        end
+      end
+    end
+
+    # @endgroup
+    ###########################################################################
+  end
+
+end