minting 1.9.6 → 1.9.7

data/lib/minting/money/format/formatting.rb

@@ -3,24 +3,92 @@
 module Mint
   # :nodoc:
   class Money
-    private
+    def self.compiled_formatters
+      @compiled_formatters ||= {}
+    end
+
+    # Build each sign template with subunit precision baked in, returning a
+    # frozen Hash of templates keyed by sign (:positive, :negative, :zero).
+    # Keeps %<symbol>s and %<currency>s as format args so width/padding specifiers work.
+    # @private
+    def self.compile_templates(format_hash, subunit)
+      [
+        format_hash[:positive] || DEFAULT_FORMAT,
+        format_hash[:negative],
+        format_hash[:zero]
+      ].map do |sign_format|
+        next unless sign_format
+
+        # Injects the currency's subunit precision into %<amount>f specifiers
+        # (e.g. '%<amount>f' → '%<amount>.2f' for USD), preserving any
+        # existing width/alignment specifier (e.g. '%<amount>+10f' stays).
+        sign_format = sign_format.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{subunit}f")
+
+        # For zero-subunit currencies (JPY, KRW, etc.), strip %<fractional>d
+        # specifiers entirely since there is no fractional part to display.
+        sign_format.gsub!(/%<fractional>[^%]*?d/, '') if subunit.zero?
+
+        sign_format
+      end
+    end
 
-    # Resolves the format template and amount based on the amount's sign
-    # (negative_format/zero_format may override both the template and negate the value)
+    # Builds and returns a lambda that formats amounts for a fixed
+    # [format_config, currency, decimal, thousand] combination.
+    # The lambda is cached by {.compiled_formatters}.
     # @private
