minting 1.7.0 → 1.7.3

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-# Mint currency store (internal)
-module Mint
-  # Internal currency registry
-  # Manages the registry cache and currency symbol lookups.
-  module CurrencyRegistry
-    extend self
-
-    # Returns the hash of all registered currencies.
-    #
-    # @return [Hash{String => Currency}] registered currencies mapped by code
-    # @api private
-    def currencies
-      @currencies ||= Mint.world_currencies.dup
-    end
-
-    # Registered symbols sorted for detection: longest match wins, then parser priority.
-    #
-    # @return [Array<Array<String, Currency>>] sorted symbol-to-currency mappings
-    # @api private
-    def currency_symbols
-      @currency_symbols ||= begin
-        currencies.values
-                  .reject { |c| c.symbol.empty? }
-                  .map { |currency| [currency.symbol, currency] }
-                  .sort_by { |symbol, currency| [-symbol.length, -currency.priority] }
-      end.freeze
-    end
-
-    # Registers a new currency, raising a KeyError if already registered.
-    #
-    # @param code [String] the unique currency code
-    # @param subunit [Integer] the decimal subunit precision, defaults to 0
-    # @param symbol [String] the display symbol
-    # @param priority [Integer] parser precedence priority
-    # @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 register(code:, subunit: 0, symbol: '', priority: 0)
-      raise ArgumentError, 'Currency code must be String' unless code.is_a? String
-      unless code.match?(/^[A-Z_]+$/)
-        raise ArgumentError,
-              "Currency code must have only letters or '_' ('USD',, 'MY_COIN')"
-      end
-
-      currencies = CurrencyRegistry.currencies
-      raise KeyError, "Currency: #{code} already registered" if currencies[code]
-
-      currency = currencies[code] = Currency.new(code:, subunit:, symbol:, priority:)
-      invalidate_symbols_cache
-      currency
-    end
-
-    private
-
-    # Clears and refreshes the currency symbol cache.
-    # Called when currencies are registered.
-    #
-    # @api private
-    def invalidate_symbols_cache
-      @currency_symbols = nil
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Mint list of world currencies
-module Mint
-  # Loads ISO world currencies from YAML file into the registry.
-  #
-  # @return [Hash{String => Currency}] ISO-4217 world currencies mapped by code
-  # @api private
-  def self.world_currencies
-    @world_currencies ||= begin
-      path = File.join(File.expand_path('../../data', __dir__), 'world-currencies.yaml')
-
-      YAML.load_file(path).to_h { |entry| [entry['code'], Currency.new(**entry.transform_keys(&:to_sym))] }
-    end.freeze
-  end
-end

data/lib/minting/mint/parser.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-# Mint Money parsing
-module Mint
-  extend self
-
-  # Parses a human-readable money string into a {Money} object.
-  #
-  # @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 With explicit currency
-  #   Money.parse('19.99', 'USD')    #=> [USD 19.99]
-  #   Money.parse('1.234,56', 'EUR') #=> [EUR 1234.56]
-  #
-  # @example With symbol or code in the string
-  #   Money.parse('$19.99')            #=> [USD 19.99]
-  #   Money.parse('19,99 €')         #=> [EUR 19.99]
-  #   Money.parse('USD 1,234.56')    #=> [USD 1234.56]
-  def 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 = Mint.currency(currency) || parse_currency(input)
-    raise ArgumentError, "Currency [#{currency}] not registered" unless currency
-
-    amount = currency.normalize_amount(parse_amount(input))
-    Mint::Money.new(amount, currency)
-  end
-
-  private
-
-  # Extracts a numeric value from input that should only contain an amount.
-  def parse_amount(input)
-    # Remove any charater that is not a digit, comma or period
-    numeric = input.scan(/[\d.,-]/).join
-    numeric = normalize_separators(numeric)
-    Rational(numeric)
-  end
-
-  def classify_separators(numeric)
-    case [numeric.count(','), numeric.count('.')]
-    in [0, 0] | [0, 1]          then :decimal_period # e.g. "1500" or "34.21".
-    in [1, 0]                   then :decimal_comma  # Only one comma: decimal (e.g. 19,99 or 1,234).
-    in [c, p] if c > 1 && p > 1 then :ambiguous      # Both separators appear multiple times
-    in [c, p] if c > 0 && p > 0 then :mixed          # Commas and dots: the rightmost one is the decimal separator.
-    else                             :thousands_only # Multiple of the same separator only (e.g. 1,234,567)
-    end
-  end
-
-  # Converts locale-specific decimal/thousand separators into a plain decimal string.
-  def normalize_separators(numeric)
-    case classify_separators(numeric)
-    when :decimal_period then numeric              # Nothing to normalize (e.g. "1500" or "34.21").
-    when :decimal_comma  then numeric.tr(',', '.') # Only one comma: decimal (e.g. 19,99 or 1,234).
-    when :thousands_only then numeric.delete(',.')
-    when :ambiguous then raise ArgumentError, "could not distinguish decimal and thousand separators in '#{numeric}'"
-    when :mixed # Commas and dots: the rightmost one is the decimal separator.
-      if numeric.rindex(',') > numeric.rindex('.')
-        numeric.delete('.').tr(',', '.')
-      else
-        numeric.delete(',')
-      end
-    end
-  end
-
-  def parse_currency(input)
-    case input
-    when String
-      # Prefer an explicit ISO 4217 code (e.g. "USD 1,234.56") over symbol matching.
-      currency = Mint.currency(input[/\b([A-Z_]+)\b/, 1])
-      return currency if currency
-
-      # Fall back to registered symbols, longest first (HK$ before $).
-      CurrencyRegistry.currency_symbols.each do |symbol, currency|
-        return currency if input.include?(symbol)
-      end
-    end
-    raise ArgumentError, 'Currency could not be detected'
-  end
-end