minting 1.9.7 → 2.0.0

data/lib/minting/money/arithmetics/operators.rb

@@ -9,11 +9,10 @@ module Mint
     # @return [Money] the sum of the addition
     # @raise [TypeError] if addition involves a different currency or incompatible types
     def +(addend)
-      case addend
-      in 0 then self
-      in Money if same_currency?(addend) then copy_with(amount: amount + addend.amount)
-      else raise TypeError, "#{addend} can't be added to #{self}"
-      end
+      return self if addend == 0
+      return copy_with(amount: amount + addend.amount) if addend.is_a?(Money) && currency == addend.currency
+
+      raise TypeError, "#{addend} can't be added to #{self}"
     end
 
     # Performs subtraction with another {Money} instance or standard zero Numeric.
@@ -22,10 +21,9 @@ module Mint
     # @return [Money] the difference of the subtraction
     # @raise [TypeError] if subtraction involves a different currency or incompatible types
     def -(subtrahend)
-      case subtrahend
-      when 0     then return self
-      when Money then return copy_with(amount: amount - subtrahend.amount) if same_currency?(subtrahend)
-      end
+      return self if subtrahend == 0
+      return copy_with(amount: amount - subtrahend.amount) if subtrahend.is_a?(Money) && currency == subtrahend.currency
+
       raise TypeError, "#{subtrahend} can't be subtracted from #{self}"
     end
 
@@ -52,10 +50,9 @@ module Mint
     # @raise [TypeError] if divisor is of incompatible type or different currency
     # @raise [ZeroDivisionError] if division by zero is attempted
     def /(divisor)
-      case divisor
-      when Numeric then return copy_with(amount: amount / divisor)
-      when Money   then return amount / divisor.amount if same_currency? divisor
-      end
+      return copy_with(amount: amount / divisor) if divisor.is_a? Numeric
+      return amount / divisor.amount if divisor.is_a?(Money) && currency == divisor.currency
+
       raise TypeError, "#{self} can't be divided by #{divisor}"
     end
 

data/lib/minting/money/clamp.rb

@@ -26,19 +26,19 @@ module Mint
     #   if min is a Range, and max is not nil
     #
     # @example In range
-    #   Mint.money(5, 'USD').clamp(0, 10) #=> [USD 5.00]  (returns self)
+    #   Money.from(5, 'USD').clamp(0, 10) #=> [USD 5.00]  (returns self)
     #
     # @example Out of range, with Numeric bounds
-    #   Mint.money(50, 'USD').clamp(0, 10) #=> [USD 10.00]
+    #   Money.from(50, 'USD').clamp(0, 10) #=> [USD 10.00]
     #
     # @example Out of range, with Money bounds
-    #   loss  = Mint.money(-5, 'USD')
-    #   floor = Mint.money(0,  'USD')
-    #   ceil  = Mint.money(10, 'USD')
+    #   loss  = Money.from(-5, 'USD')
+    #   floor = Money.from(0,  'USD')
+    #   ceil  = Money.from(10, 'USD')
     #   loss.clamp(floor, ceil) #=> [USD 0.00]
     #
     # @example Subunit-0 currency (JPY)
-    #   Mint.money(500, 'JPY').clamp(0, 100) #=> [JPY 100]
+    #   Money.from(500, 'JPY').clamp(0, 100) #=> [JPY 100]
     def clamp(min_or_range, max = nil)
       if min_or_range.is_a?(Range)
         raise(ArgumentError, "Either amount range alone or two amounts accepted: #{max}") if max

data/lib/minting/money/coercion.rb

@@ -9,7 +9,7 @@ module Mint
     # @param other [Numeric] the left-hand operand to coerce
     # @return [Array(CoercedNumber, Money)] coerced operand array
     # @example
-    #   price = Mint.money(10, 'USD')
+    #   price = Money.from(10, 'USD')
     #   5 * price  #=> [USD 50.00] (via coercion)
     def coerce(other)
       [CoercedNumber.new(other), self]

