dentaku 3.3.0 → 3.4.0

data/spec/ast/string_functions_spec.rb

@@ -26,6 +26,10 @@ describe Dentaku::AST::StringFunctions::Left do
     expect(subject.value('string' => 'abcdefg', 'length' => 40)).to eq 'abcdefg'
   end
 
+  it 'accepts strings as length if they can be parsed to a number' do
+    expect(subject.value('string' => 'ABCDEFG', 'length' => '4')).to eq 'ABCD'
+  end
+
   it 'has the proper type' do
     expect(subject.type).to eq(:string)
   end
@@ -35,6 +39,12 @@ describe Dentaku::AST::StringFunctions::Left do
       subject.value('string' => 'abcdefg', 'length' => -2)
     }.to raise_error(Dentaku::ArgumentError, /LEFT\(\) requires length to be positive/)
   end
+
+  it 'raises an error when given a junk length' do
+    expect {
+      subject.value('string' => 'abcdefg', 'length' => 'junk')
+    }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Right do
@@ -53,9 +63,19 @@ describe Dentaku::AST::StringFunctions::Right do
     expect(subject.value).to eq 'abcdefg'
   end
 
+  it 'accepts strings as length if they can be parsed to a number' do
+    subject = described_class.new(literal('ABCDEFG'), literal('4'))
+    expect(subject.value).to eq 'DEFG'
+  end
+
   it 'has the proper type' do
     expect(subject.type).to eq(:string)
   end
+
+  it 'raises an error when given a junk length' do
+    subject = described_class.new(literal('abcdefg'), literal('junk'))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Mid do
@@ -79,9 +99,24 @@ describe Dentaku::AST::StringFunctions::Mid do
     expect(subject.value).to eq 'defg'
   end
 
+  it 'accepts strings as offset and length if they can be parsed to a number' do
+    subject = described_class.new(literal('ABCDEFG'), literal('4'), literal('2'))
+    expect(subject.value).to eq 'DE'
+  end
+
   it 'has the proper type' do
     expect(subject.type).to eq(:string)
   end
+
+  it 'raises an error when given a junk offset' do
+    subject = described_class.new(literal('abcdefg'), literal('junk offset'), literal(2))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk offset' is not coercible to numeric")
+  end
+
+  it 'raises an error when given a junk length' do
+    subject = described_class.new(literal('abcdefg'), literal(4), literal('junk'))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Len do

data/spec/ast/sum_spec.rb

@@ -5,34 +5,38 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Sum' do
   it 'returns the sum of an array of Numeric values' do
     result = Dentaku('SUM(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 5.1
+    expect(result).to eq(5.1)
   end
 
   it 'returns the sum of a single entry array of a Numeric value' do
     result = Dentaku('SUM(x)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'returns the sum even if a String is passed' do
     result = Dentaku('SUM(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 5.1
+    expect(result).to eq(5.1)
   end
 
   it 'returns the sum even if an array is passed' do
     result = Dentaku('SUM(1, x, 2.3)', x: [4, 5])
-    expect(result).to eq 12.3
+    expect(result).to eq(12.3)
   end
 
   it 'returns the sum of nested sums' do
     result = Dentaku('SUM(1, x, SUM(4, 5))', x: '2.3')
-    expect(result).to eq 12.3
+    expect(result).to eq(12.3)
   end
 
   context 'checking errors' do
     let(:calculator) { Dentaku::Calculator.new }
 
     it 'raises an error if no arguments are passed' do
-      expect { calculator.evaluate!('SUM()') }.to raise_error(ArgumentError)
+      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)
     end
   end
 end

data/spec/ast/switch_spec.rb

@@ -5,26 +5,26 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Switch' do
   it 'returns the match if present in argumtents' do
     result = Dentaku('SWITCH(1, 1, "one", 2, "two")')
-    expect(result).to eq 'one'
+    expect(result).to eq('one')
   end
 
   it 'returns nil if no match was found' do
     result = Dentaku('SWITCH(3, 1, "one", 2, "two")')
-    expect(result).to eq nil
+    expect(result).to eq(nil)
   end
 
   it 'returns the default value if present and no match was found' do
     result = Dentaku('SWITCH(3, 1, "one", 2, "two", "no match")')
-    expect(result).to eq 'no match'
+    expect(result).to eq('no match')
   end
 
   it 'returns the first match if multiple matches exist' do
     result = Dentaku('SWITCH(1, 1, "one", 2, "two", 1, "three")')
-    expect(result).to eq 'one'
+    expect(result).to eq('one')
   end
 
   it 'does not return a match where a value matches the search value' do
     result = Dentaku('SWITCH(1, "one", 1, 2, "two", 3)')
-    expect(result).to eq 3
+    expect(result).to eq(3)
   end
 end

data/spec/bulk_expression_solver_spec.rb

@@ -26,6 +26,13 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       }.to raise_error(Dentaku::UnboundVariableError)
     end
 
+    it "properly handles access on an unbound variable" do
+      expressions = {more_apples: "apples[0]"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::UnboundVariableError)
+    end
+
     it "lets you know if the result is a div/0 error" do
       expressions = {more_apples: "1/0"}
       expect {
@@ -39,6 +46,16 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(solver.solve!).to eq("the value of x, incremented" => 4)
     end
 
+    it "allows self-referential formulas" do
+      expressions = { x: "x + 1" }
+      solver = described_class.new(expressions, calculator.store(x: 1))
+      expect(solver.solve!).to eq(x: 2)
+
+      expressions = { x: "y + 3", y: "x * 2" }
+      solver = described_class.new(expressions, calculator.store(x: 5, y: 3))
+      expect(solver.solve!).to eq(x: 6, y: 12) # x = 6 by the time y is calculated
+    end
+
     it "evaluates expressions in hashes and arrays, and expands the results" do
       calculator.store(
         fruit_quantities: {
@@ -137,7 +154,7 @@ RSpec.describe Dentaku::BulkExpressionSolver do
         f: "e[0] + 1"
       }
       results = described_class.new(expressions, calculator).solve
-      expect(results[:f]).to eq 10
+      expect(results[:f]).to eq(10)
     end
 
     it 'uses stored values for expressions when they are known' do

data/spec/calculator_spec.rb

@@ -74,6 +74,11 @@ describe Dentaku::Calculator do
       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 'evaluate!' do
@@ -103,6 +108,10 @@ describe Dentaku::Calculator do
       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)
     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
@@ -121,31 +130,32 @@ 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 'evaluates arrays' do
@@ -187,6 +197,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',
@@ -203,7 +222,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
@@ -223,7 +242,7 @@ 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
@@ -304,14 +323,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
@@ -365,20 +388,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)
@@ -390,7 +428,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
@@ -406,10 +444,88 @@ 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"])
+      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)')
@@ -506,14 +622,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
 
@@ -579,9 +695,10 @@ 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)", 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))
         end
       end
     end
@@ -615,7 +732,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
@@ -638,21 +755,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
 
@@ -671,4 +798,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