money 6.7.0 → 6.13.0

data/lib/money/money/formatting_rules.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+
+class Money
+  class FormattingRules
+    def initialize(currency, *raw_rules)
+      @currency = currency
+
+      # support for old format parameters
+      @rules = normalize_formatting_rules(raw_rules)
+
+      @rules = default_formatting_rules.merge(@rules) unless @rules[:ignore_defaults]
+      @rules = localize_formatting_rules(@rules)
+      @rules = translate_formatting_rules(@rules) if @rules[:translate]
+      @rules[:format] ||= determine_format_from_formatting_rules(@rules)
+
+      warn_about_deprecated_rules(@rules)
+    end
+
+    def [](key)
+      @rules[key]
+    end
+
+    def has_key?(key)
+      @rules.has_key? key
+    end
+
+    private
+
+    attr_reader :currency
+
+    # Cleans up formatting rules.
+    #
+    # @param [Hash] rules
+    #
+    # @return [Hash]
+    def normalize_formatting_rules(rules)
+      if rules.size == 0
+        rules = {}
+      elsif rules.size == 1
+        rules = rules.pop
+        rules = { rules => true } if rules.is_a?(Symbol)
+      end
+      if !rules.include?(:decimal_mark) && rules.include?(:separator)
+        rules[:decimal_mark] = rules[:separator]
+      end
+      if !rules.include?(:thousands_separator) && rules.include?(:delimiter)
+        rules[:thousands_separator] = rules[:delimiter]
+      end
+      rules
+    end
+
+    def default_formatting_rules
+      Money.default_formatting_rules || {}
+    end
+
+    def translate_formatting_rules(rules)
+      begin
+        rules[:symbol] = I18n.t currency.iso_code, scope: "number.currency.symbol", raise: true
+      rescue I18n::MissingTranslationData
+        # Do nothing
+      end
+      rules
+    end
+
+    def localize_formatting_rules(rules)
+      if currency.iso_code == "JPY" && I18n.locale == :ja
+        rules[:symbol] = "円" unless rules[:symbol] == false
+        rules[:format] = '%n%u'
+      end
+      rules
+    end
+
+    def determine_format_from_formatting_rules(rules)
+      symbol_position = symbol_position_from(rules)
+
+      if symbol_position == :before
+        rules.fetch(:symbol_before_without_space, true) ? '%u%n' : '%u %n'
+      else
+        rules[:symbol_after_without_space] ? '%n%u' : '%n %u'
+      end
+    end
+
+    def symbol_position_from(rules)
+      if rules.has_key?(:symbol_position)
+        if [:before, :after].include?(rules[:symbol_position])
+          return rules[:symbol_position]
+        else
+          raise ArgumentError, ":symbol_position must be ':before' or ':after'"
+        end
+      elsif currency.symbol_first?
+        :before
+      else
+        :after
+      end
+    end
+
+    def warn_about_deprecated_rules(rules)
+      if rules.has_key?(:symbol_position)
+        warn '[DEPRECATION] `symbol_position:` option is deprecated - use `format` to specify the formatting template.'
+      end
+
+      if rules.has_key?(:symbol_before_without_space)
+        warn '[DEPRECATION] `symbol_before_without_space:` option is deprecated - use `format` to specify the formatting template.'
+      end
+
+      if rules.has_key?(:symbol_after_without_space)
+        warn '[DEPRECATION] `symbol_after_without_space:` option is deprecated - use `format` to specify the formatting template.'
+      end
+
+      if rules.has_key?(:html)
+        warn "[DEPRECATION] `html` is deprecated - use `html_wrap` instead. Please note that `html_wrap` will wrap all parts of currency and if you use `with_currency` option, currency element class changes from `currency` to `money-currency`."
+      end
+
+      if rules.has_key?(:html_wrap_symbol)
+        warn "[DEPRECATION] `html_wrap_symbol` is deprecated - use `html_wrap` instead. Please note that `html_wrap` will wrap all parts of currency."
+      end
+
+    end
+  end
+end

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.0"
+  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")
@@ -291,7 +322,17 @@ class Money
 
     describe "#inspect" do
       it "works as documented" do
-        expect(Currency.new(:usd).inspect).to eq %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent, smallest_denomination: 1>}
+        expect(Currency.new(:usd).inspect).to eq %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2, iso_code: USD, iso_numeric: 840, subunit: Cent, smallest_denomination: 1>}
+      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