monetize 1.3.1 → 1.4.0

data/spec/core_extensions_spec.rb

@@ -1,19 +1,19 @@
 # encoding: utf-8
 
-require "spec_helper"
-require "monetize"
-require "monetize/core_extensions"
+require 'spec_helper'
+require 'monetize'
+require 'monetize/core_extensions'
 
-describe Monetize, "core extensions" do
+describe Monetize, 'core extensions' do
   describe NilClass do
-    describe "#to_money" do
-      it "work as documented" do
+    describe '#to_money' do
+      it 'work as documented' do
         money = nil.to_money
         expect(money.cents).to eq 0
         expect(money.currency).to eq Money.default_currency
       end
 
-      it "accepts optional currency" do
+      it 'accepts optional currency' do
         expect(nil.to_money('USD')).to eq Money.new(nil, 'USD')
         expect(nil.to_money('EUR')).to eq Money.new(nil, 'EUR')
       end
@@ -21,10 +21,10 @@ describe Monetize, "core extensions" do
   end
 
   describe Numeric do
-    describe "#to_money" do
-      it "work as documented" do
+    describe '#to_money' do
+      it 'work as documented' do
         money = 1234.to_money
-        expect(money.cents).to eq 1234_00
+        expect(money.cents).to eq 1_234_00
         expect(money.currency).to eq Money.default_currency
 
         money = 100.37.to_money
@@ -32,183 +32,180 @@ describe Monetize, "core extensions" do
         expect(money.currency).to eq Money.default_currency
 
         money = BigDecimal.new('1234').to_money
-        expect(money.cents).to eq 1234_00
+        expect(money.cents).to eq 1_234_00
         expect(money.currency).to eq Money.default_currency
       end
 
-      it "accepts optional currency" do
-        expect(1234.to_money('USD')).to eq Money.new(123400, 'USD')
-        expect(1234.to_money('EUR')).to eq Money.new(123400, 'EUR')
+      it 'accepts optional currency' do
+        expect(1234.to_money('USD')).to eq Money.new(1_234_00, 'USD')
+        expect(1234.to_money('EUR')).to eq Money.new(1_234_00, 'EUR')
       end
 
-      it "respects :subunit_to_unit currency property" do
+      it 'respects :subunit_to_unit currency property' do
         expect(10.to_money('USD')).to eq Money.new(10_00, 'USD')
         expect(10.to_money('TND')).to eq Money.new(10_000, 'TND')
         expect(10.to_money('JPY')).to eq Money.new(10, 'JPY')
       end
 
-      specify "GH-15" do
+      specify 'GH-15' do
         amount = 555.55.to_money
-        expect(amount).to eq Money.new(55555)
+        expect(amount).to eq Money.new(555_55)
       end
     end
   end
 
   describe String do
