rley 0.7.06 → 0.8.01

data/spec/rley/ptree/non_terminal_node_spec.rb

@@ -33,7 +33,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           terminal = OpenStruct.new(name: aSymbolName)
           return OpenStruct.new(lexeme: aLexeme, terminal: terminal)
         end
-        
+
         it 'should accept the addition of subnodes' do
           child1 = double('first_child')
           child2 = double('second_child')
@@ -44,6 +44,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.subnodes).to eq([child3, child2, child1])
         end
 
+        # rubocop: disable Naming/VariableNumber
         it 'should provide a text representation of itself' do
           # Case 1: no child
           expected_text = 'VP[0, 3]'
@@ -61,9 +62,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           noun = build_token('bus', 'Noun')
           child_3_1 = TerminalNode.new(noun, range(2, 3))
           # We reverse the sequence of subnode addition
-          subject.add_subnode(child_1_2)          
+          subject.add_subnode(child_1_2)
           subject.add_subnode(child_1_1)
-          child_1_2.add_subnode(child_2_2)          
+          child_1_2.add_subnode(child_2_2)
           child_1_2.add_subnode(child_2_1)
           child_2_2.add_subnode(child_3_1)
           expected_text = <<-SNIPPET
@@ -76,6 +77,7 @@ VP[0, 3]
 SNIPPET
           expect(subject.to_string(0)).to eq(expected_text.chomp)
         end
+        # rubocop: enable Naming/VariableNumber
       end # context
     end # describe
   end # module

data/spec/rley/ptree/parse_tree_node_spec.rb

@@ -27,17 +27,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.range).to eq(sample_range)
         end
       end # context
-      
+
       context 'Initialization:' do
         it 'should assign undefined range bounds' do
           partial_range = { low: 0 } # High bound left undefined
           instance = ParseTreeNode.new(sample_symbol, partial_range)
-          
+
           another = { low: 1, high: 4 } # High bound is specified
           instance.range = another
           expect(instance.range).to eq(low: 0, high: 4)
-        end      
-      end # context      
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/ptree/terminal_node_spec.rb

@@ -10,23 +10,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
   module PTree # Open this namespace to avoid module qualifier prefixes
     describe TerminalNode do
       let(:sample_symbol) { OpenStruct.new(name: 'Noun') }
-      let(:sample_token) do 
-        OpenStruct.new(lexeme: 'world', terminal: sample_symbol) 
+      let(:sample_token) do
+        OpenStruct.new(lexeme: 'world', terminal: sample_symbol)
       end
       let(:sample_range) { double('fake-range') }
-      
+
       subject { TerminalNode.new(sample_token, sample_range) }
-      
+
       context 'Initialization:' do
         it 'should be bound to a token' do
           expect(subject.token).to eq(sample_token)
         end
       end # context
-      
+
       context 'Provided services:' do
         it 'should provide a text representation of itself' do
           expected_text = "Noun[?, ?]: 'world'"
-          expect(subject.to_string(0)).to eq(expected_text)          
+          expect(subject.to_string(0)).to eq(expected_text)
         end
       end # context
     end # describe

data/spec/rley/sppf/alternative_node_spec.rb

@@ -19,7 +19,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       def range(low, high)
         return Lexical::TokenRange.new(low: low, high: high)
       end
-      
+
       let(:t_a) { Syntax::Terminal.new('A') }
       let(:t_b) { Syntax::Terminal.new('B') }
       let(:t_c) { Syntax::Terminal.new('C') }
@@ -29,7 +29,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
       let(:sample_item) { Base::DottedItem.new(sample_prod, 3) }
       let(:sample_vertex) { GFG::ItemVertex.new(sample_item) }
-      let(:sample_range) { range(0, 3) }      
+      let(:sample_range) { range(0, 3) }
 
       subject { AlternativeNode.new(sample_vertex, sample_range) }
 
@@ -37,9 +37,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should be created with a item vertex and a token range' do
           expect { AlternativeNode.new(sample_vertex, sample_range) }
             .not_to raise_error
-        end      
+        end
       end
-      
+
       context 'Initialization:' do
         it 'should know its token range' do
           expect(subject.range).to eq(sample_range)
@@ -50,7 +50,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.subnodes).to be_empty
         end
       end # context
-      
+
       context 'Provided services:' do
         it 'should accept the addition of subnodes' do
           subnode1 = double('first_subnode')
@@ -63,7 +63,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
 
-        it 'should have a string representation' do    
+        it 'should have a string representation' do
           expect(subject.to_string(0)).to eq('Alt(sentence => A B C .)[0, 3]')
         end
       end # context

data/spec/rley/sppf/non_terminal_node_spec.rb

