dentaku 2.0.11 → 3.0.0

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "2.0.11"
+  VERSION = "3.0.0"
 end

data/spec/ast/addition_spec.rb

@@ -4,8 +4,8 @@ require 'dentaku/ast/arithmetic'
 require 'dentaku/token'
 
 describe Dentaku::AST::Addition do
-  let(:five) { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 5) }
-  let(:six)  { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 6) }
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+  let(:six)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 6) }
 
   let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
 
@@ -17,7 +17,7 @@ describe Dentaku::AST::Addition do
   it 'requires numeric operands' do
     expect {
       described_class.new(five, t)
-    }.to raise_error(Dentaku::ParseError, /requires numeric operands/)
+    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)
@@ -29,7 +29,7 @@ describe Dentaku::AST::Addition do
 
   it 'allows operands that respond to addition' do
     # Sample struct that has a custom definition for addition
-    
+
     Operand = Struct.new(:value) do
       def +(other)
         case other
@@ -41,8 +41,8 @@ describe Dentaku::AST::Addition do
       end
     end
 
-    operand_five = Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, Operand.new(5))
-    operand_six = Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, Operand.new(6))
+    operand_five = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Operand.new(5))
+    operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Operand.new(6))
 
     expect {
       described_class.new(operand_five, operand_six)

data/spec/ast/and_function_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/and'
+
+describe 'Dentaku::AST::And' do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'returns false if any of the arguments is false' do
+    result = Dentaku('AND(1 = 1, 0 = 1)')
+    expect(result).to eq false
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('AND(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq false
+  end
+
+  it 'returns true if all of the arguments are true' do
+    result = Dentaku('AND(1 = 1, "2" = "2", true = true, true)')
+    expect(result).to eq true
+  end
+
+  it 'returns true if all nested AND functions return true' do
+    result = Dentaku('AND(AND(1 = 1), AND(true != false, AND(true)))')
+    expect(result).to eq true
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('AND()') }.to raise_error(ArgumentError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('AND("r")') }.to raise_error(ArgumentError)
+  end
+end

data/spec/ast/and_spec.rb

@@ -17,7 +17,7 @@ describe Dentaku::AST::And do
   it 'requires logical operands' do
     expect {
       described_class.new(t, five)
-    }.to raise_error(Dentaku::ParseError, /requires logical operands/)
+    }.to raise_error(Dentaku::NodeError, /requires logical operands/)
 
     expression = Dentaku::AST::LessThanOrEqual.new(five, five)
     expect {

data/spec/ast/arithmetic_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Arithmetic do
+  let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:x)   { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
+  let(:y)   { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
+  let(:ctx) {{'x' => 1, 'y' => 2}}
+
+  it 'performs an arithmetic operation with numeric operands' do
+    expect(add(one, two)).to eq  3
+    expect(sub(one, two)).to eq -1
+    expect(mul(one, two)).to eq  2
+    expect(div(one, two)).to eq  0.5
+  end
+
+  it 'performs an arithmetic operation with one numeric operand and one string operand' do
+    expect(add(one, x)).to eq 2
+    expect(sub(one, x)).to eq 0
+    expect(mul(one, x)).to eq 1
+    expect(div(one, x)).to eq 1
+
+    expect(add(y, two)).to eq 4
+    expect(sub(y, two)).to eq 0
+    expect(mul(y, two)).to eq 4
+    expect(div(y, two)).to eq 1
+  end
+
+  it 'performs an arithmetic operation with string operands' do
+    expect(add(x, y)).to eq  3
+    expect(sub(x, y)).to eq -1
+    expect(mul(x, y)).to eq  2
+    expect(div(x, y)).to eq  0.5
+  end
+
+  private
+
+  def add(left, right)
+    Dentaku::AST::Addition.new(left, right).value(ctx)
+  end
+
+  def sub(left, right)
+    Dentaku::AST::Subtraction.new(left, right).value(ctx)
+  end
+
+  def mul(left, right)
+    Dentaku::AST::Multiplication.new(left, right).value(ctx)
+  end
+
+  def div(left, right)
+    Dentaku::AST::Division.new(left, right).value(ctx)
+  end
+end

data/spec/ast/division_spec.rb

@@ -17,7 +17,7 @@ describe Dentaku::AST::Division do
   it 'requires numeric operands' do
     expect {
       described_class.new(five, t)
-    }.to raise_error(Dentaku::ParseError, /requires numeric operands/)
+    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)

data/spec/ast/function_spec.rb

@@ -1,5 +1,7 @@
+require 'bigdecimal'
 require 'spec_helper'
 require 'dentaku/ast/function'
+require 'dentaku/exceptions'
 
 class Clazz; end
 
@@ -8,12 +10,6 @@ describe Dentaku::AST::Function do
     expect(described_class).to respond_to(:get)
   end
 
-  it 'raises an exception when trying to access an undefined function' do
-    expect {
-      described_class.get("flarble")
-    }.to raise_error(Dentaku::ParseError, /undefined function/i)
-  end
-
   it 'registers a custom function' do
     described_class.register("flarble", :string, -> { "flarble" })
     expect { described_class.get("flarble") }.not_to raise_error
@@ -24,4 +20,45 @@ describe Dentaku::AST::Function do
   it 'does not throw an error when registering a function with a name that matches a currently defined constant' do
     expect { described_class.register("clazz", :string, -> { "clazzified" }) }.not_to raise_error
   end
+
+  describe "#arity" do
+    it "gives the correct arity for custom functions" do
+      zero = described_class.register("zero", :numeric, ->() { 0 })
+      expect(zero.arity).to eq 0
+
+      one = described_class.register("one", :numeric, ->(x) { x * 2 })
+      expect(one.arity).to eq 1
+
+      two = described_class.register("two", :numeric, ->(x,y) { x + y })
+      expect(two.arity).to eq 2
+
+      many = described_class.register("many", :numeric, ->(*args) { args.max })
+      expect(many.arity).to be_nil
+    end
+  end
+
+  it 'casts a String to an Integer if possible' do
+    expect(described_class.numeric('3')).to eq 3
+  end
+
+  it 'casts a String to a BigDecimal if possible and if Integer would loose information' do
+    expect(described_class.numeric('3.2')).to eq 3.2
+  end
+
+  it 'casts a String to a BigDecimal with a negative number' do
+    expect(described_class.numeric('-3.2')).to eq -3.2
+  end
+
+  it 'casts a String to a BigDecimal without a leading zero' do
+    expect(described_class.numeric('-.2')).to eq -0.2
+  end
+
+  it 'raises an error if the value could not be cast to a Numeric' do
+    expect { described_class.numeric('flarble') }.to raise_error TypeError
+    expect { described_class.numeric('-') }.to raise_error TypeError
+    expect { described_class.numeric('') }.to raise_error TypeError
+    expect { described_class.numeric(nil) }.to raise_error TypeError
+    expect { described_class.numeric('7.') }.to raise_error TypeError
+    expect { described_class.numeric(true) }.to raise_error TypeError
+  end
 end

data/spec/ast/max_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/max'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Max' do
+  it 'returns the largest numeric value in an array of Numeric values' do
+    result = Dentaku('MAX(1, x, 1.8)', x: 2.3)
+    expect(result).to eq 2.3
+  end
+
+  it 'returns the largest value even if a String is passed' do
+    result = Dentaku('MAX(1, x, 1.8)', x: '2.3')
+    expect(result).to eq 2.3
+  end
+end

data/spec/ast/min_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/min'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Min' do
+  it 'returns the smallest numeric value in an array of Numeric values' do
+    result = Dentaku('MIN(1, x, 1.8)', x: 2.3)
+    expect(result).to eq 1
+  end
+
+  it 'returns the smallest value even if a String is passed' do
+    result = Dentaku('MIN(1, x, 1.8)', x: '0.3')
+    expect(result).to eq 0.3
+  end
+end

data/spec/ast/or_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/or'
+
+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)')
+    expect(result).to eq false
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('OR(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq true
+  end
+
+  it 'returns true if any of the arguments is true' do
+    result = Dentaku('OR(1 = "1", "2" = "2", true = false, false)')
+    expect(result).to eq true
+  end
+
+  it 'returns true if any nested OR function returns true' do
+    result = Dentaku('OR(OR(1 = 0), OR(true = false, OR(true)))')
+    expect(result).to eq true
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('OR()') }.to raise_error(ArgumentError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('OR("r")') }.to raise_error(ArgumentError)
+  end
+end

