stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/schema/functional_group_def.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   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
@@ -60,6 +58,15 @@ module Stupidedi
           changes.fetch(:trailer_segment_uses, @trailer_segment_uses)
       end
 
+      # @return [String]
+      def descriptor
+        "transaction set #{id}"
+      end
+
+      def required?
+        false
+      end
+
       # @return [SegmentUse]
       def entry_segment_use
         @header_segment_uses.head
@@ -113,6 +120,5 @@ module Stupidedi
         end
       end
     end
-
   end
 end

data/lib/stupidedi/schema/interchange_def.rb

@@ -1,10 +1,8 @@
 # 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
@@ -43,6 +41,15 @@ module Stupidedi
           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
@@ -92,6 +99,5 @@ module Stupidedi
         end
       end
     end
-
   end
 end

data/lib/stupidedi/schema/loop_def.rb

@@ -1,10 +1,8 @@
 # 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
@@ -58,6 +56,11 @@ module Stupidedi
           changes.fetch(:parent, @parent)
       end
 
+      # @return [String]
+      def descriptor
+        "loop #{id}"
+      end
+
       def repeatable?
         @repeat_count.try{|r| r.include?(2) }
       end
@@ -142,7 +145,24 @@ module Stupidedi
           raise Exceptions::InvalidSchemaError,
             "first child must be a SegmentUse"
         elsif header.head.repeat_count.include?(2)
-          "first child must have RepeatCount.bounded(1)"
+          raise Exceptions::InvalidSchemaError,
+            "first child must have RepeatCount.bounded(1)"
+        end
+
+        trailer.each.with_index do |s, k|
+          unless s.segment?
+            if s.respond_to?(:pretty_inspect)
+              raise Exceptions::InvalidSchemaError,
+                "arguments after last child LoopDef (#{loop_defs.last.id})
+                must be segments, but #{k+1} arguments later is not a
+                SegmentUse: #{s.pretty_inspect}".join
+            else
+              raise Exceptions::InvalidSchemaError,
+                "arguments after last child LoopDef (#{loop_defs.last.id})
+                must be segments, but #{k+1} arguments later is not a
+                SegmentUse: #{s.inspect}".join
+            end
+          end
         end
 
         new(id, repeat_count, header, loop_defs, trailer, nil)
@@ -151,6 +171,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
-
   end
 end

data/lib/stupidedi/schema/repeat_count.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
     class RepeatCount
       class Bounded < RepeatCount
         include Comparable
@@ -84,6 +82,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
-
   end
 end

data/lib/stupidedi/schema/segment_def.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
     #
     # @see X222.pdf B.1.1.3.4 Data Segment
     #
@@ -31,7 +29,7 @@ module Stupidedi
 
       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
+          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
@@ -51,6 +49,11 @@ module Stupidedi
           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)
@@ -115,6 +118,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
-
   end
 end

data/lib/stupidedi/schema/segment_req.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
+    #
     # The 5010 X12 "data segment requirement designator"s include
     #   M - Mandatory
     #   O - Optional
@@ -14,6 +13,7 @@ module Stupidedi
     # The HIPAA implementation guides "industry usage" include
     #   SITUATIONAL
     #   REQUIRED
+    #
     class SegmentReq
       def initialize(required, forbidden, to_s)
         @required, @forbidden, @to_s =
@@ -42,6 +42,5 @@ module Stupidedi
         @to_s
       end
     end
-
   end
 end

data/lib/stupidedi/schema/segment_use.rb

@@ -1,10 +1,8 @@
 # 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
     #
@@ -19,11 +17,15 @@ module Stupidedi
       # @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
       #
@@ -33,10 +35,6 @@ module Stupidedi
       # @return [LoopDef, TableDef]
       attr_reader :parent
 
-      def_delegators :definition, :id, :code_lists
-
-      def_delegators :requirement, :required?, :optional?
-
       def initialize(definition, position, requirement, repeat_count, parent)
         @definition, @position, @requirement, @repeat_count, @parent =
           definition, position, requirement, repeat_count, parent
@@ -97,6 +95,5 @@ module Stupidedi
         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

