dentaku 3.5.7 → 3.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6992ab2a13558e752be1db54e612dba4230c8e273ebb4bc11b51d655435ab463
-  data.tar.gz: fe53f64d1015b13ec909382679e3dbc93ec822fb97d8389a3bd83870fe2dacea
+  metadata.gz: 5d84ad3261b937673547d328aae718b0a7389bca75b6aedaaa8b82dff2c1f9f9
+  data.tar.gz: 5f6e809c2a510e2d32a07ed0838ad878dd46bb9e475e73626dced73f219280c8
 SHA512:
-  metadata.gz: cad7fc2694c626beb952b44c5014bda140ef5e7953de85e333e8482b35ac02ce87f8054e2e752f9f47a0ae2c5af7666224803d28b484c7c2defaa11aa782521f
-  data.tar.gz: 53a267501045fce0f6f4cb26bfb7308e65a9b6cb1a1e8d4386cafffbbb865976b0c320fae2553da30b07193a9126be05068c2b7ba7c5034a341698733cf88305
+  metadata.gz: e939d79f7b4defcc2596b2a83fe612fbebf298cdb2b3a38b0cd7978ef8bdabeab6321e2b381ad9de83d28cd10bd807eabd4af1c8d095446ffca3c7515cbfe015
+  data.tar.gz: 390db232aa4a54ca779e0ddfe762cfbf9b5279c60731809ca6a5d59013ef3f3d161c298dd315daae4beeb7c5a51f4285e29b5f48d241f77d33d63e7787a2f91b

data/.github/workflows/rspec.yml

@@ -8,14 +8,12 @@ jobs:
     strategy:
       matrix:
         ruby:
-        - '2.5'
-        - '2.6'
-        - '2.7'
         - '3.0'
         - '3.1'
         - '3.2'
         - '3.3'
         - '3.4'
+        - '4.0'
       fail-fast: false
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Change Log
 
