dendroid 0.2.02 → 0.2.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb58d7b275f7eb65ccfef37ee213fc53319c5634cf8dbd79020451c79769a3c3
-  data.tar.gz: f075b751545df13bda67d3e2df1c3861dfdaffa8fc416a7a735d0c4fc2da01bb
+  metadata.gz: ba78964528c386b4be6024fdd2f1f76edc87478e83013ac40933d183e0d04d02
+  data.tar.gz: 1a5840b2d92a8b8e525bdf1313122ae3f3160fbb9676700c8e4d3edede71928b
 SHA512:
-  metadata.gz: 1f3598bbc4f19ff183e655a92ca86908615a10b2f142982c09eb11b01b9fd05296db1ce5b9fa14be9d5f71c8358fd60535a0eb8b0feea8fcddafae5100fe8df4
-  data.tar.gz: c3227a5e8cb2675d2de6d011091e3b665e0217e62401619db36e43967a9d407c06a50205031c03dacc43f72b01cd1b0ebf66132240194d61de1ae1e167594113
+  metadata.gz: 241163fd9a9f7ab036a1d750ef30844f538b40e2fea401af86929798a98f515ec9a82d136f2db7e61c3253ce7c88e9166db55ef24373a47acc0a6dd043e84c61
+  data.tar.gz: ee0faca7992fa087ca100b0de21b7e85464828a832462cded6593688d20b6b834a11d87284f7a3fcce137dbc670db98499e5601587119e32d25f5ab2f61a4134

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [0.2.03] - 2023-12-21
+
+### Added
+- YARD documentation for the `ParseNode` hierarchy.
+- Classes `Token` and `Literal` added the predicate method `literal?`
+
+### Changed
+- Class rename: `ANDNode` became `AndNode`
+- Class `ParseNode`: method rename: `ParseNode#to_s` became `ParseNode#range_to_s`
+- Class `ParseNode`: attribute `range` is now of type `Range` 
+
 ## [0.2.02] - 2023-12-18
 Code re-styling to fix most Rubocop offenses.
 

data/lib/dendroid/formatters/bracket_notation.rb

@@ -6,7 +6,7 @@ class BracketNotation < BaseFormatter
   # Method called by a ParseTreeVisitor to which the formatter subscribed.
   # Notification of a visit event: the visitor is about to visit
   # a non-terminal node
-  # @param and_node [ANDNode]
+  # @param and_node [AndNode]
   def before_and_node(and_node)
     write("[#{and_node.rule.lhs.name} ")
   end

data/lib/dendroid/grm_analysis/dotted_item.rb

@@ -21,7 +21,7 @@ module Dendroid
     # An item with the dot not at the beginning is sometimes referred to as a kernel item
     class DottedItem
       # (Weak) reference to the production rule
-      # @return [Dendroid::Syntax::Production]
+      # @return [Dendroid::Syntax::Rule]
       attr_reader :rule
 
       # @return [Integer] the dot position
@@ -31,12 +31,12 @@ module Dendroid
       attr_reader :alt_index
 
       # Constructor.
-      # @param aChoice [Dendroid::Syntax::Rule]
+      # @param aRule[Dendroid::Syntax::Rule]
       # @param aPosition [Integer] Position of the dot in rhs of production.
       # @param index [Integer] the rank of the alternative at hand
-      def initialize(aChoice, aPosition, index)
+      def initialize(aRule, aPosition, index)
         @alt_index = index
-        @rule = WeakRef.new(aChoice)
+        @rule = WeakRef.new(aRule)
         @position = valid_position(aPosition)
       end
 

data/lib/dendroid/lexical/literal.rb

@@ -23,6 +23,11 @@ module Dendroid
         super(original, pos, symbol)
         @value = aValue
       end
+
+      # @return [Boolean] true if the token is a literal (has a value associated with is)
+      def literal?
+        true
+      end
     end # class
   end # module
 end # module

data/lib/dendroid/lexical/token.rb

@@ -41,6 +41,11 @@ module Dendroid
       def pos_to_s
         position.to_s
       end
+
+      # @return [Boolean] true if the token is a literal (has a value associated with is)
+      def literal?
+        false
+      end
     end # class
   end # module
 end # module

data/lib/dendroid/parsing/and_node.rb

@@ -4,10 +4,18 @@ require_relative 'composite_parse_node'
 
 module Dendroid
   module Parsing
-    class ANDNode < CompositeParseNode
+    # A composite parse node that matches the sequence of grammar symbols from
+    # a right-hand side of a rule to a range of input tokens. The child nodes
+    # correspond to the grammar symbols in the RHS of the rule.
+    class AndNode < CompositeParseNode
+      # @return [WeakRef<Dendroid::Syntax::Rule>] Grammar rule
       attr_reader :rule
+
+      # @return [Integer] Index of the rule alternative.
       attr_reader :alt_index
 
+      # @param anEItem [Dendroid::Recognizer::EItem] An entry from the chart.
+      # @param rank [Integer] rank of the last input token matched by this node
       def initialize(anEItem, rank)
         @rule = WeakRef.new(anEItem.dotted_item.rule)
         @alt_index = anEItem.dotted_item.alt_index
@@ -15,14 +23,22 @@ module Dendroid
         super(anEItem.origin, upper_bound, rule.rhs[alt_index].size)
       end
 
