rley 0.7.06 → 0.8.01

data/spec/rley/parser/error_reason_spec.rb

@@ -46,8 +46,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            ExpectationNotMet.new(3, err_token, terminals) 
+          expect do
+            ExpectationNotMet.new(3, err_token, terminals)
           end.not_to raise_error
         end
 
@@ -75,8 +75,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            UnexpectedToken.new(3, err_token, terminals) 
+          expect do
+            UnexpectedToken.new(3, err_token, terminals)
           end.not_to raise_error
         end
       end # context
@@ -107,8 +107,8 @@ MESSAGE_END
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            PrematureInputEnd.new(3, err_token, terminals) 
+          expect do
+            PrematureInputEnd.new(3, err_token, terminals)
           end.not_to raise_error
         end
       end # context

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -5,7 +5,7 @@ require 'stringio'
 require_relative '../../../lib/rley/syntax/verbatim_symbol'
 require_relative '../../../lib/rley/syntax/non_terminal'
 require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 require_relative '../../../lib/rley/lexical/token'
 require_relative '../../../lib/rley/base/dotted_item'
 require_relative '../../../lib/rley/parser/gfg_parsing'
@@ -13,6 +13,7 @@ require_relative '../../../lib/rley/parser/gfg_parsing'
 # Load builders and lexers for sample grammars
 require_relative '../support/grammar_abc_helper'
 require_relative '../support/ambiguous_grammar_helper'
+require_relative '../support/grammar_int_seq_helper'
 require_relative '../support/grammar_pb_helper'
 require_relative '../support/grammar_helper'
 require_relative '../support/expectation_helper'
@@ -71,7 +72,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by grammar_expr
-      def grm2_tokens()
+      def grm2_tokens
         input_sequence = [
           { '2' => 'integer' },
           '+',
@@ -79,7 +80,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           '*',
           { '4' => 'integer' }
         ]
-        return build_token_sequence(input_sequence, grammar_expr)
+        build_token_sequence(input_sequence, grammar_expr)
       end
 
       # Default instantiation rule
@@ -104,6 +105,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Parsing: ' do
+        # rubocop: disable Naming/VariableNumber
         it 'should parse a valid simple input' do
           parse_result = subject.parse(grm1_tokens)
           expect(parse_result.success?).to eq(true)
@@ -183,6 +185,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(entry_set_5.entries.size).to eq(4)
           compare_entry_texts(entry_set_5, expected)
         end
+        # rubocop: enable Naming/VariableNumber
 
         it 'should parse a valid simple expression' do
           instance = GFGEarleyParser.new(grammar_expr)
@@ -279,6 +282,91 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           compare_entry_texts(parse_result.chart[5], expected)
         end
 
