minting 1.9.7 → 2.0.0

data/lib/minting/currency/currency.rb

@@ -30,6 +30,8 @@ module Mint
       subunit = subunit.to_i
       priority = priority.to_i
       fractional_multiplier = 10**subunit
+      symbol = nil if symbol && symbol.empty?
+      disambiguate_symbol = nil if [code, symbol].include? disambiguate_symbol
       super(code:, subunit:, symbol:, priority:, country:, name:,
             fractional_multiplier:, disambiguate_symbol:)
     end
@@ -40,17 +42,29 @@ module Mint
     # @return [Rational] smallest representable amount (1/fractional_multiplier)
     def minimum_amount = Rational(1, fractional_multiplier)
 
-    # Normalizes numeric amounts for this currency
-    # 1. Converts to Rational
-    # 2. Rounds to respect currency subunit
+    # Normalizes a numeric amount for this currency.
+    #
+    # @param amount [Numeric] the monetary amount to normalize
+    # @return [Rational] the amount converted to +Rational+ and rounded to
+    #   the currency's subunit precision (half-up by default)
+    # @example
+    #   usd = Money::Currency.for_code('USD')
+    #   usd.normalize_amount(10.567)  #=> (10567/1000)
+    #   usd.normalize_amount("5.25")  #=> (21/4)
+    #
+    # @see Mint::Rounding.apply Custom rounding modes via {Money.with_rounding}
     def normalize_amount(amount) = amount.to_r.round(subunit)
 
     # Returns the cached frozen zero-Money for this currency.
     #
     # @return [Money] a frozen zero-Money instance
     # @example
-    #   Mint::Currency.for_code('USD').zero  #=> [USD 0.00]
+    #   Money::Currency.for_code('USD').zero  #=> [USD 0.00]
     def zero = Registry.zero_for(self)
+
+    def dsymbol
+      disambiguate_symbol || (Registry.symbol_shared?(symbol) ? code : symbol)
+    end
   end
 
   # Registers a new currency, raising a KeyError if already registered.
@@ -68,20 +82,37 @@ module Mint
 
   # Resolves an object into a {Currency}, returning +nil+ when it can't.
   #
-  # Accepts +nil+, +String+, {Currency}, or {Money}.
-  # Passing a {Money} extracts its currency
+  # Accepts +nil+, +String+, {Currency}, {Money}, or any object implementing
+  # +#to_currency+ (must return {Currency}) or +#currency_code+ (must return +String+).
   #
-  # @param object [String, Currency, Money, nil] a currency code, object, or +nil+
+  # @param object [String, Currency, Money, nil, #to_currency, #currency_code]
+  #   a currency code, object, or +nil+
   # @return [Currency, nil] the resolved Currency, or +nil+ if +object+ is +nil+
   #   or the code is not registered
-  # @raise [ArgumentError] if +object+ is an unsupported type (e.g. +Integer+)
+  # @raise [ArgumentError] if +object+ is an unsupported type, or if the method
+  #   used to resolve it returns a value of the wrong type
   def Currency.resolve(object)
     case object
     when NilClass then nil
     when Currency then object
     when Money    then object.currency
     when String   then Currency.for_code object
-    else          raise ArgumentError, "currency must be [Currency], [Money], [String] or nil (#{object})"
+    else
+      if object.respond_to?(:to_currency)
+        result = object.to_currency
+        unless result.is_a?(Currency)
+          raise ArgumentError, "#to_currency must return a [Money::Currency], got #{result.class}"
+        end
+
+        result
+      elsif object.respond_to?(:currency_code)
+        result = object.currency_code
+        raise ArgumentError, "#currency_code must return a [String], got #{result.class}" unless result.is_a?(String)
+
+        Currency.for_code result
+      else
+        raise ArgumentError, "currency must be [Money::Currency], [Money], [String] or nil (#{object})"
+      end
     end
   end
 
@@ -98,6 +129,15 @@ module Mint
     resolve(object) or raise Mint::UnknownCurrency, "Could not resolve (#{object}) into a currency"
   end
 
