minting-rails 0.7.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f55a3c6c12d63ec3bcd7fe8aded08cefcb61d9fc21491ce49d3057064fcbe18c
-  data.tar.gz: dc620d935db6c7d606286bbcbb786e75ccaec3e8437eaf7cdeb7b1cd94f5f433
+  metadata.gz: 6c6f9a0ca2ddc8795a648b6c6047728d626106e2afddbe63869ad3159fcd819e
+  data.tar.gz: 863f9135a359162e053f988e991a9ac2a832e56e310cc1c7511410212e7c0427
 SHA512:
-  metadata.gz: c4683ac9e66301ef10168808c4e623dec3539066ba62492f20922ac7f117a6bc48b7270ba31ce3ee948e3f6ca61adff4808013352322f9817cd2638c19dd6e4b
-  data.tar.gz: 31299dc881a94df769ec78cc9910668e278022f94fef389816758453f987b092136dda0ab039e50503fa61ba03d41d9f6a9528bc163b312127f212badc6b2759
+  metadata.gz: 148ee6a06dde29d5685c47e5c3e284fdce46c7d75cd84ab265760087f1e3fcc43afb9f60e949bbe615cf311b576bb9a6180569f103c5665a137d10849604e42c
+  data.tar.gz: 7c0eaca1345709f22bb446764b9220c5767cca2998e0570490871555cce3c2d692e5839eea9eedcae282cdbe032dca603d1a89bb8ba61d358aa725e83b26b883

data/README.md

@@ -1,86 +1,149 @@
 # Minting::Rails
 
