rley 0.6.06 → 0.6.07

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1e6215ec93e9404550f4ac55ac71cb294d5d3ef
-  data.tar.gz: 73b5089ae521c84ec6999096054dc1212e646d28
+  metadata.gz: 25c9a2612411bdb3767901c9b21d1e38f5279c94
+  data.tar.gz: 9c3ffe74bda63f31d40421b74a6f976ac3db49ad
 SHA512:
-  metadata.gz: e954203459567724574ae05d976d5c836c21febdacc730971630a585ae73809bff5fa240238151c704ba51ccda44d9c2434f3202bdeddda75abb1b17cafa1a04
-  data.tar.gz: cc61845755b29425dfe538b7f7fd1605e21fb43be2d8e33956688bfca5f7626c257d31b6264ae44066875dadb4e9e4bb53a7e8a3adce16f76c14af2207ad9007
+  metadata.gz: d289304c2a693fb1eb14747751e205bc23cccb9941c5f416af1966e6b3fcf3d2ff58f52ae6d56a2cae40752bcccbc2cd9a2c9015cc555a5ad3ef1890306f15e9
+  data.tar.gz: c59a9d80ff3b941efabed869de7e5d16b6ebc597c3a63d914de3976aa3c709a6cfde0630c8c931e14ae559e4c3fcbc5dddb935fa2d58c12c71fafad2fc817f4e

data/.rubocop.yml