+  # Returns all registered currencies as a frozen hash keyed by ISO code.
+  #
+  # @return [Hash{String => Currency}] frozen hash of all registered currencies
+  # @example Iterate over registered currencies
+  #   Currency.registered_currencies.each { |code, currency| puts "#{code}: #{currency.name}" }
+  # @example Count of registered currencies
+  #   Currency.registered_currencies.size  #=> 154
+  def Currency.registered_currencies = Registry.currencies
+
   # Looks up a registered currency by its alpha code.
   #
   # @param code [String] the currency code
@@ -121,4 +161,36 @@ module Mint
   # @return [Money] a frozen zero-Money
   # @raise [Mint::UnknownCurrency] if the currency can't be resolved
   def Currency.zero(currency) = Registry.zero_for(Currency.resolve!(currency))
+
+  # Returns the frozen hash of all built-in ISO 4217 world currencies.
+  #
+  # @return [Hash{String => Currency}] ISO-4217 world currencies mapped by code
+  # @api private
+  def Currency.world_currencies = Registry.world_currencies
+
+  # 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 Currency.crypto_currencies = Registry.crypto_currencies
+
+  # 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 Currency.register_crypto(...) = Registry.register_crypto(...)
+
+  # 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 Currency.register_all_crypto = Registry.register_all_crypto
 end

data/lib/minting/data/crypto-currencies.yaml

@@ -0,0 +1,126 @@
+---
+- code: BTC
+  subunit: 8
+  symbol: "₿"
+  priority: 1000
+  name: Bitcoin
+- code: ETH
+  subunit: 18
+  symbol: "Ξ"
+  priority: 950
+  name: Ethereum
+- code: USDT
+  subunit: 6
+  symbol: "$"
+  priority: 900
+  name: Tether
+- code: SOL
+  subunit: 9
+  symbol: "◎"
+  priority: 850
+  name: Solana
+- code: XRP
+  subunit: 6
+  symbol: "✕"
+  priority: 800
+  name: XRP
+- code: BNB
+  subunit: 8
+  symbol: ""
+  priority: 750
+  name: BNB
+- code: USDC
+  subunit: 6
+  symbol: "$"
+  priority: 740
+  name: USD Coin
+- code: DOGE
+  subunit: 8
+  symbol: "Ð"
+  priority: 730
+  name: Dogecoin
+- code: ADA
+  subunit: 6
+  symbol: "₳"
+  priority: 720
+  name: Cardano
+- code: TRX
+  subunit: 6
+  symbol: ""
+  priority: 710
+  name: TRON
+- code: AVAX
+  subunit: 9
+  symbol: ""
+  priority: 700
+  name: Avalanche
+- code: DOT
+  subunit: 10
+  symbol: ""
+  priority: 680
+  name: Polkadot
+- code: LINK
+  subunit: 8
+  symbol: ""
+  priority: 660
+  name: Chainlink
+- code: MATIC
+  subunit: 6
+  symbol: "⧫"
+  priority: 640
+  name: Polygon
+- code: SHIB
+  subunit: 8
+  symbol: ""
+  priority: 620
+  name: Shiba Inu
+- code: UNI
+  subunit: 8
+  symbol: ""
+  priority: 600
+  name: Uniswap
+- code: ATOM
+  subunit: 6
+  symbol: ""
+  priority: 580
+  name: Cosmos
+- code: LTC
+  subunit: 8
+  symbol: "Ł"
+  priority: 560
+  name: Litecoin
+- code: BCH
+  subunit: 8
+  symbol: ""
+  priority: 540
+  name: Bitcoin Cash
+- code: FIL
+  subunit: 9
+  symbol: ""
+  priority: 520
+  name: Filecoin
+- code: APT
+  subunit: 8
+  symbol: ""
+  priority: 500
+  name: Aptos
+- code: SUI
+  subunit: 9
+  symbol: ""
+  priority: 480
+  name: Sui
+- code: TON
+  subunit: 9
+  symbol: ""
+  priority: 460
+  name: Toncoin
+- code: PEPE
+  subunit: 8
+  symbol: ""
+  priority: 440
+  name: Pepe
+- code: STX
+  subunit: 6
+  symbol: ""
+  priority: 420
+  name: Stacks