data/spec/ast/round_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/round'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Round' do
+  it 'returns the rounded down value' do
+    result = Dentaku('ROUND(1.8)')
+    expect(result).to eq 2
+  end
+
+  it 'returns the rounded down value to the given precision' do
+    result = Dentaku('ROUND(x, y)', x: 1.8453, y: 3)
+    expect(result).to eq 1.845
+  end
+
+  it 'returns the rounded down value to the given precision, also with strings' do
+    result = Dentaku('ROUND(x, y)', x: '1.8453', y: '3')
+    expect(result).to eq 1.845
+  end
+
+  it 'returns the rounded down value to the given precision, also with nil' do
+    result = Dentaku('ROUND(x, y)', x: '1.8453', y: nil)
+    expect(result).to eq 2
+  end
+end

data/spec/ast/rounddown_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/rounddown'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Round' do
+  it 'returns the rounded value' do
+    result = Dentaku('ROUNDDOWN(1.8)')
+    expect(result).to eq 1
+  end
+
+  it 'returns the rounded value to the given precision' do
+    result = Dentaku('ROUNDDOWN(x, y)', x: 1.8453, y: 3)
+    expect(result).to eq 1.845
+  end
+
+  it 'returns the rounded value to the given precision, also with strings' do
+    result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: '3')
+    expect(result).to eq 1.845
+  end
+
+  it 'returns the rounded value to the given precision, also with nil' do
+    result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: nil)
+    expect(result).to eq 1
+  end
+end

