rley 0.7.00 → 0.7.01

data/lib/rley/ptree/parse_tree_node.rb

@@ -16,6 +16,7 @@ module Rley # This module is used as a namespace
       
       # Notify the builder that the construction is over
       def done!()
+        # Do nothing
       end
 
       # Assign a value from given range to each  undefined range bound

data/lib/rley/sppf/parse_forest.rb

@@ -31,6 +31,7 @@ module Rley # This module is used as a namespace
       
       # Notification that the SPPF construction is over
       def done!
+        # Do nothing
       end
       
       # Returns true if the given node is present in the forest.
@@ -44,15 +45,16 @@ module Rley # This module is used as a namespace
         return @is_ambiguous
       end
       
-      # Create an Enumerator that helps to iterate over the possible parse trees. 
-      # That enumerator will generate a parse tree when called with `next` method.
+      # 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()
-         # 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
+        # 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      
 
       # Part of the 'visitee' role in the Visitor design pattern.

data/lib/rley/syntax/grammar.rb

@@ -26,7 +26,7 @@ module Rley # This module is used as a namespace
       attr_reader(:symbols)
 
       # A Hash that maps symbol names to their grammar symbols
-      # @return [Hash{String => GrmSymbol}] 
+      # @return [Hash{String => GrmSymbol}]
       attr_reader(:name2symbol)
 
       # @param theProductions [Array<Production>] productions of the grammar.
@@ -62,6 +62,7 @@ module Rley # This module is used as a namespace
       def validate_productions(theProductions)
         msg = 'A grammar must have at least one production'
         raise StandardError, msg if theProductions.nil? || theProductions.empty?
+
         return theProductions
       end
 
@@ -133,6 +134,7 @@ module Rley # This module is used as a namespace
 
           rules.each do |a_rule|
             next unless a_rule.generative?.nil?
+
             if a_rule.empty?
               a_rule.generative = false
               curr_marked << a_rule
@@ -146,6 +148,7 @@ module Rley # This module is used as a namespace
               break unless symbol.generative?
             end
             next if last_considered.generative?.nil?
+
             a_rule.generative = last_considered.generative?
             curr_marked << a_rule
             could_mark_nterm_generative(a_rule)
@@ -211,30 +214,31 @@ module Rley # This module is used as a namespace
             end
           end
           break if new_nullables.empty?
+
           filtered_rules.reject! { |prod| prod.lhs.nullable? }
           nullable_sets[i] = nullable_sets[i - 1].merge(new_nullables)
         end
-        
+
         mark_nullable
       end
 
       # Return the set of nonterminals which have one of their
       # production rules empty
-      def direct_nullable()
+      def direct_nullable
         nullables = Set.new
         # Direct nullable nonterminals correspond to empty productions
         rules.each do |prod|
           next unless prod.empty?
+
           prod.lhs.nullable = true
           nullables << prod.lhs
         end
 
         return nullables
       end
-      
-      
+
       # For each prodction determine whether it is nullable or not.
-      # A nullable production is a production that can match an empty string.      
+      # A nullable production is a production that can match an empty string.
       def mark_nullable
         rules.each do |prod|
           if prod.empty?

data/lib/rley/syntax/grammar_builder.rb

@@ -75,8 +75,8 @@ module Rley # This module is used as a namespace
             when Array
               rhs_members = rhs_repr.map { |name| get_nonterminal(name) }
             when String
-              # rhs_members = [get_nonterminal(rhs_repr)]
-              rhs_members = rhs_repr.scan(/\S+/).map { |name| get_nonterminal(name) }
+              rhs_lexemes = rhs_repr.scan(/\S+/)
+              rhs_members = rhs_lexemes.map { |name| get_nonterminal(name) }
             when Terminal
               rhs_members = [rhs_repr]
           end

data/lib/rley/syntax/grm_symbol.rb

