dentaku 3.4.0 → 3.5.0

data/spec/ast/map_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+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)
+  end
+
+  it 'works with an empty array' 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/max_spec.rb

@@ -17,4 +17,17 @@ describe 'Dentaku::AST::Function::Max' do
     result = Dentaku('MAX(1, x, 1.8)', x: [1.5, 2.3, 1.7])
     expect(result).to eq(2.3)
   end
+
+  it 'returns the largest value if only an Array is passed' do
+    result = Dentaku('MAX(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(2.3)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MAX(x)', x: [])).to eq(nil)
+    end
+  end
 end

data/spec/ast/min_spec.rb

@@ -17,4 +17,17 @@ describe 'Dentaku::AST::Function::Min' do
     result = Dentaku('MIN(1, x, 1.8)', x: [1.5, 0.3, 1.7])
     expect(result).to eq(0.3)
   end
+
+  it 'returns the smallest value if only an Array is passed' do
+    result = Dentaku('MIN(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(1.5)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MIN(x)', x: [])).to eq(nil)
+    end
+  end
 end

data/spec/ast/mul_spec.rb

@@ -35,8 +35,9 @@ describe 'Dentaku::AST::Function::Mul' do
       expect { calculator.evaluate!('MUL()') }.to raise_error(Dentaku::ArgumentError)
     end
 
-    it 'raises an error if an empty array is passed' do
-      expect { calculator.evaluate!('MUL(x)', x: []) }.to raise_error(Dentaku::ArgumentError)
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('MUL(x)', x: [])
+      expect(result).to eq(1)
     end
   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/sum_spec.rb

@@ -35,8 +35,9 @@ describe 'Dentaku::AST::Function::Sum' do
       expect { calculator.evaluate!('SUM()') }.to raise_error(Dentaku::ArgumentError)
     end
 
-    it 'raises an error if an empty array is passed' do
-      expect { calculator.evaluate!('SUM(x)', x: []) }.to raise_error(Dentaku::ArgumentError)
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('SUM(x)', x: [])
+      expect(result).to eq(0)
     end
   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/bulk_expression_solver_spec.rb

@@ -56,6 +56,16 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(solver.solve!).to eq(x: 6, y: 12) # x = 6 by the time y is calculated
     end
 
+    it "does not execute functions unnecessarily" do
+      calls = 0
+      external = ->() { calls += 1 }
+      hash = {test: 'EXTERNAL()'}
+      calculator = Dentaku::Calculator.new
+      calculator.add_function(:external, :numeric, external)
+      calculator.solve(hash)
+      expect(calls).to eq(1)
+    end
+
     it "evaluates expressions in hashes and arrays, and expands the results" do
       calculator.store(
         fruit_quantities: {

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
@@ -502,6 +527,10 @@ describe Dentaku::Calculator do
           {"name" => "Bob",  "age" => 44},
           {"name" => "Jane", "age" => 27}
         ])).to eq(["Bob", "Jane"])
+        expect(calculator.evaluate!('map(users, u, IF(u.age < 30, u, null))', users: [
+          {"name" => "Bob",  "age" => 44},
+          {"name" => "Jane", "age" => 27}
+        ])).to eq([nil, { "name" => "Jane", "age" => 27 }])
       end
     end
 
@@ -662,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
@@ -696,12 +750,22 @@ describe Dentaku::Calculator do
       it method do
         if Math.method(method).arity == 2
           expect(calculator.evaluate("#{method}(x,y)", x: 1, y: '2')).to eq(Math.send(method, 1, 2))
+          expect(calculator.evaluate("#{method}(x,y) + 1", x: 1, y: '2')).to be_within(0.00001).of(Math.send(method, 1, 2) + 1)
           expect { calculator.evaluate!("#{method}(x)", x: 1) }.to raise_error(Dentaku::ParseError)
         else
           expect(calculator.evaluate("#{method}(1)")).to eq(Math.send(method, 1))
+          unless [:atanh, :frexp, :lgamma].include?(method)
+            expect(calculator.evaluate("#{method}(1) + 1")).to be_within(0.00001).of(Math.send(method, 1) + 1)
+          end
         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

data/spec/parser_spec.rb

@@ -71,6 +71,11 @@ describe Dentaku::Parser do
     expect(node.value("x" => 3)).to eq(4)
   end
 