+        it 'should support Kleene plus ' do
+          extend(GrammarIntSeqHelper)
+          grammar = grammar_int_seq_builder.grammar
+          instance = GFGEarleyParser.new(grammar)
+          tokens = int_seq_tokenizer('6, 36, 216')
+          parse_result = nil
+          expect { parse_result = instance.parse(tokens) }.not_to raise_error
+          expect(parse_result.success?).to eq(true)
+
+          ###################### S(0): . 6, 36, 216
+          # Expectation chart[0]:
+          expected = [
+            '.S | 0',                                   # Initialization
+            'S => . sequence | 0',                      # start rule
+            'S => . | 0',                               # start rule
+            '.sequence | 0',                            # call rule
+            'S. | 0',                                   # exit rule
+            'sequence => . sequence comma integer | 0', # start rule
+            'sequence => . integer | 0',                # start rule
+            '.integer | 0',                             # call rule
+            'integer => . digit_plus | 0' ,             # start rule
+            '.digit_plus | 0',                          # call rule
+            'digit_plus => . digit_plus digit | 0',     # start rule (generated)
+            'digit_plus => . digit | 0'                 # start rule (generated)
+          ]
+          compare_entry_texts(parse_result.chart[0], expected)
+
+          ###################### S(1): 6 ., 36, 216
+          # Expectation chart[1]:
+          expected = [
+            'digit_plus => digit . | 0',                # Scan
+            'digit_plus. | 0',                          # exit rule
+            'integer => digit_plus . | 0' ,             # end rule
+            'digit_plus => digit_plus . digit | 0',     # rule (generated)
+            'integer. | 0',                             # exit rule
+            'sequence => integer . | 0',                # end rule
+            'sequence. | 0',                            # exit rule
+            'S => sequence . | 0',                      # end rule
+            'sequence => sequence . comma integer | 0', #  rule
+            'S. | 0'                                    # exit rule
+          ]
+          compare_entry_texts(parse_result.chart[1], expected)
+
+          ###################### S(2): 6 , . 36, 216
+          # Expectation chart[2]:
+          expected = [
+            'sequence => sequence comma . integer | 0', #  Scan
+            '.integer | 2',                # call rule
+            'integer => . digit_plus | 2' ,             # start rule
+            '.digit_plus | 2',                          # call rule
+            'digit_plus => . digit_plus digit | 2',     # start rule (generated)
+            'digit_plus => . digit | 2'                 # start rule (generated)
+          ]
+          compare_entry_texts(parse_result.chart[2], expected)
+
+          ###################### S(3): 6 , 3 . 6. , 216
+          # Expectation chart[3]:
+          expected = [
+            'digit_plus => digit . | 2',                # Scan
+            'digit_plus. | 2',                          # exit rule
+            'integer => digit_plus . | 2' ,             # end rule
+            'digit_plus => digit_plus . digit | 2',     # rule (generated)
+            'integer. | 2',                             # exit rule
+            'sequence => sequence comma integer . | 0', # rule
+            'sequence. | 0',                             # exit rule
+            'S => sequence . | 0',                      # end rule
+            'sequence => sequence . comma integer | 0', #  rule
+          ]
+          compare_entry_texts(parse_result.chart[3], expected)
+
+          ###################### S(4): 6 , 36 . . , 216
+          # Expectation chart[4]:
+          expected = [
+            'digit_plus => digit_plus digit . | 2',     # Scan
+            'digit_plus. | 2',                          # exit rule
+            'integer => digit_plus . | 2' ,             # end rule
+            'digit_plus => digit_plus . digit | 2',     #
+            'integer. | 2',                             # exit rule
+            'sequence => sequence comma integer . | 0', # rule
+            'sequence. | 0',                            # exit rule
+            'S => sequence . | 0',                      # end rule
+          ]
+          compare_entry_texts(parse_result.chart[4], expected)
+        end
+
         it 'should parse a nullable grammar' do
           # Simple but problematic grammar for the original Earley parser
           # (based on example in D. Grune, C. Jacobs "Parsing Techniques" book)
@@ -286,7 +374,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # A => ;
           t_x = Syntax::VerbatimSymbol.new('x')
 
-          builder = Syntax::GrammarBuilder.new do
+          builder = Notation::GrammarBuilder.new do
             add_terminals(t_x)
             rule 'Ss' => 'A A x'
             rule 'A' => []
@@ -332,11 +420,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           t_plus = Syntax::VerbatimSymbol.new('+')
           t_star = Syntax::VerbatimSymbol.new('*')
 
-          builder = Syntax::GrammarBuilder.new do
+          builder = Syntax::BaseGrammarBuilder.new do
             add_terminals(t_int, t_plus, t_star)
             rule 'P' => 'S'
-            rule 'S' => %w[S + S]
-            rule 'S' => %w[S * S]
+            rule 'S' => 'S + S'
+            rule 'S' => 'S * S'
             rule 'S' => 'L'
             rule 'L' => 'integer'
           end
@@ -731,7 +819,7 @@ MSG
           t_star = Syntax::VerbatimSymbol.new('*')
           t_slash = Syntax::VerbatimSymbol.new('/')
 
-          builder = Syntax::GrammarBuilder.new do
+          builder = Syntax::BaseGrammarBuilder.new do
             add_terminals(t_a, t_star, t_slash)
             rule 'Z' => 'E'
             rule 'E' => %w[E Q F]
@@ -846,10 +934,11 @@ MSG
           # S => ;
           # This grammar requires a time that is quadratic in the number of
           # input tokens
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals('a')
-          builder.add_production('S' => %w[a S])
-          builder.add_production('S' => [])
+          builder = Notation::GrammarBuilder.new do
+            add_terminals('a')
+            rule('S' => 'a S')
+            rule('S' => '')
+          end
           grammar = builder.grammar
           tokens = build_token_sequence(%w[a a a a], grammar)
 
