dentaku 3.5.2 → 3.5.4

data/lib/dentaku/exceptions.rb

@@ -67,7 +67,9 @@ module Dentaku
     private_class_method :new
 
     VALID_REASONS = %i[
-      parse_error too_many_opening_parentheses too_many_closing_parentheses
+      parse_error
+      too_many_closing_parentheses
+      too_many_opening_parentheses
       unexpected_zero_width_match
     ].freeze
 
@@ -92,8 +94,11 @@ module Dentaku
     private_class_method :new
 
     VALID_REASONS = %i[
-      invalid_operator invalid_value too_few_arguments
-      too_much_arguments incompatible_type
+      incompatible_type
+      invalid_operator
+      invalid_value
+      too_few_arguments
+      wrong_number_of_arguments
     ].freeze
 
     def self.for(reason, **meta)

data/lib/dentaku/parser.rb

@@ -43,8 +43,6 @@ module Dentaku
       operator = operations.pop
       fail! :invalid_statement if operator.nil?
 
-      operator.peek(output)
-
       output_size = output.length
       args_size = operator.arity || count
       min_size = operator.arity || operator.min_param_count || count
@@ -60,10 +58,14 @@ module Dentaku
         fail! :too_many_operands, operator: operator, expect: expect, actual: output_size
       end
 
-      fail! :invalid_statement if output_size < args_size
-      args = Array.new(args_size) { output.pop }.reverse
+      if operator == AST::Array && output.empty?
+        output.push(operator.new())
+      else
+        fail! :invalid_statement if output_size < args_size
+        args = Array.new(args_size) { output.pop }.reverse
 
-      output.push operator.new(*args)
+        output.push operator.new(*args)
+      end
 
       if operator.respond_to?(:callback) && !operator.callback.nil?
         operator.callback.call(args)
@@ -96,6 +98,7 @@ module Dentaku
 
         when :operator, :comparator, :combinator
           op_class = operation(token)
+          op_class = op_class.resolve_class(input.first)
 
           if op_class.right_associative?
             while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence

data/lib/dentaku/token.rb

@@ -20,10 +20,22 @@ module Dentaku
       length.zero?
     end
 
+    def operator?
+      is?(:operator)
+    end
+
     def grouping?
       is?(:grouping)
     end
 
+    def open?
+      grouping? && value == :open
+    end
+
+    def close?
+      grouping? && value == :close
+    end
+
     def is?(c)
       category == c
     end

data/lib/dentaku/token_scanner.rb

@@ -7,7 +7,7 @@ module Dentaku
   class TokenScanner
     extend StringCasing
 
-    DATE_TIME_REGEXP = /\d{2}\d{2}?-\d{1,2}-\d{1,2}( \d{1,2}:\d{1,2}:\d{1,2})? ?(Z|((\+|\-)\d{2}\:?\d{2}))?(?!\d)/.freeze
+    DATE_TIME_REGEXP = /\d{2}\d{2}?-\d{1,2}-\d{1,2}([ |T]\d{1,2}:\d{1,2}:\d{1,2}(\.\d*)?)? ?(Z|((\+|\-)\d{2}\:?\d{2}))?(?!\d)/.freeze
 
     def initialize(category, regexp, converter = nil, condition = nil)
       @category  = category
@@ -51,7 +51,8 @@ module Dentaku
           :comparator,
           :boolean,
           :function,
-          :identifier
+          :identifier,
+          :quoted_identifier
         ]
       end
 
@@ -180,6 +181,10 @@ module Dentaku
       def identifier
         new(:identifier, '[[[:word:]]\.]+\b', lambda { |raw| standardize_case(raw.strip) })
       end
+
+      def quoted_identifier
+        new(:identifier, '`[^`]*`', lambda { |raw| raw.gsub(/^`|`$/, '') })
+      end
     end
 
     register_default_scanners

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.2"
+  VERSION = "3.5.4"
 end

