dentaku 3.5.8 → 4.0.1

data/spec/ast/arithmetic_spec.rb

@@ -123,6 +123,99 @@ describe Dentaku::AST::Arithmetic do
     expect { add(x, one, 'x' => [1]) }.to raise_error(Dentaku::ArgumentError)
   end
 
+  describe 'parse-time operand validation (#197)' do
+    let(:calculator) do
+      Dentaku::Calculator.new.tap do |c|
+        c.add_function(:explode, :numeric, ->(*) { raise "function executed at parse time" })
+        c.add_function(:explode_flag, :logical, ->(*) { raise "function executed at parse time" })
+      end
+    end
+
+    it 'does not execute functions when an IF is an arithmetic operand' do
+      expect {
+        calculator.ast("IF(explode(1) = 1, 1, 2) + category")
+      }.not_to raise_error
+    end
+
+    it 'does not execute functions when an IF is negated' do
+      expect {
+        calculator.ast("-IF(explode(1) = 1, 1, 2)")
+      }.not_to raise_error
+    end
+
+    it 'does not execute functions when an IF is a combinator operand' do
+      expect {
+        calculator.ast("IF(explode_flag(), true, false) AND x")
+      }.not_to raise_error
+    end
+
+    it 'does not execute functions when a CASE is an arithmetic operand' do
+      expect {
+        calculator.ast("(CASE explode(1) WHEN 1 THEN 1 ELSE 2 END) + category")
+      }.not_to raise_error
+    end
+
+    it 'reports identifiers across both branches without evaluating' do
+      expect(calculator.identifiers("IF(explode(1) = 1, 1, 2) + category")).to eq(["category"])
+    end
+
+    it 'still validates operand types' do
+      expect { Dentaku::Calculator.new.ast("'abc' + 1") }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'leaves evaluation and short-circuiting unchanged' do
+      plain = Dentaku::Calculator.new
+
+      expect(plain.evaluate!("IF(a = 1, 10, 20) + 5", a: 1)).to eq(15)
+      expect(plain.evaluate!("IF(a = 1, 10, 20) + 5", a: 2)).to eq(25)
+      expect(plain.evaluate!("-IF(a = 1, 10, 20)", a: 1)).to eq(-10)
+      expect(plain.dependencies("IF(a, b, c)", a: true)).to eq(["b"])
+    end
+  end
+
+  describe 'operations that reject well-typed operands (#332)' do
+    let(:oversized) { "999999999999999 ^ 99999999999999" }
+
+    it 'wraps the raw Ruby error so it is a Dentaku::Error' do
+      expect {
+        Dentaku::Calculator.new.evaluate!(oversized)
+      }.to raise_error(Dentaku::ArgumentError, /exponent is too large/)
+    end
+
+    it 'is rescuable as Dentaku::Error' do
+      error = begin
+        Dentaku::Calculator.new.evaluate!(oversized)
+        nil
+      rescue Dentaku::Error => e
+        e
+      end
+
+      expect(error).to be_a(Dentaku::ArgumentError)
+    end
+
+    it 'returns nil from the non-bang evaluate rather than raising' do
+      expect(Dentaku::Calculator.new.evaluate(oversized)).to be_nil
+      expect(Dentaku::Calculator.new.evaluate("2 ^ 99999999999")).to be_nil
+    end
+
+    it 'yields to the block form' do
+      handled = nil
+      Dentaku::Calculator.new.evaluate(oversized) { |_expr, ex| handled = ex }
+
+      expect(handled).to be_a(Dentaku::ArgumentError)
+    end
+
+    it 'still evaluates exponentiation that fits' do
+      expect(Dentaku::Calculator.new.evaluate!("2 ^ 10")).to eq(1024)
+    end
+
+    it 'does not swallow Dentaku errors raised by the operation itself' do
+      expect {
+        Dentaku::Calculator.new.evaluate!("1 / 0")
+      }.to raise_error(Dentaku::ZeroDivisionError)
+    end
+  end
+
   private
 
   def add(left, right, context = ctx)

data/spec/ast/case_spec.rb

@@ -80,5 +80,12 @@ describe Dentaku::AST::Case do
       node = described_class.new(switch, conditional1, conditional2, else2)
       expect(node.dependencies).to eq([:fruit, :tax, :fallback])
     end