-    describe "#to_money" do
-
+    describe '#to_money' do
       STRING_TO_MONEY = {
-        "20.15"           => Money.new(20_15)                 ,
-        "100"             => Money.new(100_00)                ,
-        "100.37"          => Money.new(100_37)                ,
-        "100,37"          => Money.new(100_37)                ,
-        "100 000"         => Money.new(100_000_00)            ,
-        "100,000.00"      => Money.new(100_000_00)            ,
-        "1,000"           => Money.new(1_000_00)              ,
-        "-1,000"          => Money.new(-1_000_00)             ,
-        "1,000.5"         => Money.new(1_000_50)              ,
-        "1,000.51"        => Money.new(1_000_51)              ,
-        "1,000.505"       => Money.new(1_000_51)              ,
-        "1,000.504"       => Money.new(1_000_50)              ,
-        "1,000.0000"      => Money.new(1_000_00)              ,
-        "1,000.5000"      => Money.new(1_000_50)              ,
-        "1,000.5099"      => Money.new(1_000_51)              ,
-        "1.550"           => Money.new(1_55)                  ,
-        "25."             => Money.new(25_00)                 ,
-        ".75"             => Money.new(75)                    ,
-
-        "7.21K"           => Money.new(7_210_00)              ,
-        "1M"              => Money.new(1_000_000_00)          ,
-        "1.2M"            => Money.new(1_200_000_00)          ,
-        "1.37M"           => Money.new(1_370_000_00)          ,
-        "3.1415927M"      => Money.new(3_141_592_70)          ,
-        ".42B"            => Money.new(420_000_000_00)        ,
-        "5T"              => Money.new(5_000_000_000_000_00)  ,
-
-        "100 USD"         => Money.new(100_00, "USD")         ,
-        "-100 USD"        => Money.new(-100_00, "USD")        ,
-        "100 EUR"         => Money.new(100_00, "EUR")         ,
-        "100.37 EUR"      => Money.new(100_37, "EUR")         ,
-        "100,37 EUR"      => Money.new(100_37, "EUR")         ,
-        "100,000.00 USD"  => Money.new(100_000_00, "USD")     ,
-        "100.000,00 EUR"  => Money.new(100_000_00, "EUR")     ,
-        "1,000 USD"       => Money.new(1_000_00, "USD")       ,
-        "-1,000 USD"      => Money.new(-1_000_00, "USD")      ,
-        "1,000.5500 USD"  => Money.new(1_000_55, "USD")       ,
-        "-1,000.6500 USD" => Money.new(-1_000_65, "USD")      ,
-        "1.550 USD"       => Money.new(1_55, "USD")           ,
-
-        "USD 100"         => Money.new(100_00, "USD")         ,
-        "EUR 100"         => Money.new(100_00, "EUR")         ,
-        "EUR 100.37"      => Money.new(100_37, "EUR")         ,
-        "CAD -100.37"     => Money.new(-100_37, "CAD")        ,
-        "EUR 100,37"      => Money.new(100_37, "EUR")         ,
-        "EUR -100,37"     => Money.new(-100_37, "EUR")        ,
-        "USD 100,000.00"  => Money.new(100_000_00, "USD")     ,
-        "EUR 100.000,00"  => Money.new(100_000_00, "EUR")     ,
-        "USD 1,000"       => Money.new(1_000_00, "USD")       ,
-        "USD -1,000"      => Money.new(-1_000_00, "USD")      ,
-        "USD 1,000.9000"  => Money.new(1_000_90, "USD")       ,
-        "USD -1,000.090"  => Money.new(-1_000_09, "USD")      ,
-        "USD 1.5500"      => Money.new(1_55, "USD")           ,
-
-        "$100 USD"        => Money.new(100_00, "USD")         ,
-        "$1,194.59 USD"   => Money.new(1_194_59, "USD")       ,
-        "$-1,955 USD"     => Money.new(-1_955_00, "USD")      ,
-        "$1,194.5900 USD" => Money.new(1_194_59, "USD")       ,
-        "$-1,955.000 USD" => Money.new(-1_955_00, "USD")      ,
-        "$1.99000 USD"    => Money.new(1_99, "USD")           ,
+        '20.15'           => Money.new(20_15),
+        '100'             => Money.new(100_00),
+        '100.37'          => Money.new(100_37),
+        '100,37'          => Money.new(100_37),
+        '100 000'         => Money.new(100_000_00),
+        '100,000.00'      => Money.new(100_000_00),
+        '1,000'           => Money.new(1_000_00),
+        '-1,000'          => Money.new(-1_000_00),
+        '1,000.5'         => Money.new(1_000_50),
+        '1,000.51'        => Money.new(1_000_51),
+        '1,000.505'       => Money.new(1_000_51),
+        '1,000.504'       => Money.new(1_000_50),
+        '1,000.0000'      => Money.new(1_000_00),
+        '1,000.5000'      => Money.new(1_000_50),
+        '1,000.5099'      => Money.new(1_000_51),
+        '1.550'           => Money.new(1_55),
+        '25.'             => Money.new(25_00),
+        '.75'             => Money.new(75),
+
+        '7.21K'           => Money.new(7_210_00),
+        '1M'              => Money.new(1_000_000_00),
+        '1.2M'            => Money.new(1_200_000_00),
+        '1.37M'           => Money.new(1_370_000_00),
+        '3.1415927M'      => Money.new(3_141_592_70),
+        '.42B'            => Money.new(420_000_000_00),
+        '5T'              => Money.new(5_000_000_000_000_00),
+
+        '100 USD'         => Money.new(100_00, 'USD'),
+        '-100 USD'        => Money.new(-100_00, 'USD'),
+        '100 EUR'         => Money.new(100_00, 'EUR'),
+        '100.37 EUR'      => Money.new(100_37, 'EUR'),
+        '100,37 EUR'      => Money.new(100_37, 'EUR'),
+        '100,000.00 USD'  => Money.new(100_000_00, 'USD'),
+        '100.000,00 EUR'  => Money.new(100_000_00, 'EUR'),
+        '1,000 USD'       => Money.new(1_000_00, 'USD'),
+        '-1,000 USD'      => Money.new(-1_000_00, 'USD'),
+        '1,000.5500 USD'  => Money.new(1_000_55, 'USD'),
+        '-1,000.6500 USD' => Money.new(-1_000_65, 'USD'),
+        '1.550 USD'       => Money.new(1_55, 'USD'),
+
+        'USD 100'         => Money.new(100_00, 'USD'),
+        'EUR 100'         => Money.new(100_00, 'EUR'),
+        'EUR 100.37'      => Money.new(100_37, 'EUR'),
+        'CAD -100.37'     => Money.new(-100_37, 'CAD'),
+        'EUR 100,37'      => Money.new(100_37, 'EUR'),
+        'EUR -100,37'     => Money.new(-100_37, 'EUR'),
+        'USD 100,000.00'  => Money.new(100_000_00, 'USD'),
+        'EUR 100.000,00'  => Money.new(100_000_00, 'EUR'),
+        'USD 1,000'       => Money.new(1_000_00, 'USD'),
+        'USD -1,000'      => Money.new(-1_000_00, 'USD'),
+        'USD 1,000.9000'  => Money.new(1_000_90, 'USD'),
+        'USD -1,000.090'  => Money.new(-1_000_09, 'USD'),
+        'USD 1.5500'      => Money.new(1_55, 'USD'),
+
+        '$100 USD'        => Money.new(100_00, 'USD'),
+        '$1,194.59 USD'   => Money.new(1_194_59, 'USD'),
+        '$-1,955 USD'     => Money.new(-1_955_00, 'USD'),
+        '$1,194.5900 USD' => Money.new(1_194_59, 'USD'),
+        '$-1,955.000 USD' => Money.new(-1_955_00, 'USD'),
+        '$1.99000 USD'    => Money.new(1_99, 'USD')
       }
 
-      it "works as documented" do
+      it 'works as documented' do
         STRING_TO_MONEY.each do |string, money|
           expect(string.to_money).to eq money
         end
       end
 
-      it "coerces input to string" do
-        expect(Monetize.parse(20, "USD")).to eq Money.new(20_00, "USD")
+      it 'coerces input to string' do
+        expect(Monetize.parse(20, 'USD')).to eq Money.new(20_00, 'USD')
       end
 
-      it "accepts optional currency" do
-        expect("10.10".to_money('USD')).to eq Money.new(1010, 'USD')
-        expect("10.10".to_money('EUR')).to eq Money.new(1010, 'EUR')
-        expect("10.10 USD".to_money('USD')).to eq Money.new(1010, 'USD')
+      it 'accepts optional currency' do
+        expect('10.10'.to_money('USD')).to eq Money.new(10_10, 'USD')
+        expect('10.10'.to_money('EUR')).to eq Money.new(10_10, 'EUR')
+        expect('10.10 USD'.to_money('USD')).to eq Money.new(10_10, 'USD')
       end
 
-      it "uses parsed currency, even if currency is passed" do
-        expect("10.10 USD".to_money("EUR")).to eq(Money.new(1010, "USD"))
+      it 'uses parsed currency, even if currency is passed' do
+        expect('10.10 USD'.to_money('EUR')).to eq(Money.new(10_10, 'USD'))
       end
 
-      it "ignores unrecognized data" do
-        expect("hello 2000 world".to_money).to eq Money.new(2000_00)
+      it 'ignores unrecognized data' do
+        expect('hello 2000 world'.to_money).to eq Money.new(2_000_00)
       end
 
-      it "respects :subunit_to_unit currency property" do
-        expect("1".to_money("USD")).to eq Money.new(1_00,  "USD")
-        expect("1".to_money("TND")).to eq Money.new(1_000, "TND")
-        expect("1".to_money("JPY")).to eq Money.new(1,     "JPY")
-        expect("1.5".to_money("KWD").cents).to eq 1500
+      it 'respects :subunit_to_unit currency property' do
+        expect('1'.to_money('USD')).to eq Money.new(1_00,  'USD')
+        expect('1'.to_money('TND')).to eq Money.new(1_000, 'TND')
+        expect('1'.to_money('JPY')).to eq Money.new(1,     'JPY')
+        expect('1.5'.to_money('KWD').cents).to eq 1_500
       end
     end
 
