hayadentaku 3.5.7

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

@@ -0,0 +1,34 @@
+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
+        3
+      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
+        default    = @args[2]
+
+        collection.map { |h|
+          h.transform_keys(&:to_s).fetch(pluck_path, default&.value(context))
+        }
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:pluck, Dentaku::AST::Pluck)

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

@@ -0,0 +1,60 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Reduce < Function
+      def self.min_param_count
+        4
+      end
+
+      def self.max_param_count
+        5
+      end
+
+      def initialize(*args)
+        super
+
+        validate_identifier(@args[1], 'second')
+        validate_identifier(@args[2], 'third')
+      end
+
+      def dependencies(context = {})
+        collection      = @args[0]
+        memo_identifier = @args[1].identifier
+        item_identifier = @args[2].identifier
+        expression      = @args[3]
+
+        collection_deps = collection.dependencies(context)
+        expression_deps = expression.dependencies(context).reject do |i|
+          i == memo_identifier || i.start_with?("#{memo_identifier}.") ||
+          i == item_identifier || i.start_with?("#{item_identifier}.")
+        end
+        inital_value_deps = @args[4] ? @args[4].dependencies(context) : []
+
+        collection_deps + expression_deps + inital_value_deps
+      end
+
+      def value(context = {})
+        collection      = Array(@args[0].value(context))
+        memo_identifier = @args[1].identifier
+        item_identifier = @args[2].identifier
+        expression      = @args[3]
+        initial_value   = @args[4] && @args[4].value(context)
+
+        collection.reduce(initial_value) do |memo, item|
+          scratch = context.dup
+          FlatHash.write_pair_with_intermediates!(memo_identifier, memo, scratch)
+          FlatHash.write_pair_with_intermediates!(item_identifier, item, scratch)
+          expression.value(scratch)
+        end
+      end
+
+      def validate_identifier(arg, position, message = "#{name}() requires #{position} argument to be an identifier")
+        raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:reduce, Dentaku::AST::Reduce)

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,57 @@
+# 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)
+      rescue Math::DomainError => _e
+        raise Dentaku::MathDomainError.new(name, 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
+})

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

@@ -0,0 +1,44 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Xor < Function
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
+      def value(context = {})
+        if @args.empty?
+          raise Dentaku::ArgumentError.for(
+            :too_few_arguments,
+            function_name: 'XOR()', at_least: 1, given: 0
+          ), 'XOR() requires at least one argument'
+        end
+
+        true_arg_count = 0
+        @args.each do |arg|
+          case arg.value(context)
+          when TrueClass
+            true_arg_count += 1
+            break if true_arg_count > 1
+          when FalseClass, nil
+            next
+          else
+            raise Dentaku::ArgumentError.for(
+              :incompatible_type,
+              function_name: 'XOR()', expect: :logical, actual: arg.class
+            ), 'XOR() requires arguments to be logical expressions'
+          end
+        end
+        true_arg_count == 1
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:xor, Dentaku::AST::Xor)

data/lib/dentaku/ast/grouping.rb

@@ -0,0 +1,23 @@
+require_relative "./node"
+
+module Dentaku
+  module AST
+    class Grouping < Node
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context = {})
+        @node.value(context)
+      end
+
+      def type
+        @node.type
+      end
+
+      def dependencies(context = {})
+        @node.dependencies(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/identifier.rb

@@ -0,0 +1,52 @@
+require_relative '../exceptions'
+require 'dentaku/string_casing'
+
+module Dentaku
+  module AST
+    class Identifier < Node
+      include StringCasing
+      attr_reader :identifier, :case_sensitive
+
+      def initialize(token, options = {})
+        @case_sensitive = options.fetch(:case_sensitive, false)
+        @identifier = standardize_case(token.value)
+      end
+
+      def value(context = {})
+        v = context.fetch(identifier) do
+          raise UnboundVariableError.new([identifier]),
+                "no value provided for variables: #{identifier}"
+        end
+
+        case v
+        when Node
+          value = v.value(context)
+          context[identifier] = value if Dentaku.cache_identifier?
+          value
+        when Proc
+          v.call
+        else
+          v
+        end
+      end
+
+      def dependencies(context = {})
+        context.key?(identifier) ? dependencies_of(context[identifier], context) : [identifier]
+      end
+
+      def accept(visitor)
+        visitor.visit_identifier(self)
+      end
+
+      def to_s
+        identifier.to_s
+      end
+
+      private
+
+      def dependencies_of(node, context)
+        node.respond_to?(:dependencies) ? node.dependencies(context) : []
+      end
+    end
+  end
+end

data/lib/dentaku/ast/literal.rb

@@ -0,0 +1,30 @@
+module Dentaku
+  module AST
+    class Literal < Node
+      attr_reader :type
+
+      def initialize(token)
+        @token = token
+        @value = token.value
+        @type  = token.category
+      end
+
+      def value(*)
+        @value
+      end
+
+      def dependencies(*)
+        []
+      end
+
+      def accept(visitor)
+        visitor.visit_literal(self)
+      end
+
+      def quoted
+        @token.raw_value || value.to_s
+      end
+      alias_method :to_s, :quoted
+    end
+  end
+end

data/lib/dentaku/ast/logical.rb

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

data/lib/dentaku/ast/negation.rb

@@ -0,0 +1,54 @@
+module Dentaku
+  module AST
+    class Negation < Arithmetic
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+
+        unless valid_node?(node)
+          raise NodeError.new(:numeric, node.type, :node),
+                "#{self.class} requires numeric operands"
+        end
+      end
+
+      def operator
+        :*
+      end
+
+      def value(context = {})
+        cast(@node.value(context)) * -1
+      end
+
+      def type
+        :numeric
+      end
+
+      def self.arity
+        1
+      end
+
+      def self.right_associative?
+        true
+      end
+
+      def self.precedence
+        40
+      end
+
+      def dependencies(context = {})
+        @node.dependencies(context)
+      end
+
+      def accept(visitor)
+        visitor.visit_negation(self)
+      end
+
+      private
+
+      def valid_node?(node)
+        node && (node.dependencies.any? || node.type == :numeric)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/nil.rb

@@ -0,0 +1,13 @@
+module Dentaku
+  module AST
+    class Nil < Node
+      def value(*)
+        nil
+      end
+
+      def accept(visitor)
+        visitor.visit_nil(self)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/node.rb

@@ -0,0 +1,29 @@
+module Dentaku
+  module AST
+    class Node
+      def self.precedence
+        0
+      end
+
+      def self.arity
+        nil
+      end
+
+      def self.resolve_class(*)
+        self
+      end
+
+      def dependencies(context = {})
+        []
+      end
+
+      def type
+        nil
+      end
+
+      def name
+        self.class.name.to_s.split("::").last.upcase
+      end
+    end
+  end
+end

data/lib/dentaku/ast/numeric.rb

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