hayadentaku 3.5.7

data/lib/dentaku/ast/comparators.rb

@@ -0,0 +1,88 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class Comparator < Operation
+      def self.precedence
+        5
+      end
+
+      def type
+        :logical
+      end
+
+      def operator
+        raise NotImplementedError
+      end
+
+      def value(context = {})
+        l = validate_value(cast(left.value(context)))
+        r = validate_value(cast(right.value(context)))
+
+        l.public_send(operator, r)
+      rescue ::ArgumentError, ::TypeError => e
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
+      end
+
+      private
+
+      def cast(val)
+        return val unless val.is_a?(::String)
+        return val unless val.match?(Arithmetic::DECIMAL) || val.match?(Arithmetic::INTEGER)
+
+        v = BigDecimal(val, Float::DIG + 1)
+        v = v.to_i if v.frac.zero?
+        v
+      end
+
+      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
+        :<
+      end
+    end
+
+    class LessThanOrEqual < Comparator
+      def operator
+        :<=
+      end
+    end
+
+    class GreaterThan < Comparator
+      def operator
+        :>
+      end
+    end
+
+    class GreaterThanOrEqual < Comparator
+      def operator
+        :>=
+      end
+    end
+
+    class NotEqual < Comparator
+      def operator
+        :!=
+      end
+    end
+
+    class Equal < Comparator
+      def operator
+        :==
+      end
+
+      def display_operator
+        "="
+      end
+    end
+  end
+end

data/lib/dentaku/ast/datetime.rb

@@ -0,0 +1,8 @@
+require_relative "./literal"
+
+module Dentaku
+  module AST
+    class DateTime < Literal
+    end
+  end
+end

data/lib/dentaku/ast/function.rb

@@ -0,0 +1,56 @@
+require_relative 'node'
+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
+
+      def initialize(*args)
+        @args = args
+      end
+
+      def accept(visitor)
+        visitor.visit_function(self)
+      end
+
+      def dependencies(context = {})
+        @args.each_with_index
+             .flat_map { |a, _| a.dependencies(context) }
+      end
+
+      def self.get(name)
+        registry.get(name)
+      end
+
+      def self.register(name, type, implementation)
+        registry.register(name, type, implementation)
+      end
+
+      def self.register_class(name, function_class)
+        registry.register_class(name, function_class)
+      end
+
+      def self.registry
+        @registry ||= FunctionRegistry.new
+      end
+
+      # @return [Numeric] where possible it returns an Integer otherwise a BigDecimal.
+      # An Exception will be raised if a value is passed that cannot be cast to a Number.
+      def self.numeric(value)
+        return value if value.is_a?(::Numeric)
+
+        if value.is_a?(::String)
+          number = value[/\A-?\d*\.?\d+\z/]
+          return number.include?('.') ? BigDecimal(number, DIG) : number.to_i if number
+        end
+
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),
+          "'#{value || value.class}' is not coercible to numeric"
+      end
+    end
+  end
+end

data/lib/dentaku/ast/function_registry.rb

@@ -0,0 +1,107 @@
+module Dentaku
+  module AST
+    class FunctionRegistry < Hash
+      def get(name)
+        name = function_name(name)
+        return self[name] if has_key?(name)
+        return default[name] if default.has_key?(name)
+        nil
+      end
+
+      def register(name, type, implementation, callback = nil)
+        function = Class.new(Function) do
+          def self.name=(name)
+            @name = name
+          end
+
+          def self.name
+            @name
+          end
+
+          def self.implementation=(impl)
+            @implementation = impl
+          end
+
+          def self.implementation
+            @implementation
+          end
+
+          def self.type=(type)
+            @type = type
+          end
+
+          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
+
+          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)
+          end
+
+          def type
+            self.class.type
+          end
+        end
+
+        define_class(name, function)
+
+        function.name = name
+        function.type = type
+        function.implementation = implementation
+        function.callback = callback
+
+        self[function_name(name)] = function
+      end
+
+      def register_class(name, function_class)
+        self[function_name(name)] = function_class
+      end
+
+      def default
+        self.class.default
+      end
+
+      def self.default
+        Dentaku::AST::Function.registry
+      end
+
+      private
+
+      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/abs.rb

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

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

@@ -0,0 +1,19 @@
+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|
+          mapped_value(expression, context, 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

@@ -0,0 +1,25 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+Dentaku::AST::Function.register(:and, :logical, lambda { |*args|
+  if args.empty?
+    raise Dentaku::ArgumentError.for(
+      :too_few_arguments,
+      function_name: 'AND()', at_least: 1, given: 0
+    ), 'AND() requires at least one argument'
+  end
+
+  args.all? do |arg|
+    case arg
+    when TrueClass
+      true
+    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'
+    end
+  end
+})

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

@@ -0,0 +1,19 @@
+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|
+          mapped_value(expression, context, 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

@@ -0,0 +1,13 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:avg, :numeric, ->(*args) {
+  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.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+) / BigDecimal(flatten_args.length)
+})

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

@@ -0,0 +1,26 @@
+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)
+          return first_arg.length if first_arg.respond_to?(:length)
+        end
+
+        @args.length
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:count, Dentaku::AST::Count)

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,54 @@
+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 initialize(*args)
+        super
+        validate_identifier(@args[1])
+      end
+
+      def dependencies(context = {})
+        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")
+        raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
+      end
+
+      private
+
+      def mapped_value(expression, context, item_context)
+        # Avoid the `context.merge(FlatHash.from_hash_with_intermediates(...))`
+        # double allocation per iteration: dup the context once and write the
+        # flattened keys directly into it.
+        scratch = context.dup
+        item_context.each do |k, v|
+          FlatHash.write_pair_with_intermediates!(k, v, scratch)
+        end
+        expression.value(scratch)
+      rescue => e
+        raise e if context["__evaluation_mode"] == :strict
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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|
+          scratch = context.dup
+          FlatHash.write_pair_with_intermediates!(item_identifier, item_value, scratch)
+          expression.value(scratch)
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:filter, Dentaku::AST::Filter)

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

@@ -0,0 +1,47 @@
+require_relative '../function'
+
+module Dentaku
+  module AST
+    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
+
+      def node_type
+        :condition
+      end
+
+      def type
+        left.type
+      end
+
+      def dependencies(context = {})
+        predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
+      rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError
+        args.flat_map { |arg| arg.dependencies(context) }.uniq
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:if, Dentaku::AST::If)

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

@@ -0,0 +1,33 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:intercept, :list, ->(*args) {
+  if args.length != 2
+    raise Dentaku::ArgumentError.for(
+        :wrong_number_of_arguments,
+        function_name: 'INTERCEPT()', exact: 2, given: args.length
+    ), 'INTERCEPT() requires exactly two arrays of numbers'
+  end
+
+  x_values, y_values = args
+  if !x_values.is_a?(Array) || !y_values.is_a?(Array) || x_values.length != y_values.length
+    raise Dentaku::ArgumentError.for(
+        :invalid_value,
+        function_name: 'INTERCEPT()'
+    ), 'INTERCEPT() requires arrays of equal length'
+  end
+
+  n = x_values.length.to_f
+  x_values = x_values.map { |arg| Dentaku::AST::Function.numeric(arg) }
+  y_values = y_values.map { |arg| Dentaku::AST::Function.numeric(arg) }
+
+  x_avg = x_values.sum / n
+  y_avg = y_values.sum / n
+
+  xy_sum = x_values.zip(y_values).map { |x, y| (x_avg - x) * (y_avg - y) }.sum
+  x_square_sum = x_values.map { |x| (x_avg - x)**2 }.sum
+
+  slope = xy_sum / x_square_sum
+  intercept = x_values.zip(y_values).map { |x, y| y - slope * x }.sum / n
+
+  BigDecimal(intercept, Float::DIG + 1)
+})

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

@@ -0,0 +1,19 @@
+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|
+          mapped_value(expression, context, item_identifier => item_value)
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:map, Dentaku::AST::Map)

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:max, :numeric, ->(*args) {
+  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.max
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:min, :numeric, ->(*args) {
+  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.min
+})

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

@@ -0,0 +1,12 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:mul, :numeric, ->(*args) {
+  if 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, :*)
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:not, :logical, ->(logical) {
+  ! logical
+})

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

@@ -0,0 +1,25 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+Dentaku::AST::Function.register(:or, :logical, lambda { |*args|
+  if args.empty?
+    raise Dentaku::ArgumentError.for(
+      :too_few_arguments,
+      function_name: 'OR()', at_least: 1, given: 0
+    ), 'OR() requires at least one argument'
+  end
+
+  args.any? do |arg|
+    case arg
+    when TrueClass
+      true
+    when FalseClass, nil
+      false
+    else
+      raise Dentaku::ArgumentError.for(
+        :incompatible_type,
+        function_name: 'OR()', expect: :logical, actual: arg.class
+      ), 'OR() requires arguments to be logical expressions'
+    end
+  end
+})