stupidedi 1.1.0 → 1.2.1

data/lib/stupidedi/builder/navigation.rb

@@ -101,6 +101,14 @@ module Stupidedi
         end
       end
 
+      # Extracts the segment from the current state, if the current state is
+      # deterministic and positioned on a segment.
+      #
+      # @return [Either<Values::SegmentVal>>]
+      def segmentn
+        segment.map(&:node)
+      end
+
       # Extracts the *mth* element from the current segment, if the current
       # state is deterministic. Accepts optional arguments to extract a specific
       # occurrence of a repeated element and/or a specific component from a
@@ -141,7 +149,7 @@ module Stupidedi
                 "argument must be positive"
             end
 
-            limit = value.node.definition.repeat_count
+            limit = value.node.usage.repeat_count
             unless limit.include?(n)
               raise ArgumentError,
                 "#{designator} can only occur #{limit.max} times"
@@ -186,6 +194,16 @@ module Stupidedi
         end
       end
 
+      # Extracts the *mth* element from the current segment, if the current
+      # state is deterministic. Accepts optional arguments to extract a specific
+      # occurrence of a repeated element and/or a specific component from a
+      # composite element.
+      #
+      # @return [Either<Values::AbstractElementVal>]
+      def elementn(m, n = nil, o = nil)
+        element(m, n, o).map(&:node)
+      end
+
       # @group Navigating the Tree
       #########################################################################
 
@@ -298,7 +316,7 @@ module Stupidedi
       # there is a next segment. Optionally, a `count` argument may be
       # provided that indicates how many segments to advance.
       #
-      # @return [StateMachine]
+      # @return [Either<StateMachine>]
       def next(count = 1)
         unless count > 0
           raise ArgumentError,
@@ -385,7 +403,7 @@ module Stupidedi
       end
 
       # Returns a `StateMachine` positioned on the next matching segment,
-      # excluding {InvalidSegmentVal}s, that satisfies the given element
+      # excluding {Values::InvalidSegmentVal}s, that satisfies the given element
       # constraints. The search space is limited to certain related elements
       # described in [Navigating.md]
       #
@@ -398,7 +416,7 @@ module Stupidedi
       end
 
       # Returns a `StateMachine` positioned on the next matching segment,
-      # including {InvalidSegmentVal}s, that satisfies the given element
+      # including {Values::InvalidSegmentVal}s, that satisfies the given element
       # constraints. The search space is limited to certain related elements
       # described in [Navigating.md]
       #
@@ -420,14 +438,44 @@ module Stupidedi
         __count(true, id, elements)
       end
 
+      # Convenience method to iterate repeated occurrences of a segment by
+      # iteratively calling `find`. Beware this doesn't check that the segment
+      # is allowed to repeat, so calling `iterate(:XYZ)` may yield an `XYZ`
+      # segment and then throw an exception when searching for the second, if
+      # `XYZ` is not repeatable.
+      #
+      # @yieldparam   [StateMachine]
+      # @yieldreturn  [Object]
+      # @return       [Either<Array<Object>>]
       def iterate(id, *elements)
+        a = []
         m = find(id, *elements)
+        return m unless m.defined?
+
         while m.defined?
           m = m.flatmap do |n|
-            yield(n)
+            a << yield(n)
             n.find(id, *elements)
           end
         end
+
+        Either.success(a)
+      end
+
+      # Sequence multiple traversals together, by iteratively calling
+      # `find`. Each argument must be either a single segment ID or a
+      # list whose first element is a segment ID and remaining elements
+      # are segment constraints.
+      #
+      # @example
+      #   machine.sequence(:GS, :ST, :HL)
+      #   machine.sequence(:GS, [:ST, "837"], [:HL, nil, "20"])
+      #
+      # @return [Either<StateMachine>]
+      def sequence(pattern, *patterns)
+        patterns.inject(find(*pattern)) do |m, p|
+          m = m.flatmap{|n| n.find(*p) }
+        end
       end
 
     private
@@ -444,7 +492,13 @@ module Stupidedi
           instructions = zipper.node.instructions.matches(filter_tok, true)
           reachable  ||= !instructions.empty?
 
-          instructions.each do |op|
+          grouped = instructions.runs do |a,b|
+            a.push == b.push &&
+              a.pop_count == b.pop_count &&
+                a.drop_count == b.drop_count
+          end
+
+          grouped.each do |group|
             break if matched
 
             # Every transition follows the same shape
