money_attribute 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8058c06f7d8fd8f12abbe12c979efc9802cd56dcd788bf4f83e100838275d0fa
+  data.tar.gz: '09ade456fbca1582b9f600858177bf20f049d24d35f8539967fce3989d445534'
+SHA512:
+  metadata.gz: 1623898044fb45adb289c256683e7843365b078ecb840d5bc7e178995f7a9580aa6df92baa65a5ead5d45cd00ae8aa496062f9579ece5e9f960b9b64a3814fda
+  data.tar.gz: 48a8712ec075f95c446265c14813067f4c3ff7dd8f76bad2dba5887685235481ac95a57c0c24542ec913a0b3b4153eb9ed7187ca1cfcad74d73ec2cfbbf190ea

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Gilson Ferraz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,381 @@
+# MoneyAttribute
+
+[![CI](https://github.com/gferraz/money-attribute/actions/workflows/ci.yml/badge.svg)](https://github.com/gferraz/money-attribute/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/money_attribute.svg)](https://badge.fury.io/rb/money_attribute)
+
+Store and read Active Record attributes as `Mint::Money` objects with a single `money_attribute` declaration. No manual serialization, no boilerplate.
+
+```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 money_attribute
+bin/rails g money_attribute:initializer
+```
+
+```ruby
+# db/migrate/20260620000000_create_products.rb
+class CreateProducts < ActiveRecord::Migration[8.1]
+  def change
+    create_table :products do |t|
+      t.string :name
+      t.money  :price
+      t.timestamps
+    end
+  end
+end
+```
+
+```ruby
+# app/models/product.rb
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'
+end
+```
+
+That's it. `Product.new(price: 12).price` is a `Mint::Money`.
+
+## Why MoneyAttribute?
+
+- **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 | MoneyAttribute | 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 |  |
+
+For a detailed side-by-side comparison, see [COMPARISON.md](COMPARISON.md).
+
+## Requirements
+
+- Ruby 3.3+
+- Rails 7.1.3.2+
+- [Minting](https://github.com/gferraz/minting) 1.8.0+
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'money_attribute'
+```
+
+```sh
+bundle install
+bin/rails g money_attribute:initializer
+```
+
+The generator creates `config/initializers/money_attribute.rb`.
+
+## Migration helpers
+
+MoneyAttribute adds `add_money` / `remove_money` for existing tables and `t.money` / `t.remove_money` for `create_table` / `change_table` blocks:
+
+```ruby
+class CreateProducts < ActiveRecord::Migration[8.1]
+  def change
+    create_table :products do |t|
+      t.string :name
+      t.money  :price          # price (decimal) + price_currency (string)
+      t.money  :price_amount   # price_amount + price_currency (strips _amount suffix)
+      t.money  :fee, currency: false             # single column, no currency
+      t.money  :tax, type: :bigint               # bigint amount + currency
+      t.timestamps
+    end
+  end
+end
+
+class AddPriceToProducts < ActiveRecord::Migration[8.1]
+  def change
+    add_money :products, :price                 # add price + price_currency
+    add_money :products, :discount, type: :integer
+    remove_money :products, :obsolete_fee       # reversible in change
+  end
+end
+```
+
+### Naming
+
+| Migration call | Columns created | Model declaration |
+|---|---|---|
+| `t.money :price` | `price` decimal + `price_currency` string | `money_attribute :price` |
+| `t.money :price_amount` | `price_amount` decimal + `price_currency` string | `money_attribute :price` |
+| `t.money :price, currency: false` | `price` decimal | `money_attribute :price` |
+| `t.money :price, type: :integer` | `price` integer + `price_currency` string | `money_attribute :price` |
+| `t.money :price, amount: :a, currency: :c` | `a` + `c` | `money_attribute :price, mapping: { amount: :a, currency: :c }` |
+
+## Configuration
+
+```ruby
+# config/initializers/money_attribute.rb
+MoneyAttribute.configure do |config|
+  config.default_currency = 'USD'
+end
+```
+
+See the [Minting gem](https://github.com/gferraz/minting) for full configuration options (custom currencies, formatting, rounding).
+
+### I18n / Locale-aware formatting
+
+MoneyAttribute integrates with Rails I18n to automatically format money amounts according to the current locale.
+
+With `I18n.locale` set to `:en`:
+```ruby
+Mint.money(1234.56, 'USD').to_s  # => "$1,234.56"
+```
+
+Switch to `:'pt-BR'` and the separators change automatically (requires [`rails-i18n`](https://github.com/svenfuchs/rails-i18n) or your own locale file):
+```ruby
+I18n.locale = :'pt-BR'
+Mint.money(1234.56, 'USD').to_s  # => "$1.234,56"
+```
+
+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/money_attribute.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        # => "--"
+```
+
+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 — Two modes
+
+### Decision table
+
+| | Fixed currency (single column) | Multi-currency (amount + currency) |
+|---|---|---|
+| **Migration** | `t.money :price` (or `t.decimal :price`) | `t.money :price` (or `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.to_money('USD'))` — full type support | `Offer.where(price: 10.to_money('EUR'))` — equality only |
+
+### Fixed currency
+
+```ruby
+class Product < ApplicationRecord
+  money_attribute :price, currency: 'USD'
+end
+
+product = Product.new(price: 12)
+product.price # => [USD 12.00]
+
+Product.new(price: 12.to_money('EUR'))
+# => ArgumentError: ... has different currency. Only USD allowed.
+```
+
+### Multi-currency
+
+```ruby
+class Offer < ApplicationRecord
+  money_attribute :price
+end
+
+offer = Offer.new(price: 15.to_money('EUR'))
+offer.price          # => [EUR 15.00]
+offer.price_amount   # => 15.0
+offer.price_currency # => "EUR"
+
+offer = Offer.new(price: '12')
+offer.price.currency.code # => "USD"
+```
+
+## Column type detection
+
+Declare the column as `decimal`, `integer`, or `bigint` — the gem adapts:
+
+```ruby
+# Migration
+create_table :orders do |t|
+  t.bigint  :total_amount  # stored as cents (subunits)
+  t.string  :total_currency
+end
+
+# Model
+class Order < ApplicationRecord
+  money_attribute :total
+end
+
+Order.new(total: 19.99.to_money('USD')).total_amount # => 1999
+```
+
+Same for fixed-currency attributes:
+
+```ruby
+# Migration
+t.bigint :price
+
+# Model (no change needed)
+money_attribute :price, currency: 'USD'
+```
+
+> Use `integer`/`bigint` for large tables (faster, smaller). Use `decimal` when SQL-level readability matters.
+
+## Custom column names
+
+If your columns don't follow the `<name>_amount` / `<name>_currency` convention:
+
+```ruby
+class Invoice < ApplicationRecord
+  money_attribute :total, mapping: {
+    amount:   :total_amount,
+    currency: :currency_code
+  }
+end
+```
+
+The mapping keys are `:amount` and `:currency`; values are your database column names.
+
+## Column resolution
+
+When you declare `money_attribute :name`, the gem resolves which database columns to use by checking the table schema in this order:
+
+| Step | Condition | Columns used | Mode |
+|---|---|---|---|
+| 1 | `mapping:` provided | As specified | Explicit composite |
+| 2 | `name_currency` column exists | `name` + `name_currency` | Composite (multi-currency) |
+| 3 | `name == 'amount'` AND `currency` column exists | `amount` + `currency` | Composite (multi-currency) |
+| 4 | `name_amount` + `name_currency` columns exist | `name_amount` + `name_currency` | Composite (multi-currency) |
+| 5 | `name` column exists (no currency partner) | `name` alone | Single-column (fixed-currency) |
+
+**Example**
+
+```ruby
+create_table :financial_transactions do |t|
+  t.integer :amount
+  t.string  :currency, limit: 3
+  t.integer :discount
+  t.string  :discount_currency, limit: 3
+  t.decimal :price_amount
+  t.string  :price_currency, limit: 3
+  t.bigint  :surplus
+  t.bigint  :tax
+  t.decimal :total_amount
+  t.string  :currency_code, limit: 3
+end
+```
+
+```ruby
+class FinancialTransaction < ApplicationRecord
+  money_attribute :amount                   # step 3: amount(int) + currency
+  money_attribute :discount                 # step 2: discount(int) + discount_currency
+  money_attribute :price                    # step 4: price_amount(dec) + price_currency
+  money_attribute :surplus, currency: 'EUR' # step 5: surplus(int) (single-column, will use EUR)
+  money_attribute :tax                      # step 5: tax(int) (single-column, will use default currency)
+  money_attribute :total, mapping: { amount: :total_amount, currency: :currency_code }  # step 1: explicit
+end
+```
+
+## Querying
+
+Fixed-currency attributes support Rails-native querying through the custom type:
+
+```ruby
+# Equality
+Product.where(price: 10.to_money('USD'))
+
+# IN clause
+Product.where(price: [10.to_money('USD'), 20.to_money('USD')])
+
+# BETWEEN
+Product.where(price: 10.to_money('USD')..20.to_money('USD'))
+
+# Ordering
+Product.order(price: :desc)
+
+# Aggregation
+Product.where(price: 10.to_money('USD')).sum(:price)
+```
+
+Multi-currency attributes support equality queries via `composed_of`:
+
+```ruby
+Offer.where(price: 10.to_money('EUR'))
+```
+
+For comparisons on multi-currency attributes, use the backing columns directly:
+
+```ruby
+Offer.where(price_amount: 10..20, price_currency: 'EUR')
+Offer.where('price_amount > ? AND price_currency = ?', 10, 'EUR')
+```
+
+## Convenience methods
+
+MoneyAttribute adds small helpers on `Numeric` and `String`:
+
+```ruby
+12.to_money('USD')    # => [USD 12.00]
+12.dollars            # => [USD 12.00]
+12.euros              # => [EUR 12.00]
+```
+
+> If you prefer not to extend core classes, use `Mint.money(12, 'USD')` instead.
+
+## Roadmap
+
+1. **Method-level currency** — lambda-based currency resolution for multi-tenant and instance-level scenarios
+2. Prepare to official 1.0 launh
+
+Contributions and suggestions are welcome — open an issue or PR at [gferraz/money-attribute](https://github.com/gferraz/money-attribute).
+
+## 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/money-attribute](https://github.com/gferraz/money-attribute).
+
+## License
+
+[MIT](MIT-LICENSE)

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task default: :test_run
+
+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 money_attribute vs money-rails benchmark'
+task :bench do
+  sh({ 'RAILS_ENV' => 'test' }, 'bundle', 'exec', 'ruby', 'benchmark/comparison.rb')
+end

data/lib/generators/money_attribute/initializer_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  module Generators
+    class InitializerGenerator < ::Rails::Generators::Base
+      source_root File.expand_path('../templates', __dir__)
+
+      desc 'Creates MoneyAttribute initializer.'
+
+      def copy_initializer
+        copy_file 'money_attribute.rb', 'config/initializers/money_attribute.rb'
+      end
+    end
+  end
+end

data/lib/generators/templates/money_attribute.rb

@@ -0,0 +1,22 @@
+# encoding : utf-8
+# frozen_string_literal: true
+
+MoneyAttribute.configure do |config|
+  # Register a custom currency
+  #
+  # Example:
+  #   config.added_currencies = [
+  #     {currency: 'CRC', subunit: 2, symbol: '₡'},
+  #    {currency: 'NGN', subunit: 3, symbol: '₦'}
+  #   ]
+  config.added_currencies = [
+    { currency: 'XCRC', subunit: 2, symbol: '₡' },
+    { currency: 'XNGN', subunit: 3, symbol: '₦' }
+  ]
+
+  # To set the default currency
+  #
+  # It must be a registered currency
+  #
+  config.default_currency = 'BRL'
+end

data/lib/money_attribute/configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  class Configuration
+    attr_accessor :added_currencies, :default_currency
+
+    def initialize
+      @added_currencies = []
+      @default_currency = 'USD'
+    end
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield config if block_given?
+    @default_currency = nil
+    config
+  end
+
+  def self.default_currency
+    @default_currency ||= ::Mint::Currency.resolve!(config.default_currency)
+  end
+end

data/lib/money_attribute/core_ext.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# :nodoc
+class Numeric
+  def to_money(currency = MoneyAttribute.default_currency)
+    ::Mint.money(self, currency)
+  end
+
+  def dollars
+    ::Mint.money(self, 'USD')
+  end
+
+  def euros
+    ::Mint.money(self, 'EUR')
+  end
+
+  alias dollar dollars
+  alias euro euros
+end
+
+# :nodoc
+class String
+  def to_money(currency = MoneyAttribute.default_currency)
+    ::Mint.money(to_r, currency)
+  end
+end

data/lib/money_attribute/macro.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  module Macro
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def money_attribute(name, currency: MoneyAttribute.default_currency, mapping: nil)
+        columns = attribute_names
+        currency = ::Mint::Currency.resolve!(currency)
+        name = name.to_s
+        parser = Parser.new(currency)
+        resolved_mapping = mapping || resolve_mapping(name, columns)
+
+        if columns.include?(name) && resolved_mapping.nil?
+          define_single_column_money_attribute(name, currency, parser)
+        else
+          define_composite_money_attribute(name, resolved_mapping, parser)
+        end
+      end
+
+      private
+
+      # --- Preparation (no side effects) ---
+
+      def resolve_mapping(name, columns)
+        return nil unless columns.include?(name)
+
+        if columns.include?("#{name}_currency")
+          { amount: name, currency: :"#{name}_currency" }
+        elsif columns.include?('currency') && name == 'amount'
+          { amount: name, currency: :currency }
+        end
+      end
+
+      def resolve_composite_for(name, mapping:)
+        composite = { amount: "#{name}_amount", currency: "#{name}_currency" }
+
+        composite[:amount]    = mapping[:amount].to_s   if mapping&.key?(:amount)
+        composite[:currency]  = mapping[:currency].to_s if mapping&.key?(:currency)
+
+        assert_columns_exist!(name, composite)
+        composite
+      end
+
+      def assert_columns_exist!(name, composite)
+        missing = composite.values - attribute_names
+        return if missing.empty?
+
+        raise ArgumentError,
+              "Could not find columns for :#{name} money attribute. " \
+              "Expected: #{composite.values.join(', ')}, " \
+              "Found: #{attribute_names.join(', ')}"
+      end
+
+      def amount_extractor_for(column_name)
+        integer_column?(column_name) ? :fractional : :to_d
+      end
+
+      def money_constructor_for(amount_column) = integer_column?(amount_column) ? :from_fractional : :from
+
+      def integer_column?(column_name)
+        col = columns.find { |c| c.name == column_name }
+        %i[integer bigint].include?(col&.type)
+      end
+
+      # --- Configuration (registers types, normalizers, composed_of) ---
+
+      def define_single_column_money_attribute(name, currency, parser)
+        column_type = integer_column?(name) ? ActiveRecord::Type::Integer.new : ActiveRecord::Type::Decimal.new
+        attribute(name.to_sym, :money, currency:, column_type: column_type)
+        normalizes(name.to_sym, with: parser)
+      end
+
+      def define_composite_money_attribute(name, mapping, parser)
+        aggregated = resolve_composite_for(name, mapping:)
+
+        composed_of(name.to_sym, {
+                      allow_nil: true,
+                      class_name: 'Mint::Money',
+                      constructor: money_constructor_for(aggregated[:amount]),
+                      converter: parser,
+                      mapping: {
+                        aggregated[:amount] => amount_extractor_for(aggregated[:amount]),
+                        aggregated[:currency] => :currency_code
+                      }
+                    })
+      end
+    end
+  end
+end

data/lib/money_attribute/migration_extensions/helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  module MigrationExtensions
+    module Helper
+      private
+
+      def parse_money_args(accessor, options = {})
+        name = accessor.to_s
+
+        amount_col = options.key?(:amount) ? options[:amount].to_s : name
+
+        if options.key?(:currency)
+          currency_col = if options[:currency] == false
+                           nil
+                         else
+                           options[:currency].to_s
+                         end
+        else
+          stripped = name.end_with?('_amount') ? name.sub(/_amount$/, '') : name
+          currency_col = "#{stripped}_currency"
+        end
+
+        col_type = options[:type] || :decimal
+
+        amount_opts = {}
+        amount_opts[:type] = col_type
+
+        if options.key?(:amount) && options[:amount].is_a?(Hash)
+          amount_opts[:null]    = options[:amount][:null]    if options[:amount].key?(:null)
+          amount_opts[:default] = options[:amount][:default] if options[:amount].key?(:default)
+        end
+
+        currency_opts = {}
+        currency_opts[:limit] = options[:currency_limit] if options[:currency_limit]
+
+        if options[:currency].is_a?(Hash)
+          currency_opts[:null]    = options[:currency][:null]    if options[:currency].key?(:null)
+          currency_opts[:default] = options[:currency][:default] if options[:currency].key?(:default)
+        end
+
+        [amount_col, currency_col, amount_opts, currency_opts]
+      end
+    end
+  end
+end

data/lib/money_attribute/migration_extensions/schema_statements.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+module MoneyAttribute
+  module MigrationExtensions
+    module SchemaStatements
+      include Helper
+
+      def add_money(table_name, accessor, options = {})
+        amount_col, currency_col, amount_opts, currency_opts = parse_money_args(accessor, options)
+
+        add_column(table_name, amount_col, amount_opts[:type], **amount_opts.except(:type))
+        add_column(table_name, currency_col, :string, **currency_opts) if currency_col
+      end
+
+      def remove_money(table_name, accessor, options = {})
+        amount_col, currency_col, = parse_money_args(accessor, options)
+
+        remove_column(table_name, amount_col)
+        remove_column(table_name, currency_col) if currency_col
+      end
+    end
+  end
+end

data/lib/money_attribute/migration_extensions/table_definition.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+module MoneyAttribute
+  module MigrationExtensions
+    module TableDefinition
+      include Helper
+
+      def money(accessor, options = {})
+        amount_col, currency_col, amount_opts, currency_opts = parse_money_args(accessor, options)
+
+        column(amount_col, amount_opts[:type], **amount_opts.except(:type))
+        column(currency_col, :string, **currency_opts) if currency_col
+      end
+
+      def remove_money(accessor, options = {})
+        amount_col, currency_col, = parse_money_args(accessor, options)
+
+        remove_column(amount_col)
+        remove_column(currency_col) if currency_col
+      end
+    end
+  end
+end

data/lib/money_attribute/parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  class Parser
+    def initialize(currency = MoneyAttribute.default_currency)
+      @default_currency = currency
+    end
+
+    def parse(amount, currency = @default_currency)
+      currency = ::Mint::Currency.resolve!(currency)
+      case amount
+      when NilClass    then nil
+      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}"
+      else
+        ::Mint.parse(amount, currency)
+      end
+    end
+    alias call parse
+  end
+end

data/lib/money_attribute/railtie.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  class Railtie < ::Rails::Railtie
+    generators do
+      require 'generators/money_attribute/initializer_generator'
+    end
+
+    config.after_initialize do
+      require 'money_attribute/migration_extensions/schema_statements'
+      require 'money_attribute/migration_extensions/table_definition'
+
+      ActiveRecord::Migration.include(MoneyAttribute::MigrationExtensions::SchemaStatements)
+      ActiveRecord::ConnectionAdapters::TableDefinition.include(MoneyAttribute::MigrationExtensions::TableDefinition)
+      ActiveRecord::ConnectionAdapters::Table.include(MoneyAttribute::MigrationExtensions::TableDefinition)
+
+      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(MoneyAttribute.config.added_currencies).each do |currency_data|
+        if currency_data.respond_to?(:values_at)
+          code = currency_data[:currency]
+          subunit = currency_data[:subunit]
+          symbol = currency_data[:symbol]
+        else
+          code, subunit, symbol = *currency_data
+        end
+        ::Mint::Currency.register(code:, subunit:, symbol:)
+      rescue KeyError
+        nil
+      end
+    end
+  end
+end

data/lib/money_attribute/type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  # Type
+  class Type < ActiveRecord::Type::Value
+    def initialize(currency:, column_type: ActiveRecord::Type::Decimal.new)
+      @currency = currency
+      @column_type = column_type
+      super()
+    end
+
+    def assert_valid_value(value)
+      case value
+      when NilClass, Numeric, String then return
+      when ::Mint::Money
+        return if value.currency == @currency
+
+        message = "'#{value.inspect}' has different currency. Only #{@currency.code} allowed."
+      else
+        message = "'#{value.inspect}' is not a valid type for the attribute."
+      end
+      raise ArgumentError, message
+    end
+
+    def deserialize(value)
+      return nil unless value
+
+      if @column_type.is_a?(ActiveRecord::Type::Integer)
+        ::Mint::Money.from_fractional(value, @currency)
+      else
+        ::Mint::Money.from(value, @currency)
+      end
+    end
+
+    def serialize(value)
+      return nil unless value
+
+      if @column_type.is_a?(ActiveRecord::Type::Integer)
+        value.fractional
+      else
+        value.to_d
+      end
+    end
+
+    def self.type
+      :money
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include MoneyAttribute::Macro
+
+  ActiveRecord::Type.register(:money, MoneyAttribute::Type)
+end

data/lib/money_attribute/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MoneyAttribute
+  VERSION = '0.10.0'
+end

data/lib/money_attribute.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'minting'
+require 'money_attribute/core_ext'
+require 'money_attribute/configuration'
+require 'money_attribute/macro'
+require 'money_attribute/parser'
+require 'money_attribute/type'
+require 'money_attribute/railtie'
+require 'money_attribute/version'

data/lib/tasks/money_attribute.rake

@@ -0,0 +1 @@
+# frozen_string_literal: true

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: money_attribute
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Gilson Ferraz
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minting
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.3.2
+description: ''
+email:
+- gilson@cesar.etc.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/money_attribute/initializer_generator.rb
+- lib/generators/templates/money_attribute.rb
+- lib/money_attribute.rb
+- lib/money_attribute/configuration.rb
+- lib/money_attribute/core_ext.rb
+- lib/money_attribute/macro.rb
+- lib/money_attribute/migration_extensions/helper.rb
+- lib/money_attribute/migration_extensions/schema_statements.rb
+- lib/money_attribute/migration_extensions/table_definition.rb
+- lib/money_attribute/parser.rb
+- lib/money_attribute/railtie.rb
+- lib/money_attribute/type.rb
+- lib/money_attribute/version.rb
+- lib/tasks/money_attribute.rake
+homepage: https://github.com/gferraz/money-attribute
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/gferraz/money-attribute
+  source_code_uri: https://github.com/gferraz/money-attribute
+  changelog_uri: https://github.com/gferraz/money-attribute/releases
+  bug_tracker_uri: https://github.com/gferraz/money-attribute/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Money attributes for ActiveRecord
+test_files: []