@@ -37,12 +37,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it "shouldn't have children yet" do
           expect(subject.subnodes).to be_empty
         end
-        
+
         it 'should have :and refinement' do
           expect(subject.refinement).to eq(:and)
         end
       end # context
-      
+
       context 'Provided services:' do
         it 'should accept the addition of subnodes' do
           subnode1 = double('first_subnode')
@@ -57,7 +57,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should have a string representation' do
           expect(subject.to_string(0)).to eq('VP[0, 3]')
         end
-        
+
         it 'should return a key value of itself' do
           expect(subject.key).to eq('VP[0, 3]')
         end

data/spec/rley/sppf/token_node_spec.rb

@@ -15,8 +15,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     describe TokenNode do
       let(:sample_symbol) { Syntax::Terminal.new('Noun') }
       let(:sample_position) { Lexical::Position.new(3, 4) }
-      let(:sample_token) do 
-        Lexical::Token.new('language', sample_symbol, sample_position) 
+      let(:sample_token) do
+        Lexical::Token.new('language', sample_symbol, sample_position)
       end
       let(:sample_rank) { 3 }
 
@@ -33,13 +33,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.range.high).to eq(sample_rank + 1)
         end
       end # context
-      
+
       context 'Provided services:' do
         it 'should know its string representation' do
           expect(subject.to_string(0)).to eq('Noun[3, 4]')
           expect(subject.inspect).to eq('Noun[3, 4]')
         end
-        
+
         it 'should return a key value of itself' do
           expect(subject.key).to eq('Noun[3, 4]')
         end

data/spec/rley/support/ambiguous_grammar_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/notation/grammar_builder'
 require_relative '../../../lib/rley/lexical/token'
 
 
@@ -9,14 +9,13 @@ module AmbiguousGrammarHelper
   # Factory method. Creates a grammar builder for a basic ambiguous
   # expression grammar.
   # (based on an example from Fisher and LeBlanc: "Crafting a Compiler")
-  def grammar_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_builder
+    Rley::Notation::GrammarBuilder.new do
       add_terminals('+', 'id')
       rule 'S' => 'E'
-      rule 'E' => %w[E + E]
+      rule 'E' => 'E + E'
       rule 'E' => 'id'
     end
-    builder
   end
 
   # Basic tokenizing method

data/spec/rley/support/grammar_abc_helper.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
 # Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 
 module GrammarABCHelper
   # Factory method. Creates a grammar builder for a simple grammar.
   # (based on example in N. Wirth "Compiler Construction" book, p. 6)
-  def grammar_abc_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_abc_builder
+    Rley::Syntax::BaseGrammarBuilder.new do
       add_terminals('a', 'b', 'c')
       rule 'S' => 'A'
       rule 'A' => 'a A c'
       rule 'A' => 'b'
     end
-
-    return builder
   end
 end # module
 # End of file

data/spec/rley/support/grammar_ambig01_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/rley/lexical/token'
 
 
@@ -10,16 +10,15 @@ module GrammarAmbig01Helper
   # Factory method. Define a grammar for a very simple language
   # Grammar 3: An ambiguous arithmetic expression language
   # (based on example in article on Earley's algorithm in Wikipedia)
-  def grammar_ambig01_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_ambig01_builder
+    Rley::Syntax::BaseGrammarBuilder.new do
       add_terminals('integer', '+', '*')
       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
-    builder
   end
 
   # Highly simplified tokenizer implementation.

data/spec/rley/support/grammar_arr_int_helper.rb

@@ -3,7 +3,7 @@
 require 'strscan'
 
 # Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/syntax/base_grammar_builder'
 require_relative '../../../lib/rley/lexical/token'
 
 
@@ -11,17 +11,16 @@ module GrammarArrIntHelper
   # Factory method. Creates a grammar builder for a grammar of
   # array of integers.
   # (based on the article about Earley's algorithm in Wikipedia)
-  def grammar_arr_int_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_arr_int_builder
+    Rley::Syntax::BaseGrammarBuilder.new do
       add_terminals('[', ']', ',', 'integer')
       rule 'P' => 'arr'
-      rule 'arr' => %w([ sequence ])
+      rule 'arr' => '[ sequence ]'
       rule 'sequence' => 'list'
       rule 'sequence' => []
-      rule 'list' => %w[list , integer] # Left-recursive rule
+      rule 'list' => 'list , integer' # Left-recursive rule
       rule 'list' => 'integer'
     end
-    builder
   end
 
   # Basic tokenizer for array of integers

data/spec/rley/support/grammar_b_expr_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/rley/lexical/token'
 
 
@@ -9,17 +9,16 @@ module GrammarBExprHelper
   # Factory method. Creates a grammar builder for a basic arithmetic
   # expression grammar.
   # (based on the article about Earley's algorithm in Wikipedia)