+      # Add a child a given available position.
+      # @param child_node [Dendroid::Parsing::ParseNode] Node to add as a child
+      # @param index [Integer] position of the child node in the `children` array
       def add_child(child_node, index)
         raise StandardError unless children[index].nil? # Is slot available?
 
         super(child_node, index)
       end
 
+      # Is the given chart entry matching this node?
+      # The chart entry matches this node if:
+      #   - its origin equals to the start of the range; and,
+      #   - both rules are the same; and,
+      # @return [Boolean] true if the entry corresponds to this node.
       def match(anEItem)
-        return false if range[0] != anEItem.origin
+        return false if range.begin != anEItem.origin
 
         dotted = anEItem.dotted_item
         same_rule = (rule.lhs == dotted.rule.lhs) && (alt_index == dotted.alt_index)
@@ -31,17 +47,23 @@ module Dendroid
         dotted.initial_pos? ? true : partial?
       end
 
+      # Is this node expecting at given RHS index, the given symbol?
+      # @param symbol [Dendroid::Syntax::GrmSymbol]
+      # @param position [Integer] index of given member in RHS of the rule
       def expecting?(symbol, position)
         symb_seq = rule.rhs[alt_index]
         symb_seq[position] == symbol
       end
 
+      # @return [Boolean] true if at least one of the children slots is free.
       def partial?
         children.any?(&:nil?)
       end
 
+      # Return a String representation of itself
+      # @return [String] text representation of itself
       def to_s
-        "#{rule.lhs} => #{rule.rhs[alt_index]} #{range}"
+        "#{rule.lhs} => #{rule.rhs[alt_index]} #{range_to_s}"
       end
 
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/dendroid/parsing/chart_walker.rb

@@ -27,11 +27,11 @@ module Dendroid
           # 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)
+            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)
+              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)
@@ -40,7 +40,7 @@ module Dendroid
             fork(progress, paths, preds)
           end
         else
-          parents << ANDNode.new(start_item, curr_rank)
+          parents << AndNode.new(start_item, curr_rank)
         end
         token2node = {}
         entry2node = {}

data/lib/dendroid/parsing/composite_parse_node.rb

@@ -4,9 +4,14 @@ require_relative 'parse_node'
 
 module Dendroid
   module Parsing
+    # Composite Pattern. A specialization of parse nodes that have themselves children nodes.
     class CompositeParseNode < ParseNode
+      # @return [Array<Dendroid::Parsing::ParseNode|NilClass>] Sub-nodes. Nil values represent available slots
       attr_reader :children
 
+      # @param lowerBound [Integer] Rank of first input token that is matched by this node
+      # @param upperBound [Integer] Rank of last input token that is matched by this node
+      # @param child_count [Integer] The expected number of child nodes
       def initialize(lowerBound, upperBound, child_count)
         super(lowerBound, upperBound)
         @children = Array.new(child_count, nil)

data/lib/dendroid/parsing/empty_rule_node.rb

@@ -1,21 +1,31 @@
 # frozen_string_literal: true
 
+require 'weakref'
 require_relative 'parse_node'
 
 module Dendroid
   module Parsing
+    # A parse tree/forest node that is related to a production rule with an empty
+    # RHS (right-hand side).
     class EmptyRuleNode < ParseNode
+      # @return [WeakRef<Dendroid::Syntax::Rule>] Grammar rule
       attr_reader :rule
+
+      # @return [Integer] Index of the rule alternative.
       attr_reader :alt_index
 
+      # @param anEItem [Dendroid::Recognizer::EItem] An entry from the chart.
+      # @param rank [Integer] rank of the last input token matched by this node
       def initialize(anEItem, rank)
         super(rank, rank)
         @rule = WeakRef.new(anEItem.dotted_item.rule)
         @alt_index = anEItem.dotted_item.alt_index
       end
 
+      # Return a String representation of itself
+      # @return [String] text representation of itself
       def to_s
-        "_ #{super}"
+        "_ #{range_to_s}"
       end
 
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/dendroid/parsing/or_node.rb

@@ -4,14 +4,25 @@ require_relative 'composite_parse_node'
 
 module Dendroid
   module Parsing
+    # A composite parse node that embodies multiple syntactical derivations of a right-hand side of a rule
+    # to a range of input tokens. Each child node corresponds to a distinct derivation.
     class OrNode < CompositeParseNode
+      # @return [Dendroid::Syntax::NonTerminal] The non-terminal symbol at LHS of rule
       attr_reader :symbol
 
+      # @param sym [Dendroid::Syntax::NonTerminal]
+      # @param lower [Integer] lowest token rank matching start of the rule
+      # @param upper [Integer] largest token rank matching start of the rule
+      # @param arity [Integer] Number of derivations of the given rule
       def initialize(sym, lower, upper, arity)
         @symbol = sym
         super(lower, upper, arity)
       end
 
+      # Add a child node as root of one derivation.
+      # Place it in an available child slot.
+      # @param child_node [Dendroid::Parsing::ParseNode]
+      # @param _index [Integer] Unused
       def add_child(child_node, _index)
         idx = children.find_index(&:nil?)
         raise StandardError unless idx
@@ -20,20 +31,29 @@ module Dendroid
         super(child_node, idx)
       end
 