-    describe "#to_currency" do
-      it "converts String to Currency" do
-        expect("USD".to_currency).to eq Money::Currency.new("USD")
-        expect("EUR".to_currency).to eq Money::Currency.new("EUR")
+    describe '#to_currency' do
+      it 'converts String to Currency' do
+        expect('USD'.to_currency).to eq Money::Currency.new('USD')
+        expect('EUR'.to_currency).to eq Money::Currency.new('EUR')
       end
 
-      it "raises Money::Currency::UnknownCurrency with unknown Currency" do
-        expect { "XXX".to_currency }.to raise_error(Money::Currency::UnknownCurrency)
-        expect { " ".to_currency }.to raise_error(Money::Currency::UnknownCurrency)
+      it 'raises Money::Currency::UnknownCurrency with unknown Currency' do
+        expect { 'XXX'.to_currency }.to raise_error(Money::Currency::UnknownCurrency)
+        expect { ' '.to_currency }.to raise_error(Money::Currency::UnknownCurrency)
       end
     end
   end
 
   describe Hash do
-    describe "#to_money" do
-
-      context "when currency is present in hash" do
-        subject(:hash){ { cents: 5, currency: "EUR" } }
+    describe '#to_money' do
+      context 'when currency is present in hash' do
+        subject(:hash) { {cents: 5, currency: 'EUR'} }
 
-        it "converts Hash to Money using key from hash" do
-          expect(hash.to_money).to eq(Money.new(5, "EUR"))
+        it 'converts Hash to Money using key from hash' do
+          expect(hash.to_money).to eq(Money.new(5, 'EUR'))
         end
       end
 
-      context "when currency is passed as argument" do
-        subject(:hash){ { cents: 10 } }
+      context 'when currency is passed as argument' do
+        subject(:hash) { {cents: 10} }
 
-        it "converts Hash to Money using passed currency argument" do
-          expect(hash.to_money("JPY")).to eq(Money.new(10, "JPY"))
+        it 'converts Hash to Money using passed currency argument' do
+          expect(hash.to_money('JPY')).to eq(Money.new(10, 'JPY'))
         end
       end
 
-      context "when no currency is passed" do
-        subject(:hash){ { cents: 123 } }
+      context 'when no currency is passed' do
+        subject(:hash) { {cents: 123} }
 
-        before { allow(Money).to receive(:default_currency).and_return("USD") }
+        before { allow(Money).to receive(:default_currency).and_return('USD') }
 
-        it "converts Hash to Money using default value" do
-          expect(hash.to_money("USD")).to eq(Money.new(123, "USD"))
+        it 'converts Hash to Money using default value' do
+          expect(hash.to_money('USD')).to eq(Money.new(123, 'USD'))
         end
       end
-
     end
   end
 
   describe Symbol do
-    describe "#to_currency" do
-      it "converts Symbol to Currency" do
-        expect(:usd.to_currency).to eq Money::Currency.new("USD")
-        expect(:ars.to_currency).to eq Money::Currency.new("ARS")
+    describe '#to_currency' do
+      it 'converts Symbol to Currency' do
+        expect(:usd.to_currency).to eq Money::Currency.new('USD')
+        expect(:ars.to_currency).to eq Money::Currency.new('ARS')
       end
 
-      it "is case-insensitive" do
-        expect(:EUR.to_currency).to eq Money::Currency.new("EUR")
+      it 'is case-insensitive' do
+        expect(:EUR.to_currency).to eq Money::Currency.new('EUR')
       end
 
-      it "raises Money::Currency::UnknownCurrency with unknown Currency" do
+      it 'raises Money::Currency::UnknownCurrency with unknown Currency' do
         expect { :XXX.to_currency }.to raise_error(Money::Currency::UnknownCurrency)
         expect { :" ".to_currency }.to raise_error(Money::Currency::UnknownCurrency)
       end

data/spec/monetize_spec.rb

@@ -1,26 +1,52 @@
 # encoding: utf-8
 
-require "spec_helper"
-require "monetize"
+require 'spec_helper'
+require 'monetize'
 
 describe Monetize do
-
-  bar = '{ "priority": 1, "iso_code": "BAR", "iso_numeric": "840", "name": "Dollar with 4 decimal places", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 10000, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": "," }'
-  eu4 = '{ "priority": 1, "iso_code": "EU4", "iso_numeric": "841", "name": "Euro with 4 decimal places", "symbol": "€", "subunit": "Cent", "subunit_to_unit": 10000, "symbol_first": true, "html_entity": "€", "decimal_mark": ",", "thousands_separator": "." }'
-
-  describe ".parse" do
-
-    it "parses european-formatted inputs under 10EUR" do
+  bar = <<-JSON
+    {
+      "priority": 1,
+      "iso_code": "BAR",
+      "iso_numeric": "840",
+      "name": "Dollar with 4 decimal places",
+      "symbol": "$",
+      "subunit": "Cent",
+      "subunit_to_unit": 10000,
+      "symbol_first": true,
+      "html_entity": "$",
+      "decimal_mark": ".",
+      "thousands_separator": ","
+    }
+  JSON
+
+  eu4 = <<-JSON
+    {
+      "priority": 1,
+      "iso_code": "EU4",
+      "iso_numeric": "841",
+      "name": "Euro with 4 decimal places",
+      "symbol": "€",
+      "subunit": "Cent",
+      "subunit_to_unit": 10000,
+      "symbol_first": true,
+      "html_entity": "€",
+      "decimal_mark": ",",
+      "thousands_separator": "."
+    }
+  JSON
+
+  describe '.parse' do
+    it 'parses european-formatted inputs under 10EUR' do
       expect(Monetize.parse('EUR 5,95')).to eq Money.new(595, 'EUR')
     end
 