-  def grammar_expr_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_expr_builder
+    Rley::Syntax::BaseGrammarBuilder.new do
       add_terminals('+', '*', 'integer')
       rule 'P' => 'S'
-      rule 'S' => %w[S + M]
+      rule 'S' => 'S + M'
       rule 'S' => 'M'
-      rule 'M' => %w[M * T]
+      rule 'M' => 'M * T'
       rule 'M' => 'T'
       rule 'T' => 'integer'
     end
-    builder
   end
 
   # Basic expression tokenizer

data/spec/rley/support/grammar_int_seq_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+# Load the builder class
+require_relative '../../../lib/rley/notation/grammar_builder'
+require_relative '../../../lib/rley/lexical/token'
+
+
+module GrammarIntSeqHelper
+  # Factory method. Creates a builder for a grammar of sequence
+  # of positive integers.
+  def grammar_int_seq_builder
+    Rley::Notation::GrammarBuilder.new do
+      add_terminals('comma', 'digit')
+      rule 'S' => 'sequence'
+      rule 'S' => ''
+      rule 'sequence' => 'sequence comma integer'
+      rule 'sequence' => 'integer'
+      rule 'integer' => 'digit+'
+    end
+  end
+
+  # Basic tokenizer for sequence positive integers
+  def int_seq_tokenizer(aText)
+    scanner = StringScanner.new(aText)
+    tokens = []
+
+    loop do
+      scanner.skip(/\s+/)
+      break if scanner.eos?
+
+      curr_pos = scanner.pos
+
+      if (lexeme = scanner.scan(/,/))
+        terminal = 'comma'
+      elsif (lexeme = scanner.scan(/\d/))
+        terminal = 'digit'
+      else
+        msg = "Unknown input text '#{scanner.scan(/.*/)}'"
+        raise StandardError, msg
+      end
+
+      pos = Rley::Lexical::Position.new(1, curr_pos + 1)
+      tokens << Rley::Lexical::Token.new(lexeme, terminal, pos)
+    end
+
+    return tokens
+  end
+end # module
+# End of file

data/spec/rley/support/grammar_l0_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/rley/lexical/token'
 
 
@@ -11,29 +11,28 @@ module GrammarL0Helper
   # based on Jurafky & Martin L0 language (chapter 12 of the book).
   # It defines the syntax of a sentence in a language with a
   # very limited syntax and lexicon in the context of airline reservation.
-  def grammar_l0_builder()
-    builder = Rley::Syntax::GrammarBuilder.new do
+  def grammar_l0_builder
+    Rley::Syntax::BaseGrammarBuilder.new do
       add_terminals('Noun', 'Verb', 'Pronoun', 'Proper-Noun')
       add_terminals('Determiner', 'Preposition')
-      rule 'S' => %w[NP VP]
+      rule 'S' => 'NP VP'
       rule 'NP' => 'Pronoun'
       rule 'NP' => 'Proper-Noun'
-      rule 'NP' => %w[Determiner Nominal]
-      rule 'Nominal' => %w[Nominal Noun]
+      rule 'NP' => 'Determiner Nominal'
+      rule 'Nominal' => 'Nominal Noun'
       rule 'Nominal' => 'Noun'
       rule 'VP' => 'Verb'
-      rule 'VP' => %w[Verb NP]
-      rule 'VP' => %w[Verb NP PP]
-      rule 'VP' => %w[Verb PP]
-      rule 'PP' => %w[Preposition PP]
+      rule 'VP' => 'Verb NP'
+      rule 'VP' => 'Verb NP PP'
+      rule 'VP' => 'Verb PP'
+      rule 'PP' => 'Preposition PP'
     end
-    builder
   end
 
   # Return the language lexicon.
   # A lexicon is just a Hash with pairs of the form:
   # word => terminal symbol name
-  def lexicon_l0()
+  def lexicon_l0
     return {
       'flight' => 'Noun',
       'breeze' => 'Noun',
@@ -78,13 +77,11 @@ module GrammarL0Helper
       word = scanner.scan(/\S+/)
       break unless word
 
-      term_name = lexicon_l0[word]
-      if term_name.nil?
-        raise StandardError, "Word '#{word}' not found in lexicon"
-      end
+      term = lexicon_l0[word]
+      raise StandardError, "Word '#{word}' not found in lexicon" if term.nil?
 
       pos = Rley::Lexical::Position.new(1, curr_pos + 1)
-      tokens << Rley::Lexical::Token.new(word, term_name, pos)
+      tokens << Rley::Lexical::Token.new(word, term, pos)
     end
 
     return tokens