rley 0.7.04 → 0.7.05

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa143547cbc9df1103e8d5fa196a77fb1dde67edc118f450ba34e2d7338be18
-  data.tar.gz: 3a21aa20217d4bf09b9816229b5d5a75a804a8f41c0bb14fc8572f5119f1140b
+  metadata.gz: 6bac50f391e9fa77fd20e283cea1d15ec7729ba7663f022e0b7c2eaf3dfa4d2d
+  data.tar.gz: e85f49f87c86c2397a4ebf05b53b9fe4d7fc55ea77829892575c588424f2c789
 SHA512:
-  metadata.gz: 2bd17209dd119cf971f3ccf9f8cafb319955add4714f54d6d3a2baa542fc5a528942d71276ab9110081d1eed6d48d39bfec0f435ef55c47eb0d12dd1aa5b2801
-  data.tar.gz: 500b641afa30d01ba6f28ef8fe23d9f157db67985f66fc95a6a07bdff099946a2faeffb09bdd2651a7871edfa756799c9e5768bb3010a8528d8f4a758f5933e3
+  metadata.gz: 0443dcd4ee4c92def8f3ec0d81418f62344ae66d4839b6449e336953cbb34c31209b09389036f7c0a64ae53b04f01e132f0eef44ec16069446c86b82056996af
+  data.tar.gz: 7e078d135b134924794118386e25fed879e2d85862160e06708b711db15d01560b4ab2562489630125ee395324e5430b3b8354652c139238cc240ff8218bc780

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.7.05 / 2019-11-117
+- [FIX] Method `GFGParsing#nullable_rule`: issue with nullable productions having at least one member in their rhs.
+
 ### 0.7.04 / 2019-08-17
 - Rley recognizer is about 25% faster than previous version. Kudos to the people 
 behind the *magic_frozen_string_literal* gem. 

data/appveyor.yml

@@ -11,10 +11,6 @@ environment:
   - Ruby_version: 24
   - Ruby_version: 23
 
-# These are failing
-#  
-#  
-
 install:
   - set PATH=C:\Ruby%Ruby_version%\bin;%PATH%
   - gem update --system

data/lib/rley/constants.rb

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

data/lib/rley/lexical/token.rb

@@ -25,7 +25,7 @@ module Rley # This module is used as a namespace
       # @return [String] Input substring that is an instance of the terminal.
       attr_reader(:lexeme)
 
-      # @return [Syntax::Terminal] Terminal symbol corresponding to the lexeme.
+      # @return [String] The name of terminal symbol matching the lexeme.
       attr_reader(:terminal)
 
       # @return [Position] The position of the lexeme in the source file.

data/lib/rley/parse_rep/cst_builder.rb

@@ -42,7 +42,9 @@ module Rley # This module is used as a namespace
       # @param theChildren [Array] Children nodes (one per rhs symbol)
       def new_parent_node(aProduction, aRange, _tokens, theChildren)
         node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
-        theChildren.reverse_each { |child| node.add_subnode(child) }
+        if theChildren
+          theChildren.reverse_each { |child| node.add_subnode(child) }
+        end
         return node
       end
     end # class

data/lib/rley/parse_rep/parse_forest_builder.rb

@@ -89,6 +89,7 @@ module Rley # This module is used as a namespace
           when :backtrack
             # Restore path
             @curr_path = entry2path_to_alt[anEntry].dup
+            raise StandardError, "path is nil for #{anEntry}" if curr_path.nil?
 
           when :revisit
             # Retrieve the already existing node corresponding
@@ -151,6 +152,7 @@ module Rley # This module is used as a namespace
           when :backtrack
             # Restore path
             @curr_path = entry2path_to_alt[anEntry].dup
+            raise StandardError, 'path is nil' if curr_path.nil?
             create_alternative_node(anEntry)
 
           when :revisit

data/lib/rley/parse_rep/parse_rep_creator.rb

@@ -32,6 +32,11 @@ module Rley # This module is used as a namespace
           end
         rescue StopIteration
           # Do nothing: gobble the exception
+        rescue StandardError => exc
+          if exc.message =~ /^Ambiguous/
+            $stderr.puts parsing
+          end
+          raise exc
         end
         
         a_builder.done!