@@ -1,111 +1,111 @@
-AllCops:
-  Exclude:
-    - 'features/**/*'
-    - 'exp/**/*'    
-    - 'gems/**/*'
-    - 'refs/**/*'
-    
-# This is disabled because some demos use UTF-8
-AsciiComments:
-  Enabled: false
-  
-Attr:
-  Enabled: false
-  
-BlockComments:
-  Enabled: false
-  
-CaseIndentation:
-  EnforcedStyle: end
-  IndentOneStep: true
-
-# Rubocop enforces the use of is_a? instead of kind_of?
-# Which is contrary to modelling practice.
-ClassCheck:
-  Enabled: false
-  
-ClassLength:
-  Max: 250
-  CountComments: false  
-
-ConstantName:  
-  Enabled: false
-  
-CyclomaticComplexity:
-  Enabled: false
-  
-DefWithParentheses:  
-  Enabled: false
-  
-Documentation:
-  Enabled: false
-  
-EmptyLines:
-  Enabled: false 
-
-Encoding:
-  Enabled: false
-  
-EndOfLine:
-  Enabled: false
-#  SupportedStyles: lf
-  
-  
-IndentationWidth :
-  Enabled: false
-  
-# Disable this because it produces false negatives
-Naming/HeredocDelimiterNaming:
-  Enabled: false
-  
-# Enabled after end of support of Rubies < 2.3
-Layout/IndentHeredoc:
-  Enabled: false
-
-Metrics/AbcSize:
-  Max: 50
-  
-# Avoid methods longer than 50 lines of code
-Metrics/MethodLength:
-  Max: 50
-  CountComments: false 
-
-# Avoid modules longer than 200 lines of code 
-Metrics/ModuleLength:
-  CountComments: false
-  Max: 200  
-
-Metrics/PerceivedComplexity:
-  Enabled: true
-  Max: 50
-  
-Naming/MethodName:
-  Enabled: false
- 
-NonNilCheck:
-  Enabled: false
-
-NumericLiterals:
-  Enabled: false
-  
-RaiseArgs:
-  Enabled: false
-  
-RedundantReturn:
-  Enabled: false
-
-SpaceInsideBrackets:
-  Enabled: false
-
-TrailingWhitespace:
-  Enabled: false
-  
-VariableName:
-  Enabled: false
-
-VariableNumber:
-  Enabled: false
-  
-Style/CommentedKeyword:
-  Enabled: false
-  
+AllCops:
+  Exclude:
+    - 'features/**/*'
+    - 'exp/**/*'    
+    - 'gems/**/*'
+    - 'refs/**/*'
+    
+# This is disabled because some demos use UTF-8
+AsciiComments:
+  Enabled: false
+  
+Attr:
+  Enabled: false
+  
+BlockComments:
+  Enabled: false
+  
+CaseIndentation:
+  EnforcedStyle: end
+  IndentOneStep: true
+
+# Rubocop enforces the use of is_a? instead of kind_of?
+# Which is contrary to modelling practice.
+ClassCheck:
+  Enabled: false
+  
+ClassLength:
+  Max: 250
+  CountComments: false  
+
+ConstantName:  
+  Enabled: false
+  
+CyclomaticComplexity:
+  Enabled: false
+  
+DefWithParentheses:  
+  Enabled: false
+  
+Documentation:
+  Enabled: false
+  
+EmptyLines:
+  Enabled: false 
+
+Encoding:
+  Enabled: false
+  
+EndOfLine:
+  Enabled: false
+#  SupportedStyles: lf
+  
+  
+IndentationWidth :
+  Enabled: false
+  
+# Disable this because it produces false negatives
+Naming/HeredocDelimiterNaming:
+  Enabled: false
+  
+# Enabled after end of support of Rubies < 2.3
+Layout/IndentHeredoc:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 50
+  
+# Avoid methods longer than 50 lines of code
+Metrics/MethodLength:
+  Max: 50
+  CountComments: false 
+
+# Avoid modules longer than 200 lines of code 
+Metrics/ModuleLength:
+  CountComments: false
+  Max: 200  
+
+Metrics/PerceivedComplexity:
+  Enabled: true
+  Max: 50
+  
+Naming/MethodName:
+  Enabled: false
+ 
+NonNilCheck:
+  Enabled: false
+
+NumericLiterals:
+  Enabled: false
+  
+RaiseArgs:
+  Enabled: false
+  
+RedundantReturn:
+  Enabled: false
+
+SpaceInsideBrackets:
+  Enabled: false
+
+TrailingWhitespace:
+  Enabled: false
+  
+VariableName:
+  Enabled: false
+
+VariableNumber:
+  Enabled: false
+  
+Style/CommentedKeyword:
+  Enabled: false
+  

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 0.6.07 / 2018-05-29
+* [CHANGE] Method `GFGEarleyParser#parse` doesn't assume that the exact sequence of tokens to be known in advance.
+* [FIXED] Method `GFGParsing#nullable_rule`: in very specific cases a wrong parse entry was added to the parse chart.
+* [FIXED] File `examples/general/left.rb` is working back.
+
 ### 0.6.06 / 2018-04-12
 * [ADDED] Method `done!`: added to classes involved parse tree and parse forest creation. This method signals the end of parsing.
 * [CHANGE] Method `ParseTreeBuilder#process_item_entry`: added an explicit message in case of ambiguous parse.

data/Gemfile

@@ -5,5 +5,5 @@ group :development do
   gem 'coveralls', '>= 0.7.0'
   gem 'rake',  '>= 10.0.0' 
   gem 'rspec', '>= 3.5.0'
-  gem 'simplecov', '>= 0.1.0'
+  gem 'simplecov', '>= 0.8.0'
 end

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.6.06'.freeze
+  Version = '0.6.07'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

data/lib/rley/parse_rep/ast_base_builder.rb

@@ -21,14 +21,14 @@ module Rley # This module is used as a namespace
       def terminal2node()
         raise NotImplementedError
       end
-      
+
       # Method to override in subclass.
       # Default class for representing terminal nodes.
       # @return [Class]
       def terminalnode_class()
         PTree::TerminalNode
       end
-      
+
       # Default method name to invoke when production
       # with given name is invoked.
       # Override this method for other method naming convention.
@@ -51,7 +51,7 @@ module Rley # This module is used as a namespace
       # Simply return the second child node
       # @param _range [Lexical::TokenRange]
       # @param _tokens [Array<Lexical::Token>]
