dentaku 3.2.0 → 3.5.1

data/lib/dentaku/ast/case.rb

@@ -3,24 +3,36 @@ require_relative './case/case_when'
 require_relative './case/case_then'
 require_relative './case/case_switch_variable'
 require_relative './case/case_else'
+require 'dentaku/exceptions'
 
 module Dentaku
   module AST
     class Case < Node
+      attr_reader :switch, :conditions, :else
+
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
       def initialize(*nodes)
         @switch = nodes.shift
 
         unless @switch.is_a?(AST::CaseSwitchVariable)
-          raise 'Case missing switch variable'
+          raise ParseError.for(:node_invalid), 'Case missing switch variable'
         end
 
         @conditions = nodes
 
+        @else = nil
         @else = @conditions.pop if @conditions.last.is_a?(AST::CaseElse)
 
         @conditions.each do |condition|
           unless condition.is_a?(AST::CaseConditional)
-            raise "#{condition} is not a CaseConditional"
+            raise ParseError.for(:node_invalid), "#{condition} is not a CaseConditional"
           end
         end
       end
@@ -36,7 +48,7 @@ module Dentaku
         if @else
           return @else.value(context)
         else
-          raise "No block matched the switch value '#{switch_value}'"
+          raise ArgumentError.for(:invalid_value), "No block matched the switch value '#{switch_value}'"
         end
       end
 
@@ -47,6 +59,10 @@ module Dentaku
         else_dependencies(context)
       end
 
+      def accept(visitor)
+        visitor.visit_case(self)
+      end
+
       private
 
       def switch_dependencies(context = {})

data/lib/dentaku/ast/comparators.rb

@@ -14,65 +14,75 @@ module Dentaku
       def operator
         raise NotImplementedError
       end
-    end
 
-    class LessThan < Comparator
       def value(context = {})
-        left.value(context) < right.value(context)
+        l = validate_value(cast(left.value(context)))
+        r = validate_value(cast(right.value(context)))
+
+        l.public_send(operator, r)
+      rescue ::ArgumentError => e
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
       end
 
-      def operator
-        return :<
+      private
+
+      def cast(val)
+        return val unless val.is_a?(::String)
+        return val if val.empty?
+        return val unless val.match?(/\A-?\d*(\.\d+)?\z/)
+
+        v = BigDecimal(val, Float::DIG + 1)
+        v = v.to_i if v.frac.zero?
+        v
       end
-    end
 
-    class LessThanOrEqual < Comparator
-      def value(context = {})
-        left.value(context) <= right.value(context)
+      def validate_value(value)
+        unless value.respond_to?(operator)
+          raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),
+                "#{ self.class } requires operands that respond to #{operator}"
+        end
+
+        value
       end
+    end
 
+    class LessThan < Comparator
       def operator
-        return :<=
+        :<
       end
     end
 
-    class GreaterThan < Comparator
-      def value(context = {})
-        left.value(context) > right.value(context)
+    class LessThanOrEqual < Comparator
+      def operator
+        :<=
       end
+    end
 
+    class GreaterThan < Comparator
       def operator
-        return :>
+        :>
       end
     end
 
     class GreaterThanOrEqual < Comparator
-      def value(context = {})
-        left.value(context) >= right.value(context)
-      end
-
       def operator
-        return :>=
+        :>=
       end
     end
 
     class NotEqual < Comparator
-      def value(context = {})
-        left.value(context) != right.value(context)
-      end
-
       def operator
-        return :!=
+        :!=
       end
     end
 
     class Equal < Comparator
-      def value(context = {})
-        left.value(context) == right.value(context)
+      def operator
+        :==
       end
 
-      def operator
-        return :==
+      def display_operator
+        "="
       end
     end
   end

data/lib/dentaku/ast/function.rb

@@ -4,6 +4,8 @@ require_relative 'function_registry'
 module Dentaku
   module AST
     class Function < Node
+      attr_reader :args
+
       # @return [Integer] with the number of significant decimal digits to use.
       DIG = Float::DIG + 1
 
@@ -11,8 +13,13 @@ module Dentaku
         @args = args
       end
 
+      def accept(visitor)
+        visitor.visit_function(self)
+      end
+
       def dependencies(context = {})
-        @args.flat_map { |a| a.dependencies(context) }
+        @args.each_with_index
+             .flat_map { |a, _| a.dependencies(context) }
       end
 
       def self.get(name)
@@ -38,10 +45,11 @@ 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 TypeError, "#{value || value.class} could not be cast to a number."
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),
+          "'#{value || value.class}' is not coercible to numeric"
       end
     end
   end

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,23 @@
+require_relative './enum'
+
+module Dentaku
+  module AST
+    class All < Enum
+      def value(context = {})
+        collection      = Array(@args[0].value(context))
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        collection.all? 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(:all, Dentaku::AST::All)

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

@@ -11,9 +11,9 @@ Dentaku::AST::Function.register(:and, :logical, lambda { |*args|
 
   args.all? do |arg|
     case arg
-    when TrueClass, nil
+    when TrueClass
       true
-    when FalseClass
+    when FalseClass, nil
       false
     else
       raise Dentaku::ArgumentError.for(

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

@@ -0,0 +1,23 @@
+require_relative './enum'
+
+module Dentaku
+  module AST
+    class Any < Enum
+      def value(context = {})
+        collection      = Array(@args[0].value(context))
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        collection.any? 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(: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
+        2
+      end
+
+      def self.max_param_count
+        2
+      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/enum.rb

@@ -0,0 +1,37 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Enum < Function
+      def self.min_param_count
+        3
+      end
+
+      def self.max_param_count
+        3
+      end
+
+      def dependencies(context = {})
+        validate_identifier(@args[1])
+
+        collection      = @args[0]
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        collection_deps = collection.dependencies(context)
+        expression_deps = (expression&.dependencies(context) || []).reject do |i|
+          i == item_identifier || i.start_with?("#{item_identifier}.")
+        end
+
+        collection_deps + expression_deps
+      end
+
+      def validate_identifier(arg, message = "#{name}() requires second argument to be an identifier")
+        unless arg.is_a?(Identifier)
+          raise ArgumentError.for(:incompatible_type, value: arg, for: Identifier), message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require_relative './enum'
+
+module Dentaku
+  module AST
+    class Filter < Enum
+      def value(context = {})
+        collection      = Array(@args[0].value(context))
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        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/if.rb

@@ -5,12 +5,24 @@ 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
         @right     = right
       end
 
+      def args
+        [predicate, left, right]
+      end
+
       def value(context = {})
         predicate.value(context) ? left.value(context) : right.value(context)
       end
@@ -24,8 +36,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,23 @@
+require_relative './enum'
+
+module Dentaku
+  module AST
+    class Map < Enum
+      def value(context = {})
+        collection      = Array(@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/or.rb

@@ -11,15 +11,15 @@ Dentaku::AST::Function.register(:or, :logical, lambda { |*args|
 
   args.any? do |arg|
     case arg
-    when TrueClass, nil
+    when TrueClass
       true
-    when FalseClass
+    when FalseClass, nil
       false
     else
       raise Dentaku::ArgumentError.for(
         :incompatible_type,
-        function_name: 'AND()', expect: :logical, actual: arg.class
-      ), 'AND() requires arguments to be logical expressions'
+        function_name: 'OR()', expect: :logical, actual: arg.class
+      ), 'OR() requires arguments to be logical expressions'
     end
   end
 })

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

@@ -0,0 +1,30 @@
+require_relative './enum'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Pluck < Enum
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        2
+      end
+
+      def value(context = {})
+        collection = Array(@args[0].value(context))
+        unless collection.all? { |elem| elem.is_a?(Hash) }
+          raise ArgumentError.for(:incompatible_type, value: collection),
+                'PLUCK() requires first argument to be an array of hashes'
+        end
+
+        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,55 @@
 # import all functions from Ruby's Math module
 require_relative '../function'
 
+module Dentaku
+  module AST
+    class RubyMath < Function
+      def self.[](method)
+        klass_name = method.to_s.capitalize
+        klass = const_set(klass_name , Class.new(self))
+        klass.implement(method)
+        const_get(klass_name)
+      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