stupidedi 1.1.0 → 1.2.1

data/lib/stupidedi/guides/004010/element_reqs.rb

@@ -0,0 +1,38 @@
+module Stupidedi
+  module Guides
+    module FortyTen
+
+      #
+      # @see X222.pdf 2.2 Implementation Usage
+      #
+      module ElementReqs
+
+        # Declares that this element must always be sent. Required elements
+        # within Situational segments when the segment occurs.
+        #
+        # Similarly, required component elements within situational composite
+        # elements only occur when the composite element occurs.
+        Required = Schema::ElementReq.new(true,  false, "R")
+
+        # Use of this element varies, depending on data content and business
+        # context as described in the defining rule. The defining rule is
+        # documented in a Situational Rule attached to the element.
+        #
+        # There are two forms of Situational Rules. The first is "Required when
+        # <condition>. If not required by <condition>, the element may be
+        # provided at the discretion of the sender, but it cannot be required or
+        # requested by the receiver.'
+        #
+        # The other form is "Required when <condition>. If not required by
+        # <condition>, do not send". The element described by the rule cannot
+        # occur except when the condition holds.
+        Situational = Schema::ElementReq.new(false, false, "S")
+
+        # This element must never be sent.
+        NotUsed = Schema::ElementReq.new(false, true,  "N")
+
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides/004010/guide_builder.rb