+      # Is the given chart entry matching this node?
+      # The chart entry matches this node if:
+      #   - its origin equals to the start of the range; and,
+      #   - both rules are the same; and,
+      #   - each child matches this chart entry
+      # @return [Boolean] true if the entry corresponds to this node.
       def match(anEItem)
-        return false if range[0] != anEItem.origin
+        return false if range.begin != anEItem.origin
 
         dotted = anEItem.dotted_item
         (symbol == dotted.rule.lhs) && children.any? { |ch| ch.match(anEItem) }
       end
 
+      # @return [FalseClass]
       def partial?
         # children.any?(&:nil?)
         false
       end
 
+      # Return a String representation of itself
+      # @return [String] text representation of itself
       def to_s
-        "OR: #{symbol.name} #{range}"
+        "OR: #{symbol.name} #{range_to_s}"
       end
 
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/dendroid/parsing/parse_node.rb

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
 module Dendroid
+  # Namespace for all classes needed for implementing a generic parser.
+  # The goal is to take the output from the Earley recognizer (i.e. a chart object),
+  # visit it and build a data structure (a parse tree or a shared parse forest) that is much
+  # more convenient for subsequent processing (e.g. semantic analysis of a compiler/interpreter).
   module Parsing
+    # An abstract class (i.e. a generalization) for elements forming a parse tree (forest).
+    # A parse tree is a graph data structure that represents the parsed input text into a tree-like hierarchy
+    # of elements constructed by applying syntax rules of the language at hand.
+    # A parse forest is a data structure that merges a number parse trees into one graph.
+    # Contrary to parse trees, a parse forests can represent the results of an ambiguous parsing.
     class ParseNode
-      # @return [Array<Integer>] The range of input tokens that match this node.
+      # @return [Range] The range of indexes of the input tokens that match this node.
       attr_reader :range
 
+      # @param lowerBound [Integer] Rank of first input token that is matched by this node
+      # @param upperBound [Integer] Rank of last input token that is matched by this node
       def initialize(lowerBound, upperBound)
         @range = valid_range(lowerBound, upperBound)
       end
 
-      def to_s
-        "[#{range[0]}, #{range[1]}]"
+      protected
+
+      def range_to_s
+        "[#{range}]"
       end
 
       private
@@ -19,7 +32,7 @@ module Dendroid
       def valid_range(lowerBound, upperBound)
         raise StandardError unless lowerBound.is_a?(Integer) && upperBound.is_a?(Integer)
 
-        [lowerBound, upperBound]
+        lowerBound..upperBound
       end
     end # class
   end # module

data/lib/dendroid/parsing/parse_tree_visitor.rb

@@ -45,7 +45,7 @@ class ParseTreeVisitor
   end
 
   # Visit event. The visitor is about to visit the given non terminal node.
-  # @param aNonTerminalNode [ANDNode] the node to visit.
+  # @param aNonTerminalNode [AndNode] the node to visit.
   def visit_and_node(aNonTerminalNode)
     if @traversal == :post_order
       broadcast(:before_and_node, aNonTerminalNode)

data/lib/dendroid/parsing/terminal_node.rb

@@ -4,6 +4,7 @@ require_relative 'parse_node'
 
 module Dendroid
   module Parsing
+    # A parse tree/forest node that is related to one input token.
     class TerminalNode < ParseNode
       # @return [Dendroid::Syntax::Terminal] Terminal symbol of matching token.
       attr_reader :symbol
@@ -23,9 +24,11 @@ module Dendroid
         aVisitor.visit_terminal(self)
       end
 
+      # Render a String representation of itself
+      # @return [String]
       def to_s
-        display_val = token.is_a?(Dendroid::Lexical::Literal) ? ": #{token.value}" : ''
-        "#{symbol.name}#{display_val} #{super}"
+        display_val = token.literal? ? ": #{token.value}" : ''
+        "#{symbol.name}#{display_val} #{range_to_s}"
       end
     end # class
   end # module

data/lib/dendroid/parsing/walk_progress.rb

@@ -1,22 +1,39 @@
 # frozen_string_literal: true
 
-require_relative 'and_node'
+require_relative 'and_node.rb'
 require_relative 'or_node'
 require_relative 'terminal_node'
 require_relative 'empty_rule_node'
 
 module Dendroid
   module Parsing
+    # 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.
     class WalkProgress
+      # @return [Symbol] One of: :New, :Forking,
       attr_accessor :state
+
+      # @return [Integer] rank of the item set from the chart being visited
       attr_accessor :curr_rank
+
+      # @return [Dendroid::Recognizer::EItem] the chart entry being visited
       attr_reader :curr_item
+
+      # When not nil, override the predecessors links of the current item
+      # @return [Dendroid::Recognizer::EItem|NilClass]
       attr_accessor :predecessor
+
+      # @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>]
       def initialize(start_rank, start_item, parents)
         @state = :New
         @curr_rank = start_rank
@@ -34,32 +51,46 @@ module Dendroid
         @parents = orig.parents.dup
       end
 
+      # Current item has multiple predecessors: set the state to Forking and
+      # force one of the predecessor to be the next entry to visit.
+      # @param thePredecessor [Dendroid::Recognizer::EItem]
       def fork(thePredecessor)
         @state = :Forking
         @predecessor = thePredecessor
       end
 
+      # Set the current entry being visited to the given one
+      # @param anEntry [Dendroid::Recognizer::EItem]
       def curr_item=(anEntry)
         raise StandardError if anEntry.nil?
 
         @curr_item = anEntry
       end
 
