rley 0.3.04 → 0.3.05

data/lib/rley/parser/earley_parser.rb

@@ -188,13 +188,13 @@ module Rley # This module is used as a namespace
         term_names = terminals.map(&:name)
         err_msg = "Syntax error at or near token #{pos}"
         err_msg << ">>>#{lexeme_at_pos}<<<:\nExpected "
-        if terminals.size > 1
-          err_msg << "one of: ['#{term_names.join("', '")}'],"
-        else
-           err_msg << ": #{term_names[0]},"
-        end
+        err_msg << if terminals.size > 1
+                     "one of: ['#{term_names.join("', '")}'],"
+                   else
+                     ": #{term_names[0]},"
+                   end
         err_msg << " found a '#{aParsing.tokens[pos - 1].terminal.name}'"
-        fail StandardError, err_msg + ' instead.'
+        raise StandardError, err_msg + ' instead.'
       end
     end # class
   end # module

data/lib/rley/parser/gfg_chart.rb

@@ -27,13 +27,6 @@ module Rley # This module is used as a namespace
         push_entry(aGFGraph.start_vertex, 0, 0, :start_rule)
       end
 
-      # The dotted item/rule used to seed the parse chart.
-      # It corresponds to the start production and a dot placed
-      # at the beginning of the rhs
-      # def start_dotted_rule()
-        # return self[0].entries.first.dotted_rule
-      # end
-
       # Return the start (non-terminal) symbol of the grammar.
       def start_symbol()
         return sets.first.entries[0].vertex.non_terminal
@@ -47,11 +40,11 @@ module Rley # This module is used as a namespace
       # Return the index value of the last non-empty entry set.
       def last_index()
         first_empty = sets.find_index(&:empty?)
-        if first_empty.nil?
-          index = sets.size - 1
-        else
-          index = (first_empty == 0) ? 0 : first_empty - 1
-        end
+        index = if first_empty.nil?
+                  sets.size - 1
+                else
+                  first_empty.zero? ? 0 : first_empty - 1
+                end
 
         return index
       end
@@ -71,7 +64,7 @@ module Rley # This module is used as a namespace
             when :completion
                tracer.trace_completion(anIndex, new_entry)
             else
-              fail NotImplementedError, "Unknown push_entry mode #{aReason}"
+              raise NotImplementedError, "Unknown push_entry mode #{aReason}"
           end
         end
 
@@ -92,9 +85,9 @@ module Rley # This module is used as a namespace
         # Retrieve all the end entries (i.e. of the form
         last_entries = sets[last_index].entries.select(&:end_entry?)
 
-        # ... now find the end vertex for start symbol and with origin at zero...
+        # ... now find the end vertex for start symbol and with origin at zero.
         success_entries = last_entries.select do |entry|
-          entry.origin == 0 && entry.vertex.non_terminal == start_symbol
+          entry.origin.zero? && entry.vertex.non_terminal == start_symbol
         end
 
         return success_entries.first

data/lib/rley/parser/gfg_earley_parser.rb

@@ -6,7 +6,6 @@ module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     # Implementation of a parser that uses the Earley parsing algorithm.
     class GFGEarleyParser < BaseParser
-
       # The Grammar Flow graph for the given grammar
       attr_reader :gf_graph
 
@@ -48,7 +47,8 @@ module Rley # This module is used as a namespace
         return result
       end
 
-private
+      private
+
       # Let the current sigma set be the ith parse entry set.
       # This method is invoked when an entry is added to the parse entry set
       # and is of the form [A => alpha . B beta, k].
@@ -77,8 +77,8 @@ private
       end
 
       # This method must be invoked when an entry is added to a parse entry set
-      # and is of the form [B => γ ., k] (the dot is at the end of the production.
-      # Then entry [B., k] is added to the current entry set.
+      # and is of the form [B => γ ., k] (the dot is at the end of the
+      # production. Then entry [B., k] is added to the current entry set.
       # Gist: for an entry corresponding to a reduced production, add an entry
       # for each exit edge in the graph.
       def exit_rule(aParsing, anEntry, aPosition, aTracer)
@@ -100,13 +100,15 @@ private
       end
 
       # Given that the terminal t is at the specified position,
-      #   Locate all entries in the current sigma set that expect t: [A => α . t γ, i]
+      #   Locate all entries in the current sigma set that expect t:
+      #     [A => α . t γ, i]
       #     and allow them to cross the edge, adding the node on the back side
       #     of the edge as an entry to the next sigma set:
       #       add an entry to the next sigma set [A => α t . γ, i]
       def scan_rule(aParsing, aPosition, aTracer)
         if aTracer.level > 1
