minting-rails 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 205d9eb9b1d27048756b4f65f2e65781ae71f131d1d838a1834ea733349d3bf4
-  data.tar.gz: ea2dfd05351ae59717737a0770480c1eeb6cf484264c9daea064c87ac80dd4a0
+  metadata.gz: dfed7ac7c21d15b7b983eac0bd391ec8f4eb4f1f89b1cb9ae0308701dd15ba76
+  data.tar.gz: da2eb9d34f56f26a71674a45a792b922adb57d0ff9d6a5098eb96d2e3cf5394a
 SHA512:
-  metadata.gz: a3e434d199296b8d9a22db937b2b40af35eec147a7fdc1d4a1c1a387a3a0300b806381f2e98cb3a3dfc40371b1087f1529a3a81b399b91dff4d4f454034f39c4
-  data.tar.gz: 8552a6d4d6c8f6567a4300c6540b04c00ca220b52b3deb0f0ba00af1fb40d0c974110eb97f04d3d0acb8d037f32852d61cd4a55a6b8d2dc17cbc398c9e58c6d4
+  metadata.gz: bca70a3dc33e70b65635e1dddf9a435ee718b5d6e06e26262fdc53b8d7a9c7e3b7534b88e4ee064cdc6015c2c2772d7941a9482787e96d84397c8a74ec8cd51e
+  data.tar.gz: 73ef1dcbedaa6cbbf832d37b450c08af1ebf41c12d47a76eb1a884a571ba869c1fbebb89be24a0422a855e53e245c53cd64811466b7a73ef0fa7de5878aa0791

data/README.md

@@ -1,86 +1,104 @@
 # 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
-
-- 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.
-
-## Requirements
+```ruby
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'   # fixed currency, single column
+  money_attribute :total                    # multi-currency, two columns
+end
 
-- Ruby 3.3 or newer.
-- Rails 7.1.3.2 or newer.
-- Minting 1.6.0 or newer.
+Product.new(price: 12).price  # => [USD 12.00]
+```
 
-## Installation
+## Quick start
 
-Add the gem to your Rails application's `Gemfile`:
+```sh
+bundle add minting-rails
+bin/rails g mint:initializer
+```
 
 ```ruby
-gem 'minting-rails'
+# app/models/product.rb
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'
+end
 ```
 
-Install it:
+That's it. `Product.new(price: 12).price` is a `Mint::Money`.
 
-```sh
-bundle install
-```
+## Why Minting::Rails?
 
-Generate the initializer:
+- **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.
 
-```sh
-bin/rails g mint:initializer
-```
+### At a glance — vs money-rails
 
-## Configuration
+| 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 |  |
 
-Configure Minting in `config/initializers/minting.rb`:
+## Requirements
 
-```ruby
-Mint.configure do |config|
-  config.enabled_currencies = :all
-  config.default_currency = 'USD'
-  config.default_format = '%<symbol>s%<amount>f'
-end
-```
+- Ruby 3.3+
+- Rails 7.1.3.2+
+- [Minting](https://github.com/gferraz/minting) 1.6.0+
 
-You can limit the currencies that may be used:
+## Installation
 
 ```ruby
-Mint.configure do |config|
-  config.enabled_currencies = %w[USD EUR BRL]
-  config.default_currency = 'USD'
-end
+# Gemfile
+gem 'minting-rails'
+```
+
+```sh
+bundle install
+bin/rails g mint:initializer
 ```
 
-You can also register custom currencies before enabling or using them:
+The generator creates `config/initializers/minting.rb`.
+
+## Configuration
 
 ```ruby
+# config/initializers/minting.rb
 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
-  ]
-
-  config.enabled_currencies = :all
-  config.default_currency = 'CRC'
+  config.default_currency = 'USD'
+  # enabled_currencies removed — all registered currencies are valid
 end
 ```
 
-The default currency must be registered and included in `enabled_currencies`.
+See the [Minting gem](https://github.com/gferraz/minting) for full configuration options (custom currencies, formatting, rounding).
 
-## 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 +108,6 @@ class CreateProducts < ActiveRecord::Migration[7.1]
     create_table :products do |t|
       t.decimal :price
       t.decimal :discount
-
       t.timestamps
     end
   end
@@ -110,24 +127,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 +147,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 +166,286 @@ 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** | Built-in locale-aware formatting | None |
+| **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**
+1. **Internationalization**
 
-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,11 +4,27 @@ require 'bundler/setup'
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-task default: :test
+task default: :test_run
 
-Rake::TestTask.new(:test) do |t|
+desc 'Run tests'
+Rake::TestTask.new(:test_run) do |t|
   t.libs << 'test'
   t.libs << 'lib'
   t.test_files = FileList['test/**/*_test.rb']
   t.ruby_opts << '-rtest_helper.rb'
 end
+
+desc 'Migrate test database'
+task :test_db_migrate do
+  Dir.chdir('test/dummy') do
+    sh({ 'RAILS_ENV' => 'test' }, 'bin/rails', 'db:migrate')
+  end
+end
+
+desc 'Run tests (migrates test DB first)'
+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
-  ActiveRecord::Base.include Mint::MoneyAttribute
+  include Mint::MoneyAttribute
+
   ActiveRecord::Type.register(:mint_money, Mint::MintMoneyType)
 end

data/lib/minting/money_attribute/parser.rb

@@ -9,19 +9,20 @@ 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
-         raise TypeError, "Cannot automatically convert #{amount} to #{currency.code}"
+          return amount if amount.currency == currency
+
+          raise TypeError, "Cannot automatically convert #{amount} to #{currency.code}"
         else
           Mint.parse(amount, currency)
         end
       end
-      alias_method  :call, :parse
+      alias call parse
     end
   end
 end

data/lib/minting/money_attribute/version.rb

@@ -2,6 +2,6 @@
 
 module Mint
   module MoneyAttribute
-    VERSION = '0.7.0'
+    VERSION = '0.8.1'
   end
 end

data/lib/minting/railties.rb

@@ -6,7 +6,7 @@ module Mint
       require 'generators/minting/initializer_generator'
     end
 
-    config.to_prepare do
+    config.after_initialize do
       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 +15,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minting-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Gilson Ferraz
@@ -15,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
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Money attributes to ActiveRecord
 test_files: []