@@ -14,6 +14,7 @@ module Rley # This module is used as a namespace
       # aName [String] The name of the grammar symbol.
       def initialize(aName)
         raise 'Internal error: nil name encountered' if aName.nil?
+
         @name = aName.dup
         @name.freeze
       end

data/lib/support/base_tokenizer.rb

@@ -37,13 +37,14 @@ class BaseTokenizer
   
   # Patterns:
   # Unambiguous single character
-  # Conditional single character (e.g. '+' operator, '+' prefix for positive numbers) 
+  # Conditional single character:
+  #  (e.g. '+' operator, '+' prefix for positive numbers) 
   def _next_token
     skip_whitespaces
     curr_ch = scanner.peek(1)
     return nil if curr_ch.nil? || curr_ch.empty?
 
-    token = recognize_token()
+    token = recognize_token
     if token.nil? # Unknown token
       curr_ch = scanner.peek(1)
       erroneous = curr_ch.nil? ? '' : scanner.scan(/./)
@@ -55,40 +56,8 @@ class BaseTokenizer
     return token
   end
   
-  def recognize_token()
-=begin
-    if "()'`".include? curr_ch # Single characters
-      # Delimiters, separators => single character token
-      token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-    elsif (lexeme = scanner.scan(/(?:\.)(?=\s)/)) # Single char occurring alone
-      token = build_token('PERIOD', lexeme)
-    elsif (lexeme = scanner.scan(/,@?/))
-      token = build_token(@@lexeme2name[lexeme], lexeme)
-    elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
-      token = cardinal_token(lexeme)        
-    elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?=\s|[|()";]|$)/))
-      token = build_token('INTEGER', lexeme) # Decimal radix
-    elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:\.[0-9]+)?(?:(?:e|E)[+-]?[0-9]+)?/))
-      # Order dependency: must be tested after INTEGER case
-      token = build_token('REAL', lexeme)
-    elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/)) # Double quotes literal?
-      token = build_token('STRING_LIT', lexeme)
-    elsif (lexeme = scanner.scan(/[a-zA-Z!$%&*\/:<=>?@^_~][a-zA-Z0-9!$%&*+-.\/:<=>?@^_~+-]*/))
-      keyw = @@keywords[lexeme.upcase]
-      tok_type = keyw ? keyw : 'IDENTIFIER'
-      token = build_token(tok_type, lexeme)
-    elsif (lexeme = scanner.scan(/\|(?:[^|])*\|/)) # Vertical bar delimited
-      token = build_token('IDENTIFIER', lexeme)
-    elsif (lexeme = scanner.scan(/([\+\-])((?=\s|[|()";])|$)/))
-      #  # R7RS peculiar identifiers case 1: isolated plus and minus as identifiers
-      token = build_token('IDENTIFIER', lexeme)
-    elsif (lexeme = scanner.scan(/[+-][a-zA-Z!$%&*\/:<=>?@^_~+-@][a-zA-Z0-9!$%&*+-.\/:<=>?@^_~+-]*/))
-      # R7RS peculiar identifiers case 2
-      token = build_token('IDENTIFIER', lexeme)
-    elsif (lexeme = scanner.scan(/\.[a-zA-Z!$%&*\/:<=>?@^_~+-@.][a-zA-Z0-9!$%&*+-.\/:<=>?@^_~+-]*/))
-      # R7RS peculiar identifiers case 4
-      token = build_token('IDENTIFIER', lexeme)
-=end  
+  def recognize_token
+    raise NotImplementedError
   end
   
   def build_token(aSymbolName, aLexeme, aFormat = :default)
@@ -105,7 +74,7 @@ class BaseTokenizer
     return token
   end
   
-  def convert_to(aLexeme, aSymbolName, aFormat)
+  def convert_to(aLexeme, _symbol_name, _format)
     return aLexeme
   end
  
@@ -124,11 +93,11 @@ class BaseTokenizer
       end
       # next_ch = scanner.peek(1)
       # if next_ch == ';'
-        # cmt_found = true
-        # scanner.skip(/;[^\r\n]*(?:(?:\r\n)|\r|\n)?/)
-        # next_line
+      #   cmt_found = true
+      #   scanner.skip(/;[^\r\n]*(?:(?:\r\n)|\r|\n)?/)
+      #   next_line
       # end
-      break unless ws_found or cmt_found
+      break unless ws_found || cmt_found
     end
 
     curr_pos = scanner.pos
@@ -140,58 +109,3 @@ class BaseTokenizer
     @line_start = scanner.pos
   end  
 end # class
-=begin  
-require 'base_tokenizer'
-
-class PB_Tokenizer < BaseTokenizer
-  @@lexeme2name = {
-    '(' => 'LPAREN',
-    ')' => 'RPAREN',
-    '+' => 'PLUS',
-  }.freeze
-
-  protected
-  
-  def recognize_token()
-    token = nil
-    curr_ch = scanner.peek(1)
-    
-    if '()'.include? curr_ch # Single characters
-      # Delimiters, separators => single character token
-      token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-    elsif (lexeme = scanner.scan(/(?:\+)(?=\s)/)) # Single char occurring alone
-      token = build_token(@@lexeme2name[lexeme], lexeme)
-     elsif (lexeme = scanner.scan(/[+-]?[0-9]+/))
-      token = build_token('INTEGER', lexeme)
-    end
-  end
-end # class
-
-  # Basic tokenizer
-  # @return [Array<Rley::Lexical::Token>]
-  def tokenize(aText)
-    tokenizer = PB_Tokenizer.new(aText)
-    tokenizer.token
-  end
-
-=end 
-=begin  
-  # Basic expression tokenizer
-  def tokenize(aText)
-    tokens = aText.scan(/\S+/).map do |lexeme|
-      case lexeme
-        when '+', '(', ')'
-          terminal = @grammar.name2symbol[lexeme]
-        when /^[-+]?\d+$/
-          terminal = @grammar.name2symbol['int']
-        else
-          msg = "Unknown input text '#{lexeme}'"
-          raise StandardError, msg
-      end
-      pos = Rley::Lexical::Position.new(1, 4) # Dummy position
-      Rley::Lexical::Token.new(lexeme, terminal, pos)
-    end
-
-    return tokens
-  end
-=end

data/spec/rley/engine_spec.rb

@@ -17,10 +17,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       it 'could be created with block argument' do
-        expect { Engine.new do |config|
+        expect do 
+                 Engine.new do |config|
                    config.parse_repr = :raw
                  end
-               }.not_to raise_error
+               end.not_to raise_error
       end
 
       it "shouldn't have a link to a grammar yet" do
@@ -145,7 +146,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         visitor = subject.pforest_visitor(ptree)
         expect(visitor).to be_kind_of(ParseForestVisitor)
       end
-
     end # context
   end # describe
 end # module

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -138,6 +138,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should have shortcut edges' do
           subject.vertices.each do |a_vertex|
             next unless a_vertex.kind_of?(ItemVertex)
+
             if a_vertex.next_symbol.kind_of?(Syntax::NonTerminal)
               expect(a_vertex.shortcut).not_to be_nil
               my_d_item = a_vertex.dotted_item

data/spec/rley/parse_forest_visitor_spec.rb

@@ -179,12 +179,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             expect(children.size).to eq(2)
           },
           ->(event, item) {
-            check_event(event, item, [:before_alternative, 'Alt(S => a T .)[0, 4]'])
+            prediction = 'Alt(S => a T .)[0, 4]'
+            check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(S => a T .)[0, 4]', 6]) # 2 * 3
             check_node_accesses(item, [6])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:before_subnodes, 'Alt(S => a T .)[0, 4]'])
+            prediction = 'Alt(S => a T .)[0, 4]'
+            check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
           },
           ->(event, item) {
@@ -220,27 +222,31 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_terminal, 'b[3, 4]'])
           },
