dendroid 0.2.03 → 0.2.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba78964528c386b4be6024fdd2f1f76edc87478e83013ac40933d183e0d04d02
-  data.tar.gz: 1a5840b2d92a8b8e525bdf1313122ae3f3160fbb9676700c8e4d3edede71928b
+  metadata.gz: 27c301e0fa5d044507f9b3b670305852444b9dcd31592fa862fed32df0d1a46a
+  data.tar.gz: abd3263f035f72641bbf4f9a1219eb160be179d593487c3a4afd9a8889e479d6
 SHA512:
-  metadata.gz: 241163fd9a9f7ab036a1d750ef30844f538b40e2fea401af86929798a98f515ec9a82d136f2db7e61c3253ce7c88e9166db55ef24373a47acc0a6dd043e84c61
-  data.tar.gz: ee0faca7992fa087ca100b0de21b7e85464828a832462cded6593688d20b6b834a11d87284f7a3fcce137dbc670db98499e5601587119e32d25f5ab2f61a4134
+  metadata.gz: 011f8688d569b73abacfd4a75c4b6dea7f1524701e4af98fad7ebd426bb3ed01e0552e4eb80a0c6d633c4c28d8805c48d6dd75879d73274f6a898cbf70f1c83c
+  data.tar.gz: add10309df54041eef176bb38190c86fc3bfda400148dfc784863d69a9765fee37e9491449a62b35c805fc67338825791c82429c0a4527dc6ccf782ef2921a99

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [0.2.04] - 2023-12-24
+Some code refactoring.
+
+### Added
+- File `walk_progress_spec.rb`
+
+### Changed
+- Class `WalkProgress` refactoring & documentation
+- Class `ChartWalker` refactoring & documentation
+
 ## [0.2.03] - 2023-12-21
 
 ### Added

data/lib/dendroid/parsing/chart_walker.rb

@@ -4,58 +4,160 @@ require_relative 'walk_progress'
 
 module Dendroid
   module Parsing
