dentaku 3.2.0 → 3.5.1

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

@@ -3,7 +3,28 @@ require_relative '../function'
 module Dentaku
   module AST
     module StringFunctions
-      class Left < Function
+      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
@@ -11,12 +32,21 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          negative_argument_failure('LEFT') if length < 0
           string[0, length]
         end
       end
 
-      class Right < Function
+      class Right < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @string, @length = *@args
@@ -24,12 +54,21 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = @length.value(context)
+          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 < Function
+      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
@@ -37,13 +76,23 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          offset = @offset.value(context)
-          length = @length.value(context)
+          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 < Function
+      class Len < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          1
+        end
+
         def initialize(*args)
           super
           @string = @args[0]
@@ -53,9 +102,21 @@ module Dentaku
           string = @string.value(context).to_s
           string.length
         end
+
+        def type
+          :numeric
+        end
       end
 
-      class Find < Function
+      class Find < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @needle, @haystack = *@args
@@ -68,9 +129,21 @@ module Dentaku
           pos = haystack.index(needle)
           pos && pos + 1
         end
+
+        def type
+          :numeric
+        end
       end
 
-      class Substitute < Function
+      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
@@ -85,7 +158,15 @@ module Dentaku
         end
       end
 
-      class Concat < Function
+      class Concat < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          Float::INFINITY
+        end
+
         def initialize(*args)
           super
         end
@@ -95,7 +176,15 @@ module Dentaku
         end
       end
 
-      class Contains < Function
+      class Contains < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @needle, @haystack = *args
@@ -104,6 +193,10 @@ module Dentaku
         def value(context = {})
           @haystack.value(context).to_s.include? @needle.value(context).to_s
         end
+
+        def type
+          :logical
+        end
       end
     end
   end

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

@@ -1,6 +1,8 @@
+require_relative "./node"
+
 module Dentaku
   module AST
-    class Grouping
+    class Grouping < Node
       def initialize(node)
         @node = node
       end

data/lib/dentaku/ast/identifier.rb

@@ -20,20 +20,32 @@ module Dentaku
 
         case v
         when Node
-          v.value(context)
+          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]) : [identifier]
+        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)
-        node.respond_to?(:dependencies) ? node.dependencies : []
+      def dependencies_of(node, context)
+        node.respond_to?(:dependencies) ? node.dependencies(context) : []
       end
     end
   end

data/lib/dentaku/ast/literal.rb

@@ -4,6 +4,7 @@ module Dentaku
       attr_reader :type
 
       def initialize(token)
+        @token = token
         @value = token.value
         @type  = token.category
       end
@@ -15,6 +16,15 @@ module Dentaku
       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/negation.rb

@@ -1,11 +1,13 @@
 module Dentaku
   module AST
     class Negation < Arithmetic
+      attr_reader :node
+
       def initialize(node)
         @node = node
 
         unless valid_node?(node)
-          raise NodeError.new(:numeric, left.type, :left),
+          raise NodeError.new(:numeric, node.type, :node),
                 "#{self.class} requires numeric operands"
         end
       end
@@ -38,6 +40,10 @@ module Dentaku
         @node.dependencies(context)
       end
 
+      def accept(visitor)
+        visitor.visit_negation(self)
+      end
+
       private
 
       def valid_node?(node)

data/lib/dentaku/ast/nil.rb

@@ -4,6 +4,10 @@ module Dentaku
       def value(*)
         nil
       end
+
+      def accept(visitor)
+        visitor.visit_nil(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/node.rb

@@ -15,6 +15,14 @@ module Dentaku
       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/operation.rb

@@ -5,6 +5,14 @@ module Dentaku
     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
@@ -17,6 +25,15 @@ module Dentaku
       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

@@ -3,6 +3,13 @@ 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

@@ -11,17 +11,24 @@ 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'
@@ -29,3 +36,4 @@ 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

@@ -20,8 +20,9 @@ module Dentaku
       results = load_results(&error_handler)
 
       FlatHash.expand(
-        expression_hash.each_with_object({}) do |(k, _), r|
-          r[k] = results[k.to_s]
+        expression_hash.each_with_object({}) do |(k, v), r|
+          default = v.nil? ? v : :undefined
+          r[k] = results.fetch(k.to_s, default)
         end
       )
     end
@@ -52,35 +53,49 @@ module Dentaku
     end
 
     def expression_with_exception_handler(&block)
-      ->(expr, ex) { block.call(ex) }
+      ->(_expr, ex) { block.call(ex) }
     end
 
     def load_results(&block)
-      variables_in_resolve_order.each_with_object({}) do |var_name, r|
-        begin
-          solved = calculator.memory
-          value_from_memory = solved[var_name.downcase]
-
-          if value_from_memory.nil? &&
-              expressions[var_name].nil? &&
-              !solved.has_key?(var_name)
-            next
-          end
-
-          value = value_from_memory || evaluate!(
+      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],
-            expressions.merge(r).merge(solved),
+            context.merge(results),
             &expression_with_exception_handler(&block)
           )
-
-          r[var_name] = value
-        rescue UnboundVariableError, Dentaku::ZeroDivisionError => ex
-          ex.recipient_variable = var_name
-          r[var_name] = block.call(ex)
-        rescue Dentaku::ArgumentError => ex
-          r[var_name] = block.call(ex)
         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
@@ -109,9 +124,5 @@ module Dentaku
         end
       }
     end
-
-    def evaluate!(expression, results, &block)
-      calculator.evaluate!(expression, results, &block)
-    end
   end
 end

data/lib/dentaku/calculator.rb

@@ -9,7 +9,8 @@ require 'dentaku/token'
 module Dentaku
   class Calculator
     include StringCasing
-    attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases, :nested_data_support
+    attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases,
+                :nested_data_support, :ast_cache
 
     def initialize(options = {})
       clear
@@ -46,7 +47,7 @@ module Dentaku
 
     def evaluate(expression, data = {}, &block)
       evaluate!(expression, data)
-    rescue UnboundVariableError, Dentaku::ArgumentError => ex
+    rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError => ex
       block.call(expression, ex) if block_given?
     end
 
@@ -58,10 +59,10 @@ module Dentaku
       store(data) do
         node = expression
         node = ast(node) unless node.is_a?(AST::Node)
-        unbound = node.dependencies - memory.keys
+        unbound = node.dependencies(memory)
         unless unbound.empty?
           raise UnboundVariableError.new(unbound),
-                "no value provided for variables: #{unbound.join(', ')}"
+                "no value provided for variables: #{unbound.uniq.join(', ')}"
         end
         node.value(memory)
       end
@@ -76,13 +77,21 @@ module Dentaku
     end
 
     def dependencies(expression, context = {})
-      if expression.is_a? Array
-        return expression.flat_map { |e| dependencies(e, 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
-      store(context) { ast(expression).dependencies(memory) }
     end
 
     def ast(expression)
+      return expression.map { |e| ast(e) } if expression.is_a? Array
+
       @ast_cache.fetch(expression) {
         options = {
           case_sensitive: case_sensitive,
@@ -97,6 +106,10 @@ module Dentaku
       }
     end
 
+    def load_cache(ast_cache)
+      @ast_cache = ast_cache
+    end
+
     def clear_cache(pattern = :all)
       case pattern
       when :all
@@ -114,7 +127,7 @@ module Dentaku
       restore = Hash[memory]
 
       if value.nil?
-        key_or_hash = FlatHash.from_hash(key_or_hash) if nested_data_support
+        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

data/lib/dentaku/date_arithmetic.rb

@@ -0,0 +1,45 @@
+module Dentaku
+  class DateArithmetic
+    def initialize(date)
+      @base = date
+    end
+
+    def add(duration)
+      case duration
+      when Numeric
+        @base + duration
+      when Dentaku::AST::Duration::Value
+        case duration.unit
+        when :year
+          Time.local(@base.year + duration.value, @base.month, @base.day).to_datetime
+        when :month
+          @base >> duration.value
+        when :day
+          @base + 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 DateTime, Numeric
+        @base - duration
+      when Dentaku::AST::Duration::Value
+        case duration.unit
+        when :year
+          Time.local(@base.year - duration.value, @base.month, @base.day).to_datetime
+        when :month
+          @base << duration.value
+        when :day
+          @base - 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
+  end
+end