tediparse 2.0.0

data/lib/stupidedi/schema/interchange_def.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # @see X12-5.pdf 3.2.1 Basic Interchange Service Request
+    # @see X222.pdf B.1.1.4.1 Interchange Control Structures
+    #
+    class InterchangeDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [Array<SegmentUse>]
+      attr_reader :header_segment_uses
+
+      # @return [Array<SegmentUse>]
+      attr_reader :trailer_segment_uses
+
+      # @return [Values::InterchangeVal]
+      abstract :empty, :args => %w(separators)
+
+      # @return [Reader::Separators]
+      abstract :separators, :args => %w(isa_segment_val)
+
+      def initialize(id, header_segment_uses, trailer_segment_uses)
+        @id, @header_segment_uses, @trailer_segment_uses =
+          id, header_segment_uses, trailer_segment_uses
+
+        @header_segment_uses  = header_segment_uses.map{|x| x.copy(:parent => self) }
+        @trailer_segment_uses = trailer_segment_uses.map{|x| x.copy(:parent => self) }
+      end
+
+      # @return [InterchangeDef]
+      def copy(changes = {})
+        InterchangeDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:header_segment_uses, @header_segment_uses),
+          changes.fetch(:trailer_segment_uses, @trailer_segment_uses)
+      end
+
+      def required?
+        false
+      end
+
+      # @return [String]
+      def descriptor
+        "interchange #{id}"
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @header_segment_uses.head
+      end
+
+      # @return [Array<SegmentUse>]
+      def children
+        @header_segment_uses + @trailer_segment_uses
+      end
+
+      # (see AbstractDef)
+      def interchange?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        children.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("InterchangeDef[#{id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @header_segment_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+
+          unless q.current_group.first?
+            q.text ","
+            q.breakable
+          end
+          q.text "... (FUNCTIONAL GROUPS) ..."
+
+          @trailer_segment_uses.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/schema/loop_def.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # @see X222.pdf 2.2.2 Loops
+    # @see X222.pdf B.1.3.12.4 Loops of Data Segments
+    #
+    class LoopDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [RepeatCount]
+      attr_reader :repeat_count
+
+      # @return [Array<SegmentUse, LoopDef>]
+      attr_reader :children
+
+      # @return [LoopDef, TableDef]
+      attr_reader :parent
+
+      def_delegators :entry_segment_use, :requirement
+
+      def_delegators :requirement, :required?, :optional?
+
+      def initialize(id, repeat_count, children, parent)
+        @id, @repeat_count, @children, @parent =
+          id, repeat_count, children, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @children = @children.map{|x| x.copy(:parent => self) }
+        end
+      end
+
+      # @return [LoopDef]
+      def copy(changes = {})
+        LoopDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:repeat_count, @repeat_count),
+          changes.fetch(:children, @children),
+          changes.fetch(:parent, @parent)
+      end
+
+      # Returns segments before the first LoopDef.
+      # @deprecated Use {#children} instead. This method does not include
+      #   segments that appear between child loops in interleaved structures.
+      # @return [Array<SegmentUse>]
+      def header_segment_uses
+        @children.take_while{|x| x.is_a?(SegmentUse) }
+      end
+
+      # Returns all LoopDef children.
+      # @deprecated Use {#children} instead and filter with `select{|x| x.is_a?(LoopDef)}`.
+      # @return [Array<LoopDef>]
+      def loop_defs
+        @children.select{|x| x.is_a?(LoopDef) }
+      end
+
+      # Returns segments after the last LoopDef.
+      # @deprecated Use {#children} instead. This method does not include
+      #   segments that appear between child loops in interleaved structures.
+      # @return [Array<SegmentUse>]
+      def trailer_segment_uses
+        last_loop_idx = @children.rindex{|x| x.is_a?(LoopDef) }
+        return [] if last_loop_idx.nil?
+        @children.drop(last_loop_idx + 1).select{|x| x.is_a?(SegmentUse) }
+      end
+
+      # @return [String]
+      def descriptor
+        "loop #{id}"
+      end
+
+      def repeatable?
+        @repeat_count.try{|r| r.include?(2) }
+      end
+
+      # @see X222 B.1.1.3.11.1 Loop Control Segments
+      # @see X222 B.1.1.3.12.4 Loops of Data Segments Bounded Loops
+      def bounded?
+        first_seg = @children.find{|x| x.is_a?(SegmentUse) }
+        last_seg = @children.reverse.find{|x| x.is_a?(SegmentUse) }
+        first_seg && last_seg &&
+          first_seg.definition.id == :LS &&
+          last_seg.definition.id == :LE
+      end
+
+      # @see X12.59 5.6 HL-initiated Loop
+      def hierarchical?
+        first_seg = @children.find{|x| x.is_a?(SegmentUse) }
+        first_seg && first_seg.definition.id == :HL
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @children.find{|x| x.is_a?(SegmentUse) }
+      end
+
+      # @return [LoopVal]
+      def empty
+        Values::LoopVal.new(self, [])
+      end
+
+      def loop?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @children.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("LoopDef[#{@id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << LoopDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [LoopDef]
+      def build(id, repeat_count, *children)
+        # Validate: first child must be a SegmentUse
+        if children.empty? || !children.head.is_a?(SegmentUse)
+          raise Exceptions::InvalidSchemaError,
+            "first child must be a SegmentUse"
+        elsif children.head.repeat_count.include?(2)
+          raise Exceptions::InvalidSchemaError,
+            "first child must have RepeatCount.bounded(1)"
+        end
+
+        new(id, repeat_count, children, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/schema/repeat_count.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class RepeatCount
+      class Bounded < RepeatCount
+        include Comparable
+
+        def_delegators :@max, :<=>
+
+        # @return [Integer]
+        attr_reader :max
+
+        def initialize(max)
+          @max = max
+        end
+
+        def include?(n)
+          n <= @max
+        end
+
+        def exclude?(n)
+          n > @max
+        end
+
+        def inspect
+          @max.to_s
+        end
+      end
+
+      # @private
+      Once = Class.new(Bounded) do
+        def initialize
+          @max = 1
+        end
+      end.new
+
+      # @private
+      Unbounded = Class.new(RepeatCount) do
+        include Comparable
+
+        Infinity = 1.0/0.0
+
+        def include?(n)
+          true
+        end
+
+        def exclude?(n)
+          false
+        end
+
+        def <=>(n)
+          Infinity <=> n
+        end
+
+        def inspect
+          ">1"
+        end
+      end.new
+    end
+
+    class << RepeatCount
+      # @group Constructors
+      #########################################################################
+
+      def bounded(n)
+        if n < 1
+          raise Exceptions::InvalidSchemaError,
+            "n must be positive"
+        elsif n == 1
+          RepeatCount::Once
+        else
+          RepeatCount::Bounded.new(n)
+        end
+      end
+
+      def unbounded
+        RepeatCount::Unbounded
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/schema/segment_def.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # @see X222.pdf B.1.1.3.4 Data Segment
+    #
+    class SegmentDef < AbstractDef
+      include Inspect
+
+      # @return [Symbol]
+      attr_reader :id
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :purpose
+
+      # @return [Array<SimpleElementUse, CompositeElementUse>]
+      attr_reader :element_uses
+
+      # @return [Array<SyntaxNote>]
+      attr_reader :syntax_notes
+
+      # @return [SegmentUse]
+      attr_reader :parent
+
+      def initialize(id, name, purpose, element_uses, syntax_notes, parent)
+        @id, @name, @purpose, @element_uses, @syntax_notes, @parent =
+          id, name, purpose.join, element_uses, syntax_notes, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @element_uses = @element_uses.map{|x| x.copy(:parent => self) }
+        end
+      end
+
+      # @return [SegmentDef]
+      def copy(changes = {})
+        SegmentDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:name, @name),
+          changes.fetch(:purpose, @purpose),
+          changes.fetch(:element_uses, @element_uses),
+          changes.fetch(:syntax_notes, @syntax_notes),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return [String]
+      def descriptor
+        "segment #{id} #{name}"
+      end
+
+      # @return [SegmentUse]
+      def use(position, requirement, repeat_count)
+        SegmentUse.new(self, position, requirement, repeat_count, nil)
+      end
+
+      # @return [Values::SegmentVal]
+      def empty(usage)
+        Values::SegmentVal.new([], usage)
+      end
+
+      def value(element_vals, usage, position)
+        Values::SegmentVal.new(element_vals, usage, position)
+      end
+
+      def segment?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @element_uses.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "SegmentDef[#{@id}]"
+
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @element_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << SegmentDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [SegmentDef]
+      def build(id, name, purpose, *args)
+        element_uses = args.take_while{|x| x.is_a?(AbstractElementUse) }
+        syntax_notes = args.drop(element_uses.length)
+
+        # @todo: Validate SyntaxNotes (beyond this rudimentary validation)
+        syntax_notes.each do |sn|
+          unless sn.indexes.max - 1 <= element_uses.length
+            raise Exceptions::InvalidSchemaError,
+              "Syntax note for #{id} (#{element_uses.length} elements) " +
+              "refers to non-existent element #{sn.indexes.max}"
+          end
+        end
+
+        new(id, name, purpose, element_uses, syntax_notes, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/schema/segment_req.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # The 5010 X12 "data segment requirement designator"s include
+    #   M - Mandatory
+    #   O - Optional
+    #
+    # @see X222 B.1.3.12.6 Data Segment Requirement Designators
+    #
+    # The HIPAA implementation guides "industry usage" include
+    #   SITUATIONAL
+    #   REQUIRED
+    #
+    class SegmentReq
+      def initialize(required, forbidden, to_s)
+        @required, @forbidden, @to_s =
+          required, forbidden, to_s
+      end
+
+      def required?
+        @required
+      end
+
+      def forbidden?
+        @forbidden
+      end
+
+      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

data/lib/stupidedi/schema/segment_use.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # @see X222.pdf B.1.1.3.12.5 Data Segments in a Transaction Set
+    #
+    class SegmentUse < AbstractUse
+      include Inspect
+
+      # @see X222 B.1.1.3.12.7 Data Segment Position
+      #
+      # @return [Integer]
+      attr_reader :position
+
+      # @return [SegmentDef]
+      attr_reader :definition
+
+      def_delegators :definition, :id, :name, :descriptor, :code_lists
+
+      # @see X222 B.1.1.3.12.6 Data Segment Requirement Designators
+      #
+      # @return [SegmentReq]
+      attr_reader :requirement
+
+      def_delegators :requirement, :required?, :optional?
+
+      # @see X222 B.1.3.12.3 Repeated Occurrences of Single Data Segments
+      # @see X222 B.1.3.12.8 Data Segment Occurrence
+      #
+      # @return [RepeatCount]
+      attr_reader :repeat_count
+
+      # @return [LoopDef, TableDef]
+      attr_reader :parent
+
+      def initialize(definition, position, requirement, repeat_count, parent)
+        @definition, @position, @requirement, @repeat_count, @parent =
+          definition, position, requirement, repeat_count, 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 [SegmentUse]
+      def copy(changes = {})
+        SegmentUse.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:position, @position),
+          changes.fetch(:requirement, @requirement),
+          changes.fetch(:repeat_count, @repeat_count),
+          changes.fetch(:parent, @parent)
+      end
+
+      def repeatable?
+        @repeat_count.try{|r| r.include?(2) }
+      end
+
+      # @return [SegmentVal]
+      def empty(position)
+        definition.empty(self, position)
+      end
+
+      def value(element_vals, position)
+        definition.value(element_vals, self, position)
+      end
+
+      # (see AbstractUse#segment?)
+      def segment?
+        true
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text "SegmentUse"
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @position
+          q.text ","
+
+          q.breakable
+          q.pp @definition
+          q.text ","
+
+          q.breakable
+          q.pp @requirement
+          q.text ","
+
+          q.breakable
+          q.pp @repeat_count
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/simple_element_def.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # @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
+  end
+end