minting 1.9.6 → 2.0.0

data/lib/minting/mint/registry/crypto.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Crypto currency definitions (opt-in registration)
+module Mint
+  # Internal registry for currencies, symbols, and zero-money cache.
+  module Registry
+    @crypto_currencies = nil
+    CRYPTO_MUTEX = Monitor.new
+
+    private_constant :CRYPTO_MUTEX
+
+    # Returns the list of built-in crypto currency definitions.
+    #
+    # These are not registered by default — call {.register_crypto} to opt in.
+    #
+    # @return [Array<Currency>] frozen array of crypto currency definitions
+    def self.crypto_currencies
+      @crypto_currencies || CRYPTO_MUTEX.synchronize do
+        @crypto_currencies ||= begin
+          path = File.join(File.expand_path('../../data', __dir__), 'crypto-currencies.yaml')
+          YAML.load_file(path).map { |entry| Currency.new(**entry.transform_keys(&:to_sym)) }.freeze
+        end
+      end
+    end
+
+    # Registers one or more crypto currencies into the shared currency registry.
+    #
+    # Raises on duplicate registration or unknown code — use +rescue+ if
+    # idempotent bulk registration is needed.
+    #
+    # @param codes [Array<String>] one or more crypto currency codes
+    # @raise [ArgumentError] if a code is not a known crypto currency
+    # @raise [KeyError] if the currency code is already registered
+    # @return [Array<Currency>] the newly registered Currency objects
+    def self.register_crypto(*codes)
+      entries = crypto_currencies
+      index = entries.each_with_index.to_h { |currency, index| [currency.code, index] }
+      missing = codes.reject { |code| index.key?(code) }
+      raise ArgumentError, "Unknown crypto code(s): #{missing.join(', ')}" unless missing.empty?
+
+      codes.map do |code|
+        c = entries[index[code]]
+        Currency.register(code:, subunit: c.subunit, symbol: c.symbol, priority: c.priority)
+      end
+    end
+
+    # Registers all built-in crypto currencies at once.
+    #
+    # Raises on the first duplicate — call +rescue+ if idempotency is needed.
+    #
+    # @raise [KeyError] if any currency code is already registered
+    # @return [Array<Currency>] the newly registered Currency objects
+    def self.register_all_crypto
+      crypto_currencies.map do |c|
+        Currency.register(code: c.code, subunit: c.subunit, symbol: c.symbol, priority: c.priority)
+      end
+    end
+  end
+end

data/lib/minting/mint/registry/registration.rb

@@ -24,8 +24,7 @@ module Mint
 
         currency = Currency.new(code:, subunit:, symbol:, priority:)
         @currencies = @currencies.merge(code => currency).freeze
-        @currency_symbols = nil
-        @currency_symbol_map = nil
+        @symbols_list = nil
         currency
       end
     end

data/lib/minting/mint/registry/symbols.rb

@@ -5,44 +5,51 @@ module Mint
   module Registry
     extend self
 
-    # Looks up a currency by its display symbol.
-    #
-    # @param symbol [String] the display symbol (e.g. "$", "R$")
-    # @return [Currency, nil] the highest-priority currency for the symbol
-    # @api private
     def currency_for_symbol(symbol)
-      @currency_symbol_map || MUTEX.synchronize { @currency_symbol_map = currency_symbols.to_h.freeze }
-      @currency_symbol_map[symbol]
+      sync_symbols
+      @symbols_map[symbol]
+    end
+
+    def symbol_shared?(symbol)
+      sync_symbols
+      @shared_symbols.include?(symbol)
     end
 
-    # Scans +input+ for registered currency symbols and returns the first match.
-    #
-    # @param input [String] the string to scan
-    # @return [Currency, nil]
-    # @api private
     def detect_currency(input)
-      currency_symbols.each do |symbol, currency|
-        return currency if input.include?(symbol)
-      end
-      nil
+      sync_symbols
+      input.match(@symbols_regex) { |m| @symbols_map[m[0]] }
     end
 
     private
 
-    # Registered symbols sorted for detection: longest match wins, then parser priority.
-    # Duplicate symbols are deduplicated — the highest-priority currency wins.
-    #
-    # @return [Array<Array<String, Currency>>] sorted symbol-to-currency mappings
-    # @api private
-    def currency_symbols
-      @currency_symbols || MUTEX.synchronize do
-        @currency_symbols =
-          currencies.values
-                    .reject { |currency| currency.symbol.empty? }
-                    .map { |currency| [currency.symbol, currency] }
-                    .sort_by { |symbol, currency| [-symbol.length, -currency.priority] }
-                    .uniq { |symbol, _| symbol }
-                    .freeze
+    def build_symbol_regex(symbols)
+      /(?<![a-zA-Z])#{Regexp.union(symbols)}(?![a-zA-Z])/
+    end
+
+    def sync_symbols
+      MUTEX.synchronize do
+        return if @symbols_list
+
+        symbols_list = []
+        currencies.each_value do |currency|
+          next unless currency.symbol
+
+          symbols_list << [currency.symbol, currency]
+          symbols_list << [currency.disambiguate_symbol, currency] if currency.disambiguate_symbol
+        end
+
+        @shared_symbols = symbols_list.map(&:first).tally
+                                      .select { |_, count| count > 1 }
+                                      .keys
+                                      .to_set
+                                      .freeze
+
+        symbols_list.sort_by! { |sym, cur| [-sym.length, -cur.priority] }
+        symbols_list.uniq! { |sym, _| sym }
+
+        @symbols_list  = symbols_list.freeze
+        @symbols_map   = symbols_list.to_h.freeze
+        @symbols_regex = build_symbol_regex(@symbols_map.keys)
       end
     end
   end

