minting 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55db3e9b61e8ee1c813e313789222cc2e083f59c1070c12801cd3afd5eaf6fe6
-  data.tar.gz: d2d4420c40bd39e551a79a9b1ad42386f8d8ab4e9560ad8ad287909fc1a5633a
+  metadata.gz: 135843eccae0c9415ad8cd2c941d7afeceb19958fdff5c3d898fbcfd76d51218
+  data.tar.gz: 90d8349d74b739d37a3aa37a83002190a3975064cb11b279f8d4c9ef1760e4a6
 SHA512:
-  metadata.gz: 7aa9f93ea36aeef350308adcec126812a8e5438a95d5e305d79ca6e993f27ffbf7f27908fd4ead9fa0b3659f10f29db263b31b97c5a86fb1f689c401913401eb
-  data.tar.gz: c9267d2eb5e5329d7af59eca2507663bf85e4716f2dda4089946c86bd0da8f2848e4069e298e4a9a58eba4a89da203fd7116226f546ab2bf531ad0cc04ce3526
+  metadata.gz: aaaab50cf31d56f8e4f22d0f760803c0c24eef022648df41161c387a6dadbe403d41b6347dc7018758cb0d5e72b8ce9ba2567a3f23df84da9b26fd53c4a9b31e
+  data.tar.gz: bed44112191195ea250b6a5b8c809a43df72f79e387bae80881833f1d174ef2f01e450c986431f542b4fa41b55ed202e8ccfd38921355118ecf5004b5237ed99

data/README.md

@@ -35,7 +35,8 @@ total.currency_code                    #=> "USD"
 - Comparisons: `==`, `<=>`, `zero?`, `nonzero?`, `positive?`, `negative?`
 - Formatting: `to_s` with custom formats, thousand delimiters and decimal separators
 - Serialization: `to_json`, `to_i`, `to_f`, `to_r`, `to_d`
-- Allocation utilities: `split(quantity)`, `allocate([ratios])`
+- Allocation utilities: `split(quantity)`, `allocate([ratios])`, 
+- Utilities: `clamp(min, max)`
 - Numeric Refinements for ergonomics: `10.dollars`, `3.euros`, `4.to_money('USD')`
 - Currency registry with 117+ currencies and custom registration
 
@@ -116,6 +117,18 @@ Mint::Money.from_fractional(1234, 'JPY') #=> [JPY 1234]  # subunit 0 -> no scali
 ten.split(3)                           #=> [[USD 3.34], [USD 3.33], [USD 3.33]]
 ten.allocate([1, 2, 3])                #=> [[USD 1.67], [USD 3.33], [USD 5.00]]
 
+# Clamping to a range
+
+price = Mint.money(50, 'USD')
+min_price = Mint.money(75, 'USD')
+
+price.clamp(0, 100)                    #=> [USD 50.00]  (returns self, no new object)
+price.clamp(0, 25)                     #=> [USD 25.00]  (clamped to max)
+price.clamp(min_price, 100)                   #=> [USD 75.00]  (clamped to min)
+
+# Clamp accepts Money bounds or Numeric amounts
+price.clamp(min_price, 100) #=> [USD 75.00]
+
 # Ranges and enumeration are supported
 
 1.dollar..10.dollars                      #=> [USD 1.00]..[USD 10.00]

data/Rakefile

@@ -3,7 +3,7 @@ require 'rubocop/rake_task'
 require 'rake/testtask'
 require 'yard'
 
