minting 1.7.0 → 1.7.3

data/lib/minting/money/{allocation.rb → allocation/split.rb}

@@ -3,25 +3,6 @@
 module Mint
   # Allocation and splitting
   class Money
-    # Proportionally allocates the monetary amount among a list of ratios.
-    # Disperses any subunit rounding amounts across the initial slots
-    # @param proportions [Array<Numeric>] a list of numeric proportions/ratios to allocate by
-    # @return [Array<Money>] the list of newly allocated Money objects
-    # @raise [ArgumentError] if the proportions list is empty or sums to zero
-    #
-    # @example Proportional allocation
-    #   money = Mint.money(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?
-
-      subunit = currency.subunit
-      amounts = proportions.map { |rate| Rational(amount * rate, whole).round(subunit) }
-      allocate_left_over(amounts: amounts, left_over: amount - amounts.sum)
-    end
-
     # Splits the monetary amount into a given quantity of equal parts.
     # Disperses any fractional subunit rounding differences across the initial slots
     # so that the sum is preserved.
@@ -46,6 +27,7 @@ module Mint
     # Distributes any leftover amount across the allocation slots by adjusting
     # individual amounts by the currency's minimum unit, and converting to Money.
     # Caution: amounts array is mutated by this method
+    # @private
     def allocate_left_over(amounts:, left_over:)
       if left_over.nonzero?
         minimum = currency.minimum_amount

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mint
+  # Money Arithmetics
+  class Money
+    # Returns the absolute value of the monetary amount as a new {Money} instance.
+    #
+    # @return [Money] the absolute value
+    def abs = mint(amount.abs)
+
+    # Returns true if the monetary amount is less than zero.
+    #
+    # @return [Boolean] true if negative, false otherwise
+    def negative? = amount.negative?
+
+    # Returns true if the monetary amount is greater than zero.
+    #
+    # @return [Boolean] true if positive, false otherwise
+    def positive? = amount.positive?
+
+    # Returns the successor of the Money instance by adding the minimum possible subunit amount.
+    # Enables standard ranges and stepping (e.g. `1.dollar..10.dollars`).
+    #
+    # @return [Money] successor Money instance
+    def succ = mint(amount + currency.minimum_amount)
+  end
+end

data/lib/minting/money/{arithmetics.rb → arithmetics/operators.rb}

@@ -3,27 +3,6 @@
 module Mint
   # Money Arithmetics
   class Money
-    # Returns the absolute value of the monetary amount as a new {Money} instance.
-    #
-    # @return [Money] the absolute value
-    def abs = mint(amount.abs)
-
-    # Returns true if the monetary amount is less than zero.
-    #
-    # @return [Boolean] true if negative, false otherwise
-    def negative? = amount.negative?
-
-    # Returns true if the monetary amount is greater than zero.
-    #
-    # @return [Boolean] true if positive, false otherwise
-    def positive? = amount.positive?
-
-    # Returns the successor of the Money instance by adding the minimum possible subunit amount.
-    # Enables standard ranges and stepping (e.g. `1.dollar..10.dollars`).
-    #
-    # @return [Money] successor Money instance
-    def succ = mint(amount + currency.minimum_amount)
-
     # Performs addition with another {Money} instance or standard zero Numeric.
     #
     # @param addend [Money, Numeric] the value to add