+      # Add a child leaf node for the given chart entry that corresponds
+      # to an empty rule.
+      # @param anEntry [Dendroid::Recognizer::EItem]
+      # @return [Dendroid::Parsing::EmptyRuleNode]
       def add_node_empty(anEntry)
         node_empty = EmptyRuleNode.new(anEntry, curr_rank)
         add_child_node(node_empty)
       end
 
-      # Add a terminal node for terminal at current rank as a child of last parent
+      # Add a leaf terminal node for the token at current rank as a child of last parent.
+      # @param token [Dendroid::Lexical::Token]
+      # @return [Dendroid::Parsing::TerminalNode]
       def add_terminal_node(token)
         @curr_rank -= 1
         term_node = TerminalNode.new(curr_item.prev_symbol, token, curr_rank)
         add_child_node(term_node)
       end
 
-      # Add an AND node for given entry as a child of last parent
+      # Make an AND node for the given entry as a child of last parent and
+      # push this node in the ancestry
+      # @param anEntry [Dendroid::Recognizer::EItem]
+      # @return [Dendroid::Parsing::AndNode]
       def push_and_node(anEntry)
-        node = ANDNode.new(anEntry, curr_rank)
+        node = AndNode.new(anEntry, curr_rank)
         raise StandardError unless anEntry.rule == node.rule # Fails
 
         add_child_node(node)
@@ -68,6 +99,11 @@ module Dendroid
         node
       end
 
+      # Make an OR node as a child of last parent and
+      # push this node in the ancestry.
+      # @param origin [Integer] Start rank
+      # #param arity [Integer] The number of alternative derivations
+      # @return [Dendroid::Parsing::OrNode]
       def push_or_node(origin, arity)
         node = OrNode.new(curr_item.prev_symbol, origin, curr_rank, arity)
         add_child_node(node)
@@ -76,6 +112,9 @@ module Dendroid
         node
       end
 
+      # Add the given node as a child of the last parent node.
+      # @param aNode [Dendroid::Parsing::ParseNode]
+      # @return [Dendroid::Parsing::ParseNode]
       def add_child_node(aNode)
         parents.last.add_child(aNode, curr_item.position - 1)
         aNode
@@ -83,6 +122,8 @@ module Dendroid
 
       # 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>]
       def match_parent?(entries, stop_at_first)
         matching = []
@@ -106,7 +147,7 @@ module Dendroid
           break if stop_at_first && !matching.empty?
 
           # Stop loop when parent.origin < min(entries.origin)
-          break if node.range[0] < min_origin
+          break if node.range.begin < min_origin
 
           offset += 1
         end

data/lib/dendroid/recognizer/e_item.rb

@@ -8,6 +8,7 @@ module Dendroid
     # An Earley item is essentially a pair consisting of a dotted item and the rank of a token.
     # It helps to keep track the progress of an Earley recognizer.
     class EItem
+      # Mix-in module used to forward some method calls to the related dotted item.
       extend Forwardable
 
       # (Weak) reference to the dotted item
@@ -17,7 +18,8 @@ module Dendroid
       # @return [Integer] the rank of the token that correspond to the start of the rule.
       attr_reader :origin
 
-      # TODO: :predictor, :completer, :scanner
+      # Specifies the algorithm with which this entry can be derived from its predecessor(s).
+      # @return [Symbol] of one: :predictor, :completer, :scanner
       attr_accessor :algo
 
       # @return [Array<WeakRef>] predecessors sorted by decreasing origin value

data/lib/dendroid/syntax/rule.rb

@@ -12,7 +12,7 @@ module Dendroid
       # @return [Array<Dendroid::Syntax::SymbolSeq>]
       attr_reader :alternatives
 
-      # Create a Choice instance.
+      # Create a Rule instance.
       # @param theLhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
       # @param alt [Array<Dendroid::Syntax::SymbolSeq>] the alternatives (each as a sequence of symbols).
       def initialize(theLhs, alt)

data/spec/dendroid/lexical/literal_spec.rb

@@ -16,7 +16,11 @@ describe Dendroid::Lexical::Literal do
       expect { described_class.new(ex_source, ex_pos, ex_terminal, ex_value) }.not_to raise_error
     end
 
-    it 'knows its value' do
+    it 'knows it is a token with a literal value attached to it' do
+      expect(subject).to be_literal
+    end
+
+    it 'knows its literal value' do
       expect(subject.value).to eq(ex_value)
     end
   end # context

data/spec/dendroid/lexical/token_spec.rb

@@ -27,5 +27,9 @@ describe Dendroid::Lexical::Token do
     it 'knows the terminal name' do
       expect(subject.terminal).to eq(ex_terminal)
     end
+
+    it 'has no literal value attached to it' do
+      expect(subject).not_to be_literal
+    end
   end # context
 end # describe

data/spec/dendroid/parsing/chart_walker_spec.rb

@@ -45,37 +45,37 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('p => s [0, 5]')
+      expect(root.to_s).to eq('p => s [0..5]')
       expect(root.children.size).to eq(1)
-      expect(root.children[-1].to_s).to eq('s => s PLUS m [0, 5]')
+      expect(root.children[-1].to_s).to eq('s => s PLUS m [0..5]')
       plus_expr = root.children[-1]
       expect(plus_expr.children.size).to eq(3)
