rley 0.6.00 → 0.6.01

data/lib/rley/parser/parse_entry.rb

@@ -31,8 +31,8 @@ module Rley # This module is used as a namespace
       # production.
       # @return [String]
       def inspect()
-        result = selfie()
-        result << " @antecedents=["
+        result = selfie
+        result << ' @antecedents=['
         antecedents.each do |antec|
           result << antec.selfie
         end
@@ -147,7 +147,7 @@ module Rley # This module is used as a namespace
       # Returns a human-readable and partial representation of itself.
       # @return [String]
       def selfie()
-        result = "#<#{self.class.name}:#{self.object_id}"
+        result = "#<#{self.class.name}:#{object_id}"
         result << " @vertex=<#{vertex.class.name}:#{vertex.object_id}"
         result << " label=#{vertex.label}>"
         result << " @origin=#{origin}"

data/lib/rley/parser/parse_entry_set.rb

@@ -25,7 +25,7 @@ module Rley # This module is used as a namespace
       # set of parse entries.
       # @return [String]
       def inspect()
-        result = "#<#{self.class.name}:#{self.object_id}"
+        result = "#<#{self.class.name}:#{object_id}"
         result << ' @entries=['
         entries.each { |e| result << e.inspect }
         result << ']>'

data/lib/rley/parser/parse_walker_factory.rb

@@ -19,7 +19,7 @@ module Rley # This module is used as a namespace
       # non-terminal symbol => { index(=origin) => start entry }
       :return_stack, # @return [Array<ParseEntry>] A stack of parse entries
       :backtrack_points,
-      :lazy_walk # If true and revisit end vertex then jump to start vertex      
+      :lazy_walk # If true and revisit end vertex then jump to start vertex
     )
 
 
@@ -27,29 +27,29 @@ module Rley # This module is used as a namespace
       :entry_set_index, # Sigma set index of current parse entry
       :return_stack, # A stack of parse entries
       :visitee, # The parse entry being visited
-      :antecedent_index,
+      :antecedent_index
     )
 
     # A factory that creates an Enumerator object
     # that itself walks through a GFGParsing object.
-    # The walker (= Enumerator) yields visit events.  
+    # The walker (= Enumerator) yields visit events.
     # This class implements an external iterator
     # for a given GFGParsing object.
-    # This is different from the internal iterators, usually implemented 
+    # This is different from the internal iterators, usually implemented
     # in Ruby with an :each method.
     # Allows to perform a backwards traversal over the relevant parse entries.
-    # backwards traversal means that the traversal starts from the 
+    # backwards traversal means that the traversal starts from the
     # accepting (final) parse entries and goes to the initial parse entry.
     # Relevant parse entries are parse entries that "count" in the parse
     # (i.e. they belong to a path that leads to the accepting parse entry)
     class ParseWalkerFactory
       # Build an Enumerator that will yield the parse entries as it
       # walks backwards on the parse graph.
-      # @param acceptingEntry [ParseEntry] the final ParseEntry of a 
+      # @param acceptingEntry [ParseEntry] the final ParseEntry of a
       #    successful parse.
       # @param maxIndex [Integer] the index of the last input token.
       # @param lazyWalk [Boolean] if true then take some shortcut in re-visits.
-      # @return [Enumerator] yields visit events when walking over the 
+      # @return [Enumerator] yields visit events when walking over the
       #   parse result
       def build_walker(acceptingEntry, maxIndex, lazyWalk = false)
         # Local context for the enumerator
@@ -93,12 +93,12 @@ module Rley # This module is used as a namespace
 
         return context
       end
-      
+
       # Initialize the non-terminal to start entry mapping
       def init_nterm2start()
         h = Hash.new do |hsh, defval|
           entry, index = defval
-          nonterm = entry.vertex.non_terminal          
+          nonterm = entry.vertex.non_terminal
           if hsh.include? nonterm
             pre = hsh[nonterm]
             pre[index] = entry
@@ -106,7 +106,7 @@ module Rley # This module is used as a namespace
             hsh[nonterm] = { index => entry }
           end
         end
-          
+
         return h
       end
 
@@ -134,7 +134,7 @@ module Rley # This module is used as a namespace
 
             when GFG::ItemVertex
               # Even for non-ambiguous parse, can be caused by
-              # left recursive rule e.g. (S => S A)            
+              # left recursive rule e.g. (S => S A)
               # Skip item entries while revisiting
               event = [:revisit, anEntry, index]
             else