data/lib/minting/mint/rounding.rb

@@ -10,17 +10,20 @@ module Mint
     MODES = {
       half_up: ->(amount, ndigits) { amount.round(ndigits, half: :up) },
       half_down: ->(amount, ndigits) { amount.round(ndigits, half: :down) },
+      half_even: ->(amount, ndigits) { amount.round(ndigits, half: :even) },
       floor: ->(amount, ndigits) { amount.floor(ndigits) },
       ceil: ->(amount, ndigits) { amount.ceil(ndigits) },
       truncate: ->(amount, ndigits) { amount.truncate(ndigits) },
       down: ->(amount, ndigits) { amount.truncate(ndigits) }
     }.freeze
 
+    THREAD_KEY = :minting_rounding_mode
+
     # Returns the currently active rounding mode, falling back to +:half_up+.
     # @api private
     # @return [Symbol]
     def self.current_mode
-      Thread.current[:minting_rounding_mode] || :half_up
+      Thread.current[THREAD_KEY] || :half_up
     end
 
     # Rounds +amount+ to +ndigits+ using the currently scoped rounding mode.
@@ -30,7 +33,7 @@ module Mint
     # @param ndigits [Integer]
     # @return [Rational]
     def self.apply(amount, ndigits)
-      mode = Thread.current[:minting_rounding_mode]
+      mode = Thread.current[THREAD_KEY]
       if mode
         MODES.fetch(mode).call(amount.to_r, ndigits)
       else
@@ -47,18 +50,18 @@ module Mint
     def self.with_mode(mode)
       raise ArgumentError, "Unknown rounding mode: #{mode}" unless MODES.key?(mode)
 
-      prev = Thread.current[:minting_rounding_mode]
-      Thread.current[:minting_rounding_mode] = mode
+      prev = Thread.current[THREAD_KEY]
+      Thread.current[THREAD_KEY] = mode
       yield
     ensure
-      Thread.current[:minting_rounding_mode] = prev
+      Thread.current[THREAD_KEY] = prev
     end
   end
 end
 
 # When loaded, patch Currency to delegate rounding through this module.
 # Remove the default fast-path method first to avoid redefinition warnings.
-Mint::Currency.remove_method(:normalize_amount)
-Mint::Currency.define_method(:normalize_amount) do |amount|
+Money::Currency.remove_method(:normalize_amount)
+Money::Currency.define_method(:normalize_amount) do |amount|
   Mint::Rounding.apply(amount, subunit)
 end

data/lib/minting/mint.rb

@@ -7,8 +7,7 @@ require_relative 'mint/dsl/range'
 require_relative 'mint/dsl/string'
 require_relative 'mint/i18n'
 require_relative 'mint/mint'
-require_relative 'mint/parser/parser'
-require_relative 'mint/parser/separators'
 require_relative 'mint/registry/registry'
+require_relative 'mint/registry/crypto'
 
 require_relative 'money/money'

data/lib/minting/money/allocation/allocation.rb

@@ -10,14 +10,14 @@ module Mint
     # @raise [ArgumentError] if the proportions list is empty or sums to zero
     #
     # @example Proportional allocation
-    #   money = Mint.money(10.00, 'USD')
+    #   money = Money.from(10.00, 'USD')
     #   money.allocate([1, 2, 3]) #=> [[USD 1.67], [USD 3.33], [USD 5.00]]
     def allocate(proportions)
       whole = proportions.sum.to_r
       raise ArgumentError, 'Need at least 1 proportion element' if proportions.empty?
       raise ArgumentError, 'Proportions total must not be zero' if whole.zero?
 
-      amounts = proportions.map { |rate| currency.normalize_amount(Rational(amount * rate, whole)) }
+      amounts = proportions.map { |rate| currency.normalize_amount(amount * rate / whole) }
       allocate_left_over(amounts: amounts, left_over: amount - amounts.sum)
     end
   end

data/lib/minting/money/allocation/split.rb

@@ -12,7 +12,7 @@ module Mint
     # @raise [ArgumentError] if quantity is not a positive integer
     #
     # @example Even split
-    #   money = Mint.money(10.00, 'USD')
+    #   money = Money.from(10.00, 'USD')
     #   money.split(3) #=> [[USD 3.34], [USD 3.33], [USD 3.33]]
     def split(slices)
       raise ArgumentError, 'Slices quantity must be an poitive integer' unless slices.positive? && slices.integer?

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'bigdecimal'
+require 'bigdecimal/util'
 require 'erb'
 
 module Mint
@@ -10,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.
@@ -26,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