-      expect(plus_expr.children[0].to_s).to eq('s => m [0, 1]')
-      expect(plus_expr.children[1].to_s).to eq('PLUS [1, 2]')
-      expect(plus_expr.children[2].to_s).to eq('m => m STAR t [2, 5]')
+      expect(plus_expr.children[0].to_s).to eq('s => m [0..1]')
+      expect(plus_expr.children[1].to_s).to eq('PLUS [1..2]')
+      expect(plus_expr.children[2].to_s).to eq('m => m STAR t [2..5]')
 
       operand_plus = plus_expr.children[0]
       expect(operand_plus.children.size).to eq(1)
-      expect(operand_plus.children[0].to_s).to eq('m => t [0, 1]')
+      expect(operand_plus.children[0].to_s).to eq('m => t [0..1]')
       expect(operand_plus.children[0].children.size).to eq(1)
-      expect(operand_plus.children[0].children[0].to_s).to eq('t => INTEGER [0, 1]')
-      expect(operand_plus.children[0].children[0].children[0].to_s).to eq('INTEGER: 2 [0, 1]')
+      expect(operand_plus.children[0].children[0].to_s).to eq('t => INTEGER [0..1]')
+      expect(operand_plus.children[0].children[0].children[0].to_s).to eq('INTEGER: 2 [0..1]')
 
-      expect(plus_expr.children[1].to_s).to eq('PLUS [1, 2]')
+      expect(plus_expr.children[1].to_s).to eq('PLUS [1..2]')
 
       star_expr = plus_expr.children[2]
       expect(star_expr.children.size).to eq(3)
-      expect(star_expr.children[0].to_s).to eq('m => t [2, 3]')
-      expect(star_expr.children[1].to_s).to eq('STAR [3, 4]')
-      expect(star_expr.children[2].to_s).to eq('t => INTEGER [4, 5]')
+      expect(star_expr.children[0].to_s).to eq('m => t [2..3]')
+      expect(star_expr.children[1].to_s).to eq('STAR [3..4]')
+      expect(star_expr.children[2].to_s).to eq('t => INTEGER [4..5]')
 
       operand_star = star_expr.children[0]
       expect(operand_star.children.size).to eq(1)
-      expect(operand_star.children[0].to_s).to eq('t => INTEGER [2, 3]')
-      expect(operand_star.children[0].children[0].to_s).to eq('INTEGER: 3 [2, 3]')
+      expect(operand_star.children[0].to_s).to eq('t => INTEGER [2..3]')
+      expect(operand_star.children[0].children[0].to_s).to eq('INTEGER: 3 [2..3]')
 
       expect(star_expr.children[2].children.size).to eq(1)
-      expect(star_expr.children[2].children[0].to_s).to eq('INTEGER: 4 [4, 5]')
+      expect(star_expr.children[2].children[0].to_s).to eq('INTEGER: 4 [4..5]')
     end
 
     it 'generates a parse tree for grammar l10 (with left recursive rule)' do
@@ -84,27 +84,27 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('A => A a [0, 5]')
+      expect(root.to_s).to eq('A => A a [0..5]')
       expect(root.children.size).to eq(2)
-      expect(root.children[0].to_s).to eq('A => A a [0, 4]')
-      expect(root.children[1].to_s).to eq('a [4, 5]')
+      expect(root.children[0].to_s).to eq('A => A a [0..4]')
+      expect(root.children[1].to_s).to eq('a [4..5]')
 
       expect(root.children[0].children.size).to eq(2)
-      expect(root.children[0].children[0].to_s).to eq('A => A a [0, 3]')
-      expect(root.children[0].children[1].to_s).to eq('a [3, 4]')
+      expect(root.children[0].children[0].to_s).to eq('A => A a [0..3]')
+      expect(root.children[0].children[1].to_s).to eq('a [3..4]')
 
       grand_child = root.children[0].children[0]
       expect(grand_child.children.size).to eq(2)
-      expect(grand_child.children[0].to_s).to eq('A => A a [0, 2]')
-      expect(grand_child.children[1].to_s).to eq('a [2, 3]')
+      expect(grand_child.children[0].to_s).to eq('A => A a [0..2]')
+      expect(grand_child.children[1].to_s).to eq('a [2..3]')
 
       expect(grand_child.children[0].children.size).to eq(2)
-      expect(grand_child.children[0].children[0].to_s).to eq('A => A a [0, 1]')
-      expect(grand_child.children[0].children[1].to_s).to eq('a [1, 2]')
+      expect(grand_child.children[0].children[0].to_s).to eq('A => A a [0..1]')
+      expect(grand_child.children[0].children[1].to_s).to eq('a [1..2]')
 
       expect(grand_child.children[0].children[0].children.size).to eq(2)
-      expect(grand_child.children[0].children[0].children[0].to_s).to eq('_ [0, 0]')
-      expect(grand_child.children[0].children[0].children[1].to_s).to eq('a [0, 1]')
+      expect(grand_child.children[0].children[0].children[0].to_s).to eq('_ [0..0]')
+      expect(grand_child.children[0].children[0].children[1].to_s).to eq('a [0..1]')
     end
 
     it 'generates a parse tree for grammar l11 (with right recursive rule)' do
@@ -113,27 +113,27 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('A => a A [0, 5]')
+      expect(root.to_s).to eq('A => a A [0..5]')
       expect(root.children.size).to eq(2)