-      # @param theChildren [Array<Object>]      
+      # @param theChildren [Array<Object>]
       def return_second_child(_range, _tokens, theChildren)
         return theChildren[1]
       end
@@ -60,7 +60,7 @@ module Rley # This module is used as a namespace
       # Simply return the last child node
       # @param _range [Lexical::TokenRange]
       # @param _tokens [Array<Lexical::Token>]
-      # @param theChildren [Array<Object>]      
+      # @param theChildren [Array<Object>]
       def return_last_child(_range, _tokens, theChildren)
         return theChildren[-1]
       end
@@ -68,13 +68,13 @@ module Rley # This module is used as a namespace
       # Simply return an epsilon symbol
       # @param _range [Lexical::TokenRange]
       # @param _tokens [Array<Lexical::Token>]
-      # @param _children [Array<Object>]       
+      # @param _children [Array<Object>]
       def return_epsilon(_range, _tokens, _children)
         return nil
       end
-      
+
       protected
-     
+
       # Overriding method.
       # Create a parse tree object with given
       # node as root node.
@@ -98,7 +98,7 @@ module Rley # This module is used as a namespace
 
         return node
       end
- 
+
       # Method to override.
       # Factory method for creating a parent node object.
       # @param aProduction [Production] Production rule
@@ -119,7 +119,7 @@ module Rley # This module is used as a namespace
                    else
                     msg = "Don't know production '#{aProduction.name}'"
                     raise StandardError, msg
-                 end            
+                 end
         end
         return node
       end

data/lib/rley/parse_rep/parse_tree_builder.rb

@@ -47,7 +47,7 @@ module Rley # This module is used as a namespace
         @dummy_node = Object.new.freeze
       end
       
-      # Notify the builder that the construction is over
+      # Notify the builder that the parse tree construction is complete.
       def done!()
         result.done!
       end      
@@ -77,7 +77,7 @@ module Rley # This module is used as a namespace
 
       # Return the stack
       def stack()
-        return @stack
+        @stack
       end
 
       # Overriding method.
@@ -92,7 +92,7 @@ module Rley # This module is used as a namespace
 
       # Return the top of stack element.
       def tos()
-        return @stack.last
+        @stack.last
       end
 
       # Handler for visit events for ParseEntry matching N. pattern

data/lib/rley/parser/gfg_chart.rb

@@ -12,10 +12,9 @@ module Rley # This module is used as a namespace
       # @return [Array<ParseEntrySet>] entry sets (one per input token + 1)
       attr_reader(:sets)
 
-      # @param tokenCount [Integer] The number of lexemes in the input to parse.
       # @param aGFGraph [GFG::GrmFlowGraph] The GFG for the grammar in use.
-      def initialize(tokenCount, aGFGraph)
-        @sets = Array.new(tokenCount + 1) { |_| ParseEntrySet.new }
+      def initialize( aGFGraph)
+        @sets = [ ParseEntrySet.new ]
         push_entry(aGFGraph.start_vertex, 0, 0, :start_rule)
       end
 
@@ -25,7 +24,7 @@ module Rley # This module is used as a namespace
       end
 
       # @param index [Integer]
-      # @return [ParseEntrySet] Access the entry set at given position
+      # @return [ParseEntrySet] Access the entry set at given position.
       def [](index)
         return sets[index]
       end
@@ -53,6 +52,11 @@ module Rley # This module is used as a namespace
         # puts "  anIndex: #{anIndex}"
         # puts "  _reason: #{_reason}"
         new_entry = ParseEntry.new(aVertex, anOrigin)
+        if anIndex == sets.size
+          err_msg = "Internal error: unexpected push reason #{_reason}"
+          raise StandardError, err_msg if _reason != :scan_rule
+          add_entry_set 
+        end
         pushed = self[anIndex].push_entry(new_entry)
 
         return pushed
