minting 1.9.6 → 2.0.0

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

@@ -3,106 +3,41 @@
 module Mint
   # :nodoc:
   class Money
-    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
-
-    # 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),
-    #   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"
-    #
-    # @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"
-    #
-    # @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"
-    #
-    # @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"
-    #
-    # @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'
+    # The default display format pattern for formatting monetary values.
+    # Uses `%<symbol>s` for the currency symbol and `%<amount>f` for the rounded amount.
+    DEFAULT_FORMAT = '%<symbol>s%<amount>f'
+
+    # Match a digit followed by groups of 3 digits until end of string — inserts thousand separators.
+    THOUSAND_RE = /(\d)(?=(\d{3})+\z)/
+
+    # Returns a string representation of the money amount.
+    #
+    # 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.
+    #
+    # Unlike {#format}, this method takes **no arguments** — use
+    # {#format} (alias {#to_fs}) for custom formatting.
+    #
+    # @return [String] formatted money string
+    #
+    # @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
+      major = integral.to_s
+      major.gsub!(THOUSAND_RE, '\1,') if amount.abs >= 1000
+      if subunit > 0
+        minor = fractional.abs.to_s.rjust(subunit, '0')
+        "#{currency.symbol}#{major}.#{minor}"
+      else
+        "#{currency.symbol}#{major}"
       end
-
-      formatted = format_amount(format, decimal: decimal, thousand: thousand)
-
-      width ? formatted.rjust(width) : formatted
     end
-
-    def to_s = format
-
-    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

data/lib/minting/money/money.rb

@@ -8,26 +8,29 @@ require_relative 'clamp'
 require_relative 'coercion'
 require_relative 'comparable'
 require_relative 'constructors'
+require_relative 'parse'
 require_relative 'conversion'
-require_relative 'format/formatting'
+require_relative 'format/validator'
+require_relative 'format/formatter'
 require_relative 'format/to_s'
+require_relative 'format/format'
+require_relative 'rounding'
 
 module Mint
   # Represents a monetary value paired with a currency.
   # Money objects are immutable and support arithmetic, comparison,
   # formatting, allocation, and parsing operations.
   class Money
-    # The default display format pattern for formatting monetary values.
-    # Uses `%<symbol>s` for the currency symbol and `%<amount>f` for the rounded amount.
-    DEFAULT_FORMAT = '%<symbol>s%<amount>f'
-
     attr_reader :amount, :currency
 
+    # Money::Currency is the canonical way to access Currency class
+    Currency = Mint::Currency
+
     # Returns the ISO 3-letter currency code string.
     #
     # @return [String] the ISO currency code (e.g., "USD", "EUR", "BRL")
     # @example
-    #   Mint.money(100, 'USD').currency_code  #=> "USD"
+    #   Money.from(100, 'USD').currency_code  #=> "USD"
     def currency_code = currency.code
 
     # Returns the monetary amount expressed in the currency's smallest unit (fractional units).
@@ -35,17 +38,26 @@ module Mint
     #
     # @return [Integer] the amount in fractional units
     # @example
-    #   Mint.money(1234.56, 'USD').subunits  #=> 123456
-    #   Mint.money(1000, 'JPY').subunits     #=> 1000
-    #   Mint.money(123.456, 'IQD').subunits  #=> 123456
+    #   Money.from(1234.56, 'USD').subunits  #=> 123456
+    #   Money.from(1000, 'JPY').subunits     #=> 1000
+    #   Money.from(123.456, 'IQD').subunits  #=> 123456
     def subunits = (amount * currency.fractional_multiplier).to_i
 
+    # Returns the whole-unit (integral) part of the amount.
+    # @example
+    #   Money.from(1234.56, 'USD').integral  #=> 1234
+    #   Money.from(1000, 'JPY').integral     #=> 1000
+    #   Money.from(-9.99, 'USD').integral    #=> -9
+    def integral = amount.to_i
+
+    alias to_i integral
+
     # Returns the fractional part of the amount.
     # @example