-Minting::Rails brings [Minting](https://github.com/gferraz/minting) money objects to Active Record models.
+[![CI](https://github.com/gferraz/minting-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/gferraz/minting-rails/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/minting-rails.svg)](https://badge.fury.io/rb/minting-rails)
 
-It adds a `money_attribute` model helper, registers a `:mint_money` Active Record type, and includes small convenience methods such as `12.to_money('USD')`, `12.dollars`, and `'12.00'.mint('BRL')`.
+Store and read Active Record attributes as `Mint::Money` objects with a single `money_attribute` declaration. No manual serialization, no boilerplate.
 
-## What it does
+```ruby
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'   # fixed currency, single column
+  money_attribute :total                    # multi-currency, two columns
+end
+
+Product.new(price: 12).price  # => [USD 12.00]
+```
+
+## Quick start
+
+```sh
+bundle add minting-rails
+bin/rails g mint:initializer
+```
+
+```ruby
+# app/models/product.rb
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'
+end
+```
 
-- Stores and reads model attributes as `Mint::Money` objects.
-- Supports composed money attributes backed by amount and currency columns.
-- Normalizes numeric, string, and `Mint::Money` assignments.
-- Validates currencies against the currencies enabled in Minting.
+That's it. `Product.new(price: 12).price` is a `Mint::Money`.
+
+## Why Minting::Rails?
+
+- **No serialization boilerplate** — declare once, read/write `Mint::Money` everywhere.
+- **Two storage modes** — single column for fixed-currency apps (simpler), amount+currency columns for multi-currency records (more flexible).
+- **Integer or decimal columns** — auto-detects the column type and adjusts serialization (e.g. integer stores cents, decimal stores unit value).
+- **Normalizes everything** — pass a number, string, or `Mint::Money`; always get a `Mint::Money` back.
+- **Currency enforcement** — fixed-currency attributes reject wrong currencies at assignment time.
+- **Built on Rails primitives** — uses `ActiveRecord::Type`, `composed_of`, and `normalizes` under the hood. No monkey-patching of core classes.
+
+### At a glance — vs money-rails
+
+| Feature | minting-rails | money-rails |
+|---|---|---|
+| **Declaration** | `money_attribute :price` | `monetize :price_cents` |
+| **Column types** | `integer`, `decimal`, `bigint` — auto-detected | `integer` cents only |
+| **Storage modes** | Single column, composite (amount+currency)| Single cents column, composite (cents+currency) |
+| **Decimal columns** | Native — `t.decimal :price` | Not supported — must convert to cents manually |
+| **Multi-currency** | `money_attribute :price` (convention: `<name>_amount` + `<name>_currency`) | `monetize :price_cents, with_currency: :price_currency` |
+| **Rails integration** | `ActiveRecord::Type` + `composed_of` — no monkey-patches | `monetize` overrides reader/writer methods |
+| **Query (fixed)** | `Model.where(price: money)` — `=`, `IN`, `BETWEEN`, `ORDER`, `SUM` | Through cents column (`price_cents`) |
+| **Query (multi)** | `Model.where(price: money)` | `Model.where(price_cents:, price_currency:)` |
+| **Internal amount** | `Rational`  | `BigDecimal` |
+| **Performance** | See [BENCHMARKS.md](BENCHMARKS.md) — wins 9/11 cells |  |
 
 ## Requirements
 
-- Ruby 3.3 or newer.
-- Rails 7.1.3.2 or newer.
-- Minting 1.6.0 or newer.
+- Ruby 3.3+
+- Rails 7.1.3.2+
+- [Minting](https://github.com/gferraz/minting) 1.6.0+
 
 ## Installation
 
-Add the gem to your Rails application's `Gemfile`:
-
 ```ruby
+# Gemfile
 gem 'minting-rails'
 ```
 
-Install it:
-
 ```sh
 bundle install
-```
-
-Generate the initializer:
-
-```sh
 bin/rails g mint:initializer
 ```
 
-## Configuration
+The generator creates `config/initializers/minting.rb`.
 
-Configure Minting in `config/initializers/minting.rb`:
+## Configuration
 
 ```ruby
+# config/initializers/minting.rb
 Mint.configure do |config|
-  config.enabled_currencies = :all
   config.default_currency = 'USD'
-  config.default_format = '%<symbol>s%<amount>f'
+  # enabled_currencies removed — all registered currencies are valid
 end
 ```
 
-You can limit the currencies that may be used:
+See the [Minting gem](https://github.com/gferraz/minting) for full configuration options (custom currencies, formatting, rounding).
 
+### I18n / Locale-aware formatting
+
+Minting-rails integrates with Rails I18n to automatically format money amounts according to the current locale.
+
+With `I18n.locale` set to `:en`:
 ```ruby
-Mint.configure do |config|
-  config.enabled_currencies = %w[USD EUR BRL]
-  config.default_currency = 'USD'
-end
+Mint.money(1234.56, 'USD').to_s  # => "$1,234.56"
 ```
 
-You can also register custom currencies before enabling or using them:
-
+Switch to `:'pt-BR'` and the separators change automatically (requires [`rails-i18n`](https://github.com/svenfuchs/rails-i18n) or your own locale file):
 ```ruby
-Mint.configure do |config|
-  config.added_currencies = [
-    { currency: 'CRC', subunit: 2, symbol: 'CRC' },
-    { currency: 'NGN', subunit: 2, symbol: 'NGN' } # subunit is the number of digits after the decimal; USD has 2, JPY has 0, BHD has 3
-  ]
+I18n.locale = :'pt-BR'
+Mint.money(1234.56, 'USD').to_s  # => "$1.234,56"
+```
 
-  config.enabled_currencies = :all
-  config.default_currency = 'CRC'
-end
+The locale backend reads `number.currency.format` from your I18n translations and maps Rails format syntax (`%n` for amount, `%u` for unit) to `Mint::Money#to_s`. If the translation key is missing (no locale file for that language), it falls back to hardcoded defaults (`.` decimal, `,` thousand, `%<symbol>s%<amount>f` format).
+
+You can configure per-sign formatting by adding `positive`, `negative`, and `zero` keys to your locale:
+
+```yaml
+# config/locales/minting-rails.en.yml
+en:
+  number:
+    currency:
+      format:
+        format: "%u%n"           # fallback when no per-sign key matches
+        positive: "%u%n"         # "$1,234.56"
+        negative: "(%u%n)"       # "($1,234.56)"
+        zero: "--"               # "--"
+        separator: "."
+        delimiter: ","
+```
+
+When any of `positive`, `negative`, or `zero` is present, a Hash format is built. Missing keys fall back to `format`:
+
+```ruby
+Mint.money(1234.56, 'USD').to_s  # => "$1,234.56"
+Mint.money(-1234.56, 'USD').to_s # => "($1,234.56)"
+Mint.money(0, 'USD').to_s        # => "--"
 ```
 
-The default currency must be registered and included in `enabled_currencies`.
+If none of those keys are set, `format` is used as a plain string (simple formatting).
+
+> Formatting respects the currency's own `subunit` for decimal precision — `I18n` locale settings for `precision` are ignored since that is a currency property, not a locale one.
 
-## Usage
+## Usage — Two modes
 
-Declare money attributes in your Active Record models with `money_attribute`.
+### Decision table
 
-### Single-column fixed currency
+| | Fixed currency (single column) | Multi-currency (amount + currency) |
+|---|---|---|
+| **Migration** | `t.decimal :price` | `t.decimal :price_amount` + `t.string :price_currency` |
+| **Model** | `money_attribute :price, currency: 'USD'` | `money_attribute :price` |
+| **When to use** | Column always holds the same currency | Each row can hold a different currency |
+| **Column type** | `decimal`, `integer`, or `bigint` | `decimal`, `integer`, or `bigint` for amount; `string` for currency |
+| **Query** | `Product.where(price: 10.mint('USD'))` — full type support | `Offer.where(price: 10.mint('EUR'))` — equality only |
 
-Use this when a column always stores one currency, such as a `price` column that is always USD.
+### Fixed currency (single column)
 
 Migration:
 
@@ -90,7 +153,6 @@ class CreateProducts < ActiveRecord::Migration[7.1]
     create_table :products do |t|
       t.decimal :price
       t.decimal :discount
-
       t.timestamps
     end
   end
@@ -110,24 +172,18 @@ Assignments are normalized to `Mint::Money`:
 
 ```ruby
 product = Product.new(price: 12, discount: '3.50')
-
-product.price
-# => #<Mint::Money ... USD 12.00>
-
-product.discount
-# => #<Mint::Money ... USD 3.50>
+product.price    # => [USD 12.00]
+product.discount # => [USD 3.50]
 ```
 
-Assigning a `Mint::Money` with a different currency raises `ArgumentError`:
+A currency mismatch raises `ArgumentError`:
 
 ```ruby
 Product.new(price: 12.to_money('EUR'))
-# raises ArgumentError because the attribute only accepts USD
+# => ArgumentError: ... has different currency. Only USD allowed.
 ```
 
-### Amount and currency columns
-
-Use this when each row can store a different currency per record.
+### Multi-currency (amount + currency columns)
 
 Migration:
 
@@ -136,8 +192,7 @@ class CreateOffers < ActiveRecord::Migration[7.1]
   def change
     create_table :offers do |t|
       t.decimal :price_amount
-      t.string :price_currency
-
+      t.string  :price_currency
       t.timestamps
     end
   end
@@ -156,166 +211,285 @@ The attribute is composed from `price_amount` and `price_currency`:
 
 ```ruby
 offer = Offer.new(price: 15.to_money('EUR'))
+offer.price          # => [EUR 15.00]
+offer.price_amount   # => 15.0
+offer.price_currency # => "EUR"
+```
 
-offer.price
-# => #<Mint::Money ... EUR 15.00>
-
-offer.price_amount
-# => 15.0
+When assigning a plain number or string, `Mint.default_currency` is used:
 
-offer.price_currency
-# => "EUR"
+```ruby
+offer = Offer.new(price: '12')
+offer.price.currency.code # => "USD"
 ```
 
-### Integer storage
-
-By default, money attributes are stored as `decimal` columns. If you prefer to store amounts as integer subunits (cents, pence, etc.), use a `bigint` or `integer` column instead. Minting::Rails detects the column type automatically and adapts serialization accordingly.
+## Column type detection
 
-Migration:
+Declare the column as `decimal`, `integer`, or `bigint` — the gem adapts:
 
 ```ruby
-class CreateOrders < ActiveRecord::Migration[7.1]
-  def change
-    create_table :orders do |t|
-      t.bigint  :total_amount
-      t.string  :total_currency
-
-      t.timestamps
-    end
-  end
+# Migration
+create_table :orders do |t|
+  t.bigint  :total_amount  # stored as cents (subunits)
+  t.string  :total_currency
 end
-```
-
-Model:
 
-```ruby
+# Model
 class Order < ApplicationRecord
   money_attribute :total
 end
+
+Order.new(total: 19.99.to_money('USD')).total_amount # => 1999
 ```
 
-The amount is stored and retrieved in subunits:
+Same for fixed-currency attributes:
 
 ```ruby
-order = Order.new(total: 19.99.to_money(:USD))
+# Migration
+t.bigint :price
 
-order.total
-# => #<Mint::Money ... USD 19.99>
+# Model (no change needed)
+money_attribute :price, currency: 'USD'
+```
 
-order.total_amount
-# => 1999
+> Use `integer`/`bigint` for large tables (faster, smaller). Use `decimal` when SQL-level readability matters.
 
-order.total_currency
-# => "USD"
-```
+## Custom column names
 
-The same applies to single-column fixed-currency attributes:
+If your columns don't follow the `<name>_amount` / `<name>_currency` convention:
 
 ```ruby
-class Ticket < ApplicationRecord
-  money_attribute :price, currency: 'USD'
+class Invoice < ApplicationRecord
+  money_attribute :total, mapping: {
+    amount:   :total_amount,
+    currency: :currency_code
+  }
 end
 ```
 
-Migration:
+The mapping keys are `:amount` and `:currency`; values are your database column names.
+
+## Querying
+
+Fixed-currency attributes support Rails-native querying through the custom type:
 
 ```ruby
-t.bigint :price
-```
+# Equality
+Product.where(price: 10.mint('USD'))
+
+# IN clause
+Product.where(price: [10.mint('USD'), 20.mint('USD')])
 
-No model change is needed. The column type drives the behavior.
+# BETWEEN
+Product.where(price: 10.mint('USD')..20.mint('USD'))
 
-> **Note:** Integer storage is more efficient for large tables. Use Decimal when you need to stay close to SQL standards for interoperability with other systems
+# Ordering
+Product.order(price: :desc)
 
-### Default Currency
+# Aggregation
+Product.where(price: 10.mint('USD')).sum(:price)
+```
 
-When you assign a plain number or string, Minting::Rails uses `Mint.default_currency`:
+Multi-currency attributes support equality queries via `composed_of`:
 
 ```ruby
-offer = Offer.new(price: '12')
+Offer.where(price: 10.mint('EUR'))
+```
+
+For comparisons on multi-currency attributes, use the backing columns directly:
 
-offer.price.currency_code
-# => "USD"
+```ruby
+Offer.where(price_amount: 10..20, price_currency: 'EUR')
+Offer.where('price_amount > ? AND price_currency = ?', 10, 'EUR')
 ```
 
-### Custom column names
+## Convenience methods
 
-If your amount and currency columns do not follow the `<name>_amount` and `<name>_currency` convention, pass a mapping:
+Minting::Rails adds small helpers on `Numeric` and `String`:
 
 ```ruby
-class Invoice < ApplicationRecord
-  money_attribute :total, mapping: {
-    amount: :total_amount,
-    currency: :currency_code
-  }
-end
+12.to_money('USD')    # => [USD 12.00]
+12.dollars            # => [USD 12.00]
+12.euros              # => [EUR 12.00]
+'12.50'.mint('BRL')   # => [BRL 12.50]
 ```
 
-The mapping keys are `:amount` and `:currency`. The values are your database columns.
+> If you prefer not to extend core classes, use `Mint::Money.money(12, 'USD')` instead.
 
-## Querying
+## vs money-rails
 
-Fixed-currency attributes can be queried with `Mint::Money` values:
+[Money-rails](https://github.com/RubyMoney/money-rails) is the most popular money-in-Rails gem. Here's how they compare side-by-side.
+
+### Model declaration
 
 ```ruby
-Product.where(price: 15.to_money('USD'))
+# minting-rails
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'          # single column, fixed currency
+  money_attribute :total                           # two columns, multi-currency
+end
+
+# money-rails
+class Product < ApplicationRecord
+  monetize :price_cents                            # single cents column, fixed currency
+  monetize :total_cents, with_currency: :total_currency  # two columns, multi-currency
+end
 ```
 
-Composed attributes can also be queried with a money object:
+### Migration
 
 ```ruby
-Offer.where(price: 15.to_money('EUR'))
+# minting-rails — any numeric column type
+create_table :products do |t|
+  t.decimal :price              # stores 12.34
+  t.integer :discount           # stores 1234 (cents)
+  t.bigint  :total_amount       # stores 1999 (cents)
+  t.string  :total_currency
+end
+
+# money-rails — integer cents only
+create_table :products do |t|
+  t.integer :price_cents        # stores 1234 (cents)
+  t.integer :discount_cents     # stores 350 (cents)
+  t.integer :total_cents
+  t.string  :total_currency
+end
 ```
 
-You can still query the backing columns directly when that is clearer:
+### Reading & writing
 
 ```ruby
-Offer.where(price_amount: 15, price_currency: 'EUR')
+# minting-rails — pass any type, always get Mint::Money
+product.price = 12.34          # stores 12.34 in decimal column
+product.price = 1234           # stores 1234 in integer column
+product.price = '$12.34'       # parses string
+product.price                  # => [USD 12.34]
+
+# money-rails — pass any type, always get Money
+product.price_cents = 1234     # stores 1234
+product.price = Money.new(1234, 'USD')
+product.price                  # => #<Money fractional:1234 currency:USD>
 ```
 
-## Convenience methods
+### Querying
 
-Minting::Rails adds a few small helpers:
+```ruby
+# minting-rails (fixed-currency) — full type-aware querying
+Product.where(price: 10.mint('USD'))
+Product.where(price: [5.mint('USD'), 10.mint('USD')])
+Product.where(price: 5.mint('USD')..15.mint('USD'))
+Product.order(price: :desc)
+Product.where(price: 10.mint('USD')).sum(:price)
+
+# money-rails — query through cents column
+Product.where(price_cents: 1000)
+Product.where(price_cents: [500, 1000])
+Product.where(price_cents: 500..1500)
+Product.order(:price_cents)
+```
+
+### Decimal columns
 
 ```ruby
-12.to_money('USD')
-12.mint('BRL')
-12.dollars
-1.dollar
-1.euro
-12.euros
-'12.50'.to_money('USD')
-'12.50'.mint('BRL')
+# minting-rails — works with decimal columns out of the box
+# migration: t.decimal :price
+money_attribute :price, currency: 'USD'
+
+product.price = 12.34
+product.price           # => [USD 12.34]
+product.read_attribute(:price)  # => [USD 12.34]
+
+# money-rails — no decimal column support
+# migration: t.decimal :price  ← not supported
+# Must use integer cents:
+# migration: t.integer :price_cents
+monetize :price_cents
+product.price_cents = 1234
+product.price           # => #<Money fractional:1234 currency:USD>
 ```
 
-These return `Mint::Money` instances.
+### Multi-currency
 
-## Development
+```ruby
+# minting-rails
+money_attribute :price   # expects price_amount + price_currency columns
 
-Clone the repository and install dependencies:
+offer = Offer.new(price: 15.to_money('EUR'))
+offer.price             # => [EUR 15.00]
+offer.price_amount      # => 15.0
+offer.price_currency    # => "EUR"
 
-```sh
-bundle install
+# money-rails
+monetize :price_cents, with_currency: :price_currency
+
+offer = Offer.new(price: Money.new(1500, 'EUR'))
+offer.price             # => #<Money fractional:1500 currency:EUR>
+offer.price_cents       # => 1500
+offer.price_currency    # => "EUR"
 ```
 
-Run the test suite:
+### Column type auto-detection
 
-```sh
-bundle exec rake test
+```ruby
+# minting-rails — same declaration works with any column type
+money_attribute :price, currency: 'USD'
+
+# t.decimal :price   → stores human-readable value (12.34)
+# t.integer :price   → stores cents (1234)
+# t.bigint  :price   → stores cents (1234)
+
+# money-rails — must always match the column name
+monetize :price_cents   # column must be price_cents
+monetize :price         # column must be price — no support for other types
 ```
 
-The repository includes a dummy Rails application under `test/dummy` for exercising the engine in a Rails environment.
+### Performance
 
-## Contributing
+See [BENCHMARKS.md](BENCHMARKS.md) for detailed results across instantiation, persistence, reads, queries, arithmetic, and mass inserts. Minting-rails wins 9 of 11 benchmark cells, with the largest advantages in reads (up to 14× faster), arithmetic (6.6×), and mass inserts (1.6×).
+
+### What money-rails has (and minting-rails doesn't)
+
+Minting-rails is intentionally minimal — it focuses on storing and reading money attributes with Rails primitives. Money-rails is a more mature gem (12+ years, 1.9k stars) with a broader feature set that minting-rails does not currently provide:
+
+| Feature | money-rails | minting-rails |
+|---|---|---|
+| **Mongoid support** | Yes | ActiveRecord only |
+| **Migration helpers** | `add_monetize :products, :price` | None |
+| **View helpers** | `humanized_money`, `money_without_cents`, etc. | None |
+| **I18n / locale files** | Locale-aware formatting via I18n `number.currency.format` — reads your existing translations, no extra setup | Built-in locale-aware formatting with bundled translations |
+| **Test matcher** | `monetize(:price_cents)` RSpec matcher | None |
+| **Currency exchange** | `default_bank`, `add_rate`, EuCentralBank | None |
+| **Custom currencies** | `register_currency` for non-ISO codes | Via `minting` gem config |
+| **Validation integration** | `validates_numericality_of` auto-added | Must add manually |
+| **Rounding mode** | Configurable `rounding_mode` | None |
+| **Per-request currency** | Lambda-based for multi-tenant apps | Static default only |
+| **Allow nil** | `monetize :x, allow_nil: true` | Must handle nil manually |
+| **Parse error control** | `raise_error_on_money_parsing` option | Always raises |
+| **Community** | 1.9k stars, 386 forks, 897 commits | New gem |
+
+If you need any of these features today, money-rails may be a better fit. minting-rails fills a specific niche: a lightweight, performant money-in-Rails solution built on standard Rails primitives.
+
+## Roadmap
 
-Bug reports and pull requests are welcome on GitHub at [gferraz/minting-rails](https://github.com/gferraz/minting-rails).
+1. **Allow nil** — `money_attribute :price, currency: 'USD', allow_nil: true`
+1. **Method-level currency** — lambda-based currency resolution for multi-tenant and instance-level scenarios
+1. **Migration helper**
 
-Before opening a pull request, please run:
+Contributions and suggestions are welcome — open an issue or PR at [gferraz/minting-rails](https://github.com/gferraz/minting-rails).
+
+## Development
 
 ```sh
+bundle install
 bundle exec rake test
 ```
 
+The dummy Rails app under `test/dummy` exercises the engine in a full Rails environment.
+
+## Contributing
+
+Bug reports and pull requests welcome at [gferraz/minting-rails](https://github.com/gferraz/minting-rails).
+
 ## License
 
-The gem is available as open source under the terms of the [MIT License](MIT-LICENSE).
+[MIT](MIT-LICENSE)

data/Rakefile

@@ -4,8 +4,9 @@ require 'bundler/setup'
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-task default: :test
+task default: :test_run
 
+desc 'Run tests'
 Rake::TestTask.new(:test_run) do |t|
   t.libs << 'test'
   t.libs << 'lib'
@@ -21,4 +22,9 @@ task :test_db_migrate do
 end
 
 desc 'Run tests (migrates test DB first)'
-task test: [:test_db_migrate, :test_run]
+task test: %i[test_db_migrate test_run]
+
+desc 'Run minting-rails vs money-rails benchmark'
+task :bench do
+  sh({ 'RAILS_ENV' => 'test' }, 'bundle', 'exec', 'ruby', 'benchmark/comparison.rb')
+end

data/lib/generators/templates/minting.rb

@@ -14,13 +14,6 @@ Mint.configure do |config|
     { currency: 'NGN', subunit: 3, symbol: '₦' }
   ]
 
-  # Enable currencies
-  # Only these currencies amounts can be created
-  # Example:
-  # config.enabled_currencies = :all
-
-  config.enabled_currencies = :all
-
   # To set the default currency
   #
   # It must be a registered currency

data/lib/minting/money_attribute/configuration.rb

@@ -3,12 +3,11 @@
 module Mint
   module MoneyAttribute
     class Configuration
-      attr_accessor :added_currencies, :enabled_currencies, :default_currency,
+      attr_accessor :added_currencies, :default_currency,
                     :rounding_mode, :default_format
 
       def initialize
         @added_currencies = []
-        @enabled_currencies = :all
         @default_currency = 'USD'
         @rounding_mode = nil
         @default_format = nil
@@ -26,19 +25,7 @@ module Mint
     config
   end
 
-  def self.assert_valid_currency!(currency)
-    currency = Mint.currency(currency)
-    return currency if Mint.valid_currency?(currency)
-
-    raise ArgumentError, "Invalid currency '#{currency}'. Please select a registered currency"
-  end
-
   def self.default_currency
-    @default_currency ||= Mint.assert_valid_currency!(config.default_currency)
-  end
-
-  def self.valid_currency?(currency)
-    enabled = config.enabled_currencies
-    currency && (enabled == :all || enabled.include?(currency.code))
+    @default_currency ||= Currency.resolve!(config.default_currency)
   end
 end

data/lib/minting/money_attribute/money_attribute.rb

@@ -8,7 +8,7 @@ module Mint
     class_methods do
       # Money attribute
       def money_attribute(name, currency: Mint.default_currency, mapping: nil)
-        currency = Mint.assert_valid_currency!(currency)
+        currency = Currency.resolve!(currency)
         parser = Parser.new(currency)
         if attribute_names.include? name.to_s
           attribute(name, :mint_money, currency:)
@@ -33,21 +33,29 @@ module Mint
         case col&.type
         when :bigint, :integer
           :fractional
-        when :decimal, :numeric
-          :to_d
         else
           :to_d # :decimal, :numeric, unknown
         end
       end
 
       def find_money_attributes(name, mapping:)
-        composite = if mapping.present?
-                      { amount: mapping[:amount].to_s, currency: mapping[:currency].to_s }
-                    else
-                      { amount: "#{name}_amount", currency: "#{name}_currency" }
-                    end
-        if (composite.values & attribute_names).size != 2
-          raise ArgumentError, "Could not find attributes to map to #{name} money attribute"
+        if mapping.present?
+          missing_keys = (%i[amount currency] - mapping.keys).join(', ')
+          if missing_keys.present?
+            raise ArgumentError,
+                  "Mapping for :#{name} money attribute is missing required keys: #{missing_keys}"
+          end
+          composite = { amount: mapping[:amount].to_s, currency: mapping[:currency].to_s }
+        else
+          composite = { amount: "#{name}_amount", currency: "#{name}_currency" }
+        end
+
+        missing = composite.values - attribute_names
+        if missing.any?
+          raise ArgumentError,
+                "Could not find columns for :#{name} money attribute. " \
+                "Expected: #{composite.values.join(', ')}, " \
+                "Found: #{attribute_names.join(', ')}"
         end
 
         composite

data/lib/minting/money_attribute/money_type.rb

@@ -26,7 +26,7 @@ module Mint
       return nil unless value
 
       if @column_type.is_a?(ActiveRecord::Type::Integer)
-        Mint.money(value * @currency.multiplier, @currency)
+        Mint.money(value * @currency.fractional_multiplier, @currency)
       else
         Mint.money(value, @currency)
       end
@@ -49,6 +49,7 @@ module Mint
 end
 
 ActiveSupport.on_load(:active_record) do
-  ActiveSupport.on_load(:active_record) { include Mint::MoneyAttribute }
+  include Mint::MoneyAttribute
+
   ActiveRecord::Type.register(:mint_money, Mint::MintMoneyType)
 end

data/lib/minting/money_attribute/parser.rb

@@ -9,11 +9,11 @@ module Mint
       end
 
       def parse(amount, currency = @default_currency)
-        currency = Mint.assert_valid_currency!(currency)
+        currency = Currency.resolve!(currency)
         case amount
         when NilClass    then nil
-        when Numeric     then Mint::Money.create(amount, currency)
-        when String      then Mint::Money.create(amount.to_r, currency)
+        when Numeric     then Mint::Money.from(amount, currency)
+        when String      then Mint::Money.from(amount.to_r, currency)
         when Mint::Money
           return amount if amount.currency == currency
 

data/lib/minting/money_attribute/version.rb

@@ -2,6 +2,6 @@
 
 module Mint
   module MoneyAttribute
-    VERSION = '0.7.1'
+    VERSION = '0.8.2'
   end
 end

data/lib/minting/railties.rb

@@ -6,7 +6,31 @@ module Mint
       require 'generators/minting/initializer_generator'
     end
 
-    config.to_prepare do
+    config.after_initialize do
+      setup_locale_backend!
+      register_custom_currencies!
+    end
+
+    def self.setup_locale_backend!
+      Mint.locale_backend = lambda {
+        fmt = I18n.t('number.currency.format', default: {})
+        translator = ->(s) { s&.gsub('%n', '%<amount>f')&.gsub('%u', '%<symbol>s') }
+
+        format = if fmt.key?(:positive) || fmt.key?(:negative) || fmt.key?(:zero)
+                   {
+                     positive: translator.call(fmt[:positive] || fmt[:format]),
+                     negative: translator.call(fmt[:negative] || fmt[:format]),
+                     zero: translator.call(fmt[:zero] || fmt[:format])
+                   }
+                 else
+                   translator.call(fmt[:format])
+                 end
+
+        { decimal: fmt[:separator], thousand: fmt[:delimiter], format: format }
+      }
+    end
+
+    def self.register_custom_currencies!
       Array(Mint.config.added_currencies).each do |currency_data|
         if currency_data.respond_to?(:values_at)
           code = currency_data[:currency] || currency_data['currency']
@@ -15,7 +39,7 @@ module Mint
         else
           code, subunit, symbol = *currency_data
         end
-        Mint.register_currency(code:, subunit:, symbol:)
+        Currency.register(code:, subunit:, symbol:)
       end
     end
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: minting-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Gilson Ferraz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minting
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 1.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 1.8.1
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -69,7 +68,6 @@ metadata:
   changelog_uri: https://github.com/gferraz/minting-rails/releases
   bug_tracker_uri: https://github.com/gferraz/minting-rails/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -84,8 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Money attributes to ActiveRecord
 test_files: []