stupidedi 1.1.0

data/lib/stupidedi/schema/segment_def.rb

@@ -0,0 +1,108 @@
+module Stupidedi
+  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, 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 [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
+        new(id, name, purpose, element_uses, syntax_notes, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/schema/segment_req.rb

@@ -0,0 +1,43 @@
+module Stupidedi
+  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,98 @@
+module Stupidedi
+  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
+
+      # @see X222 B.1.1.3.12.6 Data Segment Requirement Designators
+      #
+      # @return [SegmentReq]
+      attr_reader :requirement
+
+      # @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
+
+      delegate :id, :code_lists, :to => :definition
+
+      delegate :required?, :to => :requirement
+
+      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/syntax_note.rb

@@ -0,0 +1,63 @@
+module Stupidedi
+  module Schema
+
+    # The 5010 X12 "condition code"s include
+    #   P - Paired or Multiple (if one then all)
+    #   R - Required (at least one)
+    #   E - Exclusion (no more than one)
+    #   C - Conditional (if first then all)
+    #   L - List Conditional (if first than at least one more)
+    #
+    # @see X222.pdf B.1.1.3.5 Syntax Notes
+    # @see X222.pdf B.1.1.3.9 Condition Designator
+    #
+    class SyntaxNote
+
+      # @return [Array<Integer>]
+      attr_reader :indexes
+
+      def initialize(indexes)
+        @indexes = indexes
+      end
+
+      # Returns the AbstractElementVals from the given segment or composite
+      # element that must be present, given the presence of other elements
+      #
+      # @return [Array<Zipper::AbstractCursor<Values::AbstractElementVal>>]
+      abstract :required, :args => %w(zipper)
+
+      # Returns the AbstractElementVals from the given segment or composite
+      # element that must not be present, given the presence of other elements
+      #
+      # @return [Array<Zipper::AbstractCursor<Values::AbstractElementVal>>]
+      abstract :forbidden, :args => %w(zipper)
+
+      # @return [String]
+      abstract :reason, :args => %w(zipper)
+
+      def satisfied?(zipper)
+        forbidden(zipper).all?(&:blank?) and
+          required(zipper).all?(&:present?)
+      end
+
+      # @return [Array<Zipper::AbstractCursor<Values::AbstractElementVal>>]
+      def errors(zipper)
+        f = forbidden(zipper).select{|c| c.node.present? }
+        r = required(zipper).reject{|c| c.node.present? }
+
+        f.concat(r)
+      end
+
+    private
+
+      def children(zipper)
+        indexes.map{|n| zipper.child(n - 1) }
+      rescue
+        pp zipper.node
+        pp indexes
+        raise $!
+      end
+    end
+
+  end
+end

data/lib/stupidedi/schema/table_def.rb

@@ -0,0 +1,139 @@
+module Stupidedi
+  module Schema
+
+    class TableDef < AbstractDef
+      # @return [String]
+      attr_reader :id
+
+      # @return [Array<SegmentUse>]
+      attr_reader :header_segment_uses
+
+      # @return [Array<SegmentUse>]
+      attr_reader :trailer_segment_uses
+
+      # @return [Array<LoopDef>]
+      attr_reader :loop_defs
+
+      # @return [TransactionSetDef]
+      attr_reader :parent
+
+      # @return [Integer]
+      attr_reader :position
+
+      def initialize(id, position, repeatable, header_segment_uses, loop_defs, trailer_segment_uses, parent)
+        @id, @position, @repeatable, @header_segment_uses, @loop_defs, @trailer_segment_uses, @parent =
+          id, position, repeatable, header_segment_uses, loop_defs, trailer_segment_uses, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @header_segment_uses  = @header_segment_uses.map{|x| x.copy(:parent => self) }
+          @loop_defs            = @loop_defs.map{|x| x.copy(:parent => self) }
+          @trailer_segment_uses = @trailer_segment_uses.map{|x| x.copy(:parent => self) }
+        end
+      end
+
+      # @return [TableDef]
+      def copy(changes = {})
+        TableDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:position, @position),
+          changes.fetch(:repeatable, @repeatable),
+          changes.fetch(:header_segment_uses, @header_segment_uses),
+          changes.fetch(:loop_defs, @loop_defs),
+          changes.fetch(:trailer_segment_uses, @trailer_segment_uses),
+          changes.fetch(:parent, @parent)
+      end
+
+      def repeatable?
+        @repeatable
+      end
+
+      # @return [Array<SegmentUse>]
+      def entry_segment_uses
+        uses = []
+        uses.concat(@header_segment_uses)
+        uses.concat(@loop_defs.map{|l| l.entry_segment_use })
+        uses.concat(@trailer_segment_uses)
+      end
+
+      # @return [Array<SegmentUse, LoopDef>]
+      def children
+        @header_segment_uses + @loop_defs + @trailer_segment_uses
+      end
+
+      # @return [Values::TableVal]
+      def empty
+        Values::TableVal.new(self, [])
+      end
+
+      def table?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        children.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("TableDef[#{@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
+          @loop_defs.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+          @trailer_segment_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << TableDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [TableDef]
+      def header(id, *children)
+        header, children   = children.split_when{|x| x.is_a?(LoopDef) }
+        loop_defs, trailer = children.split_when{|x| x.is_a?(SegmentUse) }
+        new(id, 1, false, header, loop_defs, trailer, nil)
+      end
+
+      # @return [TableDef]
+      def detail(id, *children)
+        header, children   = children.split_when{|x| x.is_a?(LoopDef) }
+        loop_defs, trailer = children.split_when{|x| x.is_a?(SegmentUse) }
+        new(id, 2, true, header, loop_defs, trailer, nil)
+      end
+
+      # @return [TableDef]
+      def summary(id, *children)
+        header, children   = children.split_when{|x| x.is_a?(LoopDef) }
+        loop_defs, trailer = children.split_when{|x| x.is_a?(SegmentUse) }
+        new(id, 3, false, header, loop_defs, trailer, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/schema/transaction_set_def.rb

@@ -0,0 +1,88 @@
+module Stupidedi
+  module Schema
+
+    class TransactionSetDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :functional_group
+
+      # @return [Array<TableDef>]
+      attr_reader :table_defs
+
+      def initialize(functional_group, id, name, table_defs)
+        @functional_group, @id, @name, @table_defs =
+          functional_group, id, name, table_defs
+
+        @table_defs = table_defs.map{|x| x.copy(:parent => self) }
+      end
+
+      def copy(changes = {})
+        TransactionSetDef.new \
+          changes.fetch(:functional_group, @functional_group),
+          changes.fetch(:id, @id),
+          changes.fetch(:name, @name),
+          changes.fetch(:table_defs, @table_defs)
+      end
+
+      # @return [Values::TransactionSetVal]
+      def empty
+        Values::TransactionSetVal.new(self, [])
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @table_defs.head.header_segment_uses.head
+      end
+
+      # @return [SegmentUse]
+      def first_segment_use
+        @table_defs.head.header_segment_uses.head
+      end
+
+      # @return [SegmentUse]
+      def last_segment_use
+        @table_defs.last.trailer_segment_uses.last
+      end
+
+      def transaction?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @table_defs.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("TransactionSetDef[#{@functional_group}#{@id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @table_defs.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << TransactionSetDef
+
+      # @return [TransactionSetDef]
+      def build(functional_group, id, name, *table_defs)
+        new(functional_group, id, name, table_defs)
+      end
+    end
+
+  end
+end

data/lib/stupidedi/schema.rb

@@ -0,0 +1,28 @@
+module Stupidedi
+  module Schema
+    autoload :AbstractDef,  "stupidedi/schema/abstract_def"
+    autoload :AbstractUse,  "stupidedi/schema/abstract_use"
+
+    autoload :CodeList,             "stupidedi/schema/code_list"
+    autoload :ElementReq,           "stupidedi/schema/element_req"
+    autoload :AbstractElementDef,   "stupidedi/schema/element_def"
+    autoload :AbstractElementUse,   "stupidedi/schema/element_use"
+    autoload :SimpleElementDef,     "stupidedi/schema/element_def"
+    autoload :SimpleElementUse,     "stupidedi/schema/element_use"
+    autoload :CompositeElementDef,  "stupidedi/schema/element_def"
+    autoload :CompositeElementUse,  "stupidedi/schema/element_use"
+    autoload :ComponentElementUse,  "stupidedi/schema/element_use"
+
+    autoload :LoopDef,      "stupidedi/schema/loop_def"
+    autoload :RepeatCount,  "stupidedi/schema/repeat_count"
+    autoload :SegmentDef,   "stupidedi/schema/segment_def"
+    autoload :SegmentReq,   "stupidedi/schema/segment_req"
+    autoload :SegmentUse,   "stupidedi/schema/segment_use"
+    autoload :SyntaxNote,   "stupidedi/schema/syntax_note"
+    autoload :TableDef,     "stupidedi/schema/table_def"
+
+    autoload :TransactionSetDef,  "stupidedi/schema/transaction_set_def"
+    autoload :FunctionalGroupDef, "stupidedi/schema/functional_group_def"
+    autoload :InterchangeDef,     "stupidedi/schema/interchange_def"
+  end
+end