rley 0.4.06 → 0.4.07

data/spec/rley/parser/groucho_spec.rb

@@ -23,13 +23,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         builder = Rley::Syntax::GrammarBuilder.new do
           add_terminals('N', 'V', 'Pro')  # N(oun), V(erb), Pro(noun)
           add_terminals('Det', 'P')       # Det(erminer), P(reposition)
-          rule 'S' => %w(NP VP)
-          rule 'NP' => %w(Det N)
-          rule 'NP' => %w(Det N PP)
+          rule 'S' => %w[NP VP]
+          rule 'NP' => %w[Det N]
+          rule 'NP' => %w[Det N PP]
           rule 'NP' => 'Pro'
-          rule 'VP' => %w(V NP)
-          rule 'VP' => %w(VP PP)
-          rule 'PP' => %w(P NP)
+          rule 'VP' => %w[V NP]
+          rule 'VP' => %w[VP PP]
+          rule 'PP' => %w[P NP]
         end
         builder.grammar
       end
@@ -111,7 +111,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       context 'Parse ambiguous sentence' do
-
         subject { ParseForestBuilder.new(sentence_tokens) }
 
         it 'should build a parse forest with a correct root node' do

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -24,18 +24,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
             rule 'Phi' => 'S'
-            rule 'S' => %w(A T)
-            rule 'S' => %w(a T)
+            rule 'S' => %w[A T]
+            rule 'S' => %w[a T]
             rule 'A' => 'a'
-            rule 'A' => %w(B A)
+            rule 'A' => %w[B A]
             rule 'B' => []
-            rule 'T' => %w(b b b)
+            rule 'T' => %w[b b b]
           end
           builder.grammar
       end
 
       let(:sample_tokens) do
-        build_token_sequence(%w(a b b b), sample_grammar)
+        build_token_sequence(%w[a b b b], sample_grammar)
       end
 
       let(:sample_result) do

data/spec/rley/parser/parse_forest_factory_spec.rb

@@ -23,18 +23,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
             rule 'Phi' => 'S'
-            rule 'S' => %w(A T)
-            rule 'S' => %w(a T)
+            rule 'S' => %w[A T]
+            rule 'S' => %w[a T]
             rule 'A' => 'a'
-            rule 'A' => %w(B A)
+            rule 'A' => %w[B A]
             rule 'B' => []
-            rule 'T' => %w(b b b)
+            rule 'T' => %w[b b b]
           end
           builder.grammar
       end
 
       let(:sample_tokens) do
-        build_token_sequence(%w(a b b b), sample_grammar)
+        build_token_sequence(%w[a b b b], sample_grammar)
       end
 
       let(:sample_result) do

data/spec/rley/parser/parse_state_spec.rb

@@ -74,6 +74,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           diff_rule = ParseState.new(other_dotted_rule, 3)
           expect(subject == diff_rule).to eq(false)
         end
+        
+        it 'should know if the parsing is at the start of the production' do
+          expect(subject).not_to be_predicted
+          at_start = DottedItem.new(sample_prod, 0)
+
+          instance = ParseState.new(at_start, 0)
+          expect(instance).to be_predicted
+        end        
 
         it 'should know if the parsing reached the end of the production' do
           expect(subject).not_to be_complete

data/spec/rley/parser/parse_tracer_spec.rb

@@ -17,7 +17,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:output) { StringIO.new('', 'w') }
 
       let(:token_seq) do
-        literals = %w(I saw John with a dog)
+        literals = %w[I saw John with a dog]
         literals.map { |lexeme| Tokens::Token.new(lexeme, nil) }
       end
 

data/spec/rley/parser/parse_tree_builder_spec.rb

@@ -16,7 +16,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include GrammarBExprHelper # Mix-in for basic arithmetic language
 
       let(:sample_grammar) do
-          builder = grammar_expr_builder()
+          builder = grammar_expr_builder
           builder.grammar
       end
 
@@ -33,9 +33,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Emit a text representation of the current path.
       def path_to_s()
-        text_parts = subject.curr_path.map do |path_element|
-          path_element.to_s
-        end
+        text_parts = subject.curr_path.map(&:to_s)
         return text_parts.join('/')
       end
 
@@ -94,7 +92,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           next_event(:visit, 'P => S . | 0') # Event 2
           next_event(:visit, 'S. | 0') # Event 3
           next_event(:visit, 'S => S + M . | 0') # Event 4
-          expected_curr_path('P[0, 5]/S[0, 5]')          
+          expected_curr_path('P[0, 5]/S[0, 5]')
           next_event(:visit, 'M. | 2') # Event 5
           expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]')
           next_event(:visit, 'M => M * T . | 2') # Event 6
@@ -112,7 +110,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           next_event(:visit, 'T => . integer | 4') # Event 9
           expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]/T[4, 5]')
           expected_first_child("integer[4, 5]: '4'")
-          expect(subject.curr_parent.subnodes.size).to eq(1)          
+          expect(subject.curr_parent.subnodes.size).to eq(1)
         end
 
         it 'should handle the remaining events' do