@@ -929,6 +1018,25 @@ MSG
           ]
           compare_entry_texts(parse_result.chart[4], expected)
         end
+
+        it 'should support modifier(s) in start rule' do
+          # An implicit EOF marker is a special terminal
+          # that denotes the end of input string but doesn't
+          # appear explicitly as some character or text in the input.
+          builder = Notation::GrammarBuilder.new do
+            add_terminals('a', 'b', 'EOF')
+
+            rule('S' => 'a_or_b* EOF')
+            rule('a_or_b' => 'a')
+            rule('a_or_b' => 'b')
+          end
+          grammar = builder.grammar
+          tokens = build_token_sequence(%w[EOF], grammar)
+          tokens[0].instance_variable_set(:@lexeme, '')
+          instance = GFGEarleyParser.new(grammar)
+          parse_result = instance.parse(tokens)
+          expect(parse_result.success?).to eq(true)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -6,7 +6,7 @@ require 'stringio'
 require_relative '../../../lib/rley/syntax/non_terminal'
 require_relative '../../../lib/rley/syntax/verbatim_symbol'
 require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 require_relative '../../../lib/rley/base/dotted_item'
 require_relative '../../../lib/rley/lexical/token'
 require_relative '../../../lib/rley/parser/parse_tracer'
@@ -95,14 +95,14 @@ SNIPPET
 
       context 'Parsing:' do
         # Utility method to fill the first entry set...
-        def fill_first_set()
+        def fill_first_set
           subject.start_rule(subject.initial_entry, 0)
           subject.call_rule(subject.chart[0].last, 0)
           subject.start_rule(subject.chart[0].last, 0)
         end
 
         # Utility method to initialize the second entry set...
-        def seed_second_set()
+        def seed_second_set
           # Cheating: we change the tokens to scan...
           # Seeding second entry set...
           subject.scan_rule(0, grm1_token_b[0])
@@ -252,9 +252,6 @@ SNIPPET
         end
 
 =begin
-
-
-
         it 'should retrieve the parse states that expect a given terminal' do
           item1 = DottedItem.new(prod_A1, 2)
           item2 = DottedItem.new(prod_A1, 1)
@@ -303,9 +300,9 @@ SNIPPET
 
         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          
+          expect(repr).to match(/^success\? true/)
+
+          # Let's test the last chart state only
           expectation = <<REPR
 State[5]
   T => integer . | 4
@@ -341,10 +338,6 @@ REPR
         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
       end # context
     end # describe
   end # module

data/spec/rley/parser/parse_entry_spec.rb

@@ -52,7 +52,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know the origin value' do
           expect(subject.origin).to eq(origin_val)
         end
-        
+
         it 'should have not antecedent at creation' do
           expect(subject.antecedents).to be_empty
           expect(subject).to be_orphan
@@ -91,13 +91,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance).to be_end_entry
         end
-        
+
         it 'should know if the entry is a dotted item vertex' do
           expect(subject).not_to be_dotted_entry
 
           instance = ParseEntry.new(GFG::ItemVertex.new('P => S.'), 3)
           expect(instance).to be_dotted_entry
-        end             
+        end
 
         it 'should know if the vertex is at end of production (if any)' do
           # Case: start vertex
@@ -120,7 +120,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance4 = ParseEntry.new(v2, 3)
           expect(instance4).to be_exit_entry
         end
-        
+
         it 'should know if the vertex is at begin of production (if any)' do
           # Case: start vertex
           instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
@@ -131,17 +131,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance2).not_to be_entry_entry
 
           # Case: item vertex not at begin of rhs
-          d1 = Base::DottedItem.new(sample_prod, 1)          
+          d1 = Base::DottedItem.new(sample_prod, 1)
           v1 = GFG::ItemVertex.new(d1)
           instance3 = ParseEntry.new(v1, 3)
           expect(instance3).not_to be_entry_entry
 
           # Case: item vertex at end of rhs
