dentaku 3.5.1 → 3.5.3

data/lib/dentaku/token_scanner.rb

@@ -7,6 +7,8 @@ module Dentaku
   class TokenScanner
     extend StringCasing
 
+    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
       @regexp    = %r{\A(#{ regexp })}i
@@ -49,7 +51,8 @@ module Dentaku
           :comparator,
           :boolean,
           :function,
-          :identifier
+          :identifier,
+          :quoted_identifier
         ]
       end
 
@@ -73,7 +76,9 @@ module Dentaku
 
       def scanners(options = {})
         @case_sensitive = options.fetch(:case_sensitive, false)
-        @scanners.values
+        raw_date_literals = options.fetch(:raw_date_literals, true)
+
+        @scanners.select { |k, _| raw_date_literals || k != :datetime }.values
       end
 
       def whitespace
@@ -86,7 +91,7 @@ module Dentaku
 
       # NOTE: Convert to DateTime as Array(Time) returns the parts of the time for some reason
       def datetime
-        new(:datetime, /\d{2}\d{2}?-\d{1,2}-\d{1,2}( \d{1,2}:\d{1,2}:\d{1,2})? ?(Z|((\+|\-)\d{2}\:?\d{2}))?/, lambda { |raw| Time.parse(raw).to_datetime })
+        new(:datetime, DATE_TIME_REGEXP, lambda { |raw| Time.parse(raw).to_datetime })
       end
 
       def numeric
@@ -176,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/tokenizer.rb

@@ -4,7 +4,7 @@ require 'dentaku/token_scanner'
 
 module Dentaku
   class Tokenizer
-    attr_reader :case_sensitive, :aliases
+    attr_reader :aliases
 
     LPAREN = TokenMatcher.new(:grouping, :open)
     RPAREN = TokenMatcher.new(:grouping, :close)
@@ -15,10 +15,14 @@ module Dentaku
       @aliases = options.fetch(:aliases, global_aliases)
       input    = strip_comments(string.to_s.dup)
       input    = replace_aliases(input)
-      @case_sensitive = options.fetch(:case_sensitive, false)
+
+      scanner_options = {
+        case_sensitive: options.fetch(:case_sensitive, false),
+        raw_date_literals: options.fetch(:raw_date_literals, true)
+      }
 
       until input.empty?
-        scanned = TokenScanner.scanners(case_sensitive: case_sensitive).any? do |scanner|
+        scanned = TokenScanner.scanners(scanner_options).any? do |scanner|
           scanned, input = scan(input, scanner)
           scanned
         end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.1"
+  VERSION = "3.5.3"
 end

data/lib/dentaku/visitor/infix.rb

@@ -77,6 +77,10 @@ module Dentaku
       def visit_nil(node)
         process(node)
       end
+
+      def visit_array(node)
+        process(node)
+      end
     end
   end
 end

data/spec/ast/abs_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/abs'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Abs' do
+  it 'returns the absolute value of number' do
+    result = Dentaku('ABS(-4.2)')
+    expect(result).to eq(4.2)
+  end
+
+  it 'returns the correct value for positive number' do
+    result = Dentaku('ABS(1.3)')
+    expect(result).to eq(1.3)
+  end
+
+  it 'returns the correct value for zero' do
+    result = Dentaku('ABS(0)')
+    expect(result).to eq(0)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if argument is not numeric' do
+      expect { Dentaku!("ABS(2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+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

@@ -19,7 +19,7 @@ describe Dentaku::AST::All do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('ALL({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
-      Dentaku::ArgumentError, 'ALL() requires second argument to be an identifier'
+      Dentaku::ParseError, 'ALL() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/any_spec.rb

@@ -18,6 +18,6 @@ describe Dentaku::AST::Any do
   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)
+    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ParseError)
   end
 end

data/spec/ast/arithmetic_spec.rb

@@ -1,15 +1,14 @@
 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) }
-  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(: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)) }
+  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)
@@ -46,20 +45,70 @@ describe Dentaku::AST::Arithmetic do
     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")
+    int_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1"))
+    int_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1"))
+    decimal_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1.0"))
+    decimal_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1.0"))
+
+    [int_one, int_neg_one].permutation(2).each do |(left, right)|
+      expect(add(left, right).class).to eq(Integer)
+    end
 
-    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)
+    [decimal_one, decimal_neg_one].each do |left|
+      [int_one, int_neg_one, decimal_one, decimal_neg_one].each do |right|
+        expect(add(left, right).class).to eq(BigDecimal)
+      end
+    end
   end
 
   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/avg_spec.rb

