rley 0.6.00 → 0.6.01

data/examples/general/SRL/spec/regex/multiplicity_spec.rb

@@ -1,53 +1,50 @@
 # File: Multiplicity_spec.rb
 
-require 'pp'
-require_relative '../spec_helper'	# Use the RSpec test framework
+require_relative '../spec_helper' # Use the RSpec test framework
 require_relative '../../lib/regex/multiplicity'
 
 module SRL
   # Reopen the module, in order to get rid of fully qualified names
-  module Regex	# This module is used as a namespace
-
+  module Regex # This module is used as a namespace
     describe Multiplicity do
-
-      context "Creation & initialisation" do
-        it "should be created with 3 arguments" do
+      context 'Creation & initialisation' do
+        it 'should be created with 3 arguments' do
           # Valid cases: initialized with two integer values and a policy symbol
-          [:greedy, :lazy, :possessive].each do |aPolicy|
+          %i[greedy lazy possessive].each do |aPolicy|
             expect { Multiplicity.new(0, 1, aPolicy) }.not_to raise_error
           end
-          
+
           # Invalid case: initialized with invalid policy value
-          err = "Invalid repetition policy 'wrong'."
-          expect { Multiplicity.new(0, :more, 'wrong') }.to raise_error(StandardError, err)
+          err = StandardError
+          msg = "Invalid repetition policy 'KO'."
+          expect { Multiplicity.new(0, :more, 'KO') }.to raise_error(err, msg)
         end
-      
       end
-      
-      context "Provided services" do
+
+      context 'Provided services' do
         it 'should know its text representation' do
-          policy2text = { :greedy => '' , :lazy => '?', :possessive => '+' }
-          
+          policy2text = { greedy: '', lazy: '?', possessive: '+' }
+
           # Case: zero or one
-          policy2text.keys.each do |aPolicy|
+          policy2text.each_key do |aPolicy|
             multi = Multiplicity.new(0, 1, aPolicy)
             expect(multi.to_str).to eq("?#{policy2text[aPolicy]}")
           end
-          
+
           # Case: zero or more
-          policy2text.keys.each do |aPolicy|
+          policy2text.each_key do |aPolicy|
             multi = Multiplicity.new(0, :more, aPolicy)
             expect(multi.to_str).to eq("*#{policy2text[aPolicy]}")
           end
-          
+
           # Case: one or more
-          policy2text.keys.each do |aPolicy|
+          policy2text.each_key do |aPolicy|
             multi = Multiplicity.new(1, :more, aPolicy)
             expect(multi.to_str).to eq("+#{policy2text[aPolicy]}")
           end
-          
+
           # Case: exactly m times
-          policy2text.keys.each do |aPolicy|
+          policy2text.each_key do |aPolicy|
             samples = [1, 2, 5, 100]
             samples.each do |aCount|
               multi = Multiplicity.new(aCount, aCount, aPolicy)
@@ -56,28 +53,27 @@ module SRL
           end
 
           # Case: m, n times
-          policy2text.keys.each do |aPolicy|
+          policy2text.each_key do |aPolicy|
             samples = [1, 2, 5, 100]
             samples.each do |aCount|
               upper = aCount + 1 + rand(20)
               multi = Multiplicity.new(aCount, upper, aPolicy)
-              expect(multi.to_str).to eq("{#{aCount},#{upper}}#{policy2text[aPolicy]}")
+              expectation = "{#{aCount},#{upper}}#{policy2text[aPolicy]}"
+              expect(multi.to_str).to eq(expectation)
             end
           end
 
           # Case: m or more
-          policy2text.keys.each do |aPolicy|
+          policy2text.each_key do |aPolicy|
             samples = [2, 3, 5, 100]
             samples.each do |aCount|
               multi = Multiplicity.new(aCount, :more, aPolicy)
               expect(multi.to_str).to eq("{#{aCount},}#{policy2text[aPolicy]}")
             end
-          end			
+          end
         end
-      end	
-
+      end
     end
-
   end # module
 end # module
-# End of file
+# End of file

data/examples/general/SRL/spec/spec_helper.rb

