dentaku_zevo 3.5.2

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,28 @@
+module Dentaku
+  module AST
+    class Node
+      def self.precedence
+        0
+      end
+
+      def self.arity
+        nil
+      end
+
+      def self.peek(*)
+      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

data/lib/dentaku/ast/operation.rb

@@ -0,0 +1,39 @@
+require_relative './node'
+
+module Dentaku
+  module AST
+    class Operation < Node
+      attr_reader :left, :right
+
+      def self.min_param_count
+        arity
+      end
+
+      def self.max_param_count
+        arity
+      end
+
+      def initialize(left, right)
+        @left  = left
+        @right = right
+      end
+
+      def dependencies(context = {})
+        (left.dependencies(context) + right.dependencies(context)).uniq
+      end
+
+      def self.right_associative?
+        false
+      end
+
+      def accept(visitor)
+        visitor.visit_operation(self)
+      end
+
+      def display_operator
+        operator.to_s
+      end
+      alias_method :to_s, :display_operator
+    end
+  end
+end

data/lib/dentaku/ast/string.rb

@@ -0,0 +1,15 @@
+require_relative "./literal"
+
+module Dentaku
+  module AST
+    class String < Literal
+      def quoted
+        %Q{"#{ escaped }"}
+      end
+
+      def escaped
+        @value.gsub('"', '\"')
+      end
+    end
+  end
+end

data/lib/dentaku/ast.rb

@@ -0,0 +1,39 @@
+require_relative './ast/node'
+require_relative './ast/nil'
+require_relative './ast/datetime'
+require_relative './ast/numeric'
+require_relative './ast/logical'
+require_relative './ast/string'
+require_relative './ast/identifier'
+require_relative './ast/arithmetic'
+require_relative './ast/bitwise'
+require_relative './ast/negation'
+require_relative './ast/comparators'
+require_relative './ast/combinators'
+require_relative './ast/access'
+require_relative './ast/array'
+require_relative './ast/grouping'
+require_relative './ast/case'
+require_relative './ast/function_registry'
+require_relative './ast/functions/all'
+require_relative './ast/functions/and'
+require_relative './ast/functions/any'
+require_relative './ast/functions/avg'
+require_relative './ast/functions/count'
+require_relative './ast/functions/duration'
+require_relative './ast/functions/filter'
+require_relative './ast/functions/if'
+require_relative './ast/functions/map'
+require_relative './ast/functions/max'
+require_relative './ast/functions/min'
+require_relative './ast/functions/not'
+require_relative './ast/functions/or'
+require_relative './ast/functions/pluck'
+require_relative './ast/functions/round'
+require_relative './ast/functions/rounddown'
+require_relative './ast/functions/roundup'
+require_relative './ast/functions/ruby_math'
+require_relative './ast/functions/string_functions'
+require_relative './ast/functions/sum'
+require_relative './ast/functions/switch'
+require_relative './ast/functions/xor'

data/lib/dentaku/bulk_expression_solver.rb

@@ -0,0 +1,128 @@
+require 'dentaku/dependency_resolver'
+require 'dentaku/exceptions'
+require 'dentaku/flat_hash'
+require 'dentaku/parser'
+require 'dentaku/tokenizer'
+
+module Dentaku
+  class BulkExpressionSolver
+    def initialize(expressions, calculator)
+      @expression_hash = FlatHash.from_hash(expressions)
+      @calculator = calculator
+    end
+
+    def solve!
+      solve(&raise_exception_handler)
+    end
+
+    def solve(&block)
+      error_handler = block || return_undefined_handler
+      results = load_results(&error_handler)
+
+      FlatHash.expand(
+        expression_hash.each_with_object({}) do |(k, v), r|
+          default = v.nil? ? v : :undefined
+          r[k] = results.fetch(k.to_s, default)
+        end
+      )
+    end
+
+    def dependencies
+      Hash[expression_deps].tap do |d|
+        d.values.each do |deps|
+          unresolved = deps.reject { |ud| d.has_key?(ud) }
+          unresolved.each { |u| add_dependencies(d, u) }
+        end
+      end
+    end
+
+    private
+
+    def self.dependency_cache
+      @dep_cache ||= {}
+    end
+
+    attr_reader :expression_hash, :calculator
+
+    def return_undefined_handler
+      ->(*) { :undefined }
+    end
+
+    def raise_exception_handler
+      ->(ex) { raise ex }
+    end
+
+    def expression_with_exception_handler(&block)
+      ->(_expr, ex) { block.call(ex) }
+    end
+
+    def load_results(&block)
+      facts, _formulas = expressions.transform_keys(&:downcase)
+                                    .transform_values { |v| calculator.ast(v) }
+                                    .partition { |_, v| calculator.dependencies(v, nil).empty? }
+
+      evaluated_facts = facts.to_h.each_with_object({}) do |(var_name, ast), h|
+        with_rescues(var_name, h, block) do
+          h[var_name] = ast.is_a?(Array) ? ast.map(&:value) : ast.value
+        end
+      end
+
+      context = calculator.memory.merge(evaluated_facts)
+
+      variables_in_resolve_order.each_with_object({}) do |var_name, results|
+        next if expressions[var_name].nil?
+
+        with_rescues(var_name, results, block) do
+          results[var_name] = evaluated_facts[var_name] || calculator.evaluate!(
+            expressions[var_name],
+            context.merge(results),
+            &expression_with_exception_handler(&block)
+          )
+        end
+      end
+
+    rescue TSort::Cyclic => ex
+      block.call(ex)
+      {}
+    end
+
+    def with_rescues(var_name, results, block)
+      yield
+
+    rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
+      ex.recipient_variable = var_name
+      results[var_name] = block.call(ex)
+    ensure
+      if results[var_name] == :undefined && calculator.memory.has_key?(var_name.downcase)
+        results[var_name] = calculator.memory[var_name.downcase]
+      end
+    end
+
+    def expressions
+      @expressions ||= Hash[expression_hash.map { |k, v| [k.to_s, v] }]
+    end
+
+    def expression_deps
+      expressions.map do |var, expr|
+        [var, calculator.dependencies(expr)]
+      end
+    end
+
+    def add_dependencies(current_dependencies, variable)
+      node = calculator.memory[variable]
+      if node.respond_to?(:dependencies)
+        current_dependencies[variable] = node.dependencies
+        node.dependencies.each { |d| add_dependencies(current_dependencies, d) }
+      end
+    end
+
+    def variables_in_resolve_order
+      cache_key = expressions.keys.map(&:to_s).sort.join("|")
+      @ordered_deps ||= self.class.dependency_cache.fetch(cache_key) {
+        DependencyResolver.find_resolve_order(dependencies).tap do |d|
+          self.class.dependency_cache[cache_key] = d if Dentaku.cache_dependency_order?
+        end
+      }
+    end
+  end
+end

data/lib/dentaku/calculator.rb

@@ -0,0 +1,169 @@
+require 'dentaku/bulk_expression_solver'
+require 'dentaku/dependency_resolver'
+require 'dentaku/exceptions'
+require 'dentaku/flat_hash'
+require 'dentaku/parser'
+require 'dentaku/string_casing'
+require 'dentaku/token'
+
+module Dentaku
+  class Calculator
+    include StringCasing
+    attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases,
+                :nested_data_support, :ast_cache
+
+    def initialize(options = {})
+      clear
+      @tokenizer = Tokenizer.new
+      @case_sensitive = options.delete(:case_sensitive)
+      @aliases = options.delete(:aliases) || Dentaku.aliases
+      @nested_data_support = options.fetch(:nested_data_support, true)
+      options.delete(:nested_data_support)
+      @ast_cache = options
+      @disable_ast_cache = false
+      @function_registry = Dentaku::AST::FunctionRegistry.new
+    end
+
+    def self.add_function(name, type, body)
+      Dentaku::AST::FunctionRegistry.default.register(name, type, body)
+    end
+
+    def add_function(name, type, body)
+      @function_registry.register(name, type, body)
+      self
+    end
+
+    def add_functions(fns)
+      fns.each { |(name, type, body)| add_function(name, type, body) }
+      self
+    end
+
+    def disable_cache
+      @disable_ast_cache = true
+      yield(self) if block_given?
+    ensure
+      @disable_ast_cache = false
+    end
+
+    def evaluate(expression, data = {}, &block)
+      evaluate!(expression, data)
+    rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError => ex
+      block.call(expression, ex) if block_given?
+    end
+
+    def evaluate!(expression, data = {}, &block)
+      return expression.map { |e|
+        evaluate(e, data, &block)
+      } if expression.is_a? Array
+
+      store(data) do
+        node = expression
+        node = ast(node) unless node.is_a?(AST::Node)
+        unbound = node.dependencies(memory)
+        unless unbound.empty?
+          raise UnboundVariableError.new(unbound),
+                "no value provided for variables: #{unbound.uniq.join(', ')}"
+        end
+        node.value(memory)
+      end
+    end
+
+    def solve!(expression_hash)
+      BulkExpressionSolver.new(expression_hash, self).solve!
+    end
+
+    def solve(expression_hash, &block)
+      BulkExpressionSolver.new(expression_hash, self).solve(&block)
+    end
+
+    def dependencies(expression, context = {})
+      test_context = context.nil? ? {} : store(context) { memory }
+
+      case expression
+      when Dentaku::AST::Node
+        expression.dependencies(test_context)
+      when Array
+        expression.flat_map { |e| dependencies(e, context) }
+      else
+        ast(expression).dependencies(test_context)
+      end
+    end
+
+    def ast(expression)
+      return expression.map { |e| ast(e) } if expression.is_a? Array
+
+      @ast_cache.fetch(expression) {
+        options = {
+          case_sensitive: case_sensitive,
+          function_registry: @function_registry,
+          aliases: aliases
+        }
+
+        tokens = tokenizer.tokenize(expression, options)
+        Parser.new(tokens, options).parse.tap do |node|
+          @ast_cache[expression] = node if cache_ast?
+        end
+      }
+    end
+
+    def load_cache(ast_cache)
+      @ast_cache = ast_cache
+    end
+
+    def clear_cache(pattern = :all)
+      case pattern
+      when :all
+        @ast_cache = {}
+      when String
+        @ast_cache.delete(pattern)
+      when Regexp
+        @ast_cache.delete_if { |k, _| k =~ pattern }
+      else
+        raise ::ArgumentError
+      end
+    end
+
+    def store(key_or_hash, value = nil)
+      restore = Hash[memory]
+
+      if value.nil?
+        key_or_hash = FlatHash.from_hash_with_intermediates(key_or_hash) if nested_data_support
+        key_or_hash.each do |key, val|
+          memory[standardize_case(key.to_s)] = val
+        end
+      else
+        memory[standardize_case(key_or_hash.to_s)] = value
+      end
+
+      if block_given?
+        begin
+          result = yield
+          @memory = restore
+          return result
+        rescue => e
+          @memory = restore
+          raise e
+        end
+      end
+
+      self
+    end
+    alias_method :bind, :store
+
+    def store_formula(key, formula)
+      store(key, ast(formula))
+    end
+
+    def clear
+      @memory = {}
+    end
+
+    def empty?
+      memory.empty?
+    end
+
+    def cache_ast?
+      Dentaku.cache_ast? && !@disable_ast_cache
+    end
+  end
+end