-          puts "Chart[#{aPosition}] Scan rule applied upon #{aParsing.tokens[aPosition]}:"
+          prefix = "Chart[#{aPosition}] Scan rule applied upon "
+          puts prefix + aParsing.tokens[aPosition].to_s
         end
         aParsing.scan_rule(aPosition)
       end
@@ -124,16 +126,16 @@ private
         term_names = terminals.map(&:name)
         err_msg = "Syntax error at or near token #{pos}"
         err_msg << ">>>#{lexeme_at_pos}<<<:\nExpected "
-        if terminals.size > 1
-          err_msg << "one of: ['#{term_names.join("', '")}'],"
-        else
-           err_msg << ": #{term_names[0]},"
-        end
+        err_msg << if terminals.size > 1
+                     "one of: ['#{term_names.join("', '")}'],"
+                   else
+                     ": #{term_names[0]},"
+                   end
         err_msg << " found a '#{aParsing.tokens[pos - 1].terminal.name}'"
-        fail StandardError, err_msg + ' instead.'
+        raise StandardError, err_msg + ' instead.'
       end
     end # class
   end # module
 end # module
 
-# End of file
+# End of file

data/lib/rley/parser/gfg_parsing.rb

@@ -15,9 +15,11 @@ module Rley # This module is used as a namespace
       # The sequence of input token to parse
       attr_reader(:tokens)
 
-      # A Hash with pairs of the form: parse entry => [ antecedent parse entries ]
-      # It associates to a every parse entry its antecedent(s), that is, the parse entry/ies
-      # that causes the key parse entry to be created with one the gfg rules
+      # A Hash with pairs of the form: 
+      # parse entry => [ antecedent parse entries ]
+      # It associates to a every parse entry its antecedent(s), that is,
+      # the parse entry/ies that causes the key parse entry to be created 
+      # with one the gfg rules
       attr_reader(:antecedence)
 
       # @param aTracer [ParseTracer] An object that traces the parsing.
@@ -42,7 +44,8 @@ module Rley # This module is used as a namespace
       def call_rule(anEntry, aPosition)
         next_symbol = anEntry.next_symbol
         start_vertex = gf_graph.start_vertex_for[next_symbol]
-        apply_rule(anEntry, start_vertex, aPosition, aPosition, :call_rule)        
+        pos = aPosition
+        apply_rule(anEntry, start_vertex, pos, pos, :call_rule)        
       end
 
       # Let the current sigma set be the ith parse entry set.
@@ -62,8 +65,8 @@ module Rley # This module is used as a namespace
       end
 
       # This method must be invoked when an entry is added to a parse entry set
-      # and is of the form [B => γ ., k] (the dot is at the end of the production.
-      # Then entry [B., k] is added to the current entry set.
+      # and is of the form [B => γ ., k] (the dot is at the end of the 
+      # production. Then entry [B., k] is added to the current entry set.
       # Gist: for an entry corresponding to a reduced production, add an entry
       # for each exit edge in the graph.
       def exit_rule(anEntry, aPosition)
@@ -86,12 +89,15 @@ module Rley # This module is used as a namespace
         expecting_nterm_k.each do |ntry|
           # Get the vertices after the expected non-terminal
           vertex_after_terminal = ntry.vertex.shortcut.successor
-          apply_rule(anEntry, vertex_after_terminal, ntry.origin, aPosition, :end_rule)
+          origin = ntry.origin
+          pos = aPosition
+          apply_rule(anEntry, vertex_after_terminal, origin, pos, :end_rule)
         end
       end
 
       # Given that the terminal t is at the specified position,
-      #   Locate all entries in the current sigma set that expect t: [A => α . t γ, i]
+      #   Locate all entries in the current sigma set that expect t: 
+      #     [A => α . t γ, i]
       #     and allow them to cross the edge, adding the node on the back side
       #     of the edge as an entry to the next sigma set:
       #       add an entry to the next sigma set [A => α t . γ, i]
@@ -108,7 +114,9 @@ module Rley # This module is used as a namespace
           # Get the vertices after the expected terminal
           ntry.vertex.edges.each do |an_edge|
             vertex_after_terminal = an_edge.successor
-            apply_rule(ntry, vertex_after_terminal, ntry.origin, aPosition + 1, :scan_rule)
+            origin = ntry.origin
+            pos = aPosition + 1
+            apply_rule(ntry, vertex_after_terminal, origin, pos, :scan_rule)
           end
         end
       end
@@ -117,18 +125,16 @@ module Rley # This module is used as a namespace
       # Return true if the parse was successful (= input tokens
       # followed the syntax specified by the grammar)
       def success?()
