dentaku 3.3.0 → 3.4.0

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

@@ -1,10 +1,6 @@
 module Dentaku
   module AST
     class CaseElse < Node
-      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/case/case_switch_variable.rb

@@ -16,6 +16,14 @@ module Dentaku
       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/case/case_then.rb

@@ -1,10 +1,6 @@
 module Dentaku
   module AST
     class CaseThen < Node
-      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/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)
@@ -38,7 +47,7 @@ module Dentaku
 
         if value.is_a?(::String)
           number = value[/\A-?\d*\.?\d+\z/]
-          return number.include?('.') ? ::BigDecimal.new(number, DIG) : number.to_i if number
+          return number.include?('.') ? BigDecimal(number, DIG) : number.to_i if number
         end
 
         raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),

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)