data/lib/minting/mint/i18n.rb

@@ -5,52 +5,102 @@ module Mint
   class << self
     # Optional callable that returns a Hash with locale-aware formatting defaults.
     #
-    # The callable receives no arguments and returns a Hash with these keys:
-    #   [+:decimal+]   Decimal separator (e.g. +","+)
-    #   [+:thousand+]  Thousands delimiter (e.g. +"."+)
-    #   [+:format+]    Format template string (e.g. +"%<amount>f %<symbol>s"+)
+    # The callable receives the locale (as passed to +#format+'s +locale:+ kwarg,
+    # or +nil+ when omitted) and returns a Hash with these keys (strings and
+    # symbols are treated interchangeably):
+    #   [+decimal+]   Decimal separator (e.g. +","+) — also accepts +:separator+
+    #   [+thousand+]  Thousands delimiter (e.g. +"."+) — also accepts +:delimiter+
+    #   [+format+]    Format template string (e.g. +"%<amount>f %<symbol>s"+)
     #
     # When set, +#to_formatted_s+ and +#format+ use these values as fallbacks when the
     # corresponding parameter is not explicitly provided.
     #
-    # @example Rails I18n integration (in attribute-money railtie)
-    #   Mint.locale_backend = -> {
-    #     fmt = I18n.t('number.currency.format')
-    #     {
-    #       decimal: fmt[:separator],
-    #       thousand: fmt[:delimiter],
-    #       format: fmt[:format] == '%n %u' ? '%<amount>f %<symbol>s' : '%<symbol>s%<amount>f'
-    #     }
+    # @example Per-locale formatting with string keys
+    #   LOCALE_DATA = {
+    #     'en'    => { decimal: '.', thousand: ',', format: '%<symbol>s%<amount>f' },
+    #     'de'    => { decimal: ',', thousand: '.', format: '%<amount>f %<currency>s' },
+    #   }.freeze
+    #   Mint.locale_backend = ->(locale) { LOCALE_DATA[locale.to_s] || {} }
+    #
+    # @example Rails I18n integration (direct pass-through, no mapping needed)
+    #   Mint.locale_backend = ->(locale = nil) {
+    #     I18n.with_locale(locale || I18n.default_locale) do
+    #       I18n.t('number.currency.format', default: {})
+    #     end
     #   }
     #
     # @return [Proc, #call, nil]
     attr_accessor :locale_backend
   end
 
+  # Resolves locale-aware formatting defaults from +Mint.locale_backend+.
+  #
+  # Returns a Hash with +:decimal+, +:thousand+, and +:format+ keys (any of
+  # which may be +nil+ if the backend doesn't provide them).
+  #
+  # @param locale [Symbol, String, nil] locale passed to the backend callable
+  # @return [Hash{Symbol => String, nil}]
   # @api private
-  class Money
-    private
+  def self.resolve_locale_for(locale: nil)
+    return EMPTY_LOCALE if Mint.locale_backend.nil?
+
+    lc = resolve_locale_backend(locale)
+    return EMPTY_LOCALE if lc.empty?
+
+    { decimal: fetch_locale_key(lc, :decimal),
+      thousand: fetch_locale_key(lc, :thousand),
+      format: fetch_locale_key(lc, :format) }.freeze
+  end
 
-    # Resolves format/decimal/thousand from locale_backend when not explicitly given.
-    # @private
-    def resolve_locale_for(format, decimal, thousand)
-      locale = locale_backend
+  EMPTY_LOCALE = { decimal: nil, thousand: nil, format: nil }.freeze
 
