feat: add lambda function to process external function arguments

Closes #290

Author: Fabian Segura

lib/dentaku/ast/function_registry.rb

@@ -8,7 +8,7 @@ def get(name)
         nil
       end
 
-      def register(name, type, implementation)
+      def register(name, type, implementation, callback = nil)
         function = Class.new(Function) do
           def self.name=(name)
             @name = name
@@ -34,6 +34,14 @@ def self.type
             @type
           end
 
+          def self.callback=(callback)
+            @callback = callback
+          end
+
+          def self.callback
+            @callback
+          end
+
           def self.arity
             @implementation.arity < 0 ? nil : @implementation.arity
           end
@@ -61,6 +69,7 @@ def type
         function.name = name
         function.type = type
         function.implementation = implementation
+        function.callback = callback
 
         self[function_name(name)] = function
       end

lib/dentaku/calculator.rb

@@ -24,17 +24,17 @@ def initialize(options = {})
       @function_registry = Dentaku::AST::FunctionRegistry.new
     end
 
-    def self.add_function(name, type, body)
-      Dentaku::AST::FunctionRegistry.default.register(name, type, body)
+    def self.add_function(name, type, body, callback = nil)
+      Dentaku::AST::FunctionRegistry.default.register(name, type, body, callback)
     end
 
-    def add_function(name, type, body)
-      @function_registry.register(name, type, body)
+    def add_function(name, type, body, callback = nil)
+      @function_registry.register(name, type, body, callback)
       self
     end
 
     def add_functions(fns)
-      fns.each { |(name, type, body)| add_function(name, type, body) }
+      fns.each { |(name, type, body, callback)| add_function(name, type, body, callback) }
       self
     end
 

lib/dentaku/parser.rb

@@ -61,6 +61,10 @@ def consume(count = 2)
       args = Array.new(args_size) { output.pop }.reverse
 
       output.push operator.new(*args)
+
+      if operator.respond_to?(:callback) && !operator.callback.nil?
+        operator.callback.call(args)
+      end
     rescue ::ArgumentError => e
       raise Dentaku::ArgumentError, e.message
     rescue NodeError => e

spec/external_function_spec.rb

@@ -5,8 +5,7 @@
 describe Dentaku::Calculator do
   describe 'functions' do
     describe 'external functions' do
-
-      let(:with_external_funcs) do
+      let(:custom_calculator) do
         c = described_class.new
 
         c.add_function(:now, :string, -> { Time.now.to_s })
@@ -22,30 +21,30 @@
       end
 
       it 'includes NOW' do
-        now = with_external_funcs.evaluate('NOW()')
+        now = custom_calculator.evaluate('NOW()')
         expect(now).not_to be_nil
         expect(now).not_to be_empty
       end
 
       it 'includes POW' do
-        expect(with_external_funcs.evaluate('POW(2,3)')).to eq(8)
-        expect(with_external_funcs.evaluate('POW(3,2)')).to eq(9)
-        expect(with_external_funcs.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
+        expect(custom_calculator.evaluate('POW(2,3)')).to eq(8)
+        expect(custom_calculator.evaluate('POW(3,2)')).to eq(9)
+        expect(custom_calculator.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
       end
 
       it 'includes BIGGEST' do
-        expect(with_external_funcs.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
+        expect(custom_calculator.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
       end
 
       it 'includes SMALLEST' do
-        expect(with_external_funcs.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
+        expect(custom_calculator.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
       end
 
       it 'includes OPTIONAL' do
-        expect(with_external_funcs.evaluate('OPTIONAL(1,2)')).to eq(3)
-        expect(with_external_funcs.evaluate('OPTIONAL(1,2,3)')).to eq(6)
-        expect { with_external_funcs.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
-        expect { with_external_funcs.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
+        expect(custom_calculator.evaluate('OPTIONAL(1,2)')).to eq(3)
+        expect(custom_calculator.evaluate('OPTIONAL(1,2,3)')).to eq(6)
+        expect { custom_calculator.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
+        expect { custom_calculator.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
       end
 
       it 'supports array parameters' do
@@ -62,6 +61,66 @@
       end
     end
 
+    describe 'with callbacks' do
+      let(:custom_calculator) do
+        c = described_class.new
+
+        @counts = Hash.new(0)
+
+        @initial_time = "2023-02-03"
+        @last_time = @initial_time
+
+        c.add_function(
+            :reverse,
+            :stringl,
+            ->(a) { a.reverse },
+            lambda do |args|
+              args.each do |arg|
+                @counts[arg.value] += 1 if arg.type == :string
+              end
+            end
+        )
+
+        fns = [
+            [:biggest_callback,  :numeric, ->(*args) { args.max }, ->(args) { args.each { |arg| raise Dentaku::ArgumentError unless arg.type == :numeric } }],
+            [:pythagoras, :numeric, ->(l1, l2) { Math.sqrt(l1**2 + l2**2) }, ->(e) { @last_time = Time.now.to_s }],
+            [:callback_lambda, :string, ->() { " " }, ->() { "lambda executed" }],
+            [:no_lambda_function, :numeric, ->(a) { a**a }],
+        ]
+
+        c.add_functions(fns)
+      end
+
+      it 'includes BIGGEST_CALLBACK' do
+        expect(custom_calculator.evaluate('BIGGEST_CALLBACK(1, 2, 5, 4)')).to eq(5)
+        expect { custom_calculator.dependencies('BIGGEST_CALLBACK(1, 3, 6, "hi", 10)') }.to raise_error(Dentaku::ArgumentError)
+      end
+
+      it 'includes REVERSE' do
+        expect(custom_calculator.evaluate('REVERSE(\'Dentaku\')')).to eq('ukatneD')
+        expect { custom_calculator.evaluate('REVERSE(22)') }.to raise_error(NoMethodError)
+        expect(@counts["Dentaku"]).to eq(1)
+      end
+
+      it 'includes PYTHAGORAS' do
+        expect(custom_calculator.evaluate('PYTHAGORAS(8, 7)')).to eq(10.63014581273465)
+        expect(custom_calculator.evaluate('PYTHAGORAS(3, 4)')).to eq(5)
+        expect(@last_time).not_to eq(@initial_time)
+      end
+
+      it 'exposes the `callback` method of a function' do
+        expect(Dentaku::AST::Function::Callback_lambda.callback.call()).to eq("lambda executed")
+      end
+
+      it 'does not add a `callback` method to built-in functions' do
+        expect { Dentaku::AST::If.callback.call }.to raise_error(NoMethodError)
+      end
+
+      it 'defaults `callback` method to nil if not specified' do
+        expect(Dentaku::AST::Function::No_lambda_function.callback).to eq(nil)
+      end
+    end
+
     it 'allows registering "bang" functions' do
       calculator = described_class.new
       calculator.add_function(:hey!, :string, -> { "hey!" })