rley 0.3.04 → 0.3.05

data/lib/rley/parse_forest_visitor.rb

@@ -1,115 +1,113 @@
-module Rley # This module is used as a namespace
-  # A visitor class dedicated in the visit of a parse forest.
-  # It combines the Visitor and Observer patterns.
-  class ParseForestVisitor
-    # Link to the parse forest to visit
-    attr_reader(:pforest)
-
-    # List of objects that subscribed to the visit event notification.
-    attr_reader(:subscribers)
-    
-    # A Hash with pairs of the form: Node => node visit data
-    attr_reader(:agenda)
-    
-    # Indicates the kind of forest traversal to perform: :post_order, :pre-order
-    attr_reader(:traversal)
-
-    # Build a visitor for the given pforest.
-    # @param aParseForest [ParseForest] the parse tree to visit.
-    def initialize(aParseForest, aTraversalStrategy = :post_order)
-      @pforest = aParseForest
-      @subscribers = []
-      @traversal = aTraversalStrategy
-    end
-
-    public
-
-    # Add a subscriber for the visit event notifications.
-    # @param aSubscriber [Object]
-    def subscribe(aSubscriber)
-      subscribers << aSubscriber
-    end
-
-    # Remove the given object from the subscription list.
-    # The object won't be notified of visit events.
-    # @param aSubscriber [Object]
-    def unsubscribe(aSubscriber)
-      subscribers.delete_if { |entry| entry == aSubscriber }
-    end
-
-    # The signal to begin the visit of the parse forest.
-    def start()
-      pforest.accept(self)
-    end
-
-
-    # Visit event. The visitor is about to visit the pforest.
-    # @param aParseForest [ParseForest] the pforest to visit.
-    def start_visit_pforest(aParseForest)
-      broadcast(:before_pforest, aParseForest)
-    end
-
-
-    # Visit event. The visitor is about to visit the given non terminal node.
-    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
-    def visit_nonterminal(aNonTerminalNode)
-      if @traversal == :post_order
-        broadcast(:before_non_terminal, aNonTerminalNode)
-        traverse_children(aNonTerminalNode)
-      else
-        traverse_children(aNonTerminalNode)  
-        broadcast(:before_non_terminal, aNonTerminalNode)
-      end
-      broadcast(:after_non_terminal, aNonTerminalNode)
-    end
-
-    # Visit event. The visitor is visiting the
-    # given terminal node.
-    # @param aTerminalNode [TerminalNode] the terminal to visit.
-    def visit_terminal(aTerminalNode)
-      broadcast(:before_terminal, aTerminalNode)
-      broadcast(:after_terminal, aTerminalNode)
-    end
-
-
-    # Visit event. The visitor has completed its visit of the given 
-    # non-terminal node.
-    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
-    def end_visit_nonterminal(aNonTerminalNode)
-      broadcast(:after_non_terminal, aNonTerminalNode)
-    end
-
-    # Visit event. The visitor has completed the visit of the pforest.
-    # @param aParseForest [ParseForest] the pforest to visit.
-    def end_visit_pforest(aParseForest)
-      broadcast(:after_pforest, aParseForest)
-    end
-
-    private
-    
-    # Visit event. The visitor is about to visit the children of a non 
-    # terminal node.
-    # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
-    def traverse_children(aParentNode)
-      children = aParentNode.children
-      broadcast(:before_children, aParentNode, children)
-      
-      # Let's proceed with the visit of children
-      children.each { |a_node| a_node.accept(self) }
-      
-      broadcast(:after_children, aParentNode, children)
-    end
-
-    # Send a notification to all subscribers.
-    # @param msg [Symbol] event to notify
-    # @param args [Array] arguments of the notification.
-    def broadcast(msg, *args)
-      subscribers.each do |a_subscriber|
-        next unless a_subscriber.respond_to?(msg)
-        a_subscriber.send(msg, *args)
-      end
-    end
-  end # class
-end # module
-
-# End of file
+module Rley # This module is used as a namespace
+  # A visitor class dedicated in the visit of a parse forest.
+  # It combines the Visitor and Observer patterns.
+  class ParseForestVisitor
+    # Link to the parse forest to visit
+    attr_reader(:pforest)
+
+    # List of objects that subscribed to the visit event notification.
+    attr_reader(:subscribers)
+
+    # A Hash with pairs of the form: Node => node visit data
+    attr_reader(:agenda)
+
+    # Indicates the kind of forest traversal to perform: :post_order, :pre-order
+    attr_reader(:traversal)
+
+    # Build a visitor for the given pforest.
+    # @param aParseForest [ParseForest] the parse tree to visit.
+    def initialize(aParseForest, aTraversalStrategy = :post_order)
+      @pforest = aParseForest
+      @subscribers = []
+      @traversal = aTraversalStrategy
+    end
+
+    # Add a subscriber for the visit event notifications.
+    # @param aSubscriber [Object]
+    def subscribe(aSubscriber)
+      subscribers << aSubscriber
+    end
+
+    # Remove the given object from the subscription list.
+    # The object won't be notified of visit events.
+    # @param aSubscriber [Object]
+    def unsubscribe(aSubscriber)
+      subscribers.delete_if { |entry| entry == aSubscriber }
+    end
+
+    # The signal to begin the visit of the parse forest.
+    def start()
+      pforest.accept(self)
+    end
+
+
+    # Visit event. The visitor is about to visit the pforest.
+    # @param aParseForest [ParseForest] the pforest to visit.
+    def start_visit_pforest(aParseForest)
+      broadcast(:before_pforest, aParseForest)
+    end
+
+
+    # Visit event. The visitor is about to visit the given non terminal node.
+    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
+    def visit_nonterminal(aNonTerminalNode)
+      if @traversal == :post_order
+        broadcast(:before_non_terminal, aNonTerminalNode)
+        traverse_children(aNonTerminalNode)
+      else
+        traverse_children(aNonTerminalNode)
+        broadcast(:before_non_terminal, aNonTerminalNode)
+      end
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given terminal node.
+    # @param aTerminalNode [TerminalNode] the terminal to visit.
+    def visit_terminal(aTerminalNode)
+      broadcast(:before_terminal, aTerminalNode)
+      broadcast(:after_terminal, aTerminalNode)
+    end
+
+
+    # Visit event. The visitor has completed its visit of the given
+    # non-terminal node.
+    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
+    def end_visit_nonterminal(aNonTerminalNode)
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+
+    # Visit event. The visitor has completed the visit of the pforest.
+    # @param aParseForest [ParseForest] the pforest to visit.
+    def end_visit_pforest(aParseForest)
+      broadcast(:after_pforest, aParseForest)
+    end
+
+    private
+
+    # Visit event. The visitor is about to visit the children of a non
+    # terminal node.
+    # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
+    def traverse_children(aParentNode)
+      children = aParentNode.children
+      broadcast(:before_children, aParentNode, children)
+
+      # Let's proceed with the visit of children
+      children.each { |a_node| a_node.accept(self) }
+
+      broadcast(:after_children, aParentNode, children)
+    end
+
+    # Send a notification to all subscribers.
+    # @param msg [Symbol] event to notify
+    # @param args [Array] arguments of the notification.
+    def broadcast(msg, *args)
+      subscribers.each do |a_subscriber|
+        next unless a_subscriber.respond_to?(msg)
+        a_subscriber.send(msg, *args)
+      end
+    end
+  end # class
+end # module
+
+# End of file

