stupidedi 1.3.21 → 1.3.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dca3cbe38e197d5e24eb127bb9ea501a7417e8ebdef6ce29c0841cd8a7f618f8
-  data.tar.gz: d7d967d793ee60bed8b4f4794f1168a102c07369db5deb1814727ff14d6a4b4e
+  metadata.gz: 837e13488c24a9cd85bc735feda78b9b59b3c04655389a6ee192c8be4098570d
+  data.tar.gz: 7f569b2a9ba3d81b7fc539e9c2ff1cb6a1693bca2e289c3b4ba23876b8263564
 SHA512:
-  metadata.gz: 075d7961db6721b5e60125c7a1fc98e58ed1a2847c55dce06c9ff138a0a0d745a95ca0d798e6c38923fbdfa250b60b6c026a4242fe308d7df170385b3b44ef9c
-  data.tar.gz: a899f00431881d6edd7cbf083c551f70af676bff1cc9b21df8dcbd9bc41723bf8dab402484f3a028b79b05c7abcbec745c3b95dd854c10a0c9337d62e03eb632
+  metadata.gz: 501651cef1151a4f2121a3a026f7ebf5ed62eec5cd021429ad8190f6ea4d6b286df817f2bda6a6f100326a7e78121484aa6839f5545c41799607144fd83d372c
+  data.tar.gz: 847782f2907e2caf81dd00f39b74b16a9c9f84ff70ea7e69014c6374d5ac9a60e9b7f028376a55c72bdc2fe9d91f2dcb48299d855e385381f7f89ed415dfa7bf

data/lib/stupidedi/builder/builder_dsl.rb

@@ -18,6 +18,9 @@ module Stupidedi
       # @return [Boolean]
       attr_writer :strict
 
+      # @return [DslReader]
+      attr_reader :reader
+
       def_delegators :@machine, :pretty_print, :segment, :element, :zipper, :successors, :empty?, :first?, :last?, :deterministic?
 
       def initialize(machine, strict = true)
@@ -80,6 +83,8 @@ module Stupidedi
               while p.respond_to?(:parent)
                 break if qancestors.include?(p)
 
+                # Now that we're sure that this syntax node (loop, table, etc)
+                # is done being constructed, we can perform more validations.
                 critique(p)
                 p = p.parent
               end

data/lib/stupidedi/builder/constraint_table.rb

@@ -24,6 +24,9 @@ module Stupidedi
       # @return [Array<Instruction>]
       abstract :matches, :args => %w(segment_tok)
 
+      # @return [Array<Instruction>]
+      attr_reader :instructions
+
       #
       # Performs no filtering of the {Instruction} list. This is used when there
       # already is a single {Instruction} or when a {Reader::SegmentTok} doesn't
@@ -107,21 +110,25 @@ module Stupidedi
 
         # @return [Array<Instruction>]
         def matches(segment_tok, strict)
-          invalid = true  # Were all possibly distinguishing elements invalid?
+          invalid = true  # Were all present possibly distinguishing elements invalid?
           present = false # Were any possibly distinguishing elements present?
 
-          @__basis ||= basis(shallowest(@instructions))
-          @__basis.head.each do |(n, m), map|
+          disjoint, distinct = basis(@instructions)
+
+          # First check single elements that can narrow the search space to
+          # a single matching Instruction.
+          disjoint.each do |(n, m), map|
             value = deconstruct(segment_tok.element_toks, n, m)
 
             case value
             when nil, :not_used, :default
-              # ignore
+              # value wasn't present in segment_tok, can't use it to decide
             else
               singleton = map.at(value)
               present   = true
 
               unless singleton.nil?
+                # Success, search is terminated
                 return singleton
               else
                 if strict
@@ -140,13 +147,14 @@ module Stupidedi
           # the combination of elements to iteratively narrow the search space
           space = @instructions
 
-          # @todo: These filters should be ordered by probable effectiveness,
+          # @todo: These filters could be ordered by probable effectiveness,
           # so we narrow the search space by the largest amount in the fewest
           # number of steps.
-          @__basis.last.each do |(n, m), map|
+          distinct.each do |(n, m), map|
             value = deconstruct(segment_tok.element_toks, n, m)
 
             unless value.nil?
+              # Lookup which instructions are compatible with this input
               subset  = map.at(value)
               present = true
 
@@ -155,9 +163,11 @@ module Stupidedi
                 space  &= subset
 
                 if space.length <= 1
+                  # Success, search is terminated
                   return space
                 end
               else