+  it 'evaluates a nested case statement with case-sensitivity' do
+    node = parse('CASE x WHEN 1 THEN CASE Y WHEN "A" THEN 2 WHEN "B" THEN 3 END END', { case_sensitive: true }, { case_sensitive: true })
+    expect(node.value("x" => 1, "y" => "A", "Y" => "B")).to eq(3)
+  end
+
   it 'evaluates arrays' do
     node = parse('{1, 2, 3}')
     expect(node.value).to eq([1, 2, 3])
@@ -89,6 +94,16 @@ describe Dentaku::Parser do
       }.to raise_error(Dentaku::ParseError)
     end
 
+    it 'raises a parse error for too many operands' do
+      expect {
+        parse("IF(1, 0, IF(1, 2, 3, 4))")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CASE a WHEN 1 THEN true ELSE THEN IF(1, 2, 3, 4) END")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
     it 'raises a parse error for bad grouping structure' do
       expect {
         parse(",")
@@ -144,8 +159,8 @@ describe Dentaku::Parser do
 
   private
 
-  def parse(expr)
-    tokens = Dentaku::Tokenizer.new.tokenize(expr)
-    described_class.new(tokens).parse
+  def parse(expr, parser_options = {}, tokenizer_options = {})
+    tokens = Dentaku::Tokenizer.new.tokenize(expr, tokenizer_options)
+    described_class.new(tokens, parser_options).parse
   end
 end

data/spec/print_visitor_spec.rb

@@ -0,0 +1,66 @@
+require 'dentaku/print_visitor'
+require 'dentaku/tokenizer'
+require 'dentaku/parser'
+
+describe Dentaku::PrintVisitor do
+  it 'prints a representation of an AST' do
+    repr = roundtrip('5+4')
+    expect(repr).to eq('5 + 4')
+  end
+
+  it 'quotes string literals' do
+    repr = roundtrip('Concat(\'a\',   "B")')
+    expect(repr).to eq('CONCAT("a", "B")')
+  end
+
+  it 'handles unary operations on literals' do
+    repr = roundtrip('- 4')
+    expect(repr).to eq('-4')
+  end
+
+  it 'handles unary operations on trees' do
+    repr = roundtrip('- (5 + 5)')
+    expect(repr).to eq('-(5 + 5)')
+  end
+
+  it 'handles a complex arithmetic expression' do
+    repr = roundtrip('(((1 + 7) * (8 ^ 2)) / - (3.0 - apples))')
+    expect(repr).to eq('(1 + 7) * 8 ^ 2 / -(3.0 - apples)')
+  end
+
+  it 'handles a complex logical expression' do
+    repr = roundtrip('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
+    expect(repr).to eq('1 < 2 and 3 <= 4 or 5 > 6 and 7 >= 8 or 9 != 10 and true')
+  end
+
+  it 'handles a function call' do
+    repr = roundtrip('IF(a[0] = NULL, "five", \'seven\')')
+    expect(repr).to eq('IF(a[0] = NULL, "five", "seven")')
+  end
+
+  it 'handles a case statement' do
+    repr = roundtrip('case (a % 5) when 0 then a else b end')
+    expect(repr).to eq('CASE a % 5 WHEN 0 THEN a ELSE b END')
+  end
+
+  it 'handles a bitwise operators' do
+    repr = roundtrip('0xCAFE & 0xDECAF | 0xBEEF')
+    expect(repr).to eq('0xCAFE & 0xDECAF | 0xBEEF')
+  end
+
+  it 'handles a datetime literal' do
+    repr = roundtrip('2017-12-24 23:59:59')
+    expect(repr).to eq('2017-12-24 23:59:59')
+  end
+
+  private
+
+  def roundtrip(string)
+    described_class.new(parsed(string)).to_s
+  end
+
+  def parsed(string)
+    tokens = Dentaku::Tokenizer.new.tokenize(string)
+    Dentaku::Parser.new(tokens).parse
+  end
+end

data/spec/tokenizer_spec.rb

@@ -25,6 +25,12 @@ describe Dentaku::Tokenizer do
       expect(tokens.map(&:category)).to eq([:numeric])
       expect(tokens.map(&:value)).to eq([6.02e23])
     end
+
+    tokens = tokenizer.tokenize('6E23')
+    expect(tokens.map(&:value)).to eq([0.6e24])
+
+    tokens = tokenizer.tokenize('6e-23')
+    expect(tokens.map(&:value)).to eq([0.6e-22])
   end
 
   it 'tokenizes addition' do

data/spec/visitor/infix_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require 'dentaku/visitor/infix'
+
+class ArrayProcessor
+  attr_reader :expression
+  include Dentaku::Visitor::Infix
+
+  def initialize
+    @expression = []
+  end
+
+  def process(node)
+    @expression << node.to_s
+  end
+end
+
+RSpec.describe Dentaku::Visitor::Infix do
+  it 'generates array representation of operation' do
+    processor = ArrayProcessor.new
+    processor.visit(ast('5 + 3'))
+    expect(processor.expression).to eq ['5', '+', '3']
+  end
+
+  private
+
+  def ast(expression)
+    tokens = Dentaku::Tokenizer.new.tokenize(expression)
+    Dentaku::Parser.new(tokens).parse
+  end
+end

data/spec/visitor_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'set'
+
+class TestVisitor
+  attr_reader :visited
+
+  def initialize(node)
+    @visited = Set.new
+    node.accept(self)
+  end
+
+  def mark_visited(node)
+    @visited.add(node.class.to_s.split("::").last.to_sym)
+  end
+
+  def visit_operation(node)
+    mark_visited(node)
+
+    node.left.accept(self) if node.left
+    node.right.accept(self) if node.right
+  end
+
+  def visit_function(node)
+    mark_visited(node)
+    node.args.each { |a| a.accept(self) }
+  end
+
+  def visit_array(node)
+    mark_visited(node)
+  end
+
+  def visit_case(node)
+    mark_visited(node)
+    node.switch.accept(self)
+    node.conditions.each { |c| c.accept(self) }
+    node.else && node.else.accept(self)
+  end
+
+  def visit_switch(node)
+    mark_visited(node)
+    node.node.accept(self)
+  end
+
+  def visit_case_conditional(node)
+    mark_visited(node)
+    node.when.accept(self)
+    node.then.accept(self)
+  end
+
+  def visit_when(node)
+    mark_visited(node)
+    node.node.accept(self)
+  end
+
+  def visit_then(node)
+    mark_visited(node)
+    node.node.accept(self)
+  end
+
+  def visit_else(node)
+    mark_visited(node)
+    node.node.accept(self)
+  end
+
+  def visit_negation(node)
+    mark_visited(node)
+    node.node.accept(self)
+  end
+
+  def visit_access(node)
+    mark_visited(node)
+    node.structure.accept(self)
+    node.index.accept(self)
+  end
+
+  def visit_literal(node)
+    mark_visited(node)
+  end
+
+  def visit_identifier(node)
+    mark_visited(node)
+  end
+
+  def visit_nil(node)
+    mark_visited(node)
+  end
+end
+
+describe TestVisitor do
+  def generic_subclasses
+    [
+      :Arithmetic,
+      :Combinator,
+      :Comparator,
+      :Function,
+      :FunctionRegistry,
+      :Grouping,
+      :Literal,
+      :Node,
+      :Operation,
+      :StringFunctions,
+      :RubyMath,
+      :Enum,
+    ]
+  end
+
+  it 'visits all concrete AST node types' do
+    @visited = Set.new
+
+    visit_nodes('(1 + 7) * (8 ^ 2) / - 3.0 - apples')
+    visit_nodes('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
+    visit_nodes('IF(a[0] = NULL, "five", \'seven\')')
+    visit_nodes('case (a % 5) when 0 then a else b end')
+    visit_nodes('0xCAFE & 0xDECAF | 0xBEEF')
+    visit_nodes('2017-12-24 23:59:59')
+    visit_nodes('ALL({1, 2, 3}, "val", val % 2 == 0)')
+    visit_nodes('ANY(vals, val, val > 1)')
+    visit_nodes('COUNT({1, 2, 3})')
+    visit_nodes('PLUCK(users, age)')
+    visit_nodes('XOR(false, false)')
+    visit_nodes('duration(1, day)')
+    visit_nodes('MAP(vals, val, val + 1)')
+    visit_nodes('FILTER(vals, val, val > 1)')
+
+    @expected = Set.new(Dentaku::AST::constants - generic_subclasses)
+    expect(@visited.sort).to eq(@expected.sort)
+  end
+
+  private
+
+  def visit_nodes(string)
+    tokens = Dentaku::Tokenizer.new.tokenize(string)
+    node = Dentaku::Parser.new(tokens).parse
+    visitor = TestVisitor.new(node)
+    @visited += visitor.visited
+  end
+end