data/lib/minting/money/comparable.rb

@@ -25,12 +25,12 @@ module Mint
     end
 
     # @example
-    #   two_usd == Mint.money(2r, 'USD') #=> [$ 2.00]
+    #   two_usd == Money.from(2r, 'USD') #=> [$ 2.00]
     #   two_usd > 0                      #=> true
-    #   two_usd > Mint.money(2, 'USD')   #=> false
+    #   two_usd > Money.from(2, 'USD')   #=> false
     #   two_usd > 1
     #   => TypeError: [$ 2.00] can't be compared to 1
-    #   two_usd > Mint.money(2, 'BRL')
+    #   two_usd > Money.from(2, 'BRL')
     #   => TypeError: [$ 2.00] can't be compared to [R$ 2.00]
     #
     def <=>(other)

data/lib/minting/money/constructors.rb

@@ -29,34 +29,7 @@ module Mint
     #   Money.no_currency(100)  #=> [XXX 100]
     def self.no_currency(amount) = from(amount, 'XXX')
 
-    # Parses a human-readable money string into a {Money} object.
-    #
-    # Returns +nil+ when the input is invalid or currency cannot be determined.
-    #
-    # @param input [String] Amount input, optionally including a currency symbol or code
-    # @param currency [String, Symbol, Currency, nil] ISO code when not present in +input+
-    # @return [Money, nil]
-    #
-    # @example With explicit currency
-    #   Money.parse('19.99', 'USD')    #=> [USD 19.99]
-    #   Money.parse('garbage', 'USD')  #=> nil
-    #
-    # @example With symbol or code in the string
-    #   Money.parse('$19.99')            #=> [USD 19.99]
-    #   Money.parse('USD 1,234.56')    #=> [USD 1234.56]
-    def self.parse(input, currency = nil) = Mint.parse(input, currency)
-
-    # Like {.parse} but raises on failure.
-    #
-    # @param input [String] Amount input, optionally including a currency symbol or code
-    # @param currency [String, Symbol, Currency, nil] ISO code when not present in +input+
-    # @return [Money]
-    # @raise [ArgumentError] when +input+ is invalid or currency cannot be determined
-    #
-    # @example
-    #   Money.parse!('19.99', 'USD')    #=> [USD 19.99]
-    #   Money.parse!('garbage', 'USD')  #=> ArgumentError
-    def self.parse!(input, currency = nil) = Mint.parse!(input, currency)
+    # Parsing is defined in +parse+. See {Money.parse} and {Money.parse!}.
 
     # Returns a frozen zero Money in the given currency.
     #
@@ -81,7 +54,7 @@ module Mint
     # @example JPY (subunit 0)
     #   Money.from_subunits(1234, 'JPY')    #=> [JPY 1234]
     # @example Round trip
-    #   m = Mint.money(9.99, 'USD')
+    #   m = Money.from(9.99, 'USD')
     #   Money.from_subunits(m.subunits, 'USD') == m #=> true
     def self.from_subunits(subunits, currency)
       raise ArgumentError, 'subunits must be an Integer' unless subunits.is_a?(Integer)
@@ -98,7 +71,7 @@ module Mint
     # @param amount [Numeric] The new monetary amount
     # @return [Money] A new Money object with the new amount, or self if the amount is unchanged
     # @example
-    #   price = Mint.money(10.00, 'USD')
+    #   price = Money.from(10.00, 'USD')
     #   price.copy_with(amount: 15.00)  #=> [USD 15.00]
     #   price.copy_with(amount: 10.00)  #=> [USD 10.00] (returns self)
     def copy_with(amount:)
@@ -113,18 +86,6 @@ module Mint
       end
     end
 
