dentaku 3.4.2 → 3.5.1

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

@@ -1,23 +1,10 @@
-require_relative '../function'
-require_relative '../../exceptions'
+require_relative './enum'
 
 module Dentaku
   module AST
-    class Map < Function
-      def self.min_param_count
-        3
-      end
-
-      def self.max_param_count
-        3
-      end
-
-      def deferred_args
-        [1, 2]
-      end
-
+    class Map < Enum
       def value(context = {})
-        collection      = @args[0].value(context)
+        collection      = Array(@args[0].value(context))
         item_identifier = @args[1].identifier
         expression      = @args[2]
 

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)

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

@@ -34,6 +34,14 @@ module Dentaku
         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)

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

@@ -89,13 +89,9 @@ module Dentaku
     def with_rescues(var_name, results, block)
       yield
 
-    rescue UnboundVariableError,  Dentaku::ZeroDivisionError => ex
+    rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
       ex.recipient_variable = var_name
       results[var_name] = block.call(ex)
-
-    rescue Dentaku::ArgumentError => ex
-      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]

data/lib/dentaku/exceptions.rb

@@ -1,10 +1,9 @@
 module Dentaku
   class Error < StandardError
+    attr_accessor :recipient_variable
   end
 
   class UnboundVariableError < Error
-    attr_accessor :recipient_variable
-
     attr_reader :unbound_variables
 
     def initialize(unbound_variables)
@@ -74,6 +73,7 @@ module Dentaku
 
   class ArgumentError < ::ArgumentError
     attr_reader :reason, :meta
+    attr_accessor :recipient_variable
 
     def initialize(reason, **meta)
       @reason = reason

data/lib/dentaku/parser.rb

@@ -10,8 +10,11 @@ module Dentaku
       pow:      AST::Exponentiation,
       negate:   AST::Negation,
       mod:      AST::Modulo,
+
       bitor:    AST::BitwiseOr,
       bitand:   AST::BitwiseAnd,
+      bitshiftleft:  AST::BitwiseShiftLeft,
+      bitshiftright: AST::BitwiseShiftRight,
 
       lt:       AST::LessThan,
       gt:       AST::GreaterThan,
@@ -22,6 +25,7 @@ module Dentaku
 
       and:      AST::And,
       or:       AST::Or,
+      xor:      AST::Xor,
     }.freeze
 
     attr_reader :input, :output, :operations, :arities, :case_sensitive
@@ -37,17 +41,19 @@ module Dentaku
 
     def consume(count = 2)
       operator = operations.pop
+      fail! :invalid_statement if operator.nil?
+
       operator.peek(output)
 
       args_size = operator.arity || count
       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 +149,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
 
@@ -120,9 +120,9 @@ module Dentaku
 
       def operator
         names = {
-          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&'
+          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&', bitshiftleft: '<<', bitshiftright: '>>'
         }.invert
-        new(:operator, '\^|\+|-|\*|\/|%|\||&', lambda { |raw| names[raw] })
+        new(:operator, '\^|\+|-|\*|\/|%|\||&|<<|>>', lambda { |raw| names[raw] })
       end
 
       def grouping

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.4.2"
+  VERSION = "3.5.1"
 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/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/arithmetic_spec.rb

@@ -45,6 +45,13 @@ describe Dentaku::AST::Arithmetic do
     expect(add(x, one, 'x' => '.1')).to eq(1.1)
     expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
     expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
+
+    int_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1")
+    decimal_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1.0")
+
+    expect(add(int_one, int_one).class).to eq(Integer)
+    expect(add(int_one, decimal_one).class).to eq(BigDecimal)
+    expect(add(decimal_one, decimal_one).class).to eq(BigDecimal)
   end
 
   it 'performs arithmetic on arrays' do

data/spec/ast/comparator_spec.rb

@@ -5,7 +5,9 @@ require 'dentaku/token'
 
 describe Dentaku::AST::Comparator do
   let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:one_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '1') }
   let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:two_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '2') }
   let(:x) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
   let(:y) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
   let(:nilly) do
@@ -21,20 +23,27 @@ describe Dentaku::AST::Comparator do
     expect(equal(x, y).value(ctx)).to be_falsey
   end
 
+  it 'performs conversion from string to numeric operands' do
+    expect(less_than(one, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two).value(ctx)).to be_truthy
+  end
+
   it 'raises a dentaku argument error when incorrect arguments are passed in' do
     expect { less_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
     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 +59,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

@@ -3,6 +3,7 @@ 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)
@@ -15,4 +16,10 @@ describe Dentaku::AST::Filter do
     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