data/spec/ast/addition_spec.rb

@@ -36,10 +36,10 @@ 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
+    Addable = Struct.new(:value) do
       def +(other)
         case other
-        when Operand
+        when Addable
           value + other.value
         when Numeric
           value + other
@@ -47,8 +47,8 @@ describe Dentaku::AST::Addition do
       end
     end
 
-    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))
+    operand_five = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Addable.new(5))
+    operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Addable.new(6))
 
     expect {
       described_class.new(operand_five, operand_six)

data/spec/ast/all_spec.rb

@@ -4,6 +4,7 @@ require 'dentaku'
 
 describe Dentaku::AST::All do
   let(:calculator) { Dentaku::Calculator.new }
+
   it 'performs ALL operation' do
     result = Dentaku('ALL(vals, val, val > 1)', vals: [1, 2, 3])
     expect(result).to eq(false)
@@ -22,4 +23,16 @@ describe Dentaku::AST::All do
       Dentaku::ParseError, 'ALL() requires second argument to be an identifier'
     )
   end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('ALL(items, item, item.value)', items: [{value: 1}, {}])
+    ).to be_falsy
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('ALL(items, item, item.value)', items: [{value: 1}, {}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
 end

data/spec/ast/any_spec.rb

@@ -4,6 +4,7 @@ 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)
@@ -20,4 +21,16 @@ describe Dentaku::AST::Any do
   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::ParseError)
   end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('ANY(items, item, item.value)', items: [{value: 1}, {}])
+    ).to be_truthy
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('ANY(items, item, item.value)', items: [{}, {value: 1}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
 end

data/spec/ast/arithmetic_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 require 'dentaku/ast/arithmetic'
-
-require 'dentaku/token'
+require 'dentaku'
 
 describe Dentaku::AST::Arithmetic do
   let(:one)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 1)) }
@@ -64,10 +63,52 @@ describe Dentaku::AST::Arithmetic do
 
   it 'performs arithmetic on arrays' do
     expect(add(x, y, 'x' => [1], 'y' => [2])).to eq([1, 2])
+    expect(sub(x, y, 'x' => [1], 'y' => [2])).to eq([1])
   end
 
   it 'performs date arithmetic' do
     expect(add(date, one)).to eq(DateTime.new(2020, 4, 17))
+    expect(sub(date, one)).to eq(DateTime.new(2020, 4, 15))
+  end
+
+  it 'performs arithmetic on object which implements arithmetic' do
+    CanHazMath = Struct.new(:value) do
+      extend Forwardable
+
+      def_delegators :value, :zero?
+
+      def coerce(other)
+        case other
+        when Numeric
+          [other, value]
+        else
+          super
+        end
+      end
+
+      [:+, :-, :/, :*].each do |operand|
+        define_method(operand) do |other|
+          case other
+          when CanHazMath
+            value.public_send(operand, other.value)
+          when Numeric
+            value.public_send(operand, other)
+          end
+        end
+      end
+    end
+
+    op_one = CanHazMath.new(1)
+    op_two = CanHazMath.new(2)
+
+    [op_two, two].each do |left|
+      [op_one, one].each do |right|
+        expect(add(x, y, 'x' => left, 'y' => right)).to eq(3)
+        expect(sub(x, y, 'x' => left, 'y' => right)).to eq(1)
+        expect(mul(x, y, 'x' => left, 'y' => right)).to eq(2)
+        expect(div(x, y, 'x' => left, 'y' => right)).to eq(2)
+      end
+    end
   end
 
   it 'raises ArgumentError if given individually valid but incompatible arguments' do

data/spec/ast/division_spec.rb

@@ -32,4 +32,29 @@ describe Dentaku::AST::Division do
       described_class.new(group, five)
     }.not_to raise_error
   end
