minting 2.1.1 → 2.3.0

data/lib/minting/aliases.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 # @!parse
-#   # Top-level alias for {Money::Currency}, opt-in via +require 'minting/aliases'+.
-#   Currency = Money::Currency
+#   # Top-level alias for {Mint::Currency}, opt-in via +require 'minting/aliases'+.
+#   Currency = Mint::Currency
 
-# Top-level alias for {Money::Currency}, opt-in via +require 'minting/aliases'+.
+# Top-level alias for {Mint::Currency}, opt-in via +require 'minting/aliases'+.
 #
 # {::Currency} is **not** auto-bound by `require 'minting'` because
 # application domain models are commonly named +Currency+ (e.g. a Rails
 # model). Load this file explicitly to opt in.
 #
 # If {::Currency} is already defined, a warning is emitted and the existing
-# constant is preserved — use {Money::Currency} explicitly in that case.
+# constant is preserved — use {Mint::Currency} explicitly in that case.
 #
-# @see Money::Currency
+# @see Mint::Currency
 
-Currency = Money::Currency unless defined?(Currency)
+Currency = Mint::Currency unless defined?(Currency)
 
-if Currency != Money::Currency
-  warn "minting: top-level Currency was already defined (#{Currency}); skipping alias. Use Money::Currency"
+if Currency != Mint::Currency
+  warn "minting: top-level Currency was already defined (#{Currency}); skipping alias. Use Mint::Currency"
 end

data/lib/minting/currency/currency.rb

@@ -89,13 +89,7 @@ module Mint
     #   usd.normalize_amount("5.25")  #=> (21/4)
     #
     # @see Money.with_rounding Custom rounding modes via {Money.with_rounding}
-    def normalize_amount(amount)
-      if Currency.custom_rounding_active?
-        amount.to_r.round(subunit, half: Thread.current[Currency::ROUNDING_THREAD_KEY])
-      else
-        amount.to_r.round(subunit)
-      end
-    end
+    def normalize_amount(amount) = amount.to_r.round(subunit)
 
     # Returns the cached frozen zero-Money for this currency.
     #

data/lib/minting/currency/registry.rb

@@ -32,11 +32,15 @@ module Mint
   # @param subunit [Integer] the decimal subunit precision, defaults to 0
   # @param symbol [String] the display symbol
   # @param priority [Integer] parser precedence priority
+  # @param country [String, nil] associated country code
+  # @param name [String, nil] currency name
+  # @param disambiguate_symbol [String, nil] symbol variant for disambiguation
   # @return [Currency] the newly registered Currency instance
   # @raise [ArgumentError] if the code contains invalid characters
   # @raise [KeyError] if the currency code is already registered
-  def Currency.register(code:, subunit: 0, symbol: '', priority: 0)
-    Registry.register(code:, subunit:, symbol:, priority:)
+  def Currency.register(code:, subunit: 0, symbol: '', priority: 0, country: nil, name: nil,
+                        disambiguate_symbol: nil)
+    Registry.register(code:, subunit:, symbol:, priority:, country:, name:, disambiguate_symbol:)
   end
 
   # Registers all built-in crypto currencies at once.
@@ -124,11 +128,8 @@ module Mint
   # @raise [Mint::UnknownCurrency] if the currency can't be resolved
   def Currency.zero(currency) = Registry.zero_for(Currency.resolve!(currency))
 
-  # --- @api private ---
-
   # 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
 end

data/lib/minting/currency/rounding.rb

@@ -4,6 +4,14 @@
 module Mint
   # :nodoc:
   class Currency
+    # Replaces the default normalization method after custom rounding is first
+    # requested, keeping the default path free of dispatch and thread checks.
+    module CustomRounding
+      def normalize_amount(amount)
+        amount.to_r.round(subunit, half: Thread.current[Currency::ROUNDING_THREAD_KEY] || :up)
+      end
+    end
+
     # @api private
     VALID_ROUNDING_MODES = %i[up down even].freeze
 
@@ -17,7 +25,12 @@ module Mint
     # Activates the custom rounding dispatch path in {#normalize_amount}.
     # Once called, this cannot be reversed for the lifetime of the process.
     # @api private
