stupidedi 1.1.0

data/lib/stupidedi/editor/implementation_ack.rb

@@ -0,0 +1,213 @@
+module Stupidedi
+  module Editor
+
+    # Generates an FA 999 acknowledgement
+    class ImplementationAck
+
+      def initialize(zipper, builder)
+        @builder = builder
+        @zipper  = zipper
+      end
+
+      def generate
+        @builder.ST("999", @builder.blank, "005010X231")
+
+        # GS01, GS06, and GS08 must all be present and valid. It is not clear
+        # how to respond when these elements are not valid (eg not an allowed
+        # value, not a number, too longo too short, etc) because copying the
+        # value to AK1 generates an invalid AK1 segment.
+        @builder.AK1(gs.element(1), # GS01: Functional Identifier
+                     gs.element(6), # GS06: Group Control Number
+                     gs.element(8)) # GS08: Industry Identifier
+
+          # ST01, ST02, and ST03 must all be present and valid. Like the AK1/GS
+          # paradox, there isn't a way to generate a valid response when the
+          # elements being acknowledged are not valid.
+          @builder.AK2(st.element(1), # ST01: Transaction Set Identifier Code
+                       st.element(2), # ST02: Transaction Set Control Number
+                       st.element(3)) # ST03: Implementation Guide Version
+
+            # M ID(2/3), M N0(1/10), O AN(1/4), O ID(1/3)
+            @builder.IK3(segment_id, segment_pos, loop_id, error_code)
+            #  1: Unrecoginzed segment ID
+            #  2: Unexpected segment
+            #  3: Required segment missing
+            #  4: Loop occurs over maximum times
+            #  5: Segment exceeds maximum use
+            #  6: Segment not defined in transaction set
+            #  7: Segment not in proper sequence
+            #  8: Segment has data element errors
+            # I4: Implementation "not used" segment present
+            # I6: Implementation situationally required segment missing
+            # I7: Implementation loop occurs under minimum times
+            # I8: Implementation segment below minimum use
+            # I9: Implementation situationally "not used" segment present
+
+          ### Required when IK304 = "I..."
+          ##@builder.CTX(
+          ##  @builder.composite("SITUATIONAL TRIGGER"),
+          ##  segment_id,
+          ##  segment_pos,
+          ##  loop_id,
+          ##  # Following two composites are required if the failed requirement
+          ##  # relates to an individual element, otherwise do not send
+          ##  @builder.composite(element_pos, component_pos, repeated_pos),
+          ##  @builder.composite(element_ref, component_ref))
+
+          ##@builder.CTX(
+          ### @builder.composite("TRN02", trn.element(2))
+          ### @builder.composite("NM109", nm1.element(9))
+          ### @builder.composite("ENT01", ent.element(1))
+          ### @builder.composite("REF02", ref.element(2))
+          ### @builder.composite("CLM01", clm.element(1)))
+
+              # M C030, O N0(1/4), M ID(1/3), O AN(1/99)
+              @builder.IK4(
+                @builder.composite(element_pos, component_pos, repeated_pos),
+                element_ref,
+                error_code,
+                element_data)
+              # Required when IK304 = "8"
+              #   1: Required data element missing
+              #   2: Conditional required data element missing
+              #   3: Too many data elements
+              #   4: Data element too short
+              #   5: Data element too long
+              #   6: Invalid character in data element
+              #   7: Invalid code value
+              #   8: Invalid date
+              #   9: Invalid time
+              #  10: Exclusion condition violated
+              #  12: Too many repetitions
+              #  13: Too many components
+              # I10: Implementation "not used" data element present
+              # I11: Implementation too few repetitions
+              # I12: Implementation pattern match failure
+              # I13: Implementation situationally "not used" data element present
+              #  I6: Code value not used in implementation
+              #  I9: Implementation situationally required data element missing
+
+            ### Required when IK404 = "I..."
+            ##@builder.CTX(
+            ##  @builder.composite("SITUATIONAL TRIGGER"),
+            ##  segment_id,
+            ##  segment_pos,
+            ##  loop_id,
+            ##  @builder.composite(element_pos, component_pos, repeated_pos),
+            ##  @builder.composite(element_ref, component_ref))
+
+
+          @builder.IK5(
+            acknowledgement_code,
+            error_code,
+            error_code,
+            error_code,
+            error_code,
+            error_code)
+          # A: Accepted
+          # E: Accepted but errors were noted
+          # R: Rejected
+          #
+          #  1: Transaction set not supported
+          #  2: Transaction set trailer missing
+          #  3: Transaction set control number in header and trailer do not match
+          #  4: Number of included segments does not match actual count
+          #  5: One or more segments in error
+          #  6: Missing or invalid transaction set identifier
+          #  7: Missing or invalid transaction set control number
+          # 17: Security not supported
+          # 18: Transaction set not in functional group
+          # 19: Invalid transaction set implementation convention reference
+          # 23: Transaction set control number not unique within the functional group
+          # I5: Implementation one or more segments in error
+          # I6: Implementation convention not supported
+
+        @builder.AK9(
+          acknowledgement_code,
+          included_count,
+          received_count,
+          accepted_count,
+          error_code,
+          error_code,
+          error_code,
+          error_code,
+          error_code)
+        # A: Accepted
+        # E: Accepted, but errors were found
+        # P: Partially accepted, at least one transaction set was rejected
+        # R: Rejecetd
+        #
+        #  1: Funcitonal group not supported
+        #  2: Functional group version not supported
+        #  3: Funcitonal group trailer missing
+        #  4: Group control number in the functional group header and trailer do not agree
+        #  5: Number of included transaction sets does not match actual count
+        #  6: Group control number violates syntax
+        # 16: Security not supported
+        # 19: Functional group control number not unique within interchange
+
+        @builder.ST(count, @builder.blank)
+      end
+
+    private
+
+      def validate(node)
+        if node.element?
+          if node.simple?
+            unless node.valid?
+              # 6: Invalid character in data element
+              # 8: Invalid date
+              # 9: Invalid time
+            end
+              #   3: Too many data elements
+              # I10: Implementation "not used" data element present
+              # I11: Implementation too few repetitions
+              # I12: Implementation pattern match failure
+              #  I6: Code value not used in implementation
+
+            if node.empty?
+              #   1: Required data element missing
+              #   2: Conditional required data element missing
+              #  I9: Implementation situationally required data element missing
+            else
+              #  10: Exclusion condition violated
+              # I13: Implementation situationally "not used" data element present
+
+              if node.too_long?
+                # 5: Data element too long
+              elsif node.too_short?
+                # 4: Data element too short
+              end
+
+              # 7: Invalid code value
+              unless node.allowed?
+              end
+            end
+          elsif node.repeated?
+              # 12: Too many repetitions
+          elsif node.composite?
+              # 13: Too many components
+          end
+        elsif node.segment?
+          if node.valid?
+          else
+            #  1: Unrecoginzed segment ID
+            #  2: Unexpected segment
+            #  6: Segment not defined in transaction set
+            #  7: Segment not in proper sequence
+            # I4: Implementation "not used" segment present
+          end
+            #  3: Required segment missing
+            #  4: Loop occurs over maximum times
+            #  5: Segment exceeds maximum use
+            #  8: Segment has data element errors
+            # I6: Implementation situationally required segment missing
+            # I7: Implementation loop occurs under minimum times
+            # I8: Implementation segment below minimum use
+            # I9: Implementation situationally "not used" segment present
+        end
+      end
+    end
+
+  end
+end