+
+  it 'allows operands that respond to division' do
+    # Sample struct that has a custom definition for division
+    Divisible = Struct.new(:value) do
+      def /(other)
+        case other
+        when Divisible
+          value + other.value
+        when Numeric
+          value + other
+        end
+      end
+    end
+
+    operand_five = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Divisible.new(5))
+    operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Divisible.new(6))
+
+    expect {
+      described_class.new(operand_five, operand_six)
+    }.not_to raise_error
+
+    expect {
+      described_class.new(operand_five, six)
+    }.not_to raise_error
+  end
 end

data/spec/ast/intercept_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/intercept'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Intercept' do
+  it 'returns the correct intercept for given x and y arrays' do
+    x_values = [6, 13, 15, 10, 11, 10]
+    y_values = [-1, 8, 8,  13, 3, 15]
+    result = Dentaku('INTERCEPT(ys, xs)', xs: x_values, ys: y_values)
+    expect(result).to be_within(0.001).of(9.437)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if arguments are not arrays' do
+      expect { Dentaku!("INTERCEPT(1, 2)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if the arrays are not of equal length' do
+      x_values = [1, 2, 3]
+      y_values = [2, 3, 5, 4]
+      expect { Dentaku!("INTERCEPT(y, x)", x: x_values, y: y_values) }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if any of the arrays is empty' do
+      x_values = []
+      y_values = [2, 3, 5, 4]
+      expect { Dentaku!("INTERCEPT(y, x)", x: x_values, y: y_values) }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/map_spec.rb

@@ -4,6 +4,7 @@ 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)
@@ -24,4 +25,16 @@ describe Dentaku::AST::Map do
       Dentaku::ParseError,  'MAP() requires second argument to be an identifier'
     )
   end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('MAP(items, item, item.value)', items: [{value: 1}, {}])