-          ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'T[1, 4]'])
           },
           ->(event, item) {
             check_event(event, item, [:after_non_terminal, 'T[1, 4]'])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:after_subnodes, 'Alt(S => a T .)[0, 4]'])
+            prediction = 'Alt(S => a T .)[0, 4]'
+            check_event(event, parent, [:after_subnodes, prediction])
             expect(children.size).to eq(2)
             check_legs(['Alt(S => a T .)[0, 4]', 6]) # 2 * 3
           },
           ->(event, item) {
-            check_event(event, item, [:after_alternative, 'Alt(S => a T .)[0, 4]'])
+            prediction = 'Alt(S => a T .)[0, 4]'
+            check_event(event, item, [:after_alternative, prediction])
           },
           ->(event, item) {
-            check_event(event, item, [:before_alternative, 'Alt(S => A T .)[0, 4]'])
+            prediction = 'Alt(S => A T .)[0, 4]'
+            check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(S => A T .)[0, 4]', 10]) # 2 * 5
             check_node_accesses(item, [10])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:before_subnodes, 'Alt(S => A T .)[0, 4]'])
+            prediction = 'Alt(S => A T .)[0, 4]'
+            check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
           },
           ->(event, item) {
@@ -253,13 +259,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             expect(children.size).to eq(2)
           },
           ->(event, item) {
-            check_event(event, item, [:before_alternative, 'Alt(A => a .)[0, 1]'])
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
             check_node_accesses(item, [7130])
             # p(subject.legs)
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:before_subnodes, 'Alt(A => a .)[0, 1]'])
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(1)
           },
           ->(event, item) {
@@ -268,20 +276,24 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_terminal, 'a[0, 1]'])
           },