data/spec/ast/roundup_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/roundup'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Round' do
+  it 'returns the rounded value' do
+    result = Dentaku('ROUNDUP(1.8)')
+    expect(result).to eq 2
+  end
+
+  it 'returns the rounded value to the given precision' do
+    result = Dentaku('ROUNDUP(x, y)', x: 1.8453, y: 3)
+    expect(result).to eq 1.846
+  end
+
+  it 'returns the rounded value to the given precision, also with strings' do
+    result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: '3')
+    expect(result).to eq 1.846
+  end
+
+  it 'returns the rounded value to the given precision, also with nil' do
+    result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: nil)
+    expect(result).to eq 2
+  end
+end

data/spec/ast/switch_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/switch'
+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'
+  end
+
+  it 'returns nil if no match was found' do
+    result = Dentaku('SWITCH(3, 1, "one", 2, "two")')
+    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'
+  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'
+  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
+  end
+end

data/spec/calculator_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'dentaku/calculator'
+require 'dentaku'
 
 describe Dentaku::Calculator do
   let(:calculator)  { described_class.new }
@@ -32,6 +32,7 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('0.253/0.253')).to eq(1)
     expect(calculator.evaluate('0.253/d', d: 0.253)).to eq(1)
     expect(calculator.evaluate('10 + x', x: 'abc')).to be_nil
+    expect(calculator.evaluate('a/b', a: '10', b: '2')).to eq(5)
     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)
@@ -68,6 +69,13 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('a.basket.of')).to eq '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
+    end
   end
 
   describe 'dependencies' do
@@ -192,14 +200,20 @@ describe Dentaku::Calculator do
     expect { calculator.evaluate!(unbound) }.to raise_error do |error|
       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']
+    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 'fails to evaluate incomplete statements' do
-    incomplete = 'true AND'
-    expect { calculator.evaluate!(incomplete) }.to raise_error(Dentaku::ParseError)
+    ['true AND', 'a a ^&'].each do |statement|
+      expect {
+        calculator.evaluate!(statement)
+      }.to raise_error(Dentaku::ParseError)
+    end
   end
 
   it 'evaluates unbound statements given a binding in memory' do
@@ -455,7 +469,7 @@ describe Dentaku::Calculator do
     Math.methods(false).each do |method|
       it method do
         if Math.method(method).arity == 2
-          expect(calculator.evaluate("#{method}(1,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)
         else
           expect(calculator.evaluate("#{method}(1)")).to eq Math.send(method, 1)
         end
@@ -517,4 +531,12 @@ describe Dentaku::Calculator do
       ).to eq 'abcdef'
     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
+    end
+  end
 end