-    # Returns a new Money with the given amount in the same currency.
-    #
-    # @deprecated Use {#copy_with} instead. Will be removed in v2.
-    # @param new_amount [Numeric] the new monetary amount
-    # @return [Money] a new Money instance, or self if unchanged
-    # @example
-    #   Mint.money(10, 'USD').mint(15)  #=> [USD 15.00]
-    def mint(new_amount)
-      warn 'Money#mint is now deprecated and will be removed in v2'
-      copy_with(amount: new_amount)
-    end
-
     private
 
     # Initializes a new Money object with the given amount and currency.

data/lib/minting/money/conversion.rb

@@ -11,7 +11,7 @@ module Mint
     #
     # @return [BigDecimal] the decimal representation of the money amount
     # @example
-    #   Mint.money(9.99, 'USD').to_d  #=> 0.999e1
+    #   Money.from(9.99, 'USD').to_d  #=> 0.999e1
     def to_d = amount.to_d 0
 
     # Converts the monetary amount to a standard float.
@@ -27,36 +27,40 @@ module Mint
     # @return [String] HTML5 `<data>` representation
     def to_html(format = DEFAULT_FORMAT)
       title = Kernel.format("#{currency_code} %0.#{currency.subunit}f", amount)
-      body = format(format: format)
+      body = format(format)
       %(<data class='money' title='#{title}'>#{ERB::Util.html_escape(body)}</data>)
     end
 
-    # Truncates and converts the monetary amount to an Integer.
-    #
-    # @return [Integer] the integer representation of the money amount
-    # @example
-    #   Mint.money(9.99, 'USD').to_i  #=> 9
-    #   Mint.money(-9.99, 'USD').to_i #=> -9
-    def to_i = amount.to_i
-
     # Returns a Hash representation of the money instance.
     #
     # @return [Hash] hash with :currency (String) and :amount (String) keys
     # @example
-    #   Mint.money(134120, 'BRL').to_hash
+    #   Money.from(134120, 'BRL').to_hash
     #   #=> { currency: "BRL", amount: "134120.00" }
     def to_hash
       { currency: currency_code, amount: Kernel.format("%0.#{currency.subunit}f", amount) }
     end
 
-    # Serializes the money instance to a standard JSON object containing the amount and currency.
-    # Highly optimized to run without external dependencies.
+    # Deserializes a Hash into a Money instance.
     #
-    # @return [String] the JSON serialized string representation
-    def to_json(*_args)
-      Kernel.format(
-        %({"currency": "#{currency_code}", "amount": "%0.#{currency.subunit}f"}), amount
-      )
+    # Accepts both symbol and string keys, matching the output of {#to_hash}.
+    #
+    # @param hash [Hash] a hash with +:currency+ (or +"currency"+) and
+    #   +:amount+ (or +"amount"+) keys
+    # @return [Money] the deserialized Money instance
+    # @raise [Mint::UnknownCurrency] if the currency can't be resolved
+    # @raise [ArgumentError] if amount is not parseable as a Rational
+    #
+    # @example
+    #   Money.from_hash(currency: "USD", amount: "9.99")
+    #   #=> [USD 9.99]
+    # @example Round-trip
+    #   m = Money.from(134120, "BRL")
+    #   Money.from_hash(m.to_hash) == m  #=> true
+    def self.from_hash(hash)
+      currency = Currency.resolve!(hash[:currency] || hash['currency'])
+      amount = currency.normalize_amount(Rational(hash[:amount] || hash['amount']))
+      amount.zero? ? currency.zero : new(amount, currency)
     end
 
     # Returns the exact internal Rational representation of the monetary amount.

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc:
+  class Money
+    # Formats money as a string with a customizable template, thousand delimiter,
+    # and decimal separator.
+    #
+    # @param template [String, Hash, nil] Either a format string with placeholders
+    #   (%<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:
+    #
+    #     money.format({ negative: '(%<symbol>s%<amount>f)' })
+    #
+    #   Missing keys fall back to the module default, so a Hash with only
+    #   :negative will still format positives sensibly. The valid keys are
+    #   :positive, :negative, :zero; anything else raises ArgumentError.
+    #   When +nil+, falls back to +Mint.locale_backend+ if set, otherwise
+    #   +"%<symbol>s%<amount>f"+.
+    # @param thousand [String, false, nil] Thousands delimiter (e.g., ',' for 1,000).
+    #   When +nil+, falls back to +Mint.locale_backend+ if set, otherwise +","+.
+    # @param decimal [String, nil] Decimal separator (e.g., '.' or ',').
+    #   When +nil+, falls back to +Mint.locale_backend+ if set, otherwise +"."+.
+    # @param locale [Symbol, String, nil] Locale key passed to the +Mint.locale_backend+
+    #   callable when resolving locale-aware separators and format. Ignored when
+    #   +Mint.locale_backend+ is a Hash or nil. Accepts symbols (+:en+, +:'pt-BR'+)
+    #   and strings (+"pt-BR"+), passed through as-is (matching Rails +I18n.locale+
+    #   convention).
+    # @return [String] Formatted money string
+    #
+    # @raise [ArgumentError] if +template+ is not a String or Hash, the Hash is
+    #   empty, or the Hash contains an unrecognised key.
+    #
+    # @example Basic formatting
+    #   money = Money.from(1234.56, 'USD')
+    #   money.format                               #=> "$1,234.56"
+    #   money.format(thousand: '.', decimal: ',')  #=> "$1.234,56"
+    #   money.format(decimal: ',', thousand: '')   #=> "$1234,56"
+    #
+    # @example Custom templates
+    #   money.format('%<amount>f')                              #=> "1234.56"
+    #   money.format('%<currency>s %<amount>f')                 #=> "USD 1234.56"
+    #   money.format('%<amount>f %<symbol>s')                   #=> "1234.56 $"
+    #   money.format('%<symbol>s%<amount>+f')                   #=> "$+1234.56"
+    #
+    # @example Integral & fractional parts
+    #   money.format('%<integral>d.%<fractional>02d')            #=> "1234.56"
+    #   price = Money.from(0.99, 'USD')
+    #   price.format('%<integral>d dollars and %<fractional>02d cents')
+    #   #=> "0 dollars and 99 cents"
+    #
+    # @example Per-sign Hash format (accounting parentheses)
+    #   loss = Money.from(-1234.56, 'USD')
+    #   loss.format({ negative: '(%<symbol>s%<amount>f)' })      #=> "($1,234.56)"
+    #   Money.from(0, 'BRL').format({ zero: '--' })             #=> "--"
+    #
+    # @example Padding and alignment
+    #   money.format('%<amount>10.2f')                          #=> "   1234.56"
+    #   money.format('%<symbol>s%<amount>010.2f')               #=> "$0001234.56"
+    #
+    # @example Locale-aware formatting (with Mint.locale_backend set)
+    #   money.format                       # decimal and thousand come from locale_backend
+    #   money.format(locale: :en)          # locale passed to backend callable
+    #   money.format(locale: 'pt-BR')      # strings work too
+    #
+    def format(template = nil, decimal: nil, thousand: nil, width: nil, locale: nil)
+      template, decimal, thousand = resolve_format_options(template, decimal:, thousand:, locale:)
+
+      case template
+      when Hash # :noop - validated in Formatter.for
+      when String then template = { positive: template }
+      else        raise ArgumentError, 'Invalid template. Only String or Hash are accepted'
+      end
+
+      formatted = Formatter.for(template, decimal, thousand).format(self)
+
+      width ? formatted.rjust(width) : formatted
+    end
+
+    # Alias for {#format}. Takes the same arguments.
+    alias to_fs :format
+
+    private
+
+    def resolve_format_options(template, decimal:, thousand:, locale:)
+      backend_opts = Mint.resolve_locale_for(locale:)
+
+      template ||= backend_opts[:format] || DEFAULT_FORMAT
+      decimal ||= backend_opts[:decimal] || '.'
+      if thousand.nil?
+        thousand = backend_opts[:thousand] || ','
+        thousand = false if thousand == decimal
+      end
+
+      [template, decimal, thousand]
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Mint
+  class Money
+    # Compiles and caches formatter lambdas for a fixed combination of format
+    # template, currency, and separator configuration.
+    #
+    # Use {.for} to obtain a cached instance; avoid +new+ directly unless you
+    # want an uncached formatter (typically only useful for testing).
+    #
+    # @api private
+    class Formatter
+      extend FormatterValidator
+
+      def self.cache = @cache ||= {}
+
+      # Returns a cached {Formatter} for the given configuration.
+      # @param format [Hash{Symbol => String}] per-sign templates
+      # @param decimal [String] decimal separator
+      # @param thousand [String, false] thousands delimiter (+false+ disables)
+      def self.for(format, decimal, thousand)
+        key = [format, decimal, thousand]
+        formatter = cache[key]
+        return formatter if formatter
+
+        validate_format!(format)
+        validate_separators!(decimal:, thousand:)
+
+        cache[key] = new(format, decimal, thousand)
+      end
+
+      def initialize(format, decimal, thousand)
+        @format = format
+        @decimal = decimal
+        @thousand = thousand
+        compile
+      end
+
+      SUBUNIT_PLACEHOLDER = "\uE000"
+      # Matches a digit followed by groups of exactly 3 digits that terminate
+      # at a non-digit or end-of-string. Used to insert thousand separators.
+      # e.g. "1234567" → "1" matches before "234" + "567" at string end.
+      THOUSAND_RE = /(\d)(?=(?:\d{3})+(?:[^\d]|$))/
+
+      def format(money)
+        amount = money.amount
+        currency = money.currency
+
+        template = @templates[amount <=> 0] || @positive_template
+        display_amount = template == @negative_template ? -amount : amount
+        integral = display_amount.to_i
+
+        template = template.gsub(SUBUNIT_PLACEHOLDER, currency.subunit.to_s) if @has_placeholder
+        result = Kernel.format(template,
+                               currency: currency.code,
+                               dsymbol: @needs_dsymbol && currency.dsymbol,
+                               symbol: currency.symbol,
+                               amount: display_amount,
+                               integral: integral,
+                               fractional: @needs_fractional ? money.fractional.abs : 0)
+        apply_separators(result, integral)
+      end
+
+      private
+
+      def apply_separators(result, integral)
+        unsigned_integral = integral.abs
+        int_str = unsigned_integral.to_s
+
+        result.sub!("#{int_str}.", "#{int_str}#{@decimal}") if @decimal != '.'
+
+        if @needs_thousand_substitution && unsigned_integral >= 1000
+          formatted_int = int_str.gsub(THOUSAND_RE, @thousand_replacement)
+          result.gsub!(int_str, formatted_int)
+        end
+        result
+      end
+
+      def compile
+        @templates = { -1 => @format[:negative], 0 => @format[:zero], 1 => @format[:positive] || Money::DEFAULT_FORMAT }
+        @templates.compact!
+        # Inject subunit precision into %<amount>f specs that lack an explicit
+        # precision. Matches "%<amount>f" or "%+10<amount>f" (with optional
+        # flags/width before the named ref) and appends a placeholder for the
+        # currency subunit digits — e.g. "%<amount>f" → "%<amount>\uE000f".
+        # The placeholder is later replaced with the actual subunit count at
+        # format time (e.g. "\uE000" → "2" for USD, "0" for JPY).
+        @templates.transform_values! { |f| f.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{SUBUNIT_PLACEHOLDER}f") }
+        @negative_template = @templates[-1]
+        @positive_template = @templates[1]
+
+        joined_template = @templates.values.join
+        @has_placeholder = joined_template.include?(SUBUNIT_PLACEHOLDER)
+        @needs_fractional = joined_template.include?('%<fractional>')
+        @needs_dsymbol = joined_template.include?('%<dsymbol>')
+        @needs_thousand_substitution = @thousand && !@thousand.empty? && (joined_template.include?('%<amount>') ||
+                         joined_template.include?('%<integral>'))
+        @thousand_replacement = "\\1#{@thousand}" if @needs_thousand_substitution
+      end
+    end
+  end
+end

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

@@ -7,119 +7,37 @@ module Mint
     # 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)' } },
-      european: { format: '%<amount>f %<symbol>s', decimal: ',', thousand: '.' },
-      currency: { format: '%<currency>s %<amount>f' }
-    }.freeze
+    # Match a digit followed by groups of 3 digits until end of string — inserts thousand separators.
+    THOUSAND_RE = /(\d)(?=(\d{3})+\z)/
 
-    # Formats money as a string with customizable format, thousand delimiter, and decimal
-    #
-    # @param preset [Symbol, nil] Named format preset, one of:
-    #   +:accounting+, +:european+, +:amount+, +:currency+.
-    #   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, %<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:
-    #
-    #     money.format(format: { negative: '(%<symbol>s%<amount>f)' })
-    #
-    #   Missing keys fall back to the module default, so a Hash with only
-    #   :negative will still format positives sensibly. The valid keys are
-    #   :positive, :negative, :zero; anything else raises ArgumentError.
-    #   When +nil+, falls back to +Mint.locale_backend+ if set, otherwise
-    #   +"%<symbol>s%<amount>f"+.
-    # @param thousand [String, false, nil] Thousands delimiter (e.g., ',' for 1,000).
-    #   When +nil+, falls back to +Mint.locale_backend+ if set, otherwise +","+.
-    # @param decimal [String, nil] Decimal separator (e.g., '.' or ',').
-    #   When +nil+, falls back to +Mint.locale_backend+ if set, otherwise +"."+.
-    # @return [String] Formatted money string
-    #
-    # @raise [ArgumentError] if +preset+ is not a recognised name, or if
-    #   +format+ is not a String or Hash, the Hash is empty, or the Hash
-    #   contains an unrecognised key.
-    #
-    # @example Basic formatting
-    #   money = Mint.money(1234.56, 'USD')
-    #   money.format                               #=> "$1,234.56"
-    #   money.format(thousand: '.', decimal: ',')  #=> "$1.234,56"
-    #   money.format(decimal: ',', thousand: '')   #=> "$1234,56"
+    # Returns a string representation of the money amount.
     #
-    # @example Preset formats
-    #   loss = Mint.money(-1234.56, 'USD')
-    #   loss.format(:accounting)                   #=> "($1,234.56)"
-    #   money.format(:european)                    #=> "1.234,56 €"
-    #   money.format(:amount)                      #=> "1234.56"
-    #   money.format(:currency)                    #=> "USD 1234.56"
+    # When no {Mint.locale_backend} is configured, uses +currency.symbol+,
+    # comma thousands separators for amounts >= 1000, and decimal for the
+    # fractional part. When a locale backend is set, delegates to {#format}
+    # so locale-aware formatting takes effect.
     #
-    # @example Custom formats
-    #   money.format(format: '%<amount>f')                    #=> "1234.56"
-    #   money.format(format: '%<currency>s %<amount>f')       #=> "USD 1234.56"
-    #   money.format(format: '%<amount>f %<symbol>s')         #=> "1234.56 $"
-    #   money.format(format: '%<symbol>s%<amount>+f')         #=> "$+1234.56"
+    # Unlike {#format}, this method takes **no arguments** — use
+    # {#format} (alias {#to_fs}) for custom formatting.
     #
-    # @example Integral & fractional parts
-    #   money.format(format: '%<integral>d.%<fractional>02d')  #=> "1234.56"
-    #   price = Mint.money(0.99, 'USD')
-    #   price.format(format: '%<integral>d dollars and %<fractional>02d cents')
-    #   #=> "0 dollars and 99 cents"
+    # @return [String] formatted money string
     #
-    # @example Per-sign Hash format (accounting parentheses)
-    #   loss = Mint.money(-1234.56, 'USD')
-    #   loss.format(format: { negative: '(%<symbol>s%<amount>f)' }) #=> "($1,234.56)"
-    #   Mint.money(0, 'BRL').format(format: { zero: '--' })        #=> "--"
-    #
-    # @example Padding and alignment
-    #   money.format(format: '%<amount>10.2f')                #=> "   1234.56"
-    #   money.format(format: '%<symbol>s%<amount>010.2f')     #=> "$0001234.56"
-    #
-    # @example Locale-aware formatting (with Mint.locale_backend set)
-    #   money.format  # decimal and thousand come from locale_backend
-    #
-    def format(preset = nil, format: nil, decimal: nil, thousand: nil, width: nil)
-      if preset
-        config = PRESETS.fetch(preset) { raise ArgumentError, "Unknown format preset: #{preset.inspect}" }
-        format ||= config[:format]
-        decimal ||= config[:decimal]
-        thousand ||= config[:thousand]
-        width ||= config[:width]
-      end
-
-      validate_separators!(decimal:, thousand:)
-
-      format, decimal, thousand = resolve_locale_for(format, decimal, thousand)
-
-      case format
-      when {}, '' then raise ArgumentError, 'format must not be empty'
-      when Hash   then validate_format_hash(format)
-      when String then format = { positive: format }
-      else        raise ArgumentError, 'Invalid format. Only String or Hash are accepted'
-      end
-
-      formatted = format_amount(format, decimal:, thousand:)
-
-      width ? formatted.rjust(width) : formatted
-    end
-
-    THOUSAND_RE = /(\d)(?=(\d{3})+\z)/
-
+    # @example
+    #   Money.from(1234.56, 'USD').to_s  #=> "$1,234.56"
+    #   Money.from(0.99, 'USD').to_s     #=> "$0.99"
+    #   Money.from(100, 'JPY').to_s      #=> "¥100"
     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
+      subunit = currency.subunit
+      major = integral.to_s
+      major.gsub!(THOUSAND_RE, '\1,') if amount.abs >= 1000
       if subunit > 0
-        "#{currency.symbol}#{integral}.#{fractional.to_s.rjust(subunit, '0')}"
+        minor = fractional.abs.to_s.rjust(subunit, '0')
+        "#{currency.symbol}#{major}.#{minor}"
       else
-        "#{currency.symbol}#{integral}"
+        "#{currency.symbol}#{major}"
       end
     end
-
-    alias to_fs :format
   end
 end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mint
+  class Money
+    # Shared validation for format templates and separator configuration.
+    #
+    # @api private
+    module FormatterValidator
+      def validate_format!(format)
+        raise ArgumentError, 'template must not be empty' if format == {}
+
+        unknown = format.keys - %i[positive negative zero]
+        raise ArgumentError, "Unknown format parameter(s): #{unknown.inspect}. " unless unknown.empty?
+      end
+
+      def validate_separators!(decimal:, thousand:)
+        case decimal
+        when ''       then raise ArgumentError, "decimal separator must be a non-empty - #{decimal.inspect}"
+        when /\d/     then raise ArgumentError, "decimal separator cannot be a numeral - #{decimal.inspect}"
+        when thousand then raise ArgumentError, "decimal and thousand cannot be identical - #{decimal.inspect}"
+        when String # :noop
+        else raise ArgumentError, "decimal must be a String, false, or nil, got #{decimal.inspect}"
+        end
+
+        case thousand
+        when false, nil # :noop
+        when /\d/ then raise ArgumentError, "decimal separator cannot be a numeral - #{decimal.inspect}"
+        when String # :noop
+        else raise ArgumentError, "thousand must be a String, false, or nil, got #{thousand.inspect}"
+        end
+      end
+    end
+  end
+end