-    #   Mint.money(1234.56, 'USD').fractional  #=> 56
-    #   Mint.money(1000, 'JPY').fractional     #=> 0
-    #   Mint.money(123.456, 'IQD').fractional  #=> 456
-    def fractional = ((amount.abs % 1) * currency.fractional_multiplier).to_i
+    #   Money.from(1234.56, 'USD').fractional  #=> 56
+    #   Money.from(1000, 'JPY').fractional     #=> 0
+    #   Money.from(123.456, 'IQD').fractional  #=> 456
+    def fractional = ((amount - amount.to_i) * currency.fractional_multiplier).to_i
 
     # Generates a stable hash key for Money instances.
     #

data/lib/minting/money/parse.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc:
+  class Money
+    # 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)
+      return nil unless input.is_a?(String)
+
+      input = input.strip
+      return nil if input.empty?
+
+      currency = parse_currency(input, currency)
+      return nil unless currency
+
+      amount = parse_amount(input)
+      return nil unless amount
+
+      amount = currency.normalize_amount(amount)
+      new(amount, currency)
+    end
+
+    # 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)
+      raise ArgumentError, 'input must be a String' unless input.is_a?(String)
+
+      input = input.strip
+      raise ArgumentError, 'input cannot be empty' if input.empty?
+
+      currency = parse_currency(input, currency)
+      raise ArgumentError, "Currency [#{currency}] not found" unless currency
+
+      amount = parse_amount(input)
+      raise ArgumentError, "Could not parse [#{input}]" unless amount
+
+      amount = currency.normalize_amount(amount)
+      new(amount, currency)
+    end
+
+    class << self
+      private
+
+      # Extracts a numeric value from input that should only contain an amount.
+      def parse_amount(input)
+        accounting_negative = input.start_with?('(') && input.end_with?(')')
+
+        numeric_input = input.gsub(/[^\d.,-]/, '')
+        numeric = parse_separators(numeric_input)
+        return nil unless numeric
+
+        amount = Rational(numeric)
+        accounting_negative ? -amount : amount
+      end
+
+      # Extracts currency from a string by matching ISO code or symbol.
+      #
+      # Scans all uppercase words and returns the first registered code, falling
+      # back to symbol matching. This correctly handles inputs like
+      # "MAX 10.00 USD" where the first uppercase word isn't a currency code.
+      def parse_currency(input, currency = nil)
+        input.scan(/\b([A-Z_]+)\b/) do |(code)|
+          found = Currency.for_code(code)
+          return found if found
+        end
+
+        found = Registry.detect_currency(input)
+        return found if found
+
+        Currency.resolve(currency)
+      end
+
+      # Converts locale-specific decimal/thousand separators into a plain decimal string.
+      def parse_separators(numeric)
+        return nil unless numeric.match?(/\d/)
+
+        case classify_separators(numeric)
+        when :decimal_period   then numeric
+        when :decimal_comma    then numeric.tr(',', '.')
+        when :thousands_comma  then numeric.delete(',')
+        when :thousands        then numeric.delete('.,')
+        when :invalid          then nil
+        when :mixed
+          if numeric.rindex(',') > numeric.rindex('.')
+            numeric.delete('.').tr(',', '.')
+          else
+            numeric.delete(',')
+          end
+        end
+      end
+
+      # Classifies the separator pattern in a numeric string.
+      def classify_separators(numeric)
+        case [numeric.count('.'), numeric.count(',')]
+        in [0, 1] if numeric[-4] == ',' then :thousands_comma
+        in [0, 1]                       then :decimal_comma
+        in [0, 0] | [1, 0]              then :decimal_period
+        in [p, c] if p > 1 && c > 1     then :invalid
+        in [p, c] if p > 0 && c > 0     then :mixed
+        else                                 :thousands
+        end
+      end
+    end
+  end
+end

data/lib/minting/money/rounding.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc:
+  class Money
+    # 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 '../mint/rounding' unless defined?(Mint::Rounding)
+      Mint::Rounding.with_mode(mode, &)
+    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.9.6'
+  VERSION = '2.0.0'
 end