-    def self.activate_custom_rounding! = @custom_rounding_active = true
+    def self.activate_custom_rounding!
+      return if @custom_rounding_active
+
+      @custom_rounding_active = true
+      prepend(CustomRounding)
+    end
 
     # Returns the currently active rounding mode, falling back to +:up+.
     # @api private

data/lib/minting/mint/dsl/numeric.rb

@@ -11,11 +11,16 @@ class Numeric
   # @return [Money] self interpreted as EUR
   def euros = Mint::Money.from(self, 'EUR')
 
-  # @param currency [String, Symbol, Currency] target currency
+  # @param currency [String, Currency] target currency
   # @return [Money] self interpreted as the given currency
   def to_money(currency) = Mint::Money.from(self, currency)
 
   alias dollar dollars
   alias euro euros
-  alias mint to_money
+
+  # @deprecated Use +to_money+ instead.
+  def mint(currency)
+    warn 'DEPRECATION: Numeric#mint is deprecated; use #to_money instead.', uplevel: 1
+    to_money(currency)
+  end
 end

data/lib/minting/mint/dsl/string.rb

@@ -4,7 +4,7 @@
 class String
   # Parses self as a numeric string and creates a Money in the given currency.
   #
-  # @param currency [String, Symbol, Currency] target currency
+  # @param currency [String, Currency] default currency when self has no currency marker
   # @return [Money]
-  def to_money(currency = nil) = Mint::Money.parse(self, currency)
+  def to_money(currency = nil) = Mint::Money.parse(self, default_currency: currency)
 end

data/lib/minting/mint/mint.rb

@@ -11,6 +11,8 @@ module Mint
 
   # Creates a new {Money} instance with the given amount and currency code.
   #
+  # @deprecated Use {Money.from} instead.
+  #
   # @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
@@ -20,5 +22,8 @@ module Mint
   # @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)
+  def self.money(amount, currency_code)
+    warn 'DEPRECATION: Mint.money is deprecated; use Money.from instead.', uplevel: 1
+    Money.from(amount, currency_code)
+  end
 end

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

@@ -18,7 +18,9 @@ module Mint
       @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
+          YAML.safe_load_file(path, aliases: false)
+              .map { |entry| Currency.new(**entry.transform_keys(&:to_sym)) }
+              .freeze
         end
       end
     end
@@ -40,7 +42,8 @@ module Mint
 
       codes.map do |code|
         c = entries[index[code]]
-        Currency.register(code:, subunit: c.subunit, symbol: c.symbol, priority: c.priority)
+        Currency.register(code:, subunit: c.subunit, symbol: c.symbol, priority: c.priority,
+                          country: c.country, name: c.name, disambiguate_symbol: c.disambiguate_symbol)
       end
     end
 
@@ -52,7 +55,8 @@ module Mint
     # @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)
+        Currency.register(code: c.code, subunit: c.subunit, symbol: c.symbol, priority: c.priority,
+                          country: c.country, name: c.name, disambiguate_symbol: c.disambiguate_symbol)
       end
     end
   end

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

@@ -9,10 +9,14 @@ module Mint
     # @param subunit [Integer] the decimal subunit precision, defaults to 0
     # @param symbol [String] the display symbol
     # @param priority [Integer] parser precedence priority
+    # @param country [String, nil] associated country code
+    # @param name [String, nil] currency name
+    # @param disambiguate_symbol [String, nil] symbol variant for disambiguation
     # @return [Currency] the newly registered Currency instance
     # @raise [ArgumentError] if the code contains invalid characters
     # @raise [KeyError] if the currency code is already registered
-    def self.register(code:, subunit: 0, symbol: '', priority: 0)
+    def self.register(code:, subunit: 0, symbol: '', priority: 0, country: nil, name: nil,
+                      disambiguate_symbol: nil)
       raise ArgumentError, 'Currency code must be String' unless code.is_a? String
       unless code.match?(/^[A-Z_]+$/)
         raise ArgumentError,
@@ -22,7 +26,7 @@ module Mint
       MUTEX.synchronize do
         raise KeyError, "Currency: #{code} already registered" if currencies[code]
 
-        currency = Currency.new(code:, subunit:, symbol:, priority:)
+        currency = Currency.new(code:, subunit:, symbol:, priority:, country:, name:, disambiguate_symbol:)
         @currencies = @currencies.merge(code => currency).freeze
         @symbols_list = nil
         currency

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

