rley 0.3.04 → 0.3.05

data/lib/rley/parser/parse_state.rb

@@ -16,11 +16,8 @@ module Rley # This module is used as a namespace
       def ==(other)
         return true if object_id == other.object_id
 
-        if (dotted_rule == other.dotted_rule) && (origin == other.origin)
-          result = true
-        else
-          result = false
-        end
+        result = (dotted_rule == other.dotted_rule) && 
+                 (origin == other.origin)
 
         return result
       end
@@ -50,11 +47,11 @@ module Rley # This module is used as a namespace
         return false unless dotted_rule.production == other_production
 
         prev_position = other.dotted_rule.prev_position
-        if prev_position.nil?
-          result = false
-        else
-          result = dotted_rule.position == prev_position
-        end
+        result = if prev_position.nil?
+                   false
+                 else
+                   dotted_rule.position == prev_position
+                 end
 
         return result
       end
@@ -72,7 +69,7 @@ module Rley # This module is used as a namespace
 
       # Return the validated dotted item(rule)
       def valid_dotted_rule(aDottedRule)
-        fail StandardError, 'Dotted item cannot be nil' if aDottedRule.nil?
+        raise StandardError, 'Dotted item cannot be nil' if aDottedRule.nil?
 
         return aDottedRule
       end

data/lib/rley/parser/parse_state_tracker.rb

@@ -1,56 +1,56 @@
-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
-    # while a Parsing instance is constructing a parse tree.
-    class ParseStateTracker
-      # The index of the current state set
-      attr_reader(:state_set_index)
-      
-      # The current parse state
-      attr_reader(:parse_state)
-      
-      # The already processed states from current state set
-      attr_reader(:processed_states)      
-      
-      # Constructor. Refined variant of the inherited constructor.
-      def initialize(aStateSetIndex)
-        self.state_set_index = aStateSetIndex
-      end
-      
-      # Write accessor. Sets the value of the state set index
-      def state_set_index=(anIndex)
-        @state_set_index = anIndex
-        @processed_states = {}
-      end
-
-      # Write accessor. Set the given parse state as the current one.
-      def parse_state=(aParseState)
-        fail StandardError, 'Nil parse state' if aParseState.nil?
-        @parse_state = aParseState
-        processed_states[parse_state] = true
-      end
-      
-      # Take the first provided state that wasn't processed yet.
-      def select_state(theStates)
-        a_state = theStates.find { |st| !processed_states.include?(st) }
-        self.parse_state = a_state
-      end
-      
-      # The dotted item for the current parse state.
-      def curr_dotted_item()
-        parse_state.dotted_rule
-      end
-      
-      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()      
-        self.state_set_index = state_set_index - 1
-      end
-    end # class
-  end # module
-end # module
-
-# End of file
+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
+    # while a Parsing instance is constructing a parse tree.
+    class ParseStateTracker
+      # The index of the current state set
+      attr_reader(:state_set_index)
+
+      # The current parse state
+      attr_reader(:parse_state)
+
+      # The already processed states from current state set
+      attr_reader(:processed_states)
+
+      # Constructor. Refined variant of the inherited constructor.
+      def initialize(aStateSetIndex)
+        self.state_set_index = aStateSetIndex
+      end
+
+      # Write accessor. Sets the value of the state set index
+      def state_set_index=(anIndex)
+        @state_set_index = anIndex
+        @processed_states = {}
+      end
+
+      # 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
+
+      # Take the first provided state that wasn't processed yet.
+      def select_state(theStates)
+        a_state = theStates.find { |st| !processed_states.include?(st) }
+        self.parse_state = a_state
+      end
+
+      # The dotted item for the current parse state.
+      def curr_dotted_item()
+        parse_state.dotted_rule
+      end
+
+      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()
+        self.state_set_index = state_set_index - 1
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parser/parse_tracer.rb

@@ -49,7 +49,7 @@ module Rley # This module is used as a namespace
       def trace_completion(aStatesetIndex, aParseState)
         return unless level
 
-        if aStatesetIndex == lexemes.size && aParseState.origin == 0 && 
+        if aStatesetIndex == lexemes.size && aParseState.origin.zero? && 
            aParseState.complete?
           picture = '=' * (col_width * lexemes.size - 1)
         else
@@ -70,13 +70,13 @@ module Rley # This module is used as a namespace
       def emit_heading()
         longest = lexemes.map(&:length).max
         @col_width = longest + 3
