dentaku 3.4.2 → 3.5.0

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/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.2"
+  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/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

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

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

data/spec/ast/map_spec.rb

@@ -3,6 +3,7 @@ require 'dentaku/ast/functions/map'
 require 'dentaku'
 
 describe Dentaku::AST::Map do
+  let(:calculator) { Dentaku::Calculator.new }
   it 'operates on each value in an array' do
     result = Dentaku('SUM(MAP(vals, val, val + 1))', vals: [1, 2, 3])
     expect(result).to eq(9)
@@ -12,4 +13,15 @@ describe Dentaku::AST::Map do
     result = Dentaku('MAP(vals, val, val + 1)', vals: [])
     expect(result).to eq([])
   end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('MAP(vals, val, val + 1)', vals: 1)
+    expect(result).to eq([2])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('MAP({1, 2, 3}, "val", val + 1)') }.to raise_error(
+      Dentaku::ArgumentError,  'MAP() requires second argument to be an identifier'
+    )
+  end
 end

data/spec/ast/pluck_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/pluck'
+require 'dentaku'
+
+describe Dentaku::AST::Pluck do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'operates on each value in an array' do
+    result = Dentaku('PLUCK(users, age)', users: [
+      {name: "Bob",  age: 44},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([44, 27])
+  end
+
+  it 'works with an empty array' do
+    result = Dentaku('PLUCK(users, age)', users: [])
+    expect(result).to eq([])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect do Dentaku.evaluate!('PLUCK(users, "age")', users: [
+      {name: "Bob",  age: 44},
+      {name: "Jane", age: 27}
+    ]) end.to raise_error(Dentaku::ArgumentError, 'PLUCK() requires second argument to be an identifier')
+  end
+
+  it 'raises argument error if a non array of hashes is passed as collection' do
+    expect { calculator.evaluate!('PLUCK({1, 2, 3}, age)') }.to raise_error(
+      Dentaku::ArgumentError, 'PLUCK() requires first argument to be an array of hashes'
+    )
+  end
+end

data/spec/ast/xor_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/or'
+
+describe 'Dentaku::AST::Xor' do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'returns false if all of the arguments are false' do
+    result = Dentaku('XOR(false, false)')
+    expect(result).to eq(false)
+  end
+
+  it 'returns true if only one of the arguments is true' do
+    result = Dentaku('XOR(false, true)')
+    expect(result).to eq(true)
+  end
+
+  it 'returns false if more than one of the arguments is true' do
+    result = Dentaku('XOR(false, true, true)')
+    expect(result).to eq(false)
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('XOR(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('XOR()') }.to raise_error(Dentaku::ParseError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('XOR("r")') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/calculator_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'dentaku'
 describe Dentaku::Calculator do
   let(:calculator)   { described_class.new }
+  let(:with_case_sensitivity) { described_class.new(case_sensitive: true) }
   let(:with_memory)  { described_class.new.store(apples: 3) }
   let(:with_aliases) { described_class.new(aliases: { round: ['rrround'] }) }
   let(:without_nested_data) { described_class.new(nested_data_support: false) }
@@ -186,6 +187,11 @@ describe Dentaku::Calculator do
     it "finds no dependencies in array literals" do
       expect(calculator.dependencies([1, 2, 3])).to eq([])
     end
+
+    it "finds dependencies in item expressions" do
+      expect(calculator.dependencies('MAP(vals, val, val + step)')).to eq(['vals', 'step'])
+      expect(calculator.dependencies('ALL(people, person, person.age < adult)')).to eq(['people', 'adult'])
+    end
   end
 
   describe 'solve!' do
@@ -257,8 +263,13 @@ describe Dentaku::Calculator do
 
   describe 'solve' do
     it "returns :undefined when variables are unbound" do
-      expressions = {more_apples: "apples + 1"}
-      expect(calculator.solve(expressions)).to eq(more_apples: :undefined)
+      expressions = {more_apples: "apples + 1", compare_apples: "apples > 1"}
+      expect(calculator.solve(expressions)).to eq(more_apples: :undefined, compare_apples: :undefined)
+    end
+
+    it "returns :undefined when variables are nil" do
+      expressions = {more_apples: "apples + 1", compare_apples: "apples > 1"}
+      expect(calculator.store(apples: nil).solve(expressions)).to eq(more_apples: :undefined, compare_apples: :undefined)
     end
 
     it "allows passing in a custom value to an error handler" do
@@ -304,6 +315,20 @@ describe Dentaku::Calculator do
         )
       }.not_to raise_error
     end
+
+    it "integrates with custom functions" do
+      calculator.add_function(:custom, :integer, -> { 1 })
+
+      result = calculator.solve(
+        a: "1",
+        b: "CUSTOM() - a"
+      )
+
+      expect(result).to eq(
+        a: 1,
+        b: 0
+      )
+    end
   end
 
   it 'evaluates a statement with no variables' do
@@ -666,6 +691,31 @@ describe Dentaku::Calculator do
       expect(value).to eq(5)
     end
 
+    it 'handles nested case statements with case-sensitivity' do
+      formula = <<-FORMULA
+      CASE fruit
+      WHEN 'apple'
+        THEN 1 * quantity
+      WHEN 'banana'
+        THEN
+        CASE QUANTITY
+        WHEN 1 THEN 2
+        WHEN 10 THEN
+          CASE type
+          WHEN 'organic' THEN 5
+          END
+        END
+      END
+      FORMULA
+      value = with_case_sensitivity.evaluate(
+        formula,
+        type: 'organic',
+        quantity: 1,
+        QUANTITY: 10,
+        fruit: 'banana')
+      expect(value).to eq(5)
+    end
+
     it 'handles multiple nested case statements' do
       formula = <<-FORMULA
       CASE fruit
@@ -710,6 +760,12 @@ describe Dentaku::Calculator do
         end
       end
     end
+
+    it 'are defined with a properly named class that represents it to support AST marshaling' do
+      expect {
+        Marshal.dump(calculator.ast('SQRT(20)'))
+      }.not_to raise_error
+    end
   end
 
   describe 'disable_cache' do