money-rails 1.13.0 → 1.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17a8dc1cf4b600e6893a143ea21e6a9bef017371
-  data.tar.gz: 21aa33f3cace05847f66f822b88b46059752ed99
+  metadata.gz: a4aaf2a0c37bb46472539f30ec9c60f868ffd3ec
+  data.tar.gz: cdc46c11f65bf4d28afe78dee2de672e66246c2b
 SHA512:
-  metadata.gz: 3d8d1a12dccd30071f5e269b679b55a733fb2eaedf9ed694ed8dcd9c02ff95315293fe97387559e5d891240489f79c9acd57b79861a49c68cf6eeab387f5a032
-  data.tar.gz: 87e4fd7469311f179282531901437773316083fb695dc12003f5767d9d61c9a40cb06d553f7cdc17e4246dbbbb5b0d10973a64417bd602ee8060ddb7c42d9fa3
+  metadata.gz: e79213ea0c3c9aab5563ae75984e6639045ae87fc6c9a63728482a93f8de6988a1f349a06dc36c71dcd5559dea9a718ba3ac579fd790a429991aca9b49bd4007
+  data.tar.gz: 92021999f49f2e24efa5cfba40ed18b0d9714dc2c2bb0c8df171aeec295b4cb31a5f94668de55a4a504fac88707aff31155e239c562ccda420177d552628a886

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.13.1
+
+Add a guard clause for "blank form" input (Mongoid)
+Do not add extra errors in case attribute is not a number
+Use Money.locale_backend instead of Money.use_i18n
+Add money_only_cents helper method
+
 ## 1.13.0
 
 - Bump money version to ~> 6.13.0

data/README.md

@@ -326,7 +326,7 @@ end
 ```
 
 In this case ```product.bonus``` will return a Money object with GBP as its
-currency, whereas ```product.discount.currency_as_string # => EUR ```
+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:
 
@@ -502,6 +502,7 @@ _For examples below, `@money_object == <Money fractional:650 currency:USD>`_
 | `humanized_money_with_symbol @money_object`           | $6.50                                     |
 | `money_without_cents @money_object`                   | 6                                         |
 | `money_without_cents_and_with_symbol @money_object`   | $6                                        |
+| `money_only_cents @money_object`                      | 50                                        |
 
 #### `no_cents_if_whole`
 
@@ -552,7 +553,7 @@ For examples on using the test_helpers look at
 ## Supported ORMs/ODMs
 
 * ActiveRecord (>= 3.x)
-* Mongoid (2.x, 3.x)
+* Mongoid (>= 2.x)
 
 ## Supported Ruby interpreters
 

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

@@ -44,8 +44,7 @@ module MoneyRails
       private
 
       def record_does_not_have_error?
-        return true unless @record.errors.has_key?(@attr)
-        !@record.errors.added?(@attr, :not_a_number)
+        !@record.errors.added?(@attr, :not_a_number, value: @raw_value)
       end
 
       def reset_memoized_variables!
@@ -62,16 +61,20 @@ module MoneyRails
 
       def decimal_mark
         character = currency.decimal_mark || '.'
-        @_decimal_mark ||= Money.use_i18n ? I18n.t('number.currency.format.separator', default: character) : character
+        @_decimal_mark ||= use_backend_locale? ? I18n.t('number.currency.format.separator', default: character) : character
       end
 
       def thousands_separator
         character = currency.thousands_separator || ','
-        @_thousands_separator ||= Money.use_i18n ? I18n.t('number.currency.format.delimiter', default: character) : character
+        @_thousands_separator ||= use_backend_locale? ? I18n.t('number.currency.format.delimiter', default: character) : character
       end
 
       def symbol
-        @_symbol ||= Money.use_i18n ? I18n.t('number.currency.format.unit', default: currency.symbol) : currency.symbol
+        @_symbol ||= use_backend_locale? ? I18n.t('number.currency.format.unit', default: currency.symbol) : currency.symbol
+      end
+
+      def use_backend_locale?
+        Money.locale_backend.present? || Money.use_i18n
       end
 
       def abs_raw_value

data/lib/money-rails/helpers/action_view_extension.rb