@@ -16,7 +16,7 @@ module Mint
 
     # Preload world currencies from YAML file during module load.
     path = File.join(File.expand_path('../../data', __dir__), 'world-currencies.yaml')
-    @world_currencies = YAML.load_file(path).to_h do |entry|
+    @world_currencies = YAML.safe_load_file(path, aliases: false).to_h do |entry|
       [entry['code'], Currency.new(**entry.transform_keys(&:to_sym))]
     end
     @currencies = @world_currencies.freeze.dup.freeze

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

@@ -5,13 +5,18 @@ module Mint
   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
+    # @param proportions [Array<Numeric>] a list of numeric proportions/ratios to allocate by.
+    #   Negative ratios produce signed allocations and should be used only when
+    #   that distribution is intentional.
     # @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 = Money.from(10.00, 'USD')
     #   money.allocate([1, 2, 3]) #=> [[USD 1.67], [USD 3.33], [USD 5.00]]
+    #
+    # @example Signed allocation
+    #   money.allocate([-1, 2]) #=> [[USD -10.00], [USD 20.00]]
     def allocate(proportions)
       whole = proportions.sum.to_r
       raise ArgumentError, 'Need at least 1 proportion element' if proportions.empty?

data/lib/minting/money/clamp.rb

@@ -8,28 +8,20 @@ module Mint
     # 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)
+    # @param min_or_range [Money, Range, nil] lower bound (inclusive), or range
+    # @param max [Money, 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
+    # @raise [ArgumentError] if +min+ or +max+ is not a Money 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
-    #   Money.from(5, 'USD').clamp(0, 10) #=> [USD 5.00]  (returns self)
-    #
-    # @example Out of range, with Numeric bounds
-    #   Money.from(50, 'USD').clamp(0, 10) #=> [USD 10.00]
+    #   Money.from(5, 'USD').clamp(Money.from(0, 'USD'), Money.from(10, 'USD')) #=> [USD 5.00]  (returns self)
     #
     # @example Out of range, with Money bounds
     #   loss  = Money.from(-5, 'USD')
@@ -37,8 +29,6 @@ module Mint
     #   ceil  = Money.from(10, 'USD')
     #   loss.clamp(floor, ceil) #=> [USD 0.00]
     #
-    # @example Subunit-0 currency (JPY)
-    #   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
@@ -56,10 +46,10 @@ module Mint
     # @private
     def normalize_boundary(boundary)
       case boundary
-      in NilClass | Numeric                then boundary
+      in NilClass                          then boundary
       in Money if same_currency?(boundary) then boundary.amount
       in Money                             then raise ArgumentError, "Boundary currency must be: #{currency_code}"
-      else                                 raise ArgumentError, "Boundary must be Numeric or Money #{boundary}"
+      else                                 raise ArgumentError, "Boundary must be Money or nil: #{boundary}"
       end
     end
   end

data/lib/minting/money/constructors.rb

@@ -44,7 +44,7 @@ module Mint
     #
     # @param subunits [Integer] the amount expressed in the currency's
     #   smallest unit (e.g. cents). Must be an Integer to preserve exactness.
-    # @param currency [String, Symbol, Currency] the currency identifier
+    # @param currency [String, Currency] the currency identifier
     # @return [Money] the resulting Money instance
     # @raise [ArgumentError] if +subunits+ is not an Integer
     # @raise [Mint::UnknownCurrency] if +currency+ is not registered

data/lib/minting/money/conversion.rb

@@ -57,6 +57,9 @@ module Mint
     # @example Round-trip
     #   m = Money.from(134120, "BRL")
     #   Money.from_hash(m.to_hash) == m  #=> true
+    #
+    # JSON and Rails `as_json` integration are provided by the
+    # +money_attribute+ companion gem rather than the core Minting gem.
     def self.from_hash(hash)
       currency = Currency.resolve!(hash[:currency] || hash['currency'])
       amount = currency.normalize_amount(Rational(hash[:amount] || hash['amount']))

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

@@ -7,7 +7,12 @@ module Mint
     # 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),