data/lib/minting.rb

@@ -3,12 +3,21 @@
 require 'minting/mint'
 require 'minting/version'
 
-# By default, expose Mint::Money as the top-level Money constant for
-# convenience. If Money is already defined (e.g. by the `money` gem), warn
-# and skip so both libraries can coexist in the same process without
-# corrupting either class.
-if defined?(Money) && Money != Mint::Money
-  warn "minting: top-level Money is already defined (#{Money}); skipping auto-bind. Use Mint::Money."
-else
-  Money = Mint::Money unless defined?(Money)
+# @!parse
+#   # Top-level constant auto-bound to {Mint::Money} for convenience.
+#   Money = Mint::Money
+
+# Top-level constant auto-bound to {Mint::Money} for convenience.
+#
+# Set at require-time via `require 'minting'`. If {::Money} is already
+# defined (e.g. by the `money` gem), a warning is emitted and the existing
+# constant is preserved — use {Mint::Money} explicitly in that case.
+#
+# @see Mint::Money
+# @note This is a **breaking change from v1.x** where both +Money+ and
+#   +Currency+ required explicit opt-in via +Mint.use_top_level_constants!+.
+Money = Mint::Money unless defined?(Money)
+
+if Money != Mint::Money
+  warn "minting: top-level Money was already defined (#{Money}); skipping auto-bind! Use Mint::Money."
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minting
 version: !ruby/object:Gem::Version
-  version: 1.9.6
+  version: 2.0.0
 platform: ruby
 authors:
 - Gilson Ferraz
@@ -36,16 +36,6 @@ files:
 - bin/check-currencies
 - bin/console
 - bin/setup
-- doc/Mint.html
-- doc/Mint/Currency.html
-- doc/Mint/CurrencyRegistry.html
-- doc/Mint/Money.html
-- doc/Mint/RangeStepPatch.html
-- doc/Mint/Registry.html
-- doc/Mint/Rounding.html
-- doc/Mint/UnknownCurrency.html
-- doc/Minting.html
-- doc/_index.html
 - doc/agents/api_review-2026-06-15.md
 - doc/agents/copilot-instructions.md
 - doc/agents/expired/AGENTS.md
@@ -53,31 +43,18 @@ files:
 - 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
-- doc/css/style.css
-- doc/file.README.html
-- doc/file_list.html
-- doc/frames.html
-- doc/index.html
-- doc/js/app.js
-- doc/js/full_list.js
-- doc/js/jquery.js
-- doc/method_list.html
-- doc/top-level-namespace.html
 - lib/minting.rb
+- lib/minting/aliases.rb
 - lib/minting/currency/currency.rb
+- lib/minting/data/crypto-currencies.yaml
 - lib/minting/data/world-currencies.yaml
 - lib/minting/mint.rb
-- lib/minting/mint/aliases.rb
 - lib/minting/mint/dsl/numeric.rb
 - lib/minting/mint/dsl/range.rb
 - lib/minting/mint/dsl/string.rb
 - lib/minting/mint/i18n.rb
 - lib/minting/mint/mint.rb
-- lib/minting/mint/parser/parser.rb
-- lib/minting/mint/parser/separators.rb
+- lib/minting/mint/registry/crypto.rb
 - lib/minting/mint/registry/registration.rb
 - lib/minting/mint/registry/registry.rb
 - lib/minting/mint/registry/symbols.rb
@@ -92,9 +69,13 @@ files:
 - lib/minting/money/comparable.rb
 - lib/minting/money/constructors.rb
 - lib/minting/money/conversion.rb
-- lib/minting/money/format/formatting.rb
+- lib/minting/money/format/format.rb
+- lib/minting/money/format/formatter.rb
 - lib/minting/money/format/to_s.rb
+- lib/minting/money/format/validator.rb
 - lib/minting/money/money.rb
+- lib/minting/money/parse.rb
+- lib/minting/money/rounding.rb
 - lib/minting/version.rb
 - minting.gemspec
 homepage: https://github.com/gferraz/minting