@@ -0,0 +1,180 @@
+module Stupidedi
+  module Guides
+    module FortyTen
+
+      #
+      # {GuideBuilder} is a simple DSL for construction an implementation guide.
+      #
+      module GuideBuilder
+      end
+
+      class << GuideBuilder
+
+        # @return [Schema::TransactionSetDef]
+        def build(transaction_set_def, *table_defs)
+          transaction_set_def.copy(:table_defs => table_defs)
+        end
+
+        # @group Element Constraints
+        #######################################################################
+
+        # @param [String, ...] values
+        def Values(*values)
+          [:Values, values]
+        end
+
+        # @param [Integer] n
+        def MaxLength(n)
+          [:MaxLength, n]
+        end
+
+        # @param [Integer] n
+        def MaxPrecision(n)
+          [:MaxPrecision, n]
+        end
+
+        # @endgroup
+        #######################################################################
+
+        # @group Definition Constructors
+        #######################################################################
+
+        # @param [Schema::ElementReq] requirement
+        # @param [String] name
+        def Element(requirement, name, *constraints)
+          [:Element, requirement, name, constraints]
+        end
+
+        # @return [SegmentUse]
+        def Segment(position, segment_def, name, requirement, repeat_count, *elements)
+          unless elements.length == segment_def.element_uses.length
+            raise Exceptions::InvalidSchemaError,
+              "segment #{segment_def.id} has #{segment_def.element_uses.length}" <<
+              " elements but #{elements.length} arguments were specified"
+          end
+
+          element_index = "00"
+          element_uses  = elements.zip(segment_def.element_uses).map do |e, u|
+            e_tag, e_requirement, e_name, e_arguments = e
+            element_index.succ!
+
+            unless e_tag == :Element
+              raise Exceptions::InvalidSchemaError,
+                "given argument for #{segment_def.id}#{element_index} must be Element(...)"
+            end
+
+            if u.composite?
+              e_repeat_count, e_arguments = e_arguments.partition{|x| x.is_a?(Schema::RepeatCount) }
+
+              changes = Hash.new
+              changes[:requirement] = e_requirement
+
+              if e_repeat_count.length == 1
+                changes[:repeat_count] = e_repeat_count.head
+              elsif e_repeat_count.length > 1
+                raise Exceptions::InvalidSchemaError,
+                  "more than one RepeatCount was specified"
+              end
+
+              unless e_requirement.forbidden?
+                unless e_arguments.length == u.definition.component_uses.length
+                  raise Exceptions::InvalidSchemaError,
+                    "composite element #{u.definition.id} at #{segment_def.id}" <<
+                    "#{element_index} has #{u.definition.component_uses.length}" <<
+                    " component elements but #{e_arguments.length} were given"
+                end
+
+                # ComponentElementUses
+                component_index = "00"
+                component_uses  = e_arguments.zip(u.definition.component_uses).map do |e, c|
+                  c_tag, c_requirement, c_name, c_arguments = e
+                  component_index.succ!
+
+                  unless c_tag == :Element
+                    raise Exceptions::InvalidSchemaError,
+                      "given argument for #{segment_def.id}#{element_index}" <<
+                      "-#{component_index} must be Element(...)"
+                  end
+
+                  mod_element(c, c_requirement, c_name, c_arguments)
+                end
+
+                changes[:definition] = u.definition.copy(:name           => e_name,
+                                                         :component_uses => component_uses)
+              else
+                changes[:definition] = u.definition.copy(:name => e_name)
+              end
+
+              u.copy(changes)
+            else
+              mod_element(u, e_requirement, e_name, e_arguments)
+            end
+          end
+
+          segment_def.copy(:name => name).
+            copy(:element_uses => element_uses).
+            use(position, requirement, repeat_count)
+        end
+
+        # @endgroup
+        #######################################################################
+
+       private
+
+        # @return [Schema::SimpleElementUse]
+        def mod_element(element_use, requirement, name, arguments)
+          unless requirement.is_a?(Schema::ElementReq)
+            raise Exceptions::InvalidSchemaError,
+              "first argument to Element must be a Schema::ElementReq but got #{requirement.inspect}"
+          end
+
+          unless name.is_a?(String)
+            raise Exceptions::InvalidSchemaError,
+              "element name must be a String"
+          end
+
+          changes = Hash.new # changes to SegmentUse
+          dhanges = Hash.new # changes to SegmentDef
+
+          changes[:requirement] = requirement
+          changes[:definition]  = element_use.definition.copy(:name => name)
+
+          repeat_count = arguments.select{|x| x.is_a?(Schema::RepeatCount) }
+
+          if repeat_count.length == 1
+            changes[:repeat_count] = repeat_count.head
+          elsif repeat_count.length > 1
+            raise Exceptions::InvalidSchemaError,
+              "more than one RepeatCount specified for this Element"
+          end
+
+          allowed_values = arguments.select{|x| x.is_a?(Array) and x.head == :Values }
+
+          if allowed_values.length == 1
+            changes[:allowed_values] = element_use.allowed_values.replace(allowed_values.head.last)
+          elsif allowed_values.length > 1
+            raise Exceptions::InvalidSchemaError,
+              "more than one Values specified for this Element"
+          end
+
+          max_length = arguments.select{|x| x.is_a?(Array) and x.head == :MaxLength }
+
+          if max_length.length == 1
+            dhanges[:max_length] = max_length.head.last
+          elsif max_length.length > 1
+            raise Exceptions::InvalidSchemaError,
+              "more than one MaxLength specified for this Element"
+          end
+
+          if dhanges.empty?
+            element_use.copy(changes)
+          else
+            element_use.copy(changes.merge(:definition =>
+              element_use.definition.copy(dhanges)))
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides/004010/segment_reqs.rb

@@ -0,0 +1,32 @@
+module Stupidedi
+  module Guides
+    module FortyTen
+
+      #
+      # @see X222.pdf 2.2 Implementation Usage
+      #
+      module SegmentReqs
+
+        # Declares that this segment must always be sent. Required segments
+        # within Situational loops only occur when the loop occurs.
+        Required = Schema::SegmentReq.new(true,  false, "R")
+
+        # Use of this segment varies, depending on data content and business
+        # context as described in the defining rule. The defining rule is
+        # documented in a Situational Rule attached to the segment.
+        #
+        # There are two forms of Situational Rules. The first is "Required when
+        # <condition>. If not required by <condition>, the segment may be
+        # provided at the discretion of the sender, but it cannot be required or
+        # requested by the receiver.'
+        #
+        # The other form is "Required when <condition>. If not required by
+        # <condition>, do not send". The segment described by the rule cannot
+        # occur except when the condition holds.
+        Situational = Schema::SegmentReq.new(false, false, "S")
+
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides/005010.rb

@@ -8,7 +8,6 @@ module Stupidedi
 
       autoload :SegmentReqs,  "stupidedi/guides/005010/segment_reqs"
       autoload :ElementReqs,  "stupidedi/guides/005010/element_reqs"