+    ).to eq([1, nil])
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('MAP(items, item, item.value)', items: [{value: 1}, {}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
 end

data/spec/ast/pluck_spec.rb

@@ -4,6 +4,7 @@ require 'dentaku'
 
 describe Dentaku::AST::Pluck do
   let(:calculator) { Dentaku::Calculator.new }
+
   it 'operates on each value in an array' do
     result = Dentaku('PLUCK(users, age)', users: [
       {name: "Bob",  age: 44},
@@ -12,6 +13,22 @@ describe Dentaku::AST::Pluck do
     expect(result).to eq([44, 27])
   end
 
+  it 'allows specifying a default for missing values' do
+    result = Dentaku!('PLUCK(users, age, -1)', users: [
+      {name: "Bob"},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([-1, 27])
+  end
+
+  it 'returns nil if pluck key is missing from a hash' do
+    result = Dentaku!('PLUCK(users, age)', users: [
+      {name: "Bob"},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([nil, 27])
+  end
+
   it 'works with an empty array' do
     result = Dentaku('PLUCK(users, age)', users: [])
     expect(result).to eq([])

data/spec/ast/reduce_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/reduce'
+require 'dentaku'
+
+describe Dentaku::AST::Reduce do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'performs REDUCE operation with initial value' do
+    result = Dentaku('REDUCE(vals, memo, val, CONCAT(memo, val), "hello")', vals: ["wo", "rl", "d"])
+    expect(result).to eq("helloworld")
+  end
+
+  it 'performs REDUCE operation without initial value' do
+    result = Dentaku('REDUCE(vals, memo, val, CONCAT(memo, val))', vals: ["wo", "rl", "d"])
+    expect(result).to eq("world")
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('REDUCE({1, 2, 3}, memo, "val", memo + val)') }.to raise_error(Dentaku::ParseError)
+    expect { calculator.evaluate!('REDUCE({1, 2, 3}, "memo", val, memo + val)') }.to raise_error(Dentaku::ParseError)
+  end
+end

data/spec/bulk_expression_solver_spec.rb

@@ -107,6 +107,22 @@ RSpec.describe Dentaku::BulkExpressionSolver do
   end
 
   describe "#solve" do
+    it 'resolves capitalized keys when they are declared out of order' do
+      expressions = {
+        FIRST: "SECOND * 2",
+        SECOND: "THIRD * 2",
+        THIRD: 2,
+      }
+
+      result = described_class.new(expressions, calculator).solve
+
+      expect(result).to eq(
+        FIRST: 8,
+        SECOND: 4,
+        THIRD: 2
+      )
+    end
+
     it "returns :undefined when variables are unbound" do
       expressions = {more_apples: "apples + 1"}
       expect(described_class.new(expressions, calculator).solve)
@@ -125,6 +141,12 @@ RSpec.describe Dentaku::BulkExpressionSolver do
         .to eq(more_apples: :foo)
     end
 
+    it "allows passing in ast as expression" do
+      expressions = {more_apples: calculator.ast("1/0")}
+      expect(described_class.new(expressions, calculator).solve { :foo })
+        .to eq(more_apples: :foo)
+    end
+
     it 'stores the recipient variable on the exception when there is a div/0 error' do
       expressions = {more_apples: "1/0"}
       exception = nil
@@ -197,5 +219,16 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(results).to eq('key' => [3, :undefined])
       expect { solver.solve! }.to raise_error(Dentaku::UnboundVariableError)
     end
+
+    it do
+      calculator.store(val: nil)
+      expressions = {
+        a: 'IF(5 / 0 > 0, 100, 1000)',
+        b: 'IF(val = 0, 0, IF(val > 0, 0, 0))'
+      }
+      solver = described_class.new(expressions, calculator)
+      results = solver.solve
+      expect(results).to eq(a: :undefined, b: :undefined)
+    end
   end
 end

data/spec/calculator_spec.rb

@@ -30,7 +30,6 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('0 * 10 ^ -5')).to eq(0)
     expect(calculator.evaluate('3 + 0 * -3')).to eq(3)
     expect(calculator.evaluate('3 + 0 / -3')).to eq(3)
-    expect(calculator.evaluate('15 % 8')).to eq(7)
     expect(calculator.evaluate('(((695759/735000)^(1/(1981-1991)))-1)*1000').round(4)).to eq(5.5018)
     expect(calculator.evaluate('0.253/0.253')).to eq(1)
     expect(calculator.evaluate('0.253/d', d: 0.253)).to eq(1)
@@ -40,11 +39,20 @@ 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
 
+  it "differentiates between percentage and modulo operators" do
+    expect(calculator.evaluate('15 % 8')).to eq(7)
+    expect(calculator.evaluate('15 % (4 * 2)')).to eq(7)
+    expect(calculator.evaluate("5%")).to eq (0.05)
+    expect(calculator.evaluate("400/60%").round(2)).to eq (666.67)
+    expect(calculator.evaluate("(400/60%)*1").round(2)).to eq (666.67)
+    expect(calculator.evaluate("60% * 1").round(2)).to eq (0.60)
+    expect(calculator.evaluate("50% + 50%")).to eq (1.0)
+  end
+
   describe 'evaluate' do
     it 'returns nil when formula has error' do
       expect(calculator.evaluate('1 + + 1')).to be_nil
@@ -159,6 +167,12 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('area', length: 5, width: 5)).to eq(25)
     end
 
+    it 'stores dates' do
+      calculator.store("d1", Date.parse("2024/01/02"))
+      calculator.store("d2", Date.parse("2024/01/06"))
+      expect(calculator.solve(diff: "d1 - d2")).to eq(diff: -4)
+    end
+
     it 'stores nested hashes' do
       calculator.store(a: {basket: {of: 'apples'}}, b: 2)
       expect(calculator.evaluate!('a.basket.of')).to eq('apples')
@@ -166,6 +180,13 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('b')).to eq(2)
     end
 
+    it 'stores nested hashes with quotes' 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
+
     it 'stores arrays' do
       calculator.store(a: [1, 2, 3])
       expect(calculator.evaluate!('a[0]')).to eq(1)
@@ -180,6 +201,10 @@ describe Dentaku::Calculator do
   end
 
   describe 'dependencies' do
+    it 'respects quoted identifiers in dependencies' do
+      expect(calculator.dependencies("`bob the builder` + `dole the digger` / 3")).to eq(['bob the builder', 'dole the digger'])
+    end
+
     it "finds dependencies in a generic statement" do
       expect(calculator.dependencies("bob + dole / 3")).to eq(['bob', 'dole'])
     end
@@ -188,6 +213,10 @@ describe Dentaku::Calculator do
       expect(calculator.dependencies("a + b", a: 1)).to eq(['b'])
     end
 
+    it "ignores dependencies passed in context for quoted identifiers" do
+      expect(calculator.dependencies("`a-c` + b", "a-c": 1)).to eq(['b'])
+    end
+
     it "finds dependencies in formula arguments" do
       allow(Dentaku).to receive(:cache_ast?) { true }
 
@@ -211,10 +240,11 @@ describe Dentaku::Calculator do
   describe 'solve!' do
     it "evaluates properly with variables, even if some in memory" do
       expect(with_memory.solve!(
+        "monthly fruit budget": "weekly_fruit_budget * 4",
         weekly_fruit_budget: "weekly_apple_budget + pear * 4",
         weekly_apple_budget: "apples * 7",
         pear:                "1"
-      )).to eq(pear: 1, weekly_apple_budget: 21, weekly_fruit_budget: 25)
+      )).to eq(pear: 1, weekly_apple_budget: 21, weekly_fruit_budget: 25, "monthly fruit budget": 100)
     end
 
     it "prefers variables over values in memory if they have no dependencies" do
@@ -412,6 +442,13 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('fo1o * 2', fo1o: 4)).to eq(8)
   end
 
+  it 'accepts special characters in quoted identifiers' do
+    expect(calculator.evaluate('`foo1 bar` * 2', "foo1 bar": 2)).to eq(4)
+    expect(calculator.evaluate('`foo1-bar` * 2', 'foo1-bar' => 4)).to eq(8)
+    expect(calculator.evaluate('`1foo (bar)` * 2', '1foo (bar)' => 2)).to eq(4)
+    expect(calculator.evaluate('`fo1o *bar*` * 2', 'fo1o *bar*': 4)).to eq(8)
+  end
+
   it 'compares string literals with string variables' do
     expect(calculator.evaluate('fruit = "apple"', fruit: 'apple')).to be_truthy
     expect(calculator.evaluate('fruit = "apple"', fruit: 'pear')).to be_falsey
@@ -471,16 +508,31 @@ describe Dentaku::Calculator do
 
     it 'from string variable' do
       value = '2023-01-01'
+      value2 = '2022-12-31'
 
-      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eql(Date.parse('2023-02-01'))
-      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eql(Date.parse('2022-12-01'))
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eq(Date.parse('2023-02-01'))
+      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eq(Date.parse('2022-12-01'))
+      expect(calculator.evaluate!('value - value2', { value: value, value2: value2 })).to eq(1)
     end
 
     it 'from date object' do
       value = Date.parse('2023-01-01').to_date
+      value2 = Date.parse('2022-12-31').to_date
 
-      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eql(Date.parse('2023-02-01'))
-      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eql(Date.parse('2022-12-01'))
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eq(Date.parse('2023-02-01'))
+      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eq(Date.parse('2022-12-01'))
+      expect(calculator.evaluate!('value - value2', { value: value, value2: value2 })).to eq(1)
+    end
+
+    it 'from time object' do
+      value = Time.local(2023, 7, 13, 10, 42, 11)
+      value2 = Time.local(2023, 12, 1, 9, 42, 10)
+
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value })).to eq(Time.local(2023, 8, 13, 10, 42, 11))
+      expect(calculator.evaluate!('value - duration(1, day)', { value: value })).to eq(Time.local(2023, 7, 12, 10, 42, 11))
+      expect(calculator.evaluate!('value - duration(1, year)', { value: value })).to eq(Time.local(2022, 7, 13, 10, 42, 11))
+      expect(calculator.evaluate!('value2 - value', { value: value, value2: value2 })).to eq(12_182_399.0)
+      expect(calculator.evaluate!('value - 7200', { value: value })).to eq(Time.local(2023, 7, 13, 8, 42, 11))
     end
   end
 
