tediparse 2.0.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Reader
+    class SegmentTok
+      include Inspect
+
+      # @return [Symbol]
+      attr_reader :id
+
+      # @return [Array<CompositeElementTok, SimpleElementTok>]
+      attr_reader :element_toks
+
+      # @return [Position]
+      attr_reader :position
+
+      # @return [Position]
+      attr_reader :remainder
+
+      def initialize(id, element_toks, position, remainder)
+        @id, @element_toks, @position, @remainder =
+          id, element_toks, position, remainder
+      end
+
+      # @return [SegmentTok]
+      def copy(changes = {})
+        SegmentTok.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:element_toks, @element_toks),
+          changes.fetch(:position, @position),
+          changes.fetch(:remainder, @remainder)
+      end
+
+      # :nocov:
+      def pretty_print(q)
+        q.pp(:segment.cons(@id.cons(@element_toks)))
+      end
+      # :nocov:
+
+      def blank?
+        @element_toks.all?(&:blank?)
+      end
+
+      def present?
+        not blank?
+      end
+
+      def to_x12(separators)
+        if blank?
+          "#{id}#{separators.segment}"
+        else
+          es  = @element_toks.map{|x| x.to_x12(separators) }
+          sep = separators.element || "*"
+          eos = separators.segment || "~"
+          id.cons(es).join(sep).gsub(/#{Regexp.escape(sep)}+$/, "") + eos.strip
+        end
+      end
+    end
+
+    class << SegmentTok
+      # @group Constructors
+      #########################################################################
+
+      # @return [SegmentTok]
+      def build(id, element_toks, position, remainder)
+        new(id, element_toks, position, remainder)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  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
+
+      # @return [SimpleElementTok]
+      def copy(changes = {})
+        SimpleElementTok.new \
+          changes.fetch(:value, @value),
+          changes.fetch(:position, @position),
+          changes.fetch(:remainder, @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
+
+      def to_x12(separators)
+        @value.to_s
+      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 @@
+# frozen_string_literal: true
+# encoding: ISO-8859-1
+module Stupidedi
+  using Refinements
+
+  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].pack('U') }
+
+    # @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,76 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class AbstractDef
+      def usage?
+        false
+      end
+
+      def definition?
+        true
+      end
+
+      # @return [String]
+      abstract :descriptor
+
+      abstract :required?
+
+      # 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_element_def.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  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
+
+      # @return [String]
+      def descriptor
+        "element #{id} #{description}".strip
+      end
+
+      def element?
+        true
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/abstract_element_use.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class AbstractElementUse < AbstractUse
+      include Inspect
+
+      def_delegators :requirement, :forbidden?, :required?, :optional?
+
+      def_delegators :definition, :code_lists
+
+      # @return [Symbol]
+      abstract :id
+
+      # @return [String]
+      abstract :name
+
+      # @return [String]
+      abstract :description
+
+      # @return [ElementReq]
+      abstract :requirement
+
+      # @return [SimpleElementDef, CompositeElementDef]
+      abstract :definition
+
+      abstract :simple?
+
+      abstract :component?
+
+      # @return [SimpleElementVal, CompositeElementVal]
+      def empty(position)
+        definition.empty(self, position)
+      end
+
+      # @return [SimpleElementVal, CompositeElementVal]
+      def value(object, position)
+        definition.value(object, self, position)
+      end
+
+      def composite?
+        not simple?
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/abstract_use.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class AbstractUse
+      def usage?
+        true
+      end
+
+      def definition?
+        true
+      end
+
+      # @return [Symbol]
+      abstract :id
+
+      # @return [String]
+      abstract :descriptor
+
+      #
+      #########################################################################
+
+      # 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,99 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class CodeList
+      include Inspect
+
+      abstract :external?
+
+      def internal?
+        not external?
+      end
+
+      class Internal < CodeList
+        def_delegators :@hash, :at, :defined_at?
+
+        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)
+        # @todo: deprecate
+        CodeList::Internal.new(hash)
+      end
+
+      # @return [CodeList::Internal]
+      def internal(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/component_element_use.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class ComponentElementUse < AbstractElementUse
+      # @return [SimpleElementDef]
+      attr_reader :definition
+
+      def_delegators :definition, :id, :name, :description
+
+      # @return [ElementReq]
+      attr_reader :requirement
+
+      # @return [CompositeElementDef]
+      attr_reader :parent
+
+      # @return [AbstractSet]
+      attr_reader :allowed_values
+
+      def initialize(definition, requirement, allowed_values, parent)
+        @definition, @requirement, @allowed_values, @parent =
+          definition, requirement, allowed_values, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @definition = @definition.copy(:parent => self)
+        end
+      end
+
+      # @return [ComponentElementUse]
+      def copy(changes =  {})
+        ComponentElementUse.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:requirement, @requirement),
+          changes.fetch(:allowed_values, @allowed_values),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return [String]
+      def descriptor
+        n = parent.parent.parent.element_uses.index{|u| u.eql?(parent.parent) } + 1
+        m = parent.component_uses.index{|u| u.eql?(self) } + 1
+        "element #{parent.parent.parent.id}#{"%02d-%02d" % [n, m]} #{definition.name}".strip
+      end
+
+      # @return false
+      def repeatable?
+        false
+      end
+
+      # @return true
+      def simple?
+        true
+      end
+
+      # @return true
+      def component?
+        true
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("ComponentElementUse")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @definition
+          q.text ","
+          q.breakable
+          q.pp @requirement
+        end
+      end
+    end
+  end
+end