rley 0.4.06 → 0.4.07

data/lib/rley/syntax/grammar_builder.rb

@@ -25,10 +25,10 @@ module Rley # This module is used as a namespace
       # @example Building a tiny English grammar
       #   builder = Rley::Syntax::GrammarBuilder.new do
       #     add_terminals('n', 'v', 'adj', 'det')
-      #     rule 'S' => %w(NP VP)
-      #     rule 'VP' => %w(v NP)
-      #     rule 'NP' => %w(det n)
-      #     rule 'NP' => %w(adj NP)
+      #     rule 'S' => %w[NP VP]
+      #     rule 'VP' => %w[v NP]
+      #     rule 'NP' => %w[det n]
+      #     rule 'NP' => %w[adj NP]
       #   end
       #   tiny_eng = builder.grammar
       def initialize(&aBlock)
@@ -54,7 +54,6 @@ module Rley # This module is used as a namespace
         symbols.merge!(new_symbs)
       end
 
-
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => Array.
       #   Where the key is the name of the non-terminal appearing in the
@@ -64,10 +63,10 @@ module Rley # This module is used as a namespace
       # @example Equivalent call syntaxes
       #   builder.add_production('A' => ['a', 'A', 'c'])
       #   builder.rule('A' => ['a', 'A', 'c']) # 'rule' is a synonym
-      #   builder.rule('A' => %w(a A  c)) # Use %w syntax for Array of String
-      #   builder.rule 'A' => %w(a A  c)  # Call parentheses are optional
-      # @param aProductionRepr [Hash{String, Array<String>}] A Hash-based representation 
-      #   of a production.
+      #   builder.rule('A' => %w[a A  c]) # Use %w syntax for Array of String
+      #   builder.rule 'A' => %w[a A  c]  # Call parentheses are optional
+      # @param aProductionRepr [Hash{String, Array<String>}] 
+      #   A Hash-based representation of a production.
       # @return [void]      
       def add_production(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
@@ -138,7 +137,6 @@ module Rley # This module is used as a namespace
         return symbs
       end
 
-
       # If the argument is already a grammar symbol object then it is
       # returned as is. Otherwise, the argument is treated as a name
       # for a new instance of the given class.
@@ -165,7 +163,6 @@ module Rley # This module is used as a namespace
         end
         return symbols[aSymbolName]
       end
-
     end # class
   end # module
 end # module

data/lib/rley/syntax/grm_symbol.rb

@@ -32,7 +32,6 @@ module Rley # This module is used as a namespace
       def generative?()
         return @generative
       end
-
     end # class
   end # module
 end # module

data/lib/rley/syntax/production.rb

@@ -10,14 +10,15 @@ module Rley # This module is used as a namespace
     # in other words every occurrence of the LHS can be substituted to
     # corresponding RHS.
     class Production
-      # The right-hand side (rhs) consists of a sequence of grammar symbols
+      # @return [SymbolSeq] The right-hand side (rhs).
       attr_reader(:rhs)
 
-      # The left-hand side of the rule. It must be a non-terminal symbol
+      # @return [NonTerminal] The left-hand side of the rule.
       attr_reader(:lhs)
       
-      # A production is generative when all of its rhs members are generative (that as, they
-      # can each generate/derive a non-empty string of terminals).
+      # @return [Boolean ]A production is generative when all of its 
+      # rhs members are generative (that is, they can each generate/derive
+      # a non-empty string of terminals).
       attr_writer(:generative)      
 
       # Provide common alternate names to lhs and rhs accessors

data/lib/rley/tokens/token_range.rb

@@ -21,7 +21,6 @@ module Rley # This module is used as a namespace
         assign_high(aRangeRep)
       end
 
-
       def ==(other)
         return true if object_id == other.object_id
 

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -61,7 +61,9 @@ module Rley # Re-open the module to get rid of qualified names
 
       context 'Standard creation & initialization:' do
         it 'should be initialized with an IO argument' do
-          expect { BracketNotation.new(StringIO.new('', 'w')) }.not_to raise_error
+          expect do 
+            BracketNotation.new(StringIO.new('', 'w')) 
+          end.not_to raise_error
         end
         
         it 'should know its output destination' do

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -165,7 +165,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.add_production('S' => 'B')
           builder.add_production('A' => 'a')
           # There is no edge between .B and B => B . b => non-generative
-          builder.add_production('B' => %w(B b))
+          builder.add_production('B' => %w[B b])
           
           # Non-terminal symbol C is unreachable
           builder.add_production('C' => 'c')  
@@ -181,18 +181,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           end
 
           expected = [
-              '.S',
-              'S => . A',
-              '.A',
-              'A => . a A c',
-              'A => a . A c',
-              'A => a A . c',
-              'A => a A c .',
-              'A.',
-              'A => . b',
-              'A => b .',
-              'S.'
-            ]
+            '.S',
+            'S => . A',
+            '.A',
+            'A => . a A c',
+            'A => a . A c',
+            'A => a A . c',
+            'A => a A c .',
+            'A.',
+            'A => . b',
+            'A => b .',
+            'S.'
+          ]
           expect(result).to eq(expected)
         end
         
