rley 0.7.06 → 0.8.01

data/spec/rley/gfg/end_vertex_spec.rb

@@ -23,12 +23,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end # context
 
-      context 'Provided services:' do       
+      context 'Provided services:' do
         it 'should provide human-readable representation of itself' do
-          pattern = /^#<Rley::GFG::EndVertex:\d+ label="NT\."/         
-          expect(subject.inspect).to match(pattern)       
-        end        
-      end # context      
+          pattern = /^#<Rley::GFG::EndVertex:\d+ label="NT\."/
+          expect(subject.inspect).to match(pattern)
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -112,7 +112,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should handle empty productions' do
-            builder = Rley::Syntax::GrammarBuilder.new
+            builder = Rley::Syntax::BaseGrammarBuilder.new
             builder.add_terminals('a')
             builder.add_production('S' => 'A')
             builder.add_production('A' => 'a')
@@ -162,7 +162,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         let(:problematic_grammar) do
           # Based on grammar example in book
           # C. Fisher, R. LeBlanc, "Crafting a Compiler"; page 98
-          builder = Rley::Syntax::GrammarBuilder.new
+          builder = Rley::Syntax::BaseGrammarBuilder.new
           builder.add_terminals('a', 'b', 'c')
           builder.add_production('S' => 'A')
           builder.add_production('S' => 'B')

data/spec/rley/gfg/item_vertex_spec.rb

@@ -73,10 +73,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Case: dot is after first symbol
           instance1 = ItemVertex.new(sample_item)
           expect(instance1.prev_symbol).to eq(t_a)
-          
+
           # Case: dot is after second or later symbol
           instance2 = ItemVertex.new(next_item)
-          expect(instance2.prev_symbol).to eq(nt_b_sequence)          
+          expect(instance2.prev_symbol).to eq(nt_b_sequence)
 
           # Case: dot is at begin
           instance3 = ItemVertex.new(Base::DottedItem.new(sample_prod, 0))
@@ -86,8 +86,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance4 = ItemVertex.new(Base::DottedItem.new(empty_prod, 0))
           expect(instance4.prev_symbol).to be_nil
         end
-        
-        
+
+
         it 'should know the next symbol (if any) in the rhs' do
           # Case: dot is not penultimate
           expect(subject.next_symbol).to eq(nt_b_sequence)
@@ -112,21 +112,21 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           shortcut = ShortcutEdge.new(subject, next_vertex)
           expect(subject.shortcut).to eq(shortcut)
         end
-        
+
         it 'should reject an invalid shortcut edge' do
           err = StandardError
           err_msg = 'Invalid shortcut argument'
           expect { subject.shortcut = 'invalid' }.to raise_error(err, err_msg)
-        end        
+        end
       end # context
 
       context 'Provided services:' do
         it 'should provide human-readable representation of itself' do
-          prefix = /^#<Rley::GFG::ItemVertex:\d+/           
+          prefix = /^#<Rley::GFG::ItemVertex:\d+/
           expect(subject.inspect).to match(prefix)
-          suffix = /label="sentence => a \. b_sequence c">$/        
-          expect(subject.inspect).to match(suffix)            
-        end        
+          suffix = /label="sentence => a \. b_sequence c">$/
+          expect(subject.inspect).to match(suffix)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/non_terminal_vertex_spec.rb

@@ -19,7 +19,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its non-terminal' do
           expect(subject.non_terminal).to eq(sample_nt)
         end
-        
+
 
         it 'should accept at more than one outgoing edge' do
           edge1 = double('fake-edge1')
@@ -28,11 +28,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect { subject.add_edge(edge1) }.not_to raise_error
           expect(subject.edges.size).to eq(1)
           expect(subject.edges.last).to eq(edge1)
-          
+
           expect { subject.add_edge(edge2) }.not_to raise_error
           expect(subject.edges.size).to eq(2)
           expect(subject.edges.last).to eq(edge2)
-        end         
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/shortcut_edge_spec.rb

@@ -27,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know the successor vertex' do
           expect(vertex1).to receive(:shortcut=)
           expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
-          
+
           expect(subject.successor).to eq(vertex2)
         end
 

data/spec/rley/gfg/start_vertex_spec.rb

@@ -22,12 +22,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.label).to eq('.NT')
         end
       end # context
-      
-      context 'Provided services:' do       
+
+      context 'Provided services:' do
         it 'should provide human-readable representation of itself' do
-          pattern = /^#<Rley::GFG::StartVertex:\d+ label="\.NT"/         
-          expect(subject.inspect).to match(pattern)       
-        end        
+          pattern = /^#<Rley::GFG::StartVertex:\d+ label="\.NT"/
+          expect(subject.inspect).to match(pattern)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/vertex_spec.rb

@@ -24,10 +24,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know whether it has a dot at the end of the rhs' do
           expect(subject).not_to be_complete
         end
-        
+
         it 'should know the previous symbol (if any) in the rhs' do
           expect(subject.prev_symbol).to be_nil
-        end        
+        end
 
         it 'should know the next symbol (if any) in the rhs' do
           expect(subject.next_symbol).to be_nil
@@ -40,7 +40,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect { subject.add_edge(edge1) }.not_to raise_error
           expect(subject.edges.size).to eq(1)
           expect(subject.edges.last).to eq(edge1)
-          
+
           err = StandardError
           msg = 'At most one edge accepted'
           expect { subject.add_edge(edge2) }.to raise_error err, msg

data/spec/rley/lexical/token_range_spec.rb

@@ -27,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Both bounds provided
           expect { TokenRange.new(low: 0, high: 5) }.not_to raise_error
         end
-        
+
         it 'could be created with another TokenRange' do
           # Low bound provided
           instance = TokenRange.new(low: 0)
@@ -61,7 +61,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject == [0, 5]).to eq(true)
         end
 
-      
+
         it 'should know whether it is bounded or not' do
           expect(subject).to be_bounded
 
@@ -119,50 +119,50 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.low).to eq(1)
           expect(instance.high).to eq(4)
         end
-        
+
         it 'should tell whether an index value lies outside the range' do
           # Out of range...
           expect(subject.out_of_range?(-1)).to eq(true)
           expect(subject.out_of_range?(6)).to eq(true)
-          
+
           # On boundaries...
           expect(subject.out_of_range?(0)).to eq(false)
           expect(subject.out_of_range?(5)).to eq(false)
-          
+
           # Inside boundaries
           expect(subject.out_of_range?(2)).to eq(false)
 
           instance = TokenRange.new(low: nil, high: 5)
-          
+
           # Lower bound is nil
           expect(instance.out_of_range?(-1)).to eq(false)
           expect(instance.out_of_range?(5)).to eq(false)
           expect(instance.out_of_range?(6)).to eq(true)
-          
+
           instance = TokenRange.new(low: 0, high: nil)
-          
+
           # Upper bound is nil
           expect(instance.out_of_range?(-1)).to eq(true)
           expect(instance.out_of_range?(0)).to eq(false)
           expect(instance.out_of_range?(6)).to eq(false)
         end
-        
+
         it 'should provide a text representation of itself' do
           # Case 1: not bound is set
           instance = TokenRange.new({})
-          expect(instance.to_string(0)).to eq('[?, ?]') 
-          
+          expect(instance.to_string(0)).to eq('[?, ?]')
+
           # Case: only low bound is set
           instance = TokenRange.new(low: 0)
-          expect(instance.to_string(0)).to eq('[0, ?]') 
+          expect(instance.to_string(0)).to eq('[0, ?]')
 
           # Case: only upper bound is set
-          instance = TokenRange.new(high: 5) 
-          expect(instance.to_string(0)).to eq('[?, 5]') 
+          instance = TokenRange.new(high: 5)
+          expect(instance.to_string(0)).to eq('[?, 5]')
 
           # Case: both bounds are set
-          instance = TokenRange.new(low: 0, high: 5) 
-          expect(instance.to_string(0)).to eq('[0, 5]')            
+          instance = TokenRange.new(low: 0, high: 5)
+          expect(instance.to_string(0)).to eq('[0, 5]')
         end
       end
     end # describe

data/spec/rley/lexical/token_spec.rb

@@ -29,10 +29,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its terminal' do
           expect(subject.terminal).to eq(a_terminal)
         end