-      expect(root.children[0].to_s).to eq('a [0, 1]')
-      expect(root.children[1].to_s).to eq('A => a A [1, 5]')
+      expect(root.children[0].to_s).to eq('a [0..1]')
+      expect(root.children[1].to_s).to eq('A => a A [1..5]')
 
       expect(root.children[1].children.size).to eq(2)
-      expect(root.children[1].children[0].to_s).to eq('a [1, 2]')
-      expect(root.children[1].children[1].to_s).to eq('A => a A [2, 5]')
+      expect(root.children[1].children[0].to_s).to eq('a [1..2]')
+      expect(root.children[1].children[1].to_s).to eq('A => a A [2..5]')
 
       grand_child = root.children[1].children[1]
       expect(grand_child.children.size).to eq(2)
-      expect(grand_child.children[0].to_s).to eq('a [2, 3]')
-      expect(grand_child.children[1].to_s).to eq('A => a A [3, 5]')
+      expect(grand_child.children[0].to_s).to eq('a [2..3]')
+      expect(grand_child.children[1].to_s).to eq('A => a A [3..5]')
 
       expect(grand_child.children[1].children.size).to eq(2)
-      expect(grand_child.children[1].children[0].to_s).to eq('a [3, 4]')
-      expect(grand_child.children[1].children[1].to_s).to eq('A => a A [4, 5]')
+      expect(grand_child.children[1].children[0].to_s).to eq('a [3..4]')
+      expect(grand_child.children[1].children[1].to_s).to eq('A => a A [4..5]')
 
       expect(grand_child.children[1].children[1].children.size).to eq(2)
-      expect(grand_child.children[1].children[1].children[0].to_s).to eq('a [4, 5]')
-      expect(grand_child.children[1].children[1].children[1].to_s).to eq('_ [5, 5]')
+      expect(grand_child.children[1].children[1].children[0].to_s).to eq('a [4..5]')
+      expect(grand_child.children[1].children[1].children[1].to_s).to eq('_ [5..5]')
     end
   end # context
 
@@ -144,78 +144,78 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('OR: S [0, 4]')
+      expect(root.to_s).to eq('OR: S [0..4]')
       expect(root.children.size).to eq(3)
       root.children.each do |child|
         expect(child.children.size).to eq(2)
-        expect(child.to_s).to eq('S => S S [0, 4]')
+        expect(child.to_s).to eq('S => S S [0..4]')
       end
       (a, b, c) = root.children
 
       # Test structure of tree a
       (child_a_0, child_a_1) = a.children
-      expect(child_a_0.to_s).to eq('S => S S [0, 2]')
-      expect(child_a_1.to_s).to eq('S => S S [2, 4]')
+      expect(child_a_0.to_s).to eq('S => S S [0..2]')
+      expect(child_a_1.to_s).to eq('S => S S [2..4]')
       expect(child_a_0.children.size).to eq(2)
       (child_a_0_0, child_a_0_1) = child_a_0.children
-      expect(child_a_0_0.to_s).to eq('S => x [0, 1]')
-      expect(child_a_0_1.to_s).to eq('S => x [1, 2]')
-      expect(child_a_0_0.children[0].to_s).to eq('x [0, 1]')
-      expect(child_a_0_1.children[0].to_s).to eq('x [1, 2]')
+      expect(child_a_0_0.to_s).to eq('S => x [0..1]')
+      expect(child_a_0_1.to_s).to eq('S => x [1..2]')
+      expect(child_a_0_0.children[0].to_s).to eq('x [0..1]')
+      expect(child_a_0_1.children[0].to_s).to eq('x [1..2]')
 
       expect(child_a_1.children.size).to eq(2)
       (child_a_1_0, child_a_1_1) = child_a_1.children
-      expect(child_a_1_0.to_s).to eq('S => x [2, 3]')
-      expect(child_a_1_1.to_s).to eq('S => x [3, 4]')
-      expect(child_a_1_0.children[0].to_s).to eq('x [2, 3]')
-      expect(child_a_1_1.children[0].to_s).to eq('x [3, 4]')
+      expect(child_a_1_0.to_s).to eq('S => x [2..3]')
+      expect(child_a_1_1.to_s).to eq('S => x [3..4]')
+      expect(child_a_1_0.children[0].to_s).to eq('x [2..3]')
+      expect(child_a_1_1.children[0].to_s).to eq('x [3..4]')
 
       # Test structure of forest b
       (child_b_0, child_b_1) = b.children
-      expect(child_b_0.to_s).to eq('OR: S [0, 3]')
-      expect(child_b_1.to_s).to eq('S => x [3, 4]')
+      expect(child_b_0.to_s).to eq('OR: S [0..3]')
+      expect(child_b_1.to_s).to eq('S => x [3..4]')
       expect(child_b_1.equal?(child_a_1_1)).to be_truthy # Sharing
       expect(child_b_0.children.size).to eq(2)
       (child_b_0_0, child_b_0_1) = child_b_0.children
-      expect(child_b_0_0.to_s).to eq('S => S S [0, 3]')
-      expect(child_b_0_1.to_s).to eq('S => S S [0, 3]')
+      expect(child_b_0_0.to_s).to eq('S => S S [0..3]')
+      expect(child_b_0_1.to_s).to eq('S => S S [0..3]')
       expect(child_b_0_0.children.size).to eq(2)
       (child_b_0_0_0, child_b_0_0_1) = child_b_0_0.children