@@ -88,6 +92,13 @@ module Rley # This module is used as a namespace
 
         return success_entries.first
       end
+
+      private
+
+      def add_entry_set()
+         @sets << ParseEntrySet.new
+      end
+
     end # class
   end # module
 end # module

data/lib/rley/parser/gfg_earley_parser.rb

@@ -22,36 +22,40 @@ module Rley # This module is used as a namespace
       # tokenizer/scanner/lexer.
       # @return [GFGParsing] an object that embeds the parse results.
       def parse(aTokenSequence)
-        result = GFGParsing.new(gf_graph, aTokenSequence)
-        last_token_index = aTokenSequence.size
-        if last_token_index.zero? && !grammar.start_symbol.nullable?
+        result = GFGParsing.new(gf_graph)
+        token_count = aTokenSequence.size
+        if token_count.zero? && !grammar.start_symbol.nullable?
           return unexpected_empty_input(result)
         end
 
-        (0..last_token_index).each do |i|
-          result.chart[i].each do |entry|
-            # Is entry of the form? [A => alpha . B beta, k]...
-            next_symbol = entry.next_symbol
-            if next_symbol && next_symbol.kind_of?(Syntax::NonTerminal)
-              # ...apply the Call rule
-              call_rule(result, entry, i)
-            end
-
-            exit_rule(result, entry, i) if entry.exit_entry?
-            start_rule(result, entry, i) if entry.start_entry?
-            end_rule(result, entry, i) if entry.end_entry?
-          end
-          if i < last_token_index
-            scan_success = scan_rule(result, i)
-            break unless scan_success
-          end
+        aTokenSequence.each_with_index do |token, i|
+          parse_for_token(result, i)
+          scan_success = scan_rule(result, i, token)
+          break unless scan_success
         end
+        parse_for_token(result, token_count) unless result.failure_reason
+
         result.done # End of parsing process
         return result
       end
 
       private
 
+      def parse_for_token(result, index)
+        result.chart[index].each do |entry|
+          # Is entry of the form? [A => alpha . B beta, k]...
+          next_symbol = entry.next_symbol
+          if next_symbol && next_symbol.kind_of?(Syntax::NonTerminal)
+            # ...apply the Call rule
+            call_rule(result, entry, index)
+          end
+
+          exit_rule(result, entry, index) if entry.exit_entry?
+          start_rule(result, entry, index) if entry.start_entry?
+          end_rule(result, entry, index) if entry.end_entry?
+        end
+      end
+
       # Let the current sigma set be the ith parse entry set.
       # This method is invoked when an entry is added to the parse entry set
       # and is of the form [A => alpha . B beta, k].
@@ -95,17 +99,17 @@ module Rley # This module is used as a namespace
       #     [A => α . t γ, i]
       #     and allow them to cross the edge, adding the node on the back side
       #     of the edge as an entry to the next sigma set:
-      #       add an entry to the next sigma set [A => α t . γ, i]
-      def scan_rule(aParsing, aPosition)
-        aParsing.scan_rule(aPosition)
+      #       add an entry to the next sigma set [A => α t . γ, i + 1]
+      def scan_rule(aParsing, aPosition, aToken)
+        aParsing.scan_rule(aPosition, aToken)
       end
-      
+
       # Parse error detected: no input tokens provided while the grammar
       # forbids this this.
       def unexpected_empty_input(aParsing)
         aParsing.faulty(NoInput.new)
         return aParsing
-      end 
+      end
     end # class
   end # module
 end # module

data/lib/rley/parser/gfg_parsing.rb

@@ -33,11 +33,10 @@ module Rley # This module is used as a namespace
 
       # Constructor
       # @param theGFG [GFG::GrmFlowGraph] the Grammar Flow Graph
-      # @param theTokens [Array<Token>] the array of input tokens
-      def initialize(theGFG, theTokens)
+      def initialize(theGFG)
         @gf_graph = theGFG
-        @tokens = theTokens.dup
-        @chart = GFGChart.new(tokens.size, gf_graph)
+        @tokens = []
+        @chart = GFGChart.new(gf_graph)
         @antecedence = Hash.new { |hash, key| hash[key] = [] }
         antecedence[chart[0].first]
       end
@@ -57,7 +56,7 @@ module Rley # This module is used as a namespace
 
         if next_symbol.nullable? && anEntry.dotted_entry?
           size_after = chart[pos].size
-          # ...apply the Nullable rule
+          # ...apply the Nullable rule, if not already invoked for this entry
           nullable_rule(anEntry, aPosition) if size_after == size_before
         end
       end
@@ -81,14 +80,15 @@ module Rley # This module is used as a namespace
 
         start.edges.each do |edge|
           succ = edge.successor # succ always an ItemVertex
-          next if succ.dotted_item.production.generative?
-          succ_entry = apply_rule(start_entry, succ, pos, pos, :nullable_rule)
-          apply_rule(succ_entry, end_vertex, pos, pos, :nullable_rule)
+          if succ.dotted_item.production.nullable?
+            succ_entry = apply_rule(start_entry, succ, pos, pos, :nullable_rule)
+            apply_rule(succ_entry, end_vertex, pos, pos, :nullable_rule)
+          end
         end
 
         curr_vertex = anEntry.vertex
         next_vertex = curr_vertex.shortcut.successor
-        end_entry = push_entry(end_vertex, pos, pos, :nullable_rule)        
+        end_entry = push_entry(end_vertex, pos, pos, :nullable_rule)
         apply_rule(end_entry, next_vertex, anEntry.origin, pos, :nullable_rule)
       end
 
@@ -144,10 +144,11 @@ module Rley # This module is used as a namespace
       #     [A => α . t γ, i]
       #     and allow them to cross the edge, adding the node on the back side
       #     of the edge as an entry to the next sigma set:
-      #       add an entry to the next sigma set [A => α t . γ, i]
+      #       add an entry to the next sigma set [A => α t . γ, i + 1]
       # returns true if next token matches the expectations, false otherwise.
-      def scan_rule(aPosition)
-        terminal = tokens[aPosition].terminal
+      def scan_rule(aPosition, aToken)
+        tokens << aToken
+        terminal = aToken.terminal
 
         # Retrieve all the entries that expect the given terminal
         expecting_term = chart[aPosition].entries4term(terminal)
@@ -271,11 +272,11 @@ END_MSG
             # Rule: has 1..* antecedents, all of them are exit items
             antecedents.each do |antec|
               next if antec.exit_entry?
-              msg_prefix = "Parse entry #{consequent}"
-              msg_suffix = " has for antecedent #{antec}"              
+              msg_prefix = "End vertex parse entry #{consequent}"
+              msg_suffix = " has for antecedent #{antec}"
               raise StandardError, msg_prefix + msg_suffix
             end
-          
+
           when Rley::GFG::ItemVertex
             # Rule: has exactly one antecedent
             # if antecedents.size > 1
@@ -284,15 +285,15 @@ END_MSG
               # msg_suffix = antecedents.map(&:to_s).join("\n")
               # raise(StandardError, msg_prefix + msg + msg_suffix)
             # end
-            
+
           when Rley::GFG::StartVertex
             # Rule: has 0..* antecedents, all of them are item vertices but not exit items
             antecedents.each do |antec|
               next if antec.dotted_entry? && !antec.end_entry?
               msg_prefix = "Parse entry #{consequent}"
-              msg_suffix = " has for antecedent #{antec}"              
+              msg_suffix = " has for antecedent #{antec}"
               raise StandardError, msg_prefix + msg_suffix
-            end            
+            end
         end
 
         consequent.add_antecedent(antecedentEntry)

data/lib/rley/parser/parse_walker_factory.rb