data/lib/rley/parser/gfg_chart.rb

@@ -57,8 +57,8 @@ module Rley # This module is used as a namespace
         if anIndex == sets.size
           err_msg = "Internal error: unexpected push reason #{reason}"
           raise StandardError, err_msg if reason != :scan_rule
-          
-          add_entry_set 
+
+          add_entry_set
         end
         pushed = self[anIndex].push_entry(new_entry)
 
@@ -93,7 +93,39 @@ module Rley # This module is used as a namespace
           entry.origin.zero? && entry.vertex.non_terminal == start_symbol
         end
 
-        return success_entries.first
+        success_entries.first
+      end
+      
+      # @return [Integer] The number of states.
+      def count_states
+        sets.size
+      end
+
+      # @return [Integer] The total number of entries.
+      def count_entries
+        sets.reduce(0) do |sub_result, a_set|
+          sub_result += a_set.size
+        end
+      end
+
+      # @return [Integer] The total number of edges.
+      def count_edges
+        sets.reduce(0) do |sub_result, a_set|
+          sub_result += a_set.count_edges
+        end
+      end
+
+      # @ return [String] A human-readable representation of the chart.
+      def to_s
+        result = +''
+        sets.each_with_index do |a_set, i|
+          result << "State[#{i}]\n"
+          a_set.entries.each do |item|
+            result << '  ' + item.to_s + "\n"
+          end
+        end
+        
+        result
       end
 
       private

data/lib/rley/parser/gfg_parsing.rb

@@ -15,7 +15,7 @@ module Rley # This module is used as a namespace
       attr_reader(:gf_graph)
 
       # The link to the chart object
-      # @return [GFGChart]
+      # @return [Parser::GFGChart]
       attr_reader(:chart)
 
       # The sequence of input token to parse
@@ -74,6 +74,11 @@ module Rley # This module is used as a namespace
       # [B., i]
       # [A => alpha B . beta, k]
       def nullable_rule(anEntry, aPosition)
+        # Terminology:
+        # .B : start node
+        # B => . rhs : entry node
+        # B => rhs . : exit node
+        # B. : end node
         next_symbol = anEntry.next_symbol
         pos = aPosition
         start = gf_graph.start_vertex_for[next_symbol]
@@ -85,6 +90,7 @@ module Rley # This module is used as a namespace
           succ = edge.successor # succ always an ItemVertex
           if succ.dotted_item.production.nullable?
             succ_entry = apply_rule(start_entry, succ, pos, pos, :nullable_rule)
+            next unless succ_entry.exit_entry?
             apply_rule(succ_entry, end_vertex, pos, pos, :nullable_rule)
           end
         end
@@ -179,7 +185,7 @@ module Rley # This module is used as a namespace
       # followed the syntax specified by the grammar)
       def success?()
         return false if @failure_reason
-        
+
         return chart.accepting_entry ? true : false
       end
 
@@ -239,6 +245,27 @@ END_MSG
         end
       end
 
+      def count_states
+        chart.count_states
+      end
+
+      def count_entries
+        chart.count_entries
+      end
+
+      def count_edges
+        chart.count_edges
+      end
+
+      # @return [String] A human readable representation of itself.
+      def to_s()
+        result = +''
+        result << "success? #{success?}\n"
+        result << "chart:\n"
+        result << chart.to_s
+
+        result
+      end
 
       private
 
@@ -273,7 +300,7 @@ END_MSG
 =begin
         # Invariant checks
         antecedents = antecedence[consequent]
-        
+
         case aVertex
           when Rley::GFG::EndVertex
             # Rule: has 1..* antecedents, all of them are exit items

data/lib/rley/parser/parse_entry.rb

@@ -44,6 +44,7 @@ module Rley # This module is used as a namespace
       end
 
       # Add a link to an antecedent parse entry
+      # @param anAntecedent[ParseEntry]
       def add_antecedent(anAntecedent)
         antecedents << anAntecedent unless antecedents.include?(anAntecedent)
       end

data/lib/rley/parser/parse_entry_set.rb

@@ -98,6 +98,12 @@ module Rley # This module is used as a namespace
       def expected_terminals()
         return @entries4term.keys
       end