@@ -125,8 +123,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]')
 
           next_event(:visit, 'M => M * . T | 2') # Event 11
-          
-          next_event(:visit, 'M => M . * T | 2') # Event 12          
+
+          next_event(:visit, 'M => M . * T | 2') # Event 12
           expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]')
           expect(subject.curr_parent.subnodes.size).to eq(2)
           expected_first_child("*[3, 4]: '*'")
@@ -146,44 +144,44 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_first_child("integer[2, 3]: '3'")
 
           next_event(:visit, 'T => . integer | 2') # Event 17
-          
+
           next_event(:visit, '.T | 2') # Event 18
-          expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]/M[2, 3]')          
+          expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]/M[2, 3]')
 
           next_event(:visit, 'M => . T | 2') # Event 19
           expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]/M[2, 3]')
 
           next_event(:visit, '.M | 2') # Event 20
           expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]')
- 
+
           next_event(:visit, 'M => . M * T | 2') # Event 21
-          expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]') 
+          expected_curr_path('P[0, 5]/S[0, 5]/M[2, 5]')
 
           next_event(:revisit, '.M | 2') # Revisit Event 22
-          expected_curr_path('P[0, 5]/S[0, 5]')          
- 
+          expected_curr_path('P[0, 5]/S[0, 5]')
+
           next_event(:visit, 'S => S + . M | 0') # Event 23
           expected_curr_path('P[0, 5]/S[0, 5]')
 
           next_event(:visit, 'S => S . + M | 0') # Event 24
           expected_curr_path('P[0, 5]/S[0, 5]')
           expect(subject.curr_parent.subnodes.size).to eq(2)
-          expected_first_child("+[1, 2]: '+'")          
-          
+          expected_first_child("+[1, 2]: '+'")
+
           next_event(:visit, 'S. | 0') # Event 25
-          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]')          
+          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]')
 
           next_event(:visit, 'S => M . | 0') # Event 26
           expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]')
-          
+
           next_event(:visit, 'M. | 0') # Event 27
           expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]')
 
           next_event(:visit, 'M => T . | 0') # Event 28
-          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]') 
+          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]')
 
           next_event(:visit, 'T. | 0') # Event 29
-          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]/T[0, 1]')           
+          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]/T[0, 1]')
 
           next_event(:visit, 'T => integer . | 0') # Event 30
           expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]/T[0, 1]')
@@ -194,17 +192,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_first_child("integer[0, 1]: '2'")
 
           next_event(:visit, '.T | 0') # Event 32
-          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]')  
+          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]')
 
           next_event(:visit, 'M => . T | 0') # Event 33
-          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]')           
+          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]/M[0, 1]')
 
           next_event(:visit, '.M | 0') # Event 34
-          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]') 
+          expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]')
 
           next_event(:visit, 'S => . M | 0') # Event 35
           expected_curr_path('P[0, 5]/S[0, 5]/S[0, 1]')
-          
+
           next_event(:visit, '.S | 0') # Event 36
           expected_curr_path('P[0, 5]/S[0, 5]')
 
@@ -215,12 +213,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_curr_path('P[0, 5]')
 
           next_event(:visit, 'P => . S | 0') # Event 39
-          expected_curr_path('P[0, 5]')            
+          expected_curr_path('P[0, 5]')
 
-          next_event(:visit, '.P | 0') # Event 39         
+          next_event(:visit, '.P | 0') # Event 39
           expect(path_to_s).to be_empty
         end
-        
+
         it 'should build parse trees' do
           loop do
             event = @walker.next
@@ -241,10 +239,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           second_grandchild = child_node.subnodes[1]
           expect(second_grandchild.to_s).to eq("+[1, 2]: '+'")
           third_grandchild = child_node.subnodes[2]
-          expect(third_grandchild.to_s).to eq('M[2, 5]')           
+          expect(third_grandchild.to_s).to eq('M[2, 5]')
         end
       end # context
-
     end # describe
   end # module
 end # module

data/spec/rley/parser/parse_tree_factory_spec.rb

@@ -23,18 +23,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
             rule 'Phi' => 'S'
-            rule 'S' => %w(A T)
-            rule 'S' => %w(a T)
+            rule 'S' => %w[A T]
+            rule 'S' => %w[a T]
             rule 'A' => 'a'
-            rule 'A' => %w(B A)
+            rule 'A' => %w[B A]
             rule 'B' => []
-            rule 'T' => %w(b b b)
+            rule 'T' => %w[b b b]
           end
           builder.grammar
       end
 
       let(:sample_tokens) do
-        build_token_sequence(%w(a b b b), sample_grammar)
+        build_token_sequence(%w[a b b b], sample_grammar)
       end
 
       let(:sample_result) do

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -46,18 +46,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
             rule'Phi' => 'S'
-            rule'S' => %w(A T)
-            rule'S' => %w(a T)
+            rule'S' => %w[A T]
+            rule'S' => %w[a T]
             rule'A' => 'a'
-            rule'A' => %w(B A)
+            rule'A' => %w[B A]
             rule'B' => []