+## [UNRELEASED]
+
+## [v3.5.8] 2026-08-01
+- unify numeric matching and parsing
+- fix frozen-string-literal warning
+- fix alias function calls with whitespace before the opening parenthesis
+  (#335, thanks @DirkDoes)
+- declare `tsort` as an explicit dependency for Ruby 4.1 (#334, thanks @david942j)
+- fix dependency resolution order for mixed-case variables in case-sensitive
+  bulk expressions (#353, thanks @connortorrell)
+- stop exposing downcased aliases of constants to case-sensitive bulk expressions,
+  and fix the memory fallback missing mixed-case values
+- return a String from `name` for Ruby Math functions and functions registered
+  under a Symbol, per the `Module#name` contract (#348, thanks @toy)
+- test against Ruby 3.0 through 4.0 (2.5 - 2.7 are no longer covered by CI)
+
 ## [v3.5.7] 2025-12-16
 - fix misclassification of unary minus as subtraction
 - fix parsing empty function call
@@ -277,6 +293,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[UNRELEASED]: https://github.com/rubysolo/dentaku/compare/v3.5.7...HEAD
+[v3.5.7]: https://github.com/rubysolo/dentaku/compare/v3.5.6...v3.5.7
 [v3.5.6]: https://github.com/rubysolo/dentaku/compare/v3.5.5...v3.5.6
 [v3.5.5]: https://github.com/rubysolo/dentaku/compare/v3.5.4...v3.5.5
 [v3.5.4]: https://github.com/rubysolo/dentaku/compare/v3.5.3...v3.5.4

data/Gemfile

@@ -2,3 +2,16 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in dentaku.gemspec
 gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-byebug'
+  gem 'pry-stack_explorer'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rubocop'
+  # Stay on the 0.x line: simplecov 1.0 (2026-07) removed SimpleCov.running,
+  # which the RubyMine/IntelliJ coverage runner still relies on. Lift this
+  # once the IDE integration supports 1.0.
+  gem 'simplecov', '< 1.0'
+end

data/dentaku.gemspec

@@ -16,14 +16,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency('bigdecimal')
   s.add_dependency('concurrent-ruby')
-
-  s.add_development_dependency('pry')
-  s.add_development_dependency('pry-byebug')
-  s.add_development_dependency('pry-stack_explorer')
-  s.add_development_dependency('rake')
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('rubocop')
-  s.add_development_dependency('simplecov')
+  s.add_dependency('tsort')
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/dentaku/ast/arithmetic.rb

@@ -6,9 +6,6 @@ require 'bigdecimal/util'
 module Dentaku
   module AST
     class Arithmetic < Operation
-      DECIMAL = /\A-?\d*\.\d+\z/.freeze
-      INTEGER = /\A-?\d+\z/.freeze
-
       def initialize(*)
         super
 
@@ -49,15 +46,7 @@ module Dentaku
 
       def cast(val)
         validate_value(val)
-        numeric(val)
-      end
-
-      def numeric(val)
-        case val.to_s
-        when DECIMAL then decimal(val)
-        when INTEGER then val.to_i
-        else val
-        end
+        Dentaku::NumericParser.ensure_numeric(val) || val
       end
 
       def decimal(val)
@@ -114,7 +103,7 @@ module Dentaku
       end
 
       def validate_format(string)
-        unless string =~ /\A-?\d*(\.\d+)?\z/ && !string.empty?
+        unless Dentaku::NumericParser.match(string)
           raise Dentaku::ArgumentError.for(:invalid_value, value: string, for: BigDecimal),
                 "String input '#{string}' is not coercible to numeric"
         end

data/lib/dentaku/ast/comparators.rb

@@ -28,11 +28,8 @@ module Dentaku
 
       def cast(val)
         return val unless val.is_a?(::String)
-        return val unless val.match?(Arithmetic::DECIMAL) || val.match?(Arithmetic::INTEGER)
 
-        v = BigDecimal(val, Float::DIG + 1)
-        v = v.to_i if v.frac.zero?
-        v
+        Dentaku::NumericParser.parse_string(val) || val
       end
 
       def validate_value(value)

data/lib/dentaku/ast/function.rb

@@ -37,20 +37,6 @@ module Dentaku
       def self.registry
         @registry ||= FunctionRegistry.new
       end
-
-      # @return [Numeric] where possible it returns an Integer otherwise a BigDecimal.
-      # An Exception will be raised if a value is passed that cannot be cast to a Number.
-      def self.numeric(value)
-        return value if value.is_a?(::Numeric)
-
-        if value.is_a?(::String)
-          number = value[/\A-?\d*\.?\d+\z/]
-          return number.include?('.') ? BigDecimal(number, DIG) : number.to_i if number
-        end
-
-        raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),
-          "'#{value || value.class}' is not coercible to numeric"
-      end
     end
   end
 end

data/lib/dentaku/ast/function_registry.rb

@@ -11,7 +11,7 @@ module Dentaku
       def register(name, type, implementation, callback = nil)
         function = Class.new(Function) do
           def self.name=(name)
-            @name = name
+            @name = name.to_s
           end
 
           def self.name

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:abs, :numeric, lambda { |numeric|
-  Dentaku::AST::Function.numeric(numeric).abs
+  Dentaku::NumericParser.ensure_numeric!(numeric).abs
 })

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

@@ -9,5 +9,5 @@ Dentaku::AST::Function.register(:avg, :numeric, ->(*args) {
     ), 'AVG() requires at least one argument'
   end
 
-  flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+) / BigDecimal(flatten_args.length)
+  flatten_args.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.reduce(0, :+) / BigDecimal(flatten_args.length)
 })

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

@@ -17,8 +17,8 @@ Dentaku::AST::Function.register(:intercept, :list, ->(*args) {
   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_values = x_values.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }
+  y_values = y_values.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }
 
   x_avg = x_values.sum / n
   y_avg = y_values.sum / n

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:max, :numeric, ->(*args) {
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.max
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.max
 })

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:min, :numeric, ->(*args) {
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.min
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.min
 })

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

