money 6.7.1 → 6.13.0

data/lib/money/money/locale_backend.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+require 'money/locale_backend/errors'
+require 'money/locale_backend/legacy'
+require 'money/locale_backend/i18n'
+
+class Money
+  module LocaleBackend
+    BACKENDS = {
+      legacy: Money::LocaleBackend::Legacy,
+      i18n: Money::LocaleBackend::I18n
+    }.freeze
+
+    def self.find(name)
+      raise Unknown, "Unknown locale backend: #{name}" unless BACKENDS.key?(name)
+
+      BACKENDS[name].new
+    end
+  end
+end

data/lib/money/rates_store/memory.rb

@@ -58,10 +58,9 @@ class Money
       end
 
       def marshal_dump
-        [self.class, index, options]
+        [self.class, options, index]
       end
 
-
       # Wraps block execution in a thread-safe transaction
       def transaction(&block)
         if @in_transaction || options[:without_mutex]

data/lib/money/version.rb

@@ -1,3 +1,3 @@
 class Money
-  VERSION = "6.7.1"
+  VERSION = '6.13.0'
 end

data/money.gemspec

@@ -9,33 +9,27 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Shane Emmons"]
   s.email       = ["shane@emmons.io"]
-  s.homepage    = "http://rubymoney.github.io/money"
+  s.homepage    = "https://rubymoney.github.io/money"
   s.summary     = "A Ruby Library for dealing with money and currency conversion."
   s.description = "A Ruby Library for dealing with money and currency conversion."
   s.license     = "MIT"
 
-  s.post_install_message = <<MSG
-Please note the following API changes in Money version 6
-
- - Money#amount, Money#dollars methods now return instances of BigDecimal (rather than Float).
-
-Please read the migration notes at https://github.com/RubyMoney/money#migration-notes
-and choose the migration that best suits your application.
-
-Test responsibly :-)
-MSG
-
-  s.add_dependency 'i18n', ['>= 0.6.4', '<= 0.7.0']
-  s.add_dependency 'sixarm_ruby_unaccent', ['>= 1.1.1', '< 2']
+  s.add_dependency 'i18n', [">= 0.6.4", '<= 2']
 
   s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", "~> 3.4.0"
-  s.add_development_dependency "yard", "~> 0.8"
+  s.add_development_dependency "rspec", "~> 3.4"
+  s.add_development_dependency "yard", "~> 0.9.11"
   s.add_development_dependency "kramdown", "~> 1.1"
 
   s.files         = `git ls-files`.split($/)
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
+
+  if s.respond_to?(:metadata)
+    s.metadata['changelog_uri'] = 'https://github.com/RubyMoney/money/blob/master/CHANGELOG.md'
+    s.metadata['source_code_uri'] = 'https://github.com/RubyMoney/money/'
+    s.metadata['bug_tracker_uri'] = 'https://github.com/RubyMoney/money/issues'
+  end
 end

data/spec/bank/variable_exchange_spec.rb

@@ -75,6 +75,10 @@ class Money
               special_money_class = Class.new(Money)
               expect(bank.exchange_with(special_money_class.new(100, 'USD'), 'EUR')).to be_a special_money_class
             end
+
+            it "doesn't loose precision when handling larger amounts" do
+              expect(bank.exchange_with(Money.new(100_000_000_000_000_01, 'USD'), 'EUR')).to eq Money.new(133_000_000_000_000_01, 'EUR')
+            end
           end
         end
 
@@ -147,7 +151,7 @@ class Money
 
         it "delegates options to store, options are a no-op" do
           expect(subject.store).to receive(:get_rate).with('USD', 'EUR')
-          subject.get_rate('USD', 'EUR', :without_mutex => true)
+          subject.get_rate('USD', 'EUR', without_mutex: true)
         end
       end
 
@@ -197,7 +201,7 @@ class Money
 
         it "delegates execution to store, options are a no-op" do
           expect(subject.store).to receive(:transaction)
-          subject.export_rates(:yaml, nil, :foo => 1)
+          subject.export_rates(:yaml, nil, foo: 1)
         end
 
       end
@@ -239,7 +243,7 @@ class Money
         it "delegates execution to store#transaction" do
           expect(subject.store).to receive(:transaction)
           s = "--- \nUSD_TO_EUR: 1.25\nUSD_TO_JPY: 2.55\n"
-          subject.import_rates(:yaml, s, :foo => 1)
+          subject.import_rates(:yaml, s, foo: 1)
         end
 
       end

data/spec/currency/heuristics_spec.rb

@@ -4,159 +4,8 @@ describe Money::Currency::Heuristics do
   describe "#analyze_string" do
     let(:it) { Money::Currency }
 