-    it "parses european-formatted inputs with multiple thousands-seperators" do
-      expect(Monetize.parse('EUR 1.234.567,89')).to eq Money.new(123456789, 'EUR')
-      expect(Monetize.parse('EUR 1.111.234.567,89')).to eq Money.new(111123456789, 'EUR')
+    it 'parses european-formatted inputs with multiple thousands-seperators' do
+      expect(Monetize.parse('EUR 1.234.567,89')).to eq Money.new(1_234_567_89, 'EUR')
+      expect(Monetize.parse('EUR 1.111.234.567,89')).to eq Money.new(1_111_234_567_89, 'EUR')
     end
 
     describe 'currency detection' do
-
       context 'opted in' do
         before :all do
           Monetize.assume_from_symbol = true
@@ -30,69 +56,68 @@ describe Monetize do
           Monetize.assume_from_symbol = false
         end
 
-        it "parses formatted inputs with Euros passed as a symbol" do
-          expect(Monetize.parse("€5.95")).to eq Money.new(595, 'EUR')
+        it 'parses formatted inputs with Euros passed as a symbol' do
+          expect(Monetize.parse('€5.95')).to eq Money.new(595, 'EUR')
         end
 
-        it "parses formatted inputs with Euros passed as a symbol with surrounding space" do
-          expect(Monetize.parse(" €5.95 ")).to eq Money.new(595, 'EUR')
+        it 'parses formatted inputs with Euros passed as a symbol with surrounding space' do
+          expect(Monetize.parse(' €5.95 ')).to eq Money.new(595, 'EUR')
         end
 
-        it "parses formatted inputs with British Pounds Sterling passed as a symbol" do
-          expect(Monetize.parse("£9.99")).to eq Money.new(999, 'GBP')
+        it 'parses formatted inputs with British Pounds Sterling passed as a symbol' do
+          expect(Monetize.parse('£9.99')).to eq Money.new(999, 'GBP')
         end
 
-        it "parses formatted inputs with British Pounds Sterling passed as a lira sign symbol" do
-          expect(Monetize.parse("₤9.99")).to eq Money.new(999, 'GBP')
+        it 'parses formatted inputs with British Pounds Sterling passed as a lira sign symbol' do
+          expect(Monetize.parse('₤9.99')).to eq Money.new(999, 'GBP')
         end
 
-        it "parses formatted inputs with South African Rand passed as a symbol" do
-          expect(Monetize.parse("R9.99")).to eq Money.new(999, 'ZAR')
+        it 'parses formatted inputs with South African Rand passed as a symbol' do
+          expect(Monetize.parse('R9.99')).to eq Money.new(999, 'ZAR')
         end
 
-        it "parses formatted inputs with Brazilian real passed as a symbol" do
-          expect(Monetize.parse("R$R9.99")).to eq Money.new(999, 'BRL')
+        it 'parses formatted inputs with Brazilian real passed as a symbol' do
+          expect(Monetize.parse('R$R9.99')).to eq Money.new(999, 'BRL')
         end
 
-        it "parses formatted inputs with Japanese Yen passed as a symbol" do
-          expect(Monetize.parse("¥999")).to eq Money.new(999, 'JPY')
+        it 'parses formatted inputs with Japanese Yen passed as a symbol' do
+          expect(Monetize.parse('¥999')).to eq Money.new(999, 'JPY')
         end
 
-        it "parses formatted inputs with Canadian Dollar passed as a symbol" do
-          expect(Monetize.parse("C$9.99")).to eq Money.new(999, 'CAD')
+        it 'parses formatted inputs with Canadian Dollar passed as a symbol' do
+          expect(Monetize.parse('C$9.99')).to eq Money.new(999, 'CAD')
         end
 
         it 'should assume default currency if not a recognised symbol' do
-          expect(Monetize.parse("L9.99")).to eq Money.new(999, 'USD')
+          expect(Monetize.parse('L9.99')).to eq Money.new(999, 'USD')
         end
 
         it 'parses formatted inputs without currency detection when overridden' do
-          expect(Monetize.parse("£9.99", nil, assume_from_symbol: false)).to eq Money.new(999, 'USD')
+          expect(Monetize.parse('£9.99', nil, assume_from_symbol: false)).to eq Money.new(999, 'USD')
         end
 
         it 'parses formatted inputs with minus sign and currency symbol' do
-          expect(Monetize.parse("-€9.99")).to eq Money.new(-999, 'EUR')
-          expect(Monetize.parse("-£9.99")).to eq Money.new(-999, 'GBP')
-          expect(Monetize.parse("-R$R9.99")).to eq Money.new(-999, 'BRL')
-          expect(Monetize.parse("-¥999")).to eq Money.new(-999, 'JPY')
-          expect(Monetize.parse("-C$9.99")).to eq Money.new(-999, 'CAD')
+          expect(Monetize.parse('-€9.99')).to eq Money.new(-999, 'EUR')
+          expect(Monetize.parse('-£9.99')).to eq Money.new(-999, 'GBP')
+          expect(Monetize.parse('-R$R9.99')).to eq Money.new(-999, 'BRL')
+          expect(Monetize.parse('-¥999')).to eq Money.new(-999, 'JPY')
+          expect(Monetize.parse('-C$9.99')).to eq Money.new(-999, 'CAD')
         end
 
         it 'parses formatted inputs with plus and GBP passed as symbol' do
-          expect(Monetize.parse("+€9.99")).to eq Money.new(999, 'EUR')
-          expect(Monetize.parse("+£9.99")).to eq Money.new(999, 'GBP')
-          expect(Monetize.parse("+R$R9.99")).to eq Money.new(999, 'BRL')
-          expect(Monetize.parse("+¥999")).to eq Money.new(999, 'JPY')
-          expect(Monetize.parse("+C$9.99")).to eq Money.new(999, 'CAD')
-
+          expect(Monetize.parse('+€9.99')).to eq Money.new(999, 'EUR')
+          expect(Monetize.parse('+£9.99')).to eq Money.new(999, 'GBP')
+          expect(Monetize.parse('+R$R9.99')).to eq Money.new(999, 'BRL')
+          expect(Monetize.parse('+¥999')).to eq Money.new(999, 'JPY')
+          expect(Monetize.parse('+C$9.99')).to eq Money.new(999, 'CAD')
         end
 
         it 'parses formatted inputs with currency symbol and postfix minus sign' do
-          expect(Monetize.parse("€9.99-")).to eq Money.new(-999, 'EUR')
+          expect(Monetize.parse('€9.99-')).to eq Money.new(-999, 'EUR')
         end
 
         it 'parses formatted inputs with currency symbol and postfix plus sign' do
-          expect(Monetize.parse("€9.99+")).to eq Money.new(999, 'EUR')
+          expect(Monetize.parse('€9.99+')).to eq Money.new(999, 'EUR')
         end
 
         it 'parses formatted inputs with amounts given with suffixes' do
@@ -109,24 +134,24 @@ describe Monetize do
           Monetize.assume_from_symbol = false
         end
 
-        it "ignores the Euro symbol" do
-          expect(Monetize.parse("€5.95")).to eq Money.new(595, 'USD')
+        it 'ignores the Euro symbol' do
+          expect(Monetize.parse('€5.95')).to eq Money.new(595, 'USD')
         end
 
-        it "ignores the South African Rand symbol" do
-          expect(Monetize.parse("R5.95")).to eq Money.new(595, 'USD')
+        it 'ignores the South African Rand symbol' do
+          expect(Monetize.parse('R5.95')).to eq Money.new(595, 'USD')
         end
 
-        it "ignores the Euro symbol with surrounding spaces" do
-          expect(Monetize.parse(" €5.95 ")).to eq Money.new(595, 'USD')
+        it 'ignores the Euro symbol with surrounding spaces' do
+          expect(Monetize.parse(' €5.95 ')).to eq Money.new(595, 'USD')
         end
 
-        it "ignores the British Pounds Sterling symbol" do
-          expect(Monetize.parse("£9.99")).to eq Money.new(999, 'USD')
+        it 'ignores the British Pounds Sterling symbol' do
+          expect(Monetize.parse('£9.99')).to eq Money.new(999, 'USD')
         end
 
         it 'parses formatted inputs with currency detection when overridden' do
-          expect(Monetize.parse("£9.99", nil, assume_from_symbol: true)).to eq Money.new(999, 'GBP')
+          expect(Monetize.parse('£9.99', nil, assume_from_symbol: true)).to eq Money.new(999, 'GBP')
         end
       end
 
@@ -135,7 +160,7 @@ describe Monetize do
       end
     end
 
-    it "parses USD-formatted inputs under $10" do
+    it 'parses USD-formatted inputs under $10' do
       five_ninety_five = Money.new(595, 'USD')
 
       expect(Monetize.parse(5.95)).to eq five_ninety_five
@@ -147,215 +172,223 @@ describe Monetize do
       expect(Monetize.parse('$5.95, each')).to eq five_ninety_five
     end
 
-    it "parses USD-formatted inputs with multiple thousands-seperators" do
-      expect(Monetize.parse('1,234,567.89')).to eq Money.new(123456789, 'USD')
-      expect(Monetize.parse('1,111,234,567.89')).to eq Money.new(111123456789, 'USD')
+    it 'parses USD-formatted inputs with multiple thousands-seperators' do
+      expect(Monetize.parse('1,234,567.89')).to eq Money.new(1_234_567_89, 'USD')
+      expect(Monetize.parse('1,111,234,567.89')).to eq Money.new(1_111_234_567_89, 'USD')
     end
 
-    it "does not return a price if there is a price range" do
+    it 'does not return a price if there is a price range' do
       expect { Monetize.parse('$5.95-10.95') }.to raise_error ArgumentError
       expect { Monetize.parse('$5.95 - 10.95') }.to raise_error ArgumentError
       expect { Monetize.parse('$5.95 - $10.95') }.to raise_error ArgumentError
     end
 
-    it "does not return a price for completely invalid input" do
+    it 'does not return a price for completely invalid input' do
       expect(Monetize.parse(nil)).to eq Money.empty
       expect(Monetize.parse('hellothere')).to eq Money.empty
       expect(Monetize.parse('')).to eq Money.empty
     end
 
-    it "handles negative inputs" do
+    it 'handles negative inputs' do
       five_ninety_five = Money.new(-595, 'USD')
 
-      expect(Monetize.parse("$-5.95")).to eq five_ninety_five
-      expect(Monetize.parse("-$5.95")).to eq five_ninety_five
-      expect(Monetize.parse("$5.95-")).to eq five_ninety_five
+      expect(Monetize.parse('$-5.95')).to eq five_ninety_five
+      expect(Monetize.parse('-$5.95')).to eq five_ninety_five
+      expect(Monetize.parse('$5.95-')).to eq five_ninety_five
     end
 
-    it "raises ArgumentError when unable to detect polarity" do
+    it 'raises ArgumentError when unable to detect polarity' do
       expect { Monetize.parse('-$5.95-') }.to raise_error ArgumentError
     end
 
-    it "parses correctly strings with exactly 3 decimal digits" do
-      expect(Monetize.parse("6,534", "EUR")).to eq Money.new(653, "EUR")
+    it 'parses correctly strings with exactly 3 decimal digits' do
+      expect(Monetize.parse('6,534', 'EUR')).to eq Money.new(653, 'EUR')
+      expect(Monetize.parse('6.534', 'EUR')).to eq Money.new(653, 'EUR')
+
+      Monetize.enforce_currency_delimiters = true
+      expect(Monetize.parse('6.534', 'EUR')).to eq Money.new(6_534_00, 'EUR')
+      Monetize.enforce_currency_delimiters = false
     end
 
-    context "custom currencies with 4 decimal places" do
+    context 'custom currencies with 4 decimal places' do
       before :each do
-        Money::Currency.register(JSON.parse(bar, :symbolize_names => true))
-        Money::Currency.register(JSON.parse(eu4, :symbolize_names => true))
+        Money::Currency.register(JSON.parse(bar, symbolize_names: true))
+        Money::Currency.register(JSON.parse(eu4, symbolize_names: true))
       end
 
       after :each do
-        Money::Currency.unregister(JSON.parse(bar, :symbolize_names => true))
-        Money::Currency.unregister(JSON.parse(eu4, :symbolize_names => true))
+        Money::Currency.unregister(JSON.parse(bar, symbolize_names: true))
+        Money::Currency.unregister(JSON.parse(eu4, symbolize_names: true))
       end
 
       # String#to_money(Currency) is equivalent to Monetize.parse(String, Currency)
-      it "parses strings respecting subunit to unit, decimal and thousands separator" do
-        expect("$0.4".to_money("BAR")).to eq Money.new(4000, "BAR")
-        expect("€0,4".to_money("EU4")).to eq Money.new(4000, "EU4")
+      it 'parses strings respecting subunit to unit, decimal and thousands separator' do
+        expect('$0.4'.to_money('BAR')).to eq Money.new(4000, 'BAR')
+        expect('€0,4'.to_money('EU4')).to eq Money.new(4000, 'EU4')
 
-        expect("$0.04".to_money("BAR")).to eq Money.new(400, "BAR")
-        expect("€0,04".to_money("EU4")).to eq Money.new(400, "EU4")
+        expect('$0.04'.to_money('BAR')).to eq Money.new(400, 'BAR')
+        expect('€0,04'.to_money('EU4')).to eq Money.new(400, 'EU4')
 
-        expect("$0.004".to_money("BAR")).to eq Money.new(40, "BAR")
-        expect("€0,004".to_money("EU4")).to eq Money.new(40, "EU4")
+        expect('$0.004'.to_money('BAR')).to eq Money.new(40, 'BAR')
+        expect('€0,004'.to_money('EU4')).to eq Money.new(40, 'EU4')
 
-        expect("$0.0004".to_money("BAR")).to eq Money.new(4, "BAR")
-        expect("€0,0004".to_money("EU4")).to eq Money.new(4, "EU4")
+        expect('$0.0004'.to_money('BAR')).to eq Money.new(4, 'BAR')
+        expect('€0,0004'.to_money('EU4')).to eq Money.new(4, 'EU4')
 
-        expect("$0.0024".to_money("BAR")).to eq Money.new(24, "BAR")
-        expect("€0,0024".to_money("EU4")).to eq Money.new(24, "EU4")
+        expect('$0.0024'.to_money('BAR')).to eq Money.new(24, 'BAR')
+        expect('€0,0024'.to_money('EU4')).to eq Money.new(24, 'EU4')
 
-        expect("$0.0324".to_money("BAR")).to eq Money.new(324, "BAR")
-        expect("€0,0324".to_money("EU4")).to eq Money.new(324, "EU4")
+        expect('$0.0324'.to_money('BAR')).to eq Money.new(324, 'BAR')
+        expect('€0,0324'.to_money('EU4')).to eq Money.new(324, 'EU4')
 
-        expect("$0.5324".to_money("BAR")).to eq Money.new(5324, "BAR")
-        expect("€0,5324".to_money("EU4")).to eq Money.new(5324, "EU4")
+        expect('$0.5324'.to_money('BAR')).to eq Money.new(5324, 'BAR')
+        expect('€0,5324'.to_money('EU4')).to eq Money.new(5324, 'EU4')
 
-        expect("$6.5324".to_money("BAR")).to eq Money.new(65324, "BAR")
-        expect("€6,5324".to_money("EU4")).to eq Money.new(65324, "EU4")
+        # Following currencies consider 4 decimal places
+        # rubocop:disable Style/NumericLiterals
+        expect('$6.5324'.to_money('BAR')).to eq Money.new(6_5324, 'BAR')
+        expect('€6,5324'.to_money('EU4')).to eq Money.new(6_5324, 'EU4')
 
-        expect("$86.5324".to_money("BAR")).to eq Money.new(865324, "BAR")
-        expect("€86,5324".to_money("EU4")).to eq Money.new(865324, "EU4")
+        expect('$86.5324'.to_money('BAR')).to eq Money.new(86_5324, 'BAR')
+        expect('€86,5324'.to_money('EU4')).to eq Money.new(86_5324, 'EU4')
 
-        expect("$186.5324".to_money("BAR")).to eq Money.new(1865324, "BAR")
-        expect("€186,5324".to_money("EU4")).to eq Money.new(1865324, "EU4")
+        expect('$186.5324'.to_money('BAR')).to eq Money.new(186_5324, 'BAR')
+        expect('€186,5324'.to_money('EU4')).to eq Money.new(186_5324, 'EU4')
 
-        expect("$3,331.0034".to_money("BAR")).to eq Money.new(33310034, "BAR")
-        expect("€3.331,0034".to_money("EU4")).to eq Money.new(33310034, "EU4")
+        expect('$3,331.0034'.to_money('BAR')).to eq Money.new(3_331_0034, 'BAR')
+        expect('€3.331,0034'.to_money('EU4')).to eq Money.new(3_331_0034, 'EU4')
 
-        expect("$8,883,331.0034".to_money("BAR")).to eq Money.new(88833310034, "BAR")
-        expect("€8.883.331,0034".to_money("EU4")).to eq Money.new(88833310034, "EU4")
+        expect('$8,883,331.0034'.to_money('BAR')).to eq Money.new(8_883_331_0034, 'BAR')
+        expect('€8.883.331,0034'.to_money('EU4')).to eq Money.new(8_883_331_0034, 'EU4')
+        # rubocop:enable Style/NumericLiterals
       end
     end
   end
 
-  describe ".parse_collection" do
-    it "parses into a Money::Collection" do
-      expect(Monetize.parse_collection("$7")).to be_a Monetize::Collection
+  describe '.parse_collection' do
+    it 'parses into a Money::Collection' do
+      expect(Monetize.parse_collection('$7')).to be_a Monetize::Collection
     end
 
-    it "parses comma separated values" do
-      collection = Monetize.parse_collection("$5, $7")
-      expect(collection.first).to eq Monetize.parse("$5")
-      expect(collection.last).to eq Monetize.parse("$7")
+    it 'parses comma separated values' do
+      collection = Monetize.parse_collection('$5, $7')
+      expect(collection.first).to eq Monetize.parse('$5')
+      expect(collection.last).to eq Monetize.parse('$7')
     end
 
-    it "parses slash separated values" do
-      collection = Monetize.parse_collection("£4.50/€6")
-      expect(collection.first).to eq Monetize.parse("£4.50")
-      expect(collection.last).to eq Monetize.parse("€6")
+    it 'parses slash separated values' do
+      collection = Monetize.parse_collection('£4.50/€6')
+      expect(collection.first).to eq Monetize.parse('£4.50')
+      expect(collection.last).to eq Monetize.parse('€6')
     end
 
-    it "parses hyphens as ranges" do
-      collection = Monetize.parse_collection("$4 - $10")
-      expect(collection.first).to eq Monetize.parse("$4")
-      expect(collection.last).to eq Monetize.parse("$10")
+    it 'parses hyphens as ranges' do
+      collection = Monetize.parse_collection('$4 - $10')
+      expect(collection.first).to eq Monetize.parse('$4')
+      expect(collection.last).to eq Monetize.parse('$10')
     end
   end
 
-  describe ".from_string" do
-    it "converts given amount to cents" do
-      expect(Monetize.from_string("1")).to eq Money.new(1_00)
-      expect(Monetize.from_string("1")).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_string("1", "EUR")).to eq Money.new(1_00, "EUR")
+  describe '.from_string' do
+    it 'converts given amount to cents' do
+      expect(Monetize.from_string('1')).to eq Money.new(1_00)
+      expect(Monetize.from_string('1')).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_string('1', 'EUR')).to eq Money.new(1_00, 'EUR')
     end
 
-    it "respects :subunit_to_unit currency property" do
-      expect(Monetize.from_string("1", "USD")).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_string("1", "TND")).to eq Money.new(1_000, "TND")
-      expect(Monetize.from_string("1", "JPY")).to eq Money.new(1, "JPY")
+    it 'respects :subunit_to_unit currency property' do
+      expect(Monetize.from_string('1', 'USD')).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_string('1', 'TND')).to eq Money.new(1_000, 'TND')
+      expect(Monetize.from_string('1', 'JPY')).to eq Money.new(1, 'JPY')
     end
 
-    it "accepts a currency options" do
-      m = Monetize.from_string("1")
+    it 'accepts a currency options' do
+      m = Monetize.from_string('1')
       expect(m.currency).to eq Money.default_currency
 
-      m = Monetize.from_string("1", Money::Currency.wrap("EUR"))
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_string('1', Money::Currency.wrap('EUR'))
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
 
-      m = Monetize.from_string("1", "EUR")
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_string('1', 'EUR')
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
   end
 
-  describe ".from_fixnum" do
-    it "converts given amount to cents" do
+  describe '.from_fixnum' do
+    it 'converts given amount to cents' do
       expect(Monetize.from_fixnum(1)).to eq Money.new(1_00)
-      expect(Monetize.from_fixnum(1)).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_fixnum(1, "EUR")).to eq Money.new(1_00, "EUR")
+      expect(Monetize.from_fixnum(1)).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_fixnum(1, 'EUR')).to eq Money.new(1_00, 'EUR')
     end
 
-    it "should respect :subunit_to_unit currency property" do
-      expect(Monetize.from_fixnum(1, "USD")).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_fixnum(1, "TND")).to eq Money.new(1_000, "TND")
-      expect(Monetize.from_fixnum(1, "JPY")).to eq Money.new(1, "JPY")
+    it 'should respect :subunit_to_unit currency property' do
+      expect(Monetize.from_fixnum(1, 'USD')).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_fixnum(1, 'TND')).to eq Money.new(1_000, 'TND')
+      expect(Monetize.from_fixnum(1, 'JPY')).to eq Money.new(1, 'JPY')
     end
 
-    it "accepts a currency options" do
+    it 'accepts a currency options' do
       m = Monetize.from_fixnum(1)
       expect(m.currency).to eq Money.default_currency
 
-      m = Monetize.from_fixnum(1, Money::Currency.wrap("EUR"))
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_fixnum(1, Money::Currency.wrap('EUR'))
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
 
-      m = Monetize.from_fixnum(1, "EUR")
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_fixnum(1, 'EUR')
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
   end
 
-  describe ".from_float" do
-    it "converts given amount to cents" do
+  describe '.from_float' do
+    it 'converts given amount to cents' do
       expect(Monetize.from_float(1.2)).to eq Money.new(1_20)
-      expect(Monetize.from_float(1.2)).to eq Money.new(1_20, "USD")
-      expect(Monetize.from_float(1.2, "EUR")).to eq Money.new(1_20, "EUR")
+      expect(Monetize.from_float(1.2)).to eq Money.new(1_20, 'USD')
+      expect(Monetize.from_float(1.2, 'EUR')).to eq Money.new(1_20, 'EUR')
     end
 
-    it "respects :subunit_to_unit currency property" do
-      expect(Monetize.from_float(1.2, "USD")).to eq Money.new(1_20, "USD")
-      expect(Monetize.from_float(1.2, "TND")).to eq Money.new(1_200, "TND")
-      expect(Monetize.from_float(1.2, "JPY")).to eq Money.new(1, "JPY")
+    it 'respects :subunit_to_unit currency property' do
+      expect(Monetize.from_float(1.2, 'USD')).to eq Money.new(1_20, 'USD')
+      expect(Monetize.from_float(1.2, 'TND')).to eq Money.new(1_200, 'TND')
+      expect(Monetize.from_float(1.2, 'JPY')).to eq Money.new(1, 'JPY')
     end
 
-    it "accepts a currency options" do
+    it 'accepts a currency options' do
       m = Monetize.from_float(1.2)
       expect(m.currency).to eq Money.default_currency
 
-      m = Monetize.from_float(1.2, Money::Currency.wrap("EUR"))
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_float(1.2, Money::Currency.wrap('EUR'))
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
 
-      m = Monetize.from_float(1.2, "EUR")
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_float(1.2, 'EUR')
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
   end
 
-  describe ".from_bigdecimal" do
-    it "converts given amount to cents" do
-      expect(Monetize.from_bigdecimal(BigDecimal.new("1"))).to eq Money.new(1_00)
-      expect(Monetize.from_bigdecimal(BigDecimal.new("1"))).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "EUR")).to eq Money.new(1_00, "EUR")
+  describe '.from_bigdecimal' do
+    it 'converts given amount to cents' do
+      expect(Monetize.from_bigdecimal(BigDecimal.new('1'))).to eq Money.new(1_00)
+      expect(Monetize.from_bigdecimal(BigDecimal.new('1'))).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'EUR')).to eq Money.new(1_00, 'EUR')
     end
 
-    it "respects :subunit_to_unit currency property" do
-      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "USD")).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "TND")).to eq Money.new(1_000, "TND")
-      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "JPY")).to eq Money.new(1, "JPY")
+    it 'respects :subunit_to_unit currency property' do
+      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'USD')).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'TND')).to eq Money.new(1_000, 'TND')
+      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'JPY')).to eq Money.new(1, 'JPY')
     end
 
-    it "accepts a currency options" do
-      m = Monetize.from_bigdecimal(BigDecimal.new("1"))
+    it 'accepts a currency options' do
+      m = Monetize.from_bigdecimal(BigDecimal.new('1'))
       expect(m.currency).to eq Money.default_currency
 
-      m = Monetize.from_bigdecimal(BigDecimal.new("1"), Money::Currency.wrap("EUR"))
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_bigdecimal(BigDecimal.new('1'), Money::Currency.wrap('EUR'))
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
 
-      m = Monetize.from_bigdecimal(BigDecimal.new("1"), "EUR")
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_bigdecimal(BigDecimal.new('1'), 'EUR')
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
 
-    context "infinite_precision = true" do
+    context 'infinite_precision = true' do
       before do
         Money.infinite_precision = true
       end
@@ -364,66 +397,74 @@ describe Monetize do
         Money.infinite_precision = false
       end
 
-      it "keeps precision" do
-        expect(Monetize.from_bigdecimal(BigDecimal.new("1.23456"))).to eq Money.new(123.456)
-        expect(Monetize.from_bigdecimal(BigDecimal.new("-1.23456"))).to eq Money.new(-123.456)
-        expect(Monetize.from_bigdecimal(BigDecimal.new("1.23456"))).to eq Money.new(123.456, "USD")
-        expect(Monetize.from_bigdecimal(BigDecimal.new("1.23456"), "EUR")).to eq Money.new(123.456, "EUR")
+      it 'keeps precision' do
+        expect(Monetize.from_bigdecimal(BigDecimal.new('1'))).to eq Money.new(100)
+        expect(Monetize.from_bigdecimal(BigDecimal.new('1.23456'))).to eq Money.new(123.456)
+        expect(Monetize.from_bigdecimal(BigDecimal.new('-1.23456'))).to eq Money.new(-123.456)
+        expect(Monetize.from_bigdecimal(BigDecimal.new('1.23456'))).to eq Money.new(123.456, 'USD')
+        expect(Monetize.from_bigdecimal(BigDecimal.new('1.23456'), 'EUR')).to eq Money.new(123.456, 'EUR')
+
+        expect('1'.to_money).to eq Money.new(100)
+        expect('1.23456'.to_money).to eq Money.new(123.456)
+        expect('-1.23456'.to_money).to eq Money.new(-123.456)
+        expect('$1.23456'.to_money).to eq Money.new(123.456, 'USD')
+        expect('1.23456 EUR'.to_money).to eq Money.new(123.456, 'EUR')
       end
     end
   end
 
-  describe ".from_numeric" do
-    it "converts given amount to cents" do
+  describe '.from_numeric' do
+    it 'converts given amount to cents' do
       expect(Monetize.from_numeric(1)).to eq Money.new(1_00)
       expect(Monetize.from_numeric(1.0)).to eq Money.new(1_00)
-      expect(Monetize.from_numeric(BigDecimal.new("1"))).to eq Money.new(1_00)
+      expect(Monetize.from_numeric(BigDecimal.new('1'))).to eq Money.new(1_00)
     end
 
-    it "raises ArgumentError with unsupported argument" do
-      expect { Monetize.from_numeric("100") }.to raise_error(ArgumentError)
+    it 'raises ArgumentError with unsupported argument' do
+      expect { Monetize.from_numeric('100') }.to raise_error(ArgumentError)
     end
 
-    it "optimizes workload" do
-      expect(Monetize).to receive(:from_fixnum).with(1, "USD").and_return(Money.new(1_00, "USD"))
-      expect(Monetize.from_numeric(1, "USD")).to eq Money.new(1_00, "USD")
-      expect(Monetize).to receive(:from_bigdecimal).with(BigDecimal.new("1.0"), "USD").and_return(Money.new(1_00, "USD"))
-      expect(Monetize.from_numeric(1.0, "USD")).to eq Money.new(1_00, "USD")
+    it 'optimizes workload' do
+      expect(Monetize).to receive(:from_fixnum).with(1, 'USD').and_return(Money.new(1_00, 'USD'))
+      expect(Monetize.from_numeric(1, 'USD')).to eq Money.new(1_00, 'USD')
+      expect(Monetize).to receive(:from_bigdecimal).with(BigDecimal.new('1.0'), 'USD').
+        and_return(Money.new(1_00, 'USD'))
+      expect(Monetize.from_numeric(1.0, 'USD')).to eq Money.new(1_00, 'USD')
     end
 
-    it "respects :subunit_to_unit currency property" do
-      expect(Monetize.from_numeric(1, "USD")).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_numeric(1, "TND")).to eq Money.new(1_000, "TND")
-      expect(Monetize.from_numeric(1, "JPY")).to eq Money.new(1, "JPY")
+    it 'respects :subunit_to_unit currency property' do
+      expect(Monetize.from_numeric(1, 'USD')).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_numeric(1, 'TND')).to eq Money.new(1_000, 'TND')
+      expect(Monetize.from_numeric(1, 'JPY')).to eq Money.new(1, 'JPY')
     end
 
-    it "accepts a bank option" do
+    it 'accepts a bank option' do
       expect(Monetize.from_numeric(1)).to eq Money.new(1_00)
-      expect(Monetize.from_numeric(1)).to eq Money.new(1_00, "USD")
-      expect(Monetize.from_numeric(1, "EUR")).to eq Money.new(1_00, "EUR")
+      expect(Monetize.from_numeric(1)).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_numeric(1, 'EUR')).to eq Money.new(1_00, 'EUR')
     end
 
-    it "accepts a currency options" do
+    it 'accepts a currency options' do
       m = Monetize.from_numeric(1)
       expect(m.currency).to eq Money.default_currency
 
-      m = Monetize.from_numeric(1, Money::Currency.wrap("EUR"))
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_numeric(1, Money::Currency.wrap('EUR'))
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
 
-      m = Monetize.from_numeric(1, "EUR")
-      expect(m.currency).to eq Money::Currency.wrap("EUR")
+      m = Monetize.from_numeric(1, 'EUR')
+      expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
   end
 
-  describe ".extract_cents" do
+  describe '.extract_cents' do
     it "correctly treats pipe marks '|' in input (regression test)" do
       expect(Monetize.extract_cents('100|0')).to eq Monetize.extract_cents('100!0')
     end
   end
 
-  context "given the same inputs to .parse and .from_*" do
-    it "gives the same results" do
-      expect(4.635.to_money).to eq "4.635".to_money
+  context 'given the same inputs to .parse and .from_*' do
+    it 'gives the same results' do
+      expect(4.635.to_money).to eq '4.635'.to_money
     end
   end
 end