+                # This value isn't compatible with any instruction
                 if strict
                   designator = "#{segment_tok.id}#{'%02d' % n}"
                   designator = designator + "-%02d" % m unless m.nil?
@@ -170,14 +180,27 @@ module Stupidedi
           end
 
           if invalid and present
+            # Some elements were present, but all contained invalid values, and
+            # even ignoring those we could not narrow the matches to a single
+            # instruction.
+            #
+            # We could return the remaining search space, but it is safest to
+            # mark this as an invalid segment and avoid the non-determinism
             []
           else
+            # Some elements were present and none were invalid, but it was not
+            # possible to narrow the set of matches to a single instruction.
+            #
+            # It seems wrong to mark the segment invalid. The worst thing you
+            # could say about the input is that it may have been missing a
+            # required element that could have resolved the ambiguity; but it's
+            # also possible all required elements were present and the grammar
+            # is the problem (not the input). So here we return the remaining
+            # search space, which will cause non-determinism in the parser.
             space
           end
         end
 
-      private
-
         # Resolve conflicts between instructions that have identical SegmentUse
         # values. For each SegmentUse, this chooses the Instruction that pops
         # the greatest number of states.
@@ -203,84 +226,87 @@ module Stupidedi
 
         # @return [Array(Array<(Integer, Integer, Map)>, Array<(Integer, Integer, Map)>)]
         def basis(instructions)
-          disjoint_elements = []
-          distinct_elements = []
-
-          # The first SegmentUse is used to represent the structure that must
-          # be shared by the others: number of elements and type of elements
-          element_uses = instructions.head.segment_use.definition.element_uses
-
-          # Iterate over each element across all SegmentUses (think columns)
-          #   NM1*[IL]*[  ]*..*..*..*..*..*[  ]*..*..*{..}*..
-          #   NM1*[40]*[  ]*..*..*..*..*..*[  ]*..*..*{..}*..
-          element_uses.length.times do |n|
-            if element_uses.at(n).composite?
-              ms = 0 .. element_uses.at(n).definition.component_uses.length - 1
-            else
-              ms = [nil]
-            end
+          @__basis ||= begin
+            instructions      = shallowest(instructions)
+            disjoint_elements = []
+            distinct_elements = []
+
+            # The first SegmentUse is used to represent the structure that must
+            # be shared by the others: number of elements and type of elements
+            element_uses = instructions.head.segment_use.definition.element_uses
+
+            # Iterate over each element across all SegmentUses (think columns)
+            #   NM1*[IL]*[  ]*..*..*..*..*..*[  ]*..*..*{..}*..
+            #   NM1*[40]*[  ]*..*..*..*..*..*[  ]*..*..*{..}*..
+            element_uses.length.times do |n|
+              if element_uses.at(n).composite?
+                ms = 0 .. element_uses.at(n).definition.component_uses.length - 1
+              else
+                ms = [nil]
+              end
 
-            # If this is a composite element, we iterate over each component.
-            # Otherwise this loop iterates once with the index {m} set to nil.
-            ms.each do |m|
-              last  = nil        # the last subset we examined
-              total = Sets.empty # the union of all examined subsets
+              # If this is a composite element, we iterate over each component.
+              # Otherwise this loop iterates once with the index {m} set to nil.
+              ms.each do |m|
+                last  = nil        # the last subset we examined
+                total = Sets.empty # the union of all examined subsets
 
-              distinct = false
-              disjoint = true
+                distinct = false
+                disjoint = true
 
-              instructions.each do |i|
-                element_use = i.segment_use.definition.element_uses.at(n)
+                instructions.each do |i|
+                  element_use = i.segment_use.definition.element_uses.at(n)
 
-                unless m.nil?
-                  element_use = element_use.definition.component_uses.at(m)
-                end
+                  unless m.nil?
+                    element_use = element_use.definition.component_uses.at(m)
+                  end
 
-                allowed_vals = element_use.allowed_values
+                  allowed_vals = element_use.allowed_values
 
-                # We want to know if every instruction's set of allowed values
-                # is disjoint (with one another). Instead of comparing each set
-                # with every other set, which takes (N-1)! comparisons, we can
-                # do it in N steps.
-                disjoint &&= allowed_vals.disjoint?(total)
+                  # We want to know if every instruction's set of allowed values
+                  # is disjoint (with one another). Instead of comparing each set
+                  # with every other set, which takes (N-1)! comparisons, we can
+                  # do it in N steps.
+                  disjoint &&= allowed_vals.disjoint?(total)
 