+      
+      def count_edges
+        entries.reduce(0) do |sub_result, entry|
+          sub_result += entry.vertex.edges.size
+        end
+      end
 
       private
 

data/lib/rley/parser/parse_walker_factory.rb

@@ -176,7 +176,7 @@ module Rley # This module is used as a namespace
                     select_antecedent(aContext)
                   end
 
-        return entries
+        entries
       end
 
       # Handle the case of an entry having one antecedent only
@@ -213,6 +213,7 @@ module Rley # This module is used as a namespace
         case aContext.curr_entry.vertex
           when GFG::EndVertex
             # puts "Add backtrack point stack #{aContext.curr_entry}"
+            # aContext.curr_entry.antecedents.each { |antec| puts "\t#{antec}" }
             bp = add_backtrack_point(aContext)
             new_entry = bp.visitee.antecedents[bp.antecedent_index]
 

data/spec/rley/engine_spec.rb

@@ -101,6 +101,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         sample_text = 'a a b c c'
         ABCTokenizer.new(sample_text)
       end
+      
+      it 'should build a parse tree even for a nullable production' do
+        instance = Engine.new
+        instance.build_grammar do
+          add_terminals('a', 'b', 'c')
+          add_production 'S' => 'A BC'
+          add_production 'A' => 'a'
+          add_production 'BC' => 'B_opt C_opt'
+          add_production 'B_opt' => 'b'
+          add_production 'B_opt' => []
+          add_production 'C_opt' => 'c'
+          add_production 'C_opt' => []            
+        end
+        input = ABCTokenizer.new('a')
+        raw_result = instance.parse(input)
+        expect { instance.to_ptree(raw_result) }.not_to raise_error
+      end      
 
       it 'should build default parse trees' do
         raw_result = subject.parse(sample_tokenizer)
@@ -136,6 +153,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         ABCTokenizer.new(sample_text)
       end
       
+      it 'should build a parse forest even for a nullable production' do
+        instance = Engine.new
+        instance.build_grammar do
+          add_terminals('a', 'b', 'c')
+          add_production 'S' => 'A BC'
+          add_production 'A' => 'a'
+          add_production 'BC' => 'B_opt C_opt'
+          add_production 'B_opt' => 'b'
+          add_production 'B_opt' => []
+          add_production 'C_opt' => 'c'
+          add_production 'C_opt' => []            
+        end
+        input = ABCTokenizer.new('a')
+        raw_result = instance.parse(input)
+        expect { instance.to_pforest(raw_result) }.not_to raise_error
+      end       
+      
       it 'should build parse forest' do
         raw_result = subject.parse(sample_tokenizer)
         pforest = subject.to_pforest(raw_result)

data/spec/rley/parser/gfg_chart_spec.rb

@@ -77,13 +77,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       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)        
+          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)       
+          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)
@@ -92,7 +92,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should retrieve an existing set at given position' do
           expect(subject[0]).to eq(subject.sets[0])
-        end        
+        end
+
+        it 'should a user-friendly text representation of itself' do
+          subject.push_entry(second_vertex, 0, 1, :scan_rule)
+          representation = <<REPR
+State[0]
+  .S | 0
+State[1]
+  S => . A | 0
+REPR
+          expect(subject.to_s).to eq(representation)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -286,10 +286,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # A => ;
           t_x = Syntax::VerbatimSymbol.new('x')
 
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals(t_x)
-          builder.add_production('Ss' => %w[A A x])
-          builder.add_production('A' => [])
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals(t_x)
+            rule 'Ss' => 'A A x'
+            rule 'A' => []
+          end
           pos = Lexical::Position.new(1, 1)
           tokens = [Lexical::Token.new('x', t_x, pos)]
 

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -27,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include GrammarABCHelper # Mix-in module with builder for grammar abc
       include GrammarBExprHelper # Mix-in with builder for simple expressions
       include GrammarHelper # Mix-in with method for creating token sequence
-      
+
       # Helper method. Create an array of dotted items
       # from the given grammar
       def build_items_for_grammar(aGrammar)
@@ -166,7 +166,7 @@ SNIPPET
           expect(subject.chart[0].size).to eq(3)
           # Last entry is: (.A, 0)
           dot_A_entry = subject.chart[0].last