-    def resolve_format(format)
-      negative_format = format[:negative]
-      zero_format = format[:zero]
-
-      if amount.negative? && negative_format
-        [negative_format, -amount]
-      elsif amount.zero? && zero_format
-        [zero_format,     amount]
-      else
-        [format[:positive] || '%<symbol>s%<amount>f', amount]
+    def self.compile_formatter(format_hash, currency, decimal, thousand) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      subunit = currency.subunit
+      has_decimal_substitution = decimal != '.'
+      escaped_decimal = Regexp.escape(decimal)
+      has_thousand_separator = thousand && !thousand.empty?
+
+      templates = compile_templates(format_hash, subunit)
+      positive_template, negative_template, zero_template = templates
+
+      # Detect whether templates use %<fractional> and/or %<d-symbol>
+      all_templates = templates.compact.join
+      needs_fractional = all_templates.include?('%<fractional>')
+      needs_integral = all_templates.include?('%<amount>') || all_templates.include?('%<integral>')
+      multiplier = currency.fractional_multiplier
+      symbol = currency.symbol
+
+      args = {
+        currency: currency.code,
+        dsymbol: currency.disambiguate_symbol || symbol,
+        symbol: symbol
+      }
+
+      lambda do |amount|
+        format_template = if negative_template && amount < 0
+                            amount = -amount
+                            negative_template
+                          elsif zero_template && amount == 0
+                            zero_template
+                          else
+                            positive_template
+                          end
+
+        args[:amount] = amount
+        args[:integral] = amount.to_i
+        args[:fractional] = ((amount.abs % 1) * multiplier).to_i if needs_fractional
+
+        result = Kernel.format(format_template, **args)
+        result.gsub!(/(?<=\d)\.(?=\d)/, decimal) if has_decimal_substitution
+
+        if needs_integral && has_thousand_separator && (amount >= 1000 || amount <= -1000)
+          # Split on the decimal separator between digits only — symbols may contain '.' (e.g. د.إ).
+          parts = result.split(/(?<=\d)#{escaped_decimal}(?=\d)/, 2)
+          # Insert the thousands delimiter before each run of 3 digits from the right.
+          parts[0].gsub!(/(\d)(?=(?:\d{3})+(?:[^\d]|$))/) { Regexp.last_match(1) + thousand }
+          result = parts.join(decimal)
+        end
+
+        result
       end
     end
 
+    private
+
     # Validates that format hash contains only known keys.
     # @private
     def validate_format_hash(format)
@@ -46,52 +114,17 @@ module Mint
       end
     end
 
-    def apply_thousand_separator(string, decimal:, thousand:)
-      return string if !thousand || thousand.empty?
-
-      # Apply thousands only to the integral portion, using the decimal as boundary
-      parts = string.split(/(?<=\d)#{Regexp.escape(decimal)}(?=\d)/, 2)
-      parts[0].gsub!(/(\d)(?=(?:\d{3})+(?:[^\d]|$))/, "\\1#{thousand}")
-      parts.join(decimal)
-    end
-
-    # Applies a format template to produce a formatted string representation.
+    # Applies a format template to the money amount, returning a formatted string.
+    # Uses a cached compiled formatter lambda that pre-resolves currency-specific
+    # values (symbol, code, subunit) so per-call work is reduced to
+    # Kernel.format + optional separator substitutions.
     # @private
-    #
     def format_amount(format, decimal:, thousand:)
-      subunit = currency.subunit
-      resolved_format, adjusted_amount = resolve_format(format)
-
-      resolved_format = inject_subunit_precision(resolved_format, subunit)
-
-      result = Kernel.format(resolved_format, {
-                               amount: adjusted_amount,
-                               currency: currency_code,
-                               symbol: currency.symbol,
-                               integral: adjusted_amount.to_i,
-                               fractional: fractional
-                             })
+      key = [format, currency_code, decimal, thousand].hash
 
-      # Substitute decimal first, while the dot is still unambiguous
-      result.gsub!(/(?<=\d)\.(?=\d)/, decimal) if decimal != '.'
+      formatter = Money.compiled_formatters[key] ||= Money.compile_formatter(format, currency, decimal, thousand)
 
-      return result if adjusted_amount.abs < 1000
-
-      # Apply thousands only to the integral portion, using the decimal as boundary
-      apply_thousand_separator(result, decimal:, thousand:)
-    end
-
-    # Injects the currency's subunit precision into %<amount>f specifiers
-    # (e.g. '%<amount>f' → '%<amount>.2f' for USD). For zero-subunit
-    # currencies (e.g. JPY), strips %<fractional>d specifiers.
-    # @private
-    def inject_subunit_precision(template, subunit)
-      cache ||= {}
-      cache[[template, subunit]] ||= begin
-        result = template.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{subunit}f")
-        result.gsub!(/%<fractional>[^%]*?d/, '') if subunit.zero?
-        result.freeze
-      end
+      formatter.call(amount)
     end
   end
 end

data/lib/minting/money/format/to_s.rb

@@ -3,6 +3,10 @@
 module Mint
   # :nodoc:
   class Money
+    # The default display format pattern for formatting monetary values.
+    # Uses `%<symbol>s` for the currency symbol and `%<amount>f` for the rounded amount.
+    DEFAULT_FORMAT = '%<symbol>s%<amount>f'
+
     PRESETS = {
       amount: { format: '%<amount>f' },
       accounting: { format: { negative: '(%<symbol>s%<amount>f)' } },
@@ -17,7 +21,7 @@ module Mint
     #   When provided, expands to the preset's format options and merges
     #   with any explicit keyword arguments (kwargs override the preset).
     # @param format [String, Hash, nil] Either a Format string with placeholders
-    #   (%<symbol>s, %<amount>f, %<currency>s, %<integral>d, %<fractional>d),
+    #   (%<symbol>s, %<amount>f, %<currency>s, %<integral>d, %<fractional>d, %<dsymbol>s),
     #   or a Hash with per-sign keys (:positive, :negative, :zero) each
     #   holding a format string. A Hash is convenient for sign-aware formats
     #   such as accounting parentheses:
@@ -96,12 +100,25 @@ module Mint
       else        raise ArgumentError, 'Invalid format. Only String or Hash are accepted'
       end
 
-      formatted = format_amount(format, decimal: decimal, thousand: thousand)
+      formatted = format_amount(format, decimal:, thousand:)
 
       width ? formatted.rjust(width) : formatted
     end
 
-    def to_s = format
+    THOUSAND_RE = /(\d)(?=(\d{3})+\z)/
+
+    def to_s
+      return format unless Mint.locale_backend.nil?
+
+      subunit  = currency.subunit
+      integral = to_i.to_s
+      integral.gsub!(THOUSAND_RE, '\1,') if amount.abs >= 1000
+      if subunit > 0
+        "#{currency.symbol}#{integral}.#{fractional.to_s.rjust(subunit, '0')}"
+      else
+        "#{currency.symbol}#{integral}"
+      end
+    end
 
     alias to_fs :format
   end

data/lib/minting/money/money.rb

@@ -17,10 +17,6 @@ module Mint
   # Money objects are immutable and support arithmetic, comparison,
   # formatting, allocation, and parsing operations.
   class Money
-    # The default display format pattern for formatting monetary values.
-    # Uses `%<symbol>s` for the currency symbol and `%<amount>f` for the rounded amount.
-    DEFAULT_FORMAT = '%<symbol>s%<amount>f'
-
     attr_reader :amount, :currency
 
     # Returns the ISO 3-letter currency code string.

data/lib/minting/version.rb

@@ -3,5 +3,5 @@
 # Root namespace for the Minting library.
 module Minting
   # Current version of the Minting gem.
-  VERSION = '1.9.6'
+  VERSION = '1.9.7'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minting
 version: !ruby/object:Gem::Version
-  version: 1.9.6
+  version: 1.9.7
 platform: ruby
 authors:
 - Gilson Ferraz
@@ -38,13 +38,14 @@ files:
 - bin/setup
 - doc/Mint.html
 - doc/Mint/Currency.html
-- doc/Mint/CurrencyRegistry.html
 - doc/Mint/Money.html
 - doc/Mint/RangeStepPatch.html
 - doc/Mint/Registry.html
 - doc/Mint/Rounding.html
 - doc/Mint/UnknownCurrency.html
 - doc/Minting.html
+- doc/Numeric.html
+- doc/String.html
 - doc/_index.html
 - doc/agents/api_review-2026-06-15.md
 - doc/agents/copilot-instructions.md