rley 0.8.01 → 0.8.02

data/lib/rley/notation/ast_node.rb

@@ -8,25 +8,25 @@ module Rley
     class ASTNode
       # @return [Rley::Lexical::Position] Position of the entry in the input stream.
       attr_reader :position
-      
+
       # @return [Symbol]
       attr_accessor :repetition
 
       # @return [Hash]
-      attr_reader :annotation      
+      attr_reader :annotation
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       def initialize(aPosition)
         @position = aPosition
         @repetition = :exactly_one
-        @annotation = {}        
+        @annotation = {}
       end
-      
+
       def annotation=(aMapping)
         repeat_key = 'repeat'
         @repetition = aMapping.delete(repeat_key) if aMapping.include?(repeat_key)
         @annotation = aMapping
-      end      
+      end
 
       # Notification that the parsing has successfully completed
       def done!

data/lib/rley/notation/ast_visitor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rley
   module Notation
     class ASTVisitor
@@ -110,4 +112,4 @@ module Rley
       end
     end # class
   end # module
-end # module      
+end # module

data/lib/rley/notation/grammar.rb

@@ -46,4 +46,4 @@ module Rley
     # And now build the Rley Grammar Notation (RGN) grammar...
     RGNGrammar = builder.grammar
   end # module
-end # module
+end # module

data/lib/rley/notation/grammar_builder.rb

@@ -10,7 +10,7 @@ module Rley # This module is used as a namespace
   module Notation # This module is used as a namespace
     # Structure used for production rules that are implicitly generated by Rley
     RawRule = Struct.new(:lhs, :rhs, :tag, :simple, :constraints)
-  
+
     # Builder GoF pattern. Builder builds a complex object
     #   (say, a grammar) from simpler objects (terminals and productions)
     #   and using a step by step approach.
@@ -28,7 +28,7 @@ module Rley # This module is used as a namespace
       # @return [Array<Production>] The list of production rules for
       #   the grammar to build.
       attr_reader(:productions)
-      
+
       # @return [Hash{String, String}] The synthesized raw productions
       attr_reader(:synthetized)
 
@@ -71,14 +71,14 @@ module Rley # This module is used as a namespace
         new_symbs = build_symbols(Syntax::Terminal, terminalSymbols)
         symbols.merge!(new_symbs)
       end
-      
+
       # Add the given marker symbol to the grammar of the language
       # @param aMarkerSymbol [String] A mazker symbol
-      # @return [void]      
+      # @return [void]
       def add_marker(aMarkerSymbol)
         new_symb = build_symbol(Syntax::Marker, aMarkerSymbol)
         symbols[new_symb.name] = new_symb
-      end       
+      end
 
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => String.
@@ -235,7 +235,7 @@ module Rley # This module is used as a namespace
           name_modified = "#{symb_name}#{suffix_qmark}"
           unless symbols.include? name_modified
             add_nonterminal(name_modified)
-            add_raw_rule(name_modified, "#{symb_name}", suffix_qmark_one)
+            add_raw_rule(name_modified, symb_name, suffix_qmark_one)
             add_raw_rule(name_modified, '', suffix_qmark_none)
           end
           symb_name = name_modified
@@ -254,7 +254,7 @@ module Rley # This module is used as a namespace
         when :exactly_one
           # Do nothing
 
-        when  :one_or_more
+        when :one_or_more
           name_modified = "#{symb_name}#{suffix_plus}"
           unless symbols.include? name_modified
             add_nonterminal(name_modified)
@@ -273,6 +273,7 @@ module Rley # This module is used as a namespace
       def after_sequence_node(aSequenceNode, _visitor)
         aSequenceNode.subnodes.each_with_index do |sn, i|
           next if sn.annotation.empty?
+
           matching = sn.annotation['match_closest']
           aSequenceNode.constraints << Syntax::MatchClosest.new(aSequenceNode, i, matching)
         end
