money-rails 1.15.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bb5642fbc3d57d55b592911898fc1c0beeb8bb42bb21aeea89c89d1d3dc5464
-  data.tar.gz: 8a5100169dea70dd4bbb8770a2273e59c6b99c555173025bfcc18fb4170fd7d0
+  metadata.gz: f19bdc8ef198214c817707194397d89dcd4a4582839c3665fa44a5058eaf33bd
+  data.tar.gz: 04e6523eb3ed34e9ab2c2596c35fea84a415b38c7e0a57fbc9412f4aa71c0877
 SHA512:
-  metadata.gz: eb7961c60fab97af3a1e867ebcc192fcdc6468bb4239a18f60fb269014f898836051319db22b14c6b7c69b47287f6772be68d29db4e3be6a5d0366b895cea6b4
-  data.tar.gz: 193580effbe3f55093e418f8ca6a0eea54bbfd6a46f07d0f8641a57d450564739716f69d18e743b839f785cc5d75513c234445a9378430f9bc943220598c51ae
+  metadata.gz: 6007152fd6ec545f080eb112e35a53e531bbaca69f635e630934c4f0662fa6f071fa62dabc42af779b6d1e68a5e419a4084f3da0006729768418e2a8f6637df8
+  data.tar.gz: 3450cf3305d2c5facc50e919ead251cacf95da4f414f35a924d96dee7c6970a23d197b411f18f4f839ac1e6583b2eee4c5409b7337ba443373c4b7c2808977c3

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## Unreleased
+
+## 2.0.0
+
+- **Breaking change**: Requires `money` gem version ~> 7.0.
+  See the [Money 7.0 upgrading guide](https://github.com/RubyMoney/money/blob/main/UPGRADING-7.0.md)
+- **Breaking change**: Requires `monetize` gem version ~> 7.0
+- **Breaking change**: Drop support for Ruby < 3.1 and Rails < 6.1
+- Allow monetizing methods with kwargs
+- Fix `money_only_cents` for negative money
+- Allow `nil` to be set as the default currency
+- Portuguese translation for errors
+- Skip subunit write for non-attributes in `read_monetized`
+
+## 1.15.0
+
+- Bump money version to ~> 6.16
+- Tweak to invalid currency message
+
 ## 1.14.1
 
 - Fix invalid_currency error definition
@@ -46,7 +65,7 @@
 
 - Bump money version to ~> 6.12.0
 - Bump monetize version to ~> 1.9.0
-- BREAKING CHANGE: Fix to rounding logic in this version from 1.11.0 can cause breaking changes for those relying on the incorrect behavior. Eee [the issue](https://github.com/RubyMoney/money-rails/issues/608) for details.
+- BREAKING CHANGE: Fix to rounding logic in this version from 1.11.0 can cause breaking changes for those relying on the incorrect behavior. See [the issue](https://github.com/RubyMoney/money-rails/issues/608) for details.
 
 ## 1.11.0
 
@@ -84,7 +103,7 @@
 - Fix attribute order possibly affecting the value of monetized attribute
 - Add support for RailsAdmin (use :money type)
 - Raise error when gem was unable to infer monetized attribute name
-- Revert decimal mark and thousands separator addtion, since formatting should depend on country and locale, instead of currency
+- Revert decimal mark and thousands separator addition, since formatting should depend on country and locale, instead of currency
 
 ## 1.6.1
 
@@ -148,8 +167,8 @@
 ## 1.1.0
 
 - Update dependencies to money 6.4.x and monetize 1.0.x.
-- Make subunit setter (e.g. `#price_cents=`) set the `before_type_cast...` va
-  riable. (Fixes validation errors.)
+- Make subunit setter (e.g. `#price_cents=`) set the `before_type_cast...`
+  variable. (Fixes validation errors.)
 - use HashWithIndifferentAccess instead of Hash for
   ActiveRecord::Base::monetized_attributes
 - Let the 'monetize' test helper work when testing against the model's class,
@@ -159,7 +178,7 @@
 - Upgrade specs to RSpec 3
 - Use #respond_to? instead of #try? when monetizing an aliased attribute.
 - Allow aliased attributes to be monetized
-- Fix compatability issue with Rails 4.2
+- Fix compatibility issue with Rails 4.2
 - Allow empty string as thousands separator.
 - Allow using a lambda to set default_currency
 
@@ -292,4 +311,3 @@
 ## 0.0.1
 
 - Hello World
-

data/LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2012 Andreas Loupasakis
-Copyright (c) 2021 Shane Emmons
+Copyright (c) 2025 Shane Emmons
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,15 +1,14 @@
 # RubyMoney - Money-Rails
 
 [![Gem Version](https://badge.fury.io/rb/money-rails.svg)](http://badge.fury.io/rb/money-rails)
-[![Build Status](https://secure.travis-ci.org/RubyMoney/money-rails.svg?branch=master)](http://travis-ci.org/RubyMoney/money-rails)
-[![Code Climate](https://codeclimate.com/github/RubyMoney/money-rails.svg)](https://codeclimate.com/github/RubyMoney/money-rails)
+[![Ruby](https://github.com/RubyMoney/money-rails/actions/workflows/ruby.yml/badge.svg)](https://github.com/RubyMoney/money-rails/actions/workflows/ruby.yml)
 [![License](http://img.shields.io/:license-mit-green.svg?style=flat)](http://opensource.org/licenses/MIT)
 
 ## Introduction
 
 This library provides integration of the [money](http://github.com/Rubymoney/money) gem with Rails.
 
-Use 'monetize' to specify which fields you want to be backed by
+Use `monetize` to specify which fields you want to be backed by
 Money objects and helpers provided by the [money](http://github.com/Rubymoney/money)
 gem.
 
@@ -20,26 +19,26 @@ welcome to contribute to the project.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add it to your application’s Gemfile using:
 
-    gem 'money-rails', '~>1.12'
-
-And then execute:
-
-    $ bundle
+```sh
+bundle add money-rails
+```
 
 Or install it yourself using:
 
-    $ gem install money-rails
+```sh
+$ gem install money-rails
+```
 
 You can also use the money configuration initializer:
 
-```
-$ rails g money_rails:initializer
+```sh
+$ bin/rails generate money_rails:initializer
 ```
 
 There, you can define the default currency value and set other
-configuration parameters for the rails app.
+configuration parameters for the Rails app.
 
 Without Rails in rack-based applications, call during initialization:
 
@@ -58,47 +57,44 @@ For example, we create a Product model which has an integer column called
 
 ```ruby
 class Product < ActiveRecord::Base
-
   monetize :price_cents
-
 end
 ```
 
-Now each Product object will also have an attribute called ```price``` which
+Now each Product object will also have an attribute called `price` which
 is a `Money` object, and can be used for money comparisons, conversions etc.
 
 In this case the name of the money attribute is created automagically by removing the
-```_cents``` suffix from the column name.
+`_cents` suffix from the column name.
 
-If you are using another db column name, or you prefer another name for the
-money attribute, then you can provide an ```as``` argument with a string
-value to the ```monetize``` macro:
+If you are using another database column name, or you prefer another name for the
+money attribute, then you can provide an `as` argument with a string value to the
+`monetize` macro:
 
 ```ruby
 monetize :discount_subunit, as: "discount"
 ```
 
-Now the model objects will have a ```discount``` attribute which is a `Money`
-object, wrapping the value of the ```discount_subunit``` column with a Money
+Now the model objects will have a `discount` attribute which is a `Money`
+object, wrapping the value of the `discount_subunit` column with a Money
 instance.
 
 #### Migration helpers
 
-If you want to add a money field to a product model you can use the ```add_money``` helper. This
-helper can be customized inside a ```MoneyRails.configure``` block. You should customize the
-```add_money``` helper to match the most common use case and utilize it across all migrations.
+If you want to add a money field to a product model you can use the `add_monetize` helper.
+This helper can be customized inside a `MoneyRails.configure` block. You should customize
+the `add_monetize` helper to match the most common use case and utilize it across all
+migrations.
 
 ```ruby
 class MonetizeProduct < ActiveRecord::Migration
   def change
-    add_money :products, :price    # Rails 3
-    add_monetize :products, :price # Rails 4x and above
+    add_monetize :products, :price
 
     # OR
 
     change_table :products do |t|
-      t.money :price    # Rails 3
-      t.monetize :price # Rails 4x and above
+      t.monetize :price
     end
   end
 end
@@ -109,28 +105,23 @@ Another example, where the currency column is not included:
 ```ruby
 class MonetizeItem < ActiveRecord::Migration
   def change
-    add_money :items, :price, currency: { present: false }
+    add_monetize :items, :price, currency: { present: false }
   end
 end
 ```
 
-Notice. Default value of currency field, generated by migration's helper, is USD. To override these defaults, you need change default_currency in money initializer and run migrations.
-
-The ```add_money``` helper is reversible, so you can use it inside ```change```
-migrations.  If you're writing separate ```up``` and ```down``` methods, you
-can use the ```remove_money``` helper.
-
-##### Notice for Rails >= 4.2 and PG adapter
+Notice: Default value of currency field, generated by migration’s helper, is
+USD. To override these defaults, you need change the `default_currency` in an
+initializer and run migrations.
 
-Due to the addition of the `money` column type for PostgreSQL in Rails 4.2, you
-will need to use `add_monetize` instead of `add_money` column. If you're adding
-the column within a `create_table` block, use `t.monetize`, and use
-`remove_monetize` to remove the column.
+The `add_monetize` helper is reversible, so you can use it inside `change`
+migrations.  If you’re writing separate `up` and `down` methods, you can use the
+`remove_monetize` helper.
 
 #### Allow nil values
 
-If you want to allow nil and/or blank values to a specific
-monetized field, you can use the `:allow_nil` parameter:
+If you want to allow `nil` and/or blank values to a specific monetized field,
+you can use the `:allow_nil` parameter:
 
 ```ruby
 # in Product model
@@ -138,7 +129,10 @@ monetize :optional_price_cents, allow_nil: true
 
 # in Migration
 def change
-  add_money :products, :optional_price, amount: { null: true, default: nil }
+  add_monetize :products,
+               :optional_price,
+               amount: { null: true, default: nil },
+               currency: { null: true, default: nil }
 end
 
 # now blank assignments are permitted
@@ -150,7 +144,8 @@ product.optional_price_cents # => nil
 
 #### Allow large numbers
 
-If you foresee that you will be saving large values (range is -2147483648 to +2147483647 for Postgres), increase your integer column limit to bigint:
+If you foresee that you will be saving large values (range is -2147483648 to
++2147483647 for Postgres), increase your integer column limit to `bigint`:
 
 ```ruby
 def change
@@ -165,15 +160,17 @@ You can also pass along
 such as this:
 
 ```ruby
-monetize :price_in_a_range_cents, allow_nil: true,
+monetize :price_in_a_range_cents,
+  allow_nil: true,
   numericality: {
     greater_than_or_equal_to: 0,
     less_than_or_equal_to: 10000
   }
 ```
 
-Or, if you prefer, you can skip validations entirely for the attribute. This is useful if chosen attributes
-are aggregate methods and you wish to avoid executing them on every record save.
+Or, if you prefer, you can skip validations entirely for the attribute. This is
+useful if chosen attributes are aggregate methods and you wish to avoid executing
+them on every record save.
 
 ```ruby
 monetize :price_in_a_range_cents, disable_validation: true
@@ -186,6 +183,17 @@ to the validation you are willing to skip, like this:
 monetize :price_in_a_range_cents, numericality: false
 ```
 
+And you can also use `subunit_numericality` for subunit:
+
+```ruby
+monetize :price_in_a_range_cents,
+         allow_nil: true,
+         subunit_numericality: {
+           greater_than_or_equal_to: 0,
+           less_than_or_equal_to: 100_00
+         }
+```
+
 ### Mongoid 2.x and 3.x
 
 `Money` is available as a field type to supply during a field definition:
@@ -231,18 +239,17 @@ Method return values can be monetized in the same way attributes are monetized.
 
 ```ruby
 class Transaction < ActiveRecord::Base
-
   monetize :price_cents
   monetize :tax_cents
   monetize :total_cents
+
   def total_cents
-    return price_cents + tax_cents
+    price_cents + tax_cents
   end
-
 end
 ```
 
-Now each Transaction object has a method called `total` which returns a `Money` object.
+Now each `Transaction` object has a method called `total` which returns a `Money` object.
 
 ### Currencies
 
@@ -254,14 +261,12 @@ initializer of money-rails:
 ```ruby
 # config/initializers/money.rb
 MoneyRails.configure do |config|
-
   # set the default currency
   config.default_currency = :usd
-
 end
 ```
-For complete list of available currency: [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217)
 
+For a complete list of available currencies: [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217)
 
 If you need to set the default currency on a per-request basis, such as in a
 multi-tenant application, you may use a lambda to lazy-load the default currency
@@ -270,65 +275,73 @@ from a field in a configuration model called `Tenant` in this example:
 ```ruby
 # config/initializers/money.rb
 MoneyRails.configure do |config|
-
   # set the default currency based on client configuration
   config.default_currency = -> { Tenant.current.default_currency }
 end
 ```
 
+Be aware that this **does not work in Rails 7+**, as the lambda is evaluated
+immediately, and therefore requires your model to be already loaded.
+Workarounds include wrapping the initialization in
+`ActiveSupport::Reloader.to_prepare`, or creating a function that rescues
+unloaded constants with an initialization-time default, and running that in your lambda.
+
 In many cases this is not enough, so there are some other options to
 meet your needs.
 
 #### Model Currency
 
 You can override the global default currency within a specific ActiveRecord
-model using the ```register_currency``` macro:
+model using the `register_currency` macro:
 
 ```ruby
 # app/models/product.rb
 class Product < ActiveRecord::Base
-
   # Use EUR as model level currency
   register_currency :eur
 
   monetize :discount_subunit, as: "discount"
   monetize :bonus_cents
-
 end
 ```
 
-Now ```product.discount``` and ```product.bonus``` will return a `Money`
-object using EUR as their currency, instead of the default USD.
+Now `product.discount` and `product.bonus` will return a `Money` object using
+EUR as their currency, instead of the default USD.
 
 (This is not available in  Mongoid).
 
-#### Attribute Currency (:with_currency)
+#### Attribute Currency (`:with_currency`)
 
-By passing the option ```:with_currency``` to the ```monetize``` macro call,
-with a currency code (symbol or string) or a callable object (object that responds to the method ```call```) that returns a currency code, as its value, you can define a currency in a more granular
-way. This will let you attach the given currency only to the specified monetized model
-attribute (allowing you to, for example, monetize different attributes of the same model with different currencies.).
+By passing the option `:with_currency` to the `monetize` macro call,
+with a currency code (symbol or string) or a callable object (object that responds
+to the `call` method) that returns a currency code, as its value, you can define
+a currency in a more granular way. This will let you attach the given currency
+only to the specified monetized model attribute (allowing you to, for example,
+monetize different attributes of the same model with different currencies).
 
-This allows you to override both the model level and the global
-default currencies:
+This allows you to override both the model level and the global default
+currencies:
 
 ```ruby
 # app/models/product.rb
 class Product < ActiveRecord::Base
-
   # Use EUR as the model level currency
   register_currency :eur
 
   monetize :discount_subunit, as: "discount"
   monetize :bonus_cents, with_currency: :gbp
-
 end
 ```
 
-In this case ```product.bonus``` will return a Money object with GBP as its
-currency, whereas ```product.discount.currency.to_s # => EUR ```
+In this case `product.bonus` will return a Money object with GBP as its
+currency, whereas `product.discount.currency.to_s # => EUR`
 
-As mentioned earlier you can use an object that responds to the method ```call``` and accepts the model instance as a parameter. That means you can use a ```Proc``` or ```lambda``` (we would recommend ```lambda``` over ```Proc``` because of their [different control flow characteristics](https://stackoverflow.com/questions/1740046/whats-the-difference-between-a-proc-and-a-lambda-in-ruby)) or even define a separate ```class``` with an instance or class method (maybe even a ```module```) to return the currency code:
+As mentioned earlier you can use an object that responds to the method `call`
+and accepts the model instance as a parameter. That means you can use a `Proc`
+or `lambda` (we would recommend `lambda` over `Proc` because of their
+[different control flow characteristics](https://stackoverflow.com/questions/1740046/whats-the-difference-between-a-proc-and-a-lambda-in-ruby))
+or even define a separate `class` with an instance or class method (maybe even a
+`module`) to return the currency code:
 
 ```ruby
 class DeliveryFee
@@ -343,9 +356,7 @@ module OptionalPrice
   end
 end
 
-# app/models/product.rb
 class Product < ActiveRecord::Base
-
   monetize :price_cents, with_currency: ->(_product) { :gbp }
   monetize :delivery_fee_cents, with_currency: DeliveryFee.new
   monetize :optional_price_cents, with_currency: OptionalPrice
@@ -356,9 +367,9 @@ end
 
 All the previous options do not require any extra model fields to hold
 the currency values. If the currency of a field will vary from
-one model instance to another, then you should add a column called ```currency```
-to your database table and pass the option ```with_model_currency```
-to the ```monetize``` macro.
+one model instance to another, then you should add a column called `currency`
+to your database table and pass the option `with_model_currency`
+to the `monetize` macro.
 
 money-rails will use this knowledge to override the model level and global
 default values. Non-nil instance currency values also override attribute
@@ -366,7 +377,6 @@ currency values, so they have the highest precedence.
 
 ```ruby
 class Transaction < ActiveRecord::Base
-
   # This model has a separate currency column
   attr_accessible :amount_cents, :currency, :tax_cents
 
@@ -375,7 +385,6 @@ class Transaction < ActiveRecord::Base
 
   monetize :amount_cents, with_model_currency: :currency
   monetize :tax_cents, with_model_currency: :currency
-
 end
 
 # Now instantiating with a specific currency overrides
@@ -386,11 +395,10 @@ t.amount == Money.new(2500, "CAD") # true
 
 ### Configuration parameters
 
-You can handle a bunch of configuration params through ```money.rb``` initializer:
+You can handle a bunch of configuration params through `money.rb` initializer:
 
 ```ruby
 MoneyRails.configure do |config|
-
   # To set the default currency
   #
   # config.default_currency = :usd
@@ -471,25 +479,32 @@ MoneyRails.configure do |config|
   #   symbol: nil,
   #   sign_before_symbol: nil
   # }
+
+  # Set whether an error should be raised when parsing money values
+  # This includes assigning to a monetized field with the wrong currency
+  # Default value is false
+  #
+  # config.raise_error_on_money_parsing = true
 end
 ```
 
-* ```default_currency```: Set the default (application wide) currency (USD is the default)
-* ```include_validations```: Permit the inclusion of a ```validates_numericality_of```
+* `default_currency`: Set the default (application wide) currency (USD is the default)
+* `include_validations`: Permit the inclusion of a `validates_numericality_of`
   validation for each monetized field (the default is true)
-* ```register_currency```: Register one custom currency. This option can be
+* `register_currency`: Register one custom currency. This option can be
   used more than once to set more custom currencies. The value should be
-  a hash of all the necessary key/value pairs (important keys: ```:priority```, ```:iso_code```,
-  ```:name```, ```:symbol```, ```:symbol_first```, ```:subunit```, ```:subunit_to_unit```,
-  ```:thousands_separator```, ```:decimal_mark```).
-* ```add_rate```: Provide custom exchange rate for currencies in one direction
-  only! This rate is added to the attached bank object.
-* ```default_bank```: The default bank object holding exchange rates etc.
+  a hash of all the necessary key/value pairs (important keys: `:priority`, `:iso_code`,
+  `:name`, `:symbol`, `:symbol_first`, `:subunit`, `:subunit_to_unit`,
+  `:thousands_separator`, `:decimal_mark`).
+* `add_rate`: Provide custom exchange rate for currencies in one direction only! This
+  rate is added to the attached bank object.
+* `default_bank`: The default bank object holding exchange rates etc.
   (https://github.com/RubyMoney/money#currency-exchange)
-* ```default_format```: Force `Money#format` to use these options for formatting.
-* ```amount_column```: Provide values for the amount column (holding the fractional part of a money object).
-* ```currency_column```: Provide default values or even disable (`present: false`) the currency column.
-* ```rounding_mode```: Set Money.rounding_mode to one of the BigDecimal constants
+* `default_format`: Force `Money#format` to use these options for formatting.
+* `amount_column`: Provide values for the amount column (holding the fractional part of a money object).
+* `currency_column`: Provide default values or even disable (`present: false`) the currency column.
+* `rounding_mode`: Set `Money.rounding_mode` to one of the BigDecimal constants.
+* `raise_error_on_money_parsing`: Set whether errors should be raised when parsing money values
 
 ### Helpers
 
@@ -504,7 +519,7 @@ _For examples below, `@money_object == <Money fractional:650 currency:USD>`_
 | `money_without_cents_and_with_symbol @money_object`   | $6                                        |
 | `money_only_cents @money_object`                      | 50                                        |
 
-#### `no_cents_if_whole`
+#### `no_cents_if_whole` configuration param
 
 `humanized_money` and `humanized_money_with_symbol` will not render the cents part if it contains only zeros, unless `config.no_cents_if_whole` is set to `false` in the `money.rb` configuration (default: true).
 Note that the `config.default_format` will be overwritten by `config.no_cents_if_whole`.
@@ -513,23 +528,26 @@ So `humanized_money` will ignore `config.default_format = { no_cents_if_whole: f
 ### Testing
 
 If you use Rspec there is a test helper implementation.
-Just write `require "money-rails/test_helpers"` in spec_helper.rb.
+Just write `require "money-rails/test_helpers"` in `spec_helper.rb`.
 
-* the `monetize` matcher
+#### The `monetize` matcher
 
 ```ruby
 is_expected.to monetize(:price)
 ```
+
 This will ensure that a column called `price_cents` is being monetized.
 
 ```ruby
 is_expected.to monetize(:price).allow_nil
 ```
+
 By using `allow_nil` you can specify money attributes that accept nil values.
 
 ```ruby
 is_expected.to monetize(:price).as(:discount_value)
 ```
+
 By using `as` chain you can specify the exact name to which a monetized
 column is being mapped.
 
@@ -552,14 +570,15 @@ For examples on using the test_helpers look at
 
 ## Supported ORMs/ODMs
 
-* ActiveRecord (>= 3.x)
+* ActiveRecord (>= 6.1)
 * Mongoid (>= 2.x)
 
 ## Supported Ruby interpreters
 
-* MRI Ruby >= 1.9.2
+* MRI Ruby >= 3.0
 
-You can see a full list of the currently supported interpreters in [travis.yml](http://github.com/RubyMoney/money-rails/blob/master/.travis.yml)
+You can see a full list of the currently supported interpreters in
+[ruby.yml](https://github.com/RubyMoney/money-rails/blob/main/.github/workflows/ruby.yml)
 
 ## Contributing
 
@@ -587,4 +606,4 @@ If you are testing against mongoid, make sure to have the mongod process running
 
 ## License
 
-MIT License. Copyright 2021 RubyMoney.
+[MIT License](https://github.com/RubyMoney/money-rails/blob/main/LICENSE). Copyright 2023 RubyMoney.

data/config/locales/money.pt.yml

@@ -0,0 +1,4 @@
+pt:
+  errors:
+    messages:
+      invalid_currency: tem um formato inválido (deve ser '100', '5%{decimal}24', ou '123%{thousands}456%{decimal}78'). Recebido %{currency}

data/lib/money-rails/active_job/money_serializer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MoneyRails
+  module ActiveJob
+    class MoneySerializer < ::ActiveJob::Serializers::ObjectSerializer
+      def serialize?(argument)
+        argument.is_a?(Money)
+      end
+
+      def serialize(money)
+        super("cents" => money.cents, "currency" => money.currency.to_s)
+      end
+
+      def deserialize(hash)
+        Money.new(hash["cents"], hash["currency"])
+      end
+    end
+  end
+end

data/lib/money-rails/active_record/monetizable.rb

@@ -10,7 +10,7 @@ module MoneyRails
 
       module ClassMethods
         def monetized_attributes
-          monetized_attributes = @monetized_attributes || {}
+          monetized_attributes = @monetized_attributes || {}.with_indifferent_access
 
           if superclass.respond_to?(:monetized_attributes)
             monetized_attributes.merge(superclass.monetized_attributes)
@@ -118,8 +118,8 @@ module MoneyRails
 
 
             # Getter for monetized attribute
-            define_method name do |*args|
-              read_monetized name, subunit_name, options, *args
+            define_method name do |*args, **kwargs|
+              read_monetized name, subunit_name, options, *args, **kwargs
             end
 
             # Setter for monetized attribute
@@ -178,9 +178,19 @@ module MoneyRails
         end
       end
 
-      def read_monetized(name, subunit_name, options = {}, *args)
-        # Get the cents
-        amount = public_send(subunit_name, *args)
+      def read_monetized(name, subunit_name, options = nil, *args, **kwargs)
+        # Ruby 2.x compatibility
+        if options.nil?
+          options = kwargs
+          kwargs = {}
+        end
+
+        if kwargs.any?
+          amount = public_send(subunit_name, *args, **kwargs)
+        else
+          # Ruby 2.x does not allow empty kwargs
+          amount = public_send(subunit_name, *args)
+        end
 
         return if amount.nil? && options[:allow_nil]
         # Get the currency object
@@ -195,7 +205,7 @@ module MoneyRails
             result = memoized
           else
             memoized_amount = memoized.amount.to_money(attr_currency)
-            write_attribute subunit_name, memoized_amount.cents
+            write_attribute subunit_name, memoized_amount.cents if has_attribute? subunit_name
             # Cache the value (it may be nil)
             result = instance_variable_set("@#{name}", memoized_amount)
           end