@@ -207,19 +207,19 @@ module Rley # This module is used as a namespace
 
           when GFG::StartVertex
             new_entry = select_calling_entry(aContext)
-            
+
           when GFG::ItemVertex
             # Push current entry onto stack
             # puts "Special push on return stack #{aContext.curr_entry}"
-            aContext.return_stack << aContext.curr_entry        
+            aContext.return_stack << aContext.curr_entry
             # puts "Add special backtrack point stack #{aContext.curr_entry}"
             bp = add_backtrack_point(aContext)
-            new_entry = bp.visitee.antecedents[bp.antecedent_index]          
+            new_entry = bp.visitee.antecedents[bp.antecedent_index]
           else
             raise StandardError, 'Internal error'
         end
 
-        return [ new_entry ]
+        return [new_entry]
       end
 
       def add_backtrack_point(aContext)

data/lib/rley/syntax/grammar.rb

@@ -190,7 +190,7 @@ module Rley # This module is used as a namespace
       # A nullable nonterminal is a nonterminal that can match an empty string.
       def compute_nullable()
         non_terminals.each { |nterm| nterm.nullable = false }
-        nullable_sets = [ direct_nullable ]
+        nullable_sets = [direct_nullable]
 
         # Drop productions with one terminal in rhs or with a nullable lhs
         filtered_rules = rules.reject do |prod|

data/lib/rley/syntax/grammar_builder.rb

@@ -75,9 +75,9 @@ module Rley # This module is used as a namespace
             when Array
               rhs_constituents = rhs_repr.map { |name| get_nonterminal(name) }
             when String
-              rhs_constituents = [ get_nonterminal(rhs_repr) ]
+              rhs_constituents = [get_nonterminal(rhs_repr)]
             when Terminal
-              rhs_constituents = [ rhs_repr ]
+              rhs_constituents = [rhs_repr]
           end
           new_prod = Production.new(lhs, rhs_constituents)
           productions << new_prod

data/lib/rley/syntax/production.rb

@@ -16,7 +16,8 @@ module Rley # This module is used as a namespace
       # @return [NonTerminal] The left-hand side of the rule.
       attr_reader(:lhs)
       
-      # @return [String] The name of the production rule. It must be unique in a grammar.
+      # @return [String] 
+      #   The name of the production rule. It must be unique in a grammar.
       attr_accessor(:name)
       
       # @return [Boolean] A production is generative when all of its 
@@ -55,8 +56,8 @@ module Rley # This module is used as a namespace
       # production.
       # @return [String]
       def inspect()
-        result = "#<#{self.class.name}:#{self.object_id}"
-        result << " @name=\"#{self.name}\""
+        result = "#<#{self.class.name}:#{object_id}"
+        result << " @name=\"#{name}\""
         result << " @lhs=#{lhs.name}"
         result << " @rhs=#{rhs.inspect}"
         result << " @generative=#{@generative}>"

data/lib/rley/syntax/symbol_seq.rb

@@ -38,8 +38,8 @@ module Rley # This module is used as a namespace
       # sequence of symbols.
       # @return [String]
       def inspect()
-        result = "#<#{self.class.name}:#{self.object_id}"
-        symbol_names = self.members.map(&:name)
+        result = "#<#{self.class.name}:#{object_id}"
+        symbol_names = members.map(&:name)
         result << " @members=#{symbol_names}>"
         return result
       end

data/spec/rley/base/grm_items_builder_spec.rb

@@ -23,7 +23,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Next line calls method from mixin module under test
           items = build_dotted_items(grammar_abc)
           expect(items.size).to eq(8)
-          expectations = [ 
+          expectations = [
             'S => . A',
             'S => A .',
             'A => . a A c',

data/spec/rley/engine_spec.rb

@@ -19,9 +19,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       it 'could be created with block argument' do
         expect { Engine.new do |config|
-            config.parse_repr = :raw
-          end
-        }.not_to raise_error
+                   config.parse_repr = :raw
+                 end
+               }.not_to raise_error
       end
 
       it "shouldn't have a link to a grammar yet" do
@@ -87,8 +87,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
     end # context
 
-
-
     context 'Parse tree manipulation:' do
       subject do
         instance = Engine.new
@@ -124,4 +122,3 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     end # context
   end # describe
 end # module
-

data/spec/rley/formatter/asciitree_spec.rb

@@ -13,7 +13,6 @@ require_relative '../../../lib/rley/formatter/asciitree'
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe Asciitree do
-
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -13,7 +13,6 @@ require_relative '../../../lib/rley/formatter/bracket_notation'
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe BracketNotation do
-
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do

data/spec/rley/formatter/debug_spec.rb

@@ -13,9 +13,8 @@ require_relative '../../../lib/rley/formatter/debug'
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe Debug do
-
-    # Factory method. Build a production with the given sequence    
-    # of symbols as its rhs.
+      # Factory method. Build a production with the given sequence    
+      # of symbols as its rhs.
       let(:grammar_abc) do
         sandbox = Object.new
         sandbox.extend(GrammarABCHelper)

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -139,12 +139,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.vertices.each do |a_vertex|
             next unless a_vertex.kind_of?(ItemVertex)
             if a_vertex.next_symbol.kind_of?(Syntax::NonTerminal)
-              expect(a_vertex.shortcut).not_to be_nil            
+              expect(a_vertex.shortcut).not_to be_nil
               my_d_item = a_vertex.dotted_item
-              
+
               # Retrieve dotted item of shortcut successor
               other_d_item = a_vertex.shortcut.successor.dotted_item
-              
+
               # Now the checks...
               expect(my_d_item.production).to eq(other_d_item.production)
               expect(my_d_item.position).to eq(other_d_item.prev_position)
@@ -154,7 +154,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           end
         end
       end # context
-      
+
       context 'Provided services:' do
         let(:problematic_grammar) do
           # Based on grammar example in book
@@ -166,14 +166,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.add_production('A' => 'a')
           # There is no edge between .B and B => B . b => non-generative
           builder.add_production('B' => %w[B b])
-          
+
           # Non-terminal symbol C is unreachable
-          builder.add_production('C' => 'c')  
+          builder.add_production('C' => 'c')
 
           # And now build the grammar...
-          builder.grammar       
+          builder.grammar
         end
-      
+
         it 'should provide depth-first traversal' do
           result = []
           subject.traverse_df(subject.start_vertex) do |vertex|
@@ -196,16 +196,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ]
           expect(result).to eq(expected)
         end
-        
+
         it 'should provide human-readable representation of itself' do
           prefix = /^#<Rley::GFG::GrmFlowGraph:\d+ @vertices=\[/
           expect(subject.inspect).to match(prefix)
-          pattern = /@vertices=\[#<Rley::GFG::StartVertex:\d+ label="\.S"/          
+          pattern = /@vertices=\[#<Rley::GFG::StartVertex:\d+ label="\.S"/
           expect(subject.inspect).to match(pattern)
-          suffix = /]>$/          
-          expect(subject.inspect).to match(suffix)          
-        end        
-        
+          suffix = /]>$/
+          expect(subject.inspect).to match(suffix)
+        end
+
         it 'should perform a diagnosis of a correct grammar' do
           expect { subject.diagnose }.not_to raise_error
           grammar_abc.non_terminals.each do |nterm|
@@ -213,22 +213,22 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             expect(nterm).not_to be_unreachable
           end
         end
-        
+
         it 'should detect when a non-terminal is unreachable' do
           grammar = problematic_grammar
           items = build_items_for_grammar(grammar)
 
-          graph = GrmFlowGraph.new(items)       
+          graph = GrmFlowGraph.new(items)
           expect { graph.diagnose }.not_to raise_error
           grammar.non_terminals.each do |nterm|
             expect(nterm).not_to be_undefined
           end
-          
+
           unreachable = grammar.non_terminals.select(&:unreachable?)
           expect(unreachable.size).to eq(1)
           expect(unreachable[0].name).to eq('C')
-        end        
-      end # context      
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/parse_rep/ast_builder_spec.rb

@@ -45,8 +45,8 @@ module Rley # This module is used as a namespace
         Terminal2NodeClass
       end
 
-      def reduce_P_0(_aProd, _range, _tokens, theChildren)
-        return_first_child(_range, _tokens, theChildren)
+      def reduce_P_0(_aProd, aRange, theTokens, theChildren)
+        return_first_child(aRange, theTokens, theChildren)
       end
 
       # rule 'arr' => %w([ sequence ])
@@ -55,8 +55,8 @@ module Rley # This module is used as a namespace
       end
 
       # rule 'sequence' => ['list']
