dentaku 3.4.2 → 3.5.1

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

@@ -6,7 +6,7 @@ describe 'Dentaku::AST::Or' do
   let(:calculator) { Dentaku::Calculator.new }
 
   it 'returns false if all of the arguments are false' do
-    result = Dentaku('OR(1 = "1", 0 = 1)')
+    result = Dentaku('OR(1 = "2", 0 = 1)')
     expect(result).to eq(false)
   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/bulk_expression_solver_spec.rb

@@ -143,6 +143,15 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(exception.recipient_variable).to eq('more_apples')
     end
 
+    it 'stores the recipient variable on the exception when there is an ArgumentError' do
+      expressions = {apples: "NULL", more_apples: "1 + apples"}
+      exception = nil
+      described_class.new(expressions, calculator).solve do |ex|
+        exception = ex
+      end
+      expect(exception.recipient_variable).to eq('more_apples')
+    end
+
     it 'safely handles argument errors' do
       expressions = {i: "a / 5 + d", a: "m * 12", d: "a + b"}
       result = described_class.new(expressions, calculator.store(m: 3)).solve

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) }
@@ -39,6 +40,8 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate("2 | 3 * 9")).to eq (27)
     expect(calculator.evaluate("2 & 3 * 9")).to eq (2)
     expect(calculator.evaluate("5%")).to eq (0.05)
+    expect(calculator.evaluate('1 << 3')).to eq (8)
+    expect(calculator.evaluate('0xFF >> 6')).to eq (3)
   end
 
   describe 'evaluate' do
@@ -66,6 +69,7 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('ROUNDDOWN(a)', a: nil)).to be_nil
       expect(calculator.evaluate('ROUNDUP(a)', a: nil)).to be_nil
       expect(calculator.evaluate('SUM(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('1.0 & "bar"')).to be_nil
     end
 
     it 'treats explicit nil as logical false' do
@@ -81,6 +85,13 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'ast' do
+    it 'raises parsing errors' do
+      expect { calculator.ast('()') }.to raise_error(Dentaku::ParseError)
+      expect { calculator.ast('(}') }.to raise_error(Dentaku::TokenizerError)
+    end
+  end
+
   describe 'evaluate!' do
     it 'raises exception when formula has error' do
       expect { calculator.evaluate!('1 + + 1') }.to raise_error(Dentaku::ParseError)
@@ -107,6 +118,9 @@ describe Dentaku::Calculator do
       expect { calculator.evaluate!('ROUNDDOWN(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('ROUNDUP(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('SUM(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('"foo" & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('1.0 & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('1 & "bar"') }.to raise_error(Dentaku::ArgumentError)
     end
 
     it 'raises argument error if a function is called with incorrect arity' do
@@ -186,6 +200,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 +276,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 +328,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 +704,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 +773,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

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
@@ -83,6 +89,18 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq([2, :bitand, 3])
   end
 
+  it 'tokenizes bitwise SHIFT LEFT' do
+    tokens = tokenizer.tokenize('2 << 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftleft, 3])
+  end
+
+  it 'tokenizes bitwise SHIFT RIGHT' do
+    tokens = tokenizer.tokenize('2 >> 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftright, 3])
+  end
+
   it 'ignores whitespace' do
     tokens = tokenizer.tokenize('1     / 1     ')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])

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,138 @@
+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,
+      :Bitwise,
+      :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 << 3) | (0xBEEF >> 5)')
+    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