rley 0.7.07 → 0.7.08

data/lib/rley/parser/parse_entry.rb

@@ -32,7 +32,7 @@ module Rley # This module is used as a namespace
       # Returns a string containing a human-readable representation of the
       # production.
       # @return [String]
-      def inspect()
+      def inspect
         result = selfie
         result << ' @antecedents=['
         antecedents.each do |antec|
@@ -40,7 +40,7 @@ module Rley # This module is used as a namespace
         end
         result << ']>'
 
-        return result
+        result
       end
 
       # Add a link to an antecedent parse entry
@@ -53,56 +53,55 @@ module Rley # This module is used as a namespace
       def ==(other)
         return true if equal? other
 
-        result = (vertex == other.vertex) && (origin == other.origin)
-        return result
+        (vertex == other.vertex) && (origin == other.origin)
       end
-      
+
       def hash
-        @hash ||= "#{vertex.object_id}-#{origin}".hash
+        @hash ||= (vertex.oid_str + "-#{origin}").hash
       end
 
       # Returns true iff the vertex is a start vertex (i.e. of the form: .X)
-      def start_entry?()
-        return vertex.kind_of?(GFG::StartVertex)
+      def start_entry?
+        vertex.kind_of?(GFG::StartVertex)
       end
 
       # Returns true iff the vertex is at the start of rhs
       # (i.e. of the form: X => .Y
-      def entry_entry?()
+      def entry_entry?
         return false unless vertex.kind_of?(GFG::ItemVertex)
 
-        return vertex.dotted_item.at_start?
+        vertex.dotted_item.at_start?
       end
 
       # Returns true iff the vertex corresponds to a dotted item
       # X => Y
       def dotted_entry?
-        return vertex.kind_of?(GFG::ItemVertex)
+        vertex.kind_of?(GFG::ItemVertex)
       end
 
       # Returns true iff the vertex is at end of rhs (i.e. of the form: X => Y.)
-      def exit_entry?()
-        return vertex.complete?
+      def exit_entry?
+        vertex.complete?
       end
 
       # Returns true iff the vertex is an end vertex (i.e. of the form: X.)
-      def end_entry?()
-        return vertex.kind_of?(GFG::EndVertex)
+      def end_entry?
+        vertex.kind_of?(GFG::EndVertex)
       end
 
       # Return the symbol before the dot (if any)
-      def prev_symbol()
-        return vertex.prev_symbol
+      def prev_symbol
+        vertex.prev_symbol
       end
 
       # Return the symbol after the dot (if any)
-      def next_symbol()
-        return vertex.next_symbol
+      def next_symbol
+        vertex.next_symbol
       end
 
       # Return true if the entry has no antecedent entry
-      def orphan?()
-        return antecedents.empty?
+      def orphan?
+        antecedents.empty?
       end
 
 =begin
@@ -117,11 +116,6 @@ module Rley # This module is used as a namespace
         return vertex.predicted_item?
       end
 
-      # Next expected symbol in the production
-      def next_symbol()
-        return vertex.next_symbol
-      end
-
       # Does this parse state have the 'other' as successor?
       def precedes?(other)
         return false if self == other
@@ -145,21 +139,21 @@ module Rley # This module is used as a namespace
       # The format of the text representation is
       # "format of dotted rule" + " | " + origin
       # @return [String]
-      def to_s()
-        return vertex.label + " | #{origin}"
+      def to_s
+        vertex.label + " | #{origin}"
       end
 
       protected
 
       # Returns a human-readable and partial representation of itself.
       # @return [String]
-      def selfie()
+      def selfie
         result = +"#<#{self.class.name}:#{object_id}"
         result << " @vertex=<#{vertex.class.name}:#{vertex.object_id}"
         result << " label=#{vertex.label}>"
         result << " @origin=#{origin}"
 
-        return result
+        result
       end
 
       private
@@ -169,7 +163,7 @@ module Rley # This module is used as a namespace
       def valid_vertex(aVertex)
         raise StandardError, 'GFG vertex cannot be nil' if aVertex.nil?
 
-        return aVertex
+        aVertex
       end
     end # class
   end # module

data/lib/rley/parser/parse_entry_set.rb

@@ -16,44 +16,45 @@ module Rley # This module is used as a namespace
 
       # @return [Array<ParseEntry>] The array of parse entries
       attr_reader :entries
-      
+
       # @return [Hash] A Hash with pairs { hash of ParseEntry => ParseEntry }
-      attr_reader :membership      
+      attr_reader :membership
 
       # Constructor.
-      def initialize()
+      def initialize
         @entries = []
         @membership = {}
         @entries4term = Hash.new { |hash, key| hash[key] = [] }
         @entries4n_term = Hash.new { |hash, key| hash[key] = [] }
       end
-      
-      # Returns a string containing a human-readable representation of the 
+
+      # Returns a string containing a human-readable representation of the
       # set of parse entries.
       # @return [String]
-      def inspect()
+      def inspect
         result = +"#<#{self.class.name}:#{object_id}"
         result << ' @entries=['
         entries.each { |e| result << e.inspect }
         result << ']>'
-        return result
+
+        result
       end
 
       # Access the entry at given position
       def [](index)
-        return entries[index]
+        entries[index]
       end
 
       # Returns a Hash with pairs of the form:
       #   terminal symbol => [ parse entry expecting the terminal ]
       def entries4term(aTerminal)
-        return @entries4term.fetch(aTerminal, [])
+        @entries4term.fetch(aTerminal, [])
       end
 
       # Returns a Hash with pairs of the form:
       #   non terminal symbol => [ parse entry expecting the non-terminal ]
       def entries4n_term(aNonTerminal)
-        return @entries4n_term.fetch(aNonTerminal, [])
+        @entries4n_term.fetch(aNonTerminal, [])
       end
 
       # Append the given entry (if it isn't yet in the set)
@@ -71,11 +72,11 @@ module Rley # This module is used as a namespace
           result = anEntry
         end
 
-        return result
+        result
       end
 
       # Return an Array of Arrays of ambiguous parse entries.
-      def ambiguities()
+      def ambiguities
         complete_entries = entries.select(&:exit_entry?)
         return [] if complete_entries.size <= 1
 
@@ -90,20 +91,22 @@ 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
 
       # 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
         return @entries4term.keys
       end
-      
+
       def count_edges
+        # rubocop: disable Lint/UselessAssignment
         entries.reduce(0) do |sub_result, entry|
           sub_result += entry.vertex.edges.size
         end
       end
+      # rubocop: enable Lint/UselessAssignment
 
       private
 

data/lib/rley/parser/parse_entry_tracker.rb

@@ -40,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

@@ -18,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?
@@ -50,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

@@ -28,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
@@ -40,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

@@ -11,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)
@@ -36,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
@@ -47,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
@@ -83,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}"
@@ -91,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

@@ -21,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.
@@ -53,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?
@@ -60,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
@@ -70,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?
 
@@ -84,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
 
@@ -101,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
@@ -116,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?
@@ -156,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
@@ -170,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
-
-        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
@@ -205,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
@@ -231,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)
@@ -243,7 +238,7 @@ module Rley # This module is used as a namespace
         bp.antecedent_index = 0
         aContext.backtrack_points << bp
         # puts "Backtrack size after addition #{aContext.backtrack_points.size}"
-        return bp
+        bp
       end
 
       def use_backtrack_point(aContext)
@@ -263,7 +258,7 @@ module Rley # This module is used as a namespace
         # 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
@@ -287,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