-        headers = lexemes.map { |l| "#{l.center(col_width - 1, ' ')}" }
+        headers = lexemes.map { |l| l.center(col_width - 1, ' ').to_s }
         print_if 1, '|.' + headers.join('.') + ".|\n"
       end
 
       def padding(aStatesetIndex, aParseState, aPicture)
         l_pad_pattern = '.' + ' ' * (col_width - 1)
-        left_padding =  l_pad_pattern * ([0, aParseState.origin].max)
+        left_padding =  l_pad_pattern * [0, aParseState.origin].max
         r_pad_pattern = ' ' * (col_width - 1) + '.'
         right_padding = r_pad_pattern * (lexemes.size - aStatesetIndex)
         return left_padding + aPicture + right_padding

data/lib/rley/parser/parse_tree_builder.rb

@@ -49,7 +49,7 @@ module Rley # This module is used as a namespace
         curr_node = current_node
         unless curr_node.is_a?(PTree::NonTerminalNode)
           msg = "Current node isn't a non-terminal node #{curr_node.class}"
-          fail StandardError, msg
+          raise StandardError, msg
         end
         children = curr_node.children
         path_increment = [children.size - 1, children.last]
@@ -122,7 +122,7 @@ module Rley # This module is used as a namespace
         if curr_node.symbol != prod.lhs
           snapshot = root.to_string(0)
           msg = "Current node is a #{curr_node.symbol} instead of #{prod.lhs}."
-          fail StandardError, msg + "\n" + snapshot
+          raise StandardError, msg + "\n" + snapshot
         end
         self.range = aRange
         prod.rhs.each { |symb| add_node(symb, {}) }
@@ -153,20 +153,20 @@ module Rley # This module is used as a namespace
 
       def low_bound(aRange)
         result = case aRange
-          when Fixnum then aRange
-          when Hash then aRange[:low]
-          when PTree::TokenRange then aRange.low
-        end
+                   when Integer then aRange
+                   when Hash then aRange[:low]
+                   when PTree::TokenRange then aRange.low
+                 end
 
         return { low: result }
       end
 
       def high_bound(aRange)
         result = case aRange
-          when Fixnum then aRange
-          when Hash then aRange[:high]
-          when PTree::TokenRange then aRange.high
-        end
+                   when Integer then aRange
+                   when Hash then aRange[:high]
+                   when PTree::TokenRange then aRange.high
+                 end
 
         return { high: result }
       end

data/lib/rley/parser/parse_walker_factory.rb