+
+    it 'short-circuits to the matched branch when the switch is resolvable' do
+      node = described_class.new(switch, conditional1, conditional2, else2)
+      expect(node.dependencies(fruit: 'apple')).to eq([])
+      expect(node.dependencies(fruit: 'banana')).to eq([:tax])
+      expect(node.dependencies(fruit: 'orange')).to eq([:fallback])
+    end
   end
 end

data/spec/bulk_expression_solver_spec.rb

@@ -195,7 +195,7 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       described_class.new(expressions, calculator).solve do |ex|
         exception = ex
       end
-      expect(exception.recipient_variable).to eq('more_apples')
+      expect(exception.assigned_to).to eq('more_apples')
     end
 
     it 'stores the recipient variable on the exception when there is an unbound variable' do
@@ -204,7 +204,17 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       described_class.new(expressions, calculator).solve do |ex|
         exception = ex
       end
-      expect(exception.recipient_variable).to eq('more_apples')
+      expect(exception.assigned_to).to eq('more_apples')
+    end
+
+    it 'sets the recipient variable before the solve block is invoked' do
+      expressions = {more_apples: "apples + 1"}
+      seen = :unset
+      described_class.new(expressions, calculator).solve do |ex|
+        seen = ex.assigned_to
+        :err
+      end
+      expect(seen).to eq('more_apples')
     end
 
     it 'stores the recipient variable on the exception when there is an ArgumentError' do
@@ -213,7 +223,7 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       described_class.new(expressions, calculator).solve do |ex|
         exception = ex
       end
-      expect(exception.recipient_variable).to eq('more_apples')
+      expect(exception.assigned_to).to eq('more_apples')
     end
 
     it 'safely handles argument errors' do

data/spec/calculator_spec.rb

@@ -195,6 +195,21 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('a[x+1]', x: 1)).to eq(3)
     end
 
+    it 'accesses into strings and nested arrays' do
+      expect(calculator.evaluate!('a[1]', a: 'abc')).to eq('b')
+      expect(calculator.evaluate!('a[1][0]', a: [[1], [2, 3]])).to eq(2)
+    end
+
+    it 'raises an argument error when accessing into a non-indexable value' do
+      expect { calculator.evaluate!('a[0]', a: 5) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('a[0]', a: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('a[0]', a: true) }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an argument error when the index type is incompatible' do
+      expect { calculator.evaluate!("a['one']", a: [1, 2, 3]) }.to raise_error(Dentaku::ArgumentError)
+    end
+
     it 'evaluates arrays' do
       expect(calculator.evaluate([1, 2, 3])).to eq([1, 2, 3])
       expect(calculator.evaluate!('{1,2,3}')).to eq([1, 2, 3])
@@ -967,6 +982,25 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'logical operators with unbound operands' do
+    it 'short-circuits OR when the bound operand is true' do
+      expect(calculator.evaluate!('a OR b', a: true)).to eq(true)
+      expect(calculator.evaluate!('a OR b', b: true)).to eq(true)
+    end
+
+    it 'short-circuits AND when the bound operand is false' do
+      expect(calculator.evaluate!('a AND b', a: false)).to eq(false)
+      expect(calculator.evaluate!('a AND b', b: false)).to eq(false)
+    end
+
+    it 'still raises when the unbound operand is needed to decide' do
+      expect { calculator.evaluate!('a OR b', a: false) }
+        .to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('a AND b', a: true) }
+        .to raise_error(Dentaku::UnboundVariableError)
+    end
+  end
+
   describe 'aliases' do
     it 'accepts aliases as instance option' do
       expect(with_aliases.evaluate('rrround(5.1)')).to eq(5)
@@ -975,6 +1009,39 @@ describe Dentaku::Calculator do
     it 'accepts aliases with whitespace before parentheses' do
       expect(with_aliases.evaluate('rrround (5.1)')).to eq(5)
     end