@@ -330,14 +331,14 @@ module Rley # This module is used as a namespace
       # A notification to the builderobject that the programmer
       # has completed the entry of terminals and production rules
       def grammar_complete!
-        process_raw_rules()
+        process_raw_rules
       end
 
       private
-      
-      def add_nonterminal(aName) 
+
+      def add_nonterminal(aName)
         symbols[aName] = Syntax::NonTerminal.new(aName)
-      end  
+      end
 
       def simple_rule(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
@@ -352,7 +353,7 @@ module Rley # This module is used as a namespace
           members = rhs.map do |name|
             if name.end_with?('?', '*', '+')
               modifier = name[-1]
-              suffix = modifier2suffix(aModifier)
+              suffix = modifier2suffix(modifier)
               get_grm_symbol("#{name.chop}#{suffix}")
             else
               get_grm_symbol(name)
@@ -448,7 +449,7 @@ module Rley # This module is used as a namespace
         end
       end
 
-      def node_decorated_name(aNdoe)
+      def node_decorated_name(aNode)
         base_name = node_base_name(aNode)
         suffix = repetition2suffix(aNode.repetition)
 
@@ -466,13 +467,13 @@ module Rley # This module is used as a namespace
             text << sequence_name(sn)
           end
 
-          suffix = suffix = repetition2suffix(sn.repetition)
+          suffix = repetition2suffix(sn.repetition)
           text << suffix
         end
 
         text.strip
       end
-      
+
       def add_raw_rule(aSymbol, aRHS, aTag, simplified = false, constraints = [])
         raw_rule = RawRule.new(aSymbol, aRHS, aTag, simplified, constraints)
         if synthetized.include?(aSymbol)

data/lib/rley/notation/grouping_node.rb

@@ -5,7 +5,7 @@ require_relative 'sequence_node'
 module Rley
   module Notation
     # A syntax node representing an expression bracketed by parentheses.
-    class GroupingNode < SequenceNode      
+    class GroupingNode < SequenceNode
       # @param aPosition [Rley::Lexical::Position] Start position.
       # @param sequence [Array<ASTNode>] sequence of AST nodes
       # @param theRepetition [Symbol] indicates how many times the symbol can be repeated

data/lib/rley/notation/parser.rb

@@ -1,56 +1,56 @@
-# frozen_string_literal: true
-
-require_relative 'tokenizer'
-require_relative 'grammar'
-require_relative 'ast_builder'
-
-module Rley
-  module Notation
-    # A Lox parser that produce concrete parse trees.
-    # Concrete parse trees are the default kind of parse tree
-    # generated by the Rley library.
-    # They consist of two node types only:
-    # - NonTerminalNode
-    # - TerminalNode
-    # A NonTerminalNode has zero or more child nodes (called subnodes)
-    # A TerminalNode is leaf node, that is, it has no child node.
-    # While concrete parse tree nodes can be generated out of the box,
-    # they have the following drawbacks:
-    # - Generic node classes that aren't always suited for the needs of
-    #     the language being processing.
-    # - Concrete parse tree tend to be deeply nested, which may complicate
-    #   further processing.
-    class Parser
-      # @return [Rley::Engine] A facade object for the Rley parsing library
-      attr_reader(:engine)
-
-      def initialize
-        # Create a Rley facade object
-        @engine = Rley::Engine.new do |cfg|
-          cfg.diagnose = true
-          cfg.repr_builder = Notation::ASTBuilder
-        end
-
-        # Step 1. Load RGN grammar
-        @engine.use_grammar(Rley::Notation::RGNGrammar)
-      end
-
-      # Parse the given Lox program into a parse tree.
-      # @param source [String] Lox program to parse
-      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
-      def parse(source)
-        lexer = Tokenizer.new(source)
-        result = engine.parse(lexer.tokens)
-
-        unless result.success?
-          # Stop if the parse failed...
-          line1 = "Parsing failed\n"
-          line2 = "Reason: #{result.failure_reason.message}"
-          raise SyntaxError, line1 + line2
-        end
-
-        return engine.convert(result) # engine.to_ptree(result)
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'tokenizer'
+require_relative 'grammar'
+require_relative 'ast_builder'
+
+module Rley
+  module Notation
+    # A Lox parser that produce concrete parse trees.
+    # Concrete parse trees are the default kind of parse tree
+    # generated by the Rley library.
+    # They consist of two node types only:
+    # - NonTerminalNode
+    # - TerminalNode
+    # A NonTerminalNode has zero or more child nodes (called subnodes)
+    # A TerminalNode is leaf node, that is, it has no child node.
+    # While concrete parse tree nodes can be generated out of the box,
+    # they have the following drawbacks:
+    # - Generic node classes that aren't always suited for the needs of
+    #     the language being processing.
+    # - Concrete parse tree tend to be deeply nested, which may complicate
+    #   further processing.
+    class Parser
+      # @return [Rley::Engine] A facade object for the Rley parsing library
+      attr_reader(:engine)
+
+      def initialize
+        # Create a Rley facade object
+        @engine = Rley::Engine.new do |cfg|
+          cfg.diagnose = true
+          cfg.repr_builder = Notation::ASTBuilder
+        end
+
+        # Step 1. Load RGN grammar
+        @engine.use_grammar(Rley::Notation::RGNGrammar)
+      end
+
+      # Parse the given Lox program into a parse tree.
+      # @param source [String] Lox program to parse
+      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
+      def parse(source)
+        lexer = Tokenizer.new(source)
+        result = engine.parse(lexer.tokens)
+
+        unless result.success?
+          # Stop if the parse failed...
+          line1 = "Parsing failed\n"
+          line2 = "Reason: #{result.failure_reason.message}"
+          raise SyntaxError, line1 + line2
+        end
+
+        return engine.convert(result) # engine.to_ptree(result)
+      end
+    end # class
+  end # module
+end # module

data/lib/rley/notation/sequence_node.rb

@@ -8,16 +8,16 @@ module Rley
     class SequenceNode < ASTNode
       # @return [Array<ASTNode>]
       attr_reader :subnodes
-      
+
       attr_accessor :constraints
-      
+
       # @param aPosition [Rley::Lexical::Position] Start position.
       # @param sequence [Array<ASTNode>] sequence of AST nodes
       # @param theRepetition [Symbol] indicates how many times the symbol can be repeated
       def initialize(aPosition, sequence, theRepetition = nil)
         super(aPosition)
         @subnodes = sequence
-        repetition=(theRepetition) if theRepetition
+        self.repetition = theRepetition if theRepetition
         @constraints = []
       end
 

data/lib/rley/notation/symbol_node.rb

@@ -8,14 +8,14 @@ module Rley
     class SymbolNode < ASTNode
       # @return [String] name of grammar symbol
       attr_reader :name
-      
+
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param aName [String] name of grammar symbol
       # @param theRepetition [Symbol] indicates how many times the symbol can be repeated
       def initialize(aPosition, aName, theRepetition = nil)
         super(aPosition)
         @name = aName
-        repetition=(theRepetition) if theRepetition
+        self.repetition = theRepetition if theRepetition
       end
 
       # Abstract method (must be overriden in subclasses).

data/lib/rley/notation/tokenizer.rb

@@ -35,11 +35,11 @@ module Rley
         '*' => 'STAR',
         '..' => 'ELLIPSIS'
       }.freeze
