money-rails 0.12.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c8b379f2b72435fdb82e4b5022a947ac6470ddb
-  data.tar.gz: 1a4286158053e24e3eac5da3475b014b6251518e
+  metadata.gz: 1045d1d93a0e6e7f720ee329933a3f1821210f39
+  data.tar.gz: 9059b8e4f70988725a8009ec68fb7ac2548b0335
 SHA512:
-  metadata.gz: f82ac9627b0e16100aa8d09fae383f86bc2398f632ff32e30af6f326636da2d183f863286d62b2ece83322eecc89f311cec63649d2b061191a7a1336b0ff182b
-  data.tar.gz: 79a411fa93a7a6a9ccda5ad9132b32b5973a9b2f991e116b1d05a6d86f0ba3358765f1b70375aa117f795fae0d9d5fc1d95abd2398c9af9e35457810dec02af1
+  metadata.gz: c7b9b0c7492769ffcfac56971877b9c0a58821613c4a9401f0440ecb8358276b729a303678a9f1e3ba644d674fdec6e18cd3ee6dce6a6601998b9a6e2bd7059d
+  data.tar.gz: 02b1bd7f8bd5ee35cc6365f77bc2d1b571f117a261c7e2aa7416ad012964fd956acfc588751076ee83b7eae8072289afbeac254fe3aa52c640c0a058fd5cadb1

data/CHANGELOG.md

@@ -1,7 +1,31 @@
 # Changelog
 
 ## master (next release)
+
+## 0.12.0
+- Add allow_nil chain for monetize test helper
+- Add testing tasks for rails 4.1
+
+## 0.11.0
+- Helpers respect no_cents_if_whole configuration option (GH-157)
+
+## 0.10.0
+- Depend on Money gem version ~> 6.1.1
+- Depend on monetize gem version ~> 0.3.0
+- Set mongoized value of cents to float
+- Fix validation error with whitespace between currency symbol and amount
+- Add raise_error_on_money_parsing configuration option (default is false)
+- Add rounding mode configuration option (default is ROUND_HALF_UP)
+- Rescue ArgumentError with invalid values in mongoid (GH-114)
+- Compatiblity between ActiveModel::Validations and MoneyValidator
 - Raise error when trying to change model based currency
+
+## 0.9.0
+- Depend on Money gem version ~> 6.0.0
+- Add disable_validation option for skipping validations on monetized attributes
+- Remove implicit usage of 'currency' as a default currency column
+- Options to humanized_money_with_symbol are passed to humanized_money
+- Fix mongoization of Money when using infinite_precision
 - Add testing tasks for rails 4.x
 - Fix issue with Numeric values in MoneyValidator (GH-83).
 - Fix test helper
@@ -48,11 +72,6 @@
 - Fixed issue related to symbolized keys in Mongoid (GH-40)
 - Added add_money/remove_money & t.money/t.remove_money methods for ActiveRecord migrations
 
-TODOs (for upcoming releases):
- - decouple validator from active_record
- - enhance validator to cover every possible case
- - update documentation
-
 ## 0.6.0
 - Added basic support for Mongoid >= 3.0.
 - Allow class methods to be monetized (ActiveRecord only - GH-34)

data/README.md

@@ -8,14 +8,14 @@
 
 ## Introduction
 