-          ->(event, parent, children) {
-            check_event(event, parent, [:after_subnodes, 'Alt(A => a .)[0, 1]'])
+          ->(event, parent, _children) {
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, parent, [:after_subnodes, prediction])
             check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
           },
           ->(event, item) {
-            check_event(event, item, [:after_alternative, 'Alt(A => a .)[0, 1]'])
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, item, [:after_alternative, prediction])
           },
           ->(event, item) {
-            check_event(event, item, [:before_alternative, 'Alt(A => B A .)[0, 1]'])
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(A => B A .)[0, 1]', 8510]) # 2 * 5 * 23 * 37
             check_node_accesses(item, [8510])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:before_subnodes, 'Alt(A => B A .)[0, 1]'])
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
           },
           ->(event, item) {
@@ -299,7 +311,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_epsilon, '_[0, 0]'])
           },
-          ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'B[0, 0]'])
             check_legs(['B[0, 0]', 365930]) # 2 * 5 * 23 * 37 * 43
           },
@@ -316,12 +328,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             expect(children.size).to eq(2)
           },
           ->(event, item) {
-            check_event(event, item, [:before_alternative, 'Alt(A => a .)[0, 1]'])
-            check_legs(['Alt(A => a .)[0, 1]', 12399070])  # 2 * 5 * 23 * 37 * 47 * 31
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, item, [:before_alternative, prediction])
+            # 12399070 = 2 * 5 * 23 * 37 * 47 * 31
+            check_legs(['Alt(A => a .)[0, 1]', 12399070])
             check_node_accesses(item, [7130, 12399070])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:before_subnodes, 'Alt(A => a .)[0, 1]'])
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(1)
           },
           ->(event, item) {
@@ -330,21 +345,26 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_terminal, 'a[0, 1]'])
           },
