rley 0.7.06 → 0.8.01

data/spec/rley/support/grammar_pb_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 require_relative '../../../lib/support/base_tokenizer'
 require_relative '../../../lib/rley/lexical/token'
 
@@ -12,9 +12,9 @@ class GrammarPBHelper
   # expression based on example found in paper of
   # K. Pingali and G. Bilardi:
   # "A Graphical Model for Context-Free Grammar Parsing"
-  def grammar()
+  def grammar
     @grammar ||= begin
-      builder = Rley::Syntax::GrammarBuilder.new do
+      builder = Rley::Syntax::BaseGrammarBuilder.new do
         add_terminals('int', '+', '(', ')')
         rule 'S' => 'E'
         rule 'E' => 'int'
@@ -24,12 +24,13 @@ class GrammarPBHelper
       builder.grammar
     end
   end
-  
+
   class PB_Tokenizer < BaseTokenizer
     protected
 
-    def recognize_token()
-      if (lexeme = scanner.scan(/[\(\)]/)) # Single characters
+    # rubocop: disable Lint/DuplicateBranch
+    def recognize_token
+      if (lexeme = scanner.scan(/[()]/)) # Single characters
         # Delimiters, separators => single character token
         build_token(lexeme, lexeme)
       elsif (lexeme = scanner.scan(/(?:\+)(?=\s|$)/)) # Isolated char
@@ -38,6 +39,7 @@ class GrammarPBHelper
         build_token('int', lexeme)
       end
     end
+    # rubocop: enable Lint/DuplicateBranch
   end # class
 
   # Basic tokenizer
@@ -46,6 +48,5 @@ class GrammarPBHelper
     tokenizer = PB_Tokenizer.new(aText)
     tokenizer.tokens
   end
-  
 end # class
 # End of file

data/spec/rley/support/grammar_sppf_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 
 
 module GrammarSPPFHelper
@@ -10,8 +10,8 @@ module GrammarSPPFHelper
   # "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
-  def grammar_sppf_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_sppf_builder
+    builder = Rley::Syntax::BaseGrammarBuilder.new do
       add_terminals('a', 'b')
       rule 'Phi' => 'S'
       rule 'S' => %w[A T]

data/spec/rley/syntax/{grammar_builder_spec.rb → base_grammar_builder_spec.rb}

@@ -3,14 +3,14 @@
 require_relative '../../spec_helper'
 
 # Load the class under test
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
-    describe GrammarBuilder do
+    describe BaseGrammarBuilder do
       context 'Initialization without argument:' do
         it 'could be created without argument' do
-          expect { GrammarBuilder.new }.not_to raise_error
+          expect { BaseGrammarBuilder.new }.not_to raise_error
         end
 
         it 'should have no grammar symbols at start' do
@@ -24,13 +24,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization with argument:' do
         it 'could be created with a block argument' do
-          expect do 
-            GrammarBuilder.new { nil }
+          expect do
+            BaseGrammarBuilder.new { nil }
           end.not_to raise_error
         end
 
         it 'could have grammar symbols from block argument' do
-          instance = GrammarBuilder.new do
+          instance = BaseGrammarBuilder.new do
             add_terminals('a', 'b', 'c')
           end
           expect(instance.symbols.size).to eq(3)
@@ -80,7 +80,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Adding productions:' do
         subject do
-          instance = GrammarBuilder.new
+          instance = BaseGrammarBuilder.new
           instance.add_terminals('a', 'b', 'c')
           instance
         end
@@ -99,27 +99,46 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(new_prod.lhs).to eq(subject['A'])
           expect_rhs = [subject['a'], subject['A'], subject['c']]
           expect(new_prod.rhs.members).to eq(expect_rhs)
-          
+
           # Try another syntax
           subject.add_production('A' => 'a A c')
           expect(subject.productions.size).to eq(3)
           new_prod = subject.productions.last
           expect(new_prod.lhs).to eq(subject['A'])
           expect_rhs = [subject['a'], subject['A'], subject['c']]
-          expect(new_prod.rhs.members).to eq(expect_rhs)          
+          expect(new_prod.rhs.members).to eq(expect_rhs)
 
-          # GrammarBuilder#rule is an alias of add_production
+          # BaseGrammarBuilder#rule is an alias of add_production
           subject.rule('A' => ['b'])
           expect(subject.productions.size).to eq(4)
           new_prod = subject.productions.last
           expect(new_prod.lhs).to eq(subject['A'])
           expect(new_prod.rhs[0]).to eq(subject['b'])
         end