-This library provides integration of [money](http://github.com/Rubymoney/money) gem with Rails.
+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
 Money objects and helpers provided by the [money](http://github.com/Rubymoney/money)
 gem.
 
 Currently, this library is in active development mode, so if you would
-like to have a new feature feel free to open a new issue
+like to have a new feature, feel free to open a new issue
 [here](https://github.com/RubyMoney/money-rails/issues). You are also
 welcome to contribute to the project.
 
@@ -29,11 +29,11 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+Or install it yourself using:
 
     $ gem install money-rails
 
-You may also install money configuration initializer:
+You can also use the money configuration initializer:
 
 ```
 $ rails g money_rails:initializer
@@ -48,8 +48,8 @@ configuration parameters for the rails app.
 
 #### Usage example
 
-For example, we create a Product model which has an integer price_cents column
-and we want to handle it by using a Money object instead:
+For example, we create a Product model which has an integer column called
+`price_cents` and we want to handle it using a `Money` object instead:
 
 ```ruby
 class Product < ActiveRecord::Base
@@ -60,27 +60,27 @@ end
 ```
 
 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.
+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 of 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 ```as``` argument with a string
+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:
 
 ```ruby
 monetize :discount_subunit, :as => "discount"
 ```
 
-Now the model objects will have a ```discount``` attribute which
-is a Money object, wrapping the value of ```discount_subunit``` column to a
-Money instance.
+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 money field to product model you may use ```add_money``` helper. That
-helper might be customized inside ```MoneyRails.configure``` block. You should customize
+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.
 
 ```ruby
@@ -97,7 +97,7 @@ class MonetizeProduct < ActiveRecord::Migration
 end
 ```
 
-Another example where the currency column is not including:
+Another example, where the currency column is not included:
 
 ```ruby
 class MonetizeItem < ActiveRecord::Migration
@@ -107,13 +107,14 @@ class MonetizeItem < ActiveRecord::Migration
 end
 ```
 
-```add_money``` helper is revertable, so you may use it inside ```change``` migrations.
-If you writing separate ```up``` and ```down``` methods, you may use ```remove_money``` helper.
+The ```add_money``` helper is reversible, so you an use it inside ```change```
+migrations.  If you're writing separate ```up``` and ```down``` methods, you
+can use the ```remove_money``` helper.
 
 #### Allow nil values
 
-If you want to allow the assignment of nil and/or blank values to a specific
-monetized field, you can use the `:allow_nil` parameter like this:
+If you want to allow nil and/or blank values to a specific
+monetized field, you can use the `:allow_nil` parameter:
 
 ```
 # in Product model
@@ -124,7 +125,7 @@ def change
   add_money :products, :optional_price, amount: { null: true, default: nil }
 end
 
-# then blank assignments are permitted
+# now blank assignments are permitted
 product.optional_price = nil
 product.save # returns without errors
 product.optional_price # => nil
@@ -184,7 +185,7 @@ obj
 obj.price
 #=> #<Money cents:100 currency:EUR>
 
-## You can access the money hash too :
+## You can access the money hash too:
 obj[:price]
 # => {:cents=>100, :currency_iso=>"EUR"}
 ```
@@ -193,7 +194,7 @@ The usual options on `field` as `index`, `default`, ..., are available.
 
 ### Method conversion
 
-Method return values can be converted in the same way attributes are converted. For example:
+Method return values can be monetized in the same way attributes are monetized. For example:
 
 ```ruby
 class Transaction < ActiveRecord::Base
@@ -208,13 +209,13 @@ class Transaction < ActiveRecord::Base
 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
 
-Money-rails supports a set of options to handle currencies for your
+money-rails supports a set of options to handle currencies for your
 monetized fields. The default option for every conversion is to use
-the global default currency of Money library, as given in the configuration
+the global default currency of the Money library, as given in the configuration
 initializer of money-rails:
 
 ```ruby
@@ -228,15 +229,12 @@ end
 ```
 
 In many cases this is not enough, so there are some other options to
-satisfy your needs.
+meet your needs.
 
 #### Model Currency
 
-You can define a specific currency for an activerecord model (not for mongoid).
-This currency is used for the creation and conversions of the Money objects
-referring to every monetized attributes of the specific model.
-This means it overrides the global default currency of Money library.
-To attach a currency to a model use the ```register_currency``` macro:
+You can override the global default currency within a specific ActiveRecord
+model using the ```register_currency``` macro:
 
 ```ruby
 # app/models/product.rb
@@ -251,22 +249,26 @@ class Product < ActiveRecord::Base
 end
 ```
 
-Now ```product.discount``` and ```product.bonus``` will return a Money
-object using EUR as 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 availabe in  Mongoid).
 
 #### Attribute Currency (:with_currency)
 
-By using the key ```:with_currency``` with a currency symbol value in
-the ```monetize``` macro call, you can define a currency in a more
-granular way. This way you attach a currency only to the specific monetized
-model attribute. It also allows to override both the model level
-and the global default currency:
+By passing the option ```:with_currency``` to the ```monetize``` macro call,
+with a currency code as its value, you can define a currency in a more granular
+way. This will you attach the given currency only to the specified monetized model
+attribute (allowing you tom for example, monetize different attributes of the same model with different currencyies.).
+
+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 model level currency
+  # Use EUR as the model level currency
   register_currency :eur
 
   monetize :discount_subunit, :as => "discount"
@@ -275,17 +277,18 @@ class Product < ActiveRecord::Base
 end
 ```
 
-In this case the ```product.bonus``` will return a Money object of GBP
+In this case ```product.bonus``` will return a Money object with GBP as its
 currency, whereas ```product.discount.currency_as_string # => EUR ```
 
 #### Instance Currencies
 
-All the previous options do not require any extra model field to hold
-currency values. If you need to provide differrent currency per model
-instance, then you need to add a column with the name ```currency```
-in your db table. You should specify ```with_model_currency``` as an argument
+All the previous options do not require any extra model fields to hold
+the currency values. If the currency of a field with vary from
+once 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
+
+money-rails will use this knowledge to override the model level and global
 default values. Non-nil instance currency values also override attribute
 currency values, so they have the highest precedence.
 

data/Rakefile

@@ -38,6 +38,9 @@ end
 
 namespace :spec do
 
+  desc "Run Tests against mongoid (version 4)"
+  task(:mongoid4) { run_with_gemfile 'gemfiles/mongoid4.gemfile' }
+
   desc "Run Tests against mongoid (version 3)"
   task(:mongoid3) { run_with_gemfile 'gemfiles/mongoid3.gemfile' }
 
@@ -53,8 +56,8 @@ namespace :spec do
   desc "Run Tests against rails 3"
   task(:rails3) { run_with_gemfile 'gemfiles/rails3.gemfile' }
 
-  desc "Run Tests against mongoid 2 & 3"
-  task :mongoid => [:mongoid2, :mongoid3]
+  desc "Run Tests against mongoid 2 & 3 & 4"
+  task :mongoid => [:mongoid2, :mongoid3, :mongoid4]
 
   desc "Run Tests against rails 3 & 4 & 4.1"
   task :rails => [:rails3, :rails4, :rails41]

data/config/locales/money.en.yml

@@ -1,5 +1,5 @@
 en:
   errors:
     messages:
-      invalid_currency: Must be a valid currency (eg. '100', '5%{decimal}24', or '123%{thousands}456%{decimal}78')
+      invalid_currency: Must be a valid currency (eg. '100', '5%{decimal}24', or '123%{thousands}456%{decimal}78'). Got %{currency}
 

data/lib/money-rails/active_model/validator.rb

@@ -2,78 +2,112 @@ module MoneyRails
   module ActiveModel
     class MoneyValidator < ::ActiveModel::Validations::NumericalityValidator
       def validate_each(record, attr, value)
+        reset_memoized_variables!
+        @record = record
+        @attr = attr
 
         # If subunit is not set then no need to validate as it is an
         # indicator that no assignment has been done onto the virtual
         # money field.
-        subunit_attr = record.class.monetized_attributes[attr.to_sym]
-        return unless record.changed_attributes.keys.include? subunit_attr
-
-        raw_value = nil
+        subunit_attr = @record.class.monetized_attributes[@attr.to_sym]
+        return unless @record.changed_attributes.keys.include? subunit_attr
 
         # WARNING: Currently this is only defined in ActiveRecord extension!
-        before_type_cast = "#{attr}_money_before_type_cast"
-        raw_value = record.send(before_type_cast) if record.respond_to?(
-          before_type_cast.to_sym)
+        before_type_cast = :"#{@attr}_money_before_type_cast"
+        @raw_value = @record.try(before_type_cast)
 
         # If raw value is nil and changed subunit is nil, then
         # nil is a assigned value, elsewhere we should treat the
         # subunit value as the one assigned.
-        if raw_value.nil?
-          if record.send(subunit_attr)
-            raw_value = record.send(subunit_attr)
-          end
+        if @raw_value.nil? && @record.send(subunit_attr)
+          @raw_value = @record.send(subunit_attr)
         end
 
-        return if options[:allow_nil] && raw_value.nil?
+        return if options[:allow_nil] && @raw_value.nil?
 
         # Skip normalization for Numeric values
         # which can directly be handled by NumericalityValidator
-        if raw_value.present? && !raw_value.is_a?(Numeric)
+        if raw_value_is_non_numeric
           # remove currency symbol, and negative sign
-          currency = record.send("currency_for_#{attr}")
-          decimal_mark = I18n.t('number.currency.format.separator',
-                                default: currency.decimal_mark)
-          thousands_separator = I18n.t('number.currency.format.delimiter',
-                                       default: currency.thousands_separator)
-          symbol = I18n.t('number.currency.format.unit', default: currency.symbol)
-
-          raw_value = raw_value.to_s.strip.gsub(symbol, "")
-          abs_raw_value = raw_value.strip.gsub(/^-/, "")
-
-          decimal_pieces = abs_raw_value.split(decimal_mark)
-
-          # check for numbers like '12.23.45' or '....'
-          unless [1, 2].include? decimal_pieces.length
-            record.errors.add(attr, I18n.t('errors.messages.invalid_currency',
-                                           { :thousands => thousands_separator,
-                                             :decimal => decimal_mark }))
-            return
-          end
-
-          pieces = decimal_pieces[0].split(thousands_separator)
-
-          # check for valid thousands separation
-          if pieces.length > 1
-            record.errors.add(attr, I18n.t('errors.messages.invalid_currency',
-                                           { :thousands => thousands_separator,
-                                             :decimal => decimal_mark })) if pieces[0].length > 3
-            (1..pieces.length-1).each do |index|
-              record.errors.add(attr, I18n.t('errors.messages.invalid_currency',
-                                             { :thousands => thousands_separator,
-                                               :decimal => decimal_mark })) if pieces[index].length != 3
-            end
-          end
-
-          # Remove thousands separators, normalize decimal mark,
-          # remove whitespaces and _ (E.g. 99 999 999 or 12_300_200.20)
-          raw_value = raw_value.to_s
-            .gsub(thousands_separator, '')
-            .gsub(decimal_mark, '.')
-            .gsub(/[\s_]/, '')
+          @raw_value = @raw_value.to_s.strip.gsub(symbol, "")
+
+          add_error and return if value_has_too_many_decimal_points
+          add_error if invalid_thousands_separation
+
+        end
+
+        normalize_raw_value!
+        super(@record, @attr, @raw_value)
+      end
+
+      private
+
+      def reset_memoized_variables!
+        [:currency, :decimal_mark, :thousands_separator, :symbol,
+          :abs_raw_value, :decimal_pieces, :pieces_array].each do |var_name|
+          ivar_name = :"@_#{var_name}"
+          remove_instance_variable(ivar_name) if instance_variable_get(ivar_name)
+        end
+      end
+
+      def currency
+        @_currency ||= @record.send("currency_for_#{@attr}")
+      end
+
+      def decimal_mark
+        @_decimal_mark ||= I18n.t('number.currency.format.separator', default: currency.decimal_mark)
+      end
+
+      def thousands_separator
+        @_thousands_separator ||= I18n.t('number.currency.format.delimiter', default: currency.thousands_separator)
+      end
+
+      def symbol
+        @_symbol ||= I18n.t('number.currency.format.unit', default: currency.symbol)
+      end
+
+      def raw_value_is_non_numeric
+        @raw_value.present? && !@raw_value.is_a?(Numeric)
+      end
+
+      def abs_raw_value
+        @_abs_raw_value ||= @raw_value.strip.sub(/^-/, "")
+      end
+
+      def add_error
+        @record.errors.add(@attr, I18n.t('errors.messages.invalid_currency',
+                                       { :thousands => thousands_separator,
+                                         :decimal => decimal_mark,
+                                         :currency => abs_raw_value }))
+      end
+
+      def decimal_pieces
+        @_decimal_pieces ||= abs_raw_value.split(decimal_mark)
+      end
+
+      def value_has_too_many_decimal_points
+        ![1, 2].include?(decimal_pieces.length)
+      end
+
+      def pieces_array
+        @_pieces_array ||= decimal_pieces[0].split(thousands_separator)
+      end
+
+      def invalid_thousands_separation
+        return false if pieces_array.length <= 1
+        return true  if pieces_array[0].length > 3
+        pieces_array[1..-1].any? do |thousands_group|
+          thousands_group.length != 3
         end
+      end
 
-        super(record, attr, raw_value)
+      # Remove thousands separators, normalize decimal mark,
+      # remove whitespaces and _ (E.g. 99 999 999 or 12_300_200.20)
+      def normalize_raw_value!
+        @raw_value = @raw_value.to_s
+          .gsub(thousands_separator, '')
+          .gsub(decimal_mark, '.')
+          .gsub(/[\s_]/, '')
       end
     end
   end

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

@@ -80,7 +80,7 @@ module MoneyRails
           #
           # To disable validation entirely, use :disable_validation, E.g:
           #   monetize :price_in_a_range_cents, :disable_validation => true
-          if MoneyRails.include_validations && !options[:disable_validation]
+          if validation_enabled = MoneyRails.include_validations && !options[:disable_validation]
 
             subunit_validation_options =
               unless options.has_key? :subunit_numericality
@@ -109,6 +109,7 @@ module MoneyRails
             }
           end
 
+
           define_method name do |*args|
 
             # Get the cents
@@ -155,7 +156,7 @@ module MoneyRails
             end
 
             # Update cents
-            send("#{subunit_name}=", money.try(:cents))
+            write_attribute(subunit_name, money.try(:cents))
 
             money_currency = money.try(:currency)
 
@@ -175,6 +176,16 @@ module MoneyRails
             instance_variable_set "@#{name}", money
           end
 
+          if validation_enabled
+            # Ensure that the before_type_cast value is updated when settin
+            # the subunit value directly
+            define_method "#{subunit_name}=" do |value|
+              before_type_cast = value.to_f / send("currency_for_#{name}").subunit_to_unit
+              instance_variable_set "@#{name}_money_before_type_cast", before_type_cast
+              write_attribute(subunit_name, value)
+            end
+          end
+
           define_method "currency_for_#{name}" do
             if instance_currency_name.present? &&
               self.respond_to?(instance_currency_name) &&

data/lib/money-rails/mongoid/money.rb

@@ -32,7 +32,7 @@ class Money
       when object.respond_to?(:to_money) then
         begin
           object.to_money.mongoize
-        rescue ArgumentError
+        rescue ArgumentError, Money::Currency::UnknownCurrency
           raise if MoneyRails.raise_error_on_money_parsing
           nil
         end

data/lib/money-rails/version.rb

@@ -1,3 +1,3 @@
 module MoneyRails
-    VERSION = "0.12.0"
+    VERSION = "1.0.0"
 end

data/money-rails.gemspec

@@ -26,8 +26,8 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
-  s.add_dependency "money",         "~> 6.1.1"
-  s.add_dependency "monetize",      "~> 0.3.0"
+  s.add_dependency "money",         "~> 6.4.0"
+  s.add_dependency "monetize",      "~> 1.0.0"
   s.add_dependency "activesupport", ">= 3.0"
   s.add_dependency "railties",      ">= 3.0"
 

data/spec/active_record/monetizable_spec.rb

@@ -42,7 +42,7 @@ if defined? ActiveRecord
         product.price_cents.should == 3210
       end
 
-      it "updates correctly from a Money object using update_attributes" do
+      it "correctly updates from a Money object using update_attributes" do
         product.update_attributes(:price => Money.new(215, "USD")).should eq(true)
         product.price_cents.should == 215
       end
@@ -71,6 +71,13 @@ if defined? ActiveRecord
         product.save.should eq(true)
       end
 
+      it "passes validation after updating fractional attribute which was previously invalid" do
+        product.price_in_a_range = -5
+        product.should_not be_valid
+        product.price_in_a_range_cents = 500
+        product.should be_valid
+      end
+
       context "when MoneyRails.raise_error_on_money_parsing is true" do
         before { MoneyRails.raise_error_on_money_parsing = true }
         after { MoneyRails.raise_error_on_money_parsing = false }
@@ -107,18 +114,21 @@ if defined? ActiveRecord
         product.price = "12.23.24"
         product.save.should eq(false)
         product.errors[:price].first.should match(/Must be a valid/)
+        product.errors[:price].first.should match(/Got 12.23.24/)
       end
 
       it "fails validation with the proper error message if money value is nothing but periods" do
         product.price = "..."
         product.save.should eq(false)
         product.errors[:price].first.should match(/Must be a valid/)
+        product.errors[:price].first.should match(/Got .../)
       end
 
       it "fails validation with the proper error message if money value has invalid thousands part" do
         product.price = "12,23.24"
         product.save.should eq(false)
         product.errors[:price].first.should match(/Must be a valid/)
+        product.errors[:price].first.should match(/Got 12,23.24/)
       end
 
       it "passes validation if money value is a Float and the currency decimal mark is not period" do
@@ -336,14 +346,14 @@ if defined? ActiveRecord
         product.bonus.currency.should == Money::Currency.find(:gbp)
       end
 
-      it "assigns correctly Money objects to the attribute" do
+      it "correctly assigns Money objects to the attribute" do
         product.price = Money.new(2500, :USD)
         product.save.should eq(true)
         product.price.cents.should == 2500
         product.price.currency_as_string.should == "USD"
       end
 
-      it "assigns correctly Fixnum objects to the attribute" do
+      it "correctly assigns Fixnum objects to the attribute" do
         product.price = 25
         product.save.should eq(true)
         product.price.cents.should == 2500
@@ -355,7 +365,7 @@ if defined? ActiveRecord
         service.discount.currency_as_string.should == "EUR"
       end
 
-      it "assigns correctly String objects to the attribute" do
+      it "correctly assigns String objects to the attribute" do
         product.price = "25"
         product.save.should eq(true)
         product.price.cents.should == 2500
@@ -489,7 +499,7 @@ if defined? ActiveRecord
           DummyProduct.create(:price_cents => 2600, :currency => :foo)
         end
 
-        it "serializes correctly the currency to a new instance of model" do
+        it "correctly serializes the currency to a new instance of model" do
           d = DummyProduct.new
           d.price = Money.new(10, "EUR")
           d.save!
@@ -519,12 +529,12 @@ if defined? ActiveRecord
           transaction.amount.should == Money.new(2400, :usd)
         end
 
-        it "instantiates correctly Money objects from the mapped attributes" do
+        it "correctly instantiates Money objects from the mapped attributes" do
           t = Transaction.new(:amount_cents => 2500, :currency => "CAD")
           t.amount.should == Money.new(2500, "CAD")
         end
 
-        it "assigns correctly Money objects to the attribute" do
+        it "correctly assigns Money objects to the attribute" do
           transaction.amount = Money.new(2500, :eur)
           transaction.save.should eq(true)
           transaction.amount.cents.should == Money.new(2500, :eur).cents

data/spec/dummy/db/schema.rb

@@ -9,43 +9,43 @@
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
 # you'll amass, the slower it'll run and the greater likelihood for issues).
 #
-# It's strongly recommended to check this file into your version control system.
+# It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20140110194016) do
+ActiveRecord::Schema.define(version: 20140110194016) do
 
-  create_table "dummy_products", :force => true do |t|
+  create_table "dummy_products", force: true do |t|
     t.string   "currency"
     t.integer  "price_cents"
-    t.datetime "created_at",  :null => false
-    t.datetime "updated_at",  :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
   end
 
-  create_table "products", :force => true do |t|
+  create_table "products", force: true do |t|
     t.integer  "price_cents"
     t.integer  "discount"
-    t.datetime "created_at",                                   :null => false
-    t.datetime "updated_at",                                   :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
     t.integer  "bonus_cents"
     t.integer  "optional_price_cents"
-    t.integer  "sale_price_amount",             :default => 0, :null => false
+    t.integer  "sale_price_amount",             default: 0, null: false
     t.string   "sale_price_currency_code"
     t.integer  "price_in_a_range_cents"
     t.integer  "validates_method_amount_cents"
   end
 
-  create_table "services", :force => true do |t|
+  create_table "services", force: true do |t|
     t.integer  "charge_cents"
     t.integer  "discount_cents"
-    t.datetime "created_at",     :null => false
-    t.datetime "updated_at",     :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
   end
 
-  create_table "transactions", :force => true do |t|
+  create_table "transactions", force: true do |t|
     t.integer  "amount_cents"
     t.integer  "tax_cents"
     t.string   "currency"
-    t.datetime "created_at",   :null => false
-    t.datetime "updated_at",   :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
   end
 
 end

data/spec/mongoid/four_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+if defined?(Mongoid) && ::Mongoid::VERSION =~ /^4(.*)/
+
+  describe Money do
+    let!(:priceable) { Priceable.create(:price => Money.new(100, 'EUR')) }
+    let!(:priceable_from_num) { Priceable.create(:price => 1) }
+    let!(:priceable_from_string) { Priceable.create(:price => '1 EUR' )}
+    let!(:priceable_from_hash) { Priceable.create(:price => {:cents=>100, :currency_iso=>"EUR"} )}
+    let!(:priceable_from_hash_with_indifferent_access) {
+      Priceable.create(:price => {:cents=>100, :currency_iso=>"EUR"}.with_indifferent_access)
+    }
+    let(:priceable_from_string_with_hyphen) { Priceable.create(:price => '1-2 EUR' )}
+    let(:priceable_from_string_with_unknown_currency) { Priceable.create(:price => '1 TLDR') }
+    let(:priceable_with_infinite_precision) { Priceable.create(:price => Money.new(BigDecimal.new('100.1'), 'EUR')) }
+    let(:priceable_with_hash_field) {
+      Priceable.create(:price_hash => {
+        :key1 => Money.new(100, "EUR"),
+        :key2 => Money.new(200, "USD")
+      })
+    }
+
+    context "mongoize" do
+      it "correctly mongoizes a Money object to a hash of cents and currency" do
+        priceable.price.cents.should == 100
+        priceable.price.currency.should == Money::Currency.find('EUR')
+      end
+
+      it "correctly mongoizes a Numeric object to a hash of cents and currency" do
+        priceable_from_num.price.cents.should == 100
+        priceable_from_num.price.currency.should == Money.default_currency
+      end
+
+      it "correctly mongoizes a String object to a hash of cents and currency" do
+        priceable_from_string.price.cents.should == 100
+        priceable_from_string.price.currency.should == Money::Currency.find('EUR')
+      end
+
+      context "when MoneyRails.raise_error_on_money_parsing is true" do
+        before { MoneyRails.raise_error_on_money_parsing = true }
+        after { MoneyRails.raise_error_on_money_parsing = false }
+
+        it "raises exception if the mongoized value is a String with a hyphen" do
+          expect { priceable_from_string_with_hyphen }.to raise_error
+        end
+
+        it "raises exception if the mongoized value is a String with an unknown currency" do
+          expect { priceable_from_string_with_unknown_currency }.to raise_error
+        end
+      end
+
+      context "when MoneyRails.raise_error_on_money_parsing is false" do
+        it "does not correctly mongoize a String with a hyphen in its middle" do
+          priceable_from_string_with_hyphen.price.should == nil
+        end
+
+        it "does not correctly mongoize a String with an unknown currency" do
+          priceable_from_string_with_unknown_currency.price.should == nil
+        end
+      end
+
+      it "correctly mongoizes a hash of cents and currency" do
+        priceable_from_hash.price.cents.should == 100
+        priceable_from_hash.price.currency.should == Money::Currency.find('EUR')
+      end
+
+      it "correctly mongoizes a HashWithIndifferentAccess of cents and currency" do
+        priceable_from_hash_with_indifferent_access.price.cents.should == 100
+        priceable_from_hash_with_indifferent_access.price.currency.should == Money::Currency.find('EUR')
+      end
+
+      context "infinite_precision = true" do
+        before do
+          Money.infinite_precision = true
+        end
+
+        after do
+          Money.infinite_precision = false
+        end
+
+        it "correctly mongoizes a Money object to a hash of cents and currency" do
+          priceable_with_infinite_precision.price.cents.should == BigDecimal.new('100.1')
+          priceable_with_infinite_precision.price.currency.should == Money::Currency.find('EUR')
+        end
+      end
+    end
+
+    it "correctly serializes a Hash field containing Money objects" do
+      priceable_with_hash_field.price_hash[:key1][:cents].should == 100
+      priceable_with_hash_field.price_hash[:key2][:cents].should == 200
+      priceable_with_hash_field.price_hash[:key1][:currency_iso].should == 'EUR'
+      priceable_with_hash_field.price_hash[:key2][:currency_iso].should == 'USD'
+    end
+
+    context "demongoize" do
+      subject { Priceable.first.price }
+      it { should be_an_instance_of(Money) }
+      it { should == Money.new(100, 'EUR') }
+      it "returns nil if a nil value was stored" do
+        nil_priceable = Priceable.create(:price => nil)
+        nil_priceable.price.should be_nil
+      end
+      it 'returns nil if an unknown value was stored' do
+        zero_priceable = Priceable.create(:price => [])
+        zero_priceable.price.should be_nil
+      end
+    end
+
+    context "evolve" do
+      it "correctly transforms a Money object into a Mongo friendly value" do
+        Priceable.where(:price => Money.new(100, 'EUR')).first.should == priceable
+      end
+    end
+  end
+end

data/spec/mongoid/three_spec.rb

@@ -11,6 +11,7 @@ if defined?(Mongoid) && ::Mongoid::VERSION =~ /^3(.*)/
       Priceable.create(:price => {:cents=>100, :currency_iso=>"EUR"}.with_indifferent_access)
     }
     let(:priceable_from_string_with_hyphen) { Priceable.create(:price => '1-2 EUR' )}