-    it "is not affected by blank characters and numbers" do
-      expect(it.analyze('123')).to eq []
-      expect(it.analyze('\n123 \t')).to eq []
-    end
-
-    it "returns nothing when given nothing" do
-      expect(it.analyze('')).to eq []
-      expect(it.analyze(nil)).to eq []
-    end
-
-    it "finds a currency by use of its symbol" do
-      expect(it.analyze('zł')).to eq ['PLN']
-    end
-
-    it "is not affected by trailing dot" do
-      expect(it.analyze('zł.')).to eq ['PLN']
-    end
-
-    it "finds match even if has numbers after" do
-      expect(it.analyze('zł 123')).to eq ['PLN']
-    end
-
-    it "finds match even if has numbers before" do
-      expect(it.analyze('123 zł')).to eq ['PLN']
-    end
-
-    it "find match even if symbol is next to number" do
-      expect(it.analyze('300zł')).to eq ['PLN']
-    end
-
-    it "finds match even if has numbers with delimiters" do
-      expect(it.analyze('zł 123,000.50')).to eq ['PLN']
-      expect(it.analyze('zł123,000.50')).to eq ['PLN']
-    end
-
-    it "finds currencies with dots in symbols" do
-      expect(it.analyze('L.E.')).to eq ['EGP']
-    end
-
-    it "finds by name" do
-      expect(it.analyze('1900 bulgarian lev')).to eq ['BGN']
-      expect(it.analyze('Swedish Krona')).to eq ['SEK']
-    end
-
-    it "Finds several currencies when several match" do
-      r = it.analyze('$400')
-      expect(r).to include("ARS")
-      expect(r).to include("USD")
-      expect(r).to include("NZD")
-
-      r = it.analyze('9000 £')
-      expect(r).to include("GBP")
-      expect(r).to include("SHP")
-      expect(r).to include("SYP")
-    end
-
-    it "should use alternate symbols" do
-      expect(it.analyze('US$')).to eq ['USD']
-    end
-
-    it "finds a currency by use of its iso code" do
-      expect(it.analyze('USD 200')).to eq ['USD']
-    end
-
-    it "finds currencies in the middle of a sentence!" do
-      expect(it.analyze('It would be nice to have 10000 Albanian lek by tomorrow!')).to eq ['ALL']
-    end
-
-    it "finds several currencies in the same text!" do
-      expect(it.analyze("10EUR is less than 100:- but really, I want US$1")).to eq ['EUR', 'SEK', 'USD']
-    end
-
-    it "find currencies with normal characters in name using unaccent" do
-      expect(it.analyze("10 Nicaraguan Cordoba")).to eq ["NIO"]
-    end
-
-    it "find currencies with special characters in name using unaccent" do
-      expect(it.analyze("10 Nicaraguan Córdoba")).to eq ["NIO"]
-    end
-
-    it "find currencies with special symbols using unaccent" do
-      expect(it.analyze("ل.س")).not_to eq []
-      expect(it.analyze("R₣")).not_to eq []
-      expect(it.analyze("ரூ")).not_to eq []
-      expect(it.analyze("රු")).not_to eq []
-      expect(it.analyze("сом")).not_to eq []
-      expect(it.analyze("圓")).not_to eq []
-      expect(it.analyze("円")).not_to eq []
-      expect(it.analyze("৳")).not_to eq []
-      expect(it.analyze("૱")).not_to eq []
-      expect(it.analyze("௹")).not_to eq []
-      expect(it.analyze("रु")).not_to eq []
-      expect(it.analyze("ש״ח")).not_to eq []
-      expect(it.analyze("元")).not_to eq []
-      expect(it.analyze("¢")).not_to eq []
-      expect(it.analyze("£")).not_to eq [] 
-      expect(it.analyze("€")).not_to eq []
-      expect(it.analyze("¥")).not_to eq []
-      expect(it.analyze("د.إ")).not_to eq []
-      expect(it.analyze("؋")).not_to eq []
-      expect(it.analyze("դր.")).not_to eq []
-      expect(it.analyze("ƒ")).not_to eq []
-      expect(it.analyze("₼")).not_to eq []
-      expect(it.analyze("৳")).not_to eq []
-      expect(it.analyze("лв")).not_to eq []
-      expect(it.analyze("лев")).not_to eq []
-      expect(it.analyze("дин")).not_to eq []
-      expect(it.analyze("ب.د")).not_to eq []
-      expect(it.analyze("₡")).not_to eq []
-      expect(it.analyze("Kč")).not_to eq []
-      expect(it.analyze("د.ج")).not_to eq []
-      expect(it.analyze("ج.م")).not_to eq []
-      expect(it.analyze("ლ")).not_to eq []
-      expect(it.analyze("₵")).not_to eq []
-      expect(it.analyze("₪")).not_to eq []
-      expect(it.analyze("₹")).not_to eq []
-      expect(it.analyze("ع.د")).not_to eq []
-      expect(it.analyze("﷼")).not_to eq []
-      expect(it.analyze("د.ا")).not_to eq []
-      expect(it.analyze("៛")).not_to eq []
-      expect(it.analyze("₩")).not_to eq []
-      expect(it.analyze("د.ك")).not_to eq []
-      expect(it.analyze("〒")).not_to eq []
-      expect(it.analyze("₭")).not_to eq []
-      expect(it.analyze("ل.ل")).not_to eq []
-      expect(it.analyze("₨")).not_to eq []
-      expect(it.analyze("ل.د")).not_to eq []
-      expect(it.analyze("د.م.")).not_to eq []
-      expect(it.analyze("ден")).not_to eq []
-      expect(it.analyze("₮")).not_to eq []
-      expect(it.analyze("₦")).not_to eq []
-      expect(it.analyze("C$")).not_to eq []
-      expect(it.analyze("ر.ع.")).not_to eq []
-      expect(it.analyze("₱")).not_to eq []
-      expect(it.analyze("zł")).not_to eq []
-      expect(it.analyze("₲")).not_to eq []
-      expect(it.analyze("ر.ق")).not_to eq []
-      expect(it.analyze("РСД")).not_to eq []
-      expect(it.analyze("₽")).not_to eq []
-      expect(it.analyze("ر.س")).not_to eq []
-      expect(it.analyze("฿")).not_to eq []
-      expect(it.analyze("د.ت")).not_to eq []
-      expect(it.analyze("T$")).not_to eq []
-      expect(it.analyze("₺")).not_to eq []
-      expect(it.analyze("₴")).not_to eq []
-      expect(it.analyze("₫")).not_to eq []
-      expect(it.analyze("B⃦")).not_to eq []
-      expect(it.analyze("₤")).not_to eq []
-      expect(it.analyze("ރ")).not_to eq []
-    end
-
-    it "should function with unicode characters" do
-      expect(it.analyze("10 դր.")).to eq ["AMD"]
+    it "it raises deprecation error" do
+      expect{ it.analyze('123') }.to raise_error(StandardError, 'Heuristics deprecated, add `gem "money-heuristics"` to Gemfile')
     end
   end
 end