data/lib/minting/money/clamp.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Mint
+  # Money clamp
+  class Money
+    # Constrains +self+ to the inclusive range [+min+, +max+].
+    #
+    # Bounds may be:
+    # - nil meaning no boundary
+    # - same-currency {Money} or Range
+    # - Numeric amount, or Range
+    #
+    # Numeric is interpreted as an amount in +self+'s currency, so the common
+    # pricing idiom +price.clamp(0, 100)+ reads as "0 to 100 in the same
+    # currency as +price+".
+    #
+    # When +self+ is already in range the receiver is returned (no new object
+    # allocated). When out of range, the nearest bound is returned as a new
+    # frozen {Money} in +self+'s currency.
+    #
+    # @param min_or_range [Money, Numeric, Range, nil] lower bound (inclusive), or range
+    # @param max [Money, Numeric, nil] upper bound (inclusive)
+    # @return [Money] +self+ if in range, otherwise the nearer bound
+    # @raise [ArgumentError] if +min+ or +max+ is not a Money, Numeric or nil; if
+    #   a Money operand has a different currency; if +min+ > +max+;
+    #   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)
+    #
+    # @example Out of range, with Numeric bounds
+    #   Mint.money(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.clamp(floor, ceil) #=> [USD 0.00]
+    #
+    # @example Subunit-0 currency (JPY)
+    #   Mint.money(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
+
+        min, max = min_or_range.minmax
+      else
+        min = min_or_range
+      end
+      mint(amount.clamp(normalize_boundary(min), normalize_boundary(max)))
+    end
+
+    private
+
+    # Converts a clamp boundary to a numeric amount.
+    # @private
+    def normalize_boundary(boundary)
+      case boundary
+      in NilClass | Numeric                then boundary
+      in Money if same_currency?(boundary) then boundary.amount
+      in Money                             then raise ArgumentError, "oundary currency must be: #{currency_code}"
+      else                                 raise ArgumentError, "Boundary must be Numeric or Money #{boundary}"
+      end
+    end
+  end
+end

data/lib/minting/money/coercion.rb

@@ -23,6 +23,8 @@ module Mint
       def initialize(value) = @value = value
 
       # @private
+      # Adds a CoercedNumber to a Money object.
+      # Only zero is a valid additive identity (returns the Money unchanged).
       def +(other)
         raise_coercion_error(:+, other) unless @value.zero?
 
@@ -30,6 +32,8 @@ module Mint
       end
 
       # @private
+      # Subtracts a Money object from a CoercedNumber.
+      # Only zero is valid (returns the negated Money).
       def -(other)
         raise_coercion_error(:-, other) unless @value.zero?
 
@@ -37,15 +41,20 @@ module Mint
       end
 
       # @private
+      # Multiplies a Money object by the wrapped numeric value.
+      # This is the standard coercion path for `Numeric * Money`.
       def *(other)
         other.mint(@value * other.amount)
       end
 
       # @private
+      # Divides a CoercedNumber by a Money object.
+      # Not a meaningful operation (what currency is the result?).
       def /(other)
         raise_coercion_error(:/, other)
       end
 
+      # @private
       # Only zero is dimensionless and comparable to Money.
       # e.g. 0 < price is meaningful; 0.5 < price is not (what currency is 0.5?).
       def <=>(other)
@@ -56,6 +65,7 @@ module Mint
 
       private
 
+      # Raises a TypeError with a descriptive message for unsupported coercions.
       def raise_coercion_error(operation, operand)
         raise TypeError, "#{@value} #{operation} #{operand} : incompatible operands"
       end

data/lib/minting/money/comparable.rb

@@ -14,6 +14,10 @@ module Mint
       end
     end
 
+    # Strict equality — both amount and currency must match exactly.
+    # Unlike ==, does not treat zero as equivalent across currencies.
+    #
+    # @return [Boolean]
     def eql?(other)
       other.is_a?(Mint::Money) &&
         amount == other.amount &&
@@ -37,8 +41,10 @@ module Mint
       end
     end
 
+    # @return [self, nil] self if amount is non-zero, nil otherwise
     def nonzero? = amount.nonzero?
 
+    # @return [Boolean] true if amount is zero
     def zero? = amount.zero?
   end
 end

data/lib/minting/money/constructors.rb

@@ -10,10 +10,10 @@ module Mint
     def self.create(amount, currency)
       raise ArgumentError, 'amount must be Numeric' unless amount.is_a?(Numeric)
 
-      checked_currency = Mint.currency(currency)
-      raise ArgumentError, "Currency not found (#{currency})" unless checked_currency
+      currency = Currency.resolve!(currency)
+      amount = currency.normalize_amount(amount)
 
-      new(checked_currency.normalize_amount(amount), checked_currency)
+      amount.zero? ? Mint.zero(currency) : new(amount, currency)
     end
 
     # Builds a Money from a fractional (smallest-unit) Integer amount.
@@ -37,11 +37,9 @@ module Mint
     def self.from_fractional(fractional, currency)
       raise ArgumentError, 'fractional must be an Integer' unless fractional.is_a?(Integer)
 
