dentaku 3.5.2 → 3.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b10f7d9e6a9d200c283dcf077fd56e8f4abe4922c02e3095ba20dbb29f6b81c
-  data.tar.gz: add2d3bf7c462edefb9a4c52d79595d3a161e1d78046dbb1fe90e8aa9979a13b
+  metadata.gz: a51418767c413ccded1f235a56d34866005edf21cbc0d4cf5848d4cff4bc801f
+  data.tar.gz: 2009c09a76a5cc0b85cf04769c93f0d372cc8613f410a18401de53ca268b134d
 SHA512:
-  metadata.gz: 48c2571ea61f8bb9f8a7a4483b8d588741f2c44c4fdc2d04ecd2a5c5b75a94f414b5772a3e1dca21898f8d2ed6488e54925c6a689bfd721315c0c8e0992991d7
-  data.tar.gz: b469e9c4a69c6083b93cda29ea8bf5bf4ad9c91e4a6362e5880768492e21ecd476a09eb858134b8e6c78017207c6cf50479c7ebb3af661c7e20f3866f034b49a
+  metadata.gz: 6cfeabc676fa63016096d2f3c291d60a68ce247fe7c75ba195cdc2968c28af85de9ab9eeaaa9e88749cbf7920a120b1e6fe4d78464b98f9c825180d42aafc4f1
+  data.tar.gz: 42863ad11afff2dc72dfe906d1fdc1c07821f4391dcb7fc67921d862c736350be15a6671beac9c16de9e1345f17869e0de40bb131bc1fcfea70190538274bd53

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## [Unreleased]
+- add support for empty array literals
+- add support for quoted identifiers
+- add REDUCE function
+- add INTERCEPT function
+- improve date/time parsing an arithmetic
+- improve custom class arithmetic
+- fix IF dependency
+
 ## [v3.5.2]
 - add ABS function
 - add array support for AST visitors
@@ -244,6 +253,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.2...HEAD
 [v3.5.2]: https://github.com/rubysolo/dentaku/compare/v3.5.1...v3.5.2
 [v3.5.1]: https://github.com/rubysolo/dentaku/compare/v3.5.0...v3.5.1
 [v3.5.0]:  https://github.com/rubysolo/dentaku/compare/v3.4.2...v3.5.0

data/README.md

