dentaku 3.2.0 → 3.5.1

data/spec/ast/any_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/any'
+require 'dentaku'
+
+describe Dentaku::AST::Any do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'performs ANY operation' do
+    result = Dentaku('ANY(vals, val, val > 1)', vals: [1, 2, 3])
+    expect(result).to eq(true)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('ANY(vals, val, val > 1)', vals: 1)
+    expect(result).to eq(false)
+
+    result = Dentaku('ANY(vals, val, val > 1)', vals: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/ast/arithmetic_spec.rb

@@ -4,53 +4,88 @@ 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} }
+  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} }
+  let(:date) { Dentaku::AST::DateTime.new Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16)) }
 
   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
+    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)
+    expect(neg(one)).to eq(-1)
   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(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
+    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
+    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)
+    expect(neg(x)).to eq(-1)
+  end
+
+  it 'correctly parses string operands to numeric values' do
+    expect(add(x, one, 'x' => '1')).to eq(2)
+    expect(add(x, one, 'x' => '1.1')).to eq(2.1)
+    expect(add(x, one, 'x' => '.1')).to eq(1.1)
+    expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+    expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
+
+    int_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1")
+    decimal_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1.0")
+
+    expect(add(int_one, int_one).class).to eq(Integer)
+    expect(add(int_one, decimal_one).class).to eq(BigDecimal)
+    expect(add(decimal_one, decimal_one).class).to eq(BigDecimal)
+  end
+
+  it 'performs arithmetic on arrays' do
+    expect(add(x, y, 'x' => [1], 'y' => [2])).to eq([1, 2])
+  end
+
+  it 'performs date arithmetic' do
+    expect(add(date, one)).to eq(DateTime.new(2020, 4, 17))
+  end
+
+  it 'raises ArgumentError if given individually valid but incompatible arguments' do
+    expect { add(one, date) }.to raise_error(Dentaku::ArgumentError)
+    expect { add(x, one, 'x' => [1]) }.to raise_error(Dentaku::ArgumentError)
   end
 
   private
 
-  def add(left, right)
-    Dentaku::AST::Addition.new(left, right).value(ctx)
+  def add(left, right, context = ctx)
+    Dentaku::AST::Addition.new(left, right).value(context)
+  end
+
+  def sub(left, right, context = ctx)
+    Dentaku::AST::Subtraction.new(left, right).value(context)
   end
 
-  def sub(left, right)
-    Dentaku::AST::Subtraction.new(left, right).value(ctx)
+  def mul(left, right, context = ctx)
+    Dentaku::AST::Multiplication.new(left, right).value(context)
   end
 
-  def mul(left, right)
-    Dentaku::AST::Multiplication.new(left, right).value(ctx)
+  def div(left, right, context = ctx)
+    Dentaku::AST::Division.new(left, right).value(context)
   end
 
-  def div(left, right)
-    Dentaku::AST::Division.new(left, right).value(ctx)
+  def neg(node, context = ctx)
+    Dentaku::AST::Negation.new(node).value(context)
   end
 end

data/spec/ast/avg_spec.rb

@@ -5,29 +5,33 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Avg' do
   it 'returns the average of an array of Numeric values' do
     result = Dentaku('AVG(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 1.7
+    expect(result).to eq(1.7)
   end
 
   it 'returns the average of a single entry array of a Numeric value' do
     result = Dentaku('AVG(x)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'returns the average even if a String is passed' do
     result = Dentaku('AVG(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 1.7
+    expect(result).to eq(1.7)
   end
 
   it 'returns the average even if an array is passed' do
     result = Dentaku('AVG(1, x, 2.3)', x: [4, 5])
-    expect(result).to eq 3.075
+    expect(result).to eq(3.075)
   end
 
   context 'checking errors' do
     let(:calculator) { Dentaku::Calculator.new }
 
     it 'raises an error if no arguments are passed' do
-      expect { calculator.evaluate!('AVG()') }.to raise_error(ArgumentError)
+      expect { calculator.evaluate!('AVG()') }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if an empty array is passed' do
+      expect { calculator.evaluate!('AVG(x)', x: []) }.to raise_error(Dentaku::ArgumentError)
     end
   end
 end

data/spec/ast/comparator_spec.rb

@@ -5,10 +5,15 @@ require 'dentaku/token'
 
 describe Dentaku::AST::Comparator do
   let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:one_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '1') }
   let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:two_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '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' => 'hello', 'y' => 'world' } }
+  let(:nilly) do
+    Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'nilly')
+  end
+  let(:ctx) { { 'x' => 'hello', 'y' => 'world', 'nilly' => nil } }
 
   it 'performs comparison with numeric operands' do
     expect(less_than(one, two).value(ctx)).to be_truthy
@@ -18,6 +23,31 @@ describe Dentaku::AST::Comparator do
     expect(equal(x, y).value(ctx)).to be_falsey
   end
 