+
+        it "should support Kleene's plus" do
+          instance = BaseGrammarBuilder.new
+          instance.add_terminals('plus', 'minus', 'digit')
+
+          instance.add_production('integer' => 'value')
+          instance.add_production('integer' => 'sign value')
+          instance.add_production('sign' => 'plus')
+          instance.add_production('sign' => 'minus')
+          expect(instance.productions.size).to eq(4)
+          instance.add_production('value' => 'digit+')
+          expect(instance.productions.size).to eq(7) # Two additional rules generated
+          prod_plus = instance.productions.select { |prod| prod.lhs.name == 'digit_plus' }
+          expect(prod_plus.size).to eq(2)
+          last_prod = instance.productions.last
+          expect(last_prod.lhs.name).to eq('value')
+          expect(last_prod.rhs.members[0].name).to eq('digit_plus')
+        end
+
       end # context
 
       context 'Building grammar:' do
         subject do
-          instance = GrammarBuilder.new do
+          instance = BaseGrammarBuilder.new do
             add_terminals('a', 'b', 'c')
             add_production('S' => ['A'])
             add_production('A' => %w[a A c])
@@ -141,14 +160,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should complain in absence of symbols' do
-          instance = GrammarBuilder.new
+          instance = BaseGrammarBuilder.new
           err = StandardError
           msg = 'No symbol found for grammar'
           expect { instance.grammar }.to raise_error(err, msg)
         end
 
         it 'should complain in absence of productions' do
-          instance = GrammarBuilder.new
+          instance = BaseGrammarBuilder.new
           instance.add_terminals('a', 'b', 'c')
           err = StandardError
           msg = 'No production found for grammar'
@@ -162,11 +181,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           err = StandardError
           msg = 'Useless terminal symbol(s): d.'
           expect { subject.grammar }.to raise_error(err, msg)
-          
+
           # Add another useless terminal
           subject.add_terminals('e')
           msg = 'Useless terminal symbol(s): d, e.'
-          expect { subject.grammar }.to raise_error(err, msg)          
+          expect { subject.grammar }.to raise_error(err, msg)
         end
 
         it 'should build a grammar with nullable nonterminals' do
@@ -183,7 +202,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           t_star = VerbatimSymbol.new('*')
           t_slash = VerbatimSymbol.new('/')
 
-          builder = GrammarBuilder.new
+          builder = BaseGrammarBuilder.new
           builder.add_terminals(t_a, t_star, t_slash)
           builder.add_production('S' => 'E')
           builder.add_production('E' => %w[E Q F])

data/spec/rley/syntax/grammar_spec.rb

@@ -74,7 +74,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:nt_A) { NonTerminal.new('A') }
       let(:nt_B) { NonTerminal.new('B') }
       let(:nt_C) { NonTerminal.new('C') }
-      let(:nt_D) { NonTerminal.new('D') }      
+      let(:nt_D) { NonTerminal.new('D') }
       let(:a_) { VerbatimSymbol.new('a') }
       let(:b_)  { VerbatimSymbol.new('b') }
       let(:c_)  { VerbatimSymbol.new('c') }
@@ -161,7 +161,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.name2symbol['b']).to eq(b_)
           expect(subject.name2symbol['c']).to eq(c_)
         end
-        
+
         it 'should ensure that each production has a name' do
           subject.rules.each do |prod|
             expect(prod.name).to match(Regexp.new("#{prod.lhs.name}_\\d$"))
@@ -218,8 +218,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           partitioning = instance.non_terminals.partition(&:generative?)
           expect(partitioning[0].size).to eq(2)
           expect(partitioning[0]).to eq([nt_S, nt_A])
-          expect(partitioning[1]).to eq([nt_B, nt_C, nt_D]) 
-          
+          expect(partitioning[1]).to eq([nt_B, nt_C, nt_D])
+
           undefined = instance.non_terminals.select(&:undefined?)
           expect(undefined).to be_empty
         end
@@ -248,13 +248,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
       end # context
     end # describe
   end # module

data/spec/rley/syntax/grm_symbol_spec.rb

@@ -20,7 +20,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.name).to eq(sample_name)
         end
       end # context
-      
+
       context 'Provided services:' do
         it 'should give its text representation' do
           expect(subject.to_s).to eq(sample_name)

data/spec/rley/syntax/match_closest_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/symbol_seq'
+
+# Load the class under test
+require_relative '../../../lib/rley/syntax/production'
+
+# Load the class under test
+require_relative '../../../lib/rley/syntax/match_closest'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Syntax # Open this namespace to avoid module qualifier prefixes
+    describe MatchClosest do
+      # 'stmt' => 'IF boolean THEN stmt ELSE stmt'
+      let(:boolean) { NonTerminal.new('boolean') }      
+      let(:stmt) { NonTerminal.new('stmt') }
+      let(:if_t) { Terminal.new('IF') }
+      let(:then_t) { Terminal.new('THEN') }
+      let(:else_t) { Terminal.new('ELSE') }      
+      let(:sequence) { [if_t, boolean, then_t, stmt, else_t, stmt] }
+      let(:prod) { Production.new(stmt, sequence) }
+
+      subject{ MatchClosest.new(prod.rhs.members, 4, 'IF') }
+
+      context 'Initialization:' do
+        it 'should be created with an symbol seq., an indice and a name' do
+          expect { MatchClosest.new(prod.rhs.members, 4, 'IF')  }.not_to raise_error
+        end
+
+        it 'should know the index argument' do
+          expect(subject.idx_symbol).to eq(4) # ELSE at position 4
+        end
+
+        it 'should know the name of preceding symbol to pair with' do
+          expect(subject.closest_symb).to eq('IF')
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/syntax/non_terminal_spec.rb