@@ -145,7 +145,7 @@ Comparison: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`,
 
 Logic: `IF`, `AND`, `OR`, `XOR`, `NOT`, `SWITCH`
 
-Numeric: `MIN`, `MAX`, `SUM`, `AVG`, `COUNT`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`, `ABS`
+Numeric: `MIN`, `MAX`, `SUM`, `AVG`, `COUNT`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`, `ABS`, `INTERCEPT`
 
 Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L593))
 

data/lib/dentaku/ast/arithmetic.rb

@@ -62,6 +62,8 @@ module Dentaku
 
       def decimal(val)
         BigDecimal(val.to_s, Float::DIG + 1)
+      rescue # return as is, in case value can't be coerced to big decimal
+        val
       end
 
       def datetime?(val)

data/lib/dentaku/ast/functions/if.rb

@@ -36,13 +36,9 @@ module Dentaku
       end
 
       def dependencies(context = {})
-        deps = predicate.dependencies(context)
-
-        if deps.empty?
-          predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
-        else
-          (deps + left.dependencies(context) + right.dependencies(context)).uniq
-        end
+        predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
+      rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError
+        args.flat_map { |arg| arg.dependencies(context) }.uniq
       end
     end
   end

data/lib/dentaku/ast/functions/intercept.rb

@@ -0,0 +1,33 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:intercept, :list, ->(*args) {
+  if args.length != 2
+    raise Dentaku::ArgumentError.for(
+        :wrong_number_of_arguments,
+        function_name: 'INTERCEPT()', exact: 2, given: args.length
+    ), 'INTERCEPT() requires exactly two arrays of numbers'
+  end
+
+  x_values, y_values = args
+  if !x_values.is_a?(Array) || !y_values.is_a?(Array) || x_values.length != y_values.length
+    raise Dentaku::ArgumentError.for(
+        :invalid_value,
+        function_name: 'INTERCEPT()'
+    ), 'INTERCEPT() requires arrays of equal length'
+  end
+
+  n = x_values.length.to_f
+  x_values = x_values.map { |arg| Dentaku::AST::Function.numeric(arg) }
+  y_values = y_values.map { |arg| Dentaku::AST::Function.numeric(arg) }
+
+  x_avg = x_values.sum / n
+  y_avg = y_values.sum / n
+
+  xy_sum = x_values.zip(y_values).map { |x, y| (x_avg - x) * (y_avg - y) }.sum
+  x_square_sum = x_values.map { |x| (x_avg - x)**2 }.sum
+
+  slope = xy_sum / x_square_sum
+  intercept = x_values.zip(y_values).map { |x, y| y - slope * x }.sum / n
+
+  BigDecimal(intercept, Float::DIG + 1)
+})

data/lib/dentaku/ast/functions/reduce.rb

@@ -0,0 +1,61 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Reduce < Function
+      def self.min_param_count
+        4
+      end
+
+      def self.max_param_count
+        5
+      end
+
+      def initialize(*args)
+        super
+
+        validate_identifier(@args[1], 'second')
+        validate_identifier(@args[2], 'third')
+      end
+
+      def dependencies(context = {})
+        collection      = @args[0]
+        memo_identifier = @args[1].identifier
+        item_identifier = @args[2].identifier
+        expression      = @args[3]
+
+        collection_deps = collection.dependencies(context)
+        expression_deps = expression.dependencies(context).reject do |i|
+          i == memo_identifier || i.start_with?("#{memo_identifier}.") ||
+          i == item_identifier || i.start_with?("#{item_identifier}.")
+        end
+        inital_value_deps = @args[4] ? @args[4].dependencies(context) : []
+
+        collection_deps + expression_deps + inital_value_deps
+      end
+
+      def value(context = {})
+        collection      = Array(@args[0].value(context))
+        memo_identifier = @args[1].identifier
+        item_identifier = @args[2].identifier
+        expression      = @args[3]
+        initial_value   = @args[4] && @args[4].value(context)
+
+        collection.reduce(initial_value) do |memo, item|
+          expression.value(
+            context.merge(
+              FlatHash.from_hash_with_intermediates(memo_identifier => memo, item_identifier => item)
+            )
+          )
+        end
+      end
+
+      def validate_identifier(arg, position, message = "#{name}() requires #{position} argument to be an identifier")
+        raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:reduce, Dentaku::AST::Reduce)

data/lib/dentaku/ast.rb

@@ -24,12 +24,14 @@ require_relative './ast/functions/count'
 require_relative './ast/functions/duration'
 require_relative './ast/functions/filter'
 require_relative './ast/functions/if'
+require_relative './ast/functions/intercept'
 require_relative './ast/functions/map'
 require_relative './ast/functions/max'
 require_relative './ast/functions/min'
 require_relative './ast/functions/not'
 require_relative './ast/functions/or'
 require_relative './ast/functions/pluck'
+require_relative './ast/functions/reduce'
 require_relative './ast/functions/round'
 require_relative './ast/functions/rounddown'
 require_relative './ast/functions/roundup'
@@ -37,4 +39,4 @@ require_relative './ast/functions/ruby_math'
 require_relative './ast/functions/string_functions'
 require_relative './ast/functions/sum'
 require_relative './ast/functions/switch'
-require_relative './ast/functions/xor'
+require_relative './ast/functions/xor'

data/lib/dentaku/calculator.rb

@@ -63,8 +63,7 @@ module Dentaku
       } if expression.is_a? Array
 
       store(data) do
-        node = expression
-        node = ast(node) unless node.is_a?(AST::Node)
+        node = ast(expression)
         unbound = node.dependencies(memory)
         unless unbound.empty?
           raise UnboundVariableError.new(unbound),
@@ -96,6 +95,7 @@ module Dentaku
     end
 
     def ast(expression)
+      return expression if expression.is_a?(AST::Node)
       return expression.map { |e| ast(e) } if expression.is_a? Array
 
       @ast_cache.fetch(expression) {

data/lib/dentaku/date_arithmetic.rb

@@ -29,7 +29,7 @@ module Dentaku
 
     def sub(duration)
       case duration
-      when DateTime, Numeric
+      when Date, DateTime, Numeric
         @base - duration
       when Dentaku::AST::Duration::Value
         case duration.unit
@@ -40,6 +40,8 @@ module Dentaku
         when :day
           @base - duration.value
         end
+      when Dentaku::TokenScanner::DATE_TIME_REGEXP
+        @base - Time.parse(duration).to_datetime
       else
         raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
           "'#{duration || duration.class}' is not coercible for date arithmetic"

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

@@ -60,10 +60,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)

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.3"
 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/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/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

@@ -159,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')
@@ -166,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)
@@ -180,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
@@ -188,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 }
 
@@ -211,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
@@ -412,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
@@ -471,16 +501,20 @@ 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
   end
 
@@ -522,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

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
 

data/spec/visitor_spec.rb

@@ -122,6 +122,7 @@ describe TestVisitor do
     visit_nodes('duration(1, day)')
     visit_nodes('MAP(vals, val, val + 1)')
     visit_nodes('FILTER(vals, val, val > 1)')
+    visit_nodes('REDUCE(vals, memo, val, memo + val)')
 
     @expected = Set.new(Dentaku::AST::constants - generic_subclasses)
     expect(@visited.sort).to eq(@expected.sort)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.2
+  version: 3.5.3
 platform: ruby
 authors:
 - Solomon White
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-07 00:00:00.000000000 Z
+date: 2024-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -180,6 +180,7 @@ files:
 - lib/dentaku/ast/functions/enum.rb
 - lib/dentaku/ast/functions/filter.rb
 - lib/dentaku/ast/functions/if.rb
+- lib/dentaku/ast/functions/intercept.rb
 - lib/dentaku/ast/functions/map.rb
 - lib/dentaku/ast/functions/max.rb
 - lib/dentaku/ast/functions/min.rb
@@ -187,6 +188,7 @@ files:
 - lib/dentaku/ast/functions/not.rb
 - lib/dentaku/ast/functions/or.rb
 - lib/dentaku/ast/functions/pluck.rb
+- lib/dentaku/ast/functions/reduce.rb
 - lib/dentaku/ast/functions/round.rb
 - lib/dentaku/ast/functions/rounddown.rb
 - lib/dentaku/ast/functions/roundup.rb
@@ -235,6 +237,7 @@ files:
 - spec/ast/division_spec.rb
 - spec/ast/filter_spec.rb
 - spec/ast/function_spec.rb
+- spec/ast/intercept_spec.rb
 - spec/ast/map_spec.rb
 - spec/ast/max_spec.rb
 - spec/ast/min_spec.rb
@@ -244,6 +247,7 @@ files:
 - spec/ast/numeric_spec.rb
 - spec/ast/or_spec.rb
 - spec/ast/pluck_spec.rb
+- spec/ast/reduce_spec.rb
 - spec/ast/round_spec.rb
 - spec/ast/rounddown_spec.rb
 - spec/ast/roundup_spec.rb
@@ -285,7 +289,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.9
 signing_key:
 specification_version: 4
 summary: A formula language parser and evaluator
@@ -304,6 +308,7 @@ test_files:
 - spec/ast/division_spec.rb
 - spec/ast/filter_spec.rb
 - spec/ast/function_spec.rb
+- spec/ast/intercept_spec.rb
 - spec/ast/map_spec.rb
 - spec/ast/max_spec.rb
 - spec/ast/min_spec.rb
@@ -313,6 +318,7 @@ test_files:
 - spec/ast/numeric_spec.rb
 - spec/ast/or_spec.rb
 - spec/ast/pluck_spec.rb
+- spec/ast/reduce_spec.rb
 - spec/ast/round_spec.rb
 - spec/ast/rounddown_spec.rb
 - spec/ast/roundup_spec.rb