@@ -5,7 +5,7 @@ require 'simplecov'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
   [
-    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::HTMLFormatter
   ]
 )
 

data/examples/general/SRL/spec/tokenizer_spec.rb

@@ -12,11 +12,9 @@ module SRL
       end
     end
   
-  
     subject { Tokenizer.new('') }    
     
     context 'Initialization:' do
-
       it 'should be initialized with a text to tokenize and a grammar' do
         expect { Tokenizer.new('anything') }.not_to raise_error
       end
@@ -66,8 +64,8 @@ module SRL
         input = 'literally "hello"'
         subject.scanner.string = input
         expectations = [
-          ['LITERALLY', 'literally'],
-          ['STRING_LIT', 'hello']
+          %w[LITERALLY literally],
+          %w[STRING_LIT hello]
         ]
         match_expectations(subject, expectations)
       end    
@@ -78,10 +76,10 @@ module SRL
         input = 'letter a to f'
         subject.scanner.string = input
         expectations = [
-          ['LETTER', 'letter'],
-          ['LETTER_LIT', 'a'],
-          ['TO', 'to'],
-          ['LETTER_LIT', 'f']
+          %w[LETTER letter],
+          %w[LETTER_LIT a],
+          %w[TO to],
+          %w[LETTER_LIT f]
         ]
         match_expectations(subject, expectations)
       end    
@@ -92,9 +90,9 @@ module SRL
         input = 'exactly 4 Times'
         subject.scanner.string = input
         expectations = [
-          ['EXACTLY', 'exactly'],
-          ['DIGIT_LIT', '4'],
-          ['TIMES', 'Times']
+          %w[EXACTLY exactly],
+          %w[DIGIT_LIT 4],
+          %w[TIMES Times]
         ]
         match_expectations(subject, expectations)
       end
@@ -103,11 +101,11 @@ module SRL
         input = 'Between 2 AND 4 times'
         subject.scanner.string = input
         expectations = [
-          ['BETWEEN', 'Between'],
-          ['DIGIT_LIT', '2'],
-          ['AND', 'AND'],
-          ['DIGIT_LIT', '4'],
-          ['TIMES', 'times']
+          %w[BETWEEN Between],
+          %w[DIGIT_LIT 2],
+          %w[AND AND],
+          %w[DIGIT_LIT 4],
+          %w[TIMES times]
         ]
         match_expectations(subject, expectations)
       end
@@ -116,9 +114,9 @@ module SRL
         input = 'Once or MORE'
         subject.scanner.string = input
         expectations = [
-          ['ONCE', 'Once'],
-          ['OR', 'or'],
-          ['MORE', 'MORE']
+          %w[ONCE Once],
+          %w[OR or],
+          %w[MORE MORE]
         ]
         match_expectations(subject, expectations)
       end
@@ -127,9 +125,9 @@ module SRL
         input = 'never or more'
         subject.scanner.string = input
         expectations = [
-          ['NEVER', 'never'],
-          ['OR', 'or'],
-          ['MORE', 'more']
+          %w[NEVER never],
+          %w[OR or],
+          %w[MORE more]
         ]
         match_expectations(subject, expectations)
       end 
@@ -138,13 +136,13 @@ module SRL
         input = 'at least 10 times'
         subject.scanner.string = input
         expectations = [
-          ['AT', 'at'],
-          ['LEAST', 'least'],
-          ['INTEGER', '10'],
-          ['TIMES', 'times']
+          %w[AT at],
+          %w[LEAST least],
+          %w[INTEGER 10],
+          %w[TIMES times]
         ]
         match_expectations(subject, expectations)
       end      
     end # context
   end # describe
-end # module
+end # module

data/examples/general/calc_iter1/calc_ast_builder.rb

@@ -26,13 +26,13 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
   
   # rule 'expression' => 'simple_expression'
-  def reduce_expression_0(_aProd, _range, _tokens, theChildren)
-    return_first_child(_range, _tokens, theChildren)
+  def reduce_expression_0(_production, aRange, theTokens, theChildren)
+    return_first_child(aRange, theTokens, theChildren)
   end
 
   # rule 'simple_expression' => 'term'