-      expect(child_b_0_0_0.to_s).to eq('S => x [0, 1]')
+      expect(child_b_0_0_0.to_s).to eq('S => x [0..1]')
       expect(child_b_0_0_0.equal?(child_a_0_0)).to be_truthy # Sharing
-      expect(child_b_0_0_1.to_s).to eq('S => S S [1, 3]')
+      expect(child_b_0_0_1.to_s).to eq('S => S S [1..3]')
       expect(child_b_0_0_1.children.size).to eq(2)
-      expect(child_b_0_0_1.children[0].to_s).to eq('S => x [1, 2]')
+      expect(child_b_0_0_1.children[0].to_s).to eq('S => x [1..2]')
       expect(child_b_0_0_1.children[0].equal?(child_a_0_1)).to be_truthy # Sharing
-      expect(child_b_0_0_1.children[1].to_s).to eq('S => x [2, 3]')
+      expect(child_b_0_0_1.children[1].to_s).to eq('S => x [2..3]')
       expect(child_b_0_0_1.children[1].equal?(child_a_1_0)).to be_truthy # Sharing
 
       expect(child_b_0_1.children.size).to eq(2)
       (child_b_0_1_0, child_b_0_1_1) = child_b_0_1.children
-      expect(child_b_0_1_0.to_s).to eq('S => S S [0, 2]')
+      expect(child_b_0_1_0.to_s).to eq('S => S S [0..2]')
       expect(child_b_0_1_0.equal?(child_a_0)).to be_truthy # Sharing
-      expect(child_b_0_1_1.to_s).to eq('S => x [2, 3]')
+      expect(child_b_0_1_1.to_s).to eq('S => x [2..3]')
       expect(child_b_0_1_1.equal?(child_a_1_0)).to be_truthy # Sharing
 
       # Test structure of forest c
       (child_c_0, child_c_1) = c.children
-      expect(child_c_0.to_s).to eq('S => x [0, 1]')
+      expect(child_c_0.to_s).to eq('S => x [0..1]')
       expect(child_c_0.equal?(child_a_0_0)).to be_truthy # Sharing
-      expect(child_c_1.to_s).to eq('OR: S [1, 4]')
+      expect(child_c_1.to_s).to eq('OR: S [1..4]')
       expect(child_c_1.children.size).to eq(2)
       (child_c_1_0, child_c_1_1) = child_c_1.children
-      expect(child_c_1_0.to_s).to eq('S => S S [1, 4]')
-      expect(child_c_1_1.to_s).to eq('S => S S [1, 4]')
+      expect(child_c_1_0.to_s).to eq('S => S S [1..4]')
+      expect(child_c_1_1.to_s).to eq('S => S S [1..4]')
       expect(child_c_1_0.children.size).to eq(2)
       (child_c_1_0_0, child_c_1_0_1) = child_c_1_0.children
-      expect(child_c_1_0_0.to_s).to eq('S => x [1, 2]')
+      expect(child_c_1_0_0.to_s).to eq('S => x [1..2]')
       expect(child_c_1_0_0.equal?(child_a_0_1)).to be_truthy # Sharing
-      expect(child_c_1_0_1.to_s).to eq('S => S S [2, 4]')
+      expect(child_c_1_0_1.to_s).to eq('S => S S [2..4]')
       expect(child_c_1_0_1.equal?(child_a_1)).to be_truthy # Sharing
       (child_c_1_1_0, child_c_1_1_1) = child_c_1_1.children
-      expect(child_c_1_1_0.to_s).to eq('S => S S [1, 3]')
+      expect(child_c_1_1_0.to_s).to eq('S => S S [1..3]')
       expect(child_c_1_1_0.equal?(child_b_0_0_1)).to be_truthy # Sharing
-      expect(child_c_1_1_1.to_s).to eq('S => x [3, 4]')
+      expect(child_c_1_1_1.to_s).to eq('S => x [3..4]')
       expect(child_c_1_1_1.equal?(child_b_1)).to be_truthy # Sharing
     end
 
@@ -225,24 +225,24 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('OR: S [0, 2]')
+      expect(root.to_s).to eq('OR: S [0..2]')
       expect(root.children.size).to eq(2)
       root.children.each do |ch|
-        expect(ch.to_s).to eq('S => S T [0, 2]')
+        expect(ch.to_s).to eq('S => S T [0..2]')
         expect(ch.children.size).to eq(2)
       end
       (child_0_0, child_0_1) = root.children[0].children
-      expect(child_0_0.to_s).to eq('S => a [0, 1]')
-      expect(child_0_1.to_s).to eq('T => a B [1, 2]')
+      expect(child_0_0.to_s).to eq('S => a [0..1]')
+      expect(child_0_1.to_s).to eq('T => a B [1..2]')
       expect(child_0_1.children.size).to eq(2)
-      expect(child_0_1.children[0].to_s).to eq('a [1, 2]')
-      expect(child_0_1.children[1].to_s).to eq('_ [2, 2]')
+      expect(child_0_1.children[0].to_s).to eq('a [1..2]')
+      expect(child_0_1.children[1].to_s).to eq('_ [2..2]')
 
       (child_1_0, child_1_1) = root.children[1].children