-      def reduce_sequence_0(_aProd, _range, _tokens, theChildren)
-        return_first_child(_range, _tokens, theChildren)
+      def reduce_sequence_0(_aProd, aRange, theTokens, theChildren)
+        return_first_child(aRange, theTokens, theChildren)
       end
 
       # rule 'sequence' => []
@@ -187,15 +187,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         # Event: visit P => . arr | 0 0
         # Event: visit .P | 0 0
 
-        # it 'should accept a first visit event' do
-          # stack = get_stack(subject)
+        it 'should accept a first visit event' do
+          stack = get_stack(subject)
 
-          # next_event('visit P. | 0 7')
-          # expect(stack.size).to eq(1)
-          # # stack: [P[0, 7]]
-          # expect(stack.last.range).to eq(create_range(0, 7))
-          # expect(stack.last.children).to be_nil
-        # end
+          next_event('visit P. | 0 7')
+          expect(stack.size).to eq(1)
+          # stack: [P[0, 7]]
+          expect(stack.last.range).to eq(create_range(0, 7))
+          expect(stack.last.children).to be_nil
+        end
 
         it 'should build a tree for an empty array' do
           stack = get_stack(subject)

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -288,7 +288,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.add_terminals(t_x)
           builder.add_production('Ss' => %w[A A x])
           builder.add_production('A' => [])
-          tokens = [ Lexical::Token.new('x', t_x) ]
+          tokens = [Lexical::Token.new('x', t_x)]
 
           instance = GFGEarleyParser.new(builder.grammar)
           expect { instance.parse(tokens) }.not_to raise_error

data/spec/rley/parser/parse_entry_set_spec.rb

@@ -76,7 +76,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.push_entry(entry2)
           expect(subject.entries4term(t_b)).to eq([entry1, entry2])
         end
-        
+
         it 'should list the expected terminals' do
           subject.push_entry(entry1)
           subject.push_entry(entry2)
@@ -90,20 +90,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.push_entry(entry3)
           expect(subject.entries4n_term(nt_rep_c)).to eq([entry3])
         end
-        
+
         it 'should provide human-readable representation of itself' do
           # Case 1: empty set
           pattern_empty = /^#<Rley::Parser::ParseEntrySet:\d+ @entries=\[\]>$/
           expect(subject.inspect).to match(pattern_empty)
-          
+
           # Case 2: non-empty set
           subject.push_entry(entry1)
           prefix = /^#<Rley::Parser::ParseEntrySet:\d+ @entries=\[#<Rley/
           expect(subject.inspect).to match(prefix)
-          pattern_entry = /ParseEntry:\d+ @vertex=<Rley::GFG::ItemVertex:\d+/          
+          pattern_entry = /ParseEntry:\d+ @vertex=<Rley::GFG::ItemVertex:\d+/
           expect(subject.inspect).to match(pattern_entry)
           suffix = /=> a \. b b Repetition> @origin=2 @antecedents=\[\]>\]>$/
-          expect(subject.inspect).to match(suffix)          
+          expect(subject.inspect).to match(suffix)
         end
 
 =begin

data/spec/rley/parser/parse_state_spec.rb

@@ -57,6 +57,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Provided services:' do
+        def new_parse_state(aProd, aRank, aVal)
+          item = Base::DottedItem.new(aProd, aRank)
+          ParseState.new(item, aVal)
+        end
+        
         it 'should compare with itself' do
           synonym = subject # Fool Rubocop
           expect(subject == synonym).to eq(true)
@@ -97,12 +102,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         
         it 'should know whether another instance follows this one' do
           expect(subject.precedes?(subject)).to eq(false)
-          state1 = ParseState.new(Base::DottedItem.new(sample_prod, 1), origin_val)
+          state1 = new_parse_state(sample_prod, 1, origin_val)
           expect(state1.precedes?(subject)).to eq(true)
-          state0 = ParseState.new(Base::DottedItem.new(sample_prod, 0), origin_val)
+          state0 = new_parse_state(sample_prod, 0, origin_val)
           expect(state0.precedes?(state1)).to eq(true)
           expect(state0.precedes?(subject)).to eq(false)
-          state3 = ParseState.new(Base::DottedItem.new(sample_prod, 3), origin_val)
+          state3 = new_parse_state(sample_prod, 3, origin_val)
           expect(state3.precedes?(state0)).to eq(false)
         end