-                # We also want to know if one instruction's set of allowed vals
-                # contains elements that aren't present in at least one other
-                # set. The opposite condition is easy to test: all sets contain
-                # the same elements (are equal). So we can similarly, check this
-                # condition in N steps rather than (N-1)!
-                distinct ||= allowed_vals != last unless last.nil?
+                  # We also want to know if one instruction's set of allowed vals
+                  # contains elements that aren't present in at least one other
+                  # set. The opposite condition is easy to test: all sets contain
+                  # the same elements (are equal). So we can similarly, check this
+                  # condition in N steps rather than (N-1)!
+                  distinct ||= allowed_vals != last unless last.nil?
 
-                total = allowed_vals.union(total)
-                last  = allowed_vals
-              end
+                  total = allowed_vals.union(total)
+                  last  = allowed_vals
+                end
 
-            # puts "#{n}.#{m}: disjoint(#{disjoint}) distinct(#{distinct})"
-
-              if disjoint
-                # Since each instruction's set of allowed values is disjoint, we
-                # can build a function/hash that returns the single instruction,
-                # given one of the values. When given a value outside the set of
-                # all (combined) values, it returns nil.
-                disjoint_elements << [[n, m], build_disjoint(total, n, m, instructions)]
-              elsif distinct
-                # Not all instructions have the same set of allowed values. So
-                # we can build a function/hash that accepts one of the values
-                # and returns the subset of the instructions where that value
-                # can occur. This might be some, none, or all of the original
-                # instructions, so clearly this provides less information than
-                # if each allowed value set was disjoint.
-
-                # Currently disabled (and untested) because it doesn't look like
-                # any of the HIPAA schemas would use this -- so testing it would
-                # be a pain.
-                #
-                distinct_elements << [[n, m], build_distinct(total, n, m, instructions)]
+              # puts "#{n}.#{m}: disjoint(#{disjoint}) distinct(#{distinct})"
+
+                if disjoint
+                  # Since each instruction's set of allowed values is disjoint, we
+                  # can build a function/hash that returns the single instruction,
+                  # given one of the values. When given a value outside the set of
+                  # all (combined) values, it returns nil.
+                  disjoint_elements << [[n, m], build_disjoint(total, n, m, instructions)]
+                elsif distinct
+                  # Not all instructions have the same set of allowed values. So
+                  # we can build a function/hash that accepts one of the values
+                  # and returns the subset of the instructions where that value
+                  # can occur. This might be some, none, or all of the original
+                  # instructions, so clearly this provides less information than
+                  # if each allowed value set was disjoint.
+
+                  # Currently disabled (and untested) because it doesn't look like
+                  # any of the HIPAA schemas would use this -- so testing it would
+                  # be a pain.
+                  #
+                  distinct_elements << [[n, m], build_distinct(total, n, m, instructions)]
+                end
               end
             end
-          end
 
-          [disjoint_elements, distinct_elements]
+            [disjoint_elements, distinct_elements]
+          end
         end
 
         # @return [Hash<String, Array<Instruction>>]

data/lib/stupidedi/builder/generation.rb

@@ -54,89 +54,92 @@ module Stupidedi
 
       # @return [(StateMachine, Reader::TokenReader)]
       def insert(segment_tok, reader)
-        active = []
-
-        @active.each do |zipper|
+        active = @active.flat_map do |zipper|
           state        = zipper.node
           instructions = state.instructions.matches(segment_tok)
 
           if instructions.empty?
-            active << zipper.append(FailureState.mksegment(segment_tok, state))
-            next
-          end
-
-          instructions.each do |op|
-            if op.push.nil?
-              table = zipper.node.instructions
-              value = zipper.node.zipper
-              state = zipper
-
-              op.pop_count.times do
-                value = value.up
-                state = state.up
-              end
-
-              # Create a new AbstractState node that has a new InstructionTable
-              # and also points to a new AbstractVal tree (with the new segment)
-              segment   = AbstractState.mksegment(segment_tok, op.segment_use)
-              successor = state.append(state.node.copy(
-                :zipper       => value.append(segment),
-                :instructions => table.pop(op.pop_count).drop(op.drop_count)))
-
-              unless op.pop_count.zero? or reader.stream?
-                # More general than checking if segment_tok is an ISE/GE segment
-                unless reader.separators.eql?(successor.node.separators) \
-                  and reader.segment_dict.eql?(successor.node.segment_dict)
-                  reader = reader.copy \
-                    :separators   => successor.node.separators,
-                    :segment_dict => successor.node.segment_dict
-                end
-              end
-            else
-              table = zipper.node.instructions
-              value = zipper.node.zipper
-              state = zipper
-
-              op.pop_count.times do
-                value = value.up
-                state = state.up
-              end
-
-              parent = state.node.copy \
-                :zipper       => value,
-                :children     => [],
-                :separators   => reader.separators,
-                :segment_dict => reader.segment_dict,
-                :instructions => table.pop(op.pop_count).drop(op.drop_count)
-
-              state = state.append(parent) unless state.root?
-
-              successor = op.push.push(state, parent, segment_tok, op.segment_use, @config)
-
-              # More general than checking if segment_tok is an ISA/GS segment
-              unless reader.separators.eql?(successor.node.separators) \
-                and reader.segment_dict.eql?(successor.node.segment_dict)
-                reader = reader.copy \
-                  :separators   => successor.node.separators,
-                  :segment_dict => successor.node.segment_dict
-              end
+            zipper.append(FailureState.mksegment(segment_tok, state)).cons
+          else
+            instructions.map do |op|
+              successor = execute(op, zipper, reader, segment_tok)
+              reader    = update_reader(op, reader, successor)
+              successor
             end