-            rule'T' => %w(b b b)
+            rule'T' => %w[b b b]
           end
           builder.grammar
       end
 
       let(:sample_tokens) do
-        build_token_sequence(%w(a b b b), sample_grammar)
+        build_token_sequence(%w[a b b b], sample_grammar)
       end
 
       let(:sample_result) do

data/spec/rley/ptree/parse_tree_node_spec.rb

@@ -28,12 +28,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       
       context 'Initialization:' do
         it 'should assign undefined range bounds' do
-          partial_range =  { low: 0 } # High bound left undefined
+          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})
+          expect(instance.range).to eq(low: 0, high: 4)
         end      
       end # context      
     end # describe

data/spec/rley/ptree/terminal_node_spec.rb

@@ -16,7 +16,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       subject { TerminalNode.new(sample_token, sample_range) }
       
       context 'Initialization:' do
-        it "should be bound to a token" do
+        it 'should be bound to a token' do
           expect(subject.token).to eq(sample_token)
         end
       end # context

data/spec/rley/support/ambiguous_grammar_helper.rb

@@ -11,7 +11,7 @@ module AmbiguousGrammarHelper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('+', 'id')
       rule 'S' => 'E'
-      rule 'E' => %w(E + E)
+      rule 'E' => %w[E + E]
       rule 'E' => 'id'
     end
     builder

data/spec/rley/support/expectation_helper.rb

@@ -27,7 +27,6 @@ module ExpectationHelper
     end
   end
 
-
   def expected_terminals(anEntrySet, termNames)
     terminals = anEntrySet.expected_terminals
     actual_names = terminals.map(&:name)

data/spec/rley/support/grammar_abc_helper.rb

@@ -8,7 +8,7 @@ module GrammarABCHelper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('a', 'b', 'c')
       rule 'S' => 'A'
-      rule 'A' => %w(a A c)
+      rule 'A' => %w[a A c]
       rule 'A' => 'b'
     end
 

data/spec/rley/support/grammar_ambig01_helper.rb

@@ -12,15 +12,14 @@ module GrammarAmbig01Helper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('integer', '+', '*')
       rule 'P' => 'S'
-      rule 'S' => %w(S + S)
-      rule 'S' => %w(S * S)
+      rule 'S' => %w[S + S]
+      rule 'S' => %w[S * S]
       rule 'S' => 'L'
       rule 'L' => 'integer'
     end
     builder
   end
 
-
   # Highly simplified tokenizer implementation.
   def tokenizer_ambig01(aText, aGrammar)
     tokens = aText.scan(/\S+/).map do |lexeme|

data/spec/rley/support/grammar_b_expr_helper.rb

@@ -11,9 +11,9 @@ module GrammarBExprHelper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('+', '*', 'integer')
       rule 'P' => 'S'
-      rule 'S' => %w(S + M)
+      rule 'S' => %w[S + M]
       rule 'S' => 'M'
-      rule 'M' => %w(M * T)
+      rule 'M' => %w[M * T]
       rule 'M' => 'T'
       rule 'T' => 'integer'
     end

data/spec/rley/support/grammar_l0_helper.rb

@@ -13,17 +13,17 @@ module GrammarL0Helper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('Noun', 'Verb', 'Pronoun', 'Proper-Noun')
       add_terminals('Determiner', 'Preposition')
-      rule 'S' => %w(NP VP)
+      rule 'S' => %w[NP VP]
       rule 'NP' => 'Pronoun'
       rule 'NP' => 'Proper-Noun'
-      rule 'NP' => %w(Determiner Nominal)
-      rule 'Nominal' => %w(Nominal Noun)
+      rule 'NP' => %w[Determiner Nominal]
+      rule 'Nominal' => %w[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' => %w[Verb NP]
+      rule 'VP' => %w[Verb NP PP]
+      rule 'VP' => %w[Verb PP]
+      rule 'PP' => %w[Preposition PP]
     end
     builder
   end
@@ -65,7 +65,6 @@ module GrammarL0Helper
     }
   end
 
-
   # Highly simplified tokenizer implementation.
   def tokenizer_l0(aText, aGrammar)
     tokens = aText.scan(/\S+/).map do |word|

data/spec/rley/support/grammar_pb_helper.rb

@@ -5,7 +5,6 @@ require_relative '../../../lib/rley/tokens/token'
 
 # Utility class.
 class GrammarPBHelper
-
   # Factory method. Creates a grammar for a basic arithmetic
   # expression based on example found in paper of
   # K. Pingali and G. Bilardi:
@@ -20,8 +19,8 @@ class GrammarPBHelper
         add_terminals(t_int, t_plus, t_lparen, t_rparen)
         rule 'S' => 'E'
         rule 'E' => 'int'
-        rule 'E' => %w(( E + E ))
-        rule 'E' => %w(E + E)
+        rule 'E' => %w[( E + E )]
+        rule 'E' => %w[E + E]
       end
       builder.grammar
     end
@@ -45,4 +44,4 @@ class GrammarPBHelper
     return tokens
   end
 end # module
-# End of file
+# End of file