@@ -8,5 +8,5 @@ Dentaku::AST::Function.register(:mul, :numeric, ->(*args) {
     ), 'MUL() requires at least one argument'
   end
 
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(1, :*)
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.reduce(1, :*)
 })

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:round, :numeric, lambda { |numeric, places = 0|
-  Dentaku::AST::Function.numeric(numeric).round(Dentaku::AST::Function.numeric(places || 0).to_i)
+  Dentaku::NumericParser.ensure_numeric!(numeric).round(Dentaku::NumericParser.ensure_numeric!(places || 0).to_i)
 })

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

@@ -1,8 +1,8 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:rounddown, :numeric, lambda { |numeric, precision = 0|
-  precision = Dentaku::AST::Function.numeric(precision || 0).to_i
+  precision = Dentaku::NumericParser.ensure_numeric!(precision || 0).to_i
   tens = 10.0**precision
-  result = (Dentaku::AST::Function.numeric(numeric) * tens).floor / tens
+  result = (Dentaku::NumericParser.ensure_numeric!(numeric) * tens).floor / tens
   precision <= 0 ? result.to_i : result
 })

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

@@ -1,8 +1,8 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:roundup, :numeric, lambda { |numeric, precision = 0|
-  precision = Dentaku::AST::Function.numeric(precision || 0).to_i
+  precision = Dentaku::NumericParser.ensure_numeric!(precision || 0).to_i
   tens = 10.0**precision
-  result = (Dentaku::AST::Function.numeric(numeric) * tens).ceil / tens
+  result = (Dentaku::NumericParser.ensure_numeric!(numeric) * tens).ceil / tens
   precision <= 0 ? result.to_i : result
 })

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

@@ -16,8 +16,11 @@ module Dentaku
         @implementation = Math.method(method)
       end
 
+      # Ruby documents Module#name as a String (or nil for anonymous
+      # classes), so expose one even though the function is registered
+      # under a Symbol
       def self.name
-        @name
+        @name.to_s
       end
 
       def self.arity
@@ -39,7 +42,7 @@ module Dentaku
       end
 
       def value(context = {})
-        args = @args.flatten.map { |a| Dentaku::AST::Function.numeric(a.value(context)) }
+        args = @args.flatten.map { |a|Dentaku::NumericParser.ensure_numeric!(a.value(context)) }
         self.class.call(*args)
       end
 

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

@@ -32,7 +32,7 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          length = Dentaku::NumericParser.ensure_numeric!(@length.value(context)).to_i
           negative_argument_failure('LEFT') if length < 0
           string[0, length]
         end
@@ -54,7 +54,7 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          length = Dentaku::NumericParser.ensure_numeric!(@length.value(context)).to_i
           negative_argument_failure('RIGHT') if length < 0
           string[length * -1, length] || string
         end
@@ -76,9 +76,9 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          offset = Dentaku::AST::Function.numeric(@offset.value(context)).to_i
+          offset = Dentaku::NumericParser.ensure_numeric!(@offset.value(context)).to_i
           negative_argument_failure('MID', 'offset') if offset < 0
-          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          length = Dentaku::NumericParser.ensure_numeric!(@length.value(context)).to_i
           negative_argument_failure('MID') if length < 0
           string[offset - 1, length].to_s
         end

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

@@ -8,5 +8,5 @@ Dentaku::AST::Function.register(:sum, :numeric, ->(*args) {
     ), 'SUM() requires at least one argument'
   end
 
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+)
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.reduce(0, :+)
 })

data/lib/dentaku/bulk_expression_solver.rb

@@ -85,7 +85,7 @@ module Dentaku
     end
 
     def load_results(&block)
-      facts, _formulas = expressions.transform_keys(&:downcase)
+      facts, _formulas = expressions.transform_keys { |k| normalized_name(k) }
                                     .transform_values { |v| calculator.ast(v) }
                                     .partition { |_, v| calculator.dependencies(v, nil).empty? }
 