data/lib/stupidedi/editor/interchange_ack.rb

@@ -0,0 +1,9 @@
+module Stupidedi
+  module Editor
+
+    # Generates a TA1 acknowledgment
+    class InterchangeAck
+    end
+
+  end
+end

data/lib/stupidedi/editor/result.rb

@@ -0,0 +1,100 @@
+module Stupidedi
+  module Editor
+
+    class Result
+
+      # @return [Zipper::AbstractCursor]
+      abstract :zipper
+
+      # @return [String]
+      abstract :reason
+
+      def error?
+        false
+      end
+
+      def warning?
+        false
+      end
+    end
+
+    class Warning < Result
+
+      # @return [Zipper::AbstractCursor]
+      attr_reader :zipper
+
+      # @return [String]
+      attr_reader :reason
+
+      def initialize(zipper, reason)
+        @zipper, @reason =
+          zipper, reason
+      end
+
+      # @return [String]
+      def inspect
+        "Warning(#{@reason}, #{@zipper.node.inspect})"
+      end
+
+      def warning?
+        true
+      end
+    end
+
+    class Error < Result
+
+      # @return [Zipper::AbstractCursor]
+      attr_reader :zipper
+
+      # @return [String]
+      attr_reader :reason
+
+      # @return [String]
+      attr_reader :action
+
+      # @return [String]
+      attr_reader :code
+
+      def initialize(zipper, action, code, reason)
+        @zipper, @action, @code, @reason =
+          zipper, action, code, reason
+      end
+
+      # @return [String]
+      def inspect
+        name = self.class.name.split('::').last
+        "#{name}(#{zipper.node.position.inspect}, #{@reason}, #{@zipper.node.inspect})"
+      end
+
+      def error?
+        true
+      end
+    end
+
+    # TA1 Interchange Acknowledgement
+    class TA105 < Error
+    end
+
+    # 999 Implementation Acknowledgement
+    class AK905 < Error
+    end
+
+    # 999 Implementation Acknowledgement
+    class IK304 < Error
+    end
+
+    # 999 Implementation Acknowledgement
+    class IK403 < Error
+    end
+
+    # 999 Implementation Acknowledgement
+    class IK502 < Error
+    end
+
+    # 277 Claim Acknowledgment
+    class ClaimStatus < Error
+    end
+
+  end
+end
+