@@ -522,6 +574,13 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('NOT(some_boolean) AND -1 > 3', some_boolean: true)).to be_falsey
     end
 
+    it 'calculates intercept correctly' do
+      x_values = [1, 2, 3, 4, 5]
+      y_values = [2, 3, 5, 4, 6]
+      result = calculator.evaluate('INTERCEPT(x_values, y_values)', x_values: x_values, y_values: y_values)
+      expect(result).to be_within(0.001).of(1.3)
+    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

data/spec/dependency_resolver_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'dentaku/dependency_resolver'
+
+describe Dentaku::DependencyResolver do
+  it 'sorts expressions in dependency order' do
+    dependencies = {"first" => ["second"], "second" => ["third"], "third" => []}
+    expect(described_class.find_resolve_order(dependencies)).to eq(
+      ["third", "second", "first"]
+    )
+  end
+
+  it 'handles case differences' do
+    dependencies = {"FIRST" => ["second"], "SeCoNd" => ["third"], "THIRD" => []}
+    expect(described_class.find_resolve_order(dependencies)).to eq(
+      ["THIRD", "SeCoNd", "FIRST"]
+    )
+  end
+end

data/spec/parser_spec.rb

@@ -79,6 +79,9 @@ describe Dentaku::Parser do
   it 'evaluates arrays' do
     node = parse('{1, 2, 3}')
     expect(node.value).to eq([1, 2, 3])