@@ -101,7 +101,7 @@ module Dentaku
         next if expressions[var_name].nil?
 
         with_rescues(var_name, results, block) do
-          results[var_name] = evaluated_facts[var_name] || evaluator.evaluate(
+          results[var_name] = evaluated_facts[normalized_name(var_name)] || evaluator.evaluate(
             expressions[var_name],
             context.merge(results),
             &expression_with_exception_handler(var_name, &block)
@@ -123,11 +123,18 @@ module Dentaku
       ex.recipient_variable = var_name
       results[var_name] = block.call(ex)
     ensure
-      if results[var_name] == :undefined && calculator.memory.has_key?(var_name.downcase)
-        results[var_name] = calculator.memory[var_name.downcase]
+      stored_name = normalized_name(var_name)
+      if results[var_name] == :undefined && calculator.memory.has_key?(stored_name)
+        results[var_name] = calculator.memory[stored_name]
       end
     end
 
+    # names are normalized the same way the calculator stores them, so that
+    # facts and memory lookups line up with the identifiers the parser emits
+    def normalized_name(variable_name)
+      calculator.standardize_case(variable_name.to_s)
+    end
+
     def expressions
       @expressions ||= Hash[expression_hash.map { |k, v| [k.to_s, v] }]
     end
@@ -147,9 +154,9 @@ module Dentaku
     end
 
     def variables_in_resolve_order
-      cache_key = expressions.keys.map(&:to_s).sort.join("|")
+      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).tap do |d|
+        DependencyResolver.find_resolve_order(dependencies, calculator.case_sensitive).tap do |d|
           self.class.dependency_cache[cache_key] = d if Dentaku.cache_dependency_order?
         end
       }

data/lib/dentaku/dependency_resolver.rb

@@ -5,13 +5,14 @@ module Dentaku
     include TSort
 
     def self.find_resolve_order(vars_to_dependencies_hash, case_sensitive = false)
-      self.new(vars_to_dependencies_hash).sort
+      self.new(vars_to_dependencies_hash, case_sensitive).sort
     end
 
-    def initialize(vars_to_dependencies_hash)
-      @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] }]
+    def initialize(vars_to_dependencies_hash, case_sensitive = false)
+      @case_sensitive = case_sensitive
+      @key_mapping = Hash[vars_to_dependencies_hash.keys.map { |k| [normalized_name(k), k] }]
+      # normalize variables and their dependencies alike so child lookups match
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [normalized_name(k), v.map { |d| normalized_name(d) }] }]
     end
 
     def sort
@@ -25,5 +26,11 @@ module Dentaku
     def tsort_each_child(node, &block)
       @vars_to_deps.fetch(node.to_s, []).each(&block)
     end
+
+    private
+
+    def normalized_name(variable_name)
+      @case_sensitive ? variable_name.to_s : variable_name.to_s.downcase
+    end
   end
 end

data/lib/dentaku/numeric_parser.rb