+    #   (%<symbol>s, %<amount>f, %<magnitude>f, %<sign>s, %<currency>s,
+    #   %<integral>d, %<fractional>d, %<dsymbol>s),
+    #   `%<amount>` is signed; `%<magnitude>` is always non-negative; `%<fractional>`
+    #   is the non-negative fractional component; and `%<sign>` is `+`, `-`, or
+    #   an empty string for zero. Use `%<sign>` when the sign needs explicit
+    #   placement, especially for amounts between -1 and 1.
     #   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:
@@ -44,12 +49,16 @@ module Mint
     #   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"
+    #   money.format('%<sign>s%<symbol>s%<magnitude>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"
+    #   loss = Money.from(-0.99, 'USD')
+    #   loss.format('%<sign>s%<integral>d.%<fractional>02d')
+    #   #=> "-0.99"
     #
     # @example Per-sign Hash format (accounting parentheses)
     #   loss = Money.from(-1234.56, 'USD')

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'monitor'
+
 module Mint
   class Money
     # Compiles and caches formatter lambdas for a fixed combination of format
@@ -12,9 +14,22 @@ module Mint
     class Formatter
       extend FormatterValidator
 
-      def self.cache = @cache ||= {}
+      # Keep enough compiled configurations for typical application presets and
+      # locales without retaining every caller-provided template indefinitely.
+      CACHE_LIMIT = 256
+      CACHE_MUTEX = Monitor.new
+
+      private_constant :CACHE_MUTEX
+
+      @cache = {}.freeze
 
-      # Returns a cached {Formatter} for the given configuration.
+      class << self
+        attr_reader :cache
+      end
+
+      # Returns a cached {Formatter} for the given configuration. The cache is
+      # thread-safe and bounded by {CACHE_LIMIT}; once full, new configurations
+      # are compiled without being retained.
       # @param format [Hash{Symbol => String}] per-sign templates
       # @param decimal [String] decimal separator
       # @param thousand [String, false] thousands delimiter (+false+ disables)
@@ -23,19 +38,25 @@ module Mint
         formatter = cache[key]
         return formatter if formatter
 
-        validate_format!(format)
-        validate_separators!(decimal:, thousand:)
+        CACHE_MUTEX.synchronize do
+          formatter = cache[key]
+          return formatter if formatter
+
+          validate_format!(format)
+          validate_separators!(decimal:, thousand:)
 
-        cache[key] = new(format, decimal, thousand)
+          formatter = new(format, decimal, thousand)
+          @cache = cache.merge(key => formatter).freeze unless cache.size >= CACHE_LIMIT
+          formatter
+        end
       end
 
       def initialize(format, decimal, thousand)
-        @format = format
         @decimal = decimal
-        @thousand = thousand
-        compile
+        compile(format:, thousand:)
       end
 
+      SIGNS = { -1 => '-', 0 => '', 1 => '+' }.freeze
       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.
@@ -48,9 +69,12 @@ module Mint
 
         templates = @has_placeholder ? @templates_by_subunit[currency.subunit] : @templates
 
-        template = templates[amount <=> 0] || templates[1]
+        cmp = amount <=> 0
+        template = templates[cmp] || templates[1]
+        sign = SIGNS[cmp]
 
-        display_amount = @has_negative_template && amount < 0 ? -amount : amount
+        magnitude = amount.abs
+        display_amount = @has_negative_template ? magnitude : amount
         integral = display_amount.to_i
 
         result = Kernel.format(template,
@@ -58,6 +82,8 @@ module Mint
                                dsymbol: @needs_dsymbol && currency.dsymbol,
                                symbol: currency.symbol,
                                amount: display_amount,
+                               magnitude:,
+                               sign:,
                                integral: integral,
                                fractional: @needs_fractional ? money.fractional.abs : 0)
         apply_separators(result, integral)
@@ -78,25 +104,27 @@ module Mint
         result
       end
 
-      def compile
-        @templates = { -1 => @format[:negative], 0 => @format[:zero], 1 => @format[:positive] || Money::DEFAULT_FORMAT }
+      def compile(format:, thousand:)
+        @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".
+
+        # Inject subunit precision into amount and magnitude f specs that lack
+        # an explicit precision. Matches "%<amount>f" or "%<magnitude>f" and
+        # appends a placeholder for the currency subunit digits.
         # 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") }