data/spec/currency_spec.rb

@@ -6,7 +6,7 @@ class Money
     FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 1000, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": ",", "smallest_denomination": 1 }'
 
     def register_foo(opts={})
-      foo_attrs = JSON.parse(FOO, :symbolize_names => true)
+      foo_attrs = JSON.parse(FOO, symbolize_names: true)
       # Pass an array of attribute names to 'skip' to remove them from the 'FOO'
       # json before registering foo as a currency.
       Array(opts[:skip]).each { |attr| foo_attrs.delete(attr) }
@@ -14,7 +14,7 @@ class Money
     end
 
     def unregister_foo
-      Currency.unregister(JSON.parse(FOO, :symbolize_names => true))
+      Currency.unregister(JSON.parse(FOO, symbolize_names: true))
     end
 
     describe "UnknownCurrency" do
@@ -59,6 +59,11 @@ class Money
         expect(Currency.find_by_iso_numeric('non iso 4217 numeric code')).to be_nil
         expect(Currency.find_by_iso_numeric(0)).to be_nil
       end
+
+      it "returns nil when given empty input" do
+        expect(Currency.find_by_iso_numeric('')).to be_nil
+        expect(Currency.find_by_iso_numeric(nil)).to be_nil
+      end
     end
 
     describe ".wrap" do
@@ -82,7 +87,7 @@ class Money
         expect(Currency.all.first.priority).to eq 1
       end
       it "raises a MissingAttributeError if any currency has no priority" do
-        register_foo(:skip => :priority)
+        register_foo(skip: :priority)
 
         expect{Money::Currency.all}.to \
           raise_error(Money::Currency::MissingAttributeError, /foo.*priority/)
@@ -115,6 +120,32 @@ class Money
     end
 
 
+    describe ".inherit" do
+      after do
+        Currency.unregister(iso_code: "XXX") if Currency.find("XXX")
+        Currency.unregister(iso_code: "YYY") if Currency.find("YYY")
+      end
+
+      it "inherit a new currency" do
+        Currency.register(
+          iso_code: "XXX",
+          name: "Golden Doubloon",
+          symbol: "%",
+          subunit_to_unit: 100
+        )
+        Currency.inherit("XXX",
+          iso_code: "YYY",
+          symbol: "@"
+        )
+        new_currency = Currency.find("YYY")
+        expect(new_currency).not_to be_nil
+        expect(new_currency.name).to eq "Golden Doubloon"
+        expect(new_currency.symbol).to eq "@"
+        expect(new_currency.subunit_to_unit).to eq 100
+      end
+    end
+
+
     describe ".unregister" do
       it "unregisters a currency" do
         Currency.register(iso_code: "XXX")