-  def reduce_simple_expression_0(_aProd, _range, _tokens, theChildren)
-    return_first_child(_range, _tokens, theChildren)
+  def reduce_simple_expression_0(_production, aRange, theTokens, theChildren)
+    return_first_child(aRange, theTokens, theChildren)
   end          
 
   # rule 'simple_expression' => %w[simple_expression add_operator term]
@@ -41,8 +41,8 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
   
   # rule 'term' => 'factor' 
-  def reduce_term_0(_aProd, _range, _tokens, theChildren)
-    return_first_child(_range, _tokens, theChildren)
+  def reduce_term_0(_production, aRange, theTokens, theChildren)
+    return_first_child(aRange, theTokens, theChildren)
   end  
 
   # rule 'term' => %w[term mul_operator factor]
@@ -51,13 +51,13 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
   
   # rule 'factor' => 'NUMBER'
-  def reduce_factor_0(_aProd, _range, _tokens, theChildren)
-    return_first_child(_range, _tokens, theChildren)
+  def reduce_factor_0(_aProd, aRange, theTokens, theChildren)
+    return_first_child(aRange, theTokens, theChildren)
   end
   
   # # rule 'factor' => %w[LPAREN expression RPAREN]
-  def reduce_factor_1(_aProd, _range, _tokens, theChildren)
-    return_second_child(_range, _tokens, theChildren)
+  def reduce_factor_1(_aProd, aRange, theTokens, theChildren)
+    return_second_child(aRange, theTokens, theChildren)
   end   
 
   # rule 'add_operator' => 'PLUS'

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -8,7 +8,6 @@ require_relative 'calc_ast_nodes'
 # (say, a parse tree) from simpler objects (terminal and non-terminal
 # nodes) and using a step by step approach.
 class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
-
   Terminal2NodeClass = {
     # Lexical ambiguity: minus sign represents two very concepts:
     # The unary negation operator on one hand, the binary substraction operator
@@ -28,7 +27,6 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
     Terminal2NodeClass
   end
 
-
   def reduce_binary_operator(theChildren)
     operator_node = theChildren[1]
     operator_node.children << theChildren[0]
@@ -47,7 +45,7 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule 'factor' => %w[simple_factor POWER simple_factor]]
-  def reduce_factor_1(aProduction, aRange, theTokens, theChildren)
+  def reduce_factor_1(_production, aRange, _tokens, theChildren)
     result = PowerNode.new(theChildren[1].symbol, aRange)
     result.children << theChildren[0]
     result.children << theChildren[2]
@@ -56,7 +54,7 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule 'simple_factor' => %[sign scalar]
-  def reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
+  def reduce_simple_factor_0(_production, _range, _tokens, theChildren)
     first_child = theChildren[0]
     result = if first_child.kind_of?(CalcNegateNode)
                -theChildren[1]
@@ -68,7 +66,7 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule 'simple_factor' => %w[unary_function in_parenthesis]
-  def reduce_simple_factor_1(aProduction, aRange, theTokens, theChildren)
+  def reduce_simple_factor_1(_production, aRange, _tokens, theChildren)
     func = CalcUnaryFunction.new(theChildren[0].symbol, aRange.low)
     func.func_name = theChildren[0].value
     func.children << theChildren[1]
@@ -76,15 +74,15 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule 'simple_factor' => %w[MINUS in_parenthesis]
-  def reduce_simple_factor_2(aProduction, aRange, _tokens, theChildren)
+  def reduce_simple_factor_2(_production, aRange, _tokens, theChildren)
     negation = CalcNegateNode.new(theChildren[0].symbol, aRange.low)
     negation.children << theChildren[1]
     return negation
   end
 
-   # rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
-  def reduce_in_parenthesis_0(_production, _range, _tokens, theChildren)
-    return_second_child(_range, _tokens, theChildren)
+  # rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
+  def reduce_in_parenthesis_0(_production, aRange, theTokens, theChildren)
+    return_second_child(aRange, theTokens, theChildren)
   end
 
   # rule 'add_operator' => 'PLUS'