-      checked_currency = Mint.currency(currency)
-      raise ArgumentError, "Currency not found (#{currency})" unless checked_currency
-
-      amount = Rational(fractional, checked_currency.fractional_multiplier)
-      new(amount, checked_currency)
+      currency = Currency.resolve!(currency)
+      amount = Rational(fractional, currency.fractional_multiplier)
+      amount.zero? ? Mint.zero(currency) : new(amount, currency)
     end
 
     # Returns a new Money object with the specified amount, or self if unchanged.
@@ -56,7 +54,14 @@ module Mint
     #   price.mint(10.00)  #=> [USD 10.00] (returns self)
     def mint(new_amount)
       new_amount = currency.normalize_amount(new_amount)
-      new_amount == amount ? self : Money.new(new_amount, currency)
+
+      if new_amount == amount
+        self
+      elsif new_amount.zero?
+        Mint.zero(currency)
+      else
+        Money.new(new_amount, currency)
+      end
     end
 
     private

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mint
+  # Formatting functionality for Money objects
+  class Money
+    private
+
+    # Resolves format/decimal/thousand from locale_backend when not explicitly given.
+    # @private
+    def resolve_locale_for(format, decimal, thousand)
+      locale = locale_backend
+      [format || locale[:format] || '%<symbol>s%<amount>f',
+       decimal || locale[:decimal] || '.',
+       thousand || locale[:thousand] || ',']
+    end
+
+    def locale_backend
+      bk = Mint.locale_backend
+      return {} unless bk.respond_to?(:call)
+
+      bk.call
+    end
+
+    # Selects the appropriate format template and value based on the amount's sign.
+    # @private
+    def select_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], amount]
+      end
+    end
+
+    # Validates that format hash contains only known keys.
+    # @private
+    def validate_format_hash(format)
+      unknown = format.keys - %i[positive negative zero]
+
+      raise ArgumentError, "Unknown format parameter(s): #{unknown.inspect}. " unless unknown.empty?
+    end
+
+    # Applies a format template to produce a formatted string representation.
+    # @private
+    def format_amount(format)
+      format, value = select_format(format)
+      format ||= '%<symbol>s%<amount>f'
+      # Automatically adjust decimal places based on currency subunit if missing
+      format = format.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{currency.subunit}f")
+
+      refs = format.scan(/%<(\w+)>/).flatten.map(&:to_sym)
+      all_args = { amount: value, currency: currency_code, symbol: currency.symbol }
+      Kernel.format(format, **all_args.slice(*refs))
+    end
+  end
+end

data/lib/minting/money/{formatting.rb → format/to_s.rb}

@@ -5,7 +5,7 @@ module Mint
   class Money
     # Formats money as a string with customizable format, thousand delimiter, and decimal
     #
-    # @param format [String, Hash] Either a Format string with placeholders
+    # @param format [String, Hash, nil] Either a Format string with placeholders
     #   (%<symbol>s, %<amount>f, %<currency>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:
@@ -15,8 +15,12 @@ module Mint
     #   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.
-    # @param thousand [String, false] Thousands delimiter (e.g., ',' for 1,000)
-    # @param decimal [String] Decimal separator (e.g., '.' or ',')
+    #   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 +format+ is not a String or Hash, the Hash
@@ -43,7 +47,12 @@ module Mint
     #   money.to_s(format: '%<amount>10.2f')                #=> "   1234.56"
     #   money.to_s(format: '%<symbol>s%<amount>010.2f')     #=> "$0001234.56"
     #
-    def to_s(format: '%<symbol>s%<amount>f', decimal: '.', thousand: ',', width: nil)
+    # @example Locale-aware formatting (with Mint.locale_backend set)
+    #   money.to_s  # decimal and thousand come from locale_backend
+    #
+    def to_s(format: nil, decimal: nil, thousand: nil, width: nil)
+      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)
@@ -63,37 +72,5 @@ module Mint
 
       width ? formatted.rjust(width) : formatted
     end
