hayadentaku 3.5.7

data/lib/dentaku/ast/operation.rb

@@ -0,0 +1,44 @@
+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
+
+      def operator_spacing
+        " "
+      end
+    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,42 @@
+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/abs'
+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/intercept'
+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/reduce'
+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,158 @@
+require 'dentaku/dependency_resolver'
+require 'dentaku/exceptions'
+require 'dentaku/flat_hash'
+require 'dentaku/parser'
+require 'dentaku/tokenizer'
+
+module Dentaku
+  class BulkExpressionSolver
+    class StrictEvaluator
+      def initialize(calculator)
+        @calculator = calculator
+      end
+
+      def evaluate(*args)
+        @calculator.evaluate!(*args)
+      end
+    end
+
+    class PermissiveEvaluator
+      def initialize(calculator, block)
+        @calculator = calculator
+        @block = block || ->(*) { :undefined }
+      end
+
+      def evaluate(*args)
+        @calculator.evaluate(*args) { |expr, ex|
+          @block.call(ex)
+        }
+      end
+    end
+
+    def initialize(expressions, calculator)
+      @expression_hash = FlatHash.from_hash(expressions)
+      @calculator = calculator
+    end
+
+    def solve!
+      @evaluator = StrictEvaluator.new(calculator)
+      solve(&raise_exception_handler)
+    end
+
+    def solve(&block)
+      @evaluator ||= PermissiveEvaluator.new(calculator, 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, :evaluator
+
+    def return_undefined_handler
+      ->(*) { :undefined }
+    end
+
+    def raise_exception_handler
+      ->(ex) { raise ex }
+    end
+
+    def expression_with_exception_handler(var_name, &block)
+      ->(_expr, ex) {
+        ex.recipient_variable = var_name
+        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] || evaluator.evaluate(
+            expressions[var_name],
+            context.merge(results),
+            &expression_with_exception_handler(var_name, &block)
+          ).tap { |res|
+            res.recipient_variable = var_name if res.respond_to?(:recipient_variable=)
+            res
+          }
+        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,192 @@
+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, :raw_date_literals
+
+    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)
+      @raw_date_literals = options.fetch(:raw_date_literals, true)
+      options.delete(:raw_date_literals)
+      @ast_cache = options
+      @disable_ast_cache = false
+      @function_registry = Dentaku::AST::FunctionRegistry.new
+    end
+
+    def self.add_function(name, type, body, callback = nil)
+      Dentaku::AST::FunctionRegistry.default.register(name, type, body, callback)
+    end
+
+    def self.add_functions(functions)
+      functions.each { |(name, type, body, callback)| add_function(name, type, body, callback) }
+    end
+
+    def add_function(name, type, body, callback = nil)
+      @function_registry.register(name, type, body, callback)
+      self
+    end
+
+    def add_functions(functions)
+      functions.each { |(name, type, body, callback)| add_function(name, type, body, callback) }
+      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)
+      context = evaluation_context(data, :permissive)
+      return evaluate_array(expression, context, &block) if expression.is_a?(Array)
+
+      evaluate!(expression, context)
+    rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError => ex
+      block.call(expression, ex) if block_given?
+    end
+
+    private def evaluate_array(expression, data = {}, &block)
+      expression.map { |e| evaluate(e, data, &block) }
+    end
+
+    def evaluate!(expression, data = {}, &block)
+      context = evaluation_context(data, :strict)
+      return evaluate_array!(expression, context, &block) if expression.is_a? Array
+
+      store(context) do
+        node = ast(expression)
+        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
+
+    private def evaluate_array!(expression, data = {}, &block)
+      expression.map { |e| evaluate!(e, data, &block) }
+    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 if expression.is_a?(AST::Node)
+      return expression.map { |e| ast(e) } if expression.is_a? Array
+
+      @ast_cache.fetch(expression) {
+        options = {
+          aliases: aliases,
+          case_sensitive: case_sensitive,
+          function_registry: @function_registry,
+          raw_date_literals: raw_date_literals
+        }
+
+        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 evaluation_context(data, evaluation_mode)
+      data.key?(:__evaluation_mode) ? data : data.merge(__evaluation_mode: evaluation_mode)
+    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

data/lib/dentaku/date_arithmetic.rb

@@ -0,0 +1,60 @@
+module Dentaku
+  class DateArithmetic
+    def initialize(date)
+      if date.respond_to?(:strftime)
+        @base = date
+      else
+        @base = Time.parse(date).to_datetime
+      end
+    end
+
+    def add(duration)
+      case duration
+      when Numeric
+        @base + duration
+      when Dentaku::AST::Duration::Value
+        case @base
+        when Time
+          change_datetime(@base.to_datetime, duration.unit, duration.value).to_time
+        else
+          change_datetime(@base, duration.unit, duration.value)
+        end
+      else
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
+          "'#{duration || duration.class}' is not coercible for date arithmetic"
+      end
+    end
+
+    def sub(duration)
+      case duration
+      when Date, DateTime, Numeric, Time
+        @base - duration
+      when Dentaku::AST::Duration::Value
+        case @base
+        when Time
+          change_datetime(@base.to_datetime, duration.unit, -duration.value).to_time
+        else
+          change_datetime(@base, duration.unit, -duration.value)
+        end
+      when Dentaku::TokenScanner::DATE_TIME_REGEXP
+        @base - Time.parse(duration).to_datetime
+      else
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
+          "'#{duration || duration.class}' is not coercible for date arithmetic"
+      end
+    end
+
+    private
+
+    def change_datetime(base, unit, value)
+      case unit
+      when :year
+        base >> (value * 12)
+      when :month
+        base >> value
+      when :day
+        base + value
+      end
+    end
+  end
+end

data/lib/dentaku/dependency_resolver.rb

@@ -0,0 +1,29 @@
+require 'tsort'
+
+module Dentaku
+  class DependencyResolver
+    include TSort
+
+    def self.find_resolve_order(vars_to_dependencies_hash, case_sensitive = false)
+      self.new(vars_to_dependencies_hash).sort
+    end
+
+    def initialize(vars_to_dependencies_hash)
+      @key_mapping = Hash[vars_to_dependencies_hash.keys.map { |k| [k.downcase, k] }]
+      # ensure variables are normalized strings
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.downcase.to_s, v] }]
+    end
+
+    def sort
+      tsort.map { |k| @key_mapping.fetch(k, k) }
+    end
+
+    def tsort_each_node(&block)
+      @vars_to_deps.each_key(&block)
+    end
+
+    def tsort_each_child(node, &block)
+      @vars_to_deps.fetch(node.to_s, []).each(&block)
+    end
+  end
+end

data/lib/dentaku/exceptions.rb

@@ -0,0 +1,116 @@
+module Dentaku
+  class Error < StandardError
+    attr_accessor :recipient_variable
+  end
+
+  class UnboundVariableError < Error
+    attr_reader :unbound_variables
+
+    def initialize(unbound_variables)
+      @unbound_variables = unbound_variables
+    end
+  end
+
+  class MathDomainError < Error
+    attr_reader :function_name, :args
+
+    def initialize(function_name, args)
+      @function_name = function_name
+      @args = args
+    end
+  end
+
+  class NodeError < Error
+    attr_reader :child, :expect, :actual
+
+    def initialize(expect, actual, child)
+      @expect = Array(expect)
+      @actual = actual
+      @child = child
+    end
+  end
+
+  class ParseError < Error
+    attr_reader :reason, :meta
+
+    def initialize(reason, **meta)
+      @reason = reason
+      @meta = meta
+    end
+
+    private_class_method :new
+
+    VALID_REASONS = %i[
+      node_invalid too_few_operands too_many_operands undefined_function
+      unprocessed_token unknown_case_token unbalanced_bracket
+      unbalanced_parenthesis unknown_grouping_token not_implemented_token_category
+      invalid_statement
+    ].freeze
+
+    def self.for(reason, **meta)
+      unless VALID_REASONS.include?(reason)
+        raise ::ArgumentError, "Unhandled #{reason}"
+      end
+
+      new(reason, **meta)
+    end
+  end
+
+  class TokenizerError < Error
+    attr_reader :reason, :meta
+
+    def initialize(reason, **meta)
+      @reason = reason
+      @meta = meta
+    end
+
+    private_class_method :new
+
+    VALID_REASONS = %i[
+      parse_error
+      too_many_closing_parentheses
+      too_many_opening_parentheses
+      unexpected_zero_width_match
+    ].freeze
+
+    def self.for(reason, **meta)
+      unless VALID_REASONS.include?(reason)
+        raise ::ArgumentError, "Unhandled #{reason}"
+      end
+
+      new(reason, **meta)
+    end
+  end
+
+  class ArgumentError < ::ArgumentError
+    attr_reader :reason, :meta
+    attr_accessor :recipient_variable
+
+    def initialize(reason, **meta)
+      @reason = reason
+      @meta = meta
+    end
+
+    private_class_method :new
+
+    VALID_REASONS = %i[
+      incompatible_type
+      invalid_operator
+      invalid_value
+      too_few_arguments
+      wrong_number_of_arguments
+    ].freeze
+
+    def self.for(reason, **meta)
+      unless VALID_REASONS.include?(reason)
+        raise ::ArgumentError, "Unhandled #{reason}"
+      end
+
+      new(reason, **meta)
+    end
+  end
+
+  class ZeroDivisionError < ::ZeroDivisionError
+    attr_accessor :recipient_variable
+  end
+end