@@ -453,11 +507,12 @@ module Stupidedi
             # 3. Move downward a number of nodes
             # 4. Stop on a segment
 
+            op_,  = group
             state = zipper
             value = zipper.node.zipper
 
             # 1. Move upward (possibly zero times)
-            op.pop_count.times do
+            op_.pop_count.times do
               value = value.up
               state = state.up
             end
@@ -465,11 +520,21 @@ module Stupidedi
             # 2. We know from the instruction `op` the *maximum* number of
             #    nodes to move left, but not exactly how many. Instead, we
             #    know what the InstructionTable is when we get there.
-            target = zipper.node.instructions.pop(op.pop_count).drop(op.drop_count)
+            target = zipper.node.instructions.pop(op_.pop_count).drop(op_.drop_count)
+
+            # 3. If the segment we're searching for belongs in a new subtree,
+            #    but it's not the only segment that might have "opened" that
+            #    subtree (eg, Summary Table in 835 can begin with PLB or SE)
+            #    then maybe the segment we're looking for comes *after* the
+            #    first segment in this subtree.
+            #
+            #    This is computed lazily below: non_leaders ||= ...
+            non_leaders = nil
 
             until state.last?
               state = state.next
               value = value.next
+              ops   = group
 
               # 2. Even if the InstructionTable matches, we still need to
               #    descend to some segment and compare it to the criteria. In
@@ -481,27 +546,6 @@ module Stupidedi
                 _value = value
                 _state = state
 
-                # 3. If the segment we're searching for belongs in a new subtree,
-                #    but it's not the only segment that might have "opened" that
-                #    subtree (eg, Summary Table in 835 can begin with PLB or SE)
-                #    then maybe the segment we're looking for comes *after* the
-                #    first segment in this subtree.
-                single   = op.push.nil?
-                single ||= op.segment_use.nil?
-                single ||= 1 >= zipper.node.instructions.instructions.count do |x|
-                  x.push.present? and
-                   (# This is hairy, but we know the instruction is pushing some
-                    # number of nested subtrees. We know from each AbstractState
-                    # subclass that we both either push a single subtree
-                    op.segment_use.parent.eql?(x.segment_use.try(:parent)) or
-                    # Or this instruction pushes one subtree while the other one
-                    # pushes two (eg, a new loop inside of a table)
-                    op.segment_use.parent.eql?(x.segment_use.try(:parent).try(:parent)) or
-                    # Or this instruction pushes two subtrees (eg, a new loop in
-                    # a new table) and the other also pushes two subtrees.
-                    op.segment_use.parent.parent.eql?(x.segment_use.try(:parent)))
-                end
-
                 unless _value.node.segment?
                   _value = _value.down
                   _state = _state.down
@@ -525,7 +569,7 @@ module Stupidedi
                       # GS, and ST, because we can't know the SegmentUse until we
                       # deconstruct the token and looked up the versions numbers
                       # in the Config.
-                      (op.segment_use.nil? or op.segment_use.eql?(__value.node.usage)) \
+                      ops.any?{|op| op.segment_use.nil? or op.segment_use.eql?(__value.node.usage) } \
                         and not filter?(filter_tok, __value.node)
                     end
 
@@ -539,7 +583,25 @@ module Stupidedi
                     break
                   end
 
-                  break if single
+                  ops = non_leaders     ||= group.reject do |op|
+                    op.push.nil?        ||
+                    op.segment_use.nil? ||
+                    1 >= zipper.node.instructions.instructions.count do |x|
+                      x.push.present? and
+                       (# This is hairy, but we know the instruction is pushing some
+                        # number of nested subtrees. We know from each AbstractState
+                        # subclass that we both either push a single subtree
+                        op.segment_use.parent.eql?(x.segment_use.try(:parent)) or
+                        # Or this instruction pushes one subtree while the other one
+                        # pushes two (eg, a new loop inside of a table)
+                        op.segment_use.parent.eql?(x.segment_use.try(:parent).try(:parent)) or
+                        # Or this instruction pushes two subtrees (eg, a new loop in
+                        # a new table) and the other also pushes two subtrees.
+                        op.segment_use.parent.parent.eql?(x.segment_use.try(:parent)))
+                    end
+                  end
+
+                  break if ops.empty?
                   break if _value.last?
 
                   _value = _value.next
