dentaku 3.3.3 → 3.4.2

data/lib/dentaku/ast/functions/avg.rb

@@ -1,13 +1,13 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:avg, :numeric, ->(*args) {
-  if args.empty?
+  flatten_args = args.flatten
+  if flatten_args.empty?
     raise Dentaku::ArgumentError.for(
         :too_few_arguments,
         function_name: 'AVG()', at_least: 1, given: 0
     ), 'AVG() requires at least one argument'
   end
 
-  flatten_args = args.flatten
   flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+) / flatten_args.length
 })

data/lib/dentaku/ast/functions/filter.rb

@@ -0,0 +1,36 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Filter < Function
+      def self.min_param_count
+        3
+      end
+
+      def self.max_param_count
+        3
+      end
+
+      def deferred_args
+        [1, 2]
+      end
+
+      def value(context = {})
+        collection      = @args[0].value(context)
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        Array(collection).select do |item_value|
+          expression.value(
+            context.merge(
+              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
+            )
+          )
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:filter, Dentaku::AST::Filter)

data/lib/dentaku/ast/functions/map.rb

@@ -0,0 +1,36 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Map < Function
+      def self.min_param_count
+        3
+      end
+
+      def self.max_param_count
+        3
+      end
+
+      def deferred_args
+        [1, 2]
+      end
+
+      def value(context = {})
+        collection      = @args[0].value(context)
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        collection.map do |item_value|
+          expression.value(
+            context.merge(
+              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
+            )
+          )
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:map, Dentaku::AST::Map)

data/lib/dentaku/ast/functions/pluck.rb

@@ -0,0 +1,29 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Pluck < Function
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        2
+      end
+
+      def deferred_args
+        [1]
+      end
+
+      def value(context = {})
+        collection = @args[0].value(context)
+        pluck_path = @args[1].identifier
+
+        collection.map { |h| h.transform_keys(&:to_s)[pluck_path] }
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:pluck, Dentaku::AST::Pluck)

data/lib/dentaku/ast/functions/round.rb

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:round, :numeric, lambda { |numeric, places = 0|
-  Dentaku::AST::Function.numeric(numeric).round(places.to_i)
+  Dentaku::AST::Function.numeric(numeric).round(Dentaku::AST::Function.numeric(places || 0).to_i)
 })

data/lib/dentaku/ast/functions/rounddown.rb

@@ -1,7 +1,7 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:rounddown, :numeric, lambda { |numeric, precision = 0|
-  precision = precision.to_i
+  precision = Dentaku::AST::Function.numeric(precision || 0).to_i
   tens = 10.0**precision
   result = (Dentaku::AST::Function.numeric(numeric) * tens).floor / tens
   precision <= 0 ? result.to_i : result

data/lib/dentaku/ast/functions/roundup.rb

@@ -1,7 +1,7 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:roundup, :numeric, lambda { |numeric, precision = 0|
-  precision = precision.to_i
+  precision = Dentaku::AST::Function.numeric(precision || 0).to_i
   tens = 10.0**precision
   result = (Dentaku::AST::Function.numeric(numeric) * tens).ceil / tens
   precision <= 0 ? result.to_i : result

data/lib/dentaku/ast/functions/ruby_math.rb

@@ -1,8 +1,54 @@
 # import all functions from Ruby's Math module
 require_relative '../function'
 
+module Dentaku
+  module AST
+    class RubyMath < Function
+      def self.[](method)
+        klass = Class.new(self)
+        klass.implement(method)
+        klass
+      end
+
+      def self.implement(method)
+        @name = method
+        @implementation = Math.method(method)
+      end
+
+      def self.name
+        @name
+      end
+
+      def self.arity
+        @implementation.arity < 0 ? nil : @implementation.arity
+      end
+
+      def self.min_param_count
+        @implementation.parameters.select { |type, _name| type == :req }.count
+      end
+
+      def self.max_param_count
+        @implementation.parameters.select { |type, _name| type == :rest }.any? ? Float::INFINITY : @implementation.parameters.count
+      end
+
+      def self.call(*args)
+        @implementation.call(*args)
+      end
+
+      def value(context = {})
+        args = @args.flatten.map { |a| Dentaku::AST::Function.numeric(a.value(context)) }
+        self.class.call(*args)
+      end
+
+      ARRAY_RETURN_TYPES = [:frexp, :lgamma].freeze
+
+      def type
+        ARRAY_RETURN_TYPES.include?(@name) ? :array : :numeric
+      end
+    end
+  end
+end
+
 Math.methods(false).each do |method|
-  Dentaku::AST::Function.register(method, :numeric, lambda { |*args|
-    Math.send(method, *args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) })
-  })
+  Dentaku::AST::Function.register_class(method, Dentaku::AST::RubyMath[method])
 end

data/lib/dentaku/ast/functions/string_functions.rb

@@ -32,13 +32,21 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
           negative_argument_failure('LEFT') if length < 0
           string[0, length]
         end
       end
 
       class Right < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @string, @length = *@args
@@ -46,13 +54,21 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
           negative_argument_failure('RIGHT') if length < 0
           string[length * -1, length] || string
         end
       end
 
       class Mid < Base