-          
+
           subject.start_rule(dot_A_entry, 0)
 
           # Expectations: two entries:
@@ -196,7 +196,7 @@ SNIPPET
           expect(last_entry.vertex.label).to eq('A => a . A c')
           expect(last_entry.origin).to eq(0)
           antecedence = subject.antecedence
-          expect(antecedence.fetch(last_entry)).to eq([fourth_entry])          
+          expect(antecedence.fetch(last_entry)).to eq([fourth_entry])
         end
 
         it 'should apply the exit rule correctly' do
@@ -221,7 +221,7 @@ SNIPPET
           exit_entry = subject.chart[1].last
           expect(exit_entry.vertex.label).to eq('A.')
           expect(exit_entry.origin).to eq(0)
-          expect(subject.antecedence.fetch(exit_entry)).to eq([last_entry]) 
+          expect(subject.antecedence.fetch(exit_entry)).to eq([last_entry])
         end
 
         it 'should apply the end rule correctly' do
@@ -250,6 +250,7 @@ SNIPPET
           expect(end_entry.origin).to eq(0)
           expect(subject.antecedence.fetch(end_entry)).to eq([exit_entry])
         end
+
 =begin
 
 
@@ -284,18 +285,7 @@ SNIPPET
 =end
       end # context
 
-      context 'Parse forest building:' do
-        let(:sample_grammar1) do
-          builder = grammar_abc_builder
-          builder.grammar
-        end
-
-        let(:token_seq1) do
-          %w[a a b c c].map do |letter|
-            Lexical::Token.new(letter, sample_grammar1.name2symbol[letter])
-          end
-        end
-
+      context 'Provided services:' do
         let(:b_expr_grammar) do
           builder = grammar_expr_builder
           builder.grammar
@@ -310,247 +300,51 @@ SNIPPET
           tokens = expr_tokenizer('2 + 3 * 4')
           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?
-        end
-=begin
-        it 'should create the root of a parse forest' do
-          (entry_tracker, builder) = prepare_parse_forest(subject)
-          # The root node should correspond to the start symbol and
-          # its direct children should correspond to rhs of start production
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-
-          expect(entry_tracker.entry_set_index).to eq(subject.tokens.size)
-          expected_entry = 'P => S . | 0'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(builder.current_node.to_string(0)).to eq('S[0, 5]')
-        end
-=end
-=begin
-        it 'should use a reduce item for a matched non-terminal' do
-          # Setup
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          # Same entry as in previous example
-
-          # Given matched symbol is S[0, 5]
-          # And its reduce item is S => S + M . | 0
-          # Then add child nodes corresponding to the rhs symbols
-          # And make M[?, 5] the current symbol
-          subject.insert_matched_symbol(entry_tracker, builder)
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[?, 5]
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'S => S + M . | 0'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(5)
-          expect(builder.current_node.to_string(0)).to eq('M[?, 5]')
-
-          # Second similar test
-
-          # Given matched symbol is M[?, 5]
-          # And its reduce item is M => M * T . | 2
-          # Then add child nodes corresponding to the rhs symbols
-          # And make T[?, 5] the current symbol
-          subject.insert_matched_symbol(entry_tracker, builder)
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[?, 5]
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'M => M * T . | 2'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(5)
-          expect(builder.current_node.to_string(0)).to eq('T[?, 5]')
+        it 'should give a text representation of itself' do
+          repr = subject.to_s
+          expect(repr).to match /^success\? true/
+          
+          # Let's test the last chart state only          
+          expectation = <<REPR
+State[5]
+  T => integer . | 4
+  T. | 4
+  M => M * T . | 2
+  M. | 2
+  S => S + M . | 0
+  M => M . * T | 2
+  S. | 0
+  P => S . | 0
+  S => S . + M | 0
+  P. | 0
+REPR
         end
+      end # context
 