+    let(:priceable_from_string_with_unknown_currency) { Priceable.create(:price => '1 TLDR') }
     let(:priceable_with_infinite_precision) { Priceable.create(:price => Money.new(BigDecimal.new('100.1'), 'EUR')) }
     let(:priceable_with_hash_field) {
       Priceable.create(:price_hash => {
@@ -42,12 +43,20 @@ if defined?(Mongoid) && ::Mongoid::VERSION =~ /^3(.*)/
         it "raises exception if the mongoized value is a String with a hyphen" do
           expect { priceable_from_string_with_hyphen }.to raise_error
         end
+
+        it "raises exception if the mongoized value is a String with an unknown currency" do
+          expect { priceable_from_string_with_unknown_currency }.to raise_error
+        end
       end
 
       context "when MoneyRails.raise_error_on_money_parsing is false" do
         it "does not mongoizes correctly a String with hyphen in its middle" do
           priceable_from_string_with_hyphen.price.should == nil
         end
+
+        it "does not mongoize correctly a String with an unknown currency" do
+          priceable_from_string_with_unknown_currency.price.should == nil
+        end
       end
 
       it "mongoizes correctly a hash of cents and currency" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: money-rails
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andreas Loupasakis
@@ -10,106 +10,106 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2014-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: money
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 6.1.1
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.1
+        version: 6.4.0
   type: :runtime
-- !ruby/object:Gem::Dependency
   prerelease: false
-  name: monetize
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 6.4.0
+- !ruby/object:Gem::Dependency
+  name: monetize
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 1.0.0
   type: :runtime
-- !ruby/object:Gem::Dependency
   prerelease: false
-  name: activesupport
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
-- !ruby/object:Gem::Dependency
   prerelease: false
-  name: railties
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
-- !ruby/object:Gem::Dependency
   prerelease: false
-  name: rails
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
-- !ruby/object:Gem::Dependency
   prerelease: false
-  name: rspec-rails
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.10'
   type: :development
-- !ruby/object:Gem::Dependency
   prerelease: false
-  name: database_cleaner
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.0
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
 description: This library provides integration of RubyMoney - Money gem with Rails
 email:
 - alup.rubymoney@gmail.com
@@ -194,6 +194,7 @@ files:
 - spec/dummy/script/rails
 - spec/helpers/action_view_extension_spec.rb
 - spec/helpers/form_helper_spec.rb
+- spec/mongoid/four_spec.rb
 - spec/mongoid/three_spec.rb
 - spec/mongoid/two_spec.rb
 - spec/spec_helper.rb
@@ -209,12 +210,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -277,9 +278,9 @@ test_files:
 - spec/dummy/script/rails
 - spec/helpers/action_view_extension_spec.rb
 - spec/helpers/form_helper_spec.rb
+- spec/mongoid/four_spec.rb
 - spec/mongoid/three_spec.rb
 - spec/mongoid/two_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_cleaner.rb
 - spec/test_helpers_spec.rb
-has_rdoc: