rley 0.7.03 → 0.7.08

data/lib/rley/parser/parse_entry_tracker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     # Helper class that keeps track of the parse entries used
@@ -38,16 +40,16 @@ module Rley # This module is used as a namespace
       end
 
       # The dotted item for the current parse entry.
-      def curr_dotted_item()
+      def curr_dotted_item
         parse_entry.dotted_rule
       end
 
-      def symbol_on_left()
-        return curr_dotted_item.prev_symbol
+      def symbol_on_left
+        curr_dotted_item.prev_symbol
       end
 
       # Notification that one begins with the previous entry set
-      def to_prev_entry_set()
+      def to_prev_entry_set
         self.entry_set_index = entry_set_index - 1
       end
     end # class

data/lib/rley/parser/parse_state.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     class ParseState
@@ -16,26 +18,24 @@ module Rley # This module is used as a namespace
       def ==(other)
         return true if equal?(other)
 
-        result = (dotted_rule == other.dotted_rule) &&
-                 (origin == other.origin)
-
-        return result
+        (dotted_rule == other.dotted_rule) &&
+          (origin == other.origin)
       end
 
       # Returns true if the dot is at the end of the rhs of the production.
       # In other words, the complete rhs matches the input.
-      def complete?()
-        return dotted_rule.reduce_item?
+      def complete?
+        dotted_rule.reduce_item?
       end
 
       # Returns true if the dot is at the start of the rhs of the production.
-      def predicted?()
-        return dotted_rule.predicted_item?
+      def predicted?
+        dotted_rule.predicted_item?
       end
 
       # Next expected symbol in the production
-      def next_symbol()
-        return dotted_rule.next_symbol
+      def next_symbol
+        dotted_rule.next_symbol
       end
 
       # Does this parse state have the 'other' as successor?
@@ -48,31 +48,28 @@ module Rley # This module is used as a namespace
         return false unless dotted_rule.production == other_production
 
         prev_position = other.dotted_rule.prev_position
-        result = if prev_position.nil?
-                   false
-                 else
-                   dotted_rule.position == prev_position
-                 end
-
-        return result
+        if prev_position.nil?
+          false
+        else
+          dotted_rule.position == prev_position
+        end
       end
 
       # Give a String representation of itself.
       # The format of the text representation is
       # "format of dotted rule" + " | " + origin
       # @return [String]
-      def to_s()
-        return dotted_rule.to_s + " | #{origin}"
+      def to_s
+        dotted_rule.to_s + " | #{origin}"
       end
 
-
       private
 
       # Return the validated dotted item(rule)
       def valid_dotted_rule(aDottedRule)
         raise StandardError, 'Dotted item cannot be nil' if aDottedRule.nil?
 
-        return aDottedRule
+        aDottedRule
       end
     end # class
   end # module

data/lib/rley/parser/parse_state_tracker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     # Helper class that keeps track of the parse states used
@@ -26,7 +28,7 @@ module Rley # This module is used as a namespace
       # Write accessor. Set the given parse state as the current one.
       def parse_state=(aParseState)
         raise StandardError, 'Nil parse state' if aParseState.nil?
-        
+
         @parse_state = aParseState
         processed_states[parse_state] = true
       end
@@ -38,16 +40,16 @@ module Rley # This module is used as a namespace
       end
 
       # The dotted item for the current parse state.
-      def curr_dotted_item()
+      def curr_dotted_item
         parse_state.dotted_rule
       end
 
-      def symbol_on_left()
+      def symbol_on_left
         return curr_dotted_item.prev_symbol
       end
 
       # Notification that one begins with the previous state set
-      def to_prev_state_set()
+      def to_prev_state_set
         self.state_set_index = state_set_index - 1
       end
     end # class

data/lib/rley/parser/parse_tracer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ostruct'
 
 module Rley # This module is used as a namespace
@@ -9,9 +11,7 @@ module Rley # This module is used as a namespace
 
       # The trace level
       attr_reader(:level)
-
       attr_reader(:lexemes)
-
       attr_reader(:col_width)
 
       def initialize(aTraceLevel, anIO, aTokenSequence)
@@ -34,8 +34,8 @@ module Rley # This module is used as a namespace
       def trace_scanning(aStatesetIndex, aParseState)
         return unless level
 
-        scan_picture = '[' + '-' * (col_width - 1) + ']'
-        org = OpenStruct.new(origin: aStatesetIndex - 1, 
+        scan_picture = "[#{'-' * (col_width - 1)}]"
+        org = OpenStruct.new(origin: aStatesetIndex - 1,
                              dotted_rule: aParseState.dotted_rule)
         trace_diagram(aStatesetIndex, org, scan_picture)
       end
@@ -45,35 +45,36 @@ module Rley # This module is used as a namespace
 
         trace_diagram(aStatesetIndex, aParseState, '>')
       end
-      
+
       def trace_completion(aStatesetIndex, aParseState)
         return unless level
 
-        if aStatesetIndex == lexemes.size && aParseState.origin.zero? && 
+        if aStatesetIndex == lexemes.size && aParseState.origin.zero? &&
            aParseState.complete?
           picture = '=' * (col_width * lexemes.size - 1)
         else
           count = col_width * (aStatesetIndex - aParseState.origin) - 1
           picture = '-' * count
         end
-        completion_picture = '[' + picture + (aParseState.complete? ? ']' : '>')
+        completion_picture = "[#{picture}#{aParseState.complete? ? ']' : '>'}"
         trace_diagram(aStatesetIndex, aParseState, completion_picture)
       end
 
       private
 
-      def emit_tokens()
+      def emit_tokens
         literals = lexemes.map { |lx| "'#{lx}'" }
-        print_if 1, '[' + literals.join(', ') + "]\n"
+        print_if 1, "[#{literals.join(', ')}]\n"
       end
 
-      def emit_heading()
+      def emit_heading
         longest = lexemes.map(&:length).max
         @col_width = longest + 3
         headers = lexemes.map { |l| l.center(col_width - 1, ' ').to_s }
-        print_if 1, '|.' + headers.join('.') + ".|\n"
+        print_if 1, "|.#{headers.join('.')}.|\n"
       end
 
+      # rubocop: disable Style/StringConcatenation
       def padding(aStatesetIndex, aParseState, aPicture)
         l_pad_pattern = '.' + ' ' * (col_width - 1)
         left_padding =  l_pad_pattern * [0, aParseState.origin].max
@@ -81,6 +82,7 @@ module Rley # This module is used as a namespace
         right_padding = r_pad_pattern * (lexemes.size - aStatesetIndex)
         return left_padding + aPicture + right_padding
       end
+      # rubocop: enable Style/StringConcatenation
 
       def parse_state_str(aStatesetIndex, aParseState)
         "[#{aParseState.origin}:#{aStatesetIndex}] #{aParseState.dotted_rule}"
@@ -89,10 +91,10 @@ module Rley # This module is used as a namespace
       def trace_diagram(aStatesetIndex, aParseState, aPicture)
         diagram = padding(aStatesetIndex, aParseState, aPicture)
         prefix = '|'
-        suffix = '| ' + parse_state_str(aStatesetIndex, aParseState)
+        suffix = "| #{parse_state_str(aStatesetIndex, aParseState)}"
         trace = prefix + diagram + suffix
 
-        print_if 1, trace + "\n"
+        print_if 1, "#{trace}\n"
       end
     end # class
   end # module

data/lib/rley/parser/parse_walker_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require_relative '../gfg/call_edge'
 require_relative '../gfg/scan_edge'
@@ -19,16 +21,13 @@ 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
 
     WalkerBacktrackpoint = Struct.new(
       :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.
@@ -51,6 +50,7 @@ module Rley # This module is used as a namespace
       # @param lazyWalk [Boolean] if true then take some shortcut in re-visits.
       # @return [Enumerator] yields visit events when walking over the
       #   parse result
+      # rubocop: disable Style/OptionalBooleanParameter
       def build_walker(acceptingEntry, maxIndex, lazyWalk = false)
         msg = 'Internal error: nil entry argument'
         raise StandardError, msg if acceptingEntry.nil?
@@ -58,7 +58,7 @@ module Rley # This module is used as a namespace
         # Local context for the enumerator
         ctx = init_context(acceptingEntry, maxIndex, lazyWalk)
 
-        walker = Enumerator.new do |receiver| # 'receiver' is a Yielder
+        Enumerator.new do |receiver| # 'receiver' is a Yielder
           # At this point: current entry == accepting entry
 
           loop do
@@ -68,7 +68,7 @@ module Rley # This module is used as a namespace
             if ctx.curr_entry.orphan? # No antecedent?...
               msg_prefix = "No antecedent for #{ctx.curr_entry}"
               msg_suffix = "at rank #{ctx.entry_set_index}"
-              err_msg = msg_prefix + ' ' + msg_suffix
+              err_msg = "#{msg_prefix} #{msg_suffix}"
               raise StandardError, err_msg unless ctx.curr_entry.start_entry?
               break if ctx.backtrack_points.empty?
 
@@ -82,9 +82,8 @@ module Rley # This module is used as a namespace
             ctx.curr_entry = result.last
           end
         end
-
-        return walker
       end
+      # rubocop: enable Style/OptionalBooleanParameter
 
       private
 
@@ -99,12 +98,12 @@ module Rley # This module is used as a namespace
         context.backtrack_points = []
         context.lazy_walk = lazyWalk
 
-        return context
+        context
       end
 
       # Initialize the non-terminal to start entry mapping
-      def init_nterm2start()
-        h = Hash.new do |hsh, defval|
+      def init_nterm2start
+        Hash.new do |hsh, defval|
           entry, index = defval
           nonterm = entry.vertex.non_terminal
           if hsh.include? nonterm
@@ -114,11 +113,10 @@ module Rley # This module is used as a namespace
             hsh[nonterm] = { index => entry }
           end
         end
-
-        return h
       end
 
       # [event, entry, index, vertex]
+      # rubocop: disable Lint/DuplicateBranch
       def visit_entry(anEntry, aContext)
         index = aContext.entry_set_index
         aContext.nterm2start[[anEntry, index]] if anEntry.start_entry?
@@ -154,11 +152,12 @@ module Rley # This module is used as a namespace
           event = [:visit, anEntry, index]
         end
 
-        return event
+        event
       end
+      # rubocop: enable Lint/DuplicateBranch
 
       def detect_scan_edge(_ctx)
-        return nil unless aContext.curr_entry.dotted_entry?
+        nil unless aContext.curr_entry.dotted_entry?
       end
 
       # Given the current entry from context object
@@ -168,13 +167,11 @@ module Rley # This module is used as a namespace
         entries = []
         return entries if aContext.curr_entry.orphan?
 
-        entries = if aContext.curr_entry.antecedents.size == 1
-                    antecedent_of(aContext)
-                  else
-                    select_antecedent(aContext)
-                  end
-
-        return entries
+        if aContext.curr_entry.antecedents.size == 1
+          antecedent_of(aContext)
+        else
+          select_antecedent(aContext)
+        end
       end
 
       # Handle the case of an entry having one antecedent only
@@ -203,7 +200,7 @@ module Rley # This module is used as a namespace
           raise NotImplementedError, "edge is a #{traversed_edge.class}"
         end
 
-        return events
+        events
       end
 
       # Handle the case of an entry having multiple antecedents
@@ -211,6 +208,7 @@ module Rley # This module is used as a namespace
         case aContext.curr_entry.vertex
           when GFG::EndVertex
             # puts "Add backtrack point stack #{aContext.curr_entry}"
+            # aContext.curr_entry.antecedents.each { |antec| puts "\t#{antec}" }
             bp = add_backtrack_point(aContext)
             new_entry = bp.visitee.antecedents[bp.antecedent_index]
 
@@ -228,7 +226,7 @@ module Rley # This module is used as a namespace
             raise StandardError, 'Internal error'
         end
 
-        return [new_entry]
+        [new_entry]
       end
 
       def add_backtrack_point(aContext)
@@ -239,8 +237,8 @@ module Rley # This module is used as a namespace
         bp.visitee = aContext.curr_entry
         bp.antecedent_index = 0
         aContext.backtrack_points << bp
-
-        return bp
+        # puts "Backtrack size after addition #{aContext.backtrack_points.size}"
+        bp
       end
 
       def use_backtrack_point(aContext)
@@ -257,9 +255,10 @@ module Rley # This module is used as a namespace
           aContext.backtrack_points.pop
         end
         # puts "Backtracking to #{bp.visitee}"
+        # puts "Backtrack size after backtracking #{aContext.backtrack_points.size}"
 
         # Emit a backtrack event
-        return [:backtrack, bp.visitee, aContext.entry_set_index]
+        [:backtrack, bp.visitee, aContext.entry_set_index]
       end
 
       # From the antecedent of the current parse entry
@@ -283,7 +282,7 @@ module Rley # This module is used as a namespace
         new_entry ||= aContext.curr_entry
 
         # puts "Pop from return stack matching entry #{new_entry}"
-        return new_entry
+        new_entry
       end
     end # class
   end # module

data/lib/rley/parser/state_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable' # Delegation
 
 module Rley # This module is used as a namespace
@@ -9,7 +11,7 @@ module Rley # This module is used as a namespace
       # The set of parse states
       attr_reader(:states)
 
-      def initialize()
+      def initialize
         @states = []
       end
 
@@ -32,7 +34,7 @@ module Rley # This module is used as a namespace
       # @param aSymbol [GrmSymbol] the expected symbol
       #   (=on the right of the dot)
       def states_expecting(aSymbol)
-        return states.select { |s| s.dotted_rule.next_symbol == aSymbol }
+        states.select { |s| s.dotted_rule.next_symbol == aSymbol }
       end
 
       # The list of complete ParseState that have the given non-terminal
@@ -45,7 +47,7 @@ module Rley # This module is used as a namespace
 
       # The list of ParseState that involve the given production
       def states_for(aProduction)
-        return states.select { |s| s.dotted_rule.production == aProduction }
+        states.select { |s| s.dotted_rule.production == aProduction }
       end
 
       # Retrieve the parse state that is the predecessor of the given one.
@@ -53,23 +55,22 @@ module Rley # This module is used as a namespace
         dotted_rule = aPState.dotted_rule
         raise StandardError, aPState.to_s unless dotted_rule.prev_position
 
-        candidate = states.find { |s| s.precedes?(aPState) }
-        return candidate
+        states.find { |s| s.precedes?(aPState) }
       end
 
       # The list of distinct expected terminal symbols. An expected symbol
       # is on the left of a dot in a parse state of the parse set.
-      def expected_terminals()
+      def expected_terminals
         expecting_terminals = states.select do |s|
           s.dotted_rule.next_symbol.kind_of?(Rley::Syntax::Terminal)
         end
 
         terminals = expecting_terminals.map { |s| s.dotted_rule.next_symbol }
-        return terminals.uniq
+        terminals.uniq
       end
 
       # Return an Array of Arrays of ambiguous parse states.
-      def ambiguities()
+      def ambiguities
         complete_states = states.select(&:complete?)
         return [] if complete_states.size <= 1
 
@@ -84,14 +85,14 @@ module Rley # This module is used as a namespace
           ambiguous_groups << a_group if a_group.size > 1
         end
 
-        return ambiguous_groups
+        ambiguous_groups
       end
 
       private
 
       def include?(aState)
         # TODO: make it better than linear search
-        return states.include?(aState)
+        states.include?(aState)
       end
     end # class
   end # module