stupidedi 1.1.0

data/lib/stupidedi/schema/element_use.rb

@@ -0,0 +1,251 @@
+module Stupidedi
+  module Schema
+
+    class AbstractElementUse < AbstractUse
+      include Inspect
+
+      delegate :forbidden?, :required?, :optional?, :to => :requirement
+
+      delegate :code_lists, :to => :definition
+
+      # @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
+
+    class SimpleElementUse < AbstractElementUse
+      # @return [SimpleElementDef]
+      attr_reader :definition
+
+      # @return [ElementReq]
+      attr_reader :requirement
+
+      # @return [RepeatCount]
+      attr_reader :repeat_count
+
+      # @return [AbstractSet]
+      attr_reader :allowed_values
+
+      # @return [SegmentDef]
+      attr_reader :parent
+
+      def initialize(definition, requirement, repeat_count, allowed_values, parent)
+        @definition, @requirement, @repeat_count, @allowed_values, @parent =
+          definition, requirement, repeat_count, 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 [SimpleElementUse]
+      def copy(changes = {})
+        SimpleElementUse.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:requirement, @requirement),
+          changes.fetch(:repeat_count, @repeat_count),
+          changes.fetch(:allowed_values, @allowed_values),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return [SimpleElementVal]
+      def parse(string)
+        definition.parse(string, self)
+      end
+
+      def repeatable?
+        @repeat_count.try{|r| r.include?(2) }
+      end
+
+      # @return true
+      def simple?
+        true
+      end
+
+      # @return false
+      def component?
+        false
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        if forbidden?
+          Sets.empty
+        else
+          @definition.code_lists(@allowed_values)
+        end
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("SimpleElementUse")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @definition
+          q.text ","
+
+          q.breakable
+          q.pp @requirement
+          q.text ","
+
+          q.breakable
+          q.pp @repeat_count
+        end
+      end
+    end
+
+    class ComponentElementUse < AbstractElementUse
+      # @return [SimpleElementDef]
+      attr_reader :definition
+
+      # @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 [SimpleElementVal]
+      def parse(string)
+        definition.parse(string, self)
+      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
+
+    class CompositeElementUse < AbstractElementUse
+      # @return [CompositeElementDef]
+      attr_reader :definition
+
+      # @return [ElementReq]
+      attr_reader :requirement
+
+      # @return [RepeatCount]
+      attr_reader :repeat_count
+
+      # @return [SegmentDef]
+      attr_reader :parent
+
+      def initialize(definition, requirement, repeat_count, parent)
+        @definition, @requirement, @repeat_count, @parent =
+          definition, 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 [CompositeElementUse]
+      def copy(changes = {})
+        CompositeElementUse.new \
+          changes.fetch(:definition, @definition),
+          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 false
+      def simple?
+        false
+      end
+
+      # @return false
+      def component?
+        false
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("CompositeElementUse")
+        q.group(2, "(", ")") do
+          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/functional_group_def.rb

@@ -0,0 +1,114 @@
+module Stupidedi
+  module Schema
+
+    #
+    # X12 standards are released three times yearly. The version codes sent in
+    # the `GS08` and `ST03` elements encode the version (eg 004, 005), the
+    # release (eg 0040, 0050), the subrelease (00501, 00602) and the level
+    # (eg 005010)
+    #
+    # The release schedules look like this:
+    #
+    #               Approved by    Available      Ballot Results  Available for
+    #     Version   Subcommitees   for Ballot     Approved        Distribution
+    #     ---------------------------------------------------------------------
+    #      005010     Feb 03         Jun 03         Oct 03          Jan 04
+    #      005011     Jun 03         Oct 04         Feb 04          Mar 04
+    #      005012     Oct 03         Feb 04         Jun 04          Jul 04
+    #
+    #      005020     Feb 04         Jun 04         Oct 04          Jan 05
+    #      005021     Jun 04         Oct 04         Feb 05          Mar 05
+    #      005022     Oct 04         Feb 05         Jun 05          Jul 05
+    #
+    # @see http://www.disa.org/x12org/subcommittees/dev/pdf/X12RELEASESCHED.pdf
+    #
+    # @see X222.pdf B.1.1.3.13 Functional Group
+    # @see X222.pdf B.1.1.4.2 Functional Groups
+    #
+    class FunctionalGroupDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [Array<SegmentUses>]
+      attr_reader :header_segment_uses
+
+      # @return [Array<SegmentUses>]
+      attr_reader :trailer_segment_uses
+
+      # @return [Hash, Module]
+      abstract :segment_dict
+
+      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 [FunctionalGroupDef]
+      def copy(changes = {})
+        FunctionalGroupDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:header_segment_uses, @header_segment_uses),
+          changes.fetch(:trailer_segment_uses, @trailer_segment_uses)
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @header_segment_uses.head
+      end
+
+      # @return [Array<SegmentUse>]
+      def children
+        @header_segment_uses + @trailer_segment_uses
+      end
+
+      # @return [Values::FunctionalGroupVal]
+      def empty
+        Values::FunctionalGroupVal.new(self, [], [])
+      end
+
+      def functional_group?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>
+      def code_lists
+        children.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("FunctionalGroupDef")
+        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 "... (TRANSACTION SETS) ..."
+
+          @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/interchange_def.rb

@@ -0,0 +1,93 @@
+module Stupidedi
+  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
+
+      # @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,152 @@
+module Stupidedi
+  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>]
+      attr_reader :header_segment_uses
+
+      # @return [Array<SegmentUse>]
+      attr_reader :trailer_segment_uses
+
+      # @return [Array<LoopDef>]
+      attr_reader :loop_defs
+
+      # @return [LoopDef, TableDef]
+      attr_reader :parent
+
+      delegate :requirement, :to => :entry_segment_use
+
+      delegate :required?, :to => :requirement
+
+      def initialize(id, repeat_count, header_segment_uses, loop_defs, trailer_segment_uses, parent)
+        @id, @repeat_count, @header_segment_uses, @loop_defs, @trailer_segment_uses, @parent =
+          id, repeat_count, 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 [LoopDef]
+      def copy(changes = {})
+        LoopDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:repeat_count, @repeat_count),
+          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?
+        @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?
+        @header_segment_uses.head.definition.id == :LS and
+        @trailer_segment_uses.last.definition.id == :LE
+      end
+
+      # @see X12.59 5.6 HL-initiated Loop
+      def hierarchical?
+        @header_segment_uses.head.definition.id == :HL
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @header_segment_uses.head
+      end
+
+      # @return [Array<SegmentUse, LoopDef>]
+      def children
+        @header_segment_uses + @loop_defs + @trailer_segment_uses
+      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 ""
+          @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 << LoopDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [LoopDef]
+      def build(id, repeat_count, *children)
+        header, children   = children.split_when{|x| x.is_a?(LoopDef) }
+        loop_defs, trailer = children.split_when{|x| x.is_a?(SegmentUse) }
+
+        # @todo: Ensure there is at least one SegmentUse in header
+        if header.empty?
+          raise Exceptions::InvalidSchemaError,
+            "first child must be a SegmentUse"
+        elsif header.head.repeat_count.include?(2)
+          "first child must have RepeatCount.bounded(1)"
+        end
+
+        new(id, repeat_count, header, loop_defs, trailer, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/schema/repeat_count.rb

@@ -0,0 +1,85 @@
+module Stupidedi
+  module Schema
+
+    class RepeatCount
+      class Bounded < RepeatCount
+        include Comparable
+
+        delegate :<=>, :to => :@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 Exception::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