@@ -19,28 +19,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its name' do
           expect(subject.name).to eq(sample_name)
         end
-        
+
         it 'should know that is a not a terminal' do
           expect(subject).not_to be_terminal
         end
       end # context
 
-        
-      context 'Provided services:' do    
+
+      context 'Provided services:' do
         it 'should know whether it is nullable' do
           expect(subject.nullable?).to be_nil
           subject.nullable = true
           expect(subject).to be_nullable
           subject.nullable = false
-          expect(subject).not_to be_nullable          
+          expect(subject).not_to be_nullable
         end
-        
+
         it 'should know whether it is defined' do
           expect(subject.undefined?).to be_nil
           subject.undefined = true
           expect(subject).to be_undefined
           subject.undefined = false
-          expect(subject).not_to be_undefined          
+          expect(subject).not_to be_undefined
         end
 
         it 'should know whether it is generative' do
@@ -48,8 +48,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.generative = true
           expect(subject).to be_generative
           subject.generative = false
-          expect(subject).not_to be_generative          
-        end        
+          expect(subject).not_to be_generative
+        end
       end # context
     end # describe
   end # module

data/spec/rley/syntax/production_spec.rb

@@ -24,11 +24,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should be created with a non-terminal and a symbol sequence' do
           expect { Production.new(sentence, sequence) }.not_to raise_error
         end
-        
+
         it 'should complain when its rhs is nil' do
           err = StandardError
           msg_prefix = 'Right side of a production of the kind '
-          msg_suffix = "'Sentence' => ... is nil." 
+          msg_suffix = "'Sentence' => ... is nil."
           msg = msg_prefix + msg_suffix
           expect { Production.new(sentence, nil) }.to raise_error(err, msg)
         end
@@ -43,48 +43,52 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.body).to eq(sequence)
         end
 
+        it 'should be free from constraints at start' do
+          expect(subject.constraints).to be_empty
+        end
+
         it 'should know whether its rhs is empty' do
           expect(subject).not_to be_empty
 
           instance = Production.new(sentence, [])
           expect(instance).to be_empty
         end
-        
+
         it 'should be anonymous at creation' do
           expect(subject.name).to be_nil
         end
-        
+
         it 'should complain if its lhs is not a non-terminal' do
           err = StandardError
           msg_prefix = 'Left side of production must be a non-terminal symbol'
-          msg_suffix = ", found a #{String} instead."  
+          msg_suffix = ", found a #{String} instead."
           msg = msg_prefix + msg_suffix
           expect { Production.new('wrong', sequence) }.to raise_error(err, msg)
         end
       end # context
-      
+
       context 'Provided services:' do
         it 'should accept a name (i)' do
           a_name = 'nominem'
           subject.name = a_name
           expect(subject.name).to eq(a_name)
         end
-        
+
         it 'should accept a name (ii)' do
           a_name = 'nominem'
           subject.as(a_name)
-          expect(subject.name).to eq(a_name)          
+          expect(subject.name).to eq(a_name)
         end
-        
+
         it 'should provide human-readable representation of itself' do
           subject.name = 'some name'
           prefix = /^#<Rley::Syntax::Production:\d+ @name="some name"/
           expect(subject.inspect).to match(prefix)
-          pattern = /@lhs=Sentence @rhs=#<Rley::Syntax::SymbolSeq/          
+          pattern = /@lhs=Sentence @rhs=#<Rley::Syntax::SymbolSeq/
           expect(subject.inspect).to match(pattern)
-          suffix = /> @generative=>$/          
-          expect(subject.inspect).to match(suffix)          
-        end        
+          suffix = /> @generative=>$/
+          expect(subject.inspect).to match(suffix)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/syntax/symbol_seq_spec.rb

@@ -57,13 +57,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           unequal_one = SymbolSeq.new([verb, pp, np])
           expect(subject == unequal_one).not_to eq(true)
         end
-        
+
         it 'should complain when unable to compare' do
           err = StandardError
           msg = 'Cannot compare a SymbolSeq with a String'
           expect { subject == 'dummy-text' }.to raise_error(err, msg)
         end
-        
+
         it 'should provide human-readable representation of itself' do
           suffix = /::SymbolSeq:\d+ @members=\["Verb", "NP", "PP"\]>$/
           expect(subject.inspect).to match(suffix)