-        return chart.accepting_entry() ? true : false
+        return chart.accepting_entry ? true : false
       end
 
       # Return true if there are more than one complete state
       # for the same lhs and same origin in any state set.
       def ambiguous?()
         found = chart.sets.find { |set| !set.ambiguities.empty? }
-        return ! found.nil?
+        return !found.nil?
       end
 
-
-
       # Factory method. Builds a ParseForest from the parse result.
       # @return [ParseForest]      
       def parse_forest()
@@ -152,7 +158,6 @@ module Rley # This module is used as a namespace
         return chart.accepting_entry
       end
 
-
       private
 
       # Raise an exception to indicate a syntax error.
@@ -165,13 +170,13 @@ module Rley # This module is used as a namespace
         term_names = expected.map(&:name)
         err_msg = "Syntax error at or near token #{aPosition + 1}"
         err_msg << ">>>#{lexeme_at_pos}<<<:\nExpected "
-        if expected.size > 1
-          err_msg << "one of: ['#{term_names.join("', '")}'],"
-        else
-           err_msg << ": #{term_names[0]},"
-        end
+        err_msg << if expected.size > 1
+                     "one of: ['#{term_names.join("', '")}'],"
+                   else
+                     ": #{term_names[0]},"
+                   end
         err_msg << " found a '#{actual.name}'"
-        fail StandardError, err_msg + ' instead.'
+        raise StandardError, err_msg + ' instead.'
       end
 
       def apply_rule(antecedentEntry, aVertex, anOrigin, aPosition, aRuleId)
@@ -183,7 +188,7 @@ module Rley # This module is used as a namespace
       # Push a parse entry (vertex + origin) to the
       # chart entry with given index if it isn't yet in the chart entry.
       def push_entry(aVertex, anOrigin, aChartIndex, aReason)
-        fail StandardError, 'Vertex may not be nil' if aVertex.nil?
+        raise StandardError, 'Vertex may not be nil' if aVertex.nil?
         chart.push_entry(aVertex, anOrigin, aChartIndex, aReason)
       end
 
@@ -202,7 +207,6 @@ module Rley # This module is used as a namespace
 
         return instance
       end
-
     end # class
   end # module
 end # module

data/lib/rley/parser/grm_items_builder.rb

@@ -9,7 +9,7 @@ module Rley # This module is used as a namespace
         items = []
         aGrammar.rules.each do |prod|
           rhs_size = prod.rhs.size
-          if rhs_size == 0
+          if rhs_size.zero?
             items << DottedItem.new(prod, 0)
           else
             items += (0..rhs_size).map { |i| DottedItem.new(prod, i) }
@@ -20,4 +20,5 @@ module Rley # This module is used as a namespace
       end
     end # module
   end # module
-end # module
+end # module
+# End of file

data/lib/rley/parser/parse_entry.rb

@@ -4,7 +4,6 @@ require_relative '../gfg/item_vertex'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
-
     # Responsibilities:
     # - To know whether the vertex is a start, end or item vertex
     # - To know the next symbol to expect
@@ -34,12 +33,7 @@ module Rley # This module is used as a namespace
       def ==(other)
         return true if object_id == other.object_id
 
-        if (vertex == other.vertex) && (origin == other.origin)
-          result = true
-        else
-          result = false
-        end
-
+        result = (vertex == other.vertex) && (origin == other.origin)
         return result
       end
 
@@ -137,7 +131,7 @@ module Rley # This module is used as a namespace
 
       # Return the validated GFG vertex
       def valid_vertex(aVertex)
-        fail StandardError, 'GFG vertex cannot be nil' if aVertex.nil?
+        raise StandardError, 'GFG vertex cannot be nil' if aVertex.nil?
 
         return aVertex
       end
@@ -145,4 +139,4 @@ module Rley # This module is used as a namespace
   end # module
 end # module
 
-# End of file
+# End of file

data/lib/rley/parser/parse_entry_set.rb

@@ -14,14 +14,6 @@ module Rley # This module is used as a namespace
       # The set of parse entries
       attr_reader :entries
 
-      # A Hash with pairs of the form:
-      #   terminal symbol => [ parse entry expecting the terminal ]
-      #attr_reader :entries4term
-
-      # A Hash with pairs of the form:
-      #   non terminal symbol => [ parse entry expecting the non-terminal ]
-      # attr_reader :entries4n_term
-
       def initialize()
         @entries = []
         @entries4term = Hash.new { |hash, key| hash[key] = [] } 
@@ -33,10 +25,14 @@ module Rley # This module is used as a namespace
         return 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, [])
       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, [])
       end
@@ -49,8 +45,6 @@ module Rley # This module is used as a namespace
         match = entries.find { |entry| entry == anEntry }
         if match
           result = match