@@ -583,7 +645,7 @@ module Stupidedi
             end
           elsif f_tok.present?
             raise Exceptions::ParseError,
-              "only simple and component elements can be filtered"
+              "only simple and composite elements can be filtered"
           end
         end
 
@@ -606,7 +668,7 @@ module Stupidedi
             end
           elsif f_tok.present?
             raise Exceptions::ParseError,
-              "only simple and component elements can be filtered"
+              "only simple and composite elements can be filtered"
           end
         end
 

data/lib/stupidedi/config.rb

@@ -69,24 +69,40 @@ module Stupidedi
     def default
       new.customize do |c|
         c.interchange.customize do |x|
+          #x.register("00200") { Stupidedi::Versions::Interchanges::FourOhOne::InterchangeDef }
+          x.register("00200") { Stupidedi::Versions::Interchanges::TwoHundred::InterchangeDef }
+          x.register("00300") { Stupidedi::Versions::Interchanges::ThreeHundred::InterchangeDef }
+          x.register("00400") { Stupidedi::Versions::Interchanges::FourHundred::InterchangeDef }
+          x.register("00401") { Stupidedi::Versions::Interchanges::FourOhOne::InterchangeDef }
           x.register("00501") { Stupidedi::Versions::Interchanges::FiveOhOne::InterchangeDef }
         end
 
         c.functional_group.customize do |x|
+          # x.register("002001") { Stupidedi::Versions::FunctionalGroups::FortyTen::FunctionalGroupDef }
+          x.register("002001") { Stupidedi::Versions::FunctionalGroups::TwoThousandOne::FunctionalGroupDef }
+          x.register("003010") { Stupidedi::Versions::FunctionalGroups::ThirtyTen::FunctionalGroupDef }
+          x.register("003040") { Stupidedi::Versions::FunctionalGroups::ThirtyForty::FunctionalGroupDef }
+          x.register("003050") { Stupidedi::Versions::FunctionalGroups::ThirtyFifty::FunctionalGroupDef }
+          x.register("004010") { Stupidedi::Versions::FunctionalGroups::FortyTen::FunctionalGroupDef }
           x.register("005010") { Stupidedi::Versions::FunctionalGroups::FiftyTen::FunctionalGroupDef }
         end
+      end
+    end
 
+    def hipaa(base = default)
+      base.customize do |c|
         c.transaction_set.customize do |x|
+          x.register("004010", "HP", "835") { Stupidedi::Versions::FunctionalGroups::FortyTen::TransactionSetDefs::HP835 }
           x.register("005010", "HN", "277") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HN277 }
           x.register("005010", "HP", "835") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HP835 }
           x.register("005010", "HC", "837") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HC837 }
           x.register("005010", "FA", "999") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::FA999 }
 
-          x.register("005010X214", "HN", "277") { Stupidedi::Guides::FiftyTen::X214::HN277  }
-          x.register("005010X221", "HP", "835") { Stupidedi::Guides::FiftyTen::X221::HP835  }
-          x.register("005010X222", "HC", "837") { Stupidedi::Guides::FiftyTen::X222::HC837P }
-          x.register("005010X231", "FA", "999") { Stupidedi::Guides::FiftyTen::X231::FA999  }
-
+          x.register("004010X091A1", "HP", "835") { Stupidedi::Guides::FortyTen::X091A1::HP835 }
+          x.register("005010X214",   "HN", "277") { Stupidedi::Guides::FiftyTen::X214::HN277  }
+          x.register("005010X221",   "HP", "835") { Stupidedi::Guides::FiftyTen::X221::HP835  }
+          x.register("005010X222",   "HC", "837") { Stupidedi::Guides::FiftyTen::X222::HC837P }
+          x.register("005010X231",   "FA", "999") { Stupidedi::Guides::FiftyTen::X231::FA999  }
           x.register("005010X221A1", "HP", "835") { Stupidedi::Guides::FiftyTen::X221A1::HP835  }
           x.register("005010X222A1", "HC", "837") { Stupidedi::Guides::FiftyTen::X222A1::HC837P }
           x.register("005010X231A1", "FA", "999") { Stupidedi::Guides::FiftyTen::X231A1::FA999  }