-
       autoload :GuideBuilder, "stupidedi/guides/005010/guide_builder"
 
       module X214

data/lib/stupidedi/guides/005010/X222-HC837P.rb

@@ -1879,7 +1879,7 @@ module Stupidedi
 
           d::TableDef.detail("Table 2 - Billing Provider Detail",
             d::LoopDef.build("2000A BILLING PROVIDER HIERARCHICAL LEVEL",
-              d::RepeatCount.unbounded,
+              d::RepeatCount.bounded(1),
               b::Segment(10, s::HL, "Billing Provider Hierarchical Level",
                 r::Required, d::RepeatCount.bounded(1),
                 b::Element(e::Required,    "Hierarchical ID Number"),
@@ -2045,7 +2045,7 @@ module Stupidedi
 
           d::TableDef.detail("Table 2 - Subscriber Detail",
             d::LoopDef.build("2000B SUBSCRIBER HIERARCHICAL LEVEL",
-              d::RepeatCount.unbounded,
+              d::RepeatCount.bounded(1),
               b::Segment(10, s::HL, "Subscriber Hierarchical Level",
                 r::Required, d::RepeatCount.bounded(1),
                 b::Element(e::Required,    "Hierarchical ID Number"),
@@ -2187,7 +2187,7 @@ module Stupidedi
 
           d::TableDef.detail("Table 2 - Patient Detail",
             d::LoopDef.build("2000C PATIENT HIERARCHICAL LEVEL",
-              d::RepeatCount.unbounded,
+              d::RepeatCount.bounded(1),
               b::Segment(10, s::HL, "Patient Hierachical Level",
                 r::Situational, d::RepeatCount.bounded(1),
                 b::Element(e::Required,    "Hierarchical ID Number"),

data/lib/stupidedi/guides/005010/X222A1-HC837P.rb

@@ -1879,7 +1879,7 @@ module Stupidedi
 
           d::TableDef.detail("Table 2 - Billing Provider Detail",
             d::LoopDef.build("2000A BILLING PROVIDER HIERARCHICAL LEVEL",
-              d::RepeatCount.unbounded,
+              d::RepeatCount.bounded(1),
               b::Segment(10, s::HL, "Billing Provider Hierarchical Level",
                 r::Required, d::RepeatCount.bounded(1),
                 b::Element(e::Required,    "Hierarchical ID Number"),
@@ -2045,7 +2045,7 @@ module Stupidedi
 
           d::TableDef.detail("Table 2 - Subscriber Detail",
             d::LoopDef.build("2000B SUBSCRIBER HIERARCHICAL LEVEL",
-              d::RepeatCount.unbounded,
+              d::RepeatCount.bounded(1),
               b::Segment(10, s::HL, "Subscriber Hierarchical Level",
                 r::Required, d::RepeatCount.bounded(1),
                 b::Element(e::Required,    "Hierarchical ID Number"),
@@ -2187,7 +2187,7 @@ module Stupidedi
 
           d::TableDef.detail("Table 2 - Patient Detail",
             d::LoopDef.build("2000C PATIENT HIERARCHICAL LEVEL",
-              d::RepeatCount.unbounded,
+              d::RepeatCount.bounded(1),
               b::Segment(10, s::HL, "Patient Hierachical Level",
                 r::Situational, d::RepeatCount.bounded(1),
                 b::Element(e::Required,    "Hierarchical ID Number"),

data/lib/stupidedi/guides/005010/guide_builder.rb

@@ -12,6 +12,26 @@ module Stupidedi
 
         # @return [Schema::TransactionSetDef]
         def build(transaction_set_def, *table_defs)
+          table_defs.each do |t|
+            next unless t.repeatable?
+
+            search = [t.header_segment_uses, t.loop_defs, t.trailer_segment_uses]
+            search.each do |s|
+              opt, req = s.split_until(&:optional?)
+              prefix   = opt.concat(req.take(1))
+
+              if x = prefix.find(&:repeatable?)
+                raise Exceptions::InvalidSchemaError,
+                  "#{x.id} is an entry point into #{t.id}. Both are marked " <<
+                  "repeatable, but only one should be repeatable to avoid "  <<
+                  "generating an ambiguous grammar. You probably want to "   <<
+                  "change the repeat count of #{x.id}"
+              end
+
+              break if req.present?
+            end
+          end
+
           transaction_set_def.copy(:table_defs => table_defs)
         end
 
@@ -80,7 +100,7 @@ module Stupidedi
                 unless e_arguments.length == u.definition.component_uses.length
                   raise Exceptions::InvalidSchemaError,
                     "composite element #{u.definition.id} at #{segment_def.id}" <<
-                    "#{element_index} has #{u.definition.element_uses.length}" <<
+                    "#{element_index} has #{u.definition.component_uses.length}" <<
                     " component elements but #{e_arguments.length} were given"
                 end
 

data/lib/stupidedi/reader/input/abstract_input.rb

@@ -60,24 +60,28 @@ module Stupidedi
       # The current position as the number of elements previously read
       #
       # @return [Integer]
-      delegate :offset, :to => :position
-
+      extend Forwardable
+      def_delegators :position, :offset
+      
       # The line of the current position
       #
       # @return [Integer]
-      delegate :line, :to => :position
 
+      def_delegators :position, :line
+      
       # The column of the current position. The column resets to `1` each time
       # a newline is read
       #
       # @return [Integer]
-      delegate :column, :to => :position
 
+      def_delegators :position, :column
+      
       # The file name, URI, etc that identifies the input stream
       #
       # @return [String]
-      delegate :path, :to => :position
 
+      def_delegators :position, :path
+      
       # @group Reading the Input
       ########################################################################
 
@@ -99,7 +103,7 @@ module Stupidedi
       #
       # @return [Integer]
       # @return nil if `element` is not present in the input
-      abstract :index, :args => %w(value)
+      abstract :index, :args => %w(element)
 
       # @group Advancing the Cursor
       ########################################################################

data/lib/stupidedi/reader/input/delegated_input.rb

@@ -29,14 +29,17 @@ module Stupidedi
       ########################################################################
 
       # (see AbstractInput#take)
-      delegate :take, :to => :@delegate
-
+      extend Forwardable
+      def_delegators :@delegate, :take
+      
       # (see AbstractInput#at)
-      delegate :at, :to => :@delegate
 
+      def_delegators :@delegate, :at
+      
       # (see AbstractInput#index)
-      delegate :index, :to => :@delegate
 
+      def_delegators :@delegate, :index
+      
       # @group Advancing the Cursor
       ########################################################################
 
@@ -66,13 +69,14 @@ module Stupidedi
       ########################################################################
 
       # (see AbstractInput#defined_at?)
-      delegate :defined_at?, :to => :@delegate
+      def_delegators :@delegate, :defined_at?
 
       # (see AbstractInput#empty?)
-      delegate :empty?, :to => :@delegate
+      def_delegators :@delegate, :empty?
 
+    
       # (see AbstractInput#==)
-      delegate :==, :to => :@delegate
+      def_delegators :@delegate, :==
 
       # @endgroup
       ########################################################################

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

@@ -10,8 +10,9 @@ module Stupidedi
 
       attr_reader :position
 
-      delegate :remainder, :to => "element_toks.last"
-
+      extend Forwardable
+      def_delegators "element_toks.last", :remainder
+  
       def initialize(element_toks, position)
         @element_toks, @position =
           element_toks, position

data/lib/stupidedi/schema.rb

@@ -1,7 +1,7 @@
 module Stupidedi
   module Schema
-    autoload :AbstractDef,  "stupidedi/schema/abstract_def"
-    autoload :AbstractUse,  "stupidedi/schema/abstract_use"
+    autoload :AbstractDef,          "stupidedi/schema/abstract_def"
+    autoload :AbstractUse,          "stupidedi/schema/abstract_use"
 
     autoload :CodeList,             "stupidedi/schema/code_list"
     autoload :ElementReq,           "stupidedi/schema/element_req"
@@ -13,16 +13,16 @@ module Stupidedi
     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 :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"
+    autoload :TransactionSetDef,    "stupidedi/schema/transaction_set_def"
+    autoload :FunctionalGroupDef,   "stupidedi/schema/functional_group_def"
+    autoload :InterchangeDef,       "stupidedi/schema/interchange_def"
   end
 end