@@ -295,6 +326,16 @@ class Money
       end
     end
 
+    describe "#iso?" do
+      it "returns true for iso currency" do
+        expect(Money::Currency.new(:eur).iso?).to be true
+      end
+
+      it "returns false if the currency is not iso" do
+        expect(Money::Currency.new(:btc).iso?).to be false
+      end
+    end
+
     describe "#to_s" do
       it "works as documented" do
         expect(Currency.new(:usd).to_s).to eq("USD")

data/spec/locale_backend/i18n_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+describe Money::LocaleBackend::I18n do
+  describe '#initialize' do
+    it 'raises an error when I18n is not defined' do
+      hide_const('I18n')
+
+      expect { described_class.new }.to raise_error(Money::LocaleBackend::NotSupported)
+    end
+  end
+
+  describe '#lookup' do
+    after do
+      reset_i18n
+      I18n.locale = :en
+    end
+
+    subject { described_class.new }
+
+    context 'with number.currency.format defined' do
+      before do
+        I18n.locale = :de
+        I18n.backend.store_translations(:de, number: {
+          currency: { format: { delimiter: '.', separator: ',' } }
+        })
+      end
+
+      it 'returns thousands_separator based on the current locale' do
+        expect(subject.lookup(:thousands_separator, nil)).to eq('.')
+      end
+
+      it 'returns decimal_mark based on the current locale' do
+        expect(subject.lookup(:decimal_mark, nil)).to eq(',')
+      end
+    end
+
+    context 'with number.format defined' do
+      before do
+        I18n.locale = :de
+        I18n.backend.store_translations(:de, number: { format: { delimiter: '.', separator: ',' } })
+      end
+
+      it 'returns thousands_separator based on the current locale' do
+        expect(subject.lookup(:thousands_separator, nil)).to eq('.')
+      end
+
+      it 'returns decimal_mark based on the current locale' do
+        expect(subject.lookup(:decimal_mark, nil)).to eq(',')
+      end
+    end
+
+    context 'with no translation defined' do
+      it 'returns thousands_separator based on the current locale' do
+        expect(subject.lookup(:thousands_separator, nil)).to eq(nil)
+      end
+
+      it 'returns decimal_mark based on the current locale' do
+        expect(subject.lookup(:decimal_mark, nil)).to eq(nil)
+      end
+    end
+  end
+end

data/spec/locale_backend/legacy_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+describe Money::LocaleBackend::Legacy do
+  after { Money.use_i18n = true }
+
+  describe '#initialize' do
+    it 'raises an error when use_i18n is true and I18n is not defined' do
+      Money.use_i18n = true
+      hide_const('I18n')
+
+      expect { described_class.new }.to raise_error(Money::LocaleBackend::NotSupported)
+    end
+
+    it 'does not raise error when use_i18n is false and I18n is not defined' do
+      Money.use_i18n = false
+      hide_const('I18n')
+
+      expect { described_class.new }.not_to raise_error
+    end
+  end
+
+  describe '#lookup' do
+    subject { described_class.new }
+    let(:currency) { Money::Currency.new('USD') }
+
+    context 'use_i18n is true and i18n lookup is successful' do
+      before do
+        allow(subject.send(:i18n_backend))
+          .to receive(:lookup)
+          .with(:thousands_separator, nil)
+          .and_return('.')
+
+        allow(subject.send(:i18n_backend))
+          .to receive(:lookup)
+          .with(:decimal_mark, nil)
+          .and_return(',')
+      end
+
+      it 'returns thousands_separator from I18n' do
+        expect(subject.lookup(:thousands_separator, currency)).to eq('.')
+      end
+
+      it 'returns decimal_mark based from I18n' do
+        expect(subject.lookup(:decimal_mark, currency)).to eq(',')
+      end
+    end
+
+    context 'use_i18n is true but i18n lookup is unsuccessful' do
+      before do
+        allow(subject.send(:i18n_backend)).to receive(:lookup).and_return(nil)
+      end
+
+      it 'returns thousands_separator as defined in currency' do
+        expect(subject.lookup(:thousands_separator, currency)).to eq(',')
+      end
+
+      it 'returns decimal_mark based as defined in currency' do
+        expect(subject.lookup(:decimal_mark, currency)).to eq('.')
+      end
+    end
+
+    context 'use_i18n is false' do
+      before { Money.use_i18n = false }
+
+      it 'returns thousands_separator as defined in currency' do
+        expect(subject.lookup(:thousands_separator, currency)).to eq(',')
+      end
+
+      it 'returns decimal_mark based as defined in currency' do
+        expect(subject.lookup(:decimal_mark, currency)).to eq('.')
+      end
+    end
+  end
+end