+        @templates.transform_values! do |f|
+          f.gsub(/%<(amount|magnitude)>(\s*\+?\d*)f/, "%<\\1>\\2.#{SUBUNIT_PLACEHOLDER}f")
+        end
         @has_negative_template = @templates.key?(-1)
-
         joined = @templates.values.join
         @needs_fractional = joined.include?('%<fractional>')
         @needs_dsymbol = joined.include?('%<dsymbol>')
-
-        @needs_thousand_substitution = @thousand && !@thousand.empty? &&
-                                       (joined.include?('%<amount>') || joined.include?('%<integral>'))
-        @thousand_replacement = "\\1#{@thousand}" if @needs_thousand_substitution
+        @needs_thousand_substitution = thousand && !thousand.empty? &&
+                                       (joined.include?('%<amount>') ||
+                                        joined.include?('%<magnitude>') ||
+                                        joined.include?('%<integral>'))
+        @thousand_replacement = "\\1#{thousand}" if @needs_thousand_substitution
 
         @has_placeholder = joined.include?(SUBUNIT_PLACEHOLDER)
         return unless @has_placeholder

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

@@ -30,13 +30,14 @@ module Mint
       return format unless Mint.locale_backend.nil?
 
       subunit = currency.subunit
-      major = integral.to_s
+      sign = amount.negative? ? '-' : ''
+      major = integral.abs.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}"
+        "#{currency.symbol}#{sign}#{major}.#{minor}"
       else
-        "#{currency.symbol}#{major}"
+        "#{currency.symbol}#{sign}#{major}"
       end
     end
   end

data/lib/minting/money/money.rb

@@ -52,7 +52,8 @@ module Mint
 
     alias to_i integral
 
-    # Returns the fractional part of the amount.
+    # Returns the signed fractional part of the amount. Formatting templates
+    # expose this value as a magnitude through `%<fractional>d`.
     # @example
     #   Money.from(1234.56, 'USD').fractional  #=> 56
     #   Money.from(1000, 'JPY').fractional     #=> 0

data/lib/minting/money/parse/separator_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mint
+  class Money
+    # Parses numeric input when the decimal separator is explicitly known.
+    # @api private
+    module SeparatorParser
+      module_function
+
+      def parse(numeric, decimal, thousand)
+        decimal, thousand = separators(decimal, thousand)
+        return nil unless decimal && thousand && decimal != thousand
+
+        sign = numeric.start_with?('-', '+') ? numeric[0] : ''
+        unsigned = numeric.delete_prefix(sign)
+        return nil if unsigned.count(decimal) > 1
+
+        return parse_decimal(sign, unsigned, decimal, thousand) if unsigned.include?(decimal)
+        return parse_thousands(sign, unsigned, thousand) if unsigned.include?(thousand)
+        return "#{sign}#{unsigned}" if unsigned.match?(/\A\d+\z/)
+
+        nil
+      end
+
+      def separators(decimal, thousand)
+        return [decimal, thousand] if decimal && thousand
+        return [decimal, decimal == ',' ? '.' : ','] if %w[. ,].include?(decimal)
+        return [thousand == ',' ? '.' : ',', thousand] if %w[. ,].include?(thousand)
+
+        nil
+      end
+      private_class_method :separators
+
+      def parse_decimal(sign, unsigned, decimal, thousand)
+        integral, fractional = unsigned.split(decimal, 2)
+        return nil unless valid_integer_part?(integral, thousand) && fractional.match?(/\A\d+\z/)
+
+        "#{sign}#{integral.delete(thousand)}.#{fractional}"
+      end
+      private_class_method :parse_decimal
+
+      def parse_thousands(sign, unsigned, thousand)
+        return nil unless valid_integer_part?(unsigned, thousand)
+
+        "#{sign}#{unsigned.delete(thousand)}"
+      end
+      private_class_method :parse_thousands
+
+      def valid_integer_part?(integer, thousand)
+        return integer.match?(/\A\d+\z/) unless integer.include?(thousand)
+
+        groups = integer.split(thousand)
+        groups.first.match?(/\A\d{1,3}\z/) && groups.drop(1).all? { |group| group.match?(/\A\d{3}\z/) }
+      end
+      private_class_method :valid_integer_part?
+    end
+
+    private_constant :SeparatorParser
+  end
+end