@@ -52,6 +52,8 @@ module Rley # This module is used as a namespace
       # @return [Enumerator] yields visit events when walking over the
       #   parse result
       def build_walker(acceptingEntry, maxIndex, lazyWalk = false)
+        msg = 'Internal error: nil entry argument'
+        raise StandardError, msg if acceptingEntry.nil?
         # Local context for the enumerator
         ctx = init_context(acceptingEntry, maxIndex, lazyWalk)
 

data/lib/rley/ptree/parse_tree.rb

@@ -13,7 +13,7 @@ module Rley # This module is used as a namespace
     # The root node corresponds to the main/start symbol of the grammar.
     class ParseTree
       # @return [ParseTreeNode] The root node of the tree.
-      attr_reader(:root)
+      attr_accessor(:root)
 
       # @param theRootNode [ParseTreeNode] The root node of the parse tree.
       def initialize(theRootNode)

data/lib/rley/syntax/grammar.rb

@@ -214,20 +214,36 @@ module Rley # This module is used as a namespace
           filtered_rules.reject! { |prod| prod.lhs.nullable? }
           nullable_sets[i] = nullable_sets[i - 1].merge(new_nullables)
         end
+        
+        mark_nullable
       end
 
       # Return the set of nonterminals which have one of their
       # production rules empty
       def direct_nullable()
-        nullable = Set.new
+        nullables = Set.new
         # Direct nullable nonterminals correspond to empty productions
         rules.each do |prod|
           next unless prod.empty?
           prod.lhs.nullable = true
-          nullable << prod.lhs
+          nullables << prod.lhs
         end
 
-        return nullable
+        return nullables
+      end
+      
+      
+      # For each prodction determine whether it is nullable or not.
+      # A nullable production is a production that can match an empty string.      
+      def mark_nullable
+        rules.each do |prod|
+          if prod.empty?
+            prod.nullable = true
+          else
+            # If all rhs members are all nullable, then rule is nullable
+            prod.nullable = prod.rhs.members.all?(&:nullable?)
+          end
+        end
       end
 
       def add_symbol(aSymbol)

data/lib/rley/syntax/production.rb

@@ -15,15 +15,19 @@ module Rley # This module is used as a namespace
 
       # @return [NonTerminal] The left-hand side of the rule.
       attr_reader(:lhs)
-      
-      # @return [String] 
+
+      # @return [String]
       #   The name of the production rule. It must be unique in a grammar.
       attr_accessor(:name)
-      
-      # @return [Boolean] A production is generative when all of its 
+
+      # @return [Boolean] A production is generative when all of its
       # rhs members are generative (that is, they can each generate/derive
       # a non-empty string of terminals).
-      attr_writer(:generative)      
+      attr_writer(:generative)
+
+      # @return [Boolean] A production is nullable when all of its
+      #   rhs members are nullable.
+      attr_writer(:nullable)
 
       # Provide common alternate names to lhs and rhs accessors
 
@@ -32,10 +36,10 @@ module Rley # This module is used as a namespace
 
       # Create a Production instance.
       # @param aNonTerminal [NonTerminal] The left-hand side of the rule.
-      # @param theSymbols [list<Terminal | NonTerminal>] symbols of rhs.      
+      # @param theSymbols [list<Terminal | NonTerminal>] symbols of rhs.
       def initialize(aNonTerminal, theSymbols)
         @lhs = valid_lhs(aNonTerminal)
-        @rhs = valid_rhs(theSymbols)       
+        @rhs = valid_rhs(theSymbols)
       end
 
       # Is the rhs empty?
@@ -43,16 +47,21 @@ module Rley # This module is used as a namespace
       def empty?()
         return rhs.empty?
       end
-      
-      # Return true iff the production is generative      
+
+      # Return true iff the production is generative
       def generative?()
         if @generative.nil?
         end
-        
+
         return @generative
       end
 