data/lib/rley/parse_tree_visitor.rb

@@ -19,8 +19,6 @@ module Rley # This module is used as a namespace
       @traversal = aTraversalStrategy
     end
 
-    public
-
     # Add a subscriber for the visit event notifications.
     # @param aSubscriber [Object]
     def subscribe(aSubscriber)

data/lib/rley/parser/base_parser.rb

@@ -1,27 +1,27 @@
-require_relative '../syntax/grammar'
-require_relative 'grm_items_builder'  # Use mix-in module
-require_relative 'parse_tracer'
-require_relative 'parsing'
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    # Abstract class for Earley parser. 
-    class BaseParser
-      include GrmItemsBuilder # Mix-in module for created dotted items of given grammar
-      
-      # The grammar of the language.
-      attr_reader(:grammar)
-
-      # The dotted items/rules for the productions of the grammar
-      attr_reader(:dotted_items)
-
-      
-      def initialize(aGrammar)
-        @grammar = aGrammar
-        @dotted_items = build_dotted_items(grammar) # Method from mixin
-      end
-    end # class
-  end # module
-end # module
-
-# End of file
+require_relative '../syntax/grammar'
+require_relative 'grm_items_builder' # Use mix-in module
+require_relative 'parse_tracer'
+require_relative 'parsing'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Abstract class for Earley parser.
+    class BaseParser
+      include GrmItemsBuilder # Mix-in for creating dotted items of grammar
+
+      # The grammar of the language.
+      attr_reader(:grammar)
+
+      # The dotted items/rules for the productions of the grammar
+      attr_reader(:dotted_items)
+
+
+      def initialize(aGrammar)
+        @grammar = aGrammar
+        @dotted_items = build_dotted_items(grammar) # Method from mixin
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parser/chart.rb

