rley 0.5.02 → 0.5.03

data/examples/general/calc_iter1/spec/calculator_spec.rb

@@ -67,7 +67,5 @@ describe 'Calculator' do
   it 'should evaluate multiple levels of parentheses' do
     expect_expr('2*(1/(1+3))').to eq(0.5)
   end  
-
 end # describe
 # End of file
-

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.5.02'.freeze
+  Version = '0.5.03'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

data/lib/rley/gfg/grm_flow_graph.rb

@@ -284,7 +284,7 @@ module Rley # This module is used as a namespace
       # from the start symbol to the start node .N
       def mark_unreachable_symbols()
         # Mark all non-terminals as unreachable
-        start_vertex_for.values.each do |a_vertex|
+        start_vertex_for.each_value do |a_vertex|
           a_vertex.non_terminal.unreachable = true
         end
 

data/lib/rley/parser/cst_builder.rb

@@ -13,7 +13,6 @@ module Rley # This module is used as a namespace
     # (say, a parse tree) from simpler objects (terminal and non-terminal
     # nodes) and using a step by step approach.
     class CSTBuilder < ParseTreeBuilder
-
       protected
       
       # Method to override
@@ -37,9 +36,9 @@ module Rley # This module is used as a namespace
       # Factory method for creating a parent node object.
       # @param aProduction [Production] Production rule
       # @param aRange [Range] Range of tokens matched by the rule
-      # @param theTokens [Array] The input tokens
+      # @param _tokens [Array] The input tokens
       # @param theChildren [Array] Children nodes (one per rhs symbol)
-      def new_parent_node(aProduction, aRange, theTokens, theChildren)
+      def new_parent_node(aProduction, aRange, _tokens, theChildren)
         node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
         theChildren.reverse_each { |child| node.add_subnode(child) }
         return node

data/lib/rley/parser/parse_forest_factory.rb

@@ -6,12 +6,11 @@ module Rley # This module is used as a namespace
     # Utility class that helps to create a ParseForest from
     # a given Parsing object.
     class ParseForestFactory < ParseRepCreator
-
       protected
 
       # Create a Builder, that is, an object
       # that will create piece by piece the forest
-      def builder(aParseResult, aBuilder = nil)
+      def builder(aParseResult, _builder = nil)
         ParseForestBuilder.new(aParseResult.tokens)
       end
     end # class

data/lib/rley/parser/parse_tree_builder.rb

@@ -96,10 +96,10 @@ module Rley # This module is used as a namespace
 
       # Handler for visit events for ParseEntry matching .N pattern
       # @param anEvent [Symbol] Kind of visit event. Should be: :visit
-      # @param anEntry [ParseEntry] The entry being visited
-      # @param anIndex [anIndex] The token index at end of anEntry
-      def process_start_entry(anEvent, anEntry, anIndex)
-        raise NotImplementedError unless [:visit, :revisit].include?(anEvent)
+      # @param _entry [ParseEntry] The entry being visited
+      # @param _index [Integer] The token index at end of anEntry
+      def process_start_entry(anEvent, _entry, _index)
+        raise NotImplementedError unless %I[visit revisit].include?(anEvent)
       end
 
       # Handler for visit events for ParseEntry matching N => alpha* . beta*
@@ -130,7 +130,7 @@ module Rley # This module is used as a namespace
       # @param anEntry [ParseEntry] Entry matching (pattern: N => alpha* .)
       # @param anIndex [anIndex] The token index at end of anEntry
       def process_exit_entry(anEntry, anIndex)
-        production =  anEntry.vertex.dotted_item.production
+        production = anEntry.vertex.dotted_item.production
         count_rhs = production.rhs.members.size
         init_TOS_children(count_rhs) # Create placeholders for children
         build_terminal(anEntry, anIndex) if terminal_before_dot?(anEntry)
@@ -142,20 +142,18 @@ module Rley # This module is used as a namespace
         build_terminal(anEntry, anIndex) if terminal_before_dot?(anEntry)
       end
 
-
-
       # @param anEntry [ParseEntry] Entry matching (pattern: N => . alpha)
-      # @param anIndex [anIndex] The token index at end of anEntry
-      def process_entry_entry(anEntry, anIndex)
+      # @param anIndex [_index] The token index at end of anEntry
+      def process_entry_entry(anEntry, _index)
         dotted_item = anEntry.vertex.dotted_item
         rule = dotted_item.production
         previous_tos = stack.pop
         non_terminal = entry2nonterm(anEntry)
         # For debugging purposes
         raise StandardError if previous_tos.symbol != non_terminal
-        
+
         new_node = new_parent_node(rule, previous_tos.range,
-                                     tokens, previous_tos.children)
+                                   tokens, previous_tos.children)
         if stack.empty?
           @result = create_tree(new_node)
         else
@@ -196,13 +194,12 @@ module Rley # This module is used as a namespace
         token = tokens[token_position]
         prod = anEntry.vertex.dotted_item.production
         term_node = new_leaf_node(prod, term_symbol, token_position, token)
-        
+
         # Second make it a child of TOS...
         pos = anEntry.vertex.dotted_item.prev_position # pos. in rhs of rule
         place_TOS_child(term_node, pos)
       end
 
-
       # Place the given node object as one of the children of the TOS
       # (TOS = Top Of Stack).
       # Each child has a position that is dictated by the position of the
@@ -217,7 +214,7 @@ module Rley # This module is used as a namespace
       def place_TOS_child(aNode, aRHSPos)
         if aRHSPos.nil?
           # Retrieve index of most rightmost nil child...
-          pos = tos.children.rindex { |child| child.nil? }
+          pos = tos.children.rindex(&:nil?)
           raise StandardError, 'Internal error' if pos.nil?
         else
           pos = aRHSPos
@@ -225,14 +222,14 @@ module Rley # This module is used as a namespace
 
         tos.children[pos] = aNode
       end
-      
+
       # Retrieve non-terminal symbol of given parse entry
       def entry2nonterm(anEntry)
         case anEntry.vertex
-        when GFG::StartVertex, GFG::EndVertex
-          non_terminal = anEntry.vertex.non_terminal
-        when GFG::ItemVertex
-          non_terminal = anEntry.vertex.lhs
+          when GFG::StartVertex, GFG::EndVertex
+            non_terminal = anEntry.vertex.non_terminal
+          when GFG::ItemVertex
+            non_terminal = anEntry.vertex.lhs
         end
 
         return non_terminal

data/lib/rley/parser/parse_tree_factory.rb

@@ -7,7 +7,6 @@ module Rley # This module is used as a namespace
     # Utility class that helps to create a ParseTree from
     # a given Parsing object.
     class ParseTreeFactory < ParseRepCreator
-
       protected
 
       # Create a Builder, that is, an object

data/lib/rley/parser/parse_walker_factory.rb

@@ -266,7 +266,7 @@ module Rley # This module is used as a namespace
           (antecd.origin == tos.origin) && tos_dotted_item.successor_of?(item)
         end
 
-        new_entry = aContext.curr_entry unless new_entry
+        new_entry ||= aContext.curr_entry
 
         # puts "Pop from return stack matching entry #{new_entry}"
         return new_entry

data/lib/rley/syntax/grammar.rb

@@ -31,7 +31,7 @@ module Rley # This module is used as a namespace
         @symbols = []
         @name2symbol = {}
         valid_productions = validate_productions(theProductions)
-        valid_productions.each do |prod| 
+        valid_productions.each do |prod|
           add_production(prod)
           name_production(prod)
         end
@@ -68,21 +68,23 @@ module Rley # This module is used as a namespace
 
         aProduction.rhs.each { |symb| add_symbol(symb) }
       end
-      
+
+      # If the production is anonymous, then assign it
+      # a default name
       def name_production(aProduction)
-        if aProduction.name.nil?
-          index = rules.find_index(aProduction)
-          prefix = aProduction.lhs.name.dup
-          previous = index.zero? ? nil : rules[index - 1]
-          if previous.nil? || previous.lhs != aProduction.lhs
-            suffix = '[0]'
-          else
-            prev_serial = previous.name.match(/\[(\d+)\]$/)
-            suffix = "[#{prev_serial[1].to_i + 1}]"   
-          end
-          
-          aProduction.name = prefix + suffix
+        return unless aProduction.name.nil?
+
+        index = rules.find_index(aProduction)
+        prefix = aProduction.lhs.name.dup
+        previous = index.zero? ? nil : rules[index - 1]
+        if previous.nil? || previous.lhs != aProduction.lhs
+          suffix = '[0]'
+        else
+          prev_serial = previous.name.match(/\[(\d+)\]$/)
+          suffix = "[#{prev_serial[1].to_i + 1}]"
         end
+
+        aProduction.name = prefix + suffix
       end
 
       # Perform some check of the grammar.
@@ -141,7 +143,7 @@ module Rley # This module is used as a namespace
             could_mark_nterm_generative(a_rule)
           end
           break if prev_marked.size == curr_marked.size
-        end 
+        end
 
         # The nonterminals that are not marked yet are non-generative
         non_terminals.each do |nterm|

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -80,7 +80,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should have one or more entry edges per start vertex' do
-          subject.start_vertex_for.values.each do |a_start|
+          subject.start_vertex_for.each_value do |a_start|
             expect(a_start.edges.size >= 1).to be_truthy
             a_start.edges.each do |edge|
               expect(edge.successor.dotted_item.at_start?).to be_truthy

data/spec/rley/parser/ast_builder_spec.rb

@@ -12,7 +12,6 @@ require_relative '../support/grammar_arr_int_helper'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
-
     ArrayNode = Struct.new(:children) do
       def initialize()
         super
@@ -32,7 +31,7 @@ module Rley # This module is used as a namespace
       end
 
       def interpret()
-        self.value
+        value
       end
     end
 
@@ -44,7 +43,6 @@ module Rley # This module is used as a namespace
     # (say, a parse tree) from simpler objects (terminal and non-terminal
     # nodes) and using a step by step approach.
     class ASTBuilder < ParseTreeBuilder
-
       protected
 
       # Method to override
@@ -76,53 +74,54 @@ module Rley # This module is used as a namespace
       # @param theChildren [Array] Children nodes (one per rhs symbol)
       def new_parent_node(aProduction, aRange, theTokens, theChildren)
         node = case aProduction.name
-          when 'P[0]'
-            reduce_P_0(aRange, theTokens, theChildren)
+                 when 'P[0]'
+                   reduce_P_0(aRange, theTokens, theChildren)
 
-          when 'arr[0]'
-            reduce_arr_0(aRange, theTokens, theChildren)
+                 when 'arr[0]'
+                   reduce_arr_0(aRange, theTokens, theChildren)
 
-          when 'sequence[0]'
-            reduce_sequence_0(aRange, theTokens, theChildren)
+                 when 'sequence[0]'
+                   reduce_sequence_0(aRange, theTokens, theChildren)
 
-          when 'sequence[1]'
-            reduce_sequence_1(aRange, theTokens, theChildren)
+                 when 'sequence[1]'
+                   reduce_sequence_1(aRange, theTokens, theChildren)
 
-          when 'list[0]'
-            reduce_list_0(aRange, theTokens, theChildren)
+                 when 'list[0]'
+                   reduce_list_0(aRange, theTokens, theChildren)
 
-          when 'list[1]'
-            reduce_list_1(aRange, theTokens, theChildren)
-          else
-            raise StandardError, "Don't know production #{aProduction.name}"
-        end
+                 when 'list[1]'
+                   reduce_list_1(aRange, theTokens, theChildren)
+                 else
+                  err_msg = "Don't know production #{aProduction.name}"
+                  raise StandardError, err_msg
+               end
 
         return node
       end
 
-      def reduce_P_0(aRange, theTokens, theChildren)
+      def reduce_P_0(_range, _tokens, theChildren)
         return theChildren[0]
       end
 
-      def reduce_arr_0(aRange, theTokens, theChildren)
+      def reduce_arr_0(_range, _tokens, theChildren)
         return theChildren[1]
       end
 
-      def reduce_sequence_0(aRange, theTokens, theChildren)
+      def reduce_sequence_0(_range, _tokens, theChildren)
         return theChildren[0]
       end
 
-      def reduce_sequence_1(aRange, theTokens, theChildren)
+      def reduce_sequence_1(_range, _tokens, _children)
         return ArrayNode.new
       end
 
-      def reduce_list_0(aRange, theTokens, theChildren)
+      def reduce_list_0(_range, _tokens, theChildren)
         node = theChildren[0]
         node.children << theChildren[2]
         return node
       end
 
-      def reduce_list_1(aRange, theTokens, theChildren)
+      def reduce_list_1(_range, _tokens, theChildren)
         node = ArrayNode.new
         node.children << theChildren[0]
         return node
@@ -163,12 +162,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.receive_event(*event)
         end
       end
+
       def get_stack(aBuilder)
         return aBuilder.send(:stack)
       end
 
       def create_range(low, high)
-        return Tokens::TokenRange.new({low: low, high: high })
+        return Tokens::TokenRange.new(low: low, high: high)
       end
 
       context 'Initialization:' do
@@ -190,7 +190,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Parse tree construction (no null symbol):' do
-
         def next_event(expectation)
           event = @walker.next
           (ev_type, entry, index) = event
@@ -244,9 +243,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           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        
+          expect(stack.last.children).to be_nil
         end
-        
+
         it 'should build a tree for an empty array' do
           stack = get_stack(subject)
 
@@ -317,7 +316,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event('visit list. | 1 2')
           expect(stack.size).to eq(6)
-          # stack: [P[0, 7], arr[0, 7], sequence[1, 6], list[1, 6], list[1, 4], list[1, 2]
+          # stack: [P[0, 7], arr[0, 7], sequence[1, 6], list[1, 6],
+          #        list[1, 4], list[1, 2]
           expect(stack.last.range).to eq(create_range(1, 2))
           expect(stack.last.children).to be_nil
 

data/spec/rley/parser/cst_builder_spec.rb

@@ -48,7 +48,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       def create_range(low, high)
-        return Tokens::TokenRange.new({low: low, high: high })
+        return Tokens::TokenRange.new(low: low, high: high)
       end
 
       context 'Initialization:' do
@@ -340,8 +340,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         # The visit events were generated with the following snippets:
         # 13.times do
-          # event = @walker.next
-          # subject.receive_event(*event)
+        #   event = @walker.next
+        #   subject.receive_event(*event)
         # end
         # The events are:
         # Event: visit P. | 0 2

data/spec/rley/parser/error_reason_spec.rb

@@ -80,10 +80,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Provided services:' do
         it 'should emit a message' do
-          text = <<MSG_END
+          text = <<MESSAGE_END
 Syntax error at or near token 4 >>>-<<<
 Expected one of: ['PLUS', 'LPAREN'], found a 'MINUS' instead.
-MSG_END
+MESSAGE_END
           expect(subject.to_s).to eq(text.chomp)
           expect(subject.message).to eq(text.chomp)
         end
@@ -111,10 +111,10 @@ MSG_END
 
       context 'Provided services:' do
         it 'should emit a message' do
-          text = <<MSG_END
+          text = <<MESSAGE_END
 Premature end of input after '+' at position 4
 Expected one of: ['INT', 'LPAREN'].
-MSG_END
+MESSAGE_END
           expect(subject.to_s).to eq(text.chomp)
           expect(subject.message).to eq(text.chomp)
         end

data/spec/rley/support/grammar_arr_int_helper.rb

@@ -13,10 +13,10 @@ module GrammarArrIntHelper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('[', ']', ',', 'integer')
       rule 'P' => 'arr'
-      rule 'arr' => %w( [ sequence ] )
+      rule 'arr' => %w([ sequence ])
       rule 'sequence' => ['list']
       rule 'sequence' => []
-      rule 'list' => %w[list , integer]   # Right-recursive rule
+      rule 'list' => %w[list , integer] # Right-recursive rule
       rule 'list' => 'integer'
     end
     builder
@@ -27,7 +27,7 @@ module GrammarArrIntHelper
     tokens = []
     scanner = StringScanner.new(aText)
 
-    until scanner.eos? do
+    until scanner.eos?
       scanner.skip(/\s+/)
       lexeme = scanner.scan(/[\[,\]]/)
       if lexeme