dentaku_zevo 3.5.2

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

@@ -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, :+) / 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,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

@@ -0,0 +1,51 @@
+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 = {})
+        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
+end
+
+Dentaku::AST::Function.register_class(:if, Dentaku::AST::If)

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/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
+})

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

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

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

@@ -0,0 +1,8 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:rounddown, :numeric, lambda { |numeric, precision = 0|
+  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

@@ -0,0 +1,8 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:roundup, :numeric, lambda { |numeric, precision = 0|
+  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

@@ -0,0 +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_class(method, Dentaku::AST::RubyMath[method])
+end

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

@@ -0,0 +1,212 @@
+require_relative '../function'
+
+module Dentaku
+  module AST
+    module StringFunctions
+      class Base < Function
+        def type
+          :string
+        end
+
+        def negative_argument_failure(fun, arg = 'length')
+          raise Dentaku::ArgumentError.for(
+            :invalid_value,
+            function_name: "#{fun}()"
+          ), "#{fun}() requires #{arg} to be positive"
+        end
+      end
+
+      class Left < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
+        def initialize(*args)
+          super
+          @string, @length = *@args
+        end
+
+        def value(context = {})
+          string = @string.value(context).to_s
+          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
+        end
+
+        def value(context = {})
+          string = @string.value(context).to_s
+          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
+        end
+
+        def value(context = {})
+          string = @string.value(context).to_s
+          offset = Dentaku::AST::Function.numeric(@offset.value(context)).to_i
+          negative_argument_failure('MID', 'offset') if offset < 0
+          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]
+        end
+
+        def value(context = {})
+          string = @string.value(context).to_s
+          string.length
+        end
+
+        def type
+          :numeric
+        end
+      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
+        end
+
+        def value(context = {})
+          needle = @needle.value(context)
+          needle = needle.to_s unless needle.is_a?(Regexp)
+          haystack = @haystack.value(context).to_s
+          pos = haystack.index(needle)
+          pos && pos + 1
+        end
+
+        def type
+          :numeric
+        end
+      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
+        end
+
+        def value(context = {})
+          original = @original.value(context).to_s
+          search = @search.value(context)
+          search = search.to_s unless search.is_a?(Regexp)
+          replacement = @replacement.value(context).to_s
+          original.sub(search, replacement)
+        end
+      end
+
+      class Concat < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          Float::INFINITY
+        end
+
+        def initialize(*args)
+          super
+        end
+
+        def value(context = {})
+          @args.map { |arg| arg.value(context).to_s }.join
+        end
+      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
+        end
+
+        def value(context = {})
+          @haystack.value(context).to_s.include? @needle.value(context).to_s
+        end
+
+        def type
+          :logical
+        end
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:left,       Dentaku::AST::StringFunctions::Left)
+Dentaku::AST::Function.register_class(:right,      Dentaku::AST::StringFunctions::Right)
+Dentaku::AST::Function.register_class(:mid,        Dentaku::AST::StringFunctions::Mid)
+Dentaku::AST::Function.register_class(:len,        Dentaku::AST::StringFunctions::Len)
+Dentaku::AST::Function.register_class(:find,       Dentaku::AST::StringFunctions::Find)
+Dentaku::AST::Function.register_class(:substitute, Dentaku::AST::StringFunctions::Substitute)
+Dentaku::AST::Function.register_class(:concat,     Dentaku::AST::StringFunctions::Concat)
+Dentaku::AST::Function.register_class(:contains,   Dentaku::AST::StringFunctions::Contains)

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

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

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

@@ -0,0 +1,8 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:switch, :logical, lambda { |*args|
+  value = args.shift
+  default = args.pop if args.size.odd?
+  match = args.find_index.each_with_index { |arg, index| index.even? && arg == value }
+  match ? args[match + 1] : default
+})