rley 0.7.06 → 0.8.01

data/examples/general/calc_iter1/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,23 +15,23 @@ 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
-  
+
   # 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 CalcNumberNode < CalcTerminalNode
@@ -53,30 +52,26 @@ class CalcCompositeNode
 
   def initialize(aSymbol)
     @symbol = aSymbol
-    @children = []    
+    @children = []
   end
-  
-  def done!()
+
+  def done!
     # Do nothing
-  end  
+  end
 
   # Part of the 'visitee' role in Visitor design pattern.
   # @param aVisitor[ParseTreeVisitor] the visitor
   def accept(aVisitor)
     aVisitor.visit_nonterminal(self)
   end
-  
+
   alias subnodes children
 end # class
 
 class CalcUnaryOpNode < CalcCompositeNode
-  def initialize(aSymbol)
-    super(aSymbol)
-  end
-
   # Convert this tree node in a simpler Ruby representation.
   # Basically a Calc object corresponds to a Ruhy Hash
-  def to_ruby()
+  def to_ruby
     rep = {}
     members.each do |pair|
       rep[pair.name.to_ruby] = pair.value.to_ruby
@@ -92,13 +87,9 @@ class CalcNegateNode < CalcUnaryOpNode
 end # class
 
 class CalcBinaryOpNode < CalcCompositeNode
-  def initialize(aSymbol)
-    super(aSymbol)
-  end
-  
   protected
-  
-  def retrieve_operands()
+
+  def retrieve_operands
     operands = []
     children.each do |child|
       oper = child.respond_to?(:interpret) ? child.interpret : child
@@ -111,42 +102,37 @@ 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
 # End of file

data/examples/general/calc_iter1/calc_grammar.rb

@@ -5,22 +5,23 @@ 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('LPAREN', 'RPAREN') # For '(', ')' delimiters
   add_terminals('PLUS', 'MINUS') # For '+', '-' operators
   add_terminals('STAR', 'DIVIDE') # For '*', '/' operators
+
   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' => 'NUMBER'
-  rule 'factor' => %w[LPAREN expression RPAREN]
+  rule 'factor' => '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