data/lib/stupidedi/editor/result_set.rb

@@ -0,0 +1,69 @@
+module Stupidedi
+  module Editor
+
+    class ResultSet
+      include Inspect
+
+      # @return [Array<Result>]
+      attr_reader :results
+
+      def initialize
+        @results = []
+
+        default  = lambda{|h,z| h[z] = [] }
+        @ta105s  = [] # Hash.new(&default)
+        @ak905s  = [] # Hash.new(&default)
+        @ik304s  = [] # Hash.new(&default)
+        @ik403s  = [] # Hash.new(&default)
+        @ik502s  = [] # Hash.new(&default)
+        @cscs    = [] # Hash.new(&default)
+        @csccs   = [] # Hash.new(&default)
+        @eics    = [] # Hash.new(&default)
+        @warns   = []
+      end
+
+      def ta105(*args)
+        result = TA105.new(*args)
+        @results << result
+        @ta105s  << result
+      end
+
+      def ak905(*args)
+        result = AK905.new(*args)
+        @results << result
+        @ak905s  << result
+      end
+
+      def ik304(*args)
+        result = IK304.new(*args)
+        @results << result
+        @ik304s  << result
+      end
+
+      def ik403(*args)
+        result = IK403.new(*args)
+        @results << result
+        @ik403s  << result
+      end
+
+      def ik502(*args)
+        result = IK502.new(*args)
+        @results << result
+        @ik502s  << result
+      end
+
+      def stc01(*args)
+      # result = ClaimStatus.new(*args)
+      # @results << result
+      # @cscs    << result
+      end
+
+      def warn(zipper, message)
+        result = Warning.new(zipper, message)
+        @results << result
+        @warns   << result
+      end
+    end
+
+  end
+end

data/lib/stupidedi/editor/transaction_set_ed.rb