@@ -214,42 +214,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             expect(nterm).not_to be_undefined
           end
           
-          unreachable = grammar.non_terminals.select do |nterm| 
-            nterm.unreachable? 
-          end
+          unreachable = grammar.non_terminals.select(&:unreachable?)
           expect(unreachable.size).to eq(1)
           expect(unreachable[0].name).to eq('C')
         end        
-      end # context
-      
-=begin
-      context 'Grammar without undefined symbols:' do
-        it 'should mark all its nonterminals as not undefined' do
-          nonterms = subject.non_terminals
-          nonterms.each do |nterm|
-            expect(nterm).not_to be_undefined
-          end
-        end      
-      end # context
-      
-      context 'Grammar with undefined symbols:' do
-        subject do
-          productions = [prod_S, prod_A1, prod_A2, prod_A3]
-          Grammar.new(productions)
-        end  
-        
-        it 'should detect its nonterminals that are undefined' do
-          nonterms = subject.non_terminals
-          culprits = nonterms.select do |nterm|
-            nterm.undefined?
-          end
-          
-          expect(culprits.size).to eq(1)
-          expect(culprits[0]).to eq(nt_C)
-        end      
-      end # context
-=end      
-      
+      end # context      
     end # describe
   end # module
 end # module

data/spec/rley/gfg/item_vertex_spec.rb

@@ -114,7 +114,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         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)
+          expect { subject.shortcut = 'invalid' }.to raise_error(err, err_msg)
         end        
       end # context
     end # describe

data/spec/rley/parse_forest_visitor_spec.rb

@@ -27,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     end
 
     let(:sample_tokens) do
-      build_token_sequence(%w(a b b b), grammar_sppf)
+      build_token_sequence(%w[a b b b], grammar_sppf)
     end
 
     # A forest with just a root node

data/spec/rley/parse_tree_visitor_spec.rb