-
-    private
-
-    def select_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], amount]
-      end
-    end
-
-    def validate_format_hash(format)
-      unknown = format.keys - %i[positive negative zero]
-
-      raise ArgumentError, "Unknown format parameter(s): #{unknown.inspect}. " unless unknown.empty?
-    end
-
-    def format_amount(format)
-      format, value = select_format(format)
-      format ||= '%<symbol>s%<amount>f'
-      # Automatically adjust decimal places based on currency subunit if missing
-      format = format.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{currency.subunit}f")
-
-      refs = format.scan(/%<(\w+)>/).flatten.map(&:to_sym)
-      all_args = { amount: value, currency: currency_code, symbol: currency.symbol }
-      Kernel.format(format, **all_args.slice(*refs))
-    end
   end
 end

data/lib/minting/money/money.rb

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'allocation/allocation'
+require_relative 'allocation/split'
+require_relative 'arithmetics/methods'
+require_relative 'arithmetics/operators'
+require_relative 'clamp'
+require_relative 'coercion'
+require_relative 'comparable'
+require_relative 'constructors'
+require_relative 'conversion'
+require_relative 'format/formatting'
+require_relative 'format/to_s'
+
 module Mint
   # Money constructors
   class Money
@@ -43,63 +55,5 @@ module Mint
     # @param other [Currency] the target currency to compare
     # @return [Boolean] true if currencies match, false otherwise
     def same_currency?(other) = other.currency == currency
-
-    # Constrains +self+ to the inclusive range [+min+, +max+].
-    #
-    # Bounds may be:
-    # - nil meaning no boundary
-    # - same-currency {Money} or Range
-    # - Numeric amount, or Range
-    #
-    # Numeric is interpreted as an amount in +self+'s currency, so the common
-    # pricing idiom +price.clamp(0, 100)+ reads as "0 to 100 in the same
-    # currency as +price+".
-    #
-    # When +self+ is already in range the receiver is returned (no new object
-    # allocated). When out of range, the nearest bound is returned as a new
-    # frozen {Money} in +self+'s currency.
-    #
-    # @param min_or_range [Money, Numeric, Range, nil] lower bound (inclusive), or range
-    # @param max [Money, Numeric, nil] upper bound (inclusive)
-    # @return [Money] +self+ if in range, otherwise the nearer bound
-    # @raise [ArgumentError] if +min+ or +max+ is not a Money, Numeric or nil; if
-    #   a Money operand has a different currency; if +min+ > +max+;
-    #   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)
-    #
-    # @example Out of range, with Numeric bounds
-    #   Mint.money(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.clamp(floor, ceil) #=> [USD 0.00]
-    #
-    # @example Subunit-0 currency (JPY)
-    #   Mint.money(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
-
-        min, max = min_or_range.minmax
-      else
-        min = min_or_range
-      end
-      mint(amount.clamp(normalize_boundary(min), normalize_boundary(max)))
-    end
-
-    private
-
-    def normalize_boundary(boundary)
-      case boundary
-      in NilClass | Numeric                then boundary
-      in Money if same_currency?(boundary) then boundary.amount
-      in Money                             then raise ArgumentError, "oundary currency must be: #{currency_code}"
-      else                                 raise ArgumentError, "Boundary must be Numeric or Money #{boundary}"
-      end
-    end
   end
 end

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.7.0'
+  VERSION = '1.7.3'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: minting
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.3
 platform: ruby
 authors:
 - Gilson Ferraz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -33,6 +32,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/bench_check
 - bin/check-currencies
 - bin/console
 - bin/setup
@@ -40,14 +40,17 @@ files:
 - doc/Mint/Currency.html
 - doc/Mint/CurrencyRegistry.html
 - doc/Mint/Money.html
+- doc/Mint/RangeStepPatch.html
+- doc/Mint/Registry.html
 - doc/Mint/UnknownCurrency.html
 - doc/Minting.html
 - doc/_index.html
-- doc/agents/AGENTS.md
-- doc/agents/copilot-instructions.md
-- doc/agents/gemini_gem_evaluation.md
-- doc/agents/recommendations.md
-- doc/agents/rubocop-issues.md
+- doc/agents/api_review-2026-06-15.md
+- doc/agents/expired/AGENTS.md
+- doc/agents/expired/copilot-instructions.md
+- doc/agents/expired/gemini_gem_evaluation.md
+- doc/agents/expired/recommendations.md
+- doc/agents/expired/rubocop-issues.md
 - doc/class_list.html
 - doc/css/common.css
 - doc/css/full_list.css
@@ -62,24 +65,33 @@ files:
 - doc/method_list.html
 - doc/top-level-namespace.html
 - lib/minting.rb
+- lib/minting/currency/currency.rb
 - lib/minting/data/world-currencies.yaml
 - lib/minting/mint.rb
 - lib/minting/mint/aliases.rb
-- lib/minting/mint/currency/currency.rb
-- lib/minting/mint/currency/currency_registry.rb
-- lib/minting/mint/currency/world_currencies.rb
+- lib/minting/mint/dsl/numeric.rb
 - lib/minting/mint/dsl/range.rb
-- lib/minting/mint/dsl/refinements.rb
+- lib/minting/mint/dsl/string.rb
 - lib/minting/mint/dsl/top_level.rb
+- lib/minting/mint/locale_backend.rb
 - lib/minting/mint/mint.rb
-- lib/minting/mint/parser.rb
-- lib/minting/money/allocation.rb
-- lib/minting/money/arithmetics.rb
+- lib/minting/mint/parser/parser.rb
+- lib/minting/mint/parser/separators.rb
+- lib/minting/mint/registry/registration.rb
+- lib/minting/mint/registry/registry.rb
+- lib/minting/mint/registry/symbols.rb
+- lib/minting/mint/registry/zeros.rb
+- lib/minting/money/allocation/allocation.rb
+- lib/minting/money/allocation/split.rb
+- lib/minting/money/arithmetics/methods.rb
+- lib/minting/money/arithmetics/operators.rb
+- lib/minting/money/clamp.rb
 - lib/minting/money/coercion.rb
 - lib/minting/money/comparable.rb
 - lib/minting/money/constructors.rb
 - lib/minting/money/conversion.rb
-- lib/minting/money/formatting.rb
+- lib/minting/money/format/formatting.rb
+- lib/minting/money/format/to_s.rb
 - lib/minting/money/money.rb
 - lib/minting/version.rb
 - minting.gemspec
@@ -94,7 +106,6 @@ metadata:
   source_code_uri: https://github.com/gferraz/minting
   allowed_push_host: https://rubygems.org
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -109,8 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Library to manipulate currency values
 test_files: []

data/lib/minting/mint/currency/currency.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Mint
-  # Represents a specific currency unit, identified by ISO 4217 alphabetic code.
-  # Currency objects are immutable and define the properties of a monetary unit
-  # including its subunit precision, display symbol, and formatting rules.
-  #
-  # @see https://www.iso.org/iso-4217-currency-codes.html
-  # @attr_reader code [String] ISO 4217 currency code (e.g., "USD", "EUR")
-  # @attr_reader subunit [Integer] Number of decimal places (0 for JPY, 2 for USD, 3 for IQD)
-  # @attr_reader symbol [String] Display symbol (e.g., "$", "€", "R$")
-  # @attr_reader priority [Integer] Parser precedence for symbol detection
-  # @attr_reader country [String, nil] Associated country code
-  # @attr_reader name [String, nil] Currency name
-  # @attr_reader fractional_multiplier [Integer] 10^subunit, used for fractional conversions
-  # @attr_reader minimum_amount [Rational] Smallest representable amount (1/fractional_multiplier)
-  Currency = Data.define(:code, :subunit, :symbol, :priority, :country, :name,
-                         :fractional_multiplier) do
-    def initialize(code:, symbol:, subunit: 0, priority: 0, country: nil, name: nil)
-      subunit = subunit.to_i
-      priority = priority.to_i
-      fractional_multiplier = 10**subunit
-      super(code:, subunit:, symbol:, priority:, country:, name:,
-            fractional_multiplier:)
-    end
-
-    def inspect = "<Currency:(#{code} #{symbol} #{subunit} #{name})>"
-
-    def minimum_amount = Rational(1, fractional_multiplier)
-
-    # Normalizes numeric amounts for this currency
-    # 1. Converts to Rational
-    # 2. Rounds to respect currency subunit
-    def normalize_amount(amount) = amount.to_r.round(subunit)
-  end
-end