dentaku 3.5.3 → 3.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a51418767c413ccded1f235a56d34866005edf21cbc0d4cf5848d4cff4bc801f
-  data.tar.gz: 2009c09a76a5cc0b85cf04769c93f0d372cc8613f410a18401de53ca268b134d
+  metadata.gz: ef9e8cb8d852db9a8e4c81c28815c6a7e7008c6e9bebcc8a11222768756fd7a8
+  data.tar.gz: f7d1c005ef1ba8bcfc77fcac8b885378a0e3e36fdba8f97a2c602b6b0ba6f34c
 SHA512:
-  metadata.gz: 6cfeabc676fa63016096d2f3c291d60a68ce247fe7c75ba195cdc2968c28af85de9ab9eeaaa9e88749cbf7920a120b1e6fe4d78464b98f9c825180d42aafc4f1
-  data.tar.gz: 42863ad11afff2dc72dfe906d1fdc1c07821f4391dcb7fc67921d862c736350be15a6671beac9c16de9e1345f17869e0de40bb131bc1fcfea70190538274bd53
+  metadata.gz: 6d616fd597440c13e8432ac6f9d5480592cdcbb7e9aec30c1f2c21e94e0a4bcf3ffced31cf486dc7390bd8668bb5e377745a7eebf467edfab1cd5fa0ae4f70e9
+  data.tar.gz: fca27bf921a54469f065f634a44d4a6481c6420ccbcaa39400ffe4a5cdd172ff6ae209a04aee96208a64979bbff814635719732b557df33f7d406f87123b1c3a

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Change Log
 
-## [Unreleased]
+## [v3.5.4]
+- add support for default value for PLUCK function
+- improve error handling for MAP/ANY/ALL functions
+- fix modulo / percentage operator determination
+- fix string casing bug with bulk expressions
+- add explicit gem dependency for BigDecimal
+
+## [v3.5.3]
 - add support for empty array literals
 - add support for quoted identifiers
 - add REDUCE function
@@ -253,7 +260,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
-[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.2...HEAD
+[v3.5.4]: https://github.com/rubysolo/dentaku/compare/v3.5.3...v3.5.4
+[v3.5.3]: https://github.com/rubysolo/dentaku/compare/v3.5.2...v3.5.3
 [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/dentaku.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
     Dentaku is a parser and evaluator for mathematical formulas
   DESC
 
+  s.add_dependency('bigdecimal')
   s.add_dependency('concurrent-ruby')
 
   s.add_development_dependency('codecov')

data/lib/dentaku/ast/access.rb

@@ -17,9 +17,6 @@ module Dentaku
         arity
       end
 
-      def self.peek(*)
-      end
-
       def initialize(data_structure, index)
         @structure = data_structure
         @index = index

data/lib/dentaku/ast/arithmetic.rb

@@ -179,50 +179,42 @@ module Dentaku
 
     class Modulo < Arithmetic
       def self.arity
-        @arity
+        2
       end
 
-      def self.peek(input)
-        @arity = 1
-        @arity = 2 if input.length > 1
+      def self.precedence
+        20
       end
 
-      def initialize(left, right = nil)
-        if right
-          @left  = left
-          @right = right
-        else
-          @right = left
-        end
+      def self.resolve_class(next_token)
+        next_token.nil? || next_token.operator? || next_token.close? ? Percentage : self
+      end
+
+      def operator
+        :%
+      end
+    end
+
+    class Percentage < Arithmetic
+      def self.arity
+        1
+      end
+
+      def initialize(child)
+        @right = child
 
-        unless valid_left?
-          raise NodeError.new(%i[numeric nil], left.type, :left),
-                "#{self.class} requires numeric operands or nil"
-        end
         unless valid_right?
           raise NodeError.new(:numeric, right.type, :right),
-                "#{self.class} requires numeric operands"
+                "#{self.class} requires a numeric operand"
         end
       end
 
       def dependencies(context = {})
-        if percent?
-          @right.dependencies(context)
-        else
-          super
-        end
-      end
-
-      def percent?
-        left.nil?
+        @right.dependencies(context)
       end
 
       def value(context = {})
-        if percent?
-          cast(right.value(context)) * 0.01
-        else
-          super
-        end
+        cast(right.value(context)) * 0.01
       end
 
       def operator
@@ -230,11 +222,7 @@ module Dentaku
       end
 
       def self.precedence
-        20
-      end
-
-      def valid_left?
-        valid_node?(left) || left.nil?
+        30
       end
     end
 

data/lib/dentaku/ast/array.rb

@@ -14,9 +14,6 @@ module Dentaku
         Float::INFINITY
       end
 
-      def self.peek(*)
-      end
-
       def initialize(*elements)
         @elements = *elements
       end
@@ -32,7 +29,7 @@ module Dentaku
       def type
         nil
       end
-      
+
       def accept(visitor)
         visitor.visit_array(self)
       end

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

@@ -9,11 +9,7 @@ module Dentaku
         expression      = @args[2]
 
         collection.all? do |item_value|
-          expression.value(
-            context.merge(
-              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
-            )
-          )
+          mapped_value(expression, context, item_identifier => item_value)
         end
       end
     end

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

@@ -9,11 +9,7 @@ module Dentaku
         expression      = @args[2]
 
         collection.any? do |item_value|
-          expression.value(
-            context.merge(
-              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
-            )
-          )
+          mapped_value(expression, context, item_identifier => item_value)
         end
       end
     end

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

@@ -33,6 +33,19 @@ module Dentaku
       def validate_identifier(arg, message = "#{name}() requires second argument to be an identifier")
         raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
       end
+
+      private
+
+      def mapped_value(expression, context, item_context)
+        expression.value(
+          context.merge(
+            FlatHash.from_hash_with_intermediates(item_context)
+          )
+        )
+      rescue => e
+        raise e if context["__evaluation_mode"] == :strict
+        nil
+      end
     end
   end
 end

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

@@ -9,11 +9,7 @@ module Dentaku
         expression      = @args[2]
 
         collection.map do |item_value|
-          expression.value(
-            context.merge(
-              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
-            )
-          )
+          mapped_value(expression, context, item_identifier => item_value)
         end
       end
     end

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

@@ -9,19 +9,23 @@ module Dentaku
       end
 
       def self.max_param_count
-        2
+        3
       end
 
       def value(context = {})
         collection = Array(@args[0].value(context))
+
         unless collection.all? { |elem| elem.is_a?(Hash) }
           raise ArgumentError.for(:incompatible_type, value: collection),
                 'PLUCK() requires first argument to be an array of hashes'
         end
 
         pluck_path = @args[1].identifier
+        default    = @args[2]
 
-        collection.map { |h| h.transform_keys(&:to_s)[pluck_path] }
+        collection.map { |h|
+          h.transform_keys(&:to_s).fetch(pluck_path, default&.value(context))
+        }
       end
     end
   end

data/lib/dentaku/ast/node.rb

@@ -9,7 +9,8 @@ module Dentaku
         nil
       end
 
-      def self.peek(*)
+      def self.resolve_class(*)
+        self
       end
 
       def dependencies(context = {})

data/lib/dentaku/bulk_expression_solver.rb

@@ -6,16 +6,41 @@ require 'dentaku/tokenizer'
 
 module Dentaku
   class BulkExpressionSolver
+    class StrictEvaluator
+      def initialize(calculator)
+        @calculator = calculator
+      end
+
+      def evaluate(*args)
+        @calculator.evaluate!(*args)
+      end
+    end
+
+    class PermissiveEvaluator
+      def initialize(calculator, block)
+        @calculator = calculator
+        @block = block || ->(*) { :undefined }
+      end
+
+      def evaluate(*args)
+        @calculator.evaluate(*args) { |expr, ex|
+          @block.call(ex)
+        }
+      end
+    end
+
     def initialize(expressions, calculator)
       @expression_hash = FlatHash.from_hash(expressions)
       @calculator = calculator
     end
 
     def solve!
+      @evaluator = StrictEvaluator.new(calculator)
       solve(&raise_exception_handler)
     end
 
     def solve(&block)
+      @evaluator ||= PermissiveEvaluator.new(calculator, block)
       error_handler = block || return_undefined_handler
       results = load_results(&error_handler)
 
@@ -42,7 +67,7 @@ module Dentaku
       @dep_cache ||= {}
     end
 
-    attr_reader :expression_hash, :calculator
+    attr_reader :expression_hash, :calculator, :evaluator
 
     def return_undefined_handler
       ->(*) { :undefined }
@@ -52,8 +77,11 @@ module Dentaku
       ->(ex) { raise ex }
     end
 
-    def expression_with_exception_handler(&block)
-      ->(_expr, ex) { block.call(ex) }
+    def expression_with_exception_handler(var_name, &block)
+      ->(_expr, ex) {
+        ex.recipient_variable = var_name
+        block.call(ex)
+      }
     end
 
     def load_results(&block)
@@ -73,11 +101,14 @@ module Dentaku
         next if expressions[var_name].nil?
 
         with_rescues(var_name, results, block) do
-          results[var_name] = evaluated_facts[var_name] || calculator.evaluate!(
+          results[var_name] = evaluated_facts[var_name] || evaluator.evaluate(
             expressions[var_name],
             context.merge(results),
-            &expression_with_exception_handler(&block)
-          )
+            &expression_with_exception_handler(var_name, &block)
+          ).tap { |res|
+            res.recipient_variable = var_name if res.respond_to?(:recipient_variable=)
+            res
+          }
         end
       end
 
@@ -88,7 +119,6 @@ module Dentaku
 
     def with_rescues(var_name, results, block)
       yield
-
     rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
       ex.recipient_variable = var_name
       results[var_name] = block.call(ex)

data/lib/dentaku/calculator.rb

@@ -52,27 +52,39 @@ module Dentaku
     end
 
     def evaluate(expression, data = {}, &block)
-      evaluate!(expression, data)
+      context = evaluation_context(data, :permissive)
+      return evaluate_array(expression, context, &block) if expression.is_a?(Array)
+
+      evaluate!(expression, context)
     rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError => ex
       block.call(expression, ex) if block_given?
     end
 
+    private def evaluate_array(expression, data = {}, &block)
+      expression.map { |e| evaluate(e, data, &block) }
+    end
+
     def evaluate!(expression, data = {}, &block)
-      return expression.map { |e|
-        evaluate(e, data, &block)
-      } if expression.is_a? Array
+      context = evaluation_context(data, :strict)
+      return evaluate_array!(expression, context, &block) if expression.is_a? Array
 
-      store(data) do
+      store(context) do
         node = ast(expression)
         unbound = node.dependencies(memory)
+
         unless unbound.empty?
           raise UnboundVariableError.new(unbound),
                 "no value provided for variables: #{unbound.uniq.join(', ')}"
         end
+
         node.value(memory)
       end
     end
 
+    private def evaluate_array!(expression, data = {}, &block)
+      expression.map { |e| evaluate!(e, data, &block) }
+    end
+
     def solve!(expression_hash)
       BulkExpressionSolver.new(expression_hash, self).solve!
     end
@@ -130,6 +142,10 @@ module Dentaku
       end
     end
 
+    def evaluation_context(data, evaluation_mode)
+      data.key?(:__evaluation_mode) ? data : data.merge(__evaluation_mode: evaluation_mode)
+    end
+
     def store(key_or_hash, value = nil)
       restore = Hash[memory]
 

data/lib/dentaku/date_arithmetic.rb

@@ -13,13 +13,11 @@ module Dentaku
       when Numeric
         @base + duration
       when Dentaku::AST::Duration::Value
-        case duration.unit
-        when :year
-          Time.local(@base.year + duration.value, @base.month, @base.day).to_datetime
-        when :month
-          @base >> duration.value
-        when :day
-          @base + duration.value
+        case @base
+        when Time
+          change_datetime(@base.to_datetime, duration.unit, duration.value).to_time
+        else
+          change_datetime(@base, duration.unit, duration.value)
         end
       else
         raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
@@ -29,16 +27,14 @@ module Dentaku
 
     def sub(duration)
       case duration
-      when Date, DateTime, Numeric
+      when Date, DateTime, Numeric, Time
         @base - duration
       when Dentaku::AST::Duration::Value
-        case duration.unit
-        when :year
-          Time.local(@base.year - duration.value, @base.month, @base.day).to_datetime
-        when :month
-          @base << duration.value
-        when :day
-          @base - duration.value
+        case @base
+        when Time
+          change_datetime(@base.to_datetime, duration.unit, -duration.value).to_time
+        else
+          change_datetime(@base, duration.unit, -duration.value)
         end
       when Dentaku::TokenScanner::DATE_TIME_REGEXP
         @base - Time.parse(duration).to_datetime
@@ -47,5 +43,18 @@ module Dentaku
           "'#{duration || duration.class}' is not coercible for date arithmetic"
       end
     end
+
+    private
+
+    def change_datetime(base, unit, value)
+      case unit
+      when :year
+        base >> (value * 12)
+      when :month
+        base >> value
+      when :day
+        base + value
+      end
+    end
   end
 end

data/lib/dentaku/dependency_resolver.rb

@@ -4,13 +4,18 @@ module Dentaku
   class DependencyResolver
     include TSort
 
-    def self.find_resolve_order(vars_to_dependencies_hash)
-      self.new(vars_to_dependencies_hash).tsort
+    def self.find_resolve_order(vars_to_dependencies_hash, case_sensitive = false)
+      self.new(vars_to_dependencies_hash).sort
     end
 
     def initialize(vars_to_dependencies_hash)
-      # ensure variables are strings
-      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_s, v] }]
+      @key_mapping = Hash[vars_to_dependencies_hash.keys.map { |k| [k.downcase, k] }]
+      # ensure variables are normalized strings
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.downcase.to_s, v] }]
+    end
+
+    def sort
+      tsort.map { |k| @key_mapping.fetch(k, k) }
     end
 
     def tsort_each_node(&block)

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
@@ -100,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/version.rb

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

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/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/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)

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
@@ -165,7 +173,6 @@ describe Dentaku::Calculator do
       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')
@@ -516,6 +523,17 @@ describe Dentaku::Calculator do
       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
 
   describe 'functions' do

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

@@ -108,7 +108,7 @@ describe TestVisitor do
   it 'visits all concrete AST node types' do
     @visited = Set.new
 
-    visit_nodes('(1 + 7) * (8 ^ 2) / - 3.0 - apples')
+    visit_nodes('(1 + 7) * (8 ^ 2) / - 3.0 - apples * 5%')
     visit_nodes('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
     visit_nodes('IF(a[0] = NULL, "five", \'seven\')')
     visit_nodes('case (a % 5) when 0 then a else b end')

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.3
+  version: 3.5.4
 platform: ruby
 authors:
 - Solomon White
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-04 00:00:00.000000000 Z
+date: 2024-08-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -259,6 +273,7 @@ files:
 - spec/bulk_expression_solver_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
+- spec/dependency_resolver_spec.rb
 - spec/exceptions_spec.rb
 - spec/external_function_spec.rb
 - spec/parser_spec.rb
@@ -330,6 +345,7 @@ test_files:
 - spec/bulk_expression_solver_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
+- spec/dependency_resolver_spec.rb
 - spec/exceptions_spec.rb
 - spec/external_function_spec.rb
 - spec/parser_spec.rb