+
+    it 'applies module-level aliases set after calculator creation' do
+      Dentaku.aliases = { round: ['redondear'] }
+      expect(calculator.evaluate('redondear(5.1)')).to eq(5)
+    ensure
+      Dentaku.aliases = {}
+    end
+  end
+
+  describe 'constructor options' do
+    it 'raises on unknown options' do
+      expect { described_class.new(case_sensitve: true) }
+        .to raise_error(::ArgumentError, /unknown keyword/)
+    end
+
+    it 'accepts a pre-warmed AST cache' do
+      node = calculator.ast('1+1')
+      warmed = described_class.new(ast_cache: { '1+1' => node })
+      expect(warmed.ast_cache).to eq('1+1' => node)
+    end
+
+    it 'caches ASTs when caching is enabled on the instance' do
+      caching = described_class.new(cache_ast: true)
+      caching.ast('1+1')
+      expect(caching.ast_cache.keys).to eq(['1+1'])
+    end
+
+    it 'does not cache ASTs when disabled on the instance, even if enabled globally' do
+      allow(Dentaku).to receive(:cache_ast?) { true }
+      non_caching = described_class.new(cache_ast: false)
+      non_caching.ast('1+1')
+      expect(non_caching.ast_cache).to be_empty
+    end
   end
 
   describe 'nested_data' do
@@ -1009,5 +1076,84 @@ describe Dentaku::Calculator do
         called
       }.from(12).to(1)
     end
+
+    it 'does not carry cached identifier values across evaluations' do
+      # there is no public disable, so save/restore around the example
+      was_enabled = Dentaku.cache_identifier?
+      Dentaku.enable_identifier_cache!
+      called = 0
+      calculator.store_formula("A1", "B1+B1")
+      calculator.store_formula("B1", "C1")
+      calculator.store("C1", proc { called += 1; 1 })
+
+      calculator.evaluate("A1")
+      after_first = called
+      calculator.evaluate("A1")
+
+      expect(after_first).to be > 0
+      expect(called).to eq(after_first * 2)
+    ensure
+      Dentaku.instance_variable_set(:@enable_identifier_caching, was_enabled)
+    end
+  end
+
+  describe 'block-scoped store (#336)' do
+    it 'removes keys the block introduced' do
+      calculator.store(a: 1)
+      result = calculator.store(b: 2) { calculator.evaluate!("a + b") }
+
+      expect(result).to eq(3)
+      expect(calculator.memory.keys).to eq(["a"])
+    end
+
+    it 'restores keys the block shadowed' do
+      calculator.store(a: 1)
+      inner = calculator.store(a: 99) { calculator.evaluate!("a") }
+
+      expect(inner).to eq(99)
+      expect(calculator.evaluate!("a")).to eq(1)
+    end
+
+    it 'restores when the block raises' do
+      calculator.store(a: 1)
+
+      expect {
+        calculator.store(a: 99) { raise "boom" }
+      }.to raise_error("boom")
+
+      expect(calculator.evaluate!("a")).to eq(1)
+      expect(calculator.memory.keys).to eq(["a"])
+    end
+
+    it 'restores correctly when nested' do
+      calculator.store(a: 1)
+      innermost = calculator.store(a: 2) { calculator.store(a: 3) { calculator.evaluate!("a") } }
+
+      expect(innermost).to eq(3)
+      expect(calculator.evaluate!("a")).to eq(1)
+    end
+
+    it 'does not leak the internal evaluation mode key into memory' do
+      calculator.store(a: 1)
+      calculator.evaluate("a + 1")
+
+      expect(calculator.memory.keys).to eq(["a"])
+    end
+
+    it 'restores in place rather than copying the whole memory hash' do
+      # the old implementation snapshotted memory up front and reassigned
+      # @memory to the snapshot, so evaluation cost scaled with memory size.
+      # Restoring in place keeps the same hash object throughout.
+      was_enabled = Dentaku.cache_identifier?
+      Dentaku.instance_variable_set(:@enable_identifier_caching, false)
+
+      calculator.store(a: 1, b: 2)
+      before = calculator.memory.object_id
+
+      expect(calculator.evaluate!("a + b")).to eq(3)
+      expect(calculator.memory.object_id).to eq(before)
+    ensure
+      Dentaku.instance_variable_set(:@enable_identifier_caching, was_enabled)
+    end
   end
 end

data/spec/exceptions_spec.rb

@@ -7,3 +7,90 @@ describe Dentaku::UnboundVariableError do
     expect(exception.unbound_variables).to include('length')
   end
 end
+
+describe Dentaku::Error do
+  it 'is included in every Dentaku exception, even those subclassing Ruby built-ins' do
+    [
+      Dentaku::UnboundVariableError.new(['x']),
+      Dentaku::MathDomainError.new(:asin, [2]),
+      Dentaku::NodeError.new(:numeric, :string, :left),
+      Dentaku::ParseError.for(:node_invalid),
+      Dentaku::TokenizerError.for(:parse_error),
+      Dentaku::ArgumentError.for(:invalid_value),
+      Dentaku::ZeroDivisionError.new,
+    ].each do |exception|
+      expect(exception).to be_a(described_class)
+    end
+  end
+
+  it 'preserves stdlib ancestry for exceptions subclassing Ruby built-ins' do
+    expect(Dentaku::ArgumentError.for(:invalid_value)).to be_a(::ArgumentError)
+    expect(Dentaku::ZeroDivisionError.new).to be_a(::ZeroDivisionError)
+  end
+end
+
+describe Dentaku::ParseError do
+  it 'builds a message from reason and metadata' do
+    exception = described_class.for(:too_few_operands, operation: Dentaku::AST::Addition, expected: 2, actual: 1)
+    expect(exception.message).to eq('Dentaku::AST::Addition has too few operands (given 1, expected 2)')
+  end
+
+  it 'constructs with sparse metadata' do
+    expect(described_class.for(:node_invalid).message).to eq('Node is invalid')
+  end
+
+  it 'describes an :incompatible expectation as requiring compatible operands' do
+    exception = described_class.for(:node_invalid, operation: Dentaku::AST::Addition, expected: :incompatible, actual: :string)
+    expect(exception.message).to eq('Dentaku::AST::Addition requires compatible operands, but got string')
+  end
+
+  it 'allows call sites to override the default message' do
+    expect {
+      raise described_class.for(:node_invalid), 'Case missing switch variable'
+    }.to raise_error(described_class, 'Case missing switch variable')
+  end
+end
+
+describe Dentaku::TokenizerError do
+  it 'builds a message from reason and metadata' do
+    exception = described_class.for(:parse_error, at: '$5')
+    expect(exception.message).to eq("parse error at: '$5'")
+  end
+end
+
+describe Dentaku::ArgumentError do
+  it 'builds an incompatible_type message from a function context' do
+    exception = described_class.for(:incompatible_type, function_name: 'AND', expected: :logical, actual: 5)
+    expect(exception.message).to eq('AND() requires logical arguments, but got Integer')
+  end
+
+  it 'builds an incompatible_type message from expected and actual' do
+    exception = described_class.for(:incompatible_type, expected: Integer, actual: 2.5)
+    expect(exception.message).to eq('Float is not compatible with Integer')
+  end
+
+  it 'builds an invalid_operator message' do
+    exception = described_class.for(:invalid_operator, operation: Dentaku::AST::Addition, operator: :+)
+    expect(exception.message).to eq('Dentaku::AST::Addition requires operands that respond to +')
+  end
+
+  it 'describes an at-least arity as a range' do
+    exception = described_class.for(:too_few_arguments, function_name: 'SUM', expected: 1.., actual: 0)
+    expect(exception.message).to eq('SUM() has too few arguments (given 0, expected at least 1)')
+  end
+
+  it 'describes an exact arity as a count' do
+    exception = described_class.for(:wrong_number_of_arguments, function_name: 'INTERCEPT', expected: 2, actual: 4)
+    expect(exception.message).to eq('INTERCEPT() has the wrong number of arguments (given 4, expected 2)')
+  end
+
+  it 'constructs with sparse metadata' do
+    expect(described_class.for(:invalid_value).message).to eq('Invalid value')
+  end
+
+  it 'allows call sites to override the default message' do
+    expect {
+      raise described_class.for(:invalid_value), 'INTERCEPT() requires arrays of equal length'
+    }.to raise_error(described_class, 'INTERCEPT() requires arrays of equal length')
+  end
+end

data/spec/external_function_spec.rb

@@ -109,6 +109,7 @@ describe Dentaku::Calculator do
       end
 
       it 'exposes the `callback` method of a function' do
+        custom_calculator # the `let` is lazy, and it is what registers the function
         expect(Dentaku::AST::Function::Callback_lambda.callback.call()).to eq("lambda executed")
       end
 
@@ -155,6 +156,38 @@ describe Dentaku::Calculator do
       }.to raise_error(Dentaku::ParseError)
     end
 
+    describe 'error messages (#264)' do
+      it 'names the function even when another calculator claimed the constant' do
+        messages = 2.times.map do
+          calculator = described_class.new
+          calculator.add_function(:custom, :integer, -> { 1 })
+
+          begin
+            calculator.ast("CUSTOM(1,2)")
+            nil
+          rescue Dentaku::ParseError => e
+            e.message
+          end
+        end
+
+        expect(messages).to all(include("Dentaku::AST::Function::Custom"))
+        messages.each { |message| expect(message).not_to include("#<Class:") }
+      end
+
+      it 'gives re-registered functions a stable string representation' do
+        first = described_class.new
+        first.add_function(:repeated, :numeric, ->(x) { x })
+        second = described_class.new
+        second.add_function(:repeated, :numeric, ->(x) { x * 2 })
+
+        registry = ->(c) { c.instance_variable_get(:@function_registry).get("repeated") }
+
+        expect(registry.call(second).to_s).to eq("Dentaku::AST::Function::Repeated")
+        expect(registry.call(second).to_s).to eq(registry.call(first).to_s)
+        expect(registry.call(second).name).to eq("repeated")
+      end
+    end
+
     describe 'Dentaku::Calculator.add_function' do
       it 'adds a function to default/global function registry' do
         described_class.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })

data/spec/gemspec_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'dentaku.gemspec' do
+  # tsort no longer ships as a default gem in Ruby 4.1 (PR #334)
+  it 'declares tsort as a runtime dependency' do
+    gemspec = Gem::Specification.load(File.expand_path('../dentaku.gemspec', __dir__))
+    runtime_deps = gemspec.dependencies.select { |d| d.type == :runtime }.map(&:name)
+    expect(runtime_deps).to include('tsort')
+  end
+end

data/spec/identifiers_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  describe '#identifiers' do
+    let(:calculator) { described_class.new }
+
+    it 'does not prune literal guards' do
+      expect(calculator.identifiers('IF(1 > 0, a, b)')).to eq(%w(a b))
+    end
+
+    it 'includes the guard identifiers themselves' do
+      expect(calculator.identifiers('IF(x > 5, y, z)')).to eq(%w(x y z))
+    end
+
+    it 'never executes functions, pure or volatile' do
+      count = { pure: 0, volatile: 0 }
+      calculator.add_function(:purefn, :numeric, ->(x) { count[:pure] += 1; x })
+      calculator.add_function(:volfn, :numeric, ->(x) { count[:volatile] += 1; x }, volatile: true)
+
+      expect(calculator.identifiers('IF(purefn(1) > 0, a, IF(volfn(2) > 0, b, c))')).to eq(%w(a b c))
+      expect(count).to eq(pure: 0, volatile: 0)
+    end
+
+    it 'includes switch and every branch of CASE' do
+      formula = 'CASE fruit WHEN w1 THEN t1 WHEN 2 THEN t2 ELSE e1 END'
+      expect(calculator.identifiers(formula)).to eq(%w(fruit w1 t1 t2 e1))
+    end
+
+    it 'includes both operands of AND/OR even when one is decisive' do
+      expect(calculator.identifiers('1 > 2 AND x')).to eq(['x'])
+      expect(calculator.identifiers('a AND b OR c')).to eq(%w(a b c))
+    end
+
+    it 'excludes enum-bound variables' do
+      expect(calculator.identifiers('MAP(users, u, u.age + bonus)')).to eq(%w(users bonus))
+    end
+
+    it 'ignores stored memory' do
+      calculator.store(a: 1)
+      expect(calculator.identifiers('a + b')).to eq(%w(a b))
+    end
+
+    it 'accepts an AST node' do
+      node = calculator.ast('x + y')
+      expect(calculator.identifiers(node)).to eq(%w(x y))
+    end
+
+    it 'accepts an array of expressions and deduplicates' do
+      expect(calculator.identifiers(['a + b', 'b + c'])).to eq(%w(a b c))
+    end
+
+    it 'deduplicates repeated identifiers' do
+      expect(calculator.identifiers('a + a * a')).to eq(['a'])
+    end
+
+    it 'lists all inputs of a formula using external-state functions' do
+      user_attr = ->(name, default = 0) { default }
+      calculator.add_function(:user_attr, :numeric, user_attr)
+
+      identifiers = calculator.identifiers("IF(user_attr('level') > 50, high_level_value, low_level_value)")
+      expect(identifiers).to eq(%w(high_level_value low_level_value))
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -84,6 +84,17 @@ describe Dentaku::Parser do
     expect(node.value("x" => 1, "y" => "A", "Y" => "B")).to eq(3)
   end
 
+  it 'evaluates a case statement with an unparenthesized operation as switch' do
+    node = parse('CASE a % 5 WHEN 0 THEN a ELSE b END')
+    expect(node.value("a" => 10, "b" => 1)).to eq(10)
+    expect(node.value("a" => 7, "b" => 1)).to eq(1)
+  end
+
+  it 'evaluates a case statement with a comparator as switch' do
+    node = parse('CASE a > 5 WHEN true THEN a ELSE b END')
+    expect(node.value("a" => 10, "b" => 1)).to eq(10)
+  end
+
   it 'evaluates arrays' do
     node = parse('{}')
     expect(node.value).to eq([])
@@ -111,6 +122,21 @@ describe Dentaku::Parser do
       }.to raise_error(Dentaku::ParseError)
     end
 
+    it 'preserves the node-level message for incompatible operands' do
+      expect {
+        parse('"hello" + 1')
+      }.to raise_error(
+        Dentaku::ParseError,
+        /requires operands that are numeric or compatible types, not string/
+      )
+    end
+
+    it 'preserves the node-level message for non-logical combinator operands' do
+      expect {
+        parse('1 AND 2')
+      }.to raise_error(Dentaku::ParseError, /requires logical operands/)
+    end
+
     it 'raises a parse error for too many operands' do
       expect {
         parse("IF(1, 0, IF(1, 2, 3, 4))")
@@ -167,6 +193,15 @@ describe Dentaku::Parser do
         parse("undefined()")
       }.to raise_error(Dentaku::ParseError)
     end
+
+    it 'raises a parse error for an unbalanced closing parenthesis' do
+      # the tokenizer catches unbalanced parentheses in a string expression,
+      # so exercise the parser directly with a hand-built token list
+      rparen = Dentaku::Token.new(:grouping, :close)
+      expect {
+        described_class.new([rparen]).parse
+      }.to raise_error(Dentaku::ParseError)
+    end
   end
 
   it "evaluates explicit 'NULL' as nil" do

data/spec/print_visitor_spec.rb

@@ -49,6 +49,11 @@ describe Dentaku::PrintVisitor do
     expect(repr).to eq('CASE a % 5 WHEN 0 THEN a ELSE b END')
   end
 
+  it 'prints a case statement that can be re-parsed' do
+    repr = roundtrip('case (a % 5) when 0 then a else b end')
+    expect(roundtrip(repr)).to eq(repr)
+  end
+
   it 'handles a bitwise operators' do
     repr = roundtrip('0xCAFE & 0xDECAF | 0xBEEF')
     expect(repr).to eq('0xCAFE & 0xDECAF | 0xBEEF')

data/spec/spec_helper.rb

@@ -20,6 +20,15 @@ RSpec.configure do |c|
       Dentaku.aliases = { roundup: ['roundupup'] }
     end
   }
+
+  # the caching opt-ins are module-level and have no public "disable", so an
+  # example that turns one on leaks into every example that runs after it.
+  # Reset to the documented defaults so the suite does not depend on order.
+  c.before(:each) {
+    Dentaku.instance_variable_set(:@enable_ast_caching, false)
+    Dentaku.instance_variable_set(:@enable_dependency_order_caching, false)
+    Dentaku.instance_variable_set(:@enable_identifier_caching, false)
+  }
 end
 
 # automatically create a token stream from bare values