-
-
-        it 'should use a previous item for a terminal symbol' do
-          # Setup
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          3.times do
-            subject.insert_matched_symbol(entry_tracker, builder)
-          end
-
-          # Given matched symbol is T[?, 5]
-          # And its reduce item is T => integer . | 4
-          # Then add child node corresponding to the rhs symbol
-          # And make integer[4, 5]: '(nil)' the current symbol
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[4, 5]
-         +- integer[4, 5]: '(nil)'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'T => integer . | 4'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(5)
-          integer_repr = "integer[4, 5]: '(nil)'"
-          expect(builder.current_node.to_string(0)).to eq(integer_repr)
-
-          # Given current tree symbol is integer[4, 5]: '(nil)'
-          # And its previous item is T => . integer | 4
-          # Then attach the token to the terminal node
-          # And decrement the entry index by one
-          # Make *[?, ?]: '(nil)' the current symbol
-          subject.insert_matched_symbol(entry_tracker, builder)
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'T => . integer | 4'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(4)
-          next_symbol = "*[?, ?]: '(nil)'"
-          expect(builder.current_node.to_string(0)).to eq(next_symbol)
+      context 'Parse forest building:' do
+        let(:b_expr_grammar) do
+          builder = grammar_expr_builder
+          builder.grammar
         end
 
-        it 'should handle [no symbol before dot, terminal tree node] case' do
-          # Setup
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          4.times do
-            subject.insert_matched_symbol(entry_tracker, builder)
-          end
-
-          # Given current tree symbol is *[?, ?]: '(nil)'
-          # And current dotted item is T => . integer | 4
-          # When one retrieves the parse entry expecting the T
-          # Then new parse entry is changed to: M => M * . T | 2
-          subject.insert_matched_symbol(entry_tracker, builder)
-
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'M => M * . T | 2'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(4)
-          next_symbol = "*[?, ?]: '(nil)'"
-          expect(builder.current_node.to_string(0)).to eq(next_symbol)
-
-          subject.insert_matched_symbol(entry_tracker, builder)
-          next_symbol = 'M[2, ?]'
-          expect(builder.current_node.to_string(0)).to eq(next_symbol)
+        def grm_symbol(aSymbolName)
+          b_expr_grammar.name2symbol[aSymbolName]
         end
 
-        it 'should handle the end of parse tree generation' do
-          # Begin setup
-          is_done = false
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          16.times do
-            is_done = subject.insert_matched_symbol(entry_tracker, builder)
-          end
-
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, 1]
-      +- M[0, 1]
-         +- T[0, 1]
-            +- integer[0, 1]: '2'
-   +- +[1, 2]: '+'
-   +- M[2, 5]
-      +- M[2, 3]
-         +- T[2, 3]
-            +- integer[2, 3]: '3'
-      +- *[3, 4]: '*'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-
-          expected_entry = 'T => . integer | 0'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(0)
-          expect(is_done).to eq(true)
+        subject do
+          parser = GFGEarleyParser.new(b_expr_grammar)
+          tokens = expr_tokenizer('3 * 4')
+          parser.parse(tokens)
         end
 
-
-
-        it 'should build the parse tree for a simple non-ambiguous grammar' do
-          parser = EarleyParser.new(sample_grammar1)
-          instance = parser.parse(token_seq1)
-          ptree = instance.parse_tree
-          expect(ptree).to be_kind_of(PTree::ParseTree)
+        it 'should indicate whether a parse succeeded' do
+          expect(subject.success?).to be_truthy
         end
 
-        it 'should build the parse tree for a simple expression grammar' do
-          parser = EarleyParser.new(b_expr_grammar)
-          tokens = expr_tokenizer('2 + 3 * 4', b_expr_grammar)
-          instance = parser.parse(tokens)
-          ptree = instance.parse_tree
-          expect(ptree).to be_kind_of(PTree::ParseTree)
-
-          # Expect parse tree:
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, 1]
-      +- M[0, 1]
-         +- T[0, 1]
-            +- integer[0, 1]: '2'
-   +- +[1, 2]: '+'
-   +- M[2, 5]
-      +- M[2, 3]
-         +- T[2, 3]
-            +- integer[2, 3]: '3'
-      +- *[3, 4]: '*'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          actual = ptree.root.to_string(0)
-          expect(actual).to eq(expected_text.chomp)
+        it 'should build a parse forest' do
+          expect { subject.parse_forest }.not_to raise_error if subject.success?
         end
-=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.7.04
+  version: 0.7.05
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-17 00:00:00.000000000 Z
+date: 2019-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls