shopify-money 0.16.0 → 1.0.2.pre

data/lib/money/rails/job_argument_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Money
+  module Rails
+    class JobArgumentSerializer < ::ActiveJob::Serializers::ObjectSerializer
+      def serialize(money)
+        super("value" => money.value, "currency" => money.currency.iso_code)
+      end
+
+      def deserialize(hash)
+        Money.new(hash["value"], hash["currency"])
+      end
+
+      private
+
+      def klass
+        Money
+      end
+    end
+  end
+end
+

data/lib/money/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Money
+  class Railtie < Rails::Railtie
+    initializer "shopify-money.setup_active_job_serializer" do
+      ActiveSupport.on_load :active_job do
+        require_relative "rails/job_argument_serializer"
+        ActiveJob::Serializers.add_serializers ::Money::Rails::JobArgumentSerializer
+      end
+    end
+
+    initializer "shopify-money.setup_locale_aware_parser" do
+      ActiveSupport.on_load(:action_view) do
+        Money::Parser::LocaleAware.decimal_separator_resolver =
+          -> { ::I18n.translate("number.currency.format.separator") }
+      end
+    end
+  end
+end

data/lib/money/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 class Money
-  VERSION = "0.16.0"
+  VERSION = "1.0.2.pre"
 end

data/lib/money.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
-require_relative 'money/money_parser'
+require_relative 'money/version'
+require_relative 'money/parser/fuzzy'
 require_relative 'money/helpers'
 require_relative 'money/currency'
 require_relative 'money/null_currency'
 require_relative 'money/allocator'
+require_relative 'money/config'
 require_relative 'money/money'
 require_relative 'money/errors'
 require_relative 'money/deprecations'
-require_relative 'money/accounting_money_parser'
+require_relative 'money/parser/accounting'
+require_relative 'money/parser/locale_aware'
+require_relative 'money/parser/simple'
 require_relative 'money/core_extensions'
 require_relative 'money_column' if defined?(ActiveRecord)
+require_relative 'money/railtie' if defined?(Rails::Railtie)
 
 require_relative 'rubocop/cop/money' if defined?(RuboCop)

data/lib/money_column/active_record_hooks.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 module MoneyColumn
+  class CurrencyReadOnlyError < StandardError; end
+
   module ActiveRecordHooks
     def self.included(base)
       base.extend(ClassMethods)
@@ -49,16 +51,19 @@ module MoneyColumn
         return self[column] = nil
       end
 
-      currency_raw_source = options[:currency] || (send(options[:currency_column]) rescue nil)
-
-      if !money.is_a?(Money)
-        return self[column] = Money.new(money, currency_raw_source).value
+      unless money.is_a?(Money)
+        return self[column] = Money::Helpers.value_to_decimal(money)
       end
 
       if options[:currency_read_only]
-        currency_source = Money::Helpers.value_to_currency(currency_raw_source)
-        if currency_raw_source && !money.currency.compatible?(currency_source)
-          Money.deprecate("[money_column] currency mismatch between #{currency_source} and #{money.currency} in column #{column}.")
+        currency = options[:currency] || try(options[:currency_column])
+        if currency && !money.currency.compatible?(Money::Helpers.value_to_currency(currency))
+          msg = "[money_column] currency mismatch between #{currency} and #{money.currency} in column #{column}."
+          if Money.config.legacy_deprecations
+            Money.deprecate(msg)
+          else
+            raise MoneyColumn::CurrencyReadOnlyError, msg
+          end
         end
       else
         self[options[:currency_column]] = money.currency.to_s unless money.no_currency?

data/spec/config_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe "Money::Config" do
+  describe 'legacy_deprecations' do
+    it "respects the default currency" do
+      configure(default_currency: 'USD', legacy_deprecations: true) do
+        expect(Money.default_currency).to eq("USD")
+      end
+    end
+
+    it 'defaults to not opt-in to v1' do
+      expect(Money::Config.new.legacy_deprecations).to eq(false)
+    end
+
+    it 'legacy_deprecations returns true when opting in to v1' do
+      configure(legacy_deprecations: true) do
+        expect(Money.config.legacy_deprecations).to eq(true)
+      end
+    end
+
+    it 'sets the deprecations to raise' do
+      configure(legacy_deprecations: true) do
+        expect { Money.deprecate("test") }.to raise_error(ActiveSupport::DeprecationException)
+      end
+    end
+
+    it 'legacy_deprecations defaults to NULL_CURRENCY' do
+      configure(legacy_default_currency: true) do
+        expect(Money.config.default_currency).to eq(Money::NULL_CURRENCY)
+      end
+    end
+  end
+
+  describe 'default_currency' do
+    it 'defaults to nil' do
+      configure do
+        expect(Money.config.default_currency).to eq(nil)
+      end
+    end
+
+    it 'can be set to a new currency' do
+      configure(default_currency: 'USD') do
+        expect(Money.config.default_currency).to eq('USD')
+      end
+    end
+  end
+end

data/spec/helpers_spec.rb

@@ -46,8 +46,10 @@ RSpec.describe Money::Helpers do
     end
 
     it 'invalid string returns zero' do
-      expect(Money).to receive(:deprecate).once
-      expect(subject.value_to_decimal('invalid')).to eq(0)
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).once
+        expect(subject.value_to_decimal('invalid')).to eq(0)
+      end
     end
 
     it 'raises on invalid object' do
@@ -70,7 +72,9 @@ RSpec.describe Money::Helpers do
     end
 
     it 'returns the default currency when value is empty' do
-      expect(subject.value_to_currency('')).to eq(Money.default_currency)
+      configure(legacy_deprecations: true, default_currency: 'USD') do
+        expect(subject.value_to_currency('')).to eq(Money::Currency.new('USD'))
+      end
     end
 
     it 'returns the default currency when value is xxx' do
@@ -86,8 +90,10 @@ RSpec.describe Money::Helpers do
     end
 
     it 'returns the null currency when invalid iso is passed' do
-      expect(Money).to receive(:deprecate).once
-      expect(subject.value_to_currency('invalid')).to eq(Money::NULL_CURRENCY)
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).once
+        expect(subject.value_to_currency('invalid')).to eq(Money::NULL_CURRENCY)
+      end
     end
 
     it 'raises on invalid object' do

data/spec/money_column_spec.rb

@@ -30,13 +30,18 @@ end
 
 class MoneyWithDelegatedCurrency < ActiveRecord::Base
   self.table_name = 'money_records'
-  attr_accessor :delegated_record
   delegate :currency, to: :delegated_record
   money_column :price, currency_column: 'currency', currency_read_only: true
   money_column :prix, currency_column: 'currency2', currency_read_only: true
   def currency2
     delegated_record.currency
   end
+
+  private
+
+  def delegated_record
+    MoneyRecord.new(currency: 'USD')
+  end
 end
 
 class MoneyWithCustomAccessors < ActiveRecord::Base
@@ -97,11 +102,13 @@ RSpec.describe 'MoneyColumn' do
   end
 
   it 'returns money with null currency when the currency in the DB is invalid' do
-    expect(Money).to receive(:deprecate).once
-    record.update_columns(currency: 'invalid')
-    record.reload
-    expect(record.price.currency).to be_a(Money::NullCurrency)
-    expect(record.price.value).to eq(1.23)
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      record.update_columns(currency: 'invalid')
+      record.reload
+      expect(record.price.currency).to be_a(Money::NullCurrency)
+      expect(record.price.value).to eq(1.23)
+    end
   end
 
   it 'handles legacy support for saving floats' do
@@ -114,12 +121,12 @@ RSpec.describe 'MoneyColumn' do
     expect(record.prix.currency.to_s).to eq('CAD')
   end
 
-  it 'handles legacy support for saving floats with correct currency rounding' do
+  it 'handles legacy support for saving floats as provided' do
     record.update(price: 3.2112, prix: 3.2156)
-    expect(record.attributes['price']).to eq(3.21)
+    expect(record.attributes['price']).to eq(3.2112)
     expect(record.price.value).to eq(3.21)
     expect(record.price.currency.to_s).to eq(currency)
-    expect(record.attributes['prix']).to eq(3.22)
+    expect(record.attributes['prix']).to eq(3.2156)
     expect(record.prix.value).to eq(3.22)
     expect(record.prix.currency.to_s).to eq('CAD')
   end
@@ -165,8 +172,8 @@ RSpec.describe 'MoneyColumn' do
   describe 'garbage amount' do
     let(:amount) { 'foo' }
 
-    it 'raises a deprecation warning' do
-      expect { subject }.to raise_error(ActiveSupport::DeprecationException)
+    it 'raises an ArgumentError' do
+      expect { subject }.to raise_error(ArgumentError)
     end
   end
 
@@ -174,7 +181,7 @@ RSpec.describe 'MoneyColumn' do
     let(:currency) { 'foo' }
 
     it 'raises an UnknownCurrency error' do
-      expect { subject }.to raise_error(ActiveSupport::DeprecationException)
+      expect { subject }.to raise_error(Money::Currency::UnknownCurrency)
     end
   end
 
@@ -217,11 +224,20 @@ RSpec.describe 'MoneyColumn' do
   describe 'read_only_currency true' do
     it 'does not write the currency to the db' do
       record = MoneyWithReadOnlyCurrency.create
-      record.update_columns(price: 1, currency: 'USD')
-      expect(Money).to receive(:deprecate).once
-      record.update(price: Money.new(4, 'CAD'))
-      expect(record.price.value).to eq(4)
-      expect(record.price.currency.to_s).to eq('USD')
+      record.update_columns(currency: 'USD')
+      expect { record.update(price: Money.new(4, 'CAD')) }.to raise_error(MoneyColumn::CurrencyReadOnlyError)
+    end
+
+    it 'legacy_deprecations does not write the currency to the db' do
+      configure(legacy_deprecations: true) do
+        record = MoneyWithReadOnlyCurrency.create
+        record.update_columns(currency: 'USD')
+
+        expect(Money).to receive(:deprecate).once
+        record.update(price: Money.new(4, 'CAD'))
+        expect(record.price.value).to eq(4)
+        expect(record.price.currency.to_s).to eq('USD')
+      end
     end
 
     it 'reads the currency that is already in the db' do
@@ -233,12 +249,14 @@ RSpec.describe 'MoneyColumn' do
     end
 
     it 'reads an invalid currency from the db and generates a no currency object' do
-      expect(Money).to receive(:deprecate).once
-      record = MoneyWithReadOnlyCurrency.create
-      record.update_columns(currency: 'invalid', price: 1)
-      record.reload
-      expect(record.price.value).to eq(1)
-      expect(record.price.currency.to_s).to eq('')
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).once
+        record = MoneyWithReadOnlyCurrency.create
+        record.update_columns(currency: 'invalid', price: 1)
+        record.reload
+        expect(record.price.value).to eq(1)
+        expect(record.price.currency.to_s).to eq('')
+      end
     end
 
     it 'sets the currency correctly when the currency is changed' do
@@ -248,12 +266,12 @@ RSpec.describe 'MoneyColumn' do
     end
 
     it 'handle cases where the delegate allow_nil is false' do
-      record = MoneyWithDelegatedCurrency.new(price: Money.new(10, 'USD'), delegated_record: MoneyRecord.new(currency: 'USD'))
+      record = MoneyWithDelegatedCurrency.new(price: Money.new(10, 'USD'))
       expect(record.price.currency.to_s).to eq('USD')
     end
 
     it 'handle cases where a manual delegate does not allow nil' do
-      record = MoneyWithDelegatedCurrency.new(prix: Money.new(10, 'USD'), delegated_record: MoneyRecord.new(currency: 'USD'))
+      record = MoneyWithDelegatedCurrency.new(prix: Money.new(10, 'USD'))
       expect(record.price.currency.to_s).to eq('USD')
     end
   end
@@ -370,10 +388,7 @@ RSpec.describe 'MoneyColumn' do
 
   describe 'default_currency = nil' do
     around do |example|
-      default_currency = Money.default_currency
-      Money.default_currency = nil
-      example.run
-      Money.default_currency = default_currency
+      configure(default_currency: nil) { example.run }
     end
 
     it 'writes currency from input value to the db' do
@@ -384,11 +399,17 @@ RSpec.describe 'MoneyColumn' do
       expect(record.price.currency.to_s).to eq('GBP')
     end
 
-    it 'raises missing currency error when input is not a money object' do
-      record.update(currency: nil)
+    it 'raises missing currency error reading a value that was saved using legacy non-money object' do
+      record.update(currency: nil, price: 3)
+      expect { record.price }.to raise_error(ArgumentError, 'missing currency')
+    end
 
-      expect { record.update(price: 3) }
-        .to raise_error(ArgumentError, 'missing currency')
+    it 'handles legacy support for saving price and currency separately' do
+      record.update(currency: nil)
+      record.update(price: 7, currency: 'GBP')
+      record.reload
+      expect(record.price.value).to eq(7)
+      expect(record.price.currency.to_s).to eq('GBP')
     end
   end
 end

data/spec/money_spec.rb

@@ -3,23 +3,20 @@ require 'spec_helper'
 require 'yaml'
 
 RSpec.describe "Money" do
-
   let (:money) { Money.new(1) }
   let (:amount_money) { Money.new(1.23, 'USD') }
   let (:non_fractional_money) { Money.new(1, 'JPY') }
   let (:zero_money) { Money.new(0) }
 
-  context "default currency not set" do
-    before(:each) do
-      @default_currency = Money.default_currency
-      Money.default_currency = nil
-    end
-    after(:each) do
-      Money.default_currency = @default_currency
-    end
+  it "has a version" do
+    expect(Money::VERSION).not_to(eq(nil))
+  end
 
+  context "default currency not set" do
     it "raises an error" do
-      expect { money }.to raise_error(ArgumentError)
+      configure(default_currency: nil) do
+        expect { money }.to raise_error(ArgumentError)
+      end
     end
   end
 
@@ -39,9 +36,15 @@ RSpec.describe "Money" do
     expect(Money.new(1).to_money('CAD')).to eq(Money.new(1, 'CAD'))
   end
 
-  it "#to_money doesn't overwrite the money object's currency" do
-    expect(Money).to receive(:deprecate).once
-    expect(Money.new(1, 'USD').to_money('CAD')).to eq(Money.new(1, 'USD'))
+  it "legacy_deprecations #to_money doesn't overwrite the money object's currency" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.new(1, 'USD').to_money('CAD')).to eq(Money.new(1, 'USD'))
+    end
+  end
+
+  it "#to_money raises when changing currency" do
+    expect{ Money.new(1, 'USD').to_money('CAD') }.to raise_error(Money::IncompatibleCurrencyError)
   end
 
   it "defaults to 0 when constructed with no arguments" do
@@ -52,9 +55,15 @@ RSpec.describe "Money" do
     expect(Money.new('')).to eq(Money.new(0))
   end
 
-  it "defaults to 0 when constructed with an invalid string" do
-    expect(Money).to receive(:deprecate).once
-    expect(Money.new('invalid')).to eq(Money.new(0.00))
+  it "legacy_deprecations defaults to 0 when constructed with an invalid string" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.new('invalid', 'USD')).to eq(Money.new(0.00, 'USD'))
+    end
+  end
+
+  it "raises when constructed with an invalid string" do
+    expect{ Money.new('invalid') }.to raise_error(ArgumentError)
   end
 
   it "to_s correctly displays the right number of decimal places" do
@@ -62,14 +71,14 @@ RSpec.describe "Money" do
     expect(non_fractional_money.to_s).to eq("1")
   end
 
-  it "to_s with a legacy_dollars style" do
-    expect(amount_money.to_s(:legacy_dollars)).to eq("1.23")
-    expect(non_fractional_money.to_s(:legacy_dollars)).to eq("1.00")
+  it "to_fs with a legacy_dollars style" do
+    expect(amount_money.to_fs(:legacy_dollars)).to eq("1.23")
+    expect(non_fractional_money.to_fs(:legacy_dollars)).to eq("1.00")
   end
 
-  it "to_s with a amount style" do
-    expect(amount_money.to_s(:amount)).to eq("1.23")
-    expect(non_fractional_money.to_s(:amount)).to eq("1")
+  it "to_fs with a amount style" do
+    expect(amount_money.to_fs(:amount)).to eq("1.23")
+    expect(non_fractional_money.to_fs(:amount)).to eq("1")
   end
 
   it "to_s correctly displays negative numbers" do
@@ -95,12 +104,31 @@ RSpec.describe "Money" do
     expect(Money.new("999999999999999999.99", "USD").to_s).to eq("999999999999999999.99")
   end
 
-  it "to_s raises ArgumentError on unsupported style" do
-    expect{ money.to_s(:some_weird_style) }.to raise_error(ArgumentError)
+  it "to_fs raises ArgumentError on unsupported style" do
+    expect{ money.to_fs(:some_weird_style) }.to raise_error(ArgumentError)
+  end
+
+  it "to_fs is aliased as to_s for backward compatibility" do
+    expect(money.method(:to_s)).to eq(money.method(:to_fs))
+  end
+
+  it "to_fs is aliased as to_formatted_s for backward compatibility" do
+    expect(money.method(:to_formatted_s)).to eq(money.method(:to_fs))
+  end
+
+  it "legacy_json_format makes as_json return the legacy format" do
+    configure(legacy_json_format: true) do
+      expect(Money.new(1, 'CAD').as_json).to eq("1.00")
+    end
+  end
+
+  it "legacy_format correctly sets the json format" do
+    expect(Money.new(1, 'CAD').as_json(legacy_format: true)).to eq("1.00")
+    expect(Money.new(1, 'CAD').to_json(legacy_format: true)).to eq("1.00")
   end
 
-  it "as_json as a float with 2 decimal places" do
-    expect(money.as_json).to eq("1.00")
+  it "as_json as a json containing the value and currency" do
+    expect(money.as_json).to eq(value: "1.00", currency: "CAD")
   end
 
   it "is constructable with a BigDecimal" do
@@ -139,9 +167,15 @@ RSpec.describe "Money" do
     expect((Money.new + Money.new)).to eq(Money.new)
   end
 
-  it "adds inconsistent currencies" do
-    expect(Money).to receive(:deprecate).once
-    expect(Money.new(5, 'USD') + Money.new(1, 'CAD')).to eq(Money.new(6, 'USD'))
+  it "legacy_deprecations adds inconsistent currencies" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.new(5, 'USD') + Money.new(1, 'CAD')).to eq(Money.new(6, 'USD'))
+    end
+  end
+
+  it "raises when adding inconsistent currencies" do
+    expect{ Money.new(5, 'USD') + Money.new(1, 'CAD') }.to raise_error(Money::IncompatibleCurrencyError)
   end
 
   it "is subtractable" do
@@ -157,8 +191,10 @@ RSpec.describe "Money" do
   end
 
   it "logs a deprecation warning when adding across currencies" do
-    expect(Money).to receive(:deprecate)
-    expect(Money.new(10, 'USD') - Money.new(1, 'JPY')).to eq(Money.new(9, 'USD'))
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate)
+      expect(Money.new(10, 'USD') - Money.new(1, 'JPY')).to eq(Money.new(9, 'USD'))
+    end
   end
 
   it "keeps currency when doing a computation with a null currency" do
@@ -254,9 +290,15 @@ RSpec.describe "Money" do
     expect(((1.0 / 12) * Money.new(3.3))).to eq(Money.new(0.28))
   end
 
-  it "is multipliable by a money object" do
-    expect(Money).to receive(:deprecate).once
-    expect((Money.new(3.3) * Money.new(1))).to eq(Money.new(3.3))
+  it "legacy_deprecations is multipliable by a money object" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect((Money.new(3.3, 'USD') * Money.new(1, 'USD'))).to eq(Money.new(3.3, 'USD'))
+    end
+  end
+
+  it "raises when multiplied by a money object" do
+    expect{ (Money.new(3.3) * Money.new(1)) }.to raise_error(ArgumentError)
   end
 
   it "rounds multiplication result with fractional penny of 5 or higher up" do
@@ -294,7 +336,14 @@ RSpec.describe "Money" do
   end
 
   it "returns cents in to_json" do
-    expect(Money.new(1.00).to_json).to eq("1.00")
+    configure(legacy_json_format: true) do
+      expect(Money.new('1.23', 'USD').to_json).to eq('1.23')
+    end
+  end
+
+  it "returns value and currency in to_json" do
+    expect(Money.new(1.00).to_json).to eq('{"value":"1.00","currency":"CAD"}')
+    expect(JSON.dump(Money.new(1.00, "CAD"))).to eq('{"value":"1.00","currency":"CAD"}')
   end
 
   it "supports absolute value" do
@@ -352,9 +401,36 @@ RSpec.describe "Money" do
   end
 
   it "generates a true rational" do
-    expect(Money.rational(Money.new(10.0), Money.new(15.0))).to eq(Rational(2,3))
-    expect(Money).to receive(:deprecate).once
-    expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'JPY'))).to eq(Rational(2,3))
+    expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'USD'))).to eq(Rational(2,3))
+
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'JPY'))).to eq(Rational(2,3))
+    end
+  end
+
+  it "does not allocate a new money object when multiplying by 1" do
+    expect((money * 1).object_id).to eq(money.object_id)
+  end
+
+  it "does not allocate a new money object when adding 0" do
+    expect((money + 0).object_id).to eq(money.object_id)
+  end
+
+  it "does not allocate a new money object when subtracting 0" do
+    expect((money - 0).object_id).to eq(money.object_id)
+  end
+
+  it "does not allocate when computing absolute value when already positive" do
+    expect((money.abs).object_id).to eq(money.object_id)
+  end
+
+  it "does not allocate when computing floor value when already floored" do
+    expect((money.floor).object_id).to eq(money.object_id)
+  end
+
+  it "does not allocate when computing floor value when already rounded" do
+    expect((money.round).object_id).to eq(money.object_id)
   end
 
   describe "frozen with amount of $1" do
@@ -413,9 +489,11 @@ RSpec.describe "Money" do
     end
 
     it "<=> issues deprecation warning when comparing incompatible currency" do
-      expect(Money).to receive(:deprecate).twice
-      expect(Money.new(1000, 'USD') <=> Money.new(2000, 'JPY')).to eq(-1)
-      expect(Money.new(2000, 'JPY') <=> Money.new(1000, 'USD')).to eq(1)
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).twice
+        expect(Money.new(1000, 'USD') <=> Money.new(2000, 'JPY')).to eq(-1)
+        expect(Money.new(2000, 'JPY') <=> Money.new(1000, 'USD')).to eq(1)
+      end
     end
 
     describe('same values') do
@@ -437,15 +515,22 @@ RSpec.describe "Money" do
         it { expect(cad_10 <  nil_10).to(eq(false)) }
       end
 
-      describe('different currencies') do
+      describe('legacy different currencies') do
+        around(:each) do |test|
+          configure(legacy_deprecations: true) { test.run }
+        end
+
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <=> usd_10).to(eq(0)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >  usd_10).to(eq(false)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >= usd_10).to(eq(true)) }
-        it { expect(cad_10 == usd_10).to(eq(false)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <= usd_10).to(eq(true)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <  usd_10).to(eq(false)) }
       end
 
+      describe('different currencies') do
+        it { expect(cad_10 == usd_10).to(eq(false)) }
+      end
+
       describe('to_money types') do
         it { expect(cad_10 <=> 10.00).to(eq(0)) }
         it { expect(cad_10 >   10.00).to(eq(false)) }
@@ -709,23 +794,6 @@ RSpec.describe "Money" do
     end
   end
 
-  describe "parser dependency injection" do
-    before(:each) { Money.parser = AccountingMoneyParser }
-    after(:each) { Money.parser = MoneyParser }
-
-    it "keeps AccountingMoneyParser class on new money objects" do
-      expect(Money.new.class.parser).to eq(AccountingMoneyParser)
-    end
-
-    it "supports parenthesis from AccountingMoneyParser" do
-      expect(Money.parse("($5.00)")).to eq(Money.new(-5))
-    end
-
-    it "supports parenthesis from AccountingMoneyParser for .to_money" do
-      expect("($5.00)".to_money).to eq(Money.new(-5))
-    end
-  end
-
   describe "round" do
 
     it "rounds to 0 decimal places by default" do
@@ -875,8 +943,7 @@ RSpec.describe "Money" do
     end
 
     context "with .default_currency set" do
-      before(:each) { Money.default_currency = Money::Currency.new('EUR') }
-      after(:each) { Money.default_currency = Money::NULL_CURRENCY }
+      around(:each) { |test| configure(default_currency: Money::Currency.new('EUR')) { test.run }}
 
       it "can be nested and falls back to default_currency outside of the blocks" do
         money2, money3 = nil