stupidedi 1.1.0

data/lib/stupidedi/reader/tokens/simple_element_tok.rb

@@ -0,0 +1,63 @@
+module Stupidedi
+  module Reader
+
+    class SimpleElementTok
+      include Inspect
+
+      # @return [String, Object]
+      attr_reader :value
+
+      # @return [Position]
+      attr_reader :position
+
+      # @return [Position]
+      attr_reader :remainder
+
+      def initialize(value, position, remainder)
+        @value, @position, @remainder =
+          value, position, remainder
+      end
+
+      def pretty_print(q)
+        q.pp(:simple.cons(@value.cons))
+      end
+
+      def repeated
+        RepeatedElementTok.new(self.cons, @position)
+      end
+
+      def repeated?
+        false
+      end
+
+      def blank?
+        @value.blank?
+      end
+
+      def present?
+        not blank?
+      end
+
+      def simple?
+        true
+      end
+
+      def composite?
+        false
+      end
+    end
+
+    class << SimpleElementTok
+      # @group Constructors
+      #########################################################################
+
+      def build(value, position, remainder)
+        new(value, position, remainder)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/reader.rb

@@ -0,0 +1,121 @@
+# encoding: ISO-8859-1
+
+module Stupidedi
+  module Reader
+    autoload :Result,       "stupidedi/reader/result"
+    autoload :Success,      "stupidedi/reader/result"
+    autoload :Failure,      "stupidedi/reader/result"
+
+    autoload :StreamReader, "stupidedi/reader/stream_reader"
+    autoload :TokenReader,  "stupidedi/reader/token_reader"
+    autoload :Separators,   "stupidedi/reader/separators"
+    autoload :SegmentDict,  "stupidedi/reader/segment_dict"
+
+    autoload :ComponentElementTok,  "stupidedi/reader/tokens/component_element_tok"
+    autoload :CompositeElementTok,  "stupidedi/reader/tokens/composite_element_tok"
+    autoload :RepeatedElementTok,   "stupidedi/reader/tokens/repeated_element_tok"
+    autoload :SegmentTok,           "stupidedi/reader/tokens/segment_tok"
+    autoload :SimpleElementTok,     "stupidedi/reader/tokens/simple_element_tok"
+
+    autoload :Input,          "stupidedi/reader/input"
+    autoload :Position,       "stupidedi/reader/position"
+    autoload :AbstractInput,  "stupidedi/reader/input/abstract_input"
+    autoload :DelegatedInput, "stupidedi/reader/input/delegated_input"
+    autoload :FileInput,      "stupidedi/reader/input/file_input"
+
+    # @private
+    # @return [Regexp]
+    R_BASIC    = /[A-Z0-9!"&'()*+,.\/:;?= -]/.freeze
+
+    # @private
+    # @return [Regexp]
+    R_EXTENDED = /[a-z%@\[\]_{}\\|<>~^`#\$ÀÁÂÄàáâäÈÉÊèéêëÌÍÎìíîïÒÓÔÖòóôöÙÚÛÜùúûüÇçÑñ¿¡]/.freeze
+
+    # @private
+    # @return [Regexp]
+    R_EITHER   = Regexp.union(R_BASIC, R_EXTENDED).freeze
+
+    # @private
+    # @return [String]
+    C_BYTES    = (0..255).inject(""){|string, c| string << c }.freeze
+
+    # @private
+    # @return [Hash]
+    H_BASIC    = C_BYTES.scan(R_BASIC).inject({}){|h,c| h[c] = nil; h }.freeze
+
+    # @private
+    # @return [Hash]
+    H_EXTENDED = C_BYTES.scan(R_EXTENDED).inject({}){|h,c| h[c] = nil; h }.freeze
+
+    # @private
+    # @return [Hash]
+    H_EITHER   = C_BYTES.scan(R_EITHER).inject({}){|h,c| h[c] = nil; h }.freeze
+
+    # @private
+    # @return [Regexp]
+    #_CONTROL  = Regexp.new("[^#{Regexp.quote(H_EITHER.keys.join)}]")
+
+    class << self
+
+      # @group Constructors
+      #########################################################################
+
+      # @return [StreamReader]
+      def build(input)
+        StreamReader.new(Input.build(input))
+      end
+
+      # @endgroup
+      #########################################################################
+
+      # Returns true if `character` does not belong to the extended or basic
+      # character set.
+      #
+      # @see X222.pdf B.1.1.2.4 Control Characters
+      def is_control_character?(character)
+        not H_EITHER.include?(character)
+      end
+
+      # @private
+      # @see X222.pdf B.1.1.2.2 Basic Characters
+      def is_basic_character?(character)
+        H_BASIC.include?(character)
+      end
+
+      # @private
+      # @see X222.pdf B.1.1.2.2 Extended Characters
+      def is_extended_character?(character)
+        H_EXTENDED.include?(character)
+      end
+
+      # @private
+      def has_extended_characters?(string)
+        R_EXTENDED =~ string
+      end
+
+      # @private
+      def has_control_characters?(string)
+        #_CONTROL =~ string
+      end
+
+      # @return [Character]
+      # @private
+      def basic_characters
+        H_BASIC.keys
+      end
+
+      # @return [Character]
+      # @private
+      def extended_characters
+        H_EXTENDED.keys
+      end
+
+      # @return [Character]
+      # @private
+      def control_characters
+        C_BYTES.split(//) - H_EITHER.keys
+      end
+    end
+
+  end
+end

data/lib/stupidedi/schema/abstract_def.rb

@@ -0,0 +1,74 @@
+module Stupidedi
+  module Schema
+
+    class AbstractDef
+
+      def usage?
+        false
+      end
+
+      def definition?
+        true
+      end
+
+      #
+      #########################################################################
+
+      # Is this an {InterchangeDef}?
+      def interchange?
+        false
+      end
+
+      # Is this an {FunctionalGroupDef}?
+      def functional_group?
+        false
+      end
+
+      # Is this an {TransactionSetDef}?
+      def transaction_set?
+        false
+      end
+
+      # Is this a {TableDef}?
+      def table?
+        false
+      end
+
+      # Is this a {LoopDef}?
+      def loop?
+        false
+      end
+
+      # Is this a {SegmentDef}?
+      def segment?
+        false
+      end
+
+      # Is this a {AbstractElementDef}?
+      def element?
+        false
+      end
+
+      # Is this a {CompositeElementDef}?
+      def composite?
+        false
+      end
+
+      # Is this a component {SimpleElementDef}?
+      def component?
+        false
+      end
+
+      # Is this a repeated {AbstractElementDef}?
+      def repeated?
+        false
+      end
+
+      # Is this a non-component {SimpleElementDef}?
+      def simple?
+        false
+      end
+    end
+
+  end
+end

data/lib/stupidedi/schema/abstract_use.rb

@@ -0,0 +1,73 @@
+module Stupidedi
+  module Schema
+
+    class AbstractUse
+
+      def usage?
+        true
+      end
+
+      def definition?
+        true
+      end
+
+      #
+      #########################################################################
+
+      # Is this a {SegmentUse}?
+      def segment?
+        false
+      end
+
+      # Is this a {AbstractElementUse}?
+      def element?
+        false
+      end
+
+      # Is this a {CompositeElementUse}?
+      def composite?
+        false
+      end
+
+      # Is this a component {SimpleElementUse}?
+      def component?
+        false
+      end
+
+      # Is this a repeatable {AbstractUse}?
+      def repeated?
+        false
+      end
+
+      # Is this a non-component {SimpleElementUse}?
+      def simple?
+        false
+      end
+
+      # The definitions for these types, like InterchangeDef aren't reused, so
+      # they don't have corresponding AbstractUse subclasses.
+      #########################################################################
+
+      def interchange?
+        false
+      end
+
+      def functional_group?
+        false
+      end
+
+      def transaction_set?
+        false
+      end
+
+      def table?
+        false
+      end
+
+      def loop?
+        false
+      end
+    end
+
+  end
+end

data/lib/stupidedi/schema/code_list.rb

@@ -0,0 +1,94 @@
+module Stupidedi
+  module Schema
+
+    class CodeList
+      include Inspect
+
+      abstract :external?
+
+      def internal?
+        not external?
+      end
+
+      class Internal < CodeList
+
+        delegate :at, :defined_at?, :to => :@hash
+
+        def initialize(hash)
+          @hash = hash
+        end
+
+        # @return [Array<String>]
+        def codes
+          @hash.keys
+        end
+
+        def external?
+          false
+        end
+
+        # Some elements are qualifiers that select which code list
+        # is applicable to the qualified element. For instance, the
+        # diagnosis codes in the HI segment are qualified by E1270
+        # "Code List Qualifier Code", which indicates which code list
+        # should be used to validate the E1271's diagnosis code. It
+        # maybe ICD-9, ICD-10, etc.
+        #
+        # @return [AbstractSet<CodeList>]
+        def code_lists(subset = Sets.universal)
+          related =
+            @hash.select do |k, v|
+              subset.include?(k) and v.is_a?(Schema::CodeList)
+            end
+
+          if subset.finite?
+            Sets.build([self]) + related.map{|k,v| v }
+          else
+            Sets.build([self])
+          end
+        end
+      end
+
+      class External < CodeList
+
+        # @return [String]
+        attr_reader :id
+
+        def initialize(id)
+          @id = id
+        end
+
+        def external?
+          true
+        end
+
+        def code_lists(values = Sets.universal)
+          Sets.build([self])
+        end
+
+        def to_str
+          "CodeList.external(#{@id})"
+        end
+      end
+    end
+
+    class << CodeList
+      # @group Constructors
+      #########################################################################
+
+      # @return [CodeList::Internal]
+      def build(hash)
+        CodeList::Internal.new(hash)
+      end
+
+      # @return [CodeList::External]
+      def external(id, *ignored)
+        CodeList::External.new(id)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/schema/element_def.rb

@@ -0,0 +1,173 @@
+module Stupidedi
+  module Schema
+
+    class AbstractElementDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :description
+
+      abstract :simple?
+
+      abstract :composite?
+
+      # @return [AbstractSet<CodeList>]
+      abstract :code_lists
+
+      def element?
+        true
+      end
+    end
+
+    #
+    # @see X222 B.1.1.3.1 Data Element
+    #
+    class SimpleElementDef < AbstractElementDef
+
+      # @return [SimpleElementUse, ComponentElementUse]
+      abstract :parent
+
+      # @return [SimpleElementVal]
+      abstract :empty, :args => %w(position)
+
+      # @return [SimpleElementVal]
+      abstract :value, :args => %w(object position)
+
+      # @return [SimpleElementVal]
+      abstract :parse, :args => %w(string position)
+
+      # @return true
+      def simple?
+        true
+      end
+
+      # @return false
+      def composite?
+        false
+      end
+
+      # @return [SimpleElementUse]
+      def simple_use(requirement, repeat_count, parent = nil)
+        SimpleElementUse.new(self, requirement, repeat_count, Sets.universal, parent)
+      end
+
+      # @return [ComponentElementUse]
+      def component_use(requirement, parent = nil)
+        ComponentElementUse.new(self, requirement, Sets.universal, parent)
+      end
+
+      # This is overridden (if needed) by the concrete subclasses. Specifically
+      # the "ID" element types have an extra attribute to link the CodeList.
+      #
+      # @return [AbstractSet<CodeList>]
+      def code_lists(subset = Sets.universal)
+        Sets.empty
+      end
+    end
+
+    #
+    # @see X222 B.1.1.3.3 Composite Data Structure
+    #
+    class CompositeElementDef < AbstractElementDef
+
+      # @return [Array<ComponentElementUse>]
+      attr_reader :component_uses
+
+      # @return [Array<SyntaxNote>]
+      attr_reader :syntax_notes
+
+      # @return [CompositeElementUse]
+      attr_reader :parent
+
+      def initialize(id, name, description, component_uses, syntax_notes, parent)
+        @id, @name, @description, @component_uses, @syntax_notes, @parent =
+          id, name, description, component_uses, syntax_notes, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @component_uses = @component_uses.map{|x| x.copy(:parent => self) }
+        end
+      end
+
+      # @return [CompositeElementDef]
+      def copy(changes = {})
+        CompositeElementDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:name, @name),
+          changes.fetch(:description, @description),
+          changes.fetch(:component_uses, @component_uses),
+          changes.fetch(:syntax_notes, @syntax_notes),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return false
+      def simple?
+        false
+      end
+
+      # @return true
+      def composite?
+        true
+      end
+
+      # @return [CompositeElementUse]
+      def simple_use(requirement, repeat_count, parent = nil)
+        CompositeElementUse.new(self, requirement, repeat_count, parent)
+      end
+
+      # @return [CompositeElementVal]
+      def value(component_vals, usage, position)
+        Values::CompositeElementVal.new(component_vals, usage)
+      end
+
+      # @return [CompositeElementVal]
+      def empty(usage, position)
+        Values::CompositeElementVal.new([], usage)
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @component_uses.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("CompositeElementDef[#{@id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @component_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << CompositeElementDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [CompositeElementDef]
+      def build(id, name, description, *args)
+        component_uses = args.take_while{|x| x.is_a?(AbstractElementUse) }
+        syntax_notes   = args.drop(component_uses.length)
+
+        new(id, name, description, component_uses, syntax_notes, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/schema/element_req.rb

@@ -0,0 +1,56 @@
+module Stupidedi
+  module Schema
+
+    # The 5010 X12 "condition designator"s include
+    #   M - Mandatory
+    #   O - Optional
+    #   X - Relational
+    #
+    # Where "Relational" indicates this element is subject to relational
+    # conditions between two or more elements (encoded as a SyntaxNote)
+    #
+    # @see X222 B.1.1.3.9 Condition Designator
+    #
+    # The "Implementation Usage" from the 5010 HIPAA implementation guides
+    # have three descriptors:
+    #   REQUIRED
+    #   NOT USED
+    #   SITUATIONAL
+    #
+    # @see X222.pdf 2.2.1 Industry Usage
+    #
+    class ElementReq
+
+      def initialize(required, forbidden, to_s)
+        @required, @forbidden, @to_s =
+          required, forbidden, to_s
+      end
+
+      # True if the element's presence is unconditionally required
+      def required?
+        @required
+      end
+
+      # True if the element's presence is unconditionally forbidden
+      def forbidden?
+        @forbidden
+      end
+
+      # True if the element's presence is required conditionally
+      def optional?
+        not (@required or @forbidden)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text @to_s
+      end
+
+      # @return [String]
+      def inspect
+        @to_s
+      end
+    end
+
+  end
+end