@@ -94,6 +110,38 @@ module Stupidedi
       end
     end
 
+    def contrib(base = default)
+      base.customize do |c|
+        c.transaction_set.customize do |x|
+          x.register("004010", "PO", "850") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::PO850 }
+          x.register("004010", "OW", "940") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::OW940 }
+          x.register("004010", "AR", "943") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::AR943 }
+          x.register("004010", "RE", "944") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::RE944 }
+          x.register("004010", "SW", "945") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::SW945 }
+          x.register("004010", "SM", "204") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::SM204 }
+          x.register("004010", "QM", "214") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::QM214 }
+          x.register("004010", "GF", "990") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::GF990 }
+          x.register("004010", "SS", "862") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::SS862 }
+          x.register("004010", "PS", "830") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::PS830 }
+          x.register("004010", "SH", "856") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::SH856 }
+          x.register("004010", "SQ", "866") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::SQ866 }
+          x.register("004010", "FA", "997") { Stupidedi::Contrib::FortyTen::TransactionSetDefs::FA997 }
+
+          x.register("002001", "SH", "856") { Stupidedi::Contrib::TwoThousandOne::TransactionSetDefs::SH856 }
+          x.register("002001", "PO", "830") { Stupidedi::Contrib::TwoThousandOne::TransactionSetDefs::PO830 }
+          x.register("002001", "FA", "997") { Stupidedi::Contrib::TwoThousandOne::TransactionSetDefs::FA997 }
+
+          x.register("003010", "RA", "820") { Stupidedi::Contrib::ThirtyTen::TransactionSetDefs::RA820 }
+          x.register("003010", "PO", "850") { Stupidedi::Contrib::ThirtyTen::TransactionSetDefs::PO850 }
+          x.register("003010", "PC", "860") { Stupidedi::Contrib::ThirtyTen::TransactionSetDefs::PC860 }
+
+          x.register("003040", "WA", "142") { Stupidedi::Contrib::ThirtyForty::TransactionSetDefs::WA142 }
+
+          x.register("003050", "PO", "850") { Stupidedi::Contrib::ThirtyFifty::TransactionSetDefs::PO850 }
+        end
+      end
+    end
+
     # @endgroup
     ###########################################################################
   end

data/lib/stupidedi/config/editor_config.rb

@@ -20,8 +20,7 @@ module Stupidedi
         true # @todo
       end
 
-      # @param [Class]  definition
-      # @param [String] definition
+      # @param [Class, String] definition
       def register(definition, &constructor)
         @table[definition] = constructor
       end

data/lib/stupidedi/config/functional_group_config.rb

@@ -19,7 +19,8 @@ module Stupidedi
     class FunctionalGroupConfig
       include Inspect
 
-      delegate :defined_at?, :to => :@table
+      extend Forwardable
+      def_delegators :@table, :defined_at?
 
       def initialize
         @table = Hash.new

data/lib/stupidedi/config/interchange_config.rb

@@ -27,8 +27,10 @@ module Stupidedi
     class InterchangeConfig
       include Inspect
 
-      delegate :defined_at?, :to => :@table
+      extend Forwardable
+      def_delegators :@table, :defined_at?
 
+      
       def initialize
         @table = Hash.new
       end

data/lib/stupidedi/contrib.rb

@@ -0,0 +1,9 @@
+module Stupidedi
+  module Contrib
+    autoload :FortyTen,   		"stupidedi/contrib/004010"
+    autoload :TwoThousandOne,  	"stupidedi/contrib/002001"
+    autoload :ThirtyTen,  		"stupidedi/contrib/003010"
+    autoload :ThirtyForty,  	"stupidedi/contrib/003040"
+    autoload :ThirtyFifty,  	"stupidedi/contrib/003050"
+  end
+end

data/lib/stupidedi/contrib/002001.rb

@@ -0,0 +1,13 @@
+module Stupidedi
+  module Contrib
+    module TwoThousandOne
+
+      autoload :Guides,
+        "stupidedi/contrib/002001/guides"
+
+      autoload :TransactionSetDefs,
+        "stupidedi/contrib/002001/transaction_set_defs"
+
+    end
+  end
+end

data/lib/stupidedi/contrib/002001/guides.rb