-          d2 = Base::DottedItem.new(sample_prod, 0)          
-          v2 = GFG::ItemVertex.new(d2)          
+          d2 = Base::DottedItem.new(sample_prod, 0)
+          v2 = GFG::ItemVertex.new(d2)
           instance4 = ParseEntry.new(v2, 3)
           expect(instance4).to be_entry_entry
-        end 
+        end
 
         it 'should know the symbol before the dot (if any)' do
           # Case: start vertex
@@ -151,20 +151,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Case: end vertex
           instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2.prev_symbol).to be_nil # Really correct?
-          
+
           # Case: item vertex not at start of rhs
           v1 = double('vertex-not-at-start')
           expect(v1).to receive(:prev_symbol).and_return('symbol')
           instance3 = ParseEntry.new(v1, 3)
-          expect(instance3.prev_symbol).to eq('symbol') 
+          expect(instance3.prev_symbol).to eq('symbol')
 
           # Case: item vertex at start of rhs
           v2 = double('vertex-at-start')
           expect(v2).to receive(:prev_symbol).and_return(nil)
           instance4 = ParseEntry.new(v2, 0)
-          expect(instance4.prev_symbol).to be_nil          
+          expect(instance4.prev_symbol).to be_nil
         end
-        
+
         it 'should know the next expected symbol (if any)' do
           # Case: start vertex
           instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
@@ -173,19 +173,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Case: end vertex
           instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2.next_symbol).to be_nil
-          
+
           # Case: item vertex not at end of rhs
           v1 = double('vertex-not-at-end')
           expect(v1).to receive(:next_symbol).and_return('symbol')
           instance3 = ParseEntry.new(v1, 3)
-          expect(instance3.next_symbol).to eq('symbol') 
+          expect(instance3.next_symbol).to eq('symbol')
 
           # Case: item vertex at end of rhs
           v2 = double('vertex-at-end')
           expect(v2).to receive(:next_symbol).and_return(nil)
           instance4 = ParseEntry.new(v2, 3)
-          expect(instance4.next_symbol).to be_nil          
-        end  
+          expect(instance4.next_symbol).to be_nil
+        end
 
         it 'should accept antecedents' do
           antecedent = ParseEntry.new(vertex2, origin_val)
@@ -198,7 +198,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = '.sentence | 3'
           expect(subject.to_s).to eq(expected)
         end
-        
+
         it 'should be inspectable' do
           subject.add_antecedent(subject) # Cheat for the good cause...
           # expected = '.sentence | 3'
@@ -209,8 +209,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           pattern2 = /@origin=3 @antecedents=\[/
           expect(subject.inspect).to match(pattern2)
           suffix = /<Rley::GFG::StartVertex:\d+ label=\.sentence> @origin=3\]>$/
-          expect(subject.inspect).to match(suffix)          
-        end        
+          expect(subject.inspect).to match(suffix)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -2,7 +2,7 @@
 
 require_relative '../../spec_helper'
 
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 require_relative '../support/grammar_helper'
 require_relative '../support/expectation_helper'
 
@@ -45,15 +45,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # "SPPF=Style Parsing From Earley Recognizers" in
           # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
           # contains a hidden left recursion and a cycle
-          builder = Syntax::GrammarBuilder.new do
+          builder = Syntax::BaseGrammarBuilder.new do
             add_terminals('a', 'b')
-            rule'Phi' => 'S'
-            rule'S' => %w[A T]
-            rule'S' => %w[a T]
-            rule'A' => 'a'
-            rule'A' => %w[B A]
-            rule'B' => []
-            rule'T' => %w[b b b]
+            rule 'Phi' => 'S'
+            rule 'S' => %w[A T]
+            rule 'S' => %w[a T]
+            rule 'A' => 'a'
+            rule 'A' => %w[B A]
+            rule 'B' => []
+            rule 'T' => %w[b b b]
           end
           builder.grammar
       end
@@ -303,7 +303,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event18 = walker.next
           expectations = [:revisit, 'T. | 1', 4]
           event_expectations(event18, expectations)
-          
+
           # Lazy walk: make start entry .T the current one
           # Multiple visit occurred: jump to antecedent of start entry
           event19 = walker.next