+    # Keeps track of the visited chart entries in order to implement
+    # the sharing of parse nodes.
+    class WalkContext
+      # Mapping chart item => ParseNode for the current item set.
+      # @return [Hash{Dendroid::Recognizer::EItem => ParseNode}]
+      attr_reader :entry2node
+
+      # @return [Hash{Syntax::Token => TerminalNode}]
+      attr_reader :token2node
+
+      # @return [Hash{OrNode => true}]
+      attr_reader :or_nodes_crossed
+
+      # @return [Hash{Parsing::ParseNode => Array<Dendroid::Parsing::WalkProgress>}]
+      attr_reader :sharing
+
+      def initialize
+        @entry2node = {}
+        @token2node = {}
+        @or_nodes_crossed = {}
+        @sharing = {}
+      end
+
+      # Was the given chart entry already encountered?
+      # @param anEItem [Dendroid::Recognizer::EItem] chart entry to test
+      def known_entry?(anEItem)
+        entry2node.include?(anEItem)
+      end
+
+      # Make the given chart entry the new current item and
+      # mark its related node as known (visited)
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param anEItem [Dendroid::Recognizer::EItem]
+      # @param aNode [Dendroid::Parsing::ParseNode]
+      def advance(walk_progress, anEItem, aNode)
+        walk_progress.curr_item = anEItem
+        entry2node[anEItem] = aNode
+      end
+
+      # For a given token, make a terminal node a child of the current parent.
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param token [Dendroid::Lexical::Token]
+      def add_terminal_node(walk_progress, token)
+        if token2node.include? token
+          walk_progress.add_child_node(token2node[token])
+          walk_progress.curr_rank -= 1
+        else
+          new_node = walk_progress.add_terminal_node(token)
+          token2node[token] = new_node
+        end
+      end
+
+      # Add an and node as a child of current parent of given walk progress
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param anEItem [Dendroid::Recognizer::EItem]
+      def add_and_node(walk_progress, anEItem)
+        new_node = walk_progress.push_and_node(anEItem)
+        advance(walk_progress, anEItem, new_node)
+      end
+
+      # Check whether the given node was already seen.
+      # If yes, set the state of the walk progress to Complete
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param anOrNode [Dendroid::Parsing::OrNode]
+      # @return [Boolean] true if the walk progress is in Complete state
+      def join_or_node(walk_progress, anOrNode)
+        already_crossed = or_nodes_crossed.include?(anOrNode)
+        if already_crossed
+          walk_progress.state = :Complete
+        else
+          or_nodes_crossed[anOrNode] = true
+        end
+
+        already_crossed
+      end
+
+      # @param anEItem [Dendroid::Recognizer::EItem]
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      def start_delegation(anEItem, walk_progress)
+        shared_node = entry2node[anEItem]
+        if sharing.include? shared_node
+          sharing[shared_node] << walk_progress
+        else
+          sharing[shared_node] = [walk_progress]
+        end
+        walk_progress.add_child_node(shared_node)
+        walk_progress.parents.push(shared_node)
+        walk_progress.state = :Delegating
+      end
+
+      # If the given node is shared by other WalkProgress, update them
+      # with the advancement of the provided WalkProgress & dissolve the delegation
+      # @param aNode [Dendroid::Parsing::ParseNode]
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param desired_state [Symbol] New state of the delegating walk progresses
+      def stop_delegation(aNode, walk_progress, desired_state)
+        if sharing.include? aNode
+          delegating = sharing[aNode]
+          unless delegating.include? walk_progress
+            delegating.each do |dlg|
+              dlg.curr_rank = walk_progress.curr_rank
+              dlg.curr_item = walk_progress.curr_item
+              dlg.state = desired_state
+            end
+            sharing.delete(aNode)
+          end
+        end
+      end
+
+      # Remove multiple parent from the parent stack of provided
+      # walk progress. If one of the removed node is an OrNode
+      # and it was already encountered, then the walk progress is deemed complete.
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param count [Integer] the number of parents to pop; must be greater than one
+      def pop_multiple_parents(walk_progress, count)
+        removed = walk_progress.parents.pop(count)
+        if removed.is_a?(Array)
+          or_nodes = removed.select { |entry| entry.is_a?(OrNode) }
+          unless or_nodes.empty?
+            or_nodes.reverse_each do |or_nd|
+              break if join_or_node(walk_progress, or_nd)
+            end
+          end
+        elsif removed.is_a?(OrNode)
+          join_or_node(walk_progress, removed)
+        end
+      end
+    end # class
+
+    # A chart walker visits a chart produced by the Earley recognizer.
+    # It visits the chart backwards: it begins with the chart entries
+    # representing a successful recognition then walks to the predecessor
+    # entries and so on.
     class ChartWalker
+      # @return [Dendroid::Recognizer::Chart] The chart to visit
       attr_reader :chart
-      attr_reader :last_item
-
-      # rubocop: disable Metrics/AbcSize
-      # rubocop: disable Metrics/CyclomaticComplexity
-      # rubocop: disable Metrics/PerceivedComplexity
 
+      # @param theChart [Dendroid::Recognizer::Chart] The chart to visit
       def initialize(theChart)
         @chart = theChart
       end
 
+      # @param start_item [Dendroid::Recognizer::EItem] The chart entry to visit first.
       def walk(start_item)
         curr_rank = chart.size - 1
-
-        parents = []
-        progress = WalkProgress.new(curr_rank, start_item, parents)
+        progress = WalkProgress.new(curr_rank, start_item, [])
         paths = [progress]
-
-        if start_item.predecessors.size > 1
-          # Create n times start_item as predecessors, then for each path initialize to its unique own predecessor
-          forerunners = disambiguate(progress, start_item.predecessors)
-          if forerunners.size == 1
-            parents << AndNode.new(start_item, curr_rank)
-          else
-            preds = sort_predecessors(forerunners)
-            if start_item.rule.rhs.size == 1
-              parents << AndNode.new(start_item, curr_rank)
-              progress.push_or_node(start_item.origin, preds.size)
-            else
-              parents << OrNode.new(start_item.lhs, start_item.origin, curr_rank, preds.size)
-            end
-            progress.curr_item = start_item
-            fork(progress, paths, preds)
-          end
-        else
-          parents << AndNode.new(start_item, curr_rank)
-        end
-        token2node = {}
-        entry2node = {}
-        sharing = {}
-        or_nodes_crossed = {}
+        visit_start_item(progress, paths, start_item)
+        ctx = WalkContext.new
 
         loop do # Iterate over rank values
           pass = :primary
           loop do # Iterate over paths until all are ready for previous rank
-            paths.each do |prg|
-              next if prg.state == :Complete || prg.state == :Delegating
-              next if pass == :secondary && prg.state == :Waiting
-
-              step_back(prg, paths, token2node, entry2node, sharing, or_nodes_crossed)
-            end
+            all_paths_advance(ctx, paths, pass)
             # TODO: handle path removal
             break if paths.none? { |pg| pg.state == :Running || pg.state == :Forking }
 
@@ -63,140 +165,76 @@ module Dendroid
           end
           break if paths.all? { |prg| prg.state == :Complete }
 
-          entry2node.clear
+          ctx.entry2node.clear
         end
 
-        parents[0]
+        progress.parents[0]
       end
 
-      def step_back(walk_progress, paths, token2node, entry2node, sharing, or_nodes_crossed)
-        loop do
-          case walk_progress.state
-          when :Waiting, :New
-            predecessors = predecessors_of(walk_progress.curr_item, walk_progress.parents)
-            last_parent = walk_progress.parents.last
-            if sharing.include? last_parent
-              delegating = sharing[last_parent]
-              unless delegating.include? walk_progress
-                delegating.each do |dlg|
-                  dlg.curr_rank = walk_progress.curr_rank
-                  dlg.curr_item = walk_progress.curr_item
-                  dlg.state = :Waiting
-                end
-                sharing.delete(last_parent)
-              end
-            end
-            walk_progress.state = :Running
+      # Start the visit of with the success (accept) chart entry.
+      # Build the root node(s) of parse tree/forest
+      # @param progress [Dendroid::Parsing::WalkProgress]
+      # @param paths [Array<Dendroid::Parsing::WalkProgress>]
+      # @param start_item [Dendroid::Recognizer::EItem]
+      def visit_start_item(progress, paths, start_item)
+        preds = disambiguate_predecessors(progress, start_item.predecessors)
+        if preds.size == 1
+          progress.push_and_node(start_item)
+        else
+          # Multiple predecessors...
+          if start_item.rule.rhs.size == 1
+            progress.push_and_node(start_item)
+            progress.push_or_node(start_item.origin, preds.size)
+          else
+            progress.parents << OrNode.new(start_item.lhs, start_item.origin, progress.curr_rank, preds.size)
+          end
+          progress.curr_item = start_item
+          fork(progress, paths, preds)
+        end
+      end
 
-          when :Running
-            predecessors = predecessors_of(walk_progress.curr_item, walk_progress.parents)
+      # Iterate over each path, if allowed perform a step back
+      # @param ctx [Dendroid::Parsing::WalkContext]
+      # @param paths [Array<Dendroid::Parsing::WalkProgress>]
+      # @param pass [Symbol] one of: :primary, :secondary
+      def all_paths_advance(ctx, paths, pass)
+        paths.each do |prg|
+          next if prg.state == :Complete || prg.state == :Delegating
+          next if pass == :secondary && prg.state == :Waiting
 
-          when :Forking
-            # predecessors = [walk_progress.curr_item]
-            predecessors = [walk_progress.predecessor]
-            walk_progress.predecessor = nil
-            walk_progress.state = :Running
-          end
+          step_back(prg, ctx, paths)
+        end
+      end
 
-          if predecessors.empty?
-            walk_progress.state = :Complete
-            break
-          end
+      # For the given walk_progress, perform the visit of predecessors of
+      # the chart entry designated as the current one.
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      # @param context [Dendroid::Parsing::WalkContext]
+      def step_back(walk_progress, context, paths)
+        loop do
+          predecessors = predecessors_for_state(context, walk_progress)
+          break if walk_progress.state == :Complete
 
           case walk_progress.curr_item.algo
           when :completer
-            completer_backwards(walk_progress, paths, entry2node, sharing, predecessors)
+            completer_backwards(walk_progress, context, paths, predecessors)
             break if walk_progress.state == :Delegating
 
           when :scanner
             curr_token = chart.tokens[walk_progress.curr_rank - 1]
-            if token2node.include? curr_token
-              walk_progress.add_child_node(token2node[curr_token])
-              walk_progress.curr_rank -= 1
-            else
-              new_node = walk_progress.add_terminal_node(chart.tokens[walk_progress.curr_rank - 1])
-              token2node[curr_token] = new_node
-            end
-            if predecessors.size == 1
-              walk_progress.curr_item = predecessors[0]
-              walk_progress.state = :Waiting
-              break
-            else
-              # TODO: challenge assumption single predecessor
-              raise StandardError
-            end
+            scanner_backwards(walk_progress, context, predecessors, curr_token)
+            break
 
           when :predictor
             unless walk_progress.parents.last.partial?
               last_parent = walk_progress.parents.pop
-              if sharing.include? last_parent
-                delegating = sharing[last_parent]
-                unless delegating.include? walk_progress
-                  delegating.each do |dlg|
-                    dlg.curr_rank = walk_progress.curr_rank
-                    dlg.curr_item = walk_progress.curr_item
-                    dlg.state = :Running
-                  end
-                  sharing.delete(last_parent)
-                end
-              end
+              context.stop_delegation(last_parent, walk_progress, :Running)
               if last_parent.is_a?(OrNode)
-                if or_nodes_crossed.include?(last_parent)
-                  walk_progress.state = :Complete
-                  break
-                else
-                  or_nodes_crossed[last_parent] = true
-                end
-              end
-            end
-            index_empty = predecessors.find_index { |entry| entry.dotted_item.empty? }
-            if index_empty
-              entry_empty = predecessors.delete_at(index_empty)
-              walk_progress.add_node_empty(entry_empty)
-              raise StandardError unless predecessors.empty? # Uncovered case
-
-              walk_progress.curr_item = entry_empty
-              next
-            end
-            if predecessors.size == 1
-              walk_progress.curr_item = predecessors[0]
-            else
-              # curr_item has multiple predecessors from distinct rules
-              # look in lineage the latest entry that matches one of the ancestors AND
-              # has a free slot for the current symbol
-              matches = walk_progress.match_parent?(predecessors, true)
-              if matches.empty?
-                walk_progress.state = :Complete
-                break
-              end
-              (matching_pred, stack_offset) = matches.first
-              walk_progress.curr_item = matching_pred
-              unless stack_offset.zero?
-                removed = walk_progress.parents.pop(stack_offset)
-                if removed.is_a?(Array)
-                  or_nodes = removed.select { |entry| entry.is_a?(OrNode) }
-                  unless or_nodes.empty?
-                    or_nodes.reverse_each do |or_nd|
-                      if or_nodes_crossed.include?(or_nd)
-                        walk_progress.state = :Complete
-                        break
-                      else
-                        or_nodes_crossed[or_nd] = true
-                      end
-                    end
-                    break if walk_progress.state == :Complete
-
-                  end
-                elsif removed.is_a?(OrNode)
-                  if or_nodes_crossed.include?(removed)
-                    walk_progress.state = :Complete
-                    break
-                  else
-                    or_nodes_crossed[removed] = true
-                  end
-                end
+                break if context.join_or_node(walk_progress, last_parent)
               end
             end
+            predictor_backwards(walk_progress, context, predecessors)
+            break if walk_progress.state == :Complete
           else
             raise StandardError
           end
@@ -205,10 +243,45 @@ module Dendroid
         walk_progress
       end
 
-      def disambiguate(_progress, predecessors)
+      # Determine predecessors of current item according the walk progess state.
+      # If needed, update also the state.
+      # @param context [Dendroid::Parsing::WalkContext]
+      # @param walk_progress [Dendroid::Parsing::WalkProgress]
+      def predecessors_for_state(context, walk_progress)
+        case walk_progress.state
+        when :Waiting, :New
+          predecessors = predecessors_of(walk_progress.curr_item, walk_progress.parents)
+          last_parent = walk_progress.parents.last
+          context.stop_delegation(last_parent, walk_progress, :Waiting)
+          walk_progress.state = :Running
+
+        when :Running
+          predecessors = predecessors_of(walk_progress.curr_item, walk_progress.parents)
+
+        when :Forking
+          predecessors = [walk_progress.predecessor]
+          walk_progress.predecessor = nil
+          walk_progress.state = :Running
+        end
+
+        walk_progress.state = :Complete if predecessors.empty?
         predecessors
       end
 
+      # Check whether given chart entry has multiple predecessorss.
+      # If yes, then apply disambiguation to reduce the number of valid predecessors
+      # If there are still multiple predecessors, then sort them.
+      # @param _progress [Dendroid::Parsing::WalkProgress] Unused
+      # @param predecessors [Array<Dendroid::Recognizer::EItem>]
+      # @return [Array<Dendroid::Recognizer::EItem>]
+      def disambiguate_predecessors(_progress, predecessors)
+        if predecessors.size > 1
+          sort_predecessors(predecessors)
+        else
+          predecessors
+        end
+      end
+
       def sort_predecessors(predecessors)
         predecessors
       end
@@ -222,6 +295,7 @@ module Dendroid
             raise StandardError
 
           end
+
           preds = anEItem.predecessors.dup
           preds.delete(anEItem)
           preds
@@ -230,29 +304,29 @@ module Dendroid
         end
       end
 
-      def completer_backwards(walk_progress, paths, entry2node, sharing, predecessors)
+      def scanner_backwards(walk_progress, context, predecessors, curr_token)
+        context.add_terminal_node(walk_progress, curr_token)
+        if predecessors.size == 1
+          walk_progress.curr_item = predecessors[0]
+          walk_progress.state = :Waiting
+        else
+          # TODO: challenge assumption single predecessor
+          raise StandardError
+        end
+      end
+
+      def completer_backwards(walk_progress, context, paths, predecessors)
         # Trying to remove some predecessors with some disambiguation technique
-        forerunners = disambiguate(walk_progress, predecessors)
+        forerunners = disambiguate_predecessors(walk_progress, predecessors)
 
         if forerunners.size == 1
           pred = forerunners[0]
-          if entry2node.include? pred
-            shared_node = entry2node[pred]
-            if sharing.include? shared_node
-              sharing[shared_node] << walk_progress
-            else
-              sharing[shared_node] = [walk_progress]
-            end
-            walk_progress.add_child_node(shared_node)
-            walk_progress.parents.push(shared_node)
-            walk_progress.state = :Delegating
-
+          if context.known_entry? pred
+            context.start_delegation(pred, walk_progress)
           elsif pred.predecessors.size == 1
-            new_node = walk_progress.push_and_node(pred)
-            walk_progress.curr_item = pred
-            entry2node[pred] = new_node
+            context.add_and_node(walk_progress, pred)
           else
-            pre_forerunners = disambiguate(walk_progress, pred.predecessors)
+            pre_forerunners = disambiguate_predecessors(walk_progress, pred.predecessors)
             index_empty = pre_forerunners.find_index { |entry| entry.dotted_item.empty? }
             if index_empty
               entry_empty = pre_forerunners.delete_at(index_empty)
@@ -260,23 +334,47 @@ module Dendroid
               walk_progress.curr_item = entry_empty.predecessors[0] # Assuming only one predecessor
             end
             if pre_forerunners.size == 1
-              pred = forerunners[0]
               new_node = walk_progress.push_and_node(pre_forerunners[0])
-              walk_progress.curr_item = pred
-              entry2node[pred] = new_node
+              context.advance(walk_progress, pred, new_node)
             else
-              prepreds = sort_predecessors(pre_forerunners)
-              new_node = walk_progress.push_or_node(pred.origin, prepreds.size)
-              walk_progress.curr_item = pred
-              entry2node[pred] = new_node
-              fork(walk_progress, paths, prepreds)
+              new_node = walk_progress.push_or_node(pred.origin, pre_forerunners.size)
+              context.advance(walk_progress, pred, new_node)
+              fork(walk_progress, paths, pre_forerunners)
             end
           end
         else
           # AMBIGUITY: multiple valid predecessors
-          preds = sort_predecessors(forerunners)
-          walk_progress.push_or_node(preds)
-          fork(walk_progress, paths, preds)
+          walk_progress.push_or_node(forerunners)
+          fork(walk_progress, paths, forerunners)
+        end
+      end
+
+      def predictor_backwards(walk_progress, context, predecessors)
+        index_empty = predecessors.find_index { |entry| entry.dotted_item.empty? }
+        if index_empty
+          entry_empty = predecessors.delete_at(index_empty)
+          walk_progress.add_node_empty(entry_empty)
+          raise StandardError unless predecessors.empty? # Uncovered case
+
+          walk_progress.curr_item = entry_empty
+          return
+        end
+        if predecessors.size == 1
+          walk_progress.curr_item = predecessors[0]
+        else
+          # curr_item has multiple predecessors from distinct rules
+          # look in lineage the latest entry that matches one of the ancestors AND
+          # has a free slot for the current symbol
+          matches = walk_progress.match_parent?(predecessors, true)
+          if matches.empty?
+            walk_progress.state = :Complete
+          else
+            (matching_pred, stack_offset) = matches.first
+            walk_progress.curr_item = matching_pred
+            unless stack_offset.zero?
+              context.pop_multiple_parents(walk_progress, stack_offset)
+            end
+          end
         end
       end
 
@@ -293,9 +391,5 @@ module Dendroid
         progs.each { |pg| pg.push_and_node(pg.curr_item) }
       end
     end # class
-
-    # rubocop: enable Metrics/AbcSize
-    # rubocop: enable Metrics/CyclomaticComplexity
-    # rubocop: enable Metrics/PerceivedComplexity
   end # module
 end # module

data/lib/dendroid/parsing/walk_progress.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'and_node.rb'
+require_relative 'and_node'
 require_relative 'or_node'
 require_relative 'terminal_node'
 require_relative 'empty_rule_node'
@@ -10,9 +10,9 @@ module Dendroid
     # This object holds the current state of the visit of a Chart by one
     # ChartWalker through one single visit path. A path corresponds to a
     # chain from the current item back to the initial item(s) through the predecessors links.
-    # It is used to construct (part of) the parse tree from the root node.
+    # It is used to construct (part of) the parse tree beginning from the root node.
     class WalkProgress
-      # @return [Symbol] One of: :New, :Forking,
+      # @return [Symbol] One of: :New, :Running, :Waiting, :Complete, :Forking, :Delegating
       attr_accessor :state
 
       # @return [Integer] rank of the item set from the chart being visited
@@ -28,9 +28,6 @@ module Dendroid
       # @return [Array<Dendroid::Parsing::CompositeParseNode>] The ancestry of current parse node.
       attr_reader :parents
 
-      # rubocop: disable Metrics/CyclomaticComplexity
-      # rubocop: disable Metrics/PerceivedComplexity
-
       # @param start_rank [Integer] Initial rank at the start of the visit
       # @param start_item [Dendroid::Recognizer::EItem] Initial chart entry to visit
       # @param parents [Array<Dendroid::Parsing::CompositeParseNode>]
@@ -116,15 +113,18 @@ module Dendroid
       # @param aNode [Dendroid::Parsing::ParseNode]
       # @return [Dendroid::Parsing::ParseNode]
       def add_child_node(aNode)
-        parents.last.add_child(aNode, curr_item.position - 1)
+        parents.last.add_child(aNode, curr_item.position - 1) unless parents.empty?
         aNode
       end
 
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
       # Do the given EItems match one of the parent?
       # Matching = corresponds to the same rule and range
       # @param entries [Dendroid::Recognizer::EItem]
       # @param stop_at_first [Boolean] Must be true
