RubyGems - minting - Versions diffs - 1.9.7 → 2.1.0 - Mend

minting 1.9.7 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (66) hide show

checksums.yaml +4 -4
data/README.md +298 -122
data/Rakefile +2 -7
data/doc/agents/api_review-2026-06-15.md +1 -1
data/doc/agents/copilot-instructions.md +2 -2
data/doc/agents/expired/copilot-instructions.md +2 -2
data/doc/agents/expired/gemini_gem_evaluation.md +2 -2
data/lib/minting/aliases.rb +22 -0
data/lib/minting/currency/currency.rb +77 -94
data/lib/minting/currency/registry.rb +134 -0
data/lib/minting/currency/rounding.rb +47 -0
data/lib/minting/data/crypto-currencies.yaml +126 -0
data/lib/minting/mint/i18n.rb +79 -29
data/lib/minting/mint/mint.rb +1 -26
data/lib/minting/mint/registry/crypto.rb +59 -0
data/lib/minting/mint/registry/registration.rb +1 -2
data/lib/minting/mint/registry/registry.rb +9 -11
data/lib/minting/mint/registry/symbols.rb +37 -30
data/lib/minting/mint.rb +3 -2
data/lib/minting/money/allocation/allocation.rb +2 -2
data/lib/minting/money/allocation/split.rb +2 -2
data/lib/minting/money/arithmetics/operators.rb +10 -13
data/lib/minting/money/clamp.rb +6 -6
data/lib/minting/money/coercion.rb +1 -1
data/lib/minting/money/comparable.rb +3 -3
data/lib/minting/money/constructors.rb +3 -42
data/lib/minting/money/conversion.rb +22 -18
data/lib/minting/money/format/format.rb +100 -0
data/lib/minting/money/format/formatter.rb +110 -0
data/lib/minting/money/format/to_s.rb +20 -102
data/lib/minting/money/format/validator.rb +34 -0
data/lib/minting/money/money.rb +25 -9
data/lib/minting/money/parse.rb +127 -0
data/lib/minting/money/rounding.rb +26 -0
data/lib/minting/version.rb +1 -1
data/lib/minting.rb +17 -8
metadata +12 -31
data/doc/Mint/Currency.html +0 -2032
data/doc/Mint/Money.html +0 -5139
data/doc/Mint/RangeStepPatch.html +0 -277
data/doc/Mint/Registry.html +0 -863
data/doc/Mint/Rounding.html +0 -506
data/doc/Mint/UnknownCurrency.html +0 -138
data/doc/Mint.html +0 -931
data/doc/Minting.html +0 -142
data/doc/Numeric.html +0 -479
data/doc/String.html +0 -241
data/doc/_index.html +0 -206
data/doc/class_list.html +0 -54
data/doc/css/common.css +0 -1
data/doc/css/full_list.css +0 -206
data/doc/css/style.css +0 -1089
data/doc/file.README.html +0 -291
data/doc/file_list.html +0 -59
data/doc/frames.html +0 -22
data/doc/index.html +0 -291
data/doc/js/app.js +0 -801
data/doc/js/full_list.js +0 -334
data/doc/js/jquery.js +0 -4
data/doc/method_list.html +0 -758
data/doc/top-level-namespace.html +0 -135
data/lib/minting/mint/aliases.rb +0 -16
data/lib/minting/mint/parser/parser.rb +0 -97
data/lib/minting/mint/parser/separators.rb +0 -41
data/lib/minting/mint/rounding.rb +0 -65
data/lib/minting/money/format/formatting.rb +0 -130

data/doc/top-level-namespace.html DELETED Viewed