data/examples/general/calc_iter2/calc_ast_nodes.rb

@@ -42,7 +42,7 @@ class CalcNumberNode < CalcTerminalNode
   
   # Overriding the unary minus operator
   def -@()
-    self.value = - self.value
+    self.value = - value
     return self
   end
 end
@@ -59,7 +59,6 @@ class CalcConstantNode < CalcNumberNode
 end
 
 class CalcReservedNode < CalcTerminalNode
-
 end
 
 class CalcCompositeNode
@@ -84,7 +83,7 @@ end # class
 
 class CalcUnaryOpNode < CalcCompositeNode
   def initialize(aSymbol, aPosition)
-    super(aSymbol,aPosition)
+    super(aSymbol, aPosition)
   end
 
   alias members children
@@ -92,7 +91,7 @@ end # class
 
 class CalcNegateNode < CalcUnaryOpNode  
   def interpret()
-    return -(children[0].interpret)
+    return -children[0].interpret
   end
 end # class
 
@@ -108,7 +107,7 @@ class CalcUnaryFunction < CalcCompositeNode
   
   def interpret()
     argument = children[0].interpret
-    internal_name = @@name_mapping[@func_name] # @func_name == 'ln' ? 'log' : @func_name
+    internal_name = @@name_mapping[@func_name]
     return Math.send(internal_name.to_sym, argument)
   end  
 end
@@ -177,7 +176,7 @@ class PowerNode < CalcBinaryOpNode
   # TODO
   def interpret()
     operands = retrieve_operands
-    exponentiation = operands[0] ** operands[1]
+    exponentiation = operands[0]**operands[1]
     return exponentiation
   end
 end # class

data/examples/general/calc_iter2/calc_lexer.rb

@@ -21,11 +21,9 @@ class CalcLexer
     'E' => 'E'
   }.freeze
   
-  @@unary_functions = [
-    'sin', 'cos', 'tan',
-    'asin', 'acos', 'atan',
-    'sqrt', 'cbrt', 'exp', 
-    'ln', 'log'
+  @@unary_functions = %w[
+    sin cos tan asin acos atan
+    sqrt cbrt exp ln log
   ].freeze
 
   class ScanError < StandardError; end

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

@@ -37,6 +37,8 @@ describe 'Calculator' do
   end
 
   context 'Parsing valid expressions' do
+    let(:epsilon) { 0.0000000001 }
+  
     it 'should evaluate simple integer literals' do
       expect_expr('2').to eq(2)
     end
@@ -169,10 +171,10 @@ describe 'Calculator' do
     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(0.0000000001).of(Math::E * Math::E)
+      expect_expr('exp(2)').to be_within(epsilon).of(Math::E * Math::E)
     end
 
     it 'should evaluate natural logarithm of expressions' do
@@ -193,42 +195,42 @@ describe 'Calculator' do
     
     it 'should compute the sinus of an expression' do
       expect_expr('sin(0)').to eq(0)
-      expect_expr('sin(PI/6)').to be_within(0.0000000001).of(0.5)
+      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(0.0000000001).of(0.5)
-      expect_expr('cos(PI/2)').to be_within(0.0000000001).of(0)
+      expect_expr('cos(PI/3)').to be_within(epsilon).of(0.5)
+      expect_expr('cos(PI/2)').to be_within(epsilon).of(0)
     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(0.0000000001).of(1)
-      expect_expr('tan(5*PI/12)').to be_within(0.0000000001).of(2 + Math.sqrt(3))
+      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    
  
     # 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(0.0000000001).of(Math::PI/6)
-      expect_expr('asin(1)').to eq(Math::PI/2)
+      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(0.0000000001).of(Math::PI/3)
-      expect_expr('acos(0)').to be_within(0.0000000001).of(Math::PI/2)
+      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 
 
     it 'should compute the tangent of an expression' do
       expect_expr('atan(0)').to eq(0)
-      expect_expr('atan(1)').to be_within(0.0000000001).of(Math::PI/4)
-      expect_expr('atan(2 + sqrt(3))').to be_within(0.0000000001).of(5*Math::PI/12)
+      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 # context
 end # describe
 # End of file