-        
+
         it 'should know its terminal' do
           expect(subject.position).to eq(a_pos)
-        end        
+        end
       end # context
     end # describe
   end # module

data/spec/rley/notation/grammar_builder_spec.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/notation/grammar_builder'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Notation # Open this namespace to avoid module qualifier prefixes
+    describe GrammarBuilder do
+      context 'Initialization without argument:' do
+        it 'could be created without argument' do
+          expect { GrammarBuilder.new }.not_to raise_error
+        end
+
+        it 'should have no grammar symbols at start' do
+            expect(subject.symbols).to be_empty
+        end
+
+        it 'should have no productions at start' do
+            expect(subject.productions).to be_empty
+        end
+      end # context
+
+      context 'Initialization with argument:' do
+        it 'could be created with a block argument' do
+          expect do
+            GrammarBuilder.new { nil }
+          end.not_to raise_error
+        end
+
+        it 'could have grammar symbols from block argument' do
+          instance = GrammarBuilder.new do
+            add_terminals('a', 'b', 'c')
+          end
+          expect(instance.symbols.size).to eq(3)
+        end
+
+        it 'should have no productions at start' do
+            expect(subject.productions).to be_empty
+        end
+      end # context
+
+      context 'Adding symbols:' do
+        it 'should build terminals from their names' do
+          subject.add_terminals('a', 'b', 'c')
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to be_kind_of(Syntax::Terminal)
+          expect(subject.symbols['a'].name).to eq('a')
+          expect(subject.symbols['b']).to be_kind_of(Syntax::Terminal)
+          expect(subject.symbols['b'].name).to eq('b')
+          expect(subject.symbols['c']).to be_kind_of(Syntax::Terminal)
+          expect(subject.symbols['c'].name).to eq('c')
+        end
+
+        it 'should accept already built terminals' do
+          a = Syntax::Terminal.new('a')
+          b = Syntax::VerbatimSymbol.new('b')
+          c = Syntax::Literal.new('c', /c/)
+
+          subject.add_terminals(a, b, c)
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to eq(a)
+          expect(subject.symbols['b']).to eq(b)
+          expect(subject.symbols['c']).to eq(c)
+        end
+      end # context
+
+      context 'Adding productions:' do
+        subject do
+          instance = GrammarBuilder.new
+          instance.add_terminals('a', 'b', 'c')
+          instance
+        end
+
+        it 'should add a valid production' do
+          # Case of a rhs representation that consists of one name only
+          expect { subject.add_production('S' => 'A') }.not_to raise_error
+          expect(subject.productions.size).to eq(1)
+          new_prod = subject.productions[0]
+          expect(new_prod.lhs).to eq(subject['S'])
+          expect(new_prod.rhs[0]).not_to be_nil
+          expect(new_prod.rhs[0]).to eq(subject['A'])
+
+          # Case of rhs with multiple symbols
+          subject.add_production('A' => 'a A c')
+          expect(subject.productions.size).to eq(2)
+          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)
+
+          # GrammarBuilder#rule is an alias of add_production
+          subject.rule('A' => 'b')
+          expect(subject.productions.size).to eq(3)
+          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 accept annotated terminals' do
+          subject.rule('A' => "a b {match_closest: 'IF' } c")
+          expect(subject.productions.size).to eq(1)
+          new_prod = subject.productions.last
+          expect(new_prod.lhs).to eq(subject['A'])
+          expect(new_prod.rhs[0].name).to eq('a')
+          expect(new_prod.rhs[0]).to eq(subject['a'])
+          expect(new_prod.rhs[1].name).to eq('b')
+          expect(new_prod.rhs[2].name).to eq('c')
+          expect(new_prod.constraints.size).to eq(1)
+          expect(new_prod.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(new_prod.constraints[0].idx_symbol).to eq(1) # b is on position 1
+          expect(new_prod.constraints[0].closest_symb).to eq('IF')
+        end
+
+        it 'should support optional symbol' do
+          instance = GrammarBuilder.new
+          instance.add_terminals('LPAREN', 'RPAREN')
+
+          instance.rule 'argument_list' => 'LPAREN arguments? RPAREN'
+          instance.grammar_complete!
+
+          # implicitly called: rule('arguments_qmark' => 'arguments').tag suffix_qmark_one
+          # implicitly called: rule('arguments_qmark' => '').tag suffix_qmark_none
+          expect(instance.productions.size).to eq(3)
+          prod_star = instance.productions.select { |prod| prod.lhs.name == 'arguments_qmark' }
+          expect(prod_star.size).to eq(2)
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('argument_list')
+          expect(first_prod.rhs.members[1].name).to eq('arguments_qmark')
+        end
+
+        it "should support Kleene's star" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('EOF')
+
+          instance.rule 'program' => 'declaration* EOF'
+          instance.grammar_complete!
+
+          # implicitly called: rule('declaration_star' => 'declaration_star declaration').tag suffix_star_more
+          # implicitly called: rule('declaration_star' => '').tag suffix_star_last
+          expect(instance.productions.size).to eq(3)
+          prod_star = instance.productions.select { |prod| prod.lhs.name == 'declaration_star' }
+          expect(prod_star.size).to eq(2)
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('program')
+          expect(first_prod.rhs.members[0].name).to eq('declaration_star')
+        end
+
+        it "should support symbols decorated with Kleene's plus" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('plus', 'minus', 'digit')
+
+          instance.rule 'integer' => 'value'
+          instance.rule 'integer' => 'sign value'
+          instance.rule 'sign' => 'plus'
+          instance.rule 'sign' => 'minus'
+          instance.rule 'value' => 'digit+'
+          expect(instance.productions.size).to eq(5)
+          instance.grammar_complete!
+          expect(instance.productions.size).to eq(7)
+
+          # implicitly called: rule('digit_plus' => 'digit_plus digit').tag suffix_plus_more
+          # implicitly called: rule('digit_plus' => 'digit').tag suffix_plus_last
+          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)
+          val_prod = instance.productions[4]
+          expect(val_prod.lhs.name).to eq('value')
+          expect(val_prod.rhs.members[0].name).to eq('digit_plus')
+        end
+
+        it "should support optional grouping" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('EQUAL', 'IDENTIFIER', 'VAR')
+
+          instance.rule 'var_decl' => 'VAR IDENTIFIER (EQUAL expression)?'
+          instance.grammar_complete!
+
+          # implicitly called: rule('seq_EQUAL_expression' => 'EQUAL expression').tag 'return_children'
+          # implicitly called: rule('seq_EQUAL_expression_qmark' => 'seq_EQUAL_expression').tag suffix_qmark_one
+          # implicitly called: rule('seq_EQUAL_expression_qmark' => '').tag suffix_qmark_none
+          expect(instance.productions.size).to eq(4)
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('var_decl')
+          expect(first_prod.rhs.members[2].name).to eq('seq_EQUAL_expression_qmark')
+          (p0, p1, p2) = instance.productions[1..3]
+          expect(p0.lhs.name).to eq('seq_EQUAL_expression')
+          expect(p0.rhs[0].name).to eq('EQUAL')
+          expect(p0.rhs[1].name).to eq('expression')
+          expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('seq_EQUAL_expression_qmark')
+          expect(p1.rhs[0].name).to eq('seq_EQUAL_expression')
+          expect(p1.name).to eq('_qmark_one')
+
+          expect(p2.lhs.name).to eq('seq_EQUAL_expression_qmark')
+          expect(p2.rhs).to be_empty
+          expect(p2.name).to eq('_qmark_none')
+        end
+
+        it "should support grouping with star modifier" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('OR')
+
+          instance.rule 'logic_or' => 'logic_and (OR logic_and)*'
+          instance.grammar_complete!
+
+          # implicitly called: rule('seq_OR_logic_and' => 'OR logic_and').tag 'return_children'
+          # implicitly called: rule('seq_EQUAL_expression_star' => 'seq_EQUAL_expression_star seq_EQUAL_expression').tag suffix_star_more
+          # implicitly called: rule('seq_EQUAL_expression_star' => '').tag suffix_star_none
+          expect(instance.productions.size).to eq(4)
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('logic_or')
+          expect(first_prod.rhs.members[1].name).to eq('seq_OR_logic_and_star')
+
+          (p0, p1, p2) = instance.productions[1..3]
+          expect(p0.lhs.name).to eq('seq_OR_logic_and')
+          expect(p0.rhs[0].name).to eq('OR')
+          expect(p0.rhs[1].name).to eq('logic_and')
+          expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('seq_OR_logic_and_star')
+          expect(p1.rhs[0].name).to eq('seq_OR_logic_and_star')
+          expect(p1.rhs[1].name).to eq('seq_OR_logic_and')
+          expect(p1.name).to eq('_star_more')
+
+          expect(p2.lhs.name).to eq('seq_OR_logic_and_star')
+          expect(p2.rhs).to be_empty
+          expect(p2.name).to eq('_star_none')
+        end
+
+        it "should support grouping with plus modifier" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('POINT TO SEMI_COLON')
+
+          instance.rule 'path' => 'POINT (TO POINT)+ SEMI_COLON'
+          instance.grammar_complete!
+
+          # implicitly called: rule('seq_TO_POINT' => 'TO POINT').tag 'return_children'
+          # implicitly called: rule('seq_TO_POINT_plus' => 'seq_TO_POINT_plus seq_TO_POINT').tag suffix_plus_more
+          # implicitly called: rule('seq_TO_POINT_plus' => 'seq_TO_POINT').tag suffix_plus_one
+          expect(instance.productions.size).to eq(4)
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('path')
+          expect(first_prod.rhs.members[1].name).to eq('seq_TO_POINT_plus')
+
+          (p0, p1, p2) = instance.productions[1..3]
+          expect(p0.lhs.name).to eq('seq_TO_POINT')
+          expect(p0.rhs[0].name).to eq('TO')
+          expect(p0.rhs[1].name).to eq('POINT')
+          expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('seq_TO_POINT_plus')
+          expect(p1.rhs[0].name).to eq('seq_TO_POINT_plus')
+          expect(p1.rhs[1].name).to eq('seq_TO_POINT')
+          expect(p1.name).to eq('_plus_more')
+
+          expect(p2.lhs.name).to eq('seq_TO_POINT_plus')
+          expect(p2.rhs[0].name).to eq('seq_TO_POINT')
+          expect(p2.name).to eq('_plus_one')
+        end
+
+        it "should support grouping with nested annotation" do
+          instance = GrammarBuilder.new
+          instance.add_terminals('IF ELSE LPAREN RPAREN')
+          st = "IF LPAREN expr RPAREN stmt (ELSE { match_closest: 'IF' } stmt)?"
+          instance.rule('if_stmt' => st)
+          instance.grammar_complete!
+
+          # implicitly called: rule('seq_ELSE_stmt' => 'ELSE stmt').tag 'return_children'
+          # implicitly called: rule('seq_ELSE_stmt_qmark' => 'seq_ELSE_stmt ').tag suffix_plus_more
+          # implicitly called: rule('seq_ELSE_stmt_qmark' => '').tag suffix_plus_one
+          expect(instance.productions.size).to eq(4)
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('if_stmt')
+          expect(first_prod.rhs.members[5].name).to eq('seq_ELSE_stmt_qmark')
+
+          (p0, p1, p2) = instance.productions[1..3]
+          expect(p0.lhs.name).to eq('seq_ELSE_stmt')
+          expect(p0.rhs[0].name).to eq('ELSE')
+          expect(p0.rhs[1].name).to eq('stmt')
+          expect(p0.name).to eq('return_children')
+          expect(p0.constraints.size). to eq(1)
+          expect(p0.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(p0.constraints[0].idx_symbol).to eq(0) # ELSE is on position 0
+          expect(p0.constraints[0].closest_symb).to eq('IF')
+
+          expect(p1.lhs.name).to eq('seq_ELSE_stmt_qmark')
+          expect(p1.rhs[0].name).to eq('seq_ELSE_stmt')
+          expect(p1.name).to eq('_qmark_one')
+
+          expect(p2.lhs.name).to eq('seq_ELSE_stmt_qmark')
+          expect(p2.rhs).to be_empty
+          expect(p2.name).to eq('_qmark_none')
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file