rley 0.7.07 → 0.7.08

data/examples/general/calc_iter1/calc_grammar.rb

@@ -18,9 +18,9 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'factor' => 'NUMBER'
   rule 'factor' => %w[LPAREN expression RPAREN]
   rule 'add_operator' => 'PLUS'
-  rule 'add_operator' => 'MINUS'  
+  rule 'add_operator' => 'MINUS'
   rule 'mul_operator' => 'STAR'
-  rule 'mul_operator' => 'DIVIDE'   
+  rule 'mul_operator' => 'DIVIDE'
 end
 
 # And now build the grammar...

data/examples/general/calc_iter1/calc_lexer.rb

@@ -28,7 +28,7 @@ class CalcLexer
     @lineno = 1
   end
 
-  def tokens()
+  def tokens
     tok_sequence = []
     until @scanner.eos?
       token = _next_token
@@ -40,7 +40,8 @@ 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?
@@ -63,18 +64,19 @@ class CalcLexer
       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)
   end
 
-  def skip_whitespaces()
+  def skip_whitespaces
     scanner.scan(/[ \t\f\n\r]+/)
   end
 end # class

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

@@ -12,13 +12,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)
@@ -31,7 +31,7 @@ describe 'Calculator' do
     end
 
     return result
-  end  
+  end
 
   it 'should evaluate simple number literals' do
     expect_expr('2').to eq(2)
@@ -56,7 +56,7 @@ describe 'Calculator' do
   it 'should evaluate parentheses' do
     expect_expr('2 * (2.1 + 1)').to eq(6.2)
   end
-  
+
   it 'should evaluate regardless of whitespace' do
     expect_expr("2*(1+\t1)").to eq(4)
   end
@@ -67,6 +67,6 @@ describe 'Calculator' do
 
   it 'should evaluate multiple levels of parentheses' do
     expect_expr('2*(1/(1+3))').to eq(0.5)
-  end  
+  end
 end # describe
 # End of file

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -15,8 +15,7 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
     # The unary negation operator on one hand, the binary substraction operator
     'MINUS' => { 'add_operator_1' =>  Rley::PTree::TerminalNode,
                  'simple_factor_2' => CalcNegateNode,
-                 'sign_1' => CalcNegateNode
-               },
+                 'sign_1' => CalcNegateNode },
     'NUMBER' => CalcNumberNode,
     'PI' => CalcConstantNode,
     'E' => CalcConstantNode,
@@ -25,7 +24,7 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
 
   protected
 
-  def terminal2node()
+  def terminal2node
     Terminal2NodeClass
   end
 
@@ -36,6 +35,8 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
     return operator_node
   end
 
+  # rubocop: disable Naming/VariableNumber
+
   # rule 'simple_expression' => %w[simple_expression add_operator term]
   def reduce_simple_expression_1(_production, _range, _tokens, theChildren)
     reduce_binary_operator(theChildren)
@@ -106,5 +107,6 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   def reduce_mul_operator_1(_production, aRange, _tokens, theChildren)
     return CalcDivideNode.new(theChildren[0].symbol, aRange)
   end
+  # rubocop: enable Naming/VariableNumber
 end # class
 # End of file

data/examples/general/calc_iter2/calc_ast_nodes.rb

@@ -3,7 +3,6 @@
 # Classes that implement nodes of Abstract Syntax Trees (AST) representing
 # calculator parse results.
 
-
 CalcTerminalNode = Struct.new(:token, :value, :position) do
   def initialize(aToken, aPosition)
     self.token = aToken
@@ -16,15 +15,15 @@ CalcTerminalNode = Struct.new(:token, :value, :position) do
     self.value = aLiteral.dup
   end
 
-  def symbol()
+  def symbol
     token.terminal
   end
 
-  def interpret()
-    return value
+  def interpret
+    value
   end
-  
-  def done!()
+
+  def done!
     # Do nothing
   end
 
@@ -45,9 +44,9 @@ class CalcNumberNode < CalcTerminalNode
         self.value = aLiteral.to_f
     end
   end
-  
+
   # Overriding the unary minus operator
-  def -@()
+  def -@
     self.value = - value
     return self
   end
@@ -83,8 +82,8 @@ class CalcCompositeNode
   def accept(aVisitor)
     aVisitor.visit_nonterminal(self)
   end
-  
-  def done!()
+
+  def done!
     # Do nothing
   end
 
@@ -92,44 +91,36 @@ class CalcCompositeNode
 end # class
 
 class CalcUnaryOpNode < CalcCompositeNode
-  def initialize(aSymbol, aPosition)
-    super(aSymbol, aPosition)
-  end
-
   alias members children
 end # class
 
-class CalcNegateNode < CalcUnaryOpNode  
-  def interpret()
+class CalcNegateNode < CalcUnaryOpNode
+  def interpret
     return -children[0].interpret
   end
 end # class
 
 class CalcUnaryFunction < CalcCompositeNode
-  @@name_mapping = begin 
+  @@name_mapping = begin
     map = Hash.new { |me, key| me[key] = key }
     map['ln'] = 'log'
     map['log'] = 'log10'
     map
   end
   attr_accessor(:func_name)
-  
-  
-  def interpret()
+
+
+  def interpret
     argument = children[0].interpret
     internal_name = @@name_mapping[@func_name]
     return Math.send(internal_name.to_sym, argument)
-  end  
+  end
 end
 
 class CalcBinaryOpNode < CalcCompositeNode
-  def initialize(aSymbol, aRange)
-    super(aSymbol, aRange)
-  end
-
   protected
 
-  def retrieve_operands()
+  def retrieve_operands
     operands = []
     children.each do |child|
       oper = child.respond_to?(:interpret) ? child.interpret : child
@@ -142,52 +133,45 @@ end # class
 
 class CalcAddNode < CalcBinaryOpNode
   # TODO
-  def interpret()
+  def interpret
     operands = retrieve_operands
 
-    sum = operands[0] + operands[1]
-    return sum
+    operands[0] + operands[1]
   end
 end # class
 
-
 class CalcSubtractNode < CalcBinaryOpNode
   # TODO
-  def interpret()
+  def interpret
     operands = retrieve_operands
 
-    substraction = operands[0] - operands[1]
-    return substraction
+    operands[0] - operands[1]
   end
 end # class
 
 class CalcMultiplyNode < CalcBinaryOpNode
   # TODO
-  def interpret()
+  def interpret
     operands = retrieve_operands
-    multiplication = operands[0] * operands[1]
-    return multiplication
+    operands[0] * operands[1]
   end
 end # class
 
 class CalcDivideNode < CalcBinaryOpNode
   # TODO
-  def interpret()
+  def interpret
     operands = retrieve_operands
     numerator = operands[0].to_f
     denominator = operands[1]
-    division =  numerator / denominator
-    return division
+    numerator / denominator
   end
 end # class
 
-
 class PowerNode < CalcBinaryOpNode
   # TODO
-  def interpret()
+  def interpret
     operands = retrieve_operands
-    exponentiation = operands[0]**operands[1]
-    return exponentiation
+    operands[0]**operands[1]
   end
 end # class
 # End of file

data/examples/general/calc_iter2/calc_grammar.rb

@@ -9,7 +9,7 @@ builder = Rley::Syntax::GrammarBuilder.new 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
 
@@ -23,13 +23,13 @@ builder = Rley::Syntax::GrammarBuilder.new do
   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 '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 'add_operator' => 'PLUS'

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