rley 0.7.07 → 0.7.08

data/lib/rley/parser/state_set.rb

@@ -11,7 +11,7 @@ module Rley # This module is used as a namespace
       # The set of parse states
       attr_reader(:states)
 
-      def initialize()
+      def initialize
         @states = []
       end
 
@@ -34,7 +34,7 @@ module Rley # This module is used as a namespace
       # @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 }
+        states.select { |s| s.dotted_rule.next_symbol == aSymbol }
       end
 
       # The list of complete ParseState that have the given non-terminal
@@ -47,7 +47,7 @@ module Rley # This module is used as a namespace
 
       # The list of ParseState that involve the given production
       def states_for(aProduction)
-        return states.select { |s| s.dotted_rule.production == aProduction }
+        states.select { |s| s.dotted_rule.production == aProduction }
       end
 
       # Retrieve the parse state that is the predecessor of the given one.
@@ -55,23 +55,22 @@ module Rley # This module is used as a namespace
         dotted_rule = aPState.dotted_rule
         raise StandardError, aPState.to_s unless dotted_rule.prev_position
 
-        candidate = states.find { |s| s.precedes?(aPState) }
-        return candidate
+        states.find { |s| s.precedes?(aPState) }
       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
         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
+        terminals.uniq
       end
 
       # Return an Array of Arrays of ambiguous parse states.
-      def ambiguities()
+      def ambiguities
         complete_states = states.select(&:complete?)
         return [] if complete_states.size <= 1
 
@@ -86,14 +85,14 @@ 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
 
       private
 
       def include?(aState)
         # TODO: make it better than linear search
-        return states.include?(aState)
+        states.include?(aState)
       end
     end # class
   end # module

data/lib/rley/ptree/non_terminal_node.rb

@@ -18,20 +18,22 @@ module Rley # This module is used as a namespace
       def add_subnode(aSubnode)
         subnodes.unshift(aSubnode)
       end
-      
+
       # Emit a (formatted) string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
+      # rubocop: disable Style/StringConcatenation
       def to_string(indentation)
         connector = '+- '
         selfie = super(indentation)
         prefix = "\n" + (' ' * connector.size * indentation) + connector
         subnodes_repr = subnodes.reduce(+'') do |sub_result, subnode|
-          sub_result << prefix + subnode.to_string(indentation + 1) 
+          sub_result << prefix + subnode.to_string(indentation + 1)
         end
-        
-        return selfie + subnodes_repr        
+
+        selfie + subnodes_repr
       end
-      
+      # rubocop: enable Style/StringConcatenation
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)

data/lib/rley/ptree/parse_tree.rb

@@ -6,12 +6,12 @@ require_relative 'non_terminal_node'
 module Rley # This module is used as a namespace
   module PTree # This module is used as a namespace
     # A parse tree (a.k.a. concrete syntax tree) is a tree-based representation
-    # for the parse that corresponds to the input text. In a parse tree, 
+    # for the parse that corresponds to the input text. In a parse tree,
     # a node corresponds to a grammar symbol used during the parsing:
     # - a leaf node maps to a terminal symbol occurring in
     # the input, and
     # - a intermediate node maps to a non-terminal node reduced
-    # during the parse. 
+    # during the parse.
     # The root node corresponds to the main/start symbol of the grammar.
     class ParseTree
       # @return [ParseTreeNode] The root node of the tree.
@@ -21,7 +21,7 @@ module Rley # This module is used as a namespace
       def initialize(theRootNode)
         @root = theRootNode
       end
-      
+
       # Notification from the builder telling that the parse tree construction
       # is over. This method can be overriden.
       def done!

data/lib/rley/ptree/parse_tree_node.rb

@@ -15,9 +15,9 @@ module Rley # This module is used as a namespace
         @symbol = aSymbol
         @range = Lexical::TokenRange.new(aRange)
       end
-      
+
       # Notify the builder that the construction is over
-      def done!()
+      def done!
         # Do nothing
       end
 
@@ -29,13 +29,13 @@ module Rley # This module is used as a namespace
       # Emit a (formatted) string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
       def to_string(indentation)
-        return "#{symbol.name}#{range.to_string(indentation)}"
+        "#{symbol.name}#{range.to_string(indentation)}"
       end
 
       # Emit a short string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
-      def to_s()
-        return "#{symbol.name}#{range.to_string(0)}"
+      def to_s
+        "#{symbol.name}#{range.to_string(0)}"
       end
     end # class
   end # module

data/lib/rley/ptree/terminal_node.rb

@@ -9,10 +9,10 @@ module Rley # This module is used as a namespace
       attr_reader(:token)
 
       # @param aToken [Lexical::Token] Input Token object
-      # @param aPos [Integer] position of the token in the input stream.      
+      # @param aPos [Integer] position of the token in the input stream.
       def initialize(aToken, aPos)
-        # (major, minor) =  
-        
+        # (major, minor) =
+
         # Use '1.class' trick to support both Integer and Fixnum classes
         range = aPos.kind_of?(1.class) ? { low: aPos, high: aPos + 1 } : aPos
         super(aToken.terminal, range)
@@ -24,18 +24,18 @@ module Rley # This module is used as a namespace
       def to_string(indentation)
         return super + ": '#{token.lexeme}'"
       end
-      
+
       # Emit a short string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
-      def to_s()
+      def to_s
         return super + ": '#{token.lexeme}'"
-      end      
+      end
 
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)
         aVisitor.visit_terminal(self)
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/rley_error.rb

@@ -1,12 +1,12 @@
-# frozen_string_literal: true
-
-# File: rley_error.rb
-
-module Rley # Module used as a namespace
-  # @abstract
-  # Base class for any exception explicitly raised by Rley code.
-  class RleyError < StandardError
-  end # class
-end # module
-
-# End of file
+# frozen_string_literal: true
+
+# File: rley_error.rb
+
+module Rley # Module used as a namespace
+  # @abstract
+  # Base class for any exception explicitly raised by Rley code.
+  class RleyError < StandardError
+  end # class
+end # module
+
+# End of file

data/lib/rley/sppf/alternative_node.rb

@@ -13,10 +13,10 @@ module Rley # This module is used as a namespace
       # @return [Syntax::NonTerminal] Link to lhs symbol
       attr_reader(:symbol)
 
-      # @param aVertex [GFG::ItemVertex] 
-      #   A GFG vertex that corresponds to a dotted item 
+      # @param aVertex [GFG::ItemVertex]
+      #   A GFG vertex that corresponds to a dotted item
       #   with the dot at the end) for the alternative under consideration.
-      # @param aRange [Lexical::TokenRange] 
+      # @param aRange [Lexical::TokenRange]
       #   A range of token indices corresponding to this node.
       def initialize(aVertex, aRange)
         super(aRange)
@@ -28,14 +28,14 @@ module Rley # This module is used as a namespace
       # Mainly used for diagnosis/debugging purposes.
       # @return [String]
       def to_string(indentation)
-        return "Alt(#{label})#{range.to_string(indentation)}"
+        "Alt(#{label})#{range.to_string(indentation)}"
       end
-      
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)
         aVisitor.visit_alternative(self)
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/sppf/composite_node.rb

@@ -9,11 +9,11 @@ module Rley # This module is used as a namespace
     class CompositeNode < SPPFNode
       # @return [Array<SPFFNode>] Sub-nodes (children).
       attr_reader(:subnodes)
-      
-      alias children subnodes      
+
+      alias children subnodes
 
       # Constructor
-      # @param aRange [Lexical::TokenRange]      
+      # @param aRange [Lexical::TokenRange]
       def initialize(aRange)
         super(aRange)
         @subnodes = []
@@ -24,14 +24,14 @@ module Rley # This module is used as a namespace
       def add_subnode(aSubnode)
         subnodes.unshift(aSubnode)
       end
-      
+
       # @return [String] a text representation of the node.
-      def inspect()
+      def inspect
         key
-      end      
+      end
 
       # @return [String]
-      def key()
+      def key
         @key ||= to_string(0)
       end
     end # class

data/lib/rley/sppf/epsilon_node.rb

@@ -17,14 +17,14 @@ module Rley # This module is used as a namespace
       # Mainly used for diagnosis/debugging purposes.
       # @return [String]
       def to_string(indentation)
-        return "_#{range.to_string(indentation)}"
+        "_#{range.to_string(indentation)}"
       end
-      
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)
         aVisitor.visit_epsilon(self)
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/sppf/leaf_node.rb

@@ -8,14 +8,14 @@ module Rley # This module is used as a namespace
     # child node.
     class LeafNode < SPPFNode
       # @return [String] a text representation of the node.
-      def inspect()
+      def inspect
         key
       end
 
       # @return [String]
-      def key()
+      def key
         @key ||= to_string(0)
-      end    
+      end
     end # class
   end # module
 end # module

data/lib/rley/sppf/parse_forest.rb

@@ -7,19 +7,19 @@ require_relative 'alternative_node'
 module Rley # This module is used as a namespace
   module SPPF # This module is used as a namespace
     # In an ambiguous grammar there are valid inputs that can result in multiple
-    # parse trees. A set of parse trees is commonly referred to as a parse 
-    # forest. More specifically a parse forest is a graph data 
+    # parse trees. A set of parse trees is commonly referred to as a parse
+    # forest. More specifically a parse forest is a graph data
     # structure designed to represent a set of equally syntactically correct
     # parse trees. Parse forests generated by Rley are so-called Shared Packed
-    # Parse Forests (SPPF). SPPFs allow very compact representation of parse 
+    # Parse Forests (SPPF). SPPFs allow very compact representation of parse
     # trees by sharing common sub-tree amongst the parse trees.
     class ParseForest
       # The root node of the forest
       attr_reader(:root)
-      
+
       # A Hash with pairs of the kind node key => node
       attr_reader(:key2node)
-      
+
       # A setter that tells that the parse is ambiguous.
       attr_writer(:is_ambiguous)
 
@@ -30,34 +30,34 @@ module Rley # This module is used as a namespace
         @key2node = {}
         @is_ambiguous = false
       end
-      
+
       # Notification that the SPPF construction is over
       def done!
         # Do nothing
       end
-      
+
       # Returns true if the given node is present in the forest.
       def include?(aNode)
-        return key2node.include?(aNode)
+        key2node.include?(aNode)
       end
-      
+
       # Returns true if the parse encountered a structural ambiguity
       # (i.e. more than one parse tree for the given input)
-      def ambiguous?()
-        return @is_ambiguous
+      def ambiguous?
+        @is_ambiguous
       end
-      
-      # Create an Enumerator that helps to iterate over the possible 
-      # parse trees. That enumerator will generate a parse tree when 
+
+      # Create an Enumerator that helps to iterate over the possible
+      # parse trees. That enumerator will generate a parse tree when
       # called with `next` method.
       # @return [Enumerator]
-      def to_ptree_enum()
+      def to_ptree_enum
         # How to implement?
         # One visits the forest => beware of dependency
         # At each visited item create a corresponding  tree node.
         # At end of visit & stack not empty
         # Re-generate another ptree
-      end      
+      end
 
       # Part of the 'visitee' role in the Visitor design pattern.
       #   A visitee is expected to accept the visit from a visitor object

data/lib/rley/sppf/sppf_node.rb

@@ -7,23 +7,22 @@ module Rley # This module is used as a namespace
     # Abstract class. The generalization for all kinds of nodes
     # occurring in a shared packed parse forest (SPPF).
     class SPPFNode
-    
-      # @return [Lexical::TokenRange] 
+      # @return [Lexical::TokenRange]
       # A range of token indices corresponding to this node.
       attr_reader(:range)
-      
+
       # Constructor
       # @param aRange [Lexical::TokenRange]
       def initialize(aRange)
         @range = Lexical::TokenRange.new(aRange)
       end
-      
-      # Return the origin, that is, the index of the 
+
+      # Return the origin, that is, the index of the
       # first token matched by this node.
       # @return [Integer]
-      def origin()
-        return range.low
-      end  
+      def origin
+        range.low
+      end
     end # class
   end # module
 end # module

data/lib/rley/sppf/token_node.rb

@@ -25,14 +25,14 @@ module Rley # This module is used as a namespace
       # @param indentation [Integer]
       # @return [String]
       def to_string(indentation)
-        return "#{token.terminal.name}#{range.to_string(indentation)}"
+        "#{token.terminal.name}#{range.to_string(indentation)}"
       end
-      
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)
         aVisitor.visit_terminal(self)
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/syntax/grammar.rb

@@ -48,13 +48,13 @@ module Rley # This module is used as a namespace
       end
 
       # @return [Array] The list of non-terminals in the grammar.
-      def non_terminals()
+      def non_terminals
         @non_terminals ||= symbols.select { |s| s.kind_of?(NonTerminal) }
       end
 
       # @return [Production] The start production of the grammar (i.e.
       #   the rule that specifies the syntax for the start symbol.
-      def start_production()
+      def start_production
         return rules[0]
       end
 
@@ -99,7 +99,7 @@ module Rley # This module is used as a namespace
       end
 
       # Perform some check of the grammar.
-      def diagnose()
+      def diagnose
         mark_undefined
         mark_generative
         compute_nullable
@@ -193,7 +193,7 @@ module Rley # This module is used as a namespace
 
       # For each non-terminal determine whether it is nullable or not.
       # A nullable nonterminal is a nonterminal that can match an empty string.
-      def compute_nullable()
+      def compute_nullable
         non_terminals.each { |nterm| nterm.nullable = false }
         nullable_sets = [direct_nullable]
 
@@ -236,7 +236,7 @@ module Rley # This module is used as a namespace
           nullables << prod.lhs
         end
 
-        return nullables
+        nullables
       end
 
       # For each prodction determine whether it is nullable or not.