-
-            active << successor
           end
         end
 
         return StateMachine.new(@config, active), reader
       end
 
-      # @return [StateMachine]
-      def replace(segment_tok, reader)
-        # @todo
+      # Three things change together when executing an {Instruction}:
+      #
+      # 1. The stack of instruction tables that indicates where a segment
+      #    would be located if it existed, or was added to the parse tree
+      #
+      # 2. The parse tree, to which we add the new syntax nodes using a
+      #    zipper.
+      #
+      # 3. The corresponding tree of states, which tie together the first
+      #    two and are also updated using a zipper
+      #
+      # @return [AbstractCursor<StateMachine>]
+      def execute(op, zipper, reader, segment_tok)
+        table = zipper.node.instructions  # 1.
+        value = zipper.node.zipper        # 2.
+        state = zipper                    # 3.
+
+        op.pop_count.times do
+          value = value.up
+          state = state.up
+        end
+
+        if op.push.nil?
+          # This instruction doesn't create a child node in the parse tree,
+          # but it might move us forward to a sibling or upward to an uncle
+          segment = AbstractState.mksegment(segment_tok, op.segment_use)
+          value   = value.append(segment)
+
+          # If we're moving upward, pop off the current table(s). If we're
+          # moving forward, shift off the previous instructions. Important
+          # that these are done in order.
+          instructions = table.pop(op.pop_count).drop(op.drop_count)
+
+          # Create a new AbstractState node that has a new InstructionTable
+          # and also points to a new AbstractVal tree (with the new segment)
+          state.append(state.node.copy(
+            :zipper       => value,
+            :instructions => instructions))
+        else
+          # Make a new sibling or uncle that will be the parent to the child
+          parent = state.node.copy \
+            :zipper       => value,
+            :children     => [],
+            :separators   => reader.separators,
+            :segment_dict => reader.segment_dict,
+            :instructions => table.pop(op.pop_count).drop(op.drop_count)
+
+          # Note, `state` is a cursor pointing at a state, while `parent`
+          # is an actual state
+          state = state.append(parent) unless state.root?
+
+          # Note, eg, op.push == TableState; op.push.push == TableState.push
+          op.push.push(state, parent, segment_tok, op.segment_use, @config)
+        end
       end
 
-      # @return [StateMachine]
-      def remove
-        # @todo
+      def update_reader(op, reader, successor)
+        # We might be moving up or down past the interchange or functional
+        # group envelope, which control the set of separators and the set
+        # of all possible segments
+        unless op.push.nil? and (op.pop_count.zero? or reader.stream?)
+          unless reader.separators.eql?(successor.node.separators) \
+            and reader.segment_dict.eql?(successor.node.segment_dict)
+            reader.copy \
+              :separators   => successor.node.separators,
+              :segment_dict => successor.node.segment_dict
+          end
+        end || reader
       end
 
     end

data/lib/stupidedi/builder/instruction.rb

@@ -57,6 +57,10 @@ module Stupidedi
           segment_id || segment_use.definition.id, segment_use, pop, drop, push
       end
 
+      def hash
+        [Instruction, state].hash
+      end
+
       # @return [Instruction]
       def copy(changes = {})
         Instruction.new \
@@ -100,6 +104,12 @@ module Stupidedi
           end
         end
       end
+
+    private
+
+      def state
+        [@segment_id, @segment_use, @pop_count, @drop_count, @push].hash
+      end
     end
 
   end