-      
+
       # Here are all the implemented Rley notation keywords
       @@keywords = %w[
         match_closest repeat
-      ].map { |x| [x, x] }.to_h      
+      ].map { |x| [x, x] }.to_h
 
       # Constructor. Initialize a tokenizer for Lox input.
       # @param source [String] Lox text to tokenize.
@@ -84,7 +84,7 @@ module Rley
           token = build_token(@@lexeme2name[curr_ch], scanner.getch)
         elsif '?*+,'.include? curr_ch # modifier character
           # modifiers without prefix text are symbols
-          symb = ws_found ? 'SYMBOL' : @@lexeme2name[curr_ch] 
+          symb = ws_found ? 'SYMBOL' : @@lexeme2name[curr_ch]
           token = build_token(symb, scanner.getch)
         elsif (lexeme = scanner.scan(/\.\./))
           # One or two special character tokens
@@ -114,7 +114,6 @@ module Rley
           col = scanner.pos - lex_length - @line_start + 1
           pos = Rley::Lexical::Position.new(@lineno, col)
           token = Rley::Lexical::Token.new(aLexeme.dup, aSymbolName, pos)
-
         rescue StandardError => e
           puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
           raise e
@@ -148,21 +147,10 @@ module Rley
             when "\n"
               next_line
               literal << special