+        def self.min_param_count
+          3
+        end
+
+        def self.max_param_count
+          3
+        end
+
         def initialize(*args)
           super
           @string, @offset, @length = *@args
@@ -60,15 +76,23 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          offset = @offset.value(context)
+          offset = Dentaku::AST::Function.numeric(@offset.value(context)).to_i
           negative_argument_failure('MID', 'offset') if offset < 0
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
           negative_argument_failure('MID') if length < 0
           string[offset - 1, length].to_s
         end
       end
 
       class Len < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          1
+        end
+
         def initialize(*args)
           super
           @string = @args[0]
@@ -85,6 +109,14 @@ module Dentaku
       end
 
       class Find < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @needle, @haystack = *@args
@@ -104,6 +136,14 @@ module Dentaku
       end
 
       class Substitute < Base
+        def self.min_param_count
+          3
+        end
+
+        def self.max_param_count
+          3
+        end
+
         def initialize(*args)
           super
           @original, @search, @replacement = *@args
@@ -137,6 +177,14 @@ module Dentaku
       end
 
       class Contains < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @needle, @haystack = *args

data/lib/dentaku/ast/grouping.rb

@@ -1,6 +1,8 @@
+require_relative "./node"
+
 module Dentaku
   module AST
-    class Grouping
+    class Grouping < Node
       def initialize(node)
         @node = node
       end

data/lib/dentaku/ast/identifier.rb

@@ -20,7 +20,9 @@ module Dentaku
 
         case v
         when Node
-          v.value(context)
+          value = v.value(context)
+          context[identifier] = value if Dentaku.cache_identifier?
+          value
         when Proc
           v.call
         else
@@ -29,13 +31,13 @@ module Dentaku
       end
 
       def dependencies(context = {})
-        context.key?(identifier) ? dependencies_of(context[identifier]) : [identifier]
+        context.key?(identifier) ? dependencies_of(context[identifier], context) : [identifier]
       end
 
       private
 
-      def dependencies_of(node)
-        node.respond_to?(:dependencies) ? node.dependencies : []
+      def dependencies_of(node, context)
+        node.respond_to?(:dependencies) ? node.dependencies(context) : []
       end
     end
   end

data/lib/dentaku/bulk_expression_solver.rb

@@ -53,40 +53,55 @@ module Dentaku
     end
 
     def expression_with_exception_handler(&block)
-      ->(expr, ex) { block.call(ex) }
+      ->(_expr, ex) { block.call(ex) }
     end
 
     def load_results(&block)
-      variables_in_resolve_order.each_with_object({}) do |var_name, r|
-        begin
-          solved = calculator.memory
-          value_from_memory = solved[var_name.downcase]
-
-          if value_from_memory.nil? &&
-              expressions[var_name].nil? &&
-              !solved.has_key?(var_name)
-            next
-          end
-
-          value = value_from_memory || evaluate!(
+      facts, _formulas = expressions.transform_keys(&:downcase)
+                                    .transform_values { |v| calculator.ast(v) }
+                                    .partition { |_, v| calculator.dependencies(v, nil).empty? }
+
+      evaluated_facts = facts.to_h.each_with_object({}) do |(var_name, ast), h|
+        with_rescues(var_name, h, block) do
+          h[var_name] = ast.is_a?(Array) ? ast.map(&:value) : ast.value
+        end
+      end
+
+      context = calculator.memory.merge(evaluated_facts)
+
+      variables_in_resolve_order.each_with_object({}) do |var_name, results|
+        next if expressions[var_name].nil?
+
+        with_rescues(var_name, results, block) do
+          results[var_name] = evaluated_facts[var_name] || calculator.evaluate!(
             expressions[var_name],
-            expressions.merge(r).merge(solved),
+            context.merge(results),
             &expression_with_exception_handler(&block)
           )
-
-          r[var_name] = value
-        rescue UnboundVariableError, Dentaku::ZeroDivisionError => ex
-          ex.recipient_variable = var_name
-          r[var_name] = block.call(ex)
-        rescue Dentaku::ArgumentError => ex
-          r[var_name] = block.call(ex)
         end
       end
+
     rescue TSort::Cyclic => ex
       block.call(ex)
       {}
     end
 
+    def with_rescues(var_name, results, block)
+      yield
+
+    rescue UnboundVariableError,  Dentaku::ZeroDivisionError => ex
+      ex.recipient_variable = var_name
+      results[var_name] = block.call(ex)
+
+    rescue Dentaku::ArgumentError => ex
+      results[var_name] = block.call(ex)
+
+    ensure
+      if results[var_name] == :undefined && calculator.memory.has_key?(var_name.downcase)
+        results[var_name] = calculator.memory[var_name.downcase]
+      end
+    end
+
     def expressions
       @expressions ||= Hash[expression_hash.map { |k, v| [k.to_s, v] }]
     end
@@ -113,9 +128,5 @@ module Dentaku
         end
       }
     end
-
-    def evaluate!(expression, results, &block)
-      calculator.evaluate!(expression, results, &block)
-    end
   end
 end