-      [format || locale[:format] || DEFAULT_FORMAT,
-       decimal || locale[:decimal] || '.',
-       thousand.nil? ? (locale[:thousand] || ',') : thousand]
+  # Looks up a locale key from a hash, trying both symbol and string forms.
+  #
+  # Supports aliases: +:decimal+ checks +:decimal+ and +:separator+,
+  # +:thousand+ checks +:thousand+ and +:delimiter+, +:format+ checks +:format+.
+  #
+  # @param hash [Hash] locale config hash
+  # @param key [Symbol] the primary key (+:decimal+, +:thousand+, or +:format+)
+  # @return [String, nil] the value found, or nil
+  # @api private
+  def self.fetch_locale_key(hash, key)
+    aliases = { decimal: %i[decimal separator], thousand: %i[thousand delimiter], format: [:format] }
+    aliases.fetch(key).each do |name|
+      val = hash[name] || hash[name.to_s]
+      return val unless val.nil?
     end
+    nil
+  end
 
-    def locale_backend
-      case bk = Mint.locale_backend
-      when Hash     then bk
-      when NilClass then {}
-      else
-        return bk.call if bk.respond_to?(:call)
+  # Resolves the locale backend configuration into a Hash.
+  #
+  # Handles three backend types:
+  # - +Hash+: returned as-is
+  # - +Proc+/callable: called with the locale (or no args for 0-arity),
+  #   result must be a Hash or nil
+  # - +nil+: returns empty Hash
+  #
+  # Invalid return values or backends emit a warning and return +{}+.
+  #
+  # @param locale [Symbol, String, nil] locale passed to the backend callable
+  # @return [Hash] locale configuration (possibly empty)
+  # @api private
+  def self.resolve_locale_backend(locale = nil)
+    case bk = Mint.locale_backend
+    when Hash     then bk
+    when NilClass then {}
+    else
+      if bk.respond_to?(:call)
+        args = bk.respond_to?(:arity) && bk.arity == 0 ? [] : [locale]
+        result = bk.call(*args)
+        return result if result.is_a?(Hash) || result.nil?
 
-        warn "ignoring invalid locale_backend: #{bk.inspect}"
-        {}
+        warn "ignoring invalid locale_backend result: #{result.inspect}"
+        return {}
       end
+
+      warn "ignoring invalid locale_backend: #{bk.inspect}"
+      {}
     end
   end
 end

data/lib/minting/mint/mint.rb

@@ -14,36 +14,11 @@ module Mint
   # @param amount [Numeric] the financial value
   # @param currency_code [String, Currency, Money, nil] Currency code, object,
   #   Money whose currency to reuse, or +nil+. Passed through
-  #   {Mint::Currency.resolve!} so all accepted types resolve to a registered
+  #   {Money::Currency.resolve!} so all accepted types resolve to a registered
   #   currency.
   # @return [Money] the instantiated Money object
   # @raise [ArgumentError] if the amount is not a Numeric
   # @raise [Mint::UnknownCurrency] if the currency code is not registered.
   #   +Mint::UnknownCurrency+ inherits from +ArgumentError+.
   def self.money(amount, currency_code) = Money.from(amount, currency_code)
-
-  # @return [Hash{String => Currency}] the frozen world-currencies hash
-  # @api private
-  def self.world_currencies = Registry.world_currencies
-
-  # Executes a block with a specific rounding mode applied to all money
-  # construction, parsing, change, allocation, and split operations.
-  #
-  # Restores the previous mode (or default) when the block exits, even on
-  # exception.
-  #
-  # Rounding-mode support is loaded lazily on first call. Once loaded,
-  # +Currency#normalize_amount+ is patched to dispatch through the
-  # rounding module, adding ~10–35&ns of overhead to every money creation
-  # or mutation. When rounding modes are never used (the common case),
-  # the fast path incurs zero overhead.
-  #
-  # @param mode [Symbol] one of: +:half_up+, +:half_down+, +:floor+,
-  #   +:ceil+, +:truncate+, +:down+
-  # @yield block to execute with the rounding mode active
-  # @raise [ArgumentError] if +mode+ is not a recognised rounding mode
-  def self.with_rounding(mode, &)
-    require_relative 'rounding' unless defined?(Mint::Rounding)
-    Rounding.with_mode(mode, &)
-  end
 end

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

@@ -17,11 +17,13 @@ module Mint
       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.
@@ -31,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
@@ -48,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?