@@ -48,5 +48,13 @@ module MoneyRails
     def money_without_cents_and_with_symbol(value)
       money_without_cents(value, symbol: true)
     end
+
+    def money_only_cents(value)
+      return '00' unless value.respond_to?(:to_money)
+
+      value = value.to_money
+
+      format "%0#{value.currency.exponent}d", (value % value.currency.subunit_to_unit).cents
+    end
   end
 end

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

@@ -28,25 +28,12 @@ class Money
     # Takes any possible object and converts it to how it would be
     # stored in the database.
     def mongoize(object)
-      case
-      when object.is_a?(Money) then object.mongoize
-      when object.is_a?(Hash) then
-        if object.respond_to?(:deep_symbolize_keys!)
-          object.deep_symbolize_keys!
-        elsif object.respond_to?(:symbolize_keys!)
-          object.symbolize_keys!
-        end
-        ::Money.new(object[:cents], object[:currency_iso]).mongoize
-      when object.nil? then nil
-      when object.respond_to?(:to_money) then
-        begin
-          object.to_money.mongoize
-        rescue Money::Currency::UnknownCurrency, Monetize::ParseError => e
-          raise MoneyRails::Error, e.message if MoneyRails.raise_error_on_money_parsing
-          nil
-        end
-      else object
-      end
+      return object.mongoize if object.is_a?(Money)
+      return mongoize_hash(object) if object.is_a?(Hash)
+      return nil if object.nil?
+      return mongoize_castable(object) if object.respond_to?(:to_money)
+
+      object
     end
 
     # Converts the object that was supplied to a criteria and converts it
@@ -57,5 +44,27 @@ class Money
       else object
       end
     end
+
+    private
+
+    def mongoize_hash(hash)
+      if hash.respond_to?(:deep_symbolize_keys!)
+        hash.deep_symbolize_keys!
+      elsif hash.respond_to?(:symbolize_keys!)
+        hash.symbolize_keys!
+      end
+
+      # Guard for a blank form
+      return nil if hash[:cents] == '' && hash[:currency_iso] == ''
+
+      ::Money.new(hash[:cents], hash[:currency_iso]).mongoize
+    end
+
+    def mongoize_castable(object)
+      object.to_money.mongoize
+    rescue Money::Currency::UnknownCurrency, Monetize::ParseError => e
+      return nil unless MoneyRails.raise_error_on_money_parsing
+      raise MoneyRails::Error, e.message
+    end
   end
 end

data/lib/money-rails/version.rb

@@ -1,3 +1,3 @@
 module MoneyRails
-  VERSION = '1.13.0'
+  VERSION = '1.13.1'
 end

data/spec/active_record/monetizable_spec.rb

@@ -494,31 +494,31 @@ if defined? ActiveRecord
         product.price = Money.new(2500, :USD)
         expect(product.save).to be_truthy
         expect(product.price.cents).to eq(2500)
-        expect(product.price.currency_as_string).to eq("USD")
+        expect(product.price.currency.to_s).to eq("USD")
       end
 
       it "correctly assigns Fixnum objects to the attribute" do
         product.price = 25
         expect(product.save).to be_truthy
         expect(product.price.cents).to eq(2500)
-        expect(product.price.currency_as_string).to eq("USD")
+        expect(product.price.currency.to_s).to eq("USD")
 
         service.discount = 2
         expect(service.save).to be_truthy
         expect(service.discount.cents).to eq(200)
-        expect(service.discount.currency_as_string).to eq("EUR")
+        expect(service.discount.currency.to_s).to eq("EUR")
       end
 
       it "correctly assigns String objects to the attribute" do
         product.price = "25"
         expect(product.save).to be_truthy
         expect(product.price.cents).to eq(2500)
-        expect(product.price.currency_as_string).to eq("USD")
+        expect(product.price.currency.to_s).to eq("USD")
 
         service.discount = "2"
         expect(service.save).to be_truthy
         expect(service.discount.cents).to eq(200)
-        expect(service.discount.currency_as_string).to eq("EUR")
+        expect(service.discount.currency.to_s).to eq("EUR")
       end
 
       it "correctly assigns objects to a accessor attribute" do
@@ -532,57 +532,57 @@ if defined? ActiveRecord
         product.bonus = 25
         expect(product.save).to be_truthy
         expect(product.bonus.cents).to eq(2500)
-        expect(product.bonus.currency_as_string).to eq("GBP")
+        expect(product.bonus.currency.to_s).to eq("GBP")
 
         service.charge = 2
         expect(service.save).to be_truthy
         expect(service.charge.cents).to eq(200)
-        expect(service.charge.currency_as_string).to eq("USD")
+        expect(service.charge.currency.to_s).to eq("USD")
       end
 
       it "overrides default, model currency with the value of :with_currency in string assignments" do
         product.bonus = "25"
         expect(product.save).to be_truthy
         expect(product.bonus.cents).to eq(2500)
-        expect(product.bonus.currency_as_string).to eq("GBP")
+        expect(product.bonus.currency.to_s).to eq("GBP")
 
         service.charge = "2"
         expect(service.save).to be_truthy
         expect(service.charge.cents).to eq(200)
-        expect(service.charge.currency_as_string).to eq("USD")
+        expect(service.charge.currency.to_s).to eq("USD")
 
         product.lambda_price = "32"
         expect(product.save).to be_truthy
         expect(product.lambda_price.cents).to eq(3200)
-        expect(product.lambda_price.currency_as_string).to eq("CAD")
+        expect(product.lambda_price.currency.to_s).to eq("CAD")
       end
 
       it "overrides default currency with model currency, in fixnum assignments" do
         product.discount_value = 5
         expect(product.save).to be_truthy
         expect(product.discount_value.cents).to eq(500)
-        expect(product.discount_value.currency_as_string).to eq("USD")
+        expect(product.discount_value.currency.to_s).to eq("USD")
       end
 
       it "overrides default currency with model currency, in string assignments" do
         product.discount_value = "5"
         expect(product.save).to be_truthy
         expect(product.discount_value.cents).to eq(500)
-        expect(product.discount_value.currency_as_string).to eq("USD")
+        expect(product.discount_value.currency.to_s).to eq("USD")
       end
 
       it "falls back to default currency, in fixnum assignments" do
         service.discount = 5
         expect(service.save).to be_truthy
         expect(service.discount.cents).to eq(500)
-        expect(service.discount.currency_as_string).to eq("EUR")
+        expect(service.discount.currency.to_s).to eq("EUR")
       end
 
       it "falls back to default currency, in string assignments" do
         service.discount = "5"
         expect(service.save).to be_truthy
         expect(service.discount.cents).to eq(500)
-        expect(service.discount.currency_as_string).to eq("EUR")
+        expect(service.discount.currency.to_s).to eq("EUR")
       end
 
       it "sets field to nil, in nil assignments if allow_nil is set" do
@@ -616,13 +616,13 @@ if defined? ActiveRecord
       context "for column with model currency:" do
         it "has default currency if not specified" do
           product = Product.create(sale_price_amount: 1234)
-          product.sale_price.currency_as_string == 'USD'
+          product.sale_price.currency.to_s == 'USD'
         end
 
         it "is overridden by instance currency column" do
           product = Product.create(sale_price_amount: 1234,
                                    sale_price_currency_code: 'CAD')
-          expect(product.sale_price.currency_as_string).to eq('CAD')
+          expect(product.sale_price.currency.to_s).to eq('CAD')
         end
 
         it 'can change currency of custom column' do
@@ -634,14 +634,14 @@ if defined? ActiveRecord
             sale_price_currency_code: 'USD'
           )
 
-          expect(product.sale_price.currency_as_string).to eq('USD')
+          expect(product.sale_price.currency.to_s).to eq('USD')
 
           product.sale_price = Money.new 456, 'CAD'
           product.save
           product.reload
 
-          expect(product.sale_price.currency_as_string).to eq('CAD')
-          expect(product.discount_value.currency_as_string).to eq('USD')
+          expect(product.sale_price.currency.to_s).to eq('CAD')
+          expect(product.discount_value.currency.to_s).to eq('USD')
         end
       end
 
@@ -705,12 +705,12 @@ if defined? ActiveRecord
           transaction.amount = Money.new(2500, :eur)
           expect(transaction.save).to be_truthy
           expect(transaction.amount.cents).to eq(Money.new(2500, :eur).cents)
-          expect(transaction.amount.currency_as_string).to eq("EUR")
+          expect(transaction.amount.currency.to_s).to eq("EUR")
         end
 
         it "uses default currency if a non Money object is assigned to the attribute" do
           transaction.amount = 234
-          expect(transaction.amount.currency_as_string).to eq("USD")
+          expect(transaction.amount.currency.to_s).to eq("USD")
         end
 
         it "constructs the money object from the mapped method value" do
@@ -767,9 +767,42 @@ if defined? ActiveRecord
             end
           end
 
+          context "when locale_backend is true" do
+            around(:each) do |example|
+              begin
+                Money.locale_backend = :i18n
+                Money.use_i18n = false
+                example.run
+              ensure
+                Money.locale_backend = nil
+                Money.use_i18n = true
+              end
+            end
+            it "validates with the locale's decimal mark" do
+              transaction.amount = "123,45"
+              expect(transaction.valid?).to be_truthy
+            end
+
+            it "does not validate with the currency's decimal mark" do
+              transaction.amount = "123.45"
+              expect(transaction.valid?).to be_falsey
+            end
+
+            it "validates with the locale's currency symbol" do
+              transaction.amount = "€123"
+              expect(transaction.valid?).to be_truthy
+            end
+
+            it "does not validate with the transaction's currency symbol" do
+              transaction.amount = "$123.45"
+              expect(transaction.valid?).to be_falsey
+            end
+          end
+
           context "when use_i18n is false" do
             around(:each) do |example|
               begin
+                Money.locale_backend = nil
                 Money.use_i18n = false
                 example.run
               ensure

data/spec/configuration_spec.rb

@@ -18,8 +18,8 @@ describe "configuration" do
     end
 
     it "sets no_cents_if_whole value for formatted output globally" do
-      # Disable the usage of I18n (to avoid default symbols for :en)
-      Money.use_i18n = false
+      # Enable formatting to depend only on currency (to avoid default symbols for :en)
+      Money.locale_backend = :currency
 
       value = Money.new(12345600, "EUR")
       mark = Money::Currency.find(:eur).decimal_mark
@@ -35,7 +35,7 @@ describe "configuration" do
 
       # Reset global settings
       MoneyRails.no_cents_if_whole = nil
-      Money.use_i18n = true
+      Money.locale_backend = :i18n
     end
 
     it "sets symbol for formatted output globally" do

data/spec/helpers/action_view_extension_spec.rb

@@ -74,6 +74,27 @@ describe 'MoneyRails::ActionViewExtension', type: :helper do
     it { is_expected.not_to include "00" }
   end
 
+  describe '#money_only_cents' do
+    let(:monetizable_object){ Money.new(125_00) }
+    subject { helper.money_only_cents monetizable_object }
+    it { is_expected.to eq "00" }
+
+    context 'with a non-money object' do
+      let(:monetizable_object){ 125 }
+      it { is_expected.to eq "00" }
+    end
+
+    context 'with less than 10 cents' do
+      let(:monetizable_object){ Money.new(8) }
+      it { is_expected.to eq "08" }
+    end
+
+    context 'with a non monetizable object' do
+      let(:monetizable_object){ false }
+      it { is_expected.to eq "00" }
+    end
+  end
+
   context 'respects MoneyRails::Configuration settings' do
     context 'with no_cents_if_whole: false' do
 

data/spec/mongoid/{four_spec.rb → mongoid_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if defined?(Mongoid) && ::Mongoid::VERSION =~ /^4(.*)/
+if defined?(Mongoid) && ::Mongoid::VERSION.split('.').first.to_i > 2
 
   describe Money do
     let!(:priceable) { Priceable.create(price: Money.new(100, 'EUR')) }
@@ -8,6 +8,9 @@ if defined?(Mongoid) && ::Mongoid::VERSION =~ /^4(.*)/
     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_blank_strings_hash) {
+      Priceable.create(price: {cents: '', currency_iso: ''})
+    }
     let(:priceable_from_hash_with_indifferent_access) {
       Priceable.create(price: {cents: 100, currency_iso: "EUR"}.with_indifferent_access)
     }
@@ -69,6 +72,10 @@ if defined?(Mongoid) && ::Mongoid::VERSION =~ /^4(.*)/
         expect(priceable_from_hash.price.currency).to eq(Money::Currency.find('EUR'))
       end
 
+      it "mongoizes a hash of blank strings for cents and currency to nil" do
+        expect(priceable_from_blank_strings_hash.price).to eq(nil)
+      end
+
       it "correctly mongoizes a HashWithIndifferentAccess of cents and currency" do
         expect(priceable_from_hash_with_indifferent_access.price.cents).to eq(100)
         expect(priceable_from_hash_with_indifferent_access.price.currency).to eq(Money::Currency.find('EUR'))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: money-rails
 version: !ruby/object:Gem::Version
-  version: 1.13.0
+  version: 1.13.1
 platform: ruby
 authors:
 - Andreas Loupasakis
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-23 00:00:00.000000000 Z
+date: 2019-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -221,9 +221,7 @@ files:
 - spec/dummy/script/rails
 - spec/helpers/action_view_extension_spec.rb
 - spec/helpers/form_helper_spec.rb
-- spec/mongoid/five_spec.rb
-- spec/mongoid/four_spec.rb
-- spec/mongoid/three_spec.rb
+- spec/mongoid/mongoid_spec.rb
 - spec/mongoid/two_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_cleaner.rb
@@ -315,9 +313,7 @@ test_files:
 - spec/dummy/script/rails
 - spec/helpers/action_view_extension_spec.rb
 - spec/helpers/form_helper_spec.rb
-- spec/mongoid/five_spec.rb
-- spec/mongoid/four_spec.rb
-- spec/mongoid/three_spec.rb
+- spec/mongoid/mongoid_spec.rb
 - spec/mongoid/two_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_cleaner.rb

data/spec/mongoid/five_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-if defined?(Mongoid) && ::Mongoid::VERSION =~ /^5(.*)/
-
-  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
-        expect(priceable.price.cents).to eq(100)
-        expect(priceable.price.currency).to eq(Money::Currency.find('EUR'))
-      end
-
-      it "correctly mongoizes a Numeric object to a hash of cents and currency" do
-        expect(priceable_from_num.price.cents).to eq(100)
-        expect(priceable_from_num.price.currency).to eq(Money.default_currency)
-      end
-
-      it "correctly mongoizes a String object to a hash of cents and currency" do
-        expect(priceable_from_string.price.cents).to eq(100)
-        expect(priceable_from_string.price.currency).to eq(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 MoneyRails::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 MoneyRails::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
-          expect(priceable_from_string_with_hyphen.price).to eq(nil)
-        end
-
-        it "does not correctly mongoize a String with an unknown currency" do
-          expect(priceable_from_string_with_unknown_currency.price).to eq(nil)
-        end
-      end
-
-      it "correctly mongoizes a hash of cents and currency" do
-        expect(priceable_from_hash.price.cents).to eq(100)
-        expect(priceable_from_hash.price.currency).to eq(Money::Currency.find('EUR'))
-      end
-
-      it "correctly mongoizes a HashWithIndifferentAccess of cents and currency" do
-        expect(priceable_from_hash_with_indifferent_access.price.cents).to eq(100)
-        expect(priceable_from_hash_with_indifferent_access.price.currency).to eq(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
-          expect(priceable_with_infinite_precision.price.cents).to eq(BigDecimal.new('100.1'))
-          expect(priceable_with_infinite_precision.price.currency).to eq(Money::Currency.find('EUR'))
-        end
-      end
-    end
-
-    it "correctly serializes a Hash field containing Money objects" do
-      expect(priceable_with_hash_field.price_hash[:key1][:cents]).to eq(100)
-      expect(priceable_with_hash_field.price_hash[:key2][:cents]).to eq(200)
-      expect(priceable_with_hash_field.price_hash[:key1][:currency_iso]).to eq('EUR')
-      expect(priceable_with_hash_field.price_hash[:key2][:currency_iso]).to eq('USD')
-    end
-
-    context "demongoize" do
-      subject { Priceable.first.price }
-      it { is_expected.to be_an_instance_of(Money) }
-      it { is_expected.to eq(Money.new(100, 'EUR')) }
-
-      it "returns 0 cents in default_currency if a nil value was stored" do
-        nil_priceable = Priceable.create(price: nil)
-        expect(nil_priceable.price.cents).to eq(0)
-        expect(nil_priceable.price.currency).to eq(Money.default_currency)
-      end
-      it 'returns nil if an unknown value was stored' do
-        zero_priceable = Priceable.create(price: [])
-        expect(zero_priceable.price).to be_nil
-      end
-    end
-
-    context "evolve" do
-      it "correctly transforms a Money object into a Mongo friendly value" do
-        expect(Priceable.where(price: Money.new(100, 'EUR')).first).to eq(priceable)
-      end
-    end
-  end
-end

data/spec/mongoid/three_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-if defined?(Mongoid) && ::Mongoid::VERSION =~ /^3(.*)/
-
-  describe Money do
-    let!(:priceable) { Priceable.create(price: Money.new(100, 'EUR')) }
-    let(:priceable_from_nil) { Priceable.create(price: nil) }
-    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 "mongoizes correctly nil to nil" do
-        expect(priceable_from_nil.price).to be_nil
-      end
-
-      it "mongoizes correctly a Money object to a hash of cents and currency" do
-        expect(priceable.price.cents).to eq(100)
-        expect(priceable.price.currency).to eq(Money::Currency.find('EUR'))
-      end
-
-      it "mongoizes correctly a Numeric object to a hash of cents and currency" do
-        expect(priceable_from_num.price.cents).to eq(100)
-        expect(priceable_from_num.price.currency).to eq(Money.default_currency)
-      end
-
-      it "mongoizes correctly a String object to a hash of cents and currency" do
-        expect(priceable_from_string.price.cents).to eq(100)
-        expect(priceable_from_string.price.currency).to eq(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 MoneyRails::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 MoneyRails::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
-          expect(priceable_from_string_with_hyphen.price).to eq(nil)
-        end
-
-        it "does not mongoize correctly a String with an unknown currency" do
-          expect(priceable_from_string_with_unknown_currency.price).to eq(nil)
-        end
-      end
-
-      it "mongoizes correctly a hash of cents and currency" do
-        expect(priceable_from_hash.price.cents).to eq(100)
-        expect(priceable_from_hash.price.currency).to eq(Money::Currency.find('EUR'))
-      end
-
-      it "mongoizes correctly a HashWithIndifferentAccess of cents and currency" do
-        expect(priceable_from_hash_with_indifferent_access.price.cents).to eq(100)
-        expect(priceable_from_hash_with_indifferent_access.price.currency).to eq(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 "mongoizes correctly a Money object to a hash of cents and currency" do
-          expect(priceable_with_infinite_precision.price.cents).to eq(BigDecimal.new('100.1'))
-          expect(priceable_with_infinite_precision.price.currency).to eq(Money::Currency.find('EUR'))
-        end
-      end
-    end
-
-    it "serializes correctly a Hash field containing Money objects" do
-      expect(priceable_with_hash_field.price_hash[:key1][:cents]).to eq(100)
-      expect(priceable_with_hash_field.price_hash[:key2][:cents]).to eq(200)
-      expect(priceable_with_hash_field.price_hash[:key1][:currency_iso]).to eq('EUR')
-      expect(priceable_with_hash_field.price_hash[:key2][:currency_iso]).to eq('USD')
-    end
-
-    context "demongoize" do
-      subject { Priceable.first.price }
-      it { is_expected.to be_an_instance_of(Money) }
-      it { is_expected.to eq(Money.new(100, 'EUR')) }
-
-      it "returns nil if a nil value was stored" do
-        nil_priceable = Priceable.create(price: nil)
-        expect(nil_priceable.price).to be_nil
-      end
-
-      it 'returns nil if an unknown value was stored' do
-        zero_priceable = Priceable.create(price: [])
-        expect(zero_priceable.price).to be_nil
-      end
-    end
-
-    context "evolve" do
-      it "transforms correctly a Money object to a Mongo friendly value" do
-        expect(Priceable.where(price: Money.new(100, 'EUR')).first).to eq(priceable)
-      end
-    end
-  end
-end