@@ -0,0 +1,20 @@
+module Stupidedi
+  module Contrib
+    module TwoThousandOne
+      module Guides
+
+        # GuideBuilder = Stupidedi::Guides::TwoThousandOne::GuideBuilder
+        # SegmentReqs  = Stupidedi::Guides::TwoThousandOne::SegmentReqs
+        # ElementReqs  = Stupidedi::Guides::TwoThousandOne::ElementReqs
+
+        GuideBuilder = Stupidedi::Guides::FortyTen::GuideBuilder
+        SegmentReqs  = Stupidedi::Guides::FortyTen::SegmentReqs
+        ElementReqs  = Stupidedi::Guides::FortyTen::ElementReqs
+
+        autoload :SH856, "stupidedi/contrib/002001/guides/SH856"
+        autoload :PO830, "stupidedi/contrib/002001/guides/PO830"
+        autoload :FA997, "stupidedi/contrib/002001/guides/FA997"
+      end
+    end
+  end
+end

data/lib/stupidedi/contrib/002001/guides/FA997.rb

@@ -0,0 +1,80 @@
+module Stupidedi
+  module Contrib
+    module TwoThousandOne
+      module Guides
+
+        b = GuideBuilder
+        d = Schema
+        r = SegmentReqs
+        e = ElementReqs
+        s = Versions::FunctionalGroups::TwoThousandOne::SegmentDefs
+        t = Contrib::TwoThousandOne::TransactionSetDefs
+
+        #
+        # Response to a Load Tender
+        #
+        FA997 = b.build(t::FA997,
+          d::TableDef.header("Heading",
+            b::Segment(10, s::ST, "Transaction Set Header",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Transaction Set Identifier Code"),
+              b::Element(e::Required,    "Transaction Set Control Number")),
+
+            b::Segment(20, s::AK1, "Functional Group Response Header",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Situational, "Functional Identifier Code"),
+              b::Element(e::Required,    "Group Control Number")),
+
+            d::LoopDef.build("AK2", d::RepeatCount.bounded(999999),
+              b::Segment(30, s::AK2, "Transaction Set Response Header",
+                r::Situational, d::RepeatCount.bounded(1),
+                b::Element(e::Required,    "Transaction Set Identifier Code"),
+                b::Element(e::Required,    "Transaction Set Control Number")),
+
+              d::LoopDef.build("AK3", d::RepeatCount.bounded(999999),
+                b::Segment( 40, s::AK3, "Data Segment Note",
+                  r::Situational, d::RepeatCount.bounded(1),
+                  b::Element(e::Required,    "Segment ID Code"),
+                  b::Element(e::Required,    "Segment Position in Transaction Set"),
+                  b::Element(e::Situational, "Loop Identifier Code"),
+                  b::Element(e::Situational, "Segment Syntax Error Code")),
+
+                b::Segment( 50, s::AK4, "Data Element Note",
+                  r::Situational, d::RepeatCount.bounded(99),
+                  b::Element(e::Required,    "Position in Segment",
+                      b::Element(e::Required,    "Element Position in Segment"),
+                      b::Element(e::Situational, "Component Data Element Position in Composite")),
+                  b::Element(e::Situational, "Data Element Reference Number"),
+                  b::Element(e::Required,    "Data Element Syntax Error Code"),
+                  b::Element(e::Situational, "Copy of Bad Data Element"))),
+
+              b::Segment( 60, s::AK5, "Transaction Set Response Trailer",
+                r::Required, d::RepeatCount.bounded(1),
+                b::Element(e::Required,    "Transaction Set Acknowledgment Code"),
+                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
+                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
+                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
+                b::Element(e::Situational, "Transaction Set Syntax Error Code"),
+                b::Element(e::Situational, "Transaction Set Syntax Error Code"))),
+
+            b::Segment( 70, s::AK9, "Functional Group Response Trailer",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Functional Group Acknowledge Code"),
+              b::Element(e::Required,    "Number of Transaction Sets Included"),
+              b::Element(e::Required,    "Number of Received Transaction Sets"),
+              b::Element(e::Required,    "Number of Accepted Transaction Sets"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code")),
+
+            b::Segment( 80, s::SE, "Transaction Set Trailer",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Number of Included Segments"),
+              b::Element(e::Required,    "Transaction Set Control Number"))))
+
+      end
+    end
+  end
+end