dentaku 3.3.1 → 3.4.1

data/lib/dentaku/ast/case/case_when.rb

@@ -1,10 +1,6 @@
 module Dentaku
   module AST
     class CaseWhen < Operation
-      def self.arity
-        1
-      end
-
       def initialize(node)
         @node = node
       end
@@ -16,6 +12,18 @@ module Dentaku
       def dependencies(context = {})
         @node.dependencies(context)
       end
+
+      def self.arity
+        1
+      end
+
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
     end
   end
 end

data/lib/dentaku/ast/function.rb

@@ -12,7 +12,16 @@ module Dentaku
       end
 
       def dependencies(context = {})
-        @args.flat_map { |a| a.dependencies(context) }
+        deferred = deferred_args
+        @args.each_with_index
+             .reject { |_, i| deferred.include? i }
+             .flat_map { |a, _| a.dependencies(context) }
+      end
+
+      # override if your function implementation needs to defer evaluation of
+      # any arguments
+      def deferred_args
+        []
       end
 
       def self.get(name)

data/lib/dentaku/ast/function_registry.rb

@@ -38,6 +38,14 @@ module Dentaku
             @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 value(context = {})
             args = @args.map { |a| a.value(context) }
             self.class.implementation.call(*args)
@@ -48,6 +56,8 @@ module Dentaku
           end
         end
 
+        define_class(name, function)
+
         function.name = name
         function.type = type
         function.implementation = implementation
@@ -72,6 +82,17 @@ module Dentaku
       def function_name(name)
         name.to_s.downcase
       end
+
+      def normalize_name(function_name)
+        function_name.to_s.capitalize.gsub(/\W/, '_')
+      end
+
+      def define_class(function_name, function)
+        class_name = normalize_name(function_name)
+        return if Dentaku::AST::Function.const_defined?(class_name)
+
+        Dentaku::AST::Function.const_set(class_name, function)
+      end
     end
   end
 end

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

@@ -0,0 +1,36 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class All < 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).all? do |item_value|
+          expression.value(
+            context.update(
+              FlatHash.from_hash(item_identifier => item_value)
+            )
+          )
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:all, Dentaku::AST::All)

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

@@ -0,0 +1,36 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Any < 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).any? do |item_value|
+          expression.value(
+            context.update(
+              FlatHash.from_hash(item_identifier => item_value)
+            )
+          )
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:any, Dentaku::AST::Any)

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/count.rb

@@ -3,6 +3,14 @@ require_relative '../function'
 module Dentaku
   module AST
     class Count < Function
+      def self.min_param_count
+        0
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
       def value(context = {})
         if @args.length == 1
           first_arg = @args[0].value(context)

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

@@ -0,0 +1,51 @@
+require_relative '../function'
+
+module Dentaku
+  module AST
+    class Duration < Function
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
+
+      class Value
+        attr_reader :value, :unit
+
+        def initialize(value, unit)
+          @value = value
+          @unit = validate_unit(unit)
+        end
+
+        def validate_unit(unit)
+          case unit.downcase
+          when /years?/ then :year
+          when /months?/ then :month
+          when /days?/ then :day
+          else
+            raise Dentaku::ArgumentError.for(:incompatible_type, value: unit, for: Duration),
+              "'#{unit || unit.class}' is not a valid duration unit"
+          end
+        end
+      end
+
+      def type
+        :duration
+      end
+
+      def value(context = {})
+        value_node, unit_node = *@args
+        Value.new(value_node.value(context), unit_node.identifier)
+      end
+
+      def dependencies(context = {})
+        value_node = @args.first
+        value_node.dependencies(context)
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:duration, Dentaku::AST::Duration)

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

@@ -5,6 +5,14 @@ module Dentaku
     class If < Function
       attr_reader :predicate, :left, :right
 
+      def self.min_param_count
+        3
+      end
+
+      def self.max_param_count
+        3
+      end
+
       def initialize(predicate, left, right)
         @predicate = predicate
         @left      = left
@@ -24,8 +32,13 @@ module Dentaku
       end
 
       def dependencies(context = {})
-        # TODO : short-circuit?
-        (predicate.dependencies(context) + left.dependencies(context) + right.dependencies(context)).uniq
+        deps = predicate.dependencies(context)
+
+        if deps.empty?
+          predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
+        else
+          (deps + left.dependencies(context) + right.dependencies(context)).uniq
+        end
       end
     end
   end

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.update(
+              FlatHash.from_hash(item_identifier => item_value)
+            )
+          )
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:map, Dentaku::AST::Map)

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

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

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,52 @@
 # 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
+
+      def type
+        nil
+      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