dentaku 4.0.2 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 498d10748b47ba3ab1930e2d3df6685d8d557e1e4f7b95a0887952507557325a
-  data.tar.gz: a47a69280b8c298a299edbba9758b0dc132fdcceecb055eaa4008c0427d785de
+  metadata.gz: 75997c319d555caca8df23e6b1e1995f5a99b1fbd041f25d1e876ac40b487b49
+  data.tar.gz: ee629e3909f7b5040d9f39c1cad871f3d7599be8a76d6b2753652bcdbc9aefbc
 SHA512:
-  metadata.gz: '0466598da5b7018075787a018873cc72f4185faa40eabe3596b1666646625d70d29c199a8ac91d5fe0c4436d5b960f5cc9c95efbfe6ff2ea91a4855928074288'
-  data.tar.gz: '0440877441b431ffb55da23343fe1fff2271afd6ef4868f86a860927ba26f6e37ffa586514dee83a3c018cea4506615377e092ead2135b1cf39e440006a3a933'
+  metadata.gz: 4f7342cd68c9b1edbd2c992b01784a3b66caa6f13f0cc698a26447883a01eb6ffde1c6262790d9810ded42d5bdd6ac601ab2c7585e4c6d5f5467964cb6fe92ce
+  data.tar.gz: 8b1c85908541da4fe4896b3fcb90741fe8ea907c29fc162fcb64eca9ae60bd043ecdece5fe428490c0452a6f1072174a52b090ab575f50d117cbe3f976ad0265

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Change Log
 
