dentaku 3.5.7 → 4.0.0

data/lib/dentaku/tokenizer.rb

@@ -83,7 +83,7 @@ module Dentaku
 
     def alias_regex
       values = @aliases.values.flatten.join('|')
-      /(?<=\p{Punct}|[[:space:]]|\A)(#{values})(?=\()/i
+      /(?<=\p{Punct}|[[:space:]]|\A)(#{values})(?=\s*\()/i
     end
 
     private
@@ -94,21 +94,7 @@ module Dentaku
     end
 
     def fail!(reason, **meta)
-      message =
-        case reason
-        when :parse_error
-          "parse error at: '#{meta.fetch(:at)}'"
-        when :too_many_opening_parentheses
-          "too many opening parentheses"
-        when :too_many_closing_parentheses
-          "too many closing parentheses"
-        when :unexpected_zero_width_match
-          "unexpected zero-width match (:#{meta.fetch(:category)}) at '#{meta.fetch(:at)}'"
-        else
-          raise ::ArgumentError, "Unhandled #{reason}"
-        end
-
-      raise TokenizerError.for(reason, **meta), message
+      raise TokenizerError.for(reason, **meta)
     end
   end
 end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.7"
+  VERSION = "4.0.0"
 end

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/ast/function_spec.rb

@@ -37,33 +37,19 @@ describe Dentaku::AST::Function do
     end
   end
 
-  it 'casts a String to an Integer if possible' do
-    expect(described_class.numeric('3')).to eq(3)
-  end
-
-  it 'casts a String to a BigDecimal if possible and if Integer would loose information' do
-    expect(described_class.numeric('3.2')).to eq(3.2)
-  end
-
-  it 'casts a String to a BigDecimal with a negative number' do
-    expect(described_class.numeric('-3.2')).to eq(-3.2)
-  end
-
-  it 'casts a String to a BigDecimal without a leading zero' do
-    expect(described_class.numeric('-.2')).to eq(-0.2)
-  end
-
-  it 'raises an error if the value could not be cast to a Numeric' do
-    expect { described_class.numeric('flarble') }.to raise_error Dentaku::ArgumentError
-    expect { described_class.numeric('-') }.to raise_error Dentaku::ArgumentError
-    expect { described_class.numeric('') }.to raise_error Dentaku::ArgumentError
-    expect { described_class.numeric(nil) }.to raise_error Dentaku::ArgumentError
-    expect { described_class.numeric('7.') }.to raise_error Dentaku::ArgumentError
-    expect { described_class.numeric(true) }.to raise_error Dentaku::ArgumentError
-  end
-
   it "allows read access to arguments" do
     fn = described_class.new(1, 2, 3)
     expect(fn.args).to eq([1, 2, 3])
   end
+
+  describe "#name" do
+    it "is a String for functions registered with a Symbol" do
+      fn = described_class.register(:symbol_named, :numeric, ->(x) { x })
+      expect(fn.name).to eq("symbol_named")
+    end
+
+    it "is a String for functions imported from Ruby's Math module" do
+      expect(described_class.get("sqrt").name).to eq("sqrt")
+    end
+  end
 end

data/spec/bulk_expression_solver_spec.rb

@@ -130,6 +130,41 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       )
     end
 
+    it 'resolves mixed-case keys declared out of order when case-sensitive' do
+      calculator = Dentaku::Calculator.new(case_sensitive: true)
+      expressions = {
+        'TopLevel'    => 'MidLevel * 2',
+        'MidLevel'    => 'BottomLevel * 2',
+        'BottomLevel' => '2'
+      }
+
+      result = described_class.new(expressions, calculator).solve
+
+      expect(result).to eq(
+        'TopLevel'    => 8,
+        'MidLevel'    => 4,
+        'BottomLevel' => 2
+      )
+    end
+
+    it 'does not expose a downcased alias of a constant when case-sensitive' do
+      calculator = Dentaku::Calculator.new(case_sensitive: true)
+      expressions = { 'BottomLevel' => '2', 'TopLevel' => 'bottomlevel * 2' }
+
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::UnboundVariableError, /bottomlevel/)
+    end
+
+    it 'falls back to mixed-case memory values when case-sensitive' do
+      calculator = Dentaku::Calculator.new(case_sensitive: true)
+      calculator.store('MyVar' => 7)
+
+      result = described_class.new({ 'MyVar' => 'Missing + 1' }, calculator).solve
+
+      expect(result).to eq('MyVar' => 7)
+    end
+
     it "returns :undefined when variables are unbound" do
       expressions = {more_apples: "apples + 1"}
       expect(described_class.new(expressions, calculator).solve)
@@ -160,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
@@ -169,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
@@ -178,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])
@@ -961,10 +976,72 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'functions with whitespace before parentheses' do
+    it 'accepts regular functions' do
+      expect(calculator.evaluate('round (5.1)')).to eq(5)
+    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)
     end
+
+    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

data/spec/dependency_resolver_spec.rb

@@ -15,4 +15,18 @@ describe Dentaku::DependencyResolver do
       ["THIRD", "SeCoNd", "FIRST"]
     )
   end
+
+  it 'sorts mixed-case expressions in dependency order when case-sensitive' do
+    dependencies = {"TopLevel" => ["MidLevel"], "MidLevel" => ["BottomLevel"], "BottomLevel" => []}
+    expect(described_class.find_resolve_order(dependencies, true)).to eq(
+      ["BottomLevel", "MidLevel", "TopLevel"]
+    )
+  end
+
+  it 'treats variables that differ only in case as distinct when case-sensitive' do
+    dependencies = {"foo" => ["FOO"], "FOO" => []}
+    expect(described_class.find_resolve_order(dependencies, true)).to eq(
+      ["FOO", "foo"]
+    )
+  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/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/numeric_parser_spec.rb

@@ -0,0 +1,66 @@
+require 'dentaku/numeric_parser'
+
+describe Dentaku::NumericParser do
+  it 'casts a String to an Integer if possible' do
+    result = Dentaku::NumericParser.ensure_numeric!('3')
+    expect(result).to eq(3)
+    expect(result).to be_a(Integer)
+  end
+
+  it 'casts a String to a BigDecimal if possible and if Integer would loose information' do
+    result = Dentaku::NumericParser.ensure_numeric!('3.2')
+    expect(result).to eq(3.2)
+    expect(result).to be_a(BigDecimal)
+  end
+
+  it 'casts a String to a BigDecimal with a negative number' do
+    result = Dentaku::NumericParser.ensure_numeric!('-3.2')
+    expect(result).to eq(-3.2)
+    expect(result).to be_a(BigDecimal)
+  end
+
+  it 'casts a String to a BigDecimal without a leading zero' do
+    result = Dentaku::NumericParser.ensure_numeric!('-.2')
+    expect(result).to eq(-0.2)
+    expect(result).to be_a(BigDecimal)
+  end
+
+  it 'casts a String with Sientific notiation to a BigDecimal' do
+    result = Dentaku::NumericParser.ensure_numeric!('12E1')
+    expect(result).to eq(12e1)
+    expect(result).to be_a(BigDecimal)
+  end
+
+  it 'casts a String with negative Sientific notiation to a BigDecimal' do
+    result = Dentaku::NumericParser.ensure_numeric!('12e-2')
+    expect(result).to eq(0.12)
+    expect(result).to be_a(BigDecimal)
+  end
+
+  it 'casts a String with hexadecimal to an Integer' do
+    result1 = Dentaku::NumericParser.ensure_numeric!('0xFFD')
+    result2 = Dentaku::NumericParser.ensure_numeric!('0x00000001')
+    expect(result1).to eq(4093)
+    expect(result2).to eq(1)
+    expect(result1).to be_a(Integer)
+    expect(result2).to be_a(Integer)
+  end
+
+  it 'casts a String with a negative hexadecimal to an Integer' do
+    result = Dentaku::NumericParser.ensure_numeric!('-0xFF')
+    expect(result).to eq(-0xFF)
+    expect(result).to be_a(Integer)
+  end
+
+  it 'raises an error if the value could not be cast to a Numeric' do
+    expect { Dentaku::NumericParser.ensure_numeric!('flarble') }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!('-') }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!('') }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!(nil) }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!('7.') }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!(true) }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!("1 - 2") }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!([1]) }.to raise_error Dentaku::ArgumentError
+    expect { Dentaku::NumericParser.ensure_numeric!("1f") }.to raise_error Dentaku::ArgumentError
+  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/tokenizer_spec.rb

@@ -360,6 +360,12 @@ describe Dentaku::Tokenizer do
       expect(tokenizer.replace_aliases(input)).to eq('min(4,6,2)')
     end
 
+    it 'replaces aliases with whitespace before parentheses' do
+      input = 'rrrrround! (8.2) + minimo (4,6,2)'
+      tokenizer.tokenize(input, aliases: aliases)
+      expect(tokenizer.replace_aliases(input)).to eq('round (8.2) + min (4,6,2)')
+    end
+
     it 'replace only whole aliases without word parts' do
       input = 'maximo(2,minimoooo())' # `minimoooo` doesn't match `minimo`
       tokenizer.tokenize(input, aliases: aliases)