@@ -238,8 +238,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations = [
           [:before_ptree, [grm_abc_ptree1]],
           # TODO: fix this test
-          #[:before_subnodes, [root, children]],          
-          #[:before_non_terminal, [root]],
+          # [:before_subnodes, [root, children]],          
+          # [:before_non_terminal, [root]],
 
           # [:before_non_terminal, [big_a_1]],
           # [:before_subnodes, [big_a_1, big_a_1_children]],

data/spec/rley/parser/error_reason_spec.rb

@@ -36,15 +36,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     describe ExpectationNotMet do
       let(:err_token) { double('fake-token') }
       let(:terminals) do
-        ['PLUS', 'LPAREN'].map { |name| Syntax::Terminal.new(name) }
+        %w[PLUS LPAREN].map { |name| Syntax::Terminal.new(name) }
       end
 
       # Default instantiation rule
-      subject { ExpectationNotMet.new(3, err_token, terminals)  }
+      subject { ExpectationNotMet.new(3, err_token, terminals) }
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect { ExpectationNotMet.new(3, err_token, terminals) }.not_to raise_error
+          expect do 
+            ExpectationNotMet.new(3, err_token, terminals) 
+          end.not_to raise_error
         end
 
         it 'should know the error position' do
@@ -57,21 +59,22 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
     end # describe
 
-
     describe UnexpectedToken do
-      let(:err_lexeme) { '-'}
+      let(:err_lexeme) { '-' }
       let(:err_terminal) { Syntax::Terminal.new('MINUS') }
       let(:err_token) { Tokens::Token.new(err_lexeme, err_terminal) }
       let(:terminals) do
-        ['PLUS', 'LPAREN'].map { |name| Syntax::Terminal.new(name) }
+        %w[PLUS LPAREN].map { |name| Syntax::Terminal.new(name) }
       end
 
       # Default instantiation rule
-      subject { UnexpectedToken.new(3, err_token, terminals)  }
+      subject { UnexpectedToken.new(3, err_token, terminals) }
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect { UnexpectedToken.new(3, err_token, terminals) }.not_to raise_error
+          expect do 
+            UnexpectedToken.new(3, err_token, terminals) 
+          end.not_to raise_error
         end
       end # context
 
@@ -85,22 +88,24 @@ MSG_END
           expect(subject.message).to eq(text.chomp)
         end
       end # context
-    end #describe
+    end # describe
 
     describe PrematureInputEnd do
-      let(:err_lexeme) { '+'}
+      let(:err_lexeme) { '+' }
       let(:err_terminal) { Syntax::Terminal.new('PLUS') }
       let(:err_token) { Tokens::Token.new(err_lexeme, err_terminal) }
       let(:terminals) do
-        ['INT', 'LPAREN'].map { |name| Syntax::Terminal.new(name) }
+        %w[INT LPAREN].map { |name| Syntax::Terminal.new(name) }
       end
 
       # Default instantiation rule
-      subject { PrematureInputEnd.new(3, err_token, terminals)  }
+      subject { PrematureInputEnd.new(3, err_token, terminals) }
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect { PrematureInputEnd.new(3, err_token, terminals) }.not_to raise_error
+          expect do 
+            PrematureInputEnd.new(3, err_token, terminals) 
+          end.not_to raise_error
         end
       end # context
 
@@ -117,4 +122,4 @@ MSG_END
     end # describe
   end # module
 end # module
-# End of file
+# End of file

data/spec/rley/parser/gfg_chart_spec.rb

@@ -38,7 +38,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       let(:token_seq) do
-        literals = %w(a a b c c)
+        literals = %w[a a b c c]
         literals.map { |lexeme| Tokens::Token.new(lexeme, nil) }
       end
 

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -33,7 +33,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       let(:grm1_tokens) do
-        build_token_sequence(%w(a a b c c), grammar_abc)
+        build_token_sequence(%w[a a b c c], grammar_abc)
       end
 
 
@@ -116,7 +116,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'A => . b | 0'          # start rule
           ]
           compare_entry_texts(parse_result.chart[0], expected)
-          expected_terminals(parse_result.chart[0], %w(a b))
+          expected_terminals(parse_result.chart[0], %w[a b])
 
           ######################
           # Expectation chart[1]:
@@ -129,7 +129,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           entry_set_1 = parse_result.chart[1]
           expect(entry_set_1.entries.size).to eq(4)
           compare_entry_texts(entry_set_1, expected)
-          expected_terminals(parse_result.chart[1], %w(a b))
+          expected_terminals(parse_result.chart[1], %w[a b])
 
           ######################
           # Expectation chart[2]:
@@ -142,7 +142,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           entry_set_2 = parse_result.chart[2]
           expect(entry_set_2.entries.size).to eq(4)
           compare_entry_texts(entry_set_2, expected)
-          expected_terminals(parse_result.chart[2], %w(a b))
+          expected_terminals(parse_result.chart[2], %w[a b])
 
           ######################
           # Expectation chart[3]:
@@ -154,7 +154,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           entry_set_3 = parse_result.chart[3]
           expect(entry_set_3.entries.size).to eq(3)
           compare_entry_texts(entry_set_3, expected)
-          expected_terminals(parse_result.chart[3], %w(c))
+          expected_terminals(parse_result.chart[3], ['c'])
 
 
           ######################
@@ -167,7 +167,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           entry_set_4 = parse_result.chart[4]
           expect(entry_set_4.entries.size).to eq(3)
           compare_entry_texts(entry_set_4, expected)
-          expected_terminals(parse_result.chart[4], %w(c))
+          expected_terminals(parse_result.chart[4], ['c'])
 
           ######################
           # Expectation chart[5]:
@@ -286,7 +286,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           builder = Syntax::GrammarBuilder.new
           builder.add_terminals(t_x)
-          builder.add_production('Ss' => %w(A A x))
+          builder.add_production('Ss' => %w[A A x])
           builder.add_production('A' => [])
           tokens = [ Tokens::Token.new('x', t_x) ]
 
@@ -331,8 +331,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals(t_int, t_plus, t_star)
             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
@@ -555,14 +555,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should parse an invalid simple input' do
           # Parse an erroneous input (b is missing)
-          wrong = build_token_sequence(%w(a a c c), grammar_abc)
+          wrong = build_token_sequence(%w[a a c c], grammar_abc)
           parse_result = subject.parse(wrong)
           expect(parse_result.success?).to eq(false)
           err_msg = <<-MSG
 Syntax error at or near token 3 >>>c<<<
 Expected one of: ['a', 'b'], found a 'c' instead.
 MSG
-          expect(parse_result.failure_reason.message).to eq(err_msg.chomp)            
+          expect(parse_result.failure_reason.message).to eq(err_msg.chomp)
         end
 
         it 'should report error when no input provided but was required' do
@@ -729,7 +729,7 @@ MSG
           builder = Syntax::GrammarBuilder.new do
             add_terminals(t_a, t_star, t_slash)
             rule 'Z' => 'E'
-            rule 'E' => %w(E Q F)
+            rule 'E' => %w[E Q F]
             rule 'E' => 'F'
             rule 'F' => t_a
             rule 'Q' => t_star
@@ -737,7 +737,7 @@ MSG
             rule 'Q' => [] # Empty production
           end
 
-          tokens = build_token_sequence(%w(a a / a), builder.grammar)
+          tokens = build_token_sequence(%w[a a / a], builder.grammar)
           instance = GFGEarleyParser.new(builder.grammar)
           expect { instance.parse(tokens) }.not_to raise_error
           parse_result = instance.parse(tokens)
@@ -843,10 +843,10 @@ MSG
           # input tokens
           builder = Syntax::GrammarBuilder.new
           builder.add_terminals('a')
-          builder.add_production('S' => %w(a S))
+          builder.add_production('S' => %w[a S])
           builder.add_production('S' => [])
           grammar = builder.grammar
-          tokens = build_token_sequence(%w(a a a a), grammar)
+          tokens = build_token_sequence(%w[a a a a], grammar)
 
           instance = GFGEarleyParser.new(grammar)
           parse_result = instance.parse(tokens)

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -42,10 +42,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       let(:grm1_tokens) do
-        build_token_sequence(%w(a a b c c), grm1)
+        build_token_sequence(%w[a a b c c], grm1)
       end
 
-      let(:grm1_token_b) { build_token_sequence(%w(b), grm1) }
+      let(:grm1_token_b) { build_token_sequence(['b'], grm1) }
 
       # Helper method. Create an array of dotted items
       # from the abc grammar
@@ -297,7 +297,7 @@ SNIPPET
         end
 
         let(:token_seq1) do
-          %w(a a b c c).map do |letter|
+          %w[a a b c c].map do |letter|
             Tokens::Token.new(letter, sample_grammar1.name2symbol[letter])
           end
         end