@@ -3,6 +3,11 @@ require 'dentaku/ast/functions/avg'
 require 'dentaku'
 
 describe 'Dentaku::AST::Function::Avg' do
+  it 'returns the average of an array of Numeric values as BigDecimal' do
+    result = Dentaku('AVG(1, 2)')
+    expect(result).to eq(1.5)
+  end
+
   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)

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/filter_spec.rb

@@ -19,7 +19,7 @@ describe Dentaku::AST::Filter do
 
   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'
+      Dentaku::ParseError, 'FILTER() requires second argument to be an identifier'
     )
   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

@@ -21,7 +21,7 @@ describe Dentaku::AST::Map do
 
   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'
+      Dentaku::ParseError,  'MAP() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/pluck_spec.rb

@@ -21,7 +21,7 @@ describe Dentaku::AST::Pluck do
     expect do Dentaku.evaluate!('PLUCK(users, "age")', users: [
       {name: "Bob",  age: 44},
       {name: "Jane", age: 27}
-    ]) end.to raise_error(Dentaku::ArgumentError, 'PLUCK() requires second argument to be an identifier')
+    ]) end.to raise_error(Dentaku::ParseError, 'PLUCK() requires second argument to be an identifier')
   end
 
   it 'raises argument error if a non array of hashes is passed as collection' do

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

@@ -125,6 +125,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 +203,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

@@ -22,6 +22,7 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('(2 + 3) - 1')).to eq(4)
     expect(calculator.evaluate('(-2 + 3) - 1')).to eq(0)
     expect(calculator.evaluate('(-2 - 3) - 1')).to eq(-6)
+    expect(calculator.evaluate('1353+91-1-3322-22')).to eq(-1901)
     expect(calculator.evaluate('1 + -(2 ^ 2)')).to eq(-3)
     expect(calculator.evaluate('3 + -num', num: 2)).to eq(1)
     expect(calculator.evaluate('-num + 3', num: 2)).to eq(1)
@@ -158,6 +159,13 @@ 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')
@@ -165,6 +173,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)
@@ -179,6 +194,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
@@ -187,6 +206,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 }
 
@@ -210,10 +233,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
@@ -329,6 +353,11 @@ describe Dentaku::Calculator do
       }.not_to raise_error
     end
 
+    it 'allows to compare "-" or "-."' do
+      expect { calculator.solve("IF('-' =  '-', 0, 1)") }.not_to raise_error
+      expect { calculator.solve("IF('-.'= '-.', 0, 1)") }.not_to raise_error
+    end
+
     it "integrates with custom functions" do
       calculator.add_function(:custom, :integer, -> { 1 })
 
@@ -406,6 +435,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
@@ -440,19 +476,46 @@ describe Dentaku::Calculator do
     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)
+  describe 'disabling date literals' do
+    it 'does not parse formulas with minus signs as dates' do
+      calculator = described_class.new(raw_date_literals: false)
+      expect(calculator.evaluate!('2020-01-01')).to eq(2018)
+    end
+  end
+
+  describe 'supports date arithmetic' do
+    it 'from hardcoded string' 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
+
+    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 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 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
   end
 
   describe 'functions' do
@@ -471,6 +534,13 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
 
+    it 'include ABS' do
+      expect(calculator.evaluate('abs(-2.2)')).to eq(2.2)
+      expect(calculator.evaluate('abs(5)')).to eq(5)
+
+      expect(calculator.evaluate('ABS(x * -1)', x: 10)).to eq(10)
+    end
+
     it 'include NOT' do
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: true)).to be_falsey
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: false)).to be_truthy
@@ -486,6 +556,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
@@ -758,9 +835,9 @@ describe Dentaku::Calculator do
     end
   end
 
-  describe 'math functions' do
+  describe 'math support' do
     Math.methods(false).each do |method|
-      it method do
+      it "includes `#{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) + 1", x: 1, y: '2')).to be_within(0.00001).of(Math.send(method, 1, 2) + 1)
@@ -774,11 +851,16 @@ describe Dentaku::Calculator do
       end
     end
 
-    it 'are defined with a properly named class that represents it to support AST marshaling' do
+    it 'defines a properly named class to support AST marshaling' do
       expect {
         Marshal.dump(calculator.ast('SQRT(20)'))
       }.not_to raise_error
     end
+
+    it 'properly handles a Math::DomainError' do
+      expect(calculator.evaluate('asin(2)')).to be_nil
+      expect { calculator.evaluate!('asin(2)') }.to raise_error(Dentaku::MathDomainError)
+    end
   end
 
   describe 'disable_cache' do