@@ -0,0 +1,275 @@
+module Stupidedi
+  module Editor
+
+    class TransactionSetEd < AbstractEd
+
+      # @return [Config]
+      attr_reader :config
+
+      # @return [Time]
+      attr_reader :received
+
+      def initialize(config, received)
+        @config, @received =
+          config, received
+      end
+
+      def critique(st, acc)
+        st.parent.tap do |gs|
+          gs.parent.tap do |isa|
+            critique_isa(isa, acc)
+          end
+
+          critique_gs(gs, acc)
+        end
+
+        acc.tap { critique_st(st, acc) }
+      end
+
+    private
+
+      # Performs validations using the definition of the given ISA segment
+      def critique_isa(isa, acc)
+        isa.segment.tap do |x|
+          envelope_def = x.node.definition.parent.parent
+
+          # ...
+        end
+      end
+
+      # Performs validations using the definition of the given GS segment
+      def critique_gs(gs, acc)
+        gs.segment.tap do |x|
+          envelope_def = x.node.definition.parent.parent
+
+          # ...
+        end
+      end
+
+      # Performs validations using the definition of the given ST segment
+      def critique_st(st, acc)
+        st.segment.tap do |x|
+          envelope_def = x.node.definition.parent.parent.parent
+
+          # Transaction Set Identifier Code
+          st.element(1).tap do |e|
+            if e.node.present? and e.node.valid?
+              unless e.node == envelope_def.id
+                acc.ik502(e, "R", "6", "is not an allowed value")
+              end
+            end
+          end
+
+          st.parent.tap do |gs|
+            # Functional Identifier Code
+            gs.element(1).tap do |e|
+              if e.node.present? and e.node.valid?
+                unless e.node == envelope_def.functional_group
+                  acc.ak905(e, "R", "1", "is not an allowed value")
+                end
+              end
+            end
+          end
+
+          if config.editor.defined_at?(envelope_def)
+            editor = config.editor.at(envelope_def)
+            editor.new(config, received).critique(st, acc)
+          end
+        end
+
+        st.zipper.tap do |zipper|
+          until zipper.node.transaction_set?
+            zipper = zipper.up
+          end
+
+          recurse(zipper, acc)
+        end
+      end
+
+      # IK304 "3"   Segment must be present
+      # IK304 "I6"  Segment must be present
+      # IK304 "5"   Segment occurs too many times
+      # IK304 "4"   Loop occurs too many times
+      # IK304 "I7"  Loop must be present
+      #
+      # IK403 "1"   Element must be present
+      # IK403 "I10" Element must not be present
+      # IK403 "2"   Element must be present if other element(s) is (not) present
+      # IK403 "6"   Element must contain at least one character
+      # IK403 "4"   Element value is too short
+      # IK403 "5"   Element value is too long
+      # IK403 "6"   Element has invalid characters
+      # IK403 "7"   Invalid code value
+      # IK403 "8"   Invalid date
+      # IK403 "9"   Invalid time
+
+      def recurse(zipper, acc)
+        if zipper.node.simple? or zipper.node.component?
+          if zipper.node.invalid?
+            if zipper.node.date?
+              acc.ik403(zipper, "R", "8", "is not a valid date")
+            elsif zipper.node.time?
+              acc.ik403(zipper, "R", "8", "is not a valid time")
+            elsif zipper.node.numeric?
+              acc.ik403(zipper, "R", "6", "is not a valid number")
+            else
+              acc.ik403(zipper, "R", "6", "is not a valid string")
+            end
+          elsif zipper.node.blank?
+            if zipper.node.usage.required?
+              acc.ik403(zipper, "R", "1", "must be present")
+            end
+          elsif zipper.node.usage.forbidden?
+            acc.ik403(zipper, "R", "I10", "must not be present")
+          elsif not zipper.node.allowed?
+            acc.ik403(zipper, "R", "7", "is not an allowed value")
+          elsif zipper.node.too_long?
+            acc.ik403(zipper, "R", "5", "is too long")
+          elsif zipper.node.too_short?
+            acc.ik403(zipper, "R", "4", "is too short")
+          end
+
+        elsif zipper.node.composite?
+          if zipper.node.blank?
+            if zipper.node.usage.required?
+              acc.ik403(zipper, "R", "1", "must be present")
+            end
+          elsif zipper.node.usage.forbidden?
+            acc.ik403(zipper, "R", "I10", "must not be present")
+          else
+            if zipper.node.present?
+              zipper.children.each{|z| recurse(z, acc) }
+
+              d = zipper.node.definition
+              d.syntax_notes.each do |s|
+                zs = s.errors(zipper)
+                ex = s.reason(zipper) if zs.present?
+                zs.each{|c| acc.ik403(c, "R", "2", ex) }
+              end
+            end
+          end
+
+        elsif zipper.node.repeated?
+          zipper.children.each{|z| recurse(z, acc) }
+
+        elsif zipper.node.segment?
+          if zipper.node.valid?
+            zipper.children.each do |element|
+              recurse(element, acc)
+            end
+
+            zipper.node.definition.tap do |d|
+              d.syntax_notes.each do |s|
+                es = s.errors(zipper)
+                ex = s.reason(zipper) if es.present?
+                es.each{|c| acc.ik403(c, "R", "2", ex) }
+              end
+            end
+          else
+            acc.ik304(child, "R", "2", "unexpected segment")
+          end
+
+        elsif zipper.node.loop?
+          group = Hash.new{|h,k| h[k] = [] }
+
+          zipper.children.each do |child|
+            # Child is either a segment or loop
+            recurse(child, acc)
+
+            if child.node.loop?
+              group[child.node.definition] << child
+            elsif child.node.valid?
+              group[child.node.usage] << child
+            end
+          end
+
+          # Though we're iterating the definition tree, we need to track
+          # the last location before a required child was missing.
+          last = zipper
+
+          zipper.node.definition.children.each do |child|
+            repeat  = child.repeat_count
+            matches = group.at(child)
+
+            if matches.blank? and child.required?
+              if child.loop?
+                acc.ik304(last, "R", "I7", "missing #{child.id} loop")
+              else
+                acc.ik304(last, "R", "3", "missing #{child.id} segment")
+              end
+            elsif repeat < matches.length
+              matches.drop(repeat.max).each do |c|
+                if child.loop?
+                  acc.ik304(c, "R", "4", "loop occurs too many times")
+                else
+                  acc.ik304(c, "R", "5", "segment occurs too many times")
+                end
+              end
+            end
+
+            last = matches.last unless matches.blank?
+          end
+
+        elsif zipper.node.table?
+          group = Hash.new{|h,k| h[k] = [] }
+
+          zipper.children.each do |child|
+            # Child is either a segment or loop
+            recurse(child, acc)
+
+            if child.node.loop?
+              group[child.node.definition] << child
+            elsif child.node.valid?
+              group[child.node.usage] << child
+            end
+          end
+
+            # Though we're iterating the definition tree, we need to track
+            # the last location before a required child was missing.
+            last = zipper
+
+          zipper.node.definition.children.each do |child|
+            matches = group.at(child)
+            repeat  = child.repeat_count
+
+            if matches.blank? and child.required?
+              if child.loop?
+                acc.ik304(last, "R", "I7", "missing #{child.id} loop")
+              else
+                acc.ik304(last, "R", "3", "missing #{child.id} segment")
+              end
+            elsif repeat < matches.length
+              matches.drop(repeat.max).each do |c|
+                if child.loop?
+                  acc.ik304(c, "R", "4", "loop occurs too many times")
+                else
+                  acc.ik304(c, "R", "5", "segment occurs too many times")
+                end
+              end
+            end
+
+            last = matches.last unless matches.blank?
+          end
+
+        elsif zipper.node.transaction_set?
+          group = Hash.new{|h,k| h[k] = [] }
+
+          zipper.children.each do |table|
+            recurse(table, acc)
+            group[table.node.definition] << table
+          end
+
+          zipper.node.definition.tap do |d|
+            d.table_defs.each do |table|
+              # @todo: How do we know which tables are required? It isn't
+              # obvious because some tables have more than one entry segment,
+              # and perhaps each has a different requirement designator.
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+