dentaku 3.3.4 → 3.4.1

data/spec/ast/sum_spec.rb

@@ -34,5 +34,9 @@ describe 'Dentaku::AST::Function::Sum' do
     it 'raises an error if no arguments are passed' 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)
+    end
   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,26 @@ 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 "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

@@ -147,6 +147,7 @@ describe Dentaku::Calculator do
     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!('a.basket')).to eq(of: 'apples')
       expect(calculator.evaluate!('b')).to eq(2)
     end
 
@@ -196,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',
@@ -319,6 +329,10 @@ describe Dentaku::Calculator do
       expect(error.unbound_variables).to eq(['a', 'b'])
     end
     expect(calculator.evaluate(unbound)).to be_nil
+  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
@@ -391,6 +405,7 @@ describe Dentaku::Calculator do
   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)
@@ -433,6 +448,84 @@ describe Dentaku::Calculator do
       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)')
@@ -603,6 +696,7 @@ 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)", x: 1) }.to raise_error(Dentaku::ParseError)
         else
           expect(calculator.evaluate("#{method}(1)")).to eq(Math.send(method, 1))
         end
@@ -704,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

data/spec/dentaku_spec.rb

@@ -27,20 +27,26 @@ describe Dentaku do
   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 {
-      Dentaku.enable_caching!
-    }.to change { Dentaku.cache_ast? }.from(false).to(true)
-    .and change { Dentaku.cache_dependency_order? }.from(false).to(true)
+      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/parser_spec.rb

@@ -71,6 +71,11 @@ describe Dentaku::Parser do
     expect(node.value("x" => 3)).to eq(4)
   end
 
+  it 'evaluates arrays' do
+    node = parse('{1, 2, 3}')
+    expect(node.value).to eq([1, 2, 3])
+  end
+
   context 'invalid expression' do
     it 'raises a parse error for bad math' do
       expect {
@@ -97,6 +102,14 @@ describe Dentaku::Parser do
       expect {
         parse("5 + 5, x")
       }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("{1, 2, }")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CONCAT('1', '2', )")
+      }.to raise_error(Dentaku::ParseError)
     end
 
     it 'raises parse errors for malformed case statements' do

data/spec/tokenizer_spec.rb

@@ -231,15 +231,15 @@ describe Dentaku::Tokenizer do
     ])
   end
 
-  describe 'functions' do
-    it 'include IF' do
+  describe 'tokenizing function calls' do
+    it 'handles IF' do
       tokens = tokenizer.tokenize('if(x < 10, y, z)')
       expect(tokens.length).to eq(10)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :identifier, :comparator, :numeric, :grouping, :identifier, :grouping, :identifier, :grouping])
       expect(tokens.map(&:value)).to eq([:if, :open, 'x', :lt, 10, :comma, 'y', :comma, 'z', :close])
     end
 
-    it 'include ROUND/UP/DOWN' do
+    it 'handles ROUND/UP/DOWN' do
       tokens = tokenizer.tokenize('round(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
@@ -261,13 +261,32 @@ describe Dentaku::Tokenizer do
       expect(tokens.map(&:value)).to eq([:rounddown, :open, BigDecimal('8.2'), :close])
     end
 
-    it 'include NOT' do
+    it 'handles NOT' do
       tokens = tokenizer.tokenize('not(8 < 5)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
       expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
     end
 
+    it 'handles ANY/ALL' do
+      %i( any all ).each do |fn|
+        tokens = tokenizer.tokenize("#{fn}(users, u, u.age > 18)")
+        expect(tokens.length).to eq(10)
+        expect(tokens.map { |t| [t.category, t.value] }).to eq([
+          [:function,   fn     ], # function call (any/all)
+          [:grouping,   :open  ], # (
+          [:identifier, "users"], # users
+          [:grouping,   :comma ], # ,
+          [:identifier, "u"    ], # u
+          [:grouping,   :comma ], # ,
+          [:identifier, "u.age"], # u.age
+          [:comparator, :gt    ], # >
+          [:numeric,    18     ], # 18
+          [:grouping,   :close ]  # )
+        ])
+      end
+    end
+
     it 'handles whitespace after function name' do
       tokens = tokenizer.tokenize('not (8 < 5)')
       expect(tokens.length).to eq(6)
@@ -275,7 +294,7 @@ describe Dentaku::Tokenizer do
       expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
     end
 
-    it 'can end with a bang' do
+    it 'handles when function ends with a bang' do
       tokens = tokenizer.tokenize('exp!(5 * 3)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :operator, :numeric, :grouping])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.3.4
+  version: 3.4.1
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-21 00:00:00.000000000 Z
+date: 2020-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -156,16 +156,20 @@ files:
 - lib/dentaku/ast/datetime.rb
 - lib/dentaku/ast/function.rb
 - lib/dentaku/ast/function_registry.rb
+- lib/dentaku/ast/functions/all.rb
 - lib/dentaku/ast/functions/and.rb
+- lib/dentaku/ast/functions/any.rb
 - lib/dentaku/ast/functions/avg.rb
 - lib/dentaku/ast/functions/count.rb
 - lib/dentaku/ast/functions/duration.rb
 - lib/dentaku/ast/functions/if.rb
+- lib/dentaku/ast/functions/map.rb
 - lib/dentaku/ast/functions/max.rb
 - lib/dentaku/ast/functions/min.rb
 - lib/dentaku/ast/functions/mul.rb
 - lib/dentaku/ast/functions/not.rb
 - lib/dentaku/ast/functions/or.rb
+- lib/dentaku/ast/functions/pluck.rb
 - lib/dentaku/ast/functions/round.rb
 - lib/dentaku/ast/functions/rounddown.rb
 - lib/dentaku/ast/functions/roundup.rb
@@ -251,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A formula language parser and evaluator