-      # Returns a string containing a human-readable representation of the 
+      # @return [Boolen] true iff the production is nullable
+      def nullable?()
+        return @nullable
+      end
+
+      # Returns a string containing a human-readable representation of the
       # production.
       # @return [String]
       def inspect()
@@ -63,7 +72,7 @@ module Rley # This module is used as a namespace
         result << " @generative=#{@generative}>"
         return result
       end
-      
+
       # A setter for the production name
       # @param aName [String] the name of the production
       def as(aName)
@@ -83,14 +92,14 @@ module Rley # This module is used as a namespace
 
         return aNonTerminal
       end
-      
+
       def valid_rhs(theSymbols)
         if theSymbols.nil?
           msg_prefix = 'Right side of a production of the kind '
           msg_suffix = "'#{lhs.name}' => ... is nil."
-          raise StandardError, msg_prefix + msg_suffix    
-        end 
-      
+          raise StandardError, msg_prefix + msg_suffix
+        end
+
         return SymbolSeq.new(theSymbols)
       end
     end # class

data/spec/rley/parser/gfg_chart_spec.rb

@@ -47,38 +47,50 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:items_from_grammar) { build_items_for_grammar(grammar_abc) }
       let(:sample_gfg) { GFG::GrmFlowGraph.new(items_from_grammar) }
       let(:sample_start_symbol) { sample_gfg.start_vertex.non_terminal }
+      let(:second_vertex) { sample_gfg.start_vertex.edges[0].successor }
 
 
       # Default instantiation rule
-      subject { GFGChart.new(count_token, sample_gfg) }
+      subject { GFGChart.new(sample_gfg) }
 
 
       context 'Initialization:' do
         it 'should be created with start vertex, token count' do
-          expect { GFGChart.new(count_token, sample_gfg) }
-            .not_to raise_error
+          expect { GFGChart.new(sample_gfg) }.not_to raise_error
         end
 
-        it 'should have correct entry set count' do
-          expect(subject.sets.size).to eq(count_token + 1)
+        it 'should have one entry set' do
+          expect(subject.sets.size).to eq(1)
         end
 
         it 'should know the start symbol' do
           expect(subject.start_symbol).to eq(sample_start_symbol)
         end
-        
+
         it 'should know the initial parse entry' do
           expect(subject.initial_entry.vertex).to eq(sample_gfg.start_vertex)
           expect(subject.initial_entry.origin).to eq(0)
         end
-=begin
+      end # context
 
-        it 'should know the start dotted rule' do
-          expect(subject.start_dotted_rule).to eq(dotted_rule)
+      context 'Provided services:' do
+        it 'should accept the pushing of a parse entry in existing set' do
+          expect(subject.sets[0].entries.size).to eq(1)        
+          subject.push_entry(second_vertex, 0, 0, :scan_rule)
+          expect(subject.sets[0].entries.size).to eq(2)
+        end
+        
+        it 'should accept the pushing of a parse entry in new set' do
+          expect(subject.sets[0].entries.size).to eq(1)       
+          subject.push_entry(second_vertex, 0, 1, :scan_rule)
+          expect(subject.sets[0].entries.size).to eq(1)
+          expect(subject.sets.size).to eq(2)
+          expect(subject.sets[1].entries.size).to eq(1)
         end
 
-
-=end
+        it 'should retrieve an existing set at given position' do
+          expect(subject[0]).to eq(subject.sets[0])
+        end        
       end # context
     end # describe
   end # module

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -41,10 +41,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         builder.grammar
       end
 
-      let(:grm1_tokens) do
-        build_token_sequence(%w[a a b c c], grm1)
-      end
-
+      let(:grm1_tokens) { build_token_sequence(%w[a a b c c], grm1) }
       let(:grm1_token_b) { build_token_sequence(['b'], grm1) }
 
       # Helper method. Create an array of dotted items
@@ -55,18 +52,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:output) { StringIO.new('', 'w') }
 
       # Default instantiation rule