+  it 'performs conversion from string to numeric operands' do
+    expect(less_than(one, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two).value(ctx)).to be_truthy
+  end
+
+  it 'raises a dentaku argument error when incorrect arguments are passed in' do
+    expect { less_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { less_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(one, x).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { not_equal(one, nilly).value(ctx) }.to_not raise_error
+    expect { equal(one, nilly).value(ctx) }.to_not raise_error
+  end
+
+  it 'raises a dentaku argument error when nil is passed in as first argument' do
+    expect { less_than(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { less_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { not_equal(nilly, one).value(ctx) }.to_not raise_error
+    expect { equal(nilly, one).value(ctx) }.to_not raise_error
+  end
+
   it 'returns correct operator symbols' do
     expect(less_than(one, two).operator).to eq(:<)
     expect(less_than_or_equal(one, two).operator).to eq(:<=)

data/spec/ast/count_spec.rb

@@ -5,36 +5,36 @@ require 'dentaku'
 describe 'Dentaku::AST::Count' do
   it 'returns the length of an array' do
     result = Dentaku('COUNT(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 3
+    expect(result).to eq(3)
   end
 
   it 'returns the length of a single number object' do
     result = Dentaku('COUNT(x)', x: 2.3)
-    expect(result).to eq 1
+    expect(result).to eq(1)
   end
 
   it 'returns the length if a single String is passed' do
     result = Dentaku('COUNT(x)', x: 'dentaku')
-    expect(result).to eq 7
+    expect(result).to eq(7)
   end
 
   it 'returns the length if an array is passed' do
     result = Dentaku('COUNT(x)', x: [4, 5])
-    expect(result).to eq 2
+    expect(result).to eq(2)
   end
 
   it 'returns the length if an array with one element is passed' do
     result = Dentaku('COUNT(x)', x: [4])
-    expect(result).to eq 1
+    expect(result).to eq(1)
   end
 
   it 'returns the length if an array even if it has nested array' do
     result = Dentaku('COUNT(1, x, 3)', x: [4, 5])
-    expect(result).to eq 3
+    expect(result).to eq(3)
   end
 
   it 'returns the length if an array is passed' do
     result = Dentaku('COUNT()')
-    expect(result).to eq 0
+    expect(result).to eq(0)
   end
 end

data/spec/ast/division_spec.rb

@@ -9,9 +9,15 @@ describe Dentaku::AST::Division do
 
   let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
 
+  it 'allows access to its sub-trees' do
+    node = described_class.new(five, six)
+    expect(node.left).to eq(five)
+    expect(node.right).to eq(six)
+  end
+
   it 'performs division' do
     node = described_class.new(five, six)
-    expect(node.value.round(4)).to eq 0.8333
+    expect(node.value.round(4)).to eq(0.8333)
   end
 
   it 'requires numeric operands' do

data/spec/ast/filter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/filter'
+require 'dentaku'
+
+describe Dentaku::AST::Filter do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'excludes unmatched values' do
+    result = Dentaku('SUM(FILTER(vals, val, val > 1))', vals: [1, 2, 3])
+    expect(result).to eq(5)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 1)
+    expect(result).to eq([])
+
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 2)
+    expect(result).to eq([2])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('FILTER({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
+      Dentaku::ArgumentError, 'FILTER() requires second argument to be an identifier'
+    )
+  end
+end

data/spec/ast/function_spec.rb

@@ -14,7 +14,7 @@ describe Dentaku::AST::Function do
     described_class.register("flarble", :string, -> { "flarble" })
     expect { described_class.get("flarble") }.not_to raise_error
     function = described_class.get("flarble").new
-    expect(function.value).to eq "flarble"
+    expect(function.value).to eq("flarble")
   end
 
   it 'does not throw an error when registering a function with a name that matches a currently defined constant' do
@@ -22,15 +22,15 @@ describe Dentaku::AST::Function do
   end
 
   describe "#arity" do
-    it "gives the correct arity for custom functions" do
+    it "returns the correct arity for custom functions" do
       zero = described_class.register("zero", :numeric, ->() { 0 })
-      expect(zero.arity).to eq 0
+      expect(zero.arity).to eq(0)
 
       one = described_class.register("one", :numeric, ->(x) { x * 2 })
-      expect(one.arity).to eq 1
+      expect(one.arity).to eq(1)
 
       two = described_class.register("two", :numeric, ->(x, y) { x + y })
-      expect(two.arity).to eq 2
+      expect(two.arity).to eq(2)
 
       many = described_class.register("many", :numeric, ->(*args) { args.max })
       expect(many.arity).to be_nil
@@ -38,27 +38,32 @@ describe Dentaku::AST::Function do
   end
 
   it 'casts a String to an Integer if possible' do
-    expect(described_class.numeric('3')).to eq 3
+    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
+    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
+    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
+    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
+    expect { described_class.numeric('flarble') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('-') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric(nil) }.to raise_error Dentaku::ArgumentError
+    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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+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)
+  end
+
+  it 'works with an empty array' 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/max_spec.rb

@@ -5,16 +5,29 @@ 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
+    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
+    expect(result).to eq(2.3)
   end
 
   it 'returns the largest value even if an Array is passed' do
     result = Dentaku('MAX(1, x, 1.8)', x: [1.5, 2.3, 1.7])
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
+  end
+
+  it 'returns the largest value if only an Array is passed' do
+    result = Dentaku('MAX(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(2.3)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MAX(x)', x: [])).to eq(nil)
+    end
   end
 end

data/spec/ast/min_spec.rb

@@ -5,16 +5,29 @@ 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
+    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
+    expect(result).to eq(0.3)
   end
 
   it 'returns the smallest value even if an Array is passed' do
     result = Dentaku('MIN(1, x, 1.8)', x: [1.5, 0.3, 1.7])
-    expect(result).to eq 0.3
+    expect(result).to eq(0.3)
+  end
+
+  it 'returns the smallest value if only an Array is passed' do
+    result = Dentaku('MIN(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(1.5)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MIN(x)', x: [])).to eq(nil)
+    end
   end
 end

data/spec/ast/mul_spec.rb

@@ -5,34 +5,39 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Mul' do
   it 'returns the product of an array of Numeric values' do
     result = Dentaku('MUL(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 4.14
+    expect(result).to eq(4.14)
   end
 
   it 'returns the product of a single entry array of a Numeric value' do
     result = Dentaku('MUL(x)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'coerces string inputs to numeric' do
     result = Dentaku('mul(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 4.14
+    expect(result).to eq(4.14)
   end
 
   it 'returns the product even if an array is passed' do
     result = Dentaku('mul(1, x, 2.3)', x: [4, 5])
-    expect(result).to eq 46
+    expect(result).to eq(46)
   end
 
   it 'handles nested calls' do
     result = Dentaku('mul(1, x, mul(4, 5))', x: '2.3')
-    expect(result).to eq 46
+    expect(result).to eq(46)
   end
 
   context 'checking errors' do
     let(:calculator) { Dentaku::Calculator.new }
 
     it 'raises an error if no arguments are passed' do
-      expect { calculator.evaluate!('MUL()') }.to raise_error(ArgumentError)
+      expect { calculator.evaluate!('MUL()') }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('MUL(x)', x: [])
+      expect(result).to eq(1)
     end
   end
 end

data/spec/ast/negation_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Negation do
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+  let(:t)    { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, true) }
+  let(:x)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
+
+  it 'allows access to its sub-node' do
+    node = described_class.new(five)
+    expect(node.node).to eq(five)
+  end
+
+  it 'performs negation' do
+    node = described_class.new(five)
+    expect(node.value).to eq(-5)
+  end
+
+  it 'requires numeric operands' do
+    expect {
+      described_class.new(t)
+    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
+
+    expression = Dentaku::AST::Negation.new(five)
+    group = Dentaku::AST::Grouping.new(expression)
+
+    expect {
+      described_class.new(group)
+    }.not_to raise_error
+  end
+
+  it 'correctly parses string operands to numeric values' do
+    node = described_class.new(x)
+    expect(node.value('x' => '5')).to eq(-5)
+  end
+
+  it 'raises error if input string is not coercible to numeric' do
+    node = described_class.new(x)
+    expect { node.value('x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+  end
+
+  it 'raises error if given a non-numeric argument' do
+    node = described_class.new(x)
+    expect { node.value('x' => true) }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/ast/node_spec.rb

@@ -6,30 +6,33 @@ require 'dentaku/parser'
 describe Dentaku::AST::Node do
   it 'returns list of dependencies' do
     node = make_node('x + 5')
-    expect(node.dependencies).to eq ['x']
+    expect(node.dependencies).to eq(['x'])
 
     node = make_node('5 < x')
-    expect(node.dependencies).to eq ['x']
+    expect(node.dependencies).to eq(['x'])
 
     node = make_node('5 < 7')
-    expect(node.dependencies).to eq []
+    expect(node.dependencies).to eq([])
 
     node = make_node('(y * 7)')
-    expect(node.dependencies).to eq ['y']
+    expect(node.dependencies).to eq(['y'])
 
     node = make_node('if(x > 5, y, z)')
-    expect(node.dependencies).to eq ['x', 'y', 'z']
+    expect(node.dependencies).to eq(['x', 'y', 'z'])
 
     node = make_node('if(x > 5, y, z)')
-    expect(node.dependencies('x' => 7)).to eq ['y', 'z']
+    expect(node.dependencies('x' => 7)).to eq(['y'])
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies('x' => 2)).to eq(['z'])
 
     node = make_node('')
-    expect(node.dependencies).to eq []
+    expect(node.dependencies).to eq([])
   end
 
   it 'returns unique list of dependencies' do
     node = make_node('x + x')
-    expect(node.dependencies).to eq ['x']
+    expect(node.dependencies).to eq(['x'])
   end
 
   private

data/spec/ast/numeric_spec.rb

@@ -7,7 +7,7 @@ describe Dentaku::AST::Numeric do
   subject { described_class.new(Dentaku::Token.new(:numeric, 5)) }
 
   it 'has numeric type' do
-    expect(subject.type).to eq :numeric
+    expect(subject.type).to eq(:numeric)
   end
 
   it 'has no dependencies' do