-CLOBBER.include %w[doc tmp .yardoc]
+CLOBBER.include %w[doc/css doc/js doc/Mint doc/*.html tmp .yardoc]
 
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'

data/doc/agents/recommendations.md

@@ -100,7 +100,7 @@ This makes the table *defensible* rather than aspirational.
 
 ## 🟠 P1 — Correctness, clarity, small ergonomics
 
-### P1-1 ✅ `Money.from_fractional(integer, currency)`
+### P1-1 🟡 `Money.from_fractional(integer, currency)`
 
 **Status:** Merged on branch `feature/money-from-fractional` (commit
 `150a2d0`).

data/doc/agents/rubocop-issues.md

@@ -0,0 +1,332 @@
+# Rubocop Issues Assessment: Minting Gem
+
+**Date:** 2026-06-03  
+**Total Issues Found:** 93 (88 conventions, 5 warnings)  
+**Files Analyzed:** 37  
+**Files with Issues:** 23
+
+---
+
+## Executive Summary
+
+The minting gem's rubocop analysis reveals **93 total violations**, primarily concentrated in test code rather than production code. The violations fall into two broad categories:
+
+1. **Production Code Issues (9 violations):** Focused on architectural patterns, complexity, and parameter design
+2. **Test Code Issues (84 violations):** Mostly style/complexity issues in test assertions
+
+The good news: **Most issues are low-risk conventions** affecting code style and test organization, not correctness or performance. The critical items requiring attention are marked with ⚠️.
+
+---
+
+## Issues by Category
+
+### 🚨 Critical Issues (Must Address)
+
+#### 1. **Lint/ItWithoutArgumentsInBlock** (Warning)
+- **Severity:** Warning (Ruby 3.4 compatibility)
+- **Location:** `lib/minting/money/allocation.rb:56`
+- **Issue:** `it` calls without arguments will have different semantics in Ruby 3.4
+- **Action:** Use `it()` or `self.it` explicitly
+- **Status:** Actionable, simple fix
+
+#### 2. **Lint/EmptyWhen** (Warnings) - 4 occurrences
+- **Severity:** Warning
+- **Locations:** `lib/minting/money/money.rb` (lines 136, 137, 147, 148)
+- **Issue:** Empty `when` branches in case statement (likely fall-through logic)
+- **Action:** Either add `# rubocop:disable` comment if intentional, or refactor the case logic
+- **Status:** Needs clarification on intent
+
+---
+
+### ⚠️ High Priority - Production Code (Should Address Soon)
+
+#### 1. **ThreadSafety/ClassInstanceVariable** - 4 occurrences
+- **Severity:** Convention
+- **Location:** `lib/minting/mint/registry.rb` (lines 21, 64, 72, 80)
+- **Issue:** Class instance variables used in registry pattern for caching
+- **Current Design:** Registry caches currencies and symbol mappings using `@@` class variables
+- **Trade-offs:**
+  - ✅ Simple, works well for single-threaded scenarios
+  - ❌ Not thread-safe; could cause race conditions if accessed concurrently
+  - ❌ Rubocop flags this as an anti-pattern for multi-threaded apps
+- **Recommendation:** Current design is acceptable for a gem that caches static data (currencies don't change at runtime). Consider adding thread-safety if multi-threaded use becomes a requirement.
+- **Effort:** Medium (if refactored, would use class-level synchronization or lazy initialization)
+
+#### 2. **Metrics/ParameterLists** - 1 occurrence
+- **Severity:** Convention
+- **Location:** `lib/minting/mint/currency.rb:23`
+- **Issue:** Currency constructor has 6 parameters (limit: 5)
+- **Current Signature:** `initialize(code:, subunit:, symbol: nil, priority: 0, minimum_amount: nil, ...)`
+- **Recommendation:** Consider if all parameters are essential. Could use keyword arguments or a builder pattern.
+- **Effort:** Low-to-Medium (API surface change)
+
+#### 3. **Metrics/AbcSize (Low Severity)** - 3 occurrences in production code
+- **Severity:** Convention
+- **Locations:**
+  - `lib/minting/money/allocation.rb:15` - `allocate` method (18.68/17)
+  - `lib/minting/money/formatting.rb:81` - `format_amount` method (22.65/17)
+  - `lib/minting/money/money.rb:122` - `clamp` method (20.05/17)
+- **Issue:** These methods slightly exceed the complexity threshold, but are core business logic
+- **Recommendation:** These are acceptable as-is; splitting would reduce clarity. Monitor if they grow further.
+- **Effort:** Low priority; monitor only
+
+#### 4. **Metrics/CyclomaticComplexity & Metrics/PerceivedComplexity** - 3 occurrences
+- **Severity:** Convention
+- **Locations:**
+  - `lib/minting/money/money.rb:122` - `clamp` method
+  - `lib/minting/money/parse.rb:43` - `normalize_separators` method
+  - `test/performance/benchmark_helper.rb:71` - test utility
+- **Issue:** Multiple conditional branches increase cyclomatic complexity
+- **Recommendation:** These methods handle multi-condition business logic; acceptable for now. Refactor only if maintainability becomes an issue.
+- **Effort:** Low priority
+
+---
+
+### 📊 Medium Priority - Test Code Issues
+
+#### 1. **Minitest/MultipleAssertions** - 34 occurrences (37% of total issues)
+- **Severity:** Convention
+- **Affected Files:** Most test files
+- **Issue:** Test methods exceed 3 assertions (max threshold)
+- **Examples:**
+  - `test/mint_test.rb:21` - 10 assertions
+  - `test/money/money_allocation_test.rb:26` - 12 assertions
+  - `test/money/money_arithmetics_test.rb:6` - 7 assertions
+- **Rationale in Minting:** This is a measurement gem where comprehensive verification is necessary. Each operation's correctness depends on multiple properties:
+  - Amount correctness
+  - Currency preservation
+  - Rounding behavior
+  - Edge cases (zero, negative, large values)
+- **Recommendation:** Consider documenting this intentional choice in `.rubocop.yml` or refactoring into helper assertions that reduce per-test assertion count while maintaining test coverage.
+- **Effort:** Medium-to-High (would require restructuring test organization)
+
+#### 2. **Metrics/AbcSize (Test Context)** - 22 occurrences
+- **Severity:** Convention
+- **Affected Files:** Primarily benchmark and test files
+- **Issue:** Complex test methods with many branches
+- **Recommendation:** These are acceptable in test code; they reflect the complexity of the scenarios being tested. Low priority.
+- **Effort:** Low priority
+
+#### 3. **Metrics/ClassLength** - 4 occurrences
+- **Severity:** Convention
+- **Locations:**
+  - `test/money/money_format_test.rb:3` - 232 lines
+  - `test/performance/algorithm_benchmark.rb:5` - 172 lines
+  - `test/performance/competitive_performance_benchmark.rb:5` - 182 lines
+  - `test/performance/regression_benchmark.rb:5` - 151 lines
+- **Issue:** Test classes exceed 100-line limit
+- **Recommendation:** These are large test suites for good reason (comprehensive coverage). Could be split into smaller classes, but test organization should prioritize clarity over line counts.
+- **Effort:** Medium (if refactored)
+
+#### 4. **Metrics/BlockLength** - 3 occurrences
+- **Severity:** Convention
+- **Affected Files:** Performance benchmark files
+- **Issue:** Block length exceeds 25 lines
+- **Recommendation:** Low priority for benchmarks; these require comprehensive setup and measurement
+- **Effort:** Low priority
+
+#### 5. **Metrics/ModuleLength** - 1 occurrence
+- **Severity:** Convention
+- **Location:** `test/performance/benchmark_helper.rb:11` (105 lines)
+- **Issue:** Module slightly exceeds 100-line limit
+- **Recommendation:** This is a utility module for benchmarks; acceptable as-is
+- **Effort:** Low priority
+
+#### 6. **Performance/CollectionLiteralInLoop** - 1 occurrence
+- **Severity:** Convention
+- **Location:** `test/performance/algorithm_benchmark.rb:19`
+- **Issue:** Array literal created in loop
+- **Recommendation:** Extract to constant or variable outside loop for performance
+- **Effort:** Low
+
+---
+
+## Issue Distribution Analysis
+
+### By Component
+```
+Production Code Issues:
+├── lib/minting/mint/currency.rb: 1
+├── lib/minting/mint/registry.rb: 4 (thread safety)
+├── lib/minting/money/allocation.rb: 2
+├── lib/minting/money/formatting.rb: 1
+├── lib/minting/money/money.rb: 7 (complexity)
+└── lib/minting/money/parse.rb: 2
+
+Test/Benchmark Issues:
+├── Unit tests (test/): 43
+└── Benchmarks (test/performance/): 42
+```
+
+### By Severity
+- **Warnings:** 5 (Ruby 3.4 compatibility + empty when branches)
+- **Conventions:** 88 (style, complexity, structure)
+
+### By Cop Type
+```
+Minitest/MultipleAssertions    34 (37%)   - Test assertion counts
+Metrics/AbcSize                33 (35%)   - Complexity of methods
+ThreadSafety/ClassInstanceVar   4 (4%)   - Registry caching pattern
+Lint/EmptyWhen                  4 (4%)   - Incomplete case logic
+Metrics/ClassLength             4 (4%)   - Large test classes
+Metrics/CyclomaticComplexity    3 (3%)   - Branch complexity
+Metrics/PerceivedComplexity     3 (3%)   - Subjective complexity
+Metrics/BlockLength             3 (3%)   - Large blocks
+Others                          5 (5%)   - Various minor issues
+```
+
+---
+
+## Rubocop Configuration
+
+**Current thresholds** (in `.rubocop.yml`):
+- Line length: 120 characters
+- Method length: 30 lines
+- Default complexity thresholds apply
+
+**Active plugins:**
+- rubocop-minitest (for test-specific rules)
+- rubocop-packaging (gem packaging rules)
+- rubocop-performance (performance optimizations)
+- rubocop-rake (Rakefile rules)
+- rubocop-thread_safety (concurrency patterns)
+
+---
+
+## Recommendations by Priority
+
+### Priority 1: Fix Immediately
+- [ ] Fix `Lint/ItWithoutArgumentsInBlock` in `lib/minting/money/allocation.rb:56`
+  - **Effort:** < 5 minutes
+  - **Impact:** Ensures Ruby 3.4+ compatibility
+  
+- [ ] Clarify or fix `Lint/EmptyWhen` in `lib/minting/money/money.rb` (4 lines)
+  - **Effort:** < 10 minutes
+  - **Impact:** Clarifies intent of case statement logic
+
+### Priority 2: Plan Refactoring
+- [ ] Evaluate thread-safety requirements for `Registry` class
+  - **Effort:** Medium
+  - **Impact:** Determines if class variable pattern is acceptable
+  - **Timeline:** Consider for v2.0 or if multi-threaded use is required
+
+- [ ] Decide on parameter design for `Currency` (6 parameters vs. 5 max)
+  - **Effort:** Low
+  - **Impact:** Could simplify API
+  - **Timeline:** Can defer if current design is stable
+
+### Priority 3: Test Organization (Optional)
+- [ ] Consider refactoring test assertions to reduce `Minitest/MultipleAssertions` violations
+  - **Effort:** High
+  - **Impact:** Improves test organization, but current approach is acceptable
+  - **Timeline:** Only if test maintainability becomes an issue
+
+- [ ] Consider splitting large test/benchmark classes (`money_format_test.rb`, benchmark files)
+  - **Effort:** Medium-High
+  - **Impact:** Improves file organization
+  - **Timeline:** Optional; not critical
+
+---
+
+## Configuration Adjustments
+
+### Option A: Accept Current Baseline (Recommended)
+Keep current `.rubocop.yml` configuration. The violations represent:
+- Acceptable complexity trade-offs for a measurement gem
+- Best practices for test organization given domain requirements
+- Intentional design choices for performance and clarity
+
+### Option B: Relax Thresholds
+Add exceptions to `.rubocop.yml` for known violations:
+```yaml
+Minitest/MultipleAssertions:
+  Enabled: false  # Disable for this gem; multi-assertion tests are necessary
+
+Metrics/AbcSize:
+  Exclude:
+    - test/performance/**/*
+```
+
+### Option C: Strict Compliance (Not Recommended)
+Refactor to meet all thresholds. Would require:
+- Splitting large test classes (disruptive to test organization)
+- Reducing assertions per test (reduces coverage clarity)
+- Architectural changes to reduce method complexity
+
+---
+
+## Summary Table
+
+| Category | Count | Severity | Effort | Recommendation |
+|----------|-------|----------|--------|-----------------|
+| Ruby 3.4 Compatibility | 1 | High | Low | **Fix immediately** |
+| Empty When Branches | 4 | Medium | Low | **Fix/clarify** |
+| Thread Safety | 4 | Medium | Medium | Monitor & plan |
+| Parameter Lists | 1 | Low | Low | Optional refactor |
+| Method Complexity | 8 | Low | Medium | Accept as-is |
+| Test Assertions | 34 | Low | High | Accept/document intent |
+| Test Organization | 37 | Low | High | Optional refactor |
+
+---
+
+## Next Steps
+
+1. **Immediate (This Sprint):**
+   - Fix `Lint/ItWithoutArgumentsInBlock` warning
+   - Address `Lint/EmptyWhen` warnings (fix or document intent)
+   - Run full test suite to verify fixes don't break anything
+
+2. **Short-term (This Quarter):**
+   - Evaluate thread-safety requirements
+   - Decide on currency parameter design
+   - Document rationale for test assertion counts
+
+3. **Long-term (v2.0 Planning):**
+   - Consider architectural improvements to reduce complexity
+   - Evaluate thread-safety refactoring if multi-threaded use becomes a requirement
+   - Plan test organization improvements if maintainability becomes an issue
+
+---
+
+## Appendix: Full Issue List
+
+### Production Code - All Issues
+
+**lib/minting/mint/currency.rb**
+- Line 23: `Metrics/ParameterLists` - 6 parameters vs. 5 max
+
+**lib/minting/mint/registry.rb**
+- Line 21, 64, 72, 80: `ThreadSafety/ClassInstanceVariable` - 4 violations (class instance variables for caching)
+
+**lib/minting/money/allocation.rb**
+- Line 15: `Metrics/AbcSize` - allocate method (18.68/17)
+- Line 56: `Lint/ItWithoutArgumentsInBlock` - Warning for Ruby 3.4
+
+**lib/minting/money/formatting.rb**
+- Line 81: `Metrics/AbcSize` - format_amount method (22.65/17)
+
+**lib/minting/money/money.rb**
+- Line 122: `Metrics/AbcSize` - clamp method (20.05/17)
+- Line 122: `Metrics/CyclomaticComplexity` - clamp method (11/7)
+- Line 122: `Metrics/PerceivedComplexity` - clamp method (10/8)
+- Lines 136, 137, 147, 148: `Lint/EmptyWhen` - 4 empty when branches
+
+**lib/minting/money/parse.rb**
+- Line 43: `Metrics/CyclomaticComplexity` - normalize_separators (8/7)
+- Line 43: `Metrics/PerceivedComplexity` - normalize_separators (9/8)
+
+### Test Code - Summary
+- 34 `Minitest/MultipleAssertions` violations across test files
+- 22 `Metrics/AbcSize` violations in tests
+- 4 `Metrics/ClassLength` violations
+- 3 `Metrics/BlockLength` violations in benchmarks
+- 1 `Metrics/ModuleLength` in benchmark_helper.rb
+- 1 `Performance/CollectionLiteralInLoop` in algorithm_benchmark.rb
+
+See detailed output above for specific line numbers and messages.
+
+---
+
+**Generated:** 2026-06-03  
+**Rubocop Version:** 1.87.0  
+**Ruby Version:** 4.0.1

data/lib/minting/mint/currency.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mint
   # Represents a specific currency unit, identified by ISO 4217 alphabetic code
   #
@@ -8,13 +10,12 @@ module Mint
                 :fractional_multiplier, :minimum_amount,
                 :name, :priority
 
-    def inspect
-      "<Currency:(#{code} #{symbol} #{subunit})>"
-    end
+    def inspect = "<Currency:(#{code} #{symbol} #{subunit} #{name})>"
 
-    def normalize_amount(amount)
-      amount.to_r.round(subunit)
-    end
+    # 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)
 
     private
 
@@ -26,7 +27,7 @@ module Mint
       @country = country
       @name = name
       @fractional_multiplier = 10**@subunit
-      @minimum_amount = 1r / fractional_multiplier
+      @minimum_amount = Rational(1, fractional_multiplier)
       freeze
     end
   end

data/lib/minting/mint/currency_store.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+# Mint currency store (internal)
+module Mint
+  # Internal currency storage and loading.
+  # Manages the registry cache and currency symbol lookups.
+  module CurrencyStore
+    # Returns the hash of all registered currencies.
+    #
+    # @return [Hash{String => Currency}] registered currencies mapped by code
+    # @api private
+    def self.currencies
+      @currencies ||= begin
+        registry = { 'XXX' => Currency.new(code: 'XXX', name: 'No currency', symbol: '¤') }
+        load_currencies(registry)
+      end
+    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 self.currency_symbols
+      @currency_symbols ||= begin
+        currencies.values
+                  .reject { |currency| currency.symbol.empty? }
+                  .map { |currency| [currency.symbol, currency] }
+                  .sort_by { |symbol, currency| [-symbol.length, -currency.priority] }
+      end.freeze
+    end
+
+    # Clears and refreshes the currency symbol cache.
+    # Called when currencies are registered.
+    #
+    # @api private
+    def self.invalidate_symbols_cache
+      @currency_symbols = nil
+    end
+
+    # Loads currencies from YAML file into the registry.
+    #
+    # @param registry [Hash] the registry hash to populate
+    # @return [Hash] the populated registry
+    # @api private
+    def self.load_currencies(registry)
+      base = File.expand_path('../data', __dir__)
+      path = File.join(base, 'currencies.yaml')
+
+      data = YAML.load_file(path)
+      data.each do |entry|
+        code = entry['code']
+        registry[code] = Currency.new(
+          code: code,
+          subunit: entry['subunit'],
+          symbol: entry['symbol'],
+          priority: entry['priority'],
+          country: entry['country'],
+          name: entry['name']
+        )
+      end
+      registry
+    end
+
+    private_class_method :load_currencies
+  end
+end

data/lib/minting/mint/refinements.rb

@@ -1,4 +1,6 @@
-# Mint is a library to operate with monetary values
+# frozen_string_literal: true
+
+# Mint refinements
 module Mint
   refine Numeric do
     def reais

data/lib/minting/mint/registry.rb

@@ -1,17 +1,18 @@
-require 'yaml'
+# frozen_string_literal: true
 
+# Mint currency registration and factory (public API)
 module Mint
   # Creates a new {Money} instance with the given amount and currency code.
   #
   # @param amount [Numeric] the financial value
-  # @param currency_code [String, Symbol] the ISO currency code or symbol
+  # @param currency_code [String] the ISO currency code
   # @return [Money] the instantiated Money object
   # @raise [ArgumentError] if the currency code is not registered
   def self.money(amount, currency_code)
     currency = currency(currency_code)
     return Money.create(amount, currency) if currency
 
-    raise ArgumentError, "[#{currency.inspect}] is not a registered currency. Check Mint.currencies"
+    raise ArgumentError, "[#{currency.inspect}] is not a registered currency."
   end
 
   # Returns default zero, no currency money
@@ -23,7 +24,7 @@ module Mint
   # @param currency [String, Currency] the currency identifier or object
   # @return [Currency, nil] the registered Currency instance or nil if not found
   def self.currency(currency)
-    currency.is_a?(Currency) ? currency : currencies[currency]
+    currency.is_a?(Currency) ? currency : CurrencyStore.currencies[currency]
   end
 
   # Registers a new currency if not already registered.
@@ -34,8 +35,8 @@ module Mint
   # @param priority [Integer] parser precedence priority (defaults to 0)
   # @return [Currency] the registered or existing Currency instance
   # @raise [ArgumentError] if the code layout is invalid or register throws an error
-  def self.register_currency(code:, subunit: 2, symbol: '', priority: 0)
-    currencies[code] || register_currency!(code:, subunit:, symbol:, priority:)
+  def self.register_currency(code:, subunit: 0, symbol: '', priority: 0)
+    CurrencyStore.currencies[code] || register_currency!(code:, subunit:, symbol:, priority:)
   end
 
   # Strictly registers a new currency, raising a KeyError if already registered.
@@ -54,52 +55,20 @@ module Mint
             "Currency code must only letters or '_' ('USD',, 'MY_COIN')"
     end
 
-    currency = currencies[code]
-    raise KeyError, "Currency: #{code} already registered" if currency
+    currencies = CurrencyStore.currencies
+    raise KeyError, "Currency: #{code} already registered" if currencies[code]
 
     currency = currencies[code] = Currency.new(code:, subunit:, symbol:, priority:)
-    @currency_symbols = nil
+    CurrencyStore.invalidate_symbols_cache
     currency
   end
 
-  # Returns the hash of all registered currencies.
-  #
-  # @return [Hash{String => Currency}] registered currencies mapped by code
-  def self.currencies
-    @currencies ||= begin
-      registry = { 'XXX' => Currency.new(code: 'XXX', name: 'No currency', symbol: '¤') }
-      load_currencies(registry)
-    end
-  end
-
   # Registered symbols sorted for detection: longest match wins, then parser priority.
+  # Internal API - used by Money parser.
+  #
+  # @return [Array<Array<String, Currency>>] sorted symbol-to-currency mappings
+  # @api private
   def self.currency_symbols
-    @currency_symbols ||= begin
-      currencies.values
-                .map { |currency| [currency.symbol, currency] }
-                .reject { |symbol, _| symbol.empty? }
-                .sort_by { |symbol, currency| [-symbol.length, -currency.priority] }
-    end.freeze
+    CurrencyStore.currency_symbols
   end
-
-  def self.load_currencies(registry)
-    base = File.expand_path('../data', __dir__)
-    path = File.join(base, 'currencies.yaml')
-
-    data = YAML.load_file(path)
-    data.each do |entry|
-      code = entry['code']
-      registry[code] = Currency.new(
-        code: code,
-        subunit: entry['subunit'],
-        symbol: entry['symbol'],
-        priority: entry['priority'],
-        country: entry['country'],
-        name: entry['name']
-      )
-    end
-    registry
-  end
-
-  private_class_method :load_currencies
 end

data/lib/minting/mint.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 require 'minting/mint/currency'
-require 'minting/mint/refinements'
+require 'minting/mint/currency_store'
 require 'minting/mint/registry'
+require 'minting/mint/refinements'

data/lib/minting/money/allocation.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 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
@@ -50,7 +53,7 @@ module Mint
         last_slot = (left_over / minimum).to_i - 1
         (0..last_slot).each { |slot| amounts[slot] += minimum }
       end
-      amounts.map { Money.new(it, currency) }
+      amounts.map { |amount| Money.new(amount, currency) }
     end
   end
 end