rley 0.7.06 → 0.8.01

data/examples/general/calc_iter2/calc_grammar.rb

@@ -5,33 +5,33 @@ require 'rley' # Load the gem
 
 ########################################
 # Define a grammar for basic arithmetical expressions
-builder = Rley::Syntax::GrammarBuilder.new do
+builder = Rley::grammar_builder do
   add_terminals('NUMBER')
   add_terminals('PLUS', 'MINUS') # For '+', '-' operators or sign
   add_terminals('STAR', 'DIVIDE', 'POWER') # For '*', '/', '**' operators
-  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters  
+  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters
   add_terminals('PI', 'E') # For numeric constants
   add_terminals('RESERVED') # Reserved identifiers
 
-  rule 'expression' => %w[simple_expression]
+  rule 'expression' => 'simple_expression'
   rule 'simple_expression' => 'term'
-  rule 'simple_expression' => %w[simple_expression add_operator term]
+  rule 'simple_expression' => 'simple_expression add_operator term'
   rule 'term' => 'factor'
-  rule 'term' => %w[term mul_operator factor]
+  rule 'term' => 'term mul_operator factor'
   rule 'factor' => 'simple_factor'
-  rule 'factor' => %w[factor POWER simple_factor]
-  rule 'simple_factor' => %w[sign scalar]
-  rule 'simple_factor' => %w[unary_function in_parenthesis]
-  rule 'simple_factor' => %w[MINUS in_parenthesis]
-  rule 'simple_factor' => 'in_parenthesis'  
+  rule 'factor' => 'factor POWER simple_factor'
+  rule 'simple_factor' => 'sign scalar'
+  rule 'simple_factor' => 'unary_function in_parenthesis'
+  rule 'simple_factor' => 'MINUS in_parenthesis'
+  rule 'simple_factor' => 'in_parenthesis'
   rule 'sign' => 'PLUS'
   rule 'sign' => 'MINUS'
   rule 'sign' => []
   rule 'scalar' => 'NUMBER'
   rule 'scalar' => 'PI'
-  rule 'scalar' => 'E'  
+  rule 'scalar' => 'E'
   rule 'unary_function' => 'RESERVED'
-  rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
+  rule 'in_parenthesis' => 'LPAREN expression RPAREN'
   rule 'add_operator' => 'PLUS'
   rule 'add_operator' => 'MINUS'
   rule 'mul_operator' => 'STAR'

data/examples/general/calc_iter2/calc_lexer.rb

@@ -10,7 +10,6 @@ class CalcLexer
   attr_reader(:lineno)
   attr_reader(:line_start)
 
-
   @@lexeme2name = {
     '(' => 'LPAREN',
     ')' => 'RPAREN',
@@ -22,7 +21,7 @@ class CalcLexer
     'PI' => 'PI',
     'E' => 'E'
   }.freeze