@@ -8,7 +8,7 @@ module Rley # This module is used as a namespace
     class Chart
       # An array of state sets (one per input token + 1)
       attr_reader(:state_sets)
-            
+
       # The level of trace details reported on stdout during the parse.
       # The possible values are:
       # 0: No trace output (default case)
@@ -16,10 +16,10 @@ module Rley # This module is used as a namespace
       # 2: Same as of 1 with the addition of the prediction rules
       attr_reader(:tracer)
 
-      # @param startItems [Array] A non-empty Array of dotted items for 
+      # @param startItems [Array] A non-empty Array of dotted items for
       #   the start symbol.
       # @param tokenCount [Fixnum] The number of lexemes in the input to parse.
-      # @param aTracer [ParseTracer] A tracer object. 
+      # @param aTracer [ParseTracer] A tracer object.
       def initialize(startItems, tokenCount, aTracer)
         @tracer = aTracer
         @state_sets = Array.new(tokenCount + 1) { |_| StateSet.new }
@@ -34,7 +34,7 @@ module Rley # This module is used as a namespace
       def start_dotted_rule()
         return self[0].states.first.dotted_rule
       end
-      
+
       # Return the start (non-terminal) symbol of the grammar.
       def start_symbol()
         return state_sets.first.states[0].dotted_rule.lhs
@@ -44,16 +44,16 @@ module Rley # This module is used as a namespace
       def [](index)
         return state_sets[index]
       end
-      
+
       # Return the index value of the last non-empty state set.
       def last_index()
         first_empty = state_sets.find_index(&:empty?)
-        if first_empty.nil?
-          index = state_sets.size - 1
-        else
-          index = first_empty == 0 ? 0 : first_empty - 1
-        end
-        
+        index = if first_empty.nil?
+                  state_sets.size - 1
+                else
+                  first_empty.zero? ? 0 : first_empty - 1
+                end
+
         return index
       end
 
@@ -65,14 +65,14 @@ module Rley # This module is used as a namespace
         case aReason
           when :start_rule, :prediction
             tracer.trace_prediction(anIndex, new_state)
-            
+
           when :scanning
              tracer.trace_scanning(anIndex, new_state)
-             
+
           when :completion
              tracer.trace_completion(anIndex, new_state)
           else
-            fail NotImplementedError, "Unknown push_state mode #{aReason}"
+            raise NotImplementedError, "Unknown push_state mode #{aReason}"
         end
       end
     end # class