+## [v4.1.0] 2026-10-14
+- `NumericParser` compiles its regular expressions once instead of on every
+  call. `Comparator#cast` runs one per string operand of every comparison,
+  which made the regex compilation the single largest cost of evaluating a
+  typical condition: `country = 'US'` evaluated 30k times drops from 0.47s
+  to 0.07s
+- fix dependency analysis of `AND` / `OR` chains taking exponential time
+  when a short-circuit probe raises (e.g. a zero denominator), a 4.0.0
+  regression on the normal `evaluate!` path (#355)
+- `duration()` only accepts exact unit names (`day`, `days`, `month`,
+  `months`, `year`, `years`); units merely containing one, such as
+  `dayofmonth`, are now rejected
+- `case_sensitive` is no longer shared between calculator instances. The
+  tokenizer read the setting from a class-level variable that every
+  calculator overwrote, so calculators with different settings running in
+  parallel threads could silently fold identifiers to the wrong case and
+  return wrong results. Casing is now applied only by the calculator's own
+  parser; `Tokenizer#tokenize` keeps identifiers' source casing and
+  `TokenScanner.case_sensitive` is removed
+- key the bulk-solver dependency-order cache by the resolved dependency graph,
+  so changing formulas or stored context cannot reuse an incompatible order
+  from another solve with the same variable names.
+- **behavior change:** `XOR` with three or more arguments is now the
+  exclusive OR of all of them (true when an odd number are true), matching
+  Excel and `XOR(XOR(a, b), c)`. It previously returned true only when
+  exactly one argument was true, so `XOR(true, true, true)` changes from
+  `false` to `true`. Results with one or two arguments are unchanged (#349)
+
 ## [v4.0.2] 2026-08-02
 - the 4.0.1 guard against arithmetic that rejects a well-typed operand only
   worked on Ruby 3.4+. Ruby 3.2 and 3.3 do not raise for an oversized

data/lib/dentaku/ast/combinators.rb

@@ -21,17 +21,35 @@ module Dentaku
         :logical
       end
 
+      # A short-circuit probe that raises tells us nothing about which operands are
+      # referenced, so fall back to the union of both sides. It has to be the union we
+      # already computed rather than `super`: `super` re-derives it by walking both
+      # subtrees again, and because the probe raises at every level of a chain, each
+      # level would walk its subtree twice -- making analysis exponential in the
+      # length of the chain.
       def dependencies(context = {})
         return super if static_mode?(context)
 
         left_deps = left.dependencies(context)
         right_deps = right.dependencies(context)
-        return [] if left_deps.empty? && left.pure? && decisive?(left.value(context))
-        return [] if right_deps.empty? && right.pure? && decisive?(right.value(context))
+
+        if left_deps.empty? && left.pure?
+          begin
+            return [] if decisive?(left.value(context))
+          rescue Dentaku::Error
+            return (left_deps + right_deps).uniq
+          end
+        end
+
+        if right_deps.empty? && right.pure?
+          begin
+            return [] if decisive?(right.value(context))
+          rescue Dentaku::Error
+            return (left_deps + right_deps).uniq
+          end
+        end
 
         (left_deps + right_deps).uniq
-      rescue Dentaku::Error
-        super
       end
 
       def value(context = {})

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

@@ -21,9 +21,9 @@ module Dentaku
 
         def validate_unit(unit)
           case unit.downcase
-          when /years?/ then :year
-          when /months?/ then :month
-          when /days?/ then :day
+          when /\Ayears?\z/ then :year
+          when /\Amonths?\z/ then :month
+          when /\Adays?\z/ then :day
           else
             raise Dentaku::ArgumentError.for(:incompatible_type, actual: unit, expected: Duration),
               "'#{unit || unit.class}' is not a valid duration unit"

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

@@ -20,14 +20,14 @@ module Dentaku
           )
         end
 
-        true_arg_count = 0
-        @args.each do |arg|
+        # exclusive OR of all arguments: true when an odd number are true, so
+        # XOR(a, b, c) == XOR(XOR(a, b), c)
+        true_arg_count = @args.count do |arg|
           case arg.value(context)
           when TrueClass
-            true_arg_count += 1
-            break if true_arg_count > 1
+            true
           when FalseClass, nil
-            next
+            false
           else
             raise Dentaku::ArgumentError.for(
               :incompatible_type,
@@ -35,7 +35,7 @@ module Dentaku
             )
           end
         end
-        true_arg_count == 1
+        true_arg_count.odd?
       end
     end
   end

data/lib/dentaku/bulk_expression_solver.rb

@@ -153,12 +153,15 @@ module Dentaku
     end
 
     def variables_in_resolve_order
-      cache_key = "#{!!calculator.case_sensitive}|#{expressions.keys.map(&:to_s).sort.join("|")}"
-      @ordered_deps ||= self.class.dependency_cache.fetch(cache_key) {
-        DependencyResolver.find_resolve_order(dependencies, calculator.case_sensitive).tap do |d|
-          self.class.dependency_cache[cache_key] = d if calculator.cache_dependency_order?
-        end
-      }
+      @ordered_deps ||= begin
+        dependency_graph = dependencies
+        cache_key = [!!calculator.case_sensitive, dependency_graph]
+        self.class.dependency_cache.fetch(cache_key) {
+          DependencyResolver.find_resolve_order(dependency_graph, calculator.case_sensitive).tap do |d|
+            self.class.dependency_cache[cache_key] = d if calculator.cache_dependency_order?
+          end
+        }
+      end
     end
   end
 end

data/lib/dentaku/numeric_parser.rb

@@ -5,20 +5,21 @@ module Dentaku
     HEXADECIMAL_PATTERN = '(0x[0-9a-f]+)\b'.freeze
     # e.g:  [0x1A3F]
 
+    NUMERIC_OR_HEXADECIMAL_REGEX = %r{\A(-?(#{ NUMERIC_PATTERN }|#{ HEXADECIMAL_PATTERN }))\z}i
+    NUMERIC_REGEX = %r{\A(#{ NUMERIC_PATTERN })\z}i
+    HEXADECIMAL_REGEX = %r{\A(#{ HEXADECIMAL_PATTERN })\z}i
+
     class << self
       def match(string)
-        regex = %r{\A(-?(#{ NUMERIC_PATTERN }|#{ HEXADECIMAL_PATTERN }))\z}i
-        string.match(regex)
+        string.match(NUMERIC_OR_HEXADECIMAL_REGEX)
       end
 
       def match_numeric(string)
-        regex = %r{\A(#{ NUMERIC_PATTERN })\z}i
-        string.match(regex)
+        string.match(NUMERIC_REGEX)
       end
 
       def match_hexadecimal(string)
-        regex = %r{\A(#{ HEXADECIMAL_PATTERN })\z}i
-        string.match(regex)
+        string.match(HEXADECIMAL_REGEX)
       end
 
       def parse_numeric_string(raw)

data/lib/dentaku/token_scanner.rb

@@ -1,13 +1,10 @@
 require 'bigdecimal'
 require 'time'
-require 'dentaku/string_casing'
 require 'dentaku/token'
 require 'dentaku/numeric_parser'
 
 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)
@@ -31,8 +28,6 @@ module Dentaku
     end
 
     class << self
-      attr_reader :case_sensitive
-
       def available_scanners
         [
           :null,
@@ -76,7 +71,6 @@ module Dentaku
       end
 
       def scanners(options = {})
-        @case_sensitive = options.fetch(:case_sensitive, false)
         raw_date_literals = options.fetch(:raw_date_literals, true)
 
         @scanners.select { |k, _| raw_date_literals || k != :datetime }.values
@@ -180,7 +174,7 @@ module Dentaku
       end
 
       def identifier
-        new(:identifier, '[[[:word:]]\.]+\b', lambda { |raw| standardize_case(raw.strip) })
+        new(:identifier, '[[[:word:]]\.]+\b', lambda { |raw| raw.strip })
       end
 
       def quoted_identifier

data/lib/dentaku/tokenizer.rb

@@ -17,7 +17,6 @@ module Dentaku
       input    = replace_aliases(input)
 
       scanner_options = {
-        case_sensitive: options.fetch(:case_sensitive, false),
         raw_date_literals: options.fetch(:raw_date_literals, true)
       }
 

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "4.0.2"
+  VERSION = "4.1.0"
 end

data/spec/ast/xor_spec.rb

@@ -15,9 +15,22 @@ describe 'Dentaku::AST::Xor' do
     expect(result).to eq(true)
   end
 
-  it 'returns false if more than one of the arguments is true' do
-    result = Dentaku('XOR(false, true, true)')
-    expect(result).to eq(false)
+  it 'returns false if an even number of the arguments are true' do
+    expect(Dentaku('XOR(false, true, true)')).to eq(false)
+    expect(Dentaku('XOR(true, true, true, true)')).to eq(false)
+  end
+
+  it 'returns true if an odd number of the arguments are true' do
+    expect(Dentaku('XOR(true, true, true)')).to eq(true)
+    expect(Dentaku('XOR(true, false, true, true)')).to eq(true)
+  end
+
+  it 'matches XOR applied pairwise' do
+    [true, false].repeated_permutation(4).each do |a, b, c, d|
+      context = { a: a, b: b, c: c, d: d }
+      expect(Dentaku('XOR(a, b, c, d)', context))
+        .to eq(Dentaku('XOR(XOR(a, b), XOR(c, d))', context))
+    end
   end
 
   it 'supports nested expressions' do

data/spec/bulk_expression_solver_spec.rb

@@ -8,6 +8,28 @@ RSpec.describe Dentaku::BulkExpressionSolver do
   let(:calculator) { Dentaku::Calculator.new }
 
   describe "#solve!" do
+    it 'does not reuse a cached order after formulas change with the same variable names' do
+      calculator = Dentaku::Calculator.new(cache_dependency_order: true)
+      calculator.store(seed: 1)
+      expect(calculator.solve!(a: 'b + 1', b: 'seed + 1')).to eq(a: 3, b: 2)
+      expect(calculator.solve!(a: 'seed + 1', b: 'a + 1')).to eq(a: 2, b: 3)
+    end
+
+    it 'does not share a cached order with a calculator using different dependencies' do
+      first = Dentaku::Calculator.new(cache_dependency_order: true).store(seed: 1)
+      second = Dentaku::Calculator.new(cache_dependency_order: true).store(seed: 10)
+      expect(first.solve!(left: 'right + 1', right: 'seed + 1')).to eq(left: 3, right: 2)
+      expect(second.solve!(left: 'seed + 1', right: 'left + 1')).to eq(left: 11, right: 12)
+    end
+
+    it 'includes memory-dependent edges in the cached order' do
+      first = Dentaku::Calculator.new(cache_dependency_order: true).store(seed: 1, base: 5)
+      second = Dentaku::Calculator.new(cache_dependency_order: true).store(seed: 1)
+      formulas = { result: 'base + 1', base: 'seed + 1' }
+      expect(first.solve!(formulas)).to eq(result: 6, base: 2)
+      expect(second.solve!(formulas)).to eq(result: 3, base: 2)
+    end
+
     it "evaluates properly with variables, even if some in memory" do
       expressions = {
         weekly_fruit_budget: "weekly_apple_budget + pear * 4",

data/spec/calculator_spec.rb

@@ -556,6 +556,14 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('value2 - value', { value: value, value2: value2 })).to eq(value2 - value)
       expect(calculator.evaluate!('value - 7200', { value: value })).to eq(Time.local(2023, 7, 13, 8, 42, 11))
     end
+
+    it 'does not accept unknown durations' do
+      expect { calculator.evaluate!('duration(1, foo)') }.to raise_error(Dentaku::ArgumentError, /is not a valid duration unit/)
+      expect { calculator.evaluate!('duration(1, ay)') }.to raise_error(Dentaku::ArgumentError, /is not a valid duration unit/)
+      expect { calculator.evaluate!('duration(1, daysy)') }.to raise_error(Dentaku::ArgumentError, /is not a valid duration unit/)
+      expect { calculator.evaluate!('duration(1, ayear)') }.to raise_error(Dentaku::ArgumentError, /is not a valid duration unit/)
+      expect { calculator.evaluate!('duration(1, dayofmonthofyear)') }.to raise_error(Dentaku::ArgumentError, /is not a valid duration unit/)
+    end
   end
 
   describe 'functions' do
@@ -1001,6 +1009,39 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'logical operators whose short-circuit probe raises' do
+    it 'falls back to the dependencies of both operands' do
+      expect(calculator.dependencies('a / b > 1 OR c', 'a' => 1, 'b' => 0)).to eq(['c'])
+      expect(calculator.dependencies('a <= 1 OR c', 'a' => nil)).to eq(['c'])
+    end
+
+    it 'still prunes when the probe is decisive' do
+      expect(calculator.dependencies('1 > 2 AND a')).to eq([])
+      expect(calculator.dependencies('1 < 2 OR a')).to eq([])
+      expect(calculator.dependencies('a AND 1 > 2')).to eq([])
+      expect(calculator.dependencies('a OR 1 < 2')).to eq([])
+    end
+
+    it 'still reports the other operand when the probe is not decisive' do
+      expect(calculator.dependencies('1 < 2 AND a')).to eq(['a'])
+      expect(calculator.dependencies('1 > 2 OR a')).to eq(['a'])
+    end
+
+    # Regression: the raising branch used to re-derive the dependency union via
+    # `super`, walking both subtrees a second time at every level of the chain.
+    # Twelve terms probed 2048 times instead of 12.
+    it 'probes each operand of a chain once rather than exponentially' do
+      call_count = { count: 0 }
+      calculator.add_function(:blank, :numeric, -> { call_count[:count] += 1; nil })
+
+      terms = 12
+      formula = (1..terms).map { |i| "(blank() <= #{i})" }.join(' OR ')
+
+      expect(calculator.evaluate(formula)).to be_nil
+      expect(call_count[:count]).to eq(terms)
+    end
+  end
+
   describe 'aliases' do
     it 'accepts aliases as instance option' do
       expect(with_aliases.evaluate('rrround(5.1)')).to eq(5)

data/spec/case_sensitivity_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  let(:case_sensitive)   { described_class.new(case_sensitive: true) }
+  let(:case_insensitive) { described_class.new }
+
+  it 'honours its own setting regardless of what other instances do' do
+    expect(case_sensitive.evaluate('Kiwi + 5', Kiwi: -2, kiwi: 2)).to eq(3)
+    expect(case_insensitive.evaluate('Kiwi + 5', Kiwi: -2, kiwi: 2)).to eq(7)
+
+    # same two settings, created and evaluated in the opposite order
+    other_sensitive   = described_class.new(case_sensitive: true)
+    other_insensitive = described_class.new
+    expect(other_insensitive.evaluate('Kiwi + 5', Kiwi: -2, kiwi: 2)).to eq(7)
+    expect(other_sensitive.evaluate('Kiwi + 5', Kiwi: -2, kiwi: 2)).to eq(3)
+  end
+
+  # Identifier casing used to be applied twice: once by the identifier scanner,
+  # reading a class-level flag on TokenScanner that every calculator in the
+  # process shared, and again by AST::Identifier using the calculator's own
+  # flag. The shared flag meant one instance could overwrite another's mode
+  # while the first was still tokenizing -- in practice, whenever two threads
+  # evaluated at the same time, identifiers silently folded to the other
+  # instance's casing.
+  #
+  # Reproduce that interleaving deterministically: once this calculator has
+  # fetched its scanners (which is when the mode used to be recorded), let a
+  # second, case-insensitive calculator tokenize before the first one scans its
+  # identifiers. The first calculator must be unaffected.
+  it 'is unaffected by another instance tokenizing while it scans' do
+    interloped = false
+    allow(Dentaku::TokenScanner).to receive(:scanners).and_wrap_original do |original, *args|
+      original.call(*args).tap do
+        next if interloped
+
+        interloped = true
+        case_insensitive.evaluate('Zz', Zz: 1)
+      end
+    end
+
+    expect(case_sensitive.evaluate('Kiwi', Kiwi: -2, kiwi: 2)).to eq(-2)
+    expect(case_insensitive.evaluate('Kiwi', Kiwi: -2, kiwi: 2)).to eq(2)
+  end
+
+  # casing is applied in exactly one place, AST::Identifier, which is handed
+  # the mode of the calculator that owns the parse -- so the token stream keeps
+  # the source casing of every identifier
+  it 'leaves identifier casing to the parser' do
+    tokens = Dentaku::Tokenizer.new.tokenize('Kiwi + 5')
+    expect(tokens.first.value).to eq('Kiwi')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 4.1.0
 platform: ruby
 authors:
 - Solomon White
@@ -175,6 +175,7 @@ files:
 - spec/benchmark.rb
 - spec/bulk_expression_solver_spec.rb
 - spec/calculator_spec.rb
+- spec/case_sensitivity_spec.rb
 - spec/dentaku_spec.rb
 - spec/dependency_resolver_spec.rb
 - spec/exceptions_spec.rb
@@ -215,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files: []