-  
+
   @@unary_functions = %w[
     sin cos tan asin acos atan
     sqrt cbrt exp ln log
@@ -35,7 +34,7 @@ class CalcLexer
     @lineno = 1
   end
 
-  def tokens()
+  def tokens
     @unary_f_pattern = Regexp.new(@@unary_functions.join('|'))
     tok_sequence = []
     until @scanner.eos?
@@ -48,11 +47,12 @@ class CalcLexer
 
   private
 
-  def _next_token()
+  # rubocop: disable Lint/DuplicateBranch
+  def _next_token
     skip_whitespaces
     curr_ch = scanner.peek(1)
     return nil if curr_ch.nil?
-    
+
     token = nil
 
     if '()+-/'.include? curr_ch
@@ -63,25 +63,26 @@ class CalcLexer
     elsif (lexeme = scanner.scan(/\*|PI|E/))
       token = build_token(@@lexeme2name[lexeme], lexeme)
     elsif (lexeme = scanner.scan(@unary_f_pattern))
-      token = build_token('RESERVED', lexeme)  
+      token = build_token('RESERVED', lexeme)
     elsif (lexeme = scanner.scan(/[0-9]+(\.[0-9]+)?([eE][-+]?[0-9])?/))
       token = build_token('NUMBER', lexeme)
     else # Unknown token
       erroneous = curr_ch.nil? ? '' : curr_ch
       sequel = scanner.scan(/.{1,20}/)
       erroneous += sequel unless sequel.nil?
-      raise ScanError.new("Unknown token #{erroneous}")
+      raise ScanError, "Unknown token #{erroneous}"
     end
 
     return token
   end
-  
+  # rubocop: enable Lint/DuplicateBranch
+
   def build_token(aSymbolName, aLexeme)
     pos = Rley::Lexical::Position.new(1, scanner.pos)
-    return Rley::Lexical::Token.new(aLexeme, aSymbolName, pos)    
+    return Rley::Lexical::Token.new(aLexeme, aSymbolName, pos)
   end
 
-  def skip_whitespaces()
+  def skip_whitespaces
     scanner.scan(/[ \t\f\n\r]+/)
   end
 end # class

data/examples/general/calc_iter2/spec/calculator_spec.rb

@@ -17,13 +17,13 @@ describe 'Calculator' do
     engine = Rley::Engine.new do |cfg|
       cfg.repr_builder = CalcASTBuilder
     end
-    
+
     engine.use_grammar(CalcGrammar)
     raw_result = parse_expression(engine, anExpression)
     ast = engine.to_ptree(raw_result)
     return expect(ast.root.interpret)
   end
-  
+
   def parse_expression(anEngine, anExpression)
     lexer = CalcLexer.new(anExpression)
     result = anEngine.parse(lexer.tokens)
@@ -40,7 +40,7 @@ describe 'Calculator' do
 
   context 'Parsing valid expressions' do
     let(:epsilon) { 0.0000000001 }
-  
+
     it 'should evaluate simple integer literals' do
       expect_expr('2').to eq(2)
     end
@@ -72,18 +72,18 @@ describe 'Calculator' do
     it 'should evaluate the pi constant' do
       expect_expr('PI').to eq(3.141592653589793)
     end
-    
+
     it 'should evaluate the negated pi constant' do
       expect_expr('-PI').to eq(-3.141592653589793)
-    end    
+    end
 
     it "should evaluate Neper's e constant" do
       expect_expr('E').to eq(2.718281828459045)
     end
-    
+
     it "should evaluate negated Neper's e constant" do
       expect_expr('-E').to eq(-2.718281828459045)
-    end    
+    end
 
     it 'should evaluate integer addition' do
       expect_expr('2 + 2').to eq(4)
@@ -156,7 +156,7 @@ describe 'Calculator' do
     it 'should evaluate multiple levels of parentheses' do
       expect_expr('2*(1/(1+3))').to eq(0.5)
     end
-    
+
     # Some special functions
     it 'should evaluate square root of expressions' do
       expect_expr('sqrt(0)').to eq(0)
@@ -170,69 +170,69 @@ describe 'Calculator' do
       expect_expr('cbrt(1)').to eq(1)
       expect_expr('cbrt(1 + 1)').to eq(Math.cbrt(2))
       expect_expr('cbrt(5 * 5 * 5)').to eq(5)
-    end     
+    end
 
     it 'should evaluate exponential of expressions' do
-      expect_expr('exp(-1)').to eq(1 / Math::E)    
+      expect_expr('exp(-1)').to eq(1 / Math::E)
       expect_expr('exp(0)').to eq(1)
       expect_expr('exp(1)').to eq(Math::E)
       expect_expr('exp(2)').to be_within(epsilon).of(Math::E * Math::E)
     end
 
     it 'should evaluate natural logarithm of expressions' do
-      expect_expr('ln(1/E)').to eq(-1)    
-      expect_expr('ln(1)').to eq(0)    
+      expect_expr('ln(1/E)').to eq(-1)
+      expect_expr('ln(1)').to eq(0)
       expect_expr('ln(E)').to eq(1)
       expect_expr('ln(E * E)').to eq(2)
-    end 
+    end
 
     it 'should evaluate the logarithm base 10 of expressions' do
-      expect_expr('log(1/10)').to eq(-1)    
-      expect_expr('log(1)').to eq(0)    
+      expect_expr('log(1/10)').to eq(-1)
+      expect_expr('log(1)').to eq(0)
       expect_expr('log(10)').to eq(1)
       expect_expr('log(10 * 10 * 10)').to eq(3)
-    end    
- 
+    end
+
     # Trigonometric functions
-    
+
     it 'should compute the sinus of an expression' do
       expect_expr('sin(0)').to eq(0)
       expect_expr('sin(PI/6)').to be_within(epsilon).of(0.5)
       expect_expr('sin(PI/2)').to eq(1)
     end
-    
+
     it 'should compute the cosinus of an expression' do
       expect_expr('cos(0)').to eq(1)
       expect_expr('cos(PI/3)').to be_within(epsilon).of(0.5)
       expect_expr('cos(PI/2)').to be_within(epsilon).of(0)
-    end 
+    end
 
     it 'should compute the tangent of an expression' do
       expect_expr('tan(0)').to eq(0)
       expect_expr('tan(PI/4)').to be_within(epsilon).of(1)
       expect_expr('tan(5*PI/12)').to be_within(epsilon).of(2 + Math.sqrt(3))
-    end    
- 
+    end
+
     # Inverse trigonometric functions
-    
+
     it 'should compute the arcsinus of an expression' do
       expect_expr('asin(0)').to eq(0)
       expect_expr('asin(0.5)').to be_within(epsilon).of(Math::PI / 6)
       expect_expr('asin(1)').to eq(Math::PI / 2)
     end
-    
+
     it 'should compute the arccosinus of an expression' do
       expect_expr('acos(1)').to eq(0)
       expect_expr('acos(0.5)').to be_within(epsilon).of(Math::PI / 3)
       expect_expr('acos(0)').to be_within(epsilon).of(Math::PI / 2)
-    end 
+    end
 
     it 'should compute the tangent of an expression' do
       expect_expr('atan(0)').to eq(0)
       pi = Math::PI
       expect_expr('atan(1)').to be_within(epsilon).of(pi / 4)
       expect_expr('atan(2 + sqrt(3))').to be_within(epsilon).of(5 * pi / 12)
-    end    
+    end
   end # context
 end # describe
 # End of file

data/examples/general/left.rb

@@ -8,10 +8,10 @@ builder = Rley::Syntax::GrammarBuilder.new do
   # The grammar defines a language that consists in a sequence
   # of 0 or more dots...
   add_terminals('DOT')
-  
+
   # Grammar with left recursive rule.
   rule 'l_dots' => []
-  rule 'l_dots' => %w[l_dots DOT]  
+  rule 'l_dots' => 'l_dots DOT'
 end
 
 # And now, let's build the grammar...

data/examples/general/right.rb

@@ -8,10 +8,10 @@ builder = Rley::Syntax::GrammarBuilder.new do
   # The grammar defines a language that consists in a sequence
   # of 0 or more dots...
   add_terminals('DOT')
-  
+
   # Grammar with right recursive rule.
   rule 'r_dots' => []
-  rule 'r_dots' => %w[DOT r_dots]  
+  rule 'r_dots' => 'DOT r_dots'
 end
 
 # And now, let's build the grammar...

data/lib/rley.rb

@@ -5,7 +5,7 @@
 # for a Rley client.
 
 require_relative './rley/constants'
-require_relative './rley/syntax/grammar_builder'
+require_relative './rley/interface'
 require_relative './rley/lexical/token'
 require_relative './rley/parser/gfg_earley_parser'
 require_relative './rley/parse_rep/ast_base_builder'

data/lib/rley/base/dotted_item.rb

@@ -19,14 +19,19 @@ module Rley # This module is used as a namespace
     class DottedItem
       # Production rule
       # @return [Syntax::Production]
-      attr_reader(:production)
+      attr_reader :production
 
       # Index of the next symbol (from the rhs) after the 'dot'.
       # If the dot is at the end of the rhs (i.e.) there is no next
       # symbol, then the position takes the value -1.
       # It the rhs is empty, then the position is -2
       # @return [Integer]
-      attr_reader(:position)
+      attr_reader :position
+
+      # A possible constraint between symbol on left of dot and
+      # the closest preceding given terminal
+      # @return [NilClass, Syntax::MatchClosest]
+      attr_accessor :constraint
 
       # @param aProduction [Syntax::Production]
       # @param aPosition [Integer] Position of the dot in rhs of production.
@@ -37,7 +42,7 @@ module Rley # This module is used as a namespace
 
       # Return a String representation of the dotted item.
       # @return [String]
-      def to_s()
+      def to_s
         prefix = "#{production.lhs} => "
         text_values = production.rhs.map(&:to_s)
         if position.negative?
@@ -47,13 +52,13 @@ module Rley # This module is used as a namespace
         end
         suffix = text_values.join(' ')
 
-        return prefix + suffix
+        prefix + suffix
       end
 
       # Return true if the dot position is at the start of the rhs.
       # @return [Boolean]
-      def at_start?()
-        return position.zero? || position == -2
+      def at_start?
+        position.zero? || position == -2
       end
 
       # An item with the dot at the beginning is called
@@ -62,41 +67,35 @@ module Rley # This module is used as a namespace
 
       # A dotted item is called a reduce item if the dot is at the end.
       # @return [Boolean]
-      def reduce_item?()
-        return position.negative? # Either -1 or -2
+      def reduce_item?
+        position.negative? # Either -1 or -2
       end
 
       # The non-terminal symbol that is on the left-side of the production
       # @return [Syntax::NonTerminal]
-      def lhs()
-        return production.lhs
+      def lhs
+        production.lhs
       end
 
       # Return the symbol before the dot.
       # nil is returned if the dot is at the start of the rhs
       # @return [Syntax::GrmSymbol, NilClass]
-      def prev_symbol()
+      def prev_symbol
         before_position = prev_position
-        result = if before_position.nil?
-                   nil
-                 else
-                   production.rhs[before_position]
-                 end
-
-        return result
+        before_position.nil? ? nil : production.rhs[before_position]
       end
 
       # Return the symbol after the dot.
       # nil is returned if the dot is at the end
       # @return [Syntax::GrmSymbol, NilClass]
-      def next_symbol()
-        return position.negative? ? nil : production.rhs[position]
+      def next_symbol
+        position.negative? ? nil : production.rhs[position]
       end
 
       # Calculate the position of the dot if were moved by
       # one step on the left.
       # @return [Integer]
-      def prev_position()
+      def prev_position
         unless @k_prev_position
           case position
             when -2, 0
@@ -122,7 +121,7 @@ module Rley # This module is used as a namespace
         to_the_left = prev_position
         return false if to_the_left.nil?
 
-        return to_the_left == another.position
+        to_the_left == another.position
       end
 
 
@@ -135,15 +134,13 @@ module Rley # This module is used as a namespace
           raise StandardError, 'Out of bound index'
         end
 
-        index = if rhs_size.zero?
-                  -2 # Minus 2 at start/end of empty production
-                elsif aPosition == rhs_size
-                  -1 # Minus 1 at end of non-empty production
-                else
-                  aPosition
-                end
-
-        return index
+        if rhs_size.zero?
+          -2 # Minus 2 at start/end of empty production
+        elsif aPosition == rhs_size
+          -1 # Minus 1 at end of non-empty production
+        else
+          aPosition
+        end
       end
     end # class
   end # module

data/lib/rley/base/grm_items_builder.rb

@@ -12,12 +12,18 @@ module Rley # This module is used as a namespace
       def build_dotted_items(aGrammar)
         items = []
         aGrammar.rules.each do |prod|
+          index_prev = items.size
           rhs_size = prod.rhs.size
           if rhs_size.zero?
             items << DottedItem.new(prod, 0)
           else
             items += (0..rhs_size).map { |i| DottedItem.new(prod, i) }
           end
+
+          prod.constraints.each do |cs|
+            # Attach constraint to dotted item n + 1
+            items[index_prev + cs.idx_symbol + 1].constraint = cs
+          end
         end
 
         return items