data/lib/rley/parser/dotted_item.rb

@@ -6,7 +6,7 @@ module Rley # This module is used as a namespace
   # The right part consists of symbols that are predicted to match the
   # input tokens.
   # The terminology stems from the traditional way to visualize the partition
-  # by using a fat dot character as a separator between the left and right 
+  # by using a fat dot character as a separator between the left and right
   # parts
   # An item with the dot at the beginning (i.e. before any rhs symbol)
   #  is called a predicted item.
@@ -29,7 +29,7 @@ module Rley # This module is used as a namespace
         @production = aProduction
         @position = valid_position(aPosition)
       end
-      
+
       # Return a String representation of the dotted item.
       # @return [String]
       def to_s()
@@ -41,68 +41,68 @@ module Rley # This module is used as a namespace
           text_values.insert(position, '.')
         end
         suffix = text_values.join(' ')
-        
+
         return prefix + suffix
       end
-      
+
       # Return true if the dot position is at the start of the rhs.
       def at_start?()
-        return position == 0 || position == -2
+        return position.zero? || position == -2
       end
 
-      # An item with the dot at the beginning is called 
-      # predicted item  
-      alias_method :predicted_item?, :at_start?
+      # An item with the dot at the beginning is called
+      # predicted item
+      alias predicted_item? at_start?
 
       # A dotted item is called a reduce item if the dot is at the end.
       def reduce_item?()
         return position < 0 # Either -1 or -2
       end
-      
+
       # The non-terminal symbol that is on the left-side of the production
       def lhs()
         return production.lhs
       end
-      
+
       # Return the symbol before the dot.
       # nil is returned if the dot is at the start of the rhs
       def prev_symbol()
         before_position = prev_position
-        if before_position.nil?
-          result = nil
-        else
-          result = production.rhs[before_position]
-        end
-        
+        result = if before_position.nil?
+                   nil
+                 else
+                   production.rhs[before_position]
+                 end
+
         return result
       end
-      
+
       # Return the symbol after the dot.
       # nil is returned if the dot is at the end
       def next_symbol()
-        return (position < 0) ? nil : production.rhs[position]
+        return position < 0 ? nil : production.rhs[position]
       end
-      
-      # Calculate the position of the dot if were moved by 
+
+      # Calculate the position of the dot if were moved by
       # one step on the left.
       def prev_position()
         case position
           when -2, 0
             result = nil
           when -1
-            result = (production.rhs.size == 1) ? 0 : (production.rhs.size - 1)
+            result = production.rhs.size == 1 ? 0 : production.rhs.size - 1
           else
             result = position - 1
         end
-        
+
         return result
       end
 
       # An item with the dot in front of a terminal is called a shift item
       def shift_item?()
-        return position == 0
+        return position.zero?
       end
-      
+
       # Return true if this dotted item has a dot one place
       # to the right compared to the dotted item argument.
       def successor_of?(another)
@@ -111,7 +111,7 @@ module Rley # This module is used as a namespace
         return false if to_the_left.nil?
         return to_the_left == another.position
       end
-      
+
 
       private
 
@@ -119,16 +119,16 @@ module Rley # This module is used as a namespace
       def valid_position(aPosition)
         rhs_size = production.rhs.size
         if aPosition < 0 || aPosition > rhs_size
-          fail StandardError, 'Out of bound index'
+          raise StandardError, 'Out of bound index'
         end
 
-        if rhs_size == 0
-          index = -2 # Minus 2 at start/end of empty production
-        elsif aPosition == rhs_size
-          index = -1 # Minus 1 at end of non-empty production
-        else
-          index = aPosition
-        end
+        index = if rhs_size.zero?
+                  -2 # Minus 2 at start/end of empty production
+                elsif aPosition == rhs_size
+                  -1 # Minus 1 at end of non-empty production
+                else
+                  aPosition
+                end
 
         return index
       end