data/lib/stupidedi/schema/simple_element_use.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class SimpleElementUse < AbstractElementUse
+      # @return [SimpleElementDef]
+      attr_reader :definition
+
+      def_delegators :definition, :id, :name, :description
+
+      # @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 [String]
+      def descriptor
+        idx = parent.element_uses.index{|u| u.eql?(self) } + 1
+        "element #{parent.id}#{"%02d" % idx} #{definition.name}".strip
+      end
+
+      def repeatable?
+        @repeat_count.try{|r| r.include?(2) }
+      end
+
+      # @return true
+      def simple?
+        true
+      end
+
+      # @return false
+      def component?
+        false
+      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
+  end
+end

data/lib/stupidedi/schema/syntax_note.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
+    #
     # The 5010 X12 "condition code"s include
     #   P - Paired or Multiple (if one then all)
     #   R - Required (at least one)
@@ -16,7 +15,6 @@ module Stupidedi
     # @see X222.pdf B.1.1.3.9 Condition Designator
     #
     class SyntaxNote
-
       # @return [Array<Integer>]
       attr_reader :indexes
 
@@ -44,20 +42,11 @@ module Stupidedi
           required(zipper).all?{|c| c.node.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) }
       end
     end
-
   end
 end

data/lib/stupidedi/schema/table_def.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
     class TableDef < AbstractDef
       # @return [String]
       attr_reader :id
@@ -24,9 +22,9 @@ module Stupidedi
       # @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
+      def initialize(id, position, header_segment_uses, loop_defs, trailer_segment_uses, parent)
+        @id, @position, @header_segment_uses, @loop_defs, @trailer_segment_uses, @parent =
+          id, position, 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
@@ -42,27 +40,52 @@ module Stupidedi
         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
 
+      # @return [String]
+      def descriptor
+        "table #{id}"
+      end
+
       def repeatable?
-        @repeatable
+        @header_segment_uses.empty? and
+          @loop_defs.present?       and
+          @loop_defs.head.repeatable?
+      end
+
+      def repeat_count
+        if repeatable?
+          RepeatCount.unbounded
+        else
+          RepeatCount.bounded(1)
+        end
+      end
+
+      def required?
+        entry_segment_uses.any?(&:required?)
       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)
+        uses = @header_segment_uses \
+             + @loop_defs.map{|l| l.entry_segment_use } \
+             + @trailer_segment_uses
 
         # Up to and including the first required segment
-        opt, req = uses.split_until(&:optional?)
-        opt.concat(req.take(1))
+        suffix = uses.drop_while(&:optional?)
+
+        if suffix.present?
+          # Some segment(s) is required, so table can't start without it
+          position = suffix.map(&:position).min
+          uses.take_while{|u| u.position <= position }
+        else
+          # Nothing is required, table can begin at any of these
+          uses
+        end
       end
 
       # @return [Array<SegmentUse, LoopDef>]
@@ -120,28 +143,42 @@ module Stupidedi
 
       # @return [TableDef]
       def header(id, *children)
+        unless id.is_a?(String)
+          raise Exceptions::InvalidSchemaError,
+            "first argument to TableDef.header must be a String but got #{id.inspect}"
+        end
+
         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)
+        new(id, 1, header, loop_defs, trailer, nil)
       end
 
       # @return [TableDef]
-      def detail(id, *children, repeatable: true)
+      def detail(id, *children)
+        unless id.is_a?(String)
+          raise Exceptions::InvalidSchemaError,
+            "first argument to TableDef.detail must be a String but got #{id.inspect}"
+        end
+
         header, children   = children.split_when{|x| x.is_a?(LoopDef) }
         loop_defs, trailer = children.split_when{|x| x.is_a?(SegmentUse) }
-        new(id, 2, repeatable, header, loop_defs, trailer, nil)
+        new(id, 2, header, loop_defs, trailer, nil)
       end
 
       # @return [TableDef]
       def summary(id, *children)
+        unless id.is_a?(String)
+          raise Exceptions::InvalidSchemaError,
+            "first argument to TableDef.summary must be a String but got #{id.inspect}"
+        end
+
         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)
+        new(id, 3, header, loop_defs, trailer, nil)
       end
 
       # @endgroup
       #########################################################################
     end
-
   end
 end