-          ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'Alt(A => a .)[0, 1]'])
-            check_legs(['Alt(A => a .)[0, 1]', 12399070]) # 2 * 5 * 23 * 37 * 47 * 31
+            # 12399070 = 2 * 5 * 23 * 37 * 47 * 31
+            check_legs(['Alt(A => a .)[0, 1]', 12399070]) 
           },
           ->(event, item) {
-            check_event(event, item, [:after_alternative, 'Alt(A => a .)[0, 1]'])
+            prediction = 'Alt(A => a .)[0, 1]'
+            check_event(event, item, [:after_alternative, prediction])
           },
           ->(event, item) {
-            check_event(event, item, [:before_alternative, 'Alt(A => B A .)[0, 1]'])
-            # For prime factoring: https://www.calculatorsoup.com/calculators/math/prime-factors.php
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, item, [:before_alternative, prediction])
+            # For prime factoring: 
+            # https://www.calculatorsoup.com/calculators/math/prime-factors.php
             check_legs(['Alt(A => B A .)[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
             check_node_accesses(item, [8510, 399970])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:before_subnodes, 'Alt(A => B A .)[0, 1]'])
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
           },
           ->(event, item) {
@@ -362,36 +382,40 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_epsilon, '_[0, 0]'])
           },
-           ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'B[0, 0]'])
             check_legs(['B[0, 0]', 17198710]) # 2 * 5 * 23 * 37 * 43 * 47
           },
           ->(event, item) {
             check_event(event, item, [:after_non_terminal, 'B[0, 0]'])
           },
-          ->(event, parent, children) {
-            check_event(event, parent, [:after_subnodes, 'Alt(A => B A .)[0, 1]'])
+          ->(event, parent, _children) {
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, parent, [:after_subnodes, prediction])
             check_legs(['Alt(A => B A .)[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
             check_node_accesses(parent, [8510, 399970])
           },
           ->(event, item) {
-            check_event(event, item, [:after_alternative, 'Alt(A => B A .)[0, 1]'])
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, item, [:after_alternative, prediction])
           },
-          ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'A[0, 1]'])
             check_legs(['A[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
           },
           ->(event, item) {
             check_event(event, item, [:after_non_terminal, 'A[0, 1]'])
           },
-          ->(event, parent, children) {
-            check_event(event, parent, [:after_subnodes, 'Alt(A => B A .)[0, 1]'])
+          ->(event, parent, _children) {
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, parent, [:after_subnodes, prediction])
             check_legs(['Alt(A => B A .)[0, 1]', 8510]) # 2 * 5 * 23 * 37
           },
           ->(event, item) {
-            check_event(event, item, [:after_alternative, 'Alt(A => B A .)[0, 1]'])
+            prediction = 'Alt(A => B A .)[0, 1]'
+            check_event(event, item, [:after_alternative, prediction])
           },
-          ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'A[0, 1]'])
             check_legs(['A[0, 1]', 230]) # 2 * 5 * 23
           },
@@ -425,19 +449,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_terminal, 'b[3, 4]'])
           },
-          ->(event, parent, children) {
+          ->(event, parent, _children) {
             check_event(event, parent, [:after_subnodes, 'T[1, 4]'])
           },
           ->(event, item) {
             check_event(event, item, [:after_non_terminal, 'T[1, 4]'])
           },
           ->(event, parent, children) {
-            check_event(event, parent, [:after_subnodes, 'Alt(S => A T .)[0, 4]'])
+            prediction = 'Alt(S => A T .)[0, 4]'
+            check_event(event, parent, [:after_subnodes, prediction])
             expect(children.size).to eq(2)
             check_legs(['Alt(S => A T .)[0, 4]', 10]) # 2 * 5
           },
-          ->(event, item) {
-            check_event(event, item, [:after_alternative, 'Alt(S => A T .)[0, 4]'])
+          ->(evt, itm) {
+            check_event(evt, itm, [:after_alternative, 'Alt(S => A T .)[0, 4]'])
           }, 
           ->(event, parent, children) {
             check_event(event, parent, [:after_subnodes, 'S[0, 4]'])
@@ -447,7 +472,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ->(event, item) {
             check_event(event, item, [:after_non_terminal, 'S[0, 4]'])
           },          
-           ->(event, parent, children) {
+          ->(event, parent, children) {
             check_event(event, parent, [:after_subnodes, 'Phi[0, 4]'])
             expect(children.size).to eq(1)
           },