@@ -1,135 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>
-  Top Level Namespace
-    &mdash; Documentation by YARD 0.9.44
-</title>
-  <link rel="stylesheet" href="css/style.css" type="text/css">
-  <link rel="stylesheet" href="css/common.css" type="text/css">
-<script type="text/javascript">
-  pathId = "";
-  relpath = '';
-</script>
-  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
-  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
-  </head>
-  <body>
-    <div id="main_progress" aria-hidden="true"></div>
-    <div class="nav_wrap">
-      <iframe id="nav" src="class_list.html?1"></iframe>
-      <div id="resizer"></div>
-    </div>
-    <div id="main" tabindex="-1">
-      <div id="header">
-        <div id="menu">
-    <a href="_index.html">Index</a> &raquo;
-    <span class="title">Top Level Namespace</span>
-</div>
-        <div id="search">
-    <a class="full_list_link" id="class_list_link"
-        href="class_list.html">
-        <svg width="24" height="24">
-          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
-          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
-          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
-        </svg>
-    </a>
-</div>
-        <div class="clear"></div>
-      </div>
-      <div id="content"><h1>Top Level Namespace
-</h1>
-<div class="box_info">
-</div>
-<h2>Defined Under Namespace</h2>
-<p class="children">
-      <strong class="modules">Modules:</strong> <span class='object_link'><a href="Mint.html" title="Mint (module)">Mint</a></span>, <span class='object_link'><a href="Minting.html" title="Minting (module)">Minting</a></span>
-      <strong class="classes">Classes:</strong> <span class='object_link'><a href="Numeric.html" title="Numeric (class)">Numeric</a></span>, <span class='object_link'><a href="String.html" title="String (class)">String</a></span>
-</p>
-    <h2>
-      Constant Summary
-      <small><a href="#" class="constants_summary_toggle">collapse</a></small>
-    </h2>
-    <dl class="constants">
-        <dt id="Money-constant" class="">Money =
-        </dt>
-        <dd><pre class="code"><span class='const'><span class='object_link'><a href="Mint.html" title="Mint (module)">Mint</a></span></span><span class='op'>::</span><span class='const'><span class='object_link'><a href="Mint/Money.html" title="Mint::Money (class)">Money</a></span></span></pre></dd>
-        <dt id="Currency-constant" class="">Currency =
-        </dt>
-        <dd><pre class="code"><span class='const'><span class='object_link'><a href="Mint.html" title="Mint (module)">Mint</a></span></span><span class='op'>::</span><span class='const'><span class='object_link'><a href="Mint/Currency.html" title="Mint::Currency (class)">Currency</a></span></span></pre></dd>
-    </dl>
-</div>
-      <div id="footer">
-  Generated on Wed Jul  1 01:11:52 2026 by
-  <a href="https://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.9.44 (ruby-4.0.5).
-</div>
-    </div>
-  </body>
-</html>

data/lib/minting/mint/aliases.rb DELETED Viewed

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-# Optional top-level alias for Mint::Currency.
-#
-# Mint::Money is auto-bound as the top-level Money constant by
-# `require 'minting'` (see lib/minting.rb). Currency is not auto-bound
-# because application domain models are commonly named Currency (e.g. a
-# Rails model). Require this file to opt in:
-#
-#   require 'minting/mint/aliases'
-#
-if defined?(Currency) && Currency != Mint::Currency
-  warn "minting: top-level Currency is already defined (#{Currency}); skipping alias."
-else
-  Currency = Mint::Currency unless defined?(Currency)
-end

data/lib/minting/mint/parser/parser.rb DELETED Viewed

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-# Mint Money parsing
-module Mint
-  extend self
-  # 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
-  #   Mint.parse('19.99', 'USD')    #=> [USD 19.99]
-  #   Mint.parse('garbage', 'USD')  #=> nil
-  #
-  # @example With symbol or code in the string
-  #   Mint.parse('$19.99')            #=> [USD 19.99]
-  #   Mint.parse('USD 1,234.56')    #=> [USD 1234.56]
-  def 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)
-    Mint::Money.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
-  #   Mint.parse!('19.99', 'USD')    #=> [USD 19.99]
-  #   Mint.parse!('garbage', 'USD')  #=> ArgumentError
-  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 = 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)
-    Mint::Money.new(amount, currency)
-  end
-  private
-  # Extracts a numeric value from input that should only contain an amount.
-  # @private
-  def parse_amount(input)
-    accounting_negative = input.start_with?('(') && input.end_with?(')')
-    # Remove any charater that is not a digit, comma or period
-    numeric_input = input.scan(/[\d.,-]/).join
-    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.
-  # @private
-  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
-end

