dentaku 3.2.0 → 3.5.1

data/spec/calculator_spec.rb

@@ -1,8 +1,8 @@
 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 +39,93 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('t + 1*24*60*60', t: Time.local(2017, 1, 1))).to eq(Time.local(2017, 1, 2))
     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
+    it 'returns nil when formula has error' do
+      expect(calculator.evaluate('1 + + 1')).to be_nil
+    end
+
+    it 'suppresses unbound variable errors' do
+      expect(calculator.evaluate('AND(a,b)')).to be_nil
+      expect(calculator.evaluate('IF(a, 1, 0)')).to be_nil
+      expect(calculator.evaluate('MAX(a,b)')).to be_nil
+      expect(calculator.evaluate('MIN(a,b)')).to be_nil
+      expect(calculator.evaluate('NOT(a)')).to be_nil
+      expect(calculator.evaluate('OR(a,b)')).to be_nil
+      expect(calculator.evaluate('ROUND(a)')).to be_nil
+      expect(calculator.evaluate('ROUNDDOWN(a)')).to be_nil
+      expect(calculator.evaluate('ROUNDUP(a)')).to be_nil
+      expect(calculator.evaluate('SUM(a,b)')).to be_nil
+    end
+
+    it 'suppresses numeric coercion errors' do
+      expect(calculator.evaluate('MAX(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('MIN(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('ROUND(a)', a: nil)).to be_nil
+      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
+      expect(calculator.evaluate('AND(a,b)', a: nil, b: nil)).to be_falsy
+      expect(calculator.evaluate('IF(a,1,0)', a: nil, b: nil)).to eq(0)
+      expect(calculator.evaluate('NOT(a)', a: nil, b: nil)).to be_truthy
+      expect(calculator.evaluate('OR(a,b)', a: nil, b: nil)).to be_falsy
+    end
+
+    it 'supports lazy evaluation of variables' do
+      expect(calculator.evaluate('x + 1', x: -> { 1 })).to eq(2)
+      expect { calculator.evaluate('2', x: -> { raise 'boom' }) }.not_to raise_error
+    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)
+      expect { calculator.evaluate!('(1 > 5) OR LEFT("abc", 1)') }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises unbound variable errors' do
+      expect { calculator.evaluate!('AND(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('IF(a, 1, 0)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('MAX(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('MIN(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('NOT(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('OR(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('ROUND(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('ROUNDDOWN(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('ROUNDUP(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('SUM(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+    end
+
+    it 'raises numeric coersion errors' do
+      expect { calculator.evaluate!('MAX(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('MIN(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('ROUND(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
+      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
+      expect { calculator.evaluate!('IF(a,b)', a: 1, b: 1) }.to raise_error(Dentaku::ParseError)
+    end
   end
 
   it 'supports unicode characters in identifiers' do
@@ -57,35 +144,37 @@ describe Dentaku::Calculator do
 
     it 'can store the value `false`' do
       calculator.store('i_am_false', false)
-      expect(calculator.evaluate!('i_am_false')).to eq false
+      expect(calculator.evaluate!('i_am_false')).to eq(false)
     end
 
     it 'can store multiple values' do
       calculator.store(first: 1, second: 2)
-      expect(calculator.evaluate!('first')).to eq 1
-      expect(calculator.evaluate!('second')).to eq 2
+      expect(calculator.evaluate!('first')).to eq(1)
+      expect(calculator.evaluate!('second')).to eq(2)
     end
 
     it 'stores formulas' do
       calculator.store_formula('area', 'length * width')
-      expect(calculator.evaluate!('area', length: 5, width: 5)).to eq 25
+      expect(calculator.evaluate!('area', length: 5, width: 5)).to eq(25)
     end
 
     it 'stores nested hashes' do
       calculator.store(a: {basket: {of: 'apples'}}, b: 2)
-      expect(calculator.evaluate!('a.basket.of')).to eq 'apples'
-      expect(calculator.evaluate!('b')).to eq 2
+      expect(calculator.evaluate!('a.basket.of')).to eq('apples')
+      expect(calculator.evaluate!('a.basket')).to eq(of: 'apples')
+      expect(calculator.evaluate!('b')).to eq(2)
     end
 
     it 'stores arrays' do
       calculator.store(a: [1, 2, 3])
-      expect(calculator.evaluate!('a[0]')).to eq 1
-      expect(calculator.evaluate!('a[x]', x: 1)).to eq 2
-      expect(calculator.evaluate!('a[x+1]', x: 1)).to eq 3
+      expect(calculator.evaluate!('a[0]')).to eq(1)
+      expect(calculator.evaluate!('a[x]', x: 1)).to eq(2)
+      expect(calculator.evaluate!('a[x+1]', x: 1)).to eq(3)
     end
 
-    it 'evalutates arrays' do
+    it 'evaluates arrays' do
       expect(calculator.evaluate([1, 2, 3])).to eq([1, 2, 3])
+      expect(calculator.evaluate!('{1,2,3}')).to eq([1, 2, 3])
     end
   end
 
@@ -111,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
@@ -122,6 +216,15 @@ describe Dentaku::Calculator do
       )).to eq(pear: 1, weekly_apple_budget: 21, weekly_fruit_budget: 25)
     end
 
+    it "prefers variables over values in memory if they have no dependencies" do
+      expect(with_memory.solve!(
+        weekly_fruit_budget: "weekly_apple_budget + pear * 4",
+        weekly_apple_budget: "apples * 7",
+        pear:                "1",
+        apples:              "4"
+      )).to eq(apples: 4, pear: 1, weekly_apple_budget: 28, weekly_fruit_budget: 32)
+    end
+
     it "preserves hash keys" do
       expect(calculator.solve!(
         'meaning_of_life' => 'age + kids',
@@ -138,7 +241,7 @@ describe Dentaku::Calculator do
 
     it 'is case-insensitive' do
       result = with_memory.solve!(total_fruit: "Apples + pears", pears: 10)
-      expect(result[:total_fruit]).to eq 13
+      expect(result[:total_fruit]).to eq(13)
     end
 
     it "lets you know if a variable is unbound" do
@@ -158,14 +261,28 @@ describe Dentaku::Calculator do
         width:  "length * 2",
       )
 
-      expect(result[:weight]).to eq 130.368
+      expect(result[:weight]).to eq(130.368)
+    end
+
+    it 'raises an exception if there are cyclic dependencies' do
+      expect {
+        calculator.solve!(
+          make_money: "have_money",
+          have_money: "make_money"
+        )
+      }.to raise_error(TSort::Cyclic)
     end
   end
 
   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
@@ -198,6 +315,33 @@ describe Dentaku::Calculator do
         d:           0,
       )
     end
+
+    it 'returns undefined if there are cyclic dependencies' do
+      expect {
+        result = calculator.solve(
+          make_money: "have_money",
+          have_money: "make_money"
+        )
+        expect(result).to eq(
+          make_money: :undefined,
+          have_money: :undefined
+        )
+      }.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
@@ -217,14 +361,18 @@ describe Dentaku::Calculator do
     unbound = 'foo * 1.5'
     expect { calculator.evaluate!(unbound) }.to raise_error(Dentaku::UnboundVariableError)
     expect { calculator.evaluate!(unbound) }.to raise_error do |error|
-      expect(error.unbound_variables).to eq ['foo']
+      expect(error.unbound_variables).to eq(['foo'])
     end
     expect { calculator.evaluate!('a + b') }.to raise_error do |error|
-      expect(error.unbound_variables).to eq ['a', 'b']
+      expect(error.unbound_variables).to eq(['a', 'b'])
     end
     expect(calculator.evaluate(unbound)).to be_nil
-    expect(calculator.evaluate(unbound) { :bar }).to eq :bar
-    expect(calculator.evaluate(unbound) { |e| e }).to eq unbound
+  end
+
+  it 'accepts a block for custom handling of unbound variables' do
+    unbound = 'foo * 1.5'
+    expect(calculator.evaluate(unbound) { :bar }).to eq(:bar)
+    expect(calculator.evaluate(unbound) { |e| e }).to eq(unbound)
   end
 
   it 'fails to evaluate incomplete statements' do
@@ -278,20 +426,35 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('some_boolean OR 7 < 5', some_boolean: false)).to be_falsey
   end
 
-  it 'compares Time variables' do
+  it 'compares time variables' do
     expect(calculator.evaluate('t1 < t2', t1: Time.local(2017, 1, 1).to_datetime, t2: Time.local(2017, 1, 2).to_datetime)).to be_truthy
     expect(calculator.evaluate('t1 < t2', t1: Time.local(2017, 1, 2).to_datetime, t2: Time.local(2017, 1, 1).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > t2', t1: Time.local(2017, 1, 1).to_datetime, t2: Time.local(2017, 1, 2).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > t2', t1: Time.local(2017, 1, 2).to_datetime, t2: Time.local(2017, 1, 1).to_datetime)).to be_truthy
   end
 
-  it 'compares Time literals with Time variables' do
+  it 'compares time literals with time variables' do
     expect(calculator.evaluate('t1 < 2017-01-02', t1: Time.local(2017, 1, 1).to_datetime)).to be_truthy
     expect(calculator.evaluate('t1 < 2017-01-02', t1: Time.local(2017, 1, 3).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > 2017-01-02', t1: Time.local(2017, 1, 1).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > 2017-01-02', t1: Time.local(2017, 1, 3).to_datetime)).to be_truthy
   end
 
+  it 'supports date arithmetic' do
+    expect(calculator.evaluate!('2020-01-01 + 30').to_date).to eq(Time.local(2020, 1, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 - 1').to_date).to eq(Time.local(2019, 12, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 - 2019-12-31')).to eq(1)
+    expect(calculator.evaluate!('2020-01-01 + duration(1, day)').to_date).to eq(Time.local(2020, 1, 2).to_date)
+    expect(calculator.evaluate!('2020-01-01 - duration(1, day)').to_date).to eq(Time.local(2019, 12, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(30, days)').to_date).to eq(Time.local(2020, 1, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(1, month)').to_date).to eq(Time.local(2020, 2, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 - duration(1, month)').to_date).to eq(Time.local(2019, 12, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(30, months)').to_date).to eq(Time.local(2022, 7, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(1, year)').to_date).to eq(Time.local(2021, 1, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 - duration(1, year)').to_date).to eq(Time.local(2019, 1, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(30, years)').to_date).to eq(Time.local(2050, 1, 1).to_date)
+  end
+
   describe 'functions' do
     it 'include IF' do
       expect(calculator.evaluate('if(foo < 8, 10, 20)', foo: 2)).to eq(10)
@@ -303,7 +466,7 @@ describe Dentaku::Calculator do
     it 'include ROUND' do
       expect(calculator.evaluate('round(8.2)')).to eq(8)
       expect(calculator.evaluate('round(8.8)')).to eq(9)
-      expect(calculator.evaluate('round(8.75, 1)')).to eq(BigDecimal.new('8.8'))
+      expect(calculator.evaluate('round(8.75, 1)')).to eq(BigDecimal('8.8'))
 
       expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
@@ -319,10 +482,92 @@ describe Dentaku::Calculator do
     it 'evaluates functions with negative numbers' do
       expect(calculator.evaluate('if (-1 < 5, -1, 5)')).to eq(-1)
       expect(calculator.evaluate('if (-1 = -1, -1, 5)')).to eq(-1)
-      expect(calculator.evaluate('round(-1.23, 1)')).to eq(BigDecimal.new('-1.2'))
+      expect(calculator.evaluate('round(-1.23, 1)')).to eq(BigDecimal('-1.2'))
       expect(calculator.evaluate('NOT(some_boolean) AND -1 > 3', some_boolean: true)).to be_falsey
     end
 
+    describe "any" do
+      it "enumerates values and returns true if any evaluation is truthy" do
+        expect(calculator.evaluate!('any(xs, x, x > 3)', xs: [1, 2, 3, 4])).to be_truthy
+        expect(calculator.evaluate!('any(xs, x, x > 3)', xs: 3)).to be_falsy
+        expect(calculator.evaluate!('any({1,2,3,4}, x, x > 3)')).to be_truthy
+        expect(calculator.evaluate!('any({1,2,3,4}, x, x > 10)')).to be_falsy
+        expect(calculator.evaluate!('any(users, u, u.age > 33)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to be_truthy
+        expect(calculator.evaluate!('any(users, u, u.age < 18)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to be_falsy
+      end
+    end
+
+    describe "all" do
+      it "enumerates values and returns true if all evaluations are truthy" do
+        expect(calculator.evaluate!('all(xs, x, x > 3)', xs: [1, 2, 3, 4])).to be_falsy
+        expect(calculator.evaluate!('any(xs, x, x > 2)', xs: 3)).to be_truthy
+        expect(calculator.evaluate!('all({1,2,3,4}, x, x > 0)')).to be_truthy
+        expect(calculator.evaluate!('all({1,2,3,4}, x, x > 10)')).to be_falsy
+        expect(calculator.evaluate!('all(users, u, u.age > 33)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to be_falsy
+        expect(calculator.evaluate!('all(users, u, u.age < 50)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to be_truthy
+      end
+    end
+
+    describe "map" do
+      it "maps values" do
+        expect(calculator.evaluate!('map(xs, x, x * 2)', xs: [1, 2, 3, 4])).to eq([2, 4, 6, 8])
+        expect(calculator.evaluate!('map({1,2,3,4}, x, x * 2)')).to eq([2, 4, 6, 8])
+        expect(calculator.evaluate!('map(users, u, u.age)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to eq([44, 27])
+        expect(calculator.evaluate!('map(users, u, u.age)', users: [
+          {"name" => "Bob",  "age" => 44},
+          {"name" => "Jane", "age" => 27}
+        ])).to eq([44, 27])
+        expect(calculator.evaluate!('map(users, u, u.name)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to eq(["Bob", "Jane"])
+        expect(calculator.evaluate!('map(users, u, u.name)', users: [
+          {"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
+
+    describe "pluck" do
+      it "plucks values from array of hashes" do
+        expect(calculator.evaluate!('pluck(users, age)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to eq([44, 27])
+        expect(calculator.evaluate!('pluck(users, age)', users: [
+          {"name" => "Bob",  "age" => 44},
+          {"name" => "Jane", "age" => 27}
+        ])).to eq([44, 27])
+        expect(calculator.evaluate!('pluck(users, name)', users: [
+          {name: "Bob",  age: 44},
+          {name: "Jane", age: 27}
+        ])).to eq(["Bob", "Jane"])
+        expect(calculator.evaluate!('pluck(users, name)', users: [
+          {"name" => "Bob",  "age" => 44},
+          {"name" => "Jane", "age" => 27}
+        ])).to eq(["Bob", "Jane"])
+      end
+    end
+
     it 'evaluates functions with stored variables' do
       calculator.store("multi_color" => true, "number_of_sheets" => 5000, "sheets_per_minute_black" => 2000, "sheets_per_minute_color" => 1000)
       result = calculator.evaluate('number_of_sheets / if(multi_color, sheets_per_minute_color, sheets_per_minute_black)')
@@ -419,14 +664,14 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate(formula, number: 6)).to eq(2)
     end
 
-    it 'throws an exception when no match and there is no default value' do
+    it 'raises an exception when no match and there is no default value' do
       formula = <<-FORMULA
       CASE number
       WHEN 42
         THEN 1
       END
       FORMULA
-      expect { calculator.evaluate(formula, number: 2) }
+      expect { calculator.evaluate!(formula, number: 2) }
         .to raise_error("No block matched the switch value '2'")
     end
 
@@ -459,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
@@ -492,12 +762,23 @@ describe Dentaku::Calculator do
     Math.methods(false).each do |method|
       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)", 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)
+          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
@@ -528,7 +809,7 @@ describe Dentaku::Calculator do
     end
 
     it 'clears all items from cache' do
-      expect(calculator.ast_cache.length).to eq 3
+      expect(calculator.ast_cache.length).to eq(3)
       calculator.clear_cache
       expect(calculator.ast_cache.keys).to be_empty
     end
@@ -551,21 +832,31 @@ describe Dentaku::Calculator do
     it 'concatenates strings' do
       expect(
         calculator.evaluate('CONCAT(s1, s2, s3)', 's1' => 'ab', 's2' => 'cd', 's3' => 'ef')
-      ).to eq 'abcdef'
+      ).to eq('abcdef')
+    end
+
+    it 'manipulates string arguments' do
+      expect(calculator.evaluate("left('ABCD', 2)")).to eq('AB')
+      expect(calculator.evaluate("right('ABCD', 2)")).to eq('CD')
+      expect(calculator.evaluate("mid('ABCD', 2, 2)")).to eq('BC')
+      expect(calculator.evaluate("len('ABCD')")).to eq(4)
+      expect(calculator.evaluate("find('BC', 'ABCD')")).to eq(2)
+      expect(calculator.evaluate("substitute('ABCD', 'BC', 'XY')")).to eq('AXYD')
+      expect(calculator.evaluate("contains('BC', 'ABCD')")).to be_truthy
     end
   end
 
   describe 'zero-arity functions' do
     it 'can be used in formulas' do
       calculator.add_function(:two, :numeric, -> { 2 })
-      expect(calculator.evaluate("max(two(), 1)")).to eq 2
-      expect(calculator.evaluate("max(1, two())")).to eq 2
+      expect(calculator.evaluate("max(two(), 1)")).to eq(2)
+      expect(calculator.evaluate("max(1, two())")).to eq(2)
     end
   end
 
   describe 'aliases' do
     it 'accepts aliases as instance option' do
-      expect(with_aliases.evaluate('rrround(5.1)')).to eq 5
+      expect(with_aliases.evaluate('rrround(5.1)')).to eq(5)
     end
   end
 
@@ -584,4 +875,22 @@ describe Dentaku::Calculator do
       end.to raise_error(Dentaku::UnboundVariableError)
     end
   end
+
+  describe 'identifier cache' do
+    it 'reduces call count by caching results of resolved identifiers' do
+      called = 0
+      calculator.store_formula("A1", "B1+B1+B1")
+      calculator.store_formula("B1", "C1+C1+C1+C1")
+      calculator.store_formula("C1", "D1")
+      calculator.store("D1", proc { called += 1; 1 })
+
+      expect {
+        Dentaku.enable_identifier_cache!
+      }.to change {
+        called = 0
+        calculator.evaluate("A1")
+        called
+      }.from(12).to(1)
+    end
+  end
 end

data/spec/dentaku_spec.rb

@@ -22,18 +22,31 @@ describe Dentaku do
 
   it 'raises a parse error for bad logic expressions' do
     expect {
-      Dentaku('true AND')
+      Dentaku!('true AND')
     }.to raise_error(Dentaku::ParseError)
   end
 
   it 'evaluates with class-level shortcut functions' do
-    expect(Dentaku.evaluate('2+2')).to eq(4)
-    expect(Dentaku.evaluate!('2+2')).to eq(4)
-    expect { Dentaku.evaluate!('a+1') }.to raise_error(Dentaku::UnboundVariableError)
+    expect(described_class.evaluate('2+2')).to eq(4)
+    expect(described_class.evaluate!('2+2')).to eq(4)
+    expect { described_class.evaluate!('a+1') }.to raise_error(Dentaku::UnboundVariableError)
+  end
+
+  it 'accepts a block for custom handling of unbound variables' do
+    unbound = 'apples * 1.5'
+    expect(described_class.evaluate(unbound) { :bar }).to eq(:bar)
+    expect(described_class.evaluate(unbound) { |e| e }).to eq(unbound)
   end
 
   it 'evaluates with class-level aliases' do
-    Dentaku.aliases = { roundup: ['roundupup'] }
-    expect(Dentaku.evaluate('roundupup(6.1)')).to eq(7)
+    described_class.aliases = { roundup: ['roundupup'] }
+    expect(described_class.evaluate('roundupup(6.1)')).to eq(7)
+  end
+
+  it 'sets caching opt-in flags' do
+    expect {
+      described_class.enable_caching!
+    }.to change { described_class.cache_ast? }.from(false).to(true)
+    .and change { described_class.cache_dependency_order? }.from(false).to(true)
   end
 end

data/spec/external_function_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'dentaku'
 require 'dentaku/calculator'
 
 describe Dentaku::Calculator do
@@ -14,6 +15,7 @@ describe Dentaku::Calculator do
           [:pow,      :numeric, ->(mantissa, exponent) { mantissa**exponent }],
           [:biggest,  :numeric, ->(*args) { args.max }],
           [:smallest, :numeric, ->(*args) { args.min }],
+          [:optional, :numeric, ->(x, y, z = 0) { x + y + z }],
         ]
 
         c.add_functions(fns)
@@ -39,6 +41,13 @@ describe Dentaku::Calculator do
         expect(with_external_funcs.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
       end
 
+      it 'includes OPTIONAL' do
+        expect(with_external_funcs.evaluate('OPTIONAL(1,2)')).to eq(3)
+        expect(with_external_funcs.evaluate('OPTIONAL(1,2,3)')).to eq(6)
+        expect { with_external_funcs.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
+        expect { with_external_funcs.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
+      end
+
       it 'supports array parameters' do
         calculator = described_class.new
         calculator.add_function(
@@ -59,6 +68,19 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate("hey!()")).to eq("hey!")
     end
 
+    it 'defines for a given function a properly named class that represents it to support AST marshaling' do
+      calculator = described_class.new
+      expect {
+        calculator.add_function(:ho, :string, -> {})
+      }.to change {
+        Dentaku::AST::Function.const_defined?("Ho")
+      }.from(false).to(true)
+
+      expect {
+        Marshal.dump(calculator.ast('MAX(1, 2)'))
+      }.not_to raise_error
+    end
+
     it 'does not store functions across all calculators' do
       calculator1 = Dentaku::Calculator.new
       calculator1.add_function(:my_function, :numeric, ->(x) { 2 * x + 1 })
@@ -66,15 +88,19 @@ describe Dentaku::Calculator do
       calculator2 = Dentaku::Calculator.new
       calculator2.add_function(:my_function, :numeric, ->(x) { 4 * x + 3 })
 
-      expect(calculator1.evaluate("1 + my_function(2)")). to eq (1 + 2 * 2 + 1)
-      expect(calculator2.evaluate("1 + my_function(2)")). to eq (1 + 4 * 2 + 3)
+      expect(calculator1.evaluate!("1 + my_function(2)")). to eq(1 + 2 * 2 + 1)
+      expect(calculator2.evaluate!("1 + my_function(2)")). to eq(1 + 4 * 2 + 3)
 
-      expect { Dentaku::Calculator.new.evaluate("1 + my_function(2)") }.to raise_error(Dentaku::ParseError)
+      expect {
+        Dentaku::Calculator.new.evaluate!("1 + my_function(2)")
+      }.to raise_error(Dentaku::ParseError)
     end
 
-    it 'self.add_function adds to default/global function registry' do
-      Dentaku::Calculator.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
-      expect(Dentaku::Calculator.new.evaluate("global_function(3) + 5")).to eq (10 + 3**2 + 5)
+    describe 'Dentaku::Calculator.add_function' do
+      it 'adds to default/global function registry' do
+        Dentaku::Calculator.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
+        expect(Dentaku::Calculator.new.evaluate("global_function(3) + 5")).to eq(10 + 3**2 + 5)
+      end
     end
   end
 end