-            # when '\\'
-              # ch = scanner.scan(/./)
-              # next unless ch
-
-              # escaped = @@escape_chars[ch]
-              # if escaped
-                # literal << escaped
-              # else
-                # literal << ch
-              # end
             end
           end
         end
         pos = Rley::Lexical::Position.new(line, column_start)
-        lexeme = scanner.string[scan_pos - 1..scanner.pos - 1]
         Rley::Lexical::Token.new(literal, 'STR_LIT', pos)
       end
 

data/lib/rley/parse_rep/ast_base_builder.rb

@@ -135,24 +135,24 @@ module Rley # This module is used as a namespace
       # def reduce_base_plus_last(_production, _range, _tokens, theChildren)
         # [theChildren[0]]
       # end
-      
+
       # Implicit rule generated for * modifier
       # rule('X') => 'X item'.as '_star_more'
       def reduce__star_more(_production, _range, _tokens, theChildren)
-        theChildren[0]  << theChildren[1]
+        theChildren[0] << theChildren[1]
         theChildren[0]
       end
 
       # Implicit rule generated for * modifier
       # rule('X') => ''.as '_star_none'
-      def reduce__star_none(_production, _range, _tokens, theChildren)
+      def reduce__star_none(_production, _range, _tokens, _children)
         []
       end
 
       # Implicit rule generated for + modifier
       # rule('X') => 'X item'.as '_plus_more'
       def reduce__plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0]  << theChildren[1]
+        theChildren[0] << theChildren[1]
         theChildren[0]
       end
 
@@ -160,8 +160,7 @@ module Rley # This module is used as a namespace
       # rule('X') => 'item'.as '_plus_one'
       def reduce__plus_one(_production, _range, _tokens, theChildren)
         [theChildren[0]]
-      end      
-
+      end
     end # class
   end # module
 end # module

data/lib/rley/parser/gfg_chart.rb

@@ -20,7 +20,7 @@ module Rley # This module is used as a namespace
       # @param aGFGraph [GFG::GrmFlowGraph] The GFG for the grammar in use.
       def initialize(aGFGraph)
         @sets = [ParseEntrySet.new]
-        @constraints = [[]]        
+        @constraints = [[]]
         push_entry(aGFGraph.start_vertex, 0, 0, :start_rule)
       end
 
@@ -174,7 +174,7 @@ module Rley # This module is used as a namespace
             when :before # terminal before dot
               term_name = criteria[keyword]
               if e.dotted_entry? && e.vertex.dotted_item.position > -2
-                found << e if e.prev_symbol&.name == criteria[keyword]
+                found << e if e.prev_symbol&.name == term_name
               end
           end
         end
@@ -209,12 +209,13 @@ module Rley # This module is used as a namespace
           first_entry = sets[i][0]
           prev_symbol = first_entry.prev_symbol
           break if prev_symbol.name == aConstraint.closest_symb
+
           i -= 1
-          break if i < 0
+          break if i.negative?
         end
 
         # Retrieve all entries of the kind: closest_symb .
-        if i > 0
+        if i.positive?
           entries = sets[i].entries.select do |en|
             if en.prev_symbol
               en.prev_symbol.name == aConstraint.closest_symb