rley 0.7.06 → 0.8.01

data/lib/rley/parser/gfg_parsing.rb

@@ -91,6 +91,7 @@ module Rley # This module is used as a namespace
           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
@@ -178,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
 
@@ -231,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
@@ -239,7 +226,7 @@ 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
@@ -258,7 +245,7 @@ END_MSG
       end
 
       # @return [String] A human readable representation of itself.
-      def to_s()
+      def to_s
         result = +''
         result << "success? #{success?}\n"
         result << "chart:\n"
@@ -293,9 +280,8 @@ END_MSG
 
       def apply_rule(antecedentEntry, aVertex, anOrigin, aPosition, aRuleId)
         consequent = push_entry(aVertex, anOrigin, aPosition, aRuleId)
-
-        antecedence[consequent] << antecedentEntry
-
+        if consequent
+          antecedence[consequent] << antecedentEntry
 
 =begin
         # Invariant checks
@@ -333,8 +319,10 @@ END_MSG
             end
         end
 =end
-        consequent.add_antecedent(antecedentEntry)
-        return consequent
+          consequent.add_antecedent(antecedentEntry)
+        end
+
+        consequent
       end
 
       # Push a parse entry (vertex + origin) to the
@@ -349,15 +337,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

@@ -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,17 +72,17 @@ 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
 
         # Group parse entries by lhs symbol and origin
         groupings = complete_entries.group_by do |entry|
-          entry.vertex.dotted_rule.lhs.object_id.to_s
+          entry.vertex.dotted_item.lhs.object_id.to_s
         end
 
         # Retain the groups having more than one element.
@@ -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_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