data/lib/minting/mint/parser/separators.rb DELETED Viewed

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-# Mint Money parsing
-module Mint
-  extend self
-  private
-  # Classifies the separator pattern in a numeric string.
-  # @private
-  def classify_separators(numeric)
-    case [numeric.count('.'), numeric.count(',')]
-    in [0, 1] if numeric[-4] == ',' then :thousands_comma # Comma is a thousand separator
-    in [0, 1]                       then :decimal_comma   # Only one comma: decimal (e.g. 19,99 or 1,4 or 1,2345).
-    in [0, 0] | [1, 0]              then :decimal_period  # e.g. "1500" or "34.21".
-    in [p, c] if p > 1 && c > 1     then :invalid         # Both separators appear multiple times
-    in [p, c] if p > 0 && c > 0     then :mixed           # Commas and dots: the rightmost one is the decimal
-    else                                 :thousands       # Multiple of the same separator only (e.g. 1,234,567)
-    end
-  end
-  # Converts locale-specific decimal/thousand separators into a plain decimal string.
-  # @private
-  def parse_separators(numeric)
-    return nil unless numeric.match?(/\d/)
-    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_comma  then numeric.delete(',')
-    when :thousands        then numeric.delete('.,')
-    when :invalid          then nil
-    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
-end

data/lib/minting/mint/rounding.rb DELETED Viewed

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-module Mint
-  # Rounding-mode dispatch table and block-scoped context.
-  # @api private
-  module Rounding
-    # Maps mode symbols to their corresponding +Rational+ rounding lambdas.
-    # @return [Hash{Symbol => Proc}]
-    # @api private
-    MODES = {
-      half_up: ->(amount, ndigits) { amount.round(ndigits, half: :up) },
-      half_down: ->(amount, ndigits) { amount.round(ndigits, half: :down) },
-      half_even: ->(amount, ndigits) { amount.round(ndigits, half: :even) },
-      floor: ->(amount, ndigits) { amount.floor(ndigits) },
-      ceil: ->(amount, ndigits) { amount.ceil(ndigits) },
-      truncate: ->(amount, ndigits) { amount.truncate(ndigits) },
-      down: ->(amount, ndigits) { amount.truncate(ndigits) }
-    }.freeze
-    # 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
-    end
-    # Rounds +amount+ to +ndigits+ using the currently scoped rounding mode.
-    # Uses the fast path (+to_r.round+) when no custom mode is active.
-    # @api private
-    # @param amount [Numeric]
-    # @param ndigits [Integer]
-    # @return [Rational]
-    def self.apply(amount, ndigits)
-      mode = Thread.current[:minting_rounding_mode]
-      if mode
-        MODES.fetch(mode).call(amount.to_r, ndigits)
-      else
-        amount.to_r.round(ndigits)
-      end
-    end
-    # Sets a rounding mode for the duration of a block, restoring the
-    # previous mode on exit (even on exception).
-    # @api private
-    # @param mode [Symbol]
-    # @yield block to execute with the mode active
-    # @raise [ArgumentError] on unknown mode
-    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
-      yield
-    ensure
-      Thread.current[:minting_rounding_mode] = 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|
-  Mint::Rounding.apply(amount, subunit)
-end

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

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-module Mint
-  # :nodoc:
-  class Money
-    def self.compiled_formatters
-      @compiled_formatters ||= {}
-    end
-    # Build each sign template with subunit precision baked in, returning a
-    # frozen Hash of templates keyed by sign (:positive, :negative, :zero).
-    # Keeps %<symbol>s and %<currency>s as format args so width/padding specifiers work.
-    # @private
-    def self.compile_templates(format_hash, subunit)
-      [
-        format_hash[:positive] || DEFAULT_FORMAT,
-        format_hash[:negative],
-        format_hash[:zero]
-      ].map do |sign_format|
-        next unless sign_format
-        # Injects the currency's subunit precision into %<amount>f specifiers
-        # (e.g. '%<amount>f' → '%<amount>.2f' for USD), preserving any
-        # existing width/alignment specifier (e.g. '%<amount>+10f' stays).
-        sign_format = sign_format.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{subunit}f")
-        # For zero-subunit currencies (JPY, KRW, etc.), strip %<fractional>d
-        # specifiers entirely since there is no fractional part to display.
-        sign_format.gsub!(/%<fractional>[^%]*?d/, '') if subunit.zero?
-        sign_format
-      end
-    end
-    # Builds and returns a lambda that formats amounts for a fixed
-    # [format_config, currency, decimal, thousand] combination.
-    # The lambda is cached by {.compiled_formatters}.
-    # @private
-    def self.compile_formatter(format_hash, currency, decimal, thousand) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      subunit = currency.subunit
-      has_decimal_substitution = decimal != '.'
-      escaped_decimal = Regexp.escape(decimal)
-      has_thousand_separator = thousand && !thousand.empty?
-      templates = compile_templates(format_hash, subunit)
-      positive_template, negative_template, zero_template = templates
-      # Detect whether templates use %<fractional> and/or %<d-symbol>
-      all_templates = templates.compact.join
-      needs_fractional = all_templates.include?('%<fractional>')
-      needs_integral = all_templates.include?('%<amount>') || all_templates.include?('%<integral>')
-      multiplier = currency.fractional_multiplier
-      symbol = currency.symbol
-      args = {
-        currency: currency.code,
-        dsymbol: currency.disambiguate_symbol || symbol,
-        symbol: symbol
-      }
-      lambda do |amount|
-        format_template = if negative_template && amount < 0
-                            amount = -amount
-                            negative_template
-                          elsif zero_template && amount == 0
-                            zero_template
-                          else
-                            positive_template
-                          end
-        args[:amount] = amount
-        args[:integral] = amount.to_i
-        args[:fractional] = ((amount.abs % 1) * multiplier).to_i if needs_fractional
-        result = Kernel.format(format_template, **args)
-        result.gsub!(/(?<=\d)\.(?=\d)/, decimal) if has_decimal_substitution
-        if needs_integral && has_thousand_separator && (amount >= 1000 || amount <= -1000)
-          # Split on the decimal separator between digits only — symbols may contain '.' (e.g. د.إ).
-          parts = result.split(/(?<=\d)#{escaped_decimal}(?=\d)/, 2)
-          # Insert the thousands delimiter before each run of 3 digits from the right.
-          parts[0].gsub!(/(\d)(?=(?:\d{3})+(?:[^\d]|$))/) { Regexp.last_match(1) + thousand }
-          result = parts.join(decimal)
-        end
-        result
-      end
-    end
-    private
-    # 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
-    # Validates +decimal+ and +thousand+ separator arguments.
-    # @private
-    def validate_separators!(decimal:, thousand:)
-      case decimal
-      when nil      # :noop
-      when ''       then raise ArgumentError, 'decimal must be a non-empty'
-      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, String # :noop
-      else raise ArgumentError, "thousand must be a String, false, or nil, got #{thousand.inspect}"
-      end
-    end
-    # Applies a format template to the money amount, returning a formatted string.
-    # Uses a cached compiled formatter lambda that pre-resolves currency-specific
-    # values (symbol, code, subunit) so per-call work is reduced to
-    # Kernel.format + optional separator substitutions.
-    # @private
-    def format_amount(format, decimal:, thousand:)
-      key = [format, currency_code, decimal, thousand].hash
-      formatter = Money.compiled_formatters[key] ||= Money.compile_formatter(format, currency, decimal, thousand)
-      formatter.call(amount)
-    end
-  end
-end