+
+    node = parse('{}')
+    expect(node.value).to eq([])
   end
 
   context 'invalid expression' do

data/spec/tokenizer_spec.rb

@@ -1,3 +1,4 @@
+require 'dentaku/exceptions'
 require 'dentaku/tokenizer'
 
 describe Dentaku::Tokenizer do
@@ -234,9 +235,9 @@ describe Dentaku::Tokenizer do
   end
 
   it 'tokenizes Time literals' do
-    tokens = tokenizer.tokenize('2017-01-01 2017-01-2 2017-1-03 2017-01-04 12:23:42 2017-1-5 1:2:3 2017-1-06 1:02:30 2017-01-07 12:34:56 Z 2017-01-08 1:2:3 +0800')
-    expect(tokens.length).to eq(8)
-    expect(tokens.map(&:category)).to eq([:datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime])
+    tokens = tokenizer.tokenize('2017-01-01 2017-01-2 2017-1-03 2017-01-04 12:23:42 2017-1-5 1:2:3 2017-1-06 1:02:30 2017-01-07 12:34:56 Z 2017-01-08 1:2:3 +0800 2017-01-08T01:02:03.456Z')
+    expect(tokens.length).to eq(9)
+    expect(tokens.map(&:category)).to eq([:datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime])
     expect(tokens.map(&:value)).to eq([
       Time.local(2017, 1, 1).to_datetime,
       Time.local(2017, 1, 2).to_datetime,
@@ -245,7 +246,8 @@ describe Dentaku::Tokenizer do
       Time.local(2017, 1, 5, 1, 2, 3).to_datetime,
       Time.local(2017, 1, 6, 1, 2, 30).to_datetime,
       Time.utc(2017, 1, 7, 12, 34, 56).to_datetime,
-      Time.new(2017, 1, 8, 1, 2, 3, "+08:00").to_datetime
+      Time.new(2017, 1, 8, 1, 2, 3, "+08:00").to_datetime,
+      Time.utc(2017, 1, 8, 1, 2, 3, 456000).to_datetime
     ])
   end