-        #if entries.include?(anEntry)  # TODO: check performance
-        #  result = false
         else
           @entries << anEntry
           expecting = anEntry.next_symbol
@@ -64,12 +58,12 @@ module Rley # This module is used as a namespace
       
       # Return an Array of Arrays of ambiguous parse entries.
       def ambiguities()
-        complete_entries = entries.select { |entry| entry.exit_entry? }
+        complete_entries = entries.select(&:exit_entry?)
         return [] if complete_entries.size <= 1
         
         # Group parse entries by lhs symbol and origin
         groupings = complete_entries.group_by do |entry|
-          "#{entry.vertex.dotted_rule.lhs.object_id}"
+          entry.vertex.dotted_rule.lhs.object_id.to_s
         end
         
         # Retain the groups having more than one element.
@@ -87,18 +81,19 @@ module Rley # This module is used as a namespace
         return @entries4term.keys
       end      
       
-private
+      private
+
       def add_lookup4symbol(anEntry)
         symb = anEntry.next_symbol
         case symb
-        when Syntax::Terminal
-          @entries4term[symb] << anEntry  
-          
-        when Syntax::NonTerminal
-          @entries4n_term[symb] << anEntry
+          when Syntax::Terminal
+            @entries4term[symb] << anEntry  
+            
+          when Syntax::NonTerminal
+            @entries4n_term[symb] << anEntry
         end
       end
     end # class
   end # module
 end # module
-# End of file
+# End of file

data/lib/rley/parser/parse_entry_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 entries used
-    # while a Parsing instance is constructing a parse forest.
-    class ParseEntryTracker
-      # The index of the current entry set
-      attr_reader(:entry_set_index)
-      
-      # The current parse entry
-      attr_reader(:parse_entry)
-      
-      # The already processed entries from current entry set
-      attr_reader(:processed_entries)      
-      
-      # Constructor.
-      def initialize(aEntrySetIndex)
-        self.entry_set_index = aEntrySetIndex
-      end
-      
-      # Write accessor. Sets the value of the entry set index
-      def entry_set_index=(anIndex)
-        @entry_set_index = anIndex
-        @processed_entries = {}
-      end
-
-      # Write accessor. Set the given parse entry as the current one.
-      def parse_entry=(aParseEntry)
-        fail StandardError, 'Nil parse entry' if aParseEntry.nil?
-        @parse_entry = aParseEntry
-        processed_entries[parse_entry] = true
-      end
-      
-      # Take the first provided entry that wasn't processed yet.
-      def select_entry(theEntrys)
-        a_entry = theEntrys.find { |st| !processed_entries.include?(st) }
-        self.parse_entry = a_entry
-      end
-      
-      # The dotted item for the current parse entry.
-      def curr_dotted_item()
-        parse_entry.dotted_rule
-      end
-      
-      def symbol_on_left()
-        return curr_dotted_item.prev_symbol
-      end
-      
-      # Notification that one begins with the previous entry set
-      def to_prev_entry_set()      
-        self.entry_set_index = entry_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 entries used
+    # while a Parsing instance is constructing a parse forest.
+    class ParseEntryTracker
+      # The index of the current entry set
+      attr_reader(:entry_set_index)
+
+      # The current parse entry
+      attr_reader(:parse_entry)
+
+      # The already processed entries from current entry set
+      attr_reader(:processed_entries)
+
+      # Constructor.
+      def initialize(aEntrySetIndex)
+        self.entry_set_index = aEntrySetIndex
+      end
+
+      # Write accessor. Sets the value of the entry set index
+      def entry_set_index=(anIndex)
+        @entry_set_index = anIndex
+        @processed_entries = {}
+      end
+
+      # Write accessor. Set the given parse entry as the current one.
+      def parse_entry=(aParseEntry)
+        raise StandardError, 'Nil parse entry' if aParseEntry.nil?
+        @parse_entry = aParseEntry
+        processed_entries[parse_entry] = true
+      end
+
+      # Take the first provided entry that wasn't processed yet.
+      def select_entry(theEntrys)
+        a_entry = theEntrys.find { |st| !processed_entries.include?(st) }
+        self.parse_entry = a_entry
+      end
+
+      # The dotted item for the current parse entry.
+      def curr_dotted_item()
+        parse_entry.dotted_rule
+      end
+
+      def symbol_on_left()
+        return curr_dotted_item.prev_symbol
+      end
+
+      # Notification that one begins with the previous entry set
+      def to_prev_entry_set()
+        self.entry_set_index = entry_set_index - 1
+      end
+    end # class
+  end # module
+end # module
+
+# End of file