-      # @return [Array<EItem>]
+      # @return [Array<Array<EItem, Integer>>]
       def match_parent?(entries, stop_at_first)
         matching = []
         min_origin = entries[0].origin

data/lib/dendroid.rb

@@ -6,10 +6,8 @@
 module Dendroid
 end # module
 
-
 # This file acts as a jumping-off point for loading dependencies expected
 # for a Dendroid client.
-
 require_relative './dendroid/grm_dsl/base_grm_builder'
 require_relative './dendroid/utils/base_tokenizer'
 require_relative './dendroid/recognizer/recognizer'

data/spec/dendroid/parsing/chart_walker_spec.rb

@@ -5,14 +5,6 @@ require_relative '../support/sample_grammars'
 require_relative '../../../lib/dendroid/recognizer/recognizer'
 require_relative '../../../lib/dendroid/parsing/chart_walker'
 
-# require_relative '../grm_dsl/base_grm_builder'
-# require_relative '../utils/base_tokenizer'
-# require_relative '../recognizer/recognizer'
-# require_relative 'chart_walker'
-# require_relative 'parse_tree_visitor'
-# require_relative '../formatters/bracket_notation'
-# require_relative '../formatters/ascii_tree'
-
 RSpec.describe Dendroid::Parsing::ChartWalker do
   include SampleGrammars
 

data/spec/dendroid/parsing/walk_progress_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+require_relative '../support/sample_grammars'
+require_relative '../../../lib/dendroid/recognizer/recognizer'
+require_relative '../../../lib/dendroid/parsing/walk_progress'
+
+RSpec.describe Dendroid::Parsing::WalkProgress do
+  include SampleGrammars
+
+  def retrieve_success_item(chart, grammar)
+    last_item_set = chart.item_sets.last
+    result = nil
+    last_item_set.items.reverse_each do |itm|
+      if itm.origin.zero? && itm.dotted_item.completed? && itm.dotted_item.rule.lhs == grammar.start_symbol
+        result = itm
+        break
+      end
+    end
+
+    result
+  end
+
+  def recognizer_for(grammar, tokenizer)
+    Dendroid::Recognizer::Recognizer.new(grammar, tokenizer)
+  end
+
+  def success_entry(chart, recognizer)
+    retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  end
+
+  subject do
+    recognizer = recognizer_for(grammar_l8, tokenizer_l8)
+    chart = recognizer.run('x x x x')
+    described_class.new(4, success_entry(chart, recognizer), [])
+  end
+
+  context 'Initialization:' do
+    it 'should be initialized with a symbol, terminal and a rank' do
+      recognizer = recognizer_for(grammar_l8, tokenizer_l8)
+      chart = recognizer.run('x x x x')
+      expect { described_class.new(4, success_entry(chart, recognizer), []) }.not_to raise_error
+    end
+
+    it 'is in New state' do
+      expect(subject.state).to eq(:New)
+    end
+
+    it 'has no overriding predecessor at start' do
+      expect(subject.predecessor).to be_nil
+    end
+
+    it 'knows the current rank' do
+      expect(subject.curr_rank).to eq(4)
+    end
+
+    it 'knows the current item' do
+      expect(subject.curr_item.to_s).to eq('S => S S . @ 0')
+    end
+  end # context
+end # describe

data/version.txt

@@ -1 +1 @@
-0.2.03
+0.2.04

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.2.03
+  version: 0.2.04
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-22 00:00:00.000000000 Z
+date: 2023-12-24 00:00:00.000000000 Z
 dependencies: []
 description: WIP. A Ruby implementation of an Earley parser
 email: famished.tiger@yahoo.com
@@ -66,6 +66,7 @@ files:
 - spec/dendroid/parsing/empty_rule_node_spec.rb
 - spec/dendroid/parsing/parse_node_spec.rb
 - spec/dendroid/parsing/terminal_node_spec.rb
+- spec/dendroid/parsing/walk_progress_spec.rb
 - spec/dendroid/recognizer/chart_spec.rb
 - spec/dendroid/recognizer/e_item_spec.rb
 - spec/dendroid/recognizer/item_set_spec.rb