rley 0.7.07 → 0.7.08

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

@@ -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::Syntax::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

@@ -6,15 +6,13 @@ require_relative '../../../lib/rley/syntax/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::GrammarBuilder.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

@@ -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::GrammarBuilder.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

@@ -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::GrammarBuilder.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

@@ -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::GrammarBuilder.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_l0_helper.rb

@@ -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::GrammarBuilder.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',

data/spec/rley/support/grammar_pb_helper.rb

@@ -12,7 +12,7 @@ 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
         add_terminals('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

@@ -10,7 +10,7 @@ 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()
+  def grammar_sppf_builder
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('a', 'b')
       rule 'Phi' => 'S'

data/spec/rley/syntax/grammar_builder_spec.rb

@@ -24,7 +24,7 @@ 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 
+          expect do
             GrammarBuilder.new { nil }
           end.not_to raise_error
         end
@@ -99,14 +99,14 @@ 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
           subject.rule('A' => ['b'])
@@ -162,11 +162,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

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