-      subject do
-        GFGParsing.new(sample_gfg, grm1_tokens)
-      end
+      subject { GFGParsing.new(sample_gfg) }
 
       context 'Initialization:' do
-        it 'should be created with a GFG, tokens' do
-          expect { GFGParsing.new(sample_gfg, grm1_tokens) }
-            .not_to raise_error
+        it 'should be created with a GFG' do
+          expect { GFGParsing.new(sample_gfg) }.not_to raise_error
         end
 
-        it 'should know the input tokens' do
-          expect(subject.tokens).to eq(grm1_tokens)
+        it 'should have an empty tokens array' do
+          expect(subject.tokens).to be_empty
         end
 
         it 'should know its chart object' do
@@ -107,11 +101,9 @@ SNIPPET
 
         # Utility method to initialize the second entry set...
         def seed_second_set()
-          # Cheating: we change surreptitiously the tokens to scan...
-          subject.instance_variable_set(:@tokens, grm1_token_b)
-
+          # Cheating: we change the tokens to scan...
           # Seeding second entry set...
-          subject.scan_rule(0)
+          subject.scan_rule(0, grm1_token_b[0])
         end
 
         # Utility method used to invoke the private method 'push_entry'
@@ -120,19 +112,19 @@ SNIPPET
         end
 
         it 'should push a parse entry to a given chart entry set' do
-          expect(subject.chart[1]).to be_empty
+          expect(subject.chart.sets[1]).to be_nil
           a_vertex = sample_gfg.find_vertex('A => a . A c')
 
-          push_entry(subject, a_vertex, 1, 1, :scanning)
+          push_entry(subject, a_vertex, 1, 1, :scan_rule)
           expect(subject.chart[1].size).to eq(1)
           expect(subject.chart[1].first.vertex).to eq(a_vertex)
 
           # Pushing twice the same state must be no-op
-          push_entry(subject, a_vertex, 1, 1, :scanning)
+          push_entry(subject, a_vertex, 1, 1, :scan_rule)
           expect(subject.chart[1].size).to eq(1)
 
           # Pushing to another entry set
-          push_entry(subject, a_vertex, 1, 2, :scanning)
+          push_entry(subject, a_vertex, 1, 2, :scan_rule)
           expect(subject.chart[2].size).to eq(1)
         end
 
@@ -191,8 +183,8 @@ SNIPPET
           # ['A => . a A c', 'A => . b']
           fourth_entry = subject.chart[0].entries[3] # 'A => . a A c'
 
-          expect(subject.chart[1]).to be_empty
-          subject.scan_rule(0)
+          expect(subject.chart.sets[1]).to be_nil
+          subject.scan_rule(0, grm1_tokens[0])
           # Given that the scanned token is 'a'...
           # Then a new entry is added in next entry set
           expect(subject.chart[1].size).to eq(1)
@@ -316,9 +308,15 @@ SNIPPET
           tokens = expr_tokenizer('2 + 3 * 4', b_expr_grammar)
           parser.parse(tokens)
         end
+        
+        it 'should indicate whether a parse succeeded' do
+          expect(subject.success?).to be_truthy
+        end
 
         it 'should build a parse forest' do
-          expect { subject.parse_forest }.not_to raise_error
+          if subject.success?
+            expect { subject.parse_forest }.not_to raise_error
+          end
         end
 =begin
         it 'should create the root of a parse forest' do

data/spec/rley/syntax/grammar_spec.rb

@@ -246,6 +246,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             expect(nterm).to be_nullable
           end
         end
+        
+        it 'should mark its nullable productions' do
+          # Given the above productions, here are our expectations:
+          expectations = [true, false, false, true]
+          actuals = subject.rules.map(&:nullable?)
+          expect(actuals).to eq(expectations)
+        end        
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.6.06
+  version: 0.6.07
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-12 00:00:00.000000000 Z
+date: 2018-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls