dentaku 3.4.0 → 3.5.0

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

@@ -1,9 +1,9 @@
-require_relative '../function'
+require_relative './enum'
 require_relative '../../exceptions'
 
 module Dentaku
   module AST
-    class Pluck < Function
+    class Pluck < Enum
       def self.min_param_count
         2
       end
@@ -12,12 +12,13 @@ module Dentaku
         2
       end
 
-      def deferred_args
-        [1]
-      end
-
       def value(context = {})
-        collection = @args[0].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] }

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

@@ -5,9 +5,10 @@ module Dentaku
   module AST
     class RubyMath < Function
       def self.[](method)
-        klass = Class.new(self)
+        klass_name = method.to_s.capitalize
+        klass = const_set(klass_name , Class.new(self))
         klass.implement(method)
-        klass
+        const_get(klass_name)
       end
 
       def self.implement(method)
@@ -40,8 +41,10 @@ module Dentaku
         self.class.call(*args)
       end
 
+      ARRAY_RETURN_TYPES = [:frexp, :lgamma].freeze
+
       def type
-        nil
+        ARRAY_RETURN_TYPES.include?(@name) ? :array : :numeric
       end
     end
   end

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

@@ -1,13 +1,12 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:sum, :numeric, ->(*args) {
-  flatten_args = args.flatten
-  if flatten_args.empty?
+  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
 
-  flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+)
+  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+)
 })

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/identifier.rb

@@ -31,13 +31,21 @@ module Dentaku
       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

@@ -40,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

@@ -19,6 +19,10 @@ module Dentaku
       def type
         nil
       end
+
+      def name
+        self.class.name.to_s.split("::").last.upcase
+      end
     end
   end
 end

data/lib/dentaku/ast/operation.rb

@@ -25,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

@@ -21,6 +21,7 @@ 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'
@@ -35,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

@@ -61,17 +61,19 @@ module Dentaku
                                     .transform_values { |v| calculator.ast(v) }
                                     .partition { |_, v| calculator.dependencies(v, nil).empty? }
 
-      context = calculator.memory.merge(facts.to_h.each_with_object({}) do |(var_name, ast), h|
+      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)
+      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] = calculator.evaluate!(
+          results[var_name] = evaluated_facts[var_name] || calculator.evaluate!(
             expressions[var_name],
             context.merge(results),
             &expression_with_exception_handler(&block)

data/lib/dentaku/calculator.rb

@@ -59,7 +59,7 @@ 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.uniq.join(', ')}"

data/lib/dentaku/parser.rb

@@ -22,6 +22,7 @@ module Dentaku
 
       and:      AST::And,
       or:       AST::Or,
+      xor:      AST::Xor,
     }.freeze
 
     attr_reader :input, :output, :operations, :arities, :case_sensitive
@@ -43,11 +44,11 @@ module Dentaku
       min_size = operator.arity || operator.min_param_count || count
       max_size = operator.arity || operator.max_param_count || count
 
-      if output.length < min_size
+      if output.length < min_size || args_size < min_size
         fail! :too_few_operands, operator: operator, expect: min_size, actual: output.length
       end
 
-      if output.length > max_size && operations.empty?
+      if output.length > max_size && operations.empty? || args_size > max_size
         fail! :too_many_operands, operator: operator, expect: max_size, actual: output.length
       end
 
@@ -143,7 +144,8 @@ module Dentaku
                 inner_case_inputs,
                 operations: [AST::Case],
                 arities: [0],
-                function_registry: @function_registry
+                function_registry: @function_registry,
+                case_sensitive: case_sensitive
               )
               subparser.parse
               output.concat(subparser.output)

data/lib/dentaku/print_visitor.rb