@@ -0,0 +1,68 @@
+module Dentaku
+  module NumericParser
+    NUMERIC_PATTERN = '((?:\d+(\.\d+)?|\.\d+)(?:(e|E)(\+|-)?\d+)?)\b'.freeze
+    # e.g:  [2, 1.2, .5, 1e10, 1.5E-10]
+    HEXADECIMAL_PATTERN = '(0x[0-9a-f]+)\b'.freeze
+    # e.g:  [0x1A3F]
+
+    class << self
+      def match(string)
+        regex = %r{\A(-?(#{ NUMERIC_PATTERN }|#{ HEXADECIMAL_PATTERN }))\z}i
+        string.match(regex)
+      end
+
+      def match_numeric(string)
+        regex = %r{\A(#{ NUMERIC_PATTERN })\z}i
+        string.match(regex)
+      end
+
+      def match_hexadecimal(string)
+        regex = %r{\A(#{ HEXADECIMAL_PATTERN })\z}i
+        string.match(regex)
+      end
+
+      def parse_numeric_string(raw)
+        raw =~ /(\.|e|E)/ ? BigDecimal(raw, Float::DIG + 1) : raw.to_i
+      end
+
+      def parse_hexadecimal_string(raw)
+        raw[2..-1].to_i(16)
+      end
+
+      def parse_string(raw)
+        return nil unless !!match(raw)
+
+        is_negative = raw.start_with?('-')
+        number_part = is_negative ? raw[1..-1] : raw
+
+        value = if number_part =~ /\A0x/i
+          parse_hexadecimal_string(number_part)
+        else
+          parse_numeric_string(number_part)
+        end
+
+        is_negative ? -value : value
+      end
+
+      # @return [Numeric] where possible it returns an Integer otherwise a BigDecimal.
+      # An Exception will be raised if a value is passed that cannot be cast to a Number.
+      def ensure_numeric!(value)
+        return value if value.is_a?(::Numeric)
+
+        if value.is_a?(::String)
+          number = parse_string(value)
+          return number if number
+        end
+
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),
+          "'#{value || value.class}' is not coercible to numeric"
+      end
+
+      def ensure_numeric(value)
+        ensure_numeric!(value)
+      rescue Dentaku::ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/dentaku/print_visitor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 module Dentaku
   class PrintVisitor
     def initialize(node)

data/lib/dentaku/token_scanner.rb

@@ -2,6 +2,7 @@ require 'bigdecimal'
 require 'time'
 require 'dentaku/string_casing'
 require 'dentaku/token'
+require 'dentaku/numeric_parser'
 
 module Dentaku
   class TokenScanner
@@ -95,13 +96,11 @@ module Dentaku
       end
 
       def numeric
-        new(:numeric, '((?:\d+(\.\d+)?|\.\d+)(?:(e|E)(\+|-)?\d+)?)\b', lambda { |raw|
-          raw =~ /(\.|e|E)/ ? BigDecimal(raw) : raw.to_i
-        })
+        new(:numeric, NumericParser::NUMERIC_PATTERN, lambda { |raw| NumericParser.parse_numeric_string(raw) })
       end
 
       def hexadecimal
-        new(:numeric, '(0x[0-9a-f]+)\b', lambda { |raw| raw[2..-1].to_i(16) })
+        new(:numeric, NumericParser::HEXADECIMAL_PATTERN, lambda { |raw| NumericParser.parse_hexadecimal_string(raw) })
       end
 
       def double_quoted_string

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

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.7"
+  VERSION = "3.5.8"
 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)

data/spec/calculator_spec.rb

@@ -961,10 +961,20 @@ 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 '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
   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/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/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)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.7
+  version: 3.5.8
 platform: ruby
 authors:
 - Solomon White
 bindir: bin
 cert_chain: []
-date: 2025-12-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -38,97 +38,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: tsort
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -214,6 +130,7 @@ files:
 - lib/dentaku/dependency_resolver.rb
 - lib/dentaku/exceptions.rb
 - lib/dentaku/flat_hash.rb
+- lib/dentaku/numeric_parser.rb
 - lib/dentaku/parser.rb
 - lib/dentaku/print_visitor.rb
 - lib/dentaku/string_casing.rb
@@ -263,6 +180,7 @@ files:
 - spec/dependency_resolver_spec.rb
 - spec/exceptions_spec.rb
 - spec/external_function_spec.rb
+- spec/numeric_parser_spec.rb
 - spec/parser_spec.rb
 - spec/print_visitor_spec.rb
 - spec/spec_helper.rb
@@ -290,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
@@ -333,6 +251,7 @@ test_files:
 - spec/dependency_resolver_spec.rb
 - spec/exceptions_spec.rb
 - spec/external_function_spec.rb
+- spec/numeric_parser_spec.rb
 - spec/parser_spec.rb
 - spec/print_visitor_spec.rb
 - spec/spec_helper.rb