rley 0.7.03 → 0.7.08

data/lib/rley/parser/gfg_earley_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../base/base_parser'
 require_relative '../gfg/grm_flow_graph'
 require_relative 'gfg_parsing'
@@ -49,7 +51,7 @@ module Rley # This module is used as a namespace
         result.chart[index].each do |entry|
           # Is entry of the form? [A => alpha . B beta, k]...
           next_symbol = entry.next_symbol
-          if next_symbol && next_symbol.kind_of?(Syntax::NonTerminal)
+          if next_symbol&.kind_of?(Syntax::NonTerminal)
             # ...apply the Call rule
             call_rule(result, entry, index)
           end

data/lib/rley/parser/gfg_parsing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'gfg_chart'
 require_relative 'error_reason'
 require_relative 'parse_entry_tracker'
@@ -13,7 +15,7 @@ module Rley # This module is used as a namespace
       attr_reader(:gf_graph)
 
       # The link to the chart object
-      # @return [GFGChart]
+      # @return [Parser::GFGChart]
       attr_reader(:chart)
 
       # The sequence of input token to parse
@@ -34,6 +36,7 @@ module Rley # This module is used as a namespace
       # Constructor
       # @param theGFG [GFG::GrmFlowGraph] the Grammar Flow Graph
       def initialize(theGFG)
+        super()
         @gf_graph = theGFG
         @tokens = []
         @chart = GFGChart.new(gf_graph)
@@ -71,6 +74,11 @@ module Rley # This module is used as a namespace
       # [B., i]
       # [A => alpha B . beta, k]
       def nullable_rule(anEntry, aPosition)
+        # Terminology:
+        # .B : start node
+        # B => . rhs : entry node
+        # B => rhs . : exit node
+        # B. : end node
         next_symbol = anEntry.next_symbol
         pos = aPosition
         start = gf_graph.start_vertex_for[next_symbol]
@@ -82,6 +90,8 @@ module Rley # This module is used as a namespace
           succ = edge.successor # succ always an ItemVertex
           if succ.dotted_item.production.nullable?
             succ_entry = apply_rule(start_entry, succ, pos, pos, :nullable_rule)
+            next unless succ_entry.exit_entry?
+
             apply_rule(succ_entry, end_vertex, pos, pos, :nullable_rule)
           end
         end
@@ -169,50 +179,36 @@ module Rley # This module is used as a namespace
           end
         end
 
-        return true
+        true
       end
 
       # Return true if the parse was successful (= input tokens
       # followed the syntax specified by the grammar)
-      def success?()
+      def success?
         return false if @failure_reason
-        
-        return chart.accepting_entry ? true : false
+
+        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?()
+      def ambiguous?
         found = chart.sets.find { |set| !set.ambiguities.empty? }
-        return !found.nil?
-      end
-
-      # Factory method. Builds a ParseForest from the parse result.
-      # @return [ParseForest]
-      def parse_forest()
-        msg = <<-END_MSG
- Method Rley::Parser::GFGParsing.parse_forest is deprecated, call
- Rley::Engine::to_pforest. It will be removed June 1st
- or version 0.6.1 (whichever is first)
-END_MSG
-        # warn(msg)
-        factory = ParseRep::ParseForestFactory.new(self)
-
-        return factory.create
+        !found.nil?
       end
 
       # Retrieve the very first parse entry added to the chart.
       # This entry corresponds to the start vertex of the GF graph
       # with origin equal to zero.
-      def initial_entry()
-        return chart.initial_entry
+      def initial_entry
+        chart.initial_entry
       end
 
       # Retrieve the accepting parse entry that represents
       # a complete, successful parse
       # After a successful parse, the last chart entry set
       # has an end parse entry that involves the start symbol
-      def accepting_entry()
+      def accepting_entry
         return chart.accepting_entry
       end
 
@@ -222,7 +218,7 @@ END_MSG
       end
 
       # A notification that the parsing reached an end
-      def done()
+      def done
         # Parse not successful and no reason identified
         # Assuming that parse failed because of a premature end
         premature_end unless success? || failure_reason
@@ -230,12 +226,33 @@ END_MSG
 
       # Clean and normalize the object.
       # Call this method when the parsing is complete.
-      def tidy_up!()
+      def tidy_up!
         antecedence.each_key do |entry|
           antecedence[entry].uniq!
         end
       end
 
+      def count_states
+        chart.count_states
+      end
+
+      def count_entries
+        chart.count_entries
+      end
+
+      def count_edges
+        chart.count_edges
+      end
+
+      # @return [String] A human readable representation of itself.
+      def to_s
+        result = +''
+        result << "success? #{success?}\n"
+        result << "chart:\n"
+        result << chart.to_s
+
+        result
+      end
 
       private
 
@@ -266,8 +283,10 @@ END_MSG
 
         antecedence[consequent] << antecedentEntry
 
+=begin
         # Invariant checks
         antecedents = antecedence[consequent]
+
         case aVertex
           when Rley::GFG::EndVertex
             # Rule: has 1..* antecedents, all of them are exit items
@@ -299,9 +318,9 @@ END_MSG
               raise StandardError, msg_prefix + msg_suffix
             end
         end
-
+=end
         consequent.add_antecedent(antecedentEntry)
-        return consequent
+        consequent
       end
 
       # Push a parse entry (vertex + origin) to the
@@ -316,15 +335,16 @@ END_MSG
       def forest_builder(anIndex)
         full_range = { low: 0, high: anIndex }
         start_production = chart.start_dotted_rule.production
-        return ParseForestBuilder.new(start_production, full_range)
+
+        ParseForestBuilder.new(start_production, full_range)
       end
 
       # Factory method. Creates and initializes a ParseEntryTracker instance.
-      def new_entry_tracker()
+      def new_entry_tracker
         instance = ParseEntryTracker.new(chart.last_index)
         instance.parse_entry = accepting_entry
 
-        return instance
+        instance
       end
     end # class
   end # module

data/lib/rley/parser/parse_entry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../gfg/start_vertex'
 require_relative '../gfg/end_vertex'
 require_relative '../gfg/item_vertex'
@@ -30,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|
@@ -38,10 +40,11 @@ module Rley # This module is used as a namespace
         end
         result << ']>'
 
-        return result
+        result
       end
 
       # Add a link to an antecedent parse entry
+      # @param anAntecedent[ParseEntry]
       def add_antecedent(anAntecedent)
         antecedents << anAntecedent unless antecedents.include?(anAntecedent)
       end
@@ -50,57 +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
-        @my_hash ||= "#{vertex.object_id}-#{origin}".hash
-        @my_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
@@ -115,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
@@ -143,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()
-        result = "#<#{self.class.name}:#{object_id}"
+      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
@@ -167,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable' # For the Delegation pattern
 require 'set'
 
@@ -14,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()
-        result = "#<#{self.class.name}:#{object_id}"
+      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)
@@ -59,13 +62,9 @@ module Rley # This module is used as a namespace
       # @param anEntry [ParseEntry] the parse entry to push.
       # @return [ParseEntry] the passed parse entry if it pushes it
       def push_entry(anEntry)
-        # TODO: control overhead next line
-        #match = entries.find { |entry| entry == anEntry }
         entry_key = anEntry.hash
-        match = membership.fetch(entry_key, false)
-        if match
-          result = match
-        else
+        result = membership.fetch(entry_key, false)
+        unless result
           @entries << anEntry
           membership[entry_key] = anEntry
           expecting = anEntry.next_symbol
@@ -73,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
 
@@ -92,25 +91,31 @@ 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
 
       def add_lookup4symbol(anEntry)
         symb = anEntry.next_symbol
-        case symb
-          when Syntax::Terminal
-            @entries4term[symb] << anEntry
-
-          when Syntax::NonTerminal
-            @entries4n_term[symb] << anEntry
+        if symb.kind_of?(Syntax::Terminal)
+          @entries4term[symb] << anEntry
+        else
+          @entries4n_term[symb] << anEntry
         end
       end
     end # class