@@ -0,0 +1,101 @@
+module Dentaku
+  class PrintVisitor
+    def initialize(node)
+      @output = ''
+      node.accept(self)
+    end
+
+    def visit_operation(node)
+      if node.left
+        visit_operand(node.left, node.class.precedence, suffix: " ")
+      end
+
+      @output << node.display_operator
+
+      if node.right
+        visit_operand(node.right, node.class.precedence, prefix: " ")
+      end
+    end
+
+    def visit_operand(node, precedence, prefix: "", suffix: "")
+      @output << prefix
+      @output << "(" if node.is_a?(Dentaku::AST::Operation) && node.class.precedence < precedence
+      node.accept(self)
+      @output << ")" if node.is_a?(Dentaku::AST::Operation) && node.class.precedence < precedence
+      @output << suffix
+    end
+
+    def visit_function(node)
+      @output << node.name
+      @output << "("
+      arg_count = node.args.length
+      node.args.each_with_index do |a, index|
+        a.accept(self)
+        @output << ", " unless index >= arg_count - 1
+      end
+      @output << ")"
+    end
+
+    def visit_case(node)
+      @output << "CASE "
+      node.switch.accept(self)
+      node.conditions.each { |c| c.accept(self) }
+      node.else && node.else.accept(self)
+      @output << " END"
+    end
+
+    def visit_switch(node)
+      node.node.accept(self)
+    end
+
+    def visit_case_conditional(node)
+      node.when.accept(self)
+      node.then.accept(self)
+    end
+
+    def visit_when(node)
+      @output << " WHEN "
+      node.node.accept(self)
+    end
+
+    def visit_then(node)
+      @output << " THEN "
+      node.node.accept(self)
+    end
+
+    def visit_else(node)
+      @output << " ELSE "
+      node.node.accept(self)
+    end
+
+    def visit_negation(node)
+      @output << "-"
+      @output << "(" unless node.node.is_a? Dentaku::AST::Literal
+      node.node.accept(self)
+      @output << ")" unless node.node.is_a? Dentaku::AST::Literal
+    end
+
+    def visit_access(node)
+      node.structure.accept(self)
+      @output << "["
+      node.index.accept(self)
+      @output << "]"
+    end
+
+    def visit_literal(node)
+      @output << node.quoted
+    end
+
+    def visit_identifier(node)
+      @output << node.identifier
+    end
+
+    def visit_nil(node)
+      @output << "NULL"
+    end
+
+    def to_s
+      @output
+    end
+  end
+end

data/lib/dentaku/token_scanner.rb

@@ -91,7 +91,7 @@ module Dentaku
 
       def numeric
         new(:numeric, '((?:\d+(\.\d+)?|\.\d+)(?:(e|E)(\+|-)?\d+)?)\b', lambda { |raw|
-          raw =~ /\./ ? BigDecimal(raw) : raw.to_i
+          raw =~ /(\.|e|E)/ ? BigDecimal(raw) : raw.to_i
         })
       end
 

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.4.0"
+  VERSION = "3.5.0"
 end

data/lib/dentaku/visitor/infix.rb

@@ -0,0 +1,82 @@
+# infix visitor
+#
+# use this visitor in a processor to get infix visiting order
+#
+#  visitor     node     deps
+#    accept ->   visit left ->
+#                process
+#                visit right ->
+module Dentaku
+  module Visitor
+    module Infix
+      def visit(ast)
+        ast.accept(self)
+      end
+
+      def process(_ast)
+        raise NotImplementedError
+      end
+
+      def visit_function(node)
+        node.args.each do |arg|
+          visit(arg)
+        end
+        process(node)
+      end
+
+      def visit_identifier(node)
+        process(node)
+      end
+
+      def visit_operation(node)
+        visit(node.left) if node.left
+        process(node)
+        visit(node.right) if node.right
+      end
+
+      def visit_operand(node)
+        process(node)
+      end
+
+      def visit_case(node)
+        process(node)
+      end
+
+      def visit_switch(node)
+        process(node)
+        end
+
+      def visit_case_conditional(node)
+        process(node)
+      end
+
+      def visit_when(node)
+        process(node)
+      end
+
+      def visit_then(node)
+        process(node)
+      end
+
+      def visit_else(node)
+        process(node)
+      end
+
+      def visit_negation(node)
+        process(node)
+      end
+
+      def visit_access(node)
+        process(node)
+      end
+
+      def visit_literal(node)
+        process(node)
+      end
+
+      def visit_nil(node)
+        process(node)
+      end
+    end
+  end
+end

data/lib/dentaku.rb

@@ -1,4 +1,5 @@
 require "bigdecimal"
+require "concurrent"
 require "dentaku/calculator"
 require "dentaku/version"
 
@@ -9,11 +10,11 @@ module Dentaku
   @aliases = {}
 
   def self.evaluate(expression, data = {}, &block)
-    calculator.evaluate(expression, data, &block)
+    calculator.value.evaluate(expression, data, &block)
   end
 
   def self.evaluate!(expression, data = {}, &block)
-    calculator.evaluate!(expression, data, &block)
+    calculator.value.evaluate!(expression, data, &block)
   end
 
   def self.enable_caching!
@@ -55,7 +56,7 @@ module Dentaku
   end
 
   def self.calculator
-    @calculator ||= Dentaku::Calculator.new
+    @calculator ||= Concurrent::ThreadLocalVar.new { Dentaku::Calculator.new }
   end
 end
 

data/spec/ast/all_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/all'
+require 'dentaku'
+
+describe Dentaku::AST::All do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'performs ALL operation' do
+    result = Dentaku('ALL(vals, val, val > 1)', vals: [1, 2, 3])
+    expect(result).to eq(false)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('ALL(vals, val, val > 1)', vals: 1)
+    expect(result).to eq(false)
+
+    result = Dentaku('ALL(vals, val, val > 1)', vals: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('ALL({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
+      Dentaku::ArgumentError, 'ALL() requires second argument to be an identifier'
+    )
+  end
+end

data/spec/ast/any_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/any'
+require 'dentaku'
+
+describe Dentaku::AST::Any do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'performs ANY operation' do
+    result = Dentaku('ANY(vals, val, val > 1)', vals: [1, 2, 3])
+    expect(result).to eq(true)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('ANY(vals, val, val > 1)', vals: 1)
+    expect(result).to eq(false)
+
+    result = Dentaku('ANY(vals, val, val > 1)', vals: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/ast/comparator_spec.rb

@@ -26,15 +26,16 @@ describe Dentaku::AST::Comparator do
     expect { less_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
     expect { greater_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
     expect { greater_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(one, x).value(ctx) }.to raise_error Dentaku::ArgumentError
     expect { not_equal(one, nilly).value(ctx) }.to_not raise_error
     expect { equal(one, nilly).value(ctx) }.to_not raise_error
   end
 
-  it 'raises a dentaku error when nil is passed in as first argument' do
-    expect { less_than(nilly, one).value(ctx) }.to raise_error Dentaku::Error
-    expect { less_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::Error
-    expect { greater_than(nilly, one).value(ctx) }.to raise_error Dentaku::Error
-    expect { greater_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::Error
+  it 'raises a dentaku argument error when nil is passed in as first argument' do
+    expect { less_than(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { less_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
     expect { not_equal(nilly, one).value(ctx) }.to_not raise_error
     expect { equal(nilly, one).value(ctx) }.to_not raise_error
   end
@@ -50,10 +51,6 @@ describe Dentaku::AST::Comparator do
       .to raise_error(NotImplementedError)
   end
 
-  it 'relies on inheriting classes to expose value method' do
-    expect { described_class.new(one, two).value(ctx) }.to raise_error NoMethodError
-  end
-
   private
 
   def less_than(left, right)

data/spec/ast/filter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/filter'
+require 'dentaku'
+
+describe Dentaku::AST::Filter do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'excludes unmatched values' do
+    result = Dentaku('SUM(FILTER(vals, val, val > 1))', vals: [1, 2, 3])
+    expect(result).to eq(5)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 1)
+    expect(result).to eq([])
+
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 2)
+    expect(result).to eq([2])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('FILTER({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
+      Dentaku::ArgumentError, 'FILTER() requires second argument to be an identifier'
+    )
+  end
+end

data/spec/ast/function_spec.rb

@@ -61,4 +61,9 @@ describe Dentaku::AST::Function do
     expect { described_class.numeric('7.') }.to raise_error Dentaku::ArgumentError
     expect { described_class.numeric(true) }.to raise_error Dentaku::ArgumentError
   end
+
+  it "allows read access to arguments" do
+    fn = described_class.new(1, 2, 3)
+    expect(fn.args).to eq([1, 2, 3])
+  end
 end