-      expect(child_1_0.to_s).to eq('S => a [0, 1]')
-      expect(child_1_1.to_s).to eq('T => a [1, 2]')
+      expect(child_1_0.to_s).to eq('S => a [0..1]')
+      expect(child_1_1.to_s).to eq('T => a [1..2]')
       expect(child_1_0.equal?(child_0_0)).to be_truthy # Sharing
-      expect(child_1_1.children[0].to_s).to eq('a [1, 2]')
+      expect(child_1_1.children[0].to_s).to eq('a [1..2]')
       expect(child_1_1.children[0].equal?(child_0_1.children[0])).to be_truthy # Sharing
     end
   end # context

data/spec/dendroid/parsing/composite_parse_node_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/dendroid/parsing/composite_parse_node'
+
+RSpec.describe Dendroid::Parsing::CompositeParseNode do
+  let(:sample_range) { 3..5 }
+  let(:sample_child_count) { 7 }
+  subject { described_class.new(sample_range.begin, sample_range.end, sample_child_count) }
+
+  context 'Initialization:' do
+    it 'should be initialized with two token positions and a child count' do
+      expect { described_class.new(sample_range.begin, sample_range.end, sample_child_count) }.not_to raise_error
+    end
+
+    it 'has its children array filled with nils' do
+      # Check number of elements...
+      expect(subject.children.size).to eq(sample_child_count)
+
+      # All elements are nil
+      expect(subject.children.all?(&:nil?)).to be_truthy
+    end
+  end # context
+
+  context 'provided services:' do
+    it 'adds a child node at a specific slot' do
+      child3 = Dendroid::Parsing::ParseNode.new(3, 4)
+      child5 = Dendroid::Parsing::ParseNode.new(5, 6)
+      subject.add_child(child3, 3)
+      subject.add_child(child5, 5)
+      expect(subject.children.reject(&:nil?).size).to eq(2)
+      expect(subject.children[3]).to eq(child3)
+      expect(subject.children[5]).to eq(child5)
+    end
+  end # context
+end # describe

data/spec/dendroid/parsing/empty_rule_node_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/dendroid/grm_dsl/base_grm_builder'
+require_relative '../../../lib/dendroid/grm_analysis/dotted_item'
+require_relative '../../../lib/dendroid/recognizer/e_item'
+require_relative '../../../lib/dendroid/parsing/empty_rule_node'
+
+RSpec.describe Dendroid::Parsing::EmptyRuleNode do
+  let(:sample_rule) { sample_grammar.rules[0] }
+  let(:sample_dotted_item) { Dendroid::GrmAnalysis::DottedItem.new(sample_rule, 0, 1) }
+  let(:sample_entry) { Dendroid::Recognizer::EItem.new(sample_dotted_item, 5) }
+
+  subject { described_class.new(sample_entry, 5) }
+
+  let(:sample_grammar) do
+    builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
+      declare_terminals('INTEGER')
+
+      rule('s' => ['INTEGER', ''])
+    end
+
+    builder.grammar
+  end
+
+  context 'Initialization:' do
+    it 'should be initialized with a chart entry and an end rank number' do
+      expect { described_class.new(sample_entry, 5) }.not_to raise_error
+    end
+
+    it 'knows the rule it is related to' do
+      expect(subject.rule).to eq(sample_grammar.rules[0])
+    end
+
+    it 'knows the alternative index it is related to' do
+      expect(subject.alt_index).to eq(1)
+    end
+
+    it 'knows its origin and end positions' do
+      expect(subject.range.begin).to eq(subject.range.end)
+      expect(subject.range.begin).to eq(5)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'renders a String representation of its range' do
+      expect(subject.to_s).to eq('_ [5..5]')
+    end
+  end # context
+end # describe

data/spec/dendroid/parsing/parse_node_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/dendroid/parsing/parse_node'
+
+RSpec.describe Dendroid::Parsing::ParseNode do
+  let(:sample_range) { 3..5 }
+  subject { described_class.new(3, 5) }
+
+  context 'Initialization:' do
+    it 'should be initialized with two token positions' do
+      expect { described_class.new(3, 5) }.not_to raise_error
+    end
+
+    it 'knows its origin and end positions' do
+      expect(subject.range).to eq(sample_range)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'renders a String representation of its range' do
+      expect(subject.send(:range_to_s)).to eq('[3..5]')
+    end
+  end # context
+end # describe

data/spec/dendroid/parsing/terminal_node_spec.rb

@@ -22,15 +22,15 @@ RSpec.describe Dendroid::Parsing::TerminalNode do
     it 'should be initialized with a symbol, terminal and a rank' do
       expect { described_class.new(ex_terminal, plus_token, 3) }.not_to raise_error
     end
-  end
+  end # context
 
-  context 'provided services' do
+  context 'provided services:' do
     it 'renders a String representation of itself' do
-      expect(plus_node.to_s).to eq('PLUS [3, 4]')
+      expect(plus_node.to_s).to eq('PLUS [3..4]')
     end
 
     it 'renders also the token value (if any)' do
-      expect(int_node.to_s).to eq('INTEGER: 2 [5, 6]')
+      expect(int_node.to_s).to eq('INTEGER: 2 [5..6]')
     end
   end
 end

data/version.txt

@@ -1 +1 @@
-0.2.02
+0.2.03

metadata

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