@@ -9,16 +9,16 @@ require_relative '../gfg/start_vertex'
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     ParseWalkerContext = Struct.new(
-      :curr_entry,  # Parse entry currently being visited
-      :entry_set_index,  # Sigma set index of current parse entry
-      :visitees,  # The set of already visited parse entries
+      :curr_entry, # Parse entry currently being visited
+      :entry_set_index, # Sigma set index of current parse entry
+      :visitees, # The set of already visited parse entries
       :nterm2start, # A Hash non-terminal symbol => start entry
       :return_stack, # A stack of parse entries
       :backtrack_points
     )
 
     WalkerBacktrackpoint = Struct.new(
-      :entry_set_index,  # Sigma set index of current parse entry
+      :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
@@ -31,11 +31,11 @@ module Rley # This module is used as a namespace
     # Terminology warning: this class implements an external iterator
     # for a given GFGParsing object. In other words, its instances are objects
     # distinct for the GFGParsing.
-    # This is different from the internal iterators, usually implemented in Ruby
-    # with an each method.
+    # 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 accepting (final)
-    # parse entries and goes to the initial parse entry.
+    # 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
@@ -53,16 +53,13 @@ module Rley # This module is used as a namespace
             receiver << event unless event.nil?
 
             if ctx.curr_entry.orphan? # No antecedent?...
-              if ctx.backtrack_points.empty?
-                break
-              else
-                receiver << use_backtrack_point(ctx)
-                receiver << visit_entry(ctx.curr_entry, ctx)
-              end
+              break if ctx.backtrack_points.empty?
+              receiver << use_backtrack_point(ctx)
+              receiver << visit_entry(ctx.curr_entry, ctx)
             end
 
             result = jump_to_antecedent(ctx)
-            # Emit detection of scan edge if any...            
+            # Emit detection of scan edge if any...
             receiver << result[0] if result.size > 1
             ctx.curr_entry = result.last
           end
@@ -71,7 +68,8 @@ module Rley # This module is used as a namespace
         return walker
       end
 
-private
+      private
+
       # Context factory method
       def init_context(acceptingEntry, maxIndex)
         context = ParseWalkerContext.new
@@ -108,8 +106,8 @@ private
             when GFG::ItemVertex
               # Skip item entries while revisiting
               event = nil
-          else
-            fail NotImplementedError
+            else
+              raise NotImplementedError
           end
         else
           # first time visit
@@ -120,7 +118,7 @@ private
         return event
       end
 
-      def detect_scan_edge(ctx)
+      def detect_scan_edge(_ctx)
         return nil unless aContext.curr_entry.dotted_entry?
       end
 
@@ -131,12 +129,12 @@ private
       def jump_to_antecedent(aContext)
         entries = []
         return entries if aContext.curr_entry.orphan?
-        
-        if aContext.curr_entry.antecedents.size == 1
-          entries = antecedent_of(aContext)
-        else
-          entries = select_antecedent(aContext)
-        end
+
+        entries = if aContext.curr_entry.antecedents.size == 1
+                    antecedent_of(aContext)
+                  else
+                    select_antecedent(aContext)
+                  end
 
         return entries
       end
@@ -153,15 +151,15 @@ private
           aContext.return_stack << aContext.curr_entry
         elsif traversed_edge.kind_of?(GFG::CallEdge)
           # Pop top of stack
-          tos = aContext.return_stack.pop
+          aContext.return_stack.pop
           # puts "Pop from return stack matching entry #{new_entry}"
-        elsif traversed_edge.kind_of?(GFG::ScanEdge)  
+        elsif traversed_edge.kind_of?(GFG::ScanEdge)
           # Scan edge encountered, decrease sigma set index
           aContext.entry_set_index -= 1
         elsif traversed_edge.kind_of?(GFG::EpsilonEdge)
           # Do nothing
         else
-          fail NotImplementedError, "edge is a #{traversed_edge.class}"        
+          raise NotImplementedError, "edge is a #{traversed_edge.class}"
         end
 
         return events
@@ -180,7 +178,7 @@ private
           when GFG::StartVertex
             new_entry = select_calling_entry(aContext)
           else
-            fail StandardError, "Internal error"
+            raise StandardError, 'Internal error'
         end
 
         return [ new_entry ]
@@ -213,7 +211,7 @@ private
           aContext.backtrack_points.pop
         end
         # puts "Backtracking to #{bp.visitee}"
-        
+
         # Emit a backtrack event
         return [:backtrack, bp.visitee, aContext.entry_set_index]
       end
@@ -233,8 +231,7 @@ private
           item = antecd.vertex.dotted_item
           (antecd.origin == tos.origin) && tos_dotted_item.successor_of?(item)
         end
-        
-        # TODO: double-check validity of next line
+
         new_entry = aContext.curr_entry unless new_entry
 
         # puts "Pop from return stack matching entry #{new_entry}"
@@ -242,4 +239,4 @@ private
       end
     end # class
   end # module
-end # module
+end # module

data/lib/rley/parser/parsing.rb

@@ -32,7 +32,7 @@ module Rley # This module is used as a namespace
 
         # Retrieve all the complete states with start symbol in lhs 
         end_states = last_chart_entry.states_rewriting(start_symbol)
-        success_states = end_states.select { |st| st.origin == 0 }
+        success_states = end_states.select { |st| st.origin.zero? }
         
         return !success_states.empty?
       end
@@ -41,7 +41,7 @@ module Rley # This module is used as a namespace
       # for the same lhs and same origin in any state set.
       def ambiguous?()
         found = chart.state_sets.find { |set| !set.ambiguities.empty? }
-        return ! found.nil?
+        return !found.nil?
       end
 
       # Factory method. Builds a ParseTree from the parse result.
@@ -74,7 +74,7 @@ module Rley # This module is used as a namespace
       # Push a parse state (dotted item + origin) to the
       # chart entry with given index if it isn't yet in the chart entry.
       def push_state(aDottedItem, anOrigin, aChartIndex, aReason)
-        fail StandardError, 'Dotted item may not be nil' if aDottedItem.nil?
+        raise StandardError, 'Dotted item may not be nil' if aDottedItem.nil?
         chart.push_state(aDottedItem, anOrigin, aChartIndex, aReason)
       end
 
@@ -93,13 +93,13 @@ module Rley # This module is used as a namespace
       # @param aPosition [Fixnum] position in the input token sequence.
       # @param nextMapping [Proc or Lambda] code to evaluate in order to
       #   determine the "next" dotted rule for a given one.
-      def scanning(aTerminal, aPosition, &nextMapping)
+      def scanning(aTerminal, aPosition, &_nextMapping)
         curr_token = tokens[aPosition]
         return unless curr_token.terminal == aTerminal
 
         states = states_expecting(aTerminal, aPosition, false)
         states.each do |s|
-          next_item = nextMapping.call(s.dotted_rule)
+          next_item = yield s.dotted_rule
           push_state(next_item, s.origin, aPosition + 1, :scanning)
         end
       end
@@ -115,12 +115,12 @@ module Rley # This module is used as a namespace
       #  In other words, rules that predicted the non-terminal X.
       # For each s, add to chart[aPosition] a state of the form
       #  { dotted_rule: Y → α X • β, origin: i})
-      def completion(aState, aPosition, &nextMapping)
+      def completion(aState, aPosition, &_nextMapping)
         curr_origin = aState.origin
         curr_lhs = aState.dotted_rule.lhs
         states = states_expecting(curr_lhs, curr_origin, false)
         states.each do |s|
-          next_item = nextMapping.call(s.dotted_rule)
+          next_item = yield s.dotted_rule
           push_state(next_item, s.origin, aPosition, :completion)
         end
       end
@@ -207,7 +207,7 @@ module Rley # This module is used as a namespace
         aTreeBuilder.current_node.range = { low: index, high: index + 1 }
         link_node_to_token(aTreeBuilder, aStateTracker.state_set_index)
         unless aTreeBuilder.current_node.is_a?(PTree::TerminalNode)
-          fail StandardError, 'Expected terminal node'
+          raise StandardError, 'Expected terminal node'
         end
         aTreeBuilder.move_back
         state_set = chart[aStateTracker.state_set_index]

data/lib/rley/parser/state_set.rb

@@ -9,7 +9,6 @@ module Rley # This module is used as a namespace
       # The set of parse states
       attr_reader(:states)
 
-
       def initialize()
         @states = []
       end
@@ -22,72 +21,70 @@ module Rley # This module is used as a namespace
         if include?(aState)
           result = false
         else
-          @states << aState 
+          @states << aState
           result = true
         end
-        
+
         return result
       end
 
       # The list of ParseState that expect the given symbol.
-      # @param aSymbol [GrmSymbol] the expected symbol 
+      # @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 }
       end
-     
 
-      # The list of complete ParseState that have the given non-terminal 
+
+      # The list of complete ParseState that have the given non-terminal
       # symbol as the lhs of their production.
       def states_rewriting(aNonTerm)
-        return states.select do |s| 
+        return states.select do |s|
           (s.dotted_rule.production.lhs == aNonTerm) && s.complete?
         end
       end
-      
+
       # The list of ParseState that involve the given production
       def states_for(aProduction)
         return states.select { |s| s.dotted_rule.production == aProduction }
       end
-      
+
       # Retrieve the parse state that is the predecessor of the given one.
-      def predecessor_state(aParseState)
-        if aParseState.dotted_rule.prev_position.nil?
-          fail StandardError, "#{aParseState}"
-        else
-          candidate = states.find { |s| s.precedes?(aParseState) }
-        end
-        
+      def predecessor_state(aPState)
+        dotted_rule = aPState.dotted_rule
+        raise StandardError, aPState.to_s unless dotted_rule.prev_position
+
+        candidate = states.find { |s| s.precedes?(aPState) }
         return candidate
       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()
-        expecting_terminals = states.select do |s| 
-          s.dotted_rule.next_symbol.kind_of?(Rley::Syntax::Terminal) 
+        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
       end
-      
+
       # Return an Array of Arrays of ambiguous parse states.
       def ambiguities()
-        complete_states = states.select { |st|  st.complete? }
+        complete_states = states.select(&:complete?)
         return [] if complete_states.size <= 1
-        
+
         # Group parse state by lhs symbol and origin
         groupings = complete_states.group_by do |st|
-          "#{st.dotted_rule.lhs.object_id}"
+          st.dotted_rule.lhs.object_id.to_s
         end
-        
+
         # Retain the groups having more than one element.
         ambiguous_groups = []
         groupings.each_value do |a_group|
           ambiguous_groups << a_group if a_group.size > 1
         end
-        
+
         return ambiguous_groups
       end