money 6.9.0 → 6.16.0

data/config/currency_non_iso.json

@@ -1,14 +1,31 @@
 {
+  "bch": {
+    "priority": 100,
+    "iso_code": "BCH",
+    "name": "Bitcoin Cash",
+    "symbol": "₿",
+    "disambiguate_symbol": "₿CH",
+    "alternate_symbols": ["BCH"],
+    "subunit": "Satoshi",
+    "subunit_to_unit": 100000000,
+    "symbol_first": false,
+    "format": "%n %u",
+    "html_entity": "₿",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
   "btc": {
     "priority": 100,
     "iso_code": "BTC",
     "name": "Bitcoin",
-    "symbol": "B⃦",
+    "symbol": "₿",
     "alternate_symbols": [],
     "subunit": "Satoshi",
     "subunit_to_unit": 100000000,
     "symbol_first": true,
-    "html_entity": "",
+    "html_entity": "₿",
     "decimal_mark": ".",
     "thousands_separator": ",",
     "iso_numeric": "",
@@ -93,5 +110,21 @@
     "thousands_separator": ",",
     "iso_numeric": "",
     "smallest_denomination": 1
+  },
+  "cnh": {
+    "priority": 100,
+    "iso_code": "CNH",
+    "name": "Chinese Renminbi Yuan Offshore",
+    "symbol": "¥",
+    "disambiguate_symbol": "CNH",
+    "alternate_symbols": ["CN¥", "元", "CN元"],
+    "subunit": "Fen",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "￥",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
   }
 }

data/lib/money/bank/variable_exchange.rb

@@ -42,12 +42,12 @@ class Money
     #   bank.get_rate 'USD', 'CAD'
     class VariableExchange < Base
 
-      attr_reader :mutex, :store
+      attr_reader :mutex
 
       # Available formats for importing/exporting rates.
       RATE_FORMATS = [:json, :ruby, :yaml].freeze
       SERIALIZER_SEPARATOR = '_TO_'.freeze
-      FORMAT_SERIALIZERS = {:json => JSON, :ruby => Marshal, :yaml => YAML}.freeze
+      FORMAT_SERIALIZERS = {json: JSON, ruby: Marshal, yaml: YAML}.freeze
 
       # Initializes a new +Money::Bank::VariableExchange+ object.
       # It defaults to using an in-memory, thread safe store instance for
@@ -61,6 +61,10 @@ class Money
         super(&block)
       end
 
+      def store
+        @store.is_a?(String) ? Object.const_get(@store) : @store
+      end
+
       def marshal_dump
         [store.marshal_dump, @rounding_method]
       end
@@ -109,8 +113,10 @@ class Money
         else
           if rate = get_rate(from.currency, to_currency)
             fractional = calculate_fractional(from, to_currency)
-            from.class.new(
-              exchange(fractional, rate, &block), to_currency
+            from.dup_with(
+              fractional: exchange(fractional, rate, &block),
+              currency: to_currency,
+              bank: self
             )
           else
             raise UnknownRate, "No conversion rate known for '#{from.currency.iso_code}' -> '#{to_currency}'"
@@ -119,14 +125,14 @@ class Money
       end
 
       def calculate_fractional(from, to_currency)
-        BigDecimal.new(from.fractional.to_s) / (
-          BigDecimal.new(from.currency.subunit_to_unit.to_s) /
-          BigDecimal.new(to_currency.subunit_to_unit.to_s)
+        BigDecimal(from.fractional.to_s) / (
+          BigDecimal(from.currency.subunit_to_unit.to_s) /
+          BigDecimal(to_currency.subunit_to_unit.to_s)
         )
       end
 
       def exchange(fractional, rate, &block)
-        ex = fractional * BigDecimal.new(rate.to_s)
+        ex = fractional * BigDecimal(rate.to_s)
         if block_given?
           yield ex
         elsif @rounding_method
@@ -213,8 +219,7 @@ class Money
       #   s = bank.export_rates(:json)
       #   s #=> "{\"USD_TO_CAD\":1.24515,\"CAD_TO_USD\":0.803115}"
       def export_rates(format, file = nil, opts = {})
-        raise Money::Bank::UnknownRateFormat unless
-          RATE_FORMATS.include? format
+        raise Money::Bank::UnknownRateFormat unless RATE_FORMATS.include?(format)
 
         store.transaction do
           s = FORMAT_SERIALIZERS[format].dump(rates)
@@ -254,8 +259,13 @@ class Money
       #   bank.get_rate("USD", "CAD") #=> 1.24515
       #   bank.get_rate("CAD", "USD") #=> 0.803115
       def import_rates(format, s, opts = {})
-        raise Money::Bank::UnknownRateFormat unless
-          RATE_FORMATS.include? format
+        raise Money::Bank::UnknownRateFormat unless RATE_FORMATS.include?(format)
+
+        if format == :ruby
+          warn '[WARNING] Using :ruby format when importing rates is potentially unsafe and ' \
+            'might lead to remote code execution via Marshal.load deserializer. Consider using ' \
+            'safe alternatives such as :json and :yaml.'
+        end
 
         store.transaction do
           data = FORMAT_SERIALIZERS[format].load(s)

data/lib/money/currency/loader.rb

@@ -3,21 +3,23 @@ class Money
     module Loader
       DATA_PATH = File.expand_path("../../../../config", __FILE__)
 
-      # Loads and returns the currencies stored in JSON files in the config directory.
-      #
-      # @return [Hash]
-      def load_currencies
-        currencies = parse_currency_file("currency_iso.json")
-        currencies.merge! parse_currency_file("currency_non_iso.json")
-        currencies.merge! parse_currency_file("currency_backwards_compatible.json")
-      end
+      class << self
+        # Loads and returns the currencies stored in JSON files in the config directory.
+        #
+        # @return [Hash]
+        def load_currencies
+          currencies = parse_currency_file("currency_iso.json")
+          currencies.merge! parse_currency_file("currency_non_iso.json")
+          currencies.merge! parse_currency_file("currency_backwards_compatible.json")
+        end
 
-      private
+        private
 
-      def parse_currency_file(filename)
-        json = File.read("#{DATA_PATH}/#{filename}")
-        json.force_encoding(::Encoding::UTF_8) if defined?(::Encoding)
-        JSON.parse(json, :symbolize_names => true)
+        def parse_currency_file(filename)
+          json = File.read("#{DATA_PATH}/#{filename}")
+          json.force_encoding(::Encoding::UTF_8) if defined?(::Encoding)
+          JSON.parse(json, symbolize_names: true)
+        end
       end
     end
   end

data/lib/money/currency.rb

@@ -13,7 +13,6 @@ class Money
   class Currency
     include Comparable
     extend Enumerable
-    extend Money::Currency::Loader
     extend Money::Currency::Heuristics
 
     # Keeping cached instances in sync between threads
@@ -76,10 +75,12 @@ class Money
       #
       # @example
       #   Money::Currency.find_by_iso_numeric(978) #=> #<Money::Currency id: eur ...>
+      #   Money::Currency.find_by_iso_numeric(51) #=> #<Money::Currency id: amd ...>
       #   Money::Currency.find_by_iso_numeric('001') #=> nil
       def find_by_iso_numeric(num)
-        num = num.to_s
-        id, _ = self.table.find{|key, currency| currency[:iso_numeric] == num}
+        num = num.to_s.rjust(3, '0')
+        return if num.empty?
+        id, _ = self.table.find { |key, currency| currency[:iso_numeric] == num }
         new(id)
       rescue UnknownCurrency
         nil
@@ -120,14 +121,14 @@ class Money
       # See https://en.wikipedia.org/wiki/List_of_circulating_currencies and
       # http://search.cpan.org/~tnguyen/Locale-Currency-Format-1.28/Format.pm
       def table
-        @table ||= load_currencies
+        @table ||= Loader.load_currencies
       end
 
       # List the currencies imported and registered
       # @return [Array]
       #
       # @example
-      #   Money::Currency.iso_codes()
+      #   Money::Currency.all()
       #   [#<Currency ..USD>, 'CAD', 'EUR']...
       def all
         table.keys.map do |curr|
@@ -170,9 +171,18 @@ class Money
         key = curr.fetch(:iso_code).downcase.to_sym
         @@mutex.synchronize { _instances.delete(key.to_s) }
         @table[key] = curr
-        @stringified_keys = stringify_keys
+        @stringified_keys = nil
       end
 
+      # Inherit a new currency from existing one
+      #
+      # @param parent_iso_code [String] the international 3-letter code as defined
+      # @param curr [Hash] See {register} method for hash structure
+      def inherit(parent_iso_code, curr)
+        parent_iso_code = parent_iso_code.downcase.to_sym
+        curr = @table.fetch(parent_iso_code, {}).merge(curr)
+        register(curr)
+      end
 
       # Unregister a currency.
       #
@@ -188,15 +198,18 @@ class Money
           key = curr.downcase.to_sym
         end
         existed = @table.delete(key)
-        @stringified_keys = stringify_keys if existed
+        @stringified_keys = nil if existed
         existed ? true : false
       end
 
-
       def each
         all.each { |c| yield(c) }
       end
 
+      def reset!
+        @@instances = {}
+        @table = Loader.load_currencies
+      end
 
       private
 
@@ -244,7 +257,7 @@ class Money
 
     attr_reader :id, :priority, :iso_code, :iso_numeric, :name, :symbol,
       :disambiguate_symbol, :html_entity, :subunit, :subunit_to_unit, :decimal_mark,
-      :thousands_separator, :symbol_first, :smallest_denomination
+      :thousands_separator, :symbol_first, :smallest_denomination, :format
 
     alias_method :separator, :decimal_mark
     alias_method :delimiter, :thousands_separator
@@ -332,7 +345,7 @@ class Money
     # @example
     #   Money::Currency.new(:usd) #=> #<Currency id: usd ...>
     def inspect
-      "#<#{self.class.name} id: #{id}, priority: #{priority}, symbol_first: #{symbol_first}, thousands_separator: #{thousands_separator}, html_entity: #{html_entity}, decimal_mark: #{decimal_mark}, name: #{name}, symbol: #{symbol}, subunit_to_unit: #{subunit_to_unit}, exponent: #{exponent}, iso_code: #{iso_code}, iso_numeric: #{iso_numeric}, subunit: #{subunit}, smallest_denomination: #{smallest_denomination}>"
+      "#<#{self.class.name} id: #{id}, priority: #{priority}, symbol_first: #{symbol_first}, thousands_separator: #{thousands_separator}, html_entity: #{html_entity}, decimal_mark: #{decimal_mark}, name: #{name}, symbol: #{symbol}, subunit_to_unit: #{subunit_to_unit}, exponent: #{exponent}, iso_code: #{iso_code}, iso_numeric: #{iso_numeric}, subunit: #{subunit}, smallest_denomination: #{smallest_denomination}, format: #{format}>"
     end
 
     # Returns a string representation corresponding to the upcase +id+
@@ -392,45 +405,30 @@ class Money
       !!@symbol_first
     end
 
-    # Returns the relation between subunit and unit as a base 10 exponent.
+    # Returns if a code currency is ISO.
     #
-    # Note that MGA and MRO are exceptions and are rounded to 1
-    # @see https://en.wikipedia.org/wiki/ISO_4217#Active_codes
+    # @return [Boolean]
     #
-    # @return [Integer]
-    def exponent
-      Math.log10(@subunit_to_unit).round
-    end
-
-    # Cache decimal places for subunit_to_unit values. Common ones pre-cached.
-    def self.decimal_places_cache
-      @decimal_places_cache ||= {1 => 0, 10 => 1, 100 => 2, 1000 => 3}
+    # @example
+    #   Money::Currency.new(:usd).iso?
+    #
+    def iso?
+      iso_numeric && iso_numeric != ''
     end
 
-    # The number of decimal places needed.
+    # Returns the relation between subunit and unit as a base 10 exponent.
+    #
+    # Note that MGA and MRU are exceptions and are rounded to 1
+    # @see https://en.wikipedia.org/wiki/ISO_4217#Active_codes
     #
     # @return [Integer]
-    def decimal_places
-      cache[subunit_to_unit] ||= calculate_decimal_places(subunit_to_unit)
+    def exponent
+      Math.log10(subunit_to_unit).round
     end
+    alias decimal_places exponent
 
     private
 
-    def cache
-      self.class.decimal_places_cache
-    end
-
-    # If we need to figure out how many decimal places we need we
-    # use repeated integer division.
-    def calculate_decimal_places(num)
-      i = 1
-      while num >= 10
-        num /= 10
-        i += 1 if num >= 10
-      end
-      i
-    end
-
     def initialize_data!
       data = self.class.table[@id]
       @alternate_symbols     = data[:alternate_symbols]
@@ -447,6 +445,7 @@ class Money
       @symbol                = data[:symbol]
       @symbol_first          = data[:symbol_first]
       @thousands_separator   = data[:thousands_separator]
+      @format                = data[:format]
     end
   end
 end

data/lib/money/locale_backend/base.rb

@@ -0,0 +1,7 @@
+require 'money/locale_backend/errors'
+
+class Money
+  module LocaleBackend
+    class Base; end
+  end
+end

data/lib/money/locale_backend/currency.rb

@@ -0,0 +1,11 @@
+require 'money/locale_backend/base'
+
+class Money
+  module LocaleBackend
+    class Currency < Base
+      def lookup(key, currency)
+        currency.public_send(key) if currency.respond_to?(key)
+      end
+    end
+  end
+end

data/lib/money/locale_backend/errors.rb

@@ -0,0 +1,6 @@
+class Money
+  module LocaleBackend
+    class NotSupported < StandardError; end
+    class Unknown < ArgumentError; end
+  end
+end

data/lib/money/locale_backend/i18n.rb

@@ -0,0 +1,25 @@
+require 'money/locale_backend/base'
+
+class Money
+  module LocaleBackend
+    class I18n < Base
+      KEY_MAP = {
+        thousands_separator: :delimiter,
+        decimal_mark: :separator,
+        symbol: :unit
+      }.freeze
+
+      def initialize
+        raise NotSupported, 'I18n not found' unless defined?(::I18n)
+      end
+
+      def lookup(key, _)
+        i18n_key = KEY_MAP[key]
+
+        ::I18n.t i18n_key, scope: 'number.currency.format', raise: true
+      rescue ::I18n::MissingTranslationData
+        ::I18n.t i18n_key, scope: 'number.format', default: nil
+      end
+    end
+  end
+end

data/lib/money/locale_backend/legacy.rb

@@ -0,0 +1,28 @@
+require 'money/locale_backend/base'
+require 'money/locale_backend/i18n'
+
+class Money
+  module LocaleBackend
+    class Legacy < Base
+      def initialize
+        raise NotSupported, 'I18n not found' if Money.use_i18n && !defined?(::I18n)
+      end
+
+      def lookup(key, currency)
+        warn '[DEPRECATION] You are using the default localization behaviour that will change in the next major release. Find out more - https://github.com/RubyMoney/money#deprecation'
+
+        if Money.use_i18n
+          i18n_backend.lookup(key, nil) || currency.public_send(key)
+        else
+          currency.public_send(key)
+        end
+      end
+
+      private
+
+      def i18n_backend
+        @i18n_backend ||= Money::LocaleBackend::I18n.new
+      end
+    end
+  end
+end

data/lib/money/money/allocation.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+class Money
+  class Allocation
+    # Splits a given amount in parts without losing pennies.
+    # The left-over pennies will be distributed round-robin amongst the parts. This means that
+    # parts listed first will likely receive more pennies than the ones listed later.
+    #
+    # The results should always add up to the original amount.
+    #
+    # The parts can be specified as:
+    #   Numeric — performs the split between a given number of parties evenely
+    #   Array<Numeric> — allocates the amounts proportionally to the given array
+    #
+    def self.generate(amount, parts, whole_amounts = true)
+      parts = if parts.is_a?(Numeric)
+        Array.new(parts, 1)
+      elsif parts.all?(&:zero?)
+        Array.new(parts.count, 1)
+      else
+        parts.dup
+      end
+
+      raise ArgumentError, 'need at least one party' if parts.empty?
+
+      result = []
+      remaining_amount = amount
+
+      until parts.empty? do
+        parts_sum = parts.inject(0, :+)
+        part = parts.pop
+
+        current_split = 0
+        if parts_sum > 0
+          current_split = remaining_amount * part / parts_sum
+          current_split = current_split.truncate if whole_amounts
+        end
+
+        result.unshift current_split
+        remaining_amount -= current_split
+      end
+
+      result
+    end
+  end
+end

data/lib/money/money/arithmetic.rb

@@ -16,7 +16,7 @@ class Money
     # @example
     #    - Money.new(100) #=> #<Money @fractional=-100>
     def -@
-      self.class.new(-fractional, currency)
+      dup_with(fractional: -fractional)
     end
 
     # Checks whether two Money objects have the same currency and the same
@@ -46,7 +46,7 @@ class Money
     # Compares two Money objects. If money objects have a different currency it
     # will attempt to convert the currency.
     #
-    # @param [Money] other_money Value to compare with.
+    # @param [Money] other Value to compare with.
     #
     # @return [Integer]
     #
@@ -57,6 +57,12 @@ class Money
         return unless other.respond_to?(:zero?) && other.zero?
         return other.is_a?(CoercedNumeric) ? 0 <=> fractional : fractional <=> 0
       end
+
+      # Always allow comparison with zero
+      if zero? || other.zero?
+        return fractional <=> other.fractional
+      end
+
       other = other.exchange_to(currency)
       fractional <=> other.fractional
     rescue Money::Bank::UnknownRate
@@ -102,7 +108,7 @@ class Money
     # values. If +other_money+ has a different currency then its monetary value
     # is automatically exchanged to this object's currency using +exchange_to+.
     #
-    # @param [Money] other_money Other +Money+ object to add.
+    # @param [Money] other Other +Money+ object to add.
     #
     # @return [Money]
     #
@@ -115,20 +121,32 @@ class Money
     # its monetary value is automatically exchanged to this object's currency
     # using +exchange_to+.
     #
-    # @param [Money] other_money Other +Money+ object to subtract.
+    # @param [Money] other Other +Money+ object to subtract.
     #
     # @return [Money]
     #
     # @example
     #   Money.new(100) - Money.new(99) #=> #<Money @fractional=1>
     [:+, :-].each do |op|
+      non_zero_message = lambda do |value|
+        "Can't add or subtract a non-zero #{value.class.name} value"
+      end
+
       define_method(op) do |other|
-        unless other.is_a?(Money)
-          return self if other.zero?
-          raise TypeError
+        case other
+        when Money
+          other = other.exchange_to(currency)
+          new_fractional = fractional.public_send(op, other.fractional)
+          dup_with(fractional: new_fractional)
+        when CoercedNumeric
+          raise TypeError, non_zero_message.call(other.value) unless other.zero?
+          dup_with(fractional: other.value.public_send(op, fractional))
+        when Numeric
+          raise TypeError, non_zero_message.call(other) unless other.zero?
+          self
+        else
+          raise TypeError, "Unsupported argument type: #{other.class.name}"
         end
-        other = other.exchange_to(currency)
-        self.class.new(fractional.public_send(op, other.fractional), currency)
       end
     end
 
@@ -149,7 +167,7 @@ class Money
     def *(value)
       value = value.value if value.is_a?(CoercedNumeric)
       if value.is_a? Numeric
-        self.class.new(fractional * value, currency)
+        dup_with(fractional: fractional * value)
       else
         raise TypeError, "Can't multiply a #{self.class.name} by a #{value.class.name}'s value"
       end
@@ -175,7 +193,7 @@ class Money
         fractional / as_d(value.exchange_to(currency).fractional).to_f
       else
         raise TypeError, 'Can not divide by Money' if value.is_a?(CoercedNumeric)
-        self.class.new(fractional / as_d(value), currency)
+        dup_with(fractional: fractional / as_d(value))
       end
     end
 
@@ -213,13 +231,13 @@ class Money
     def divmod_money(val)
       cents = val.exchange_to(currency).cents
       quotient, remainder = fractional.divmod(cents)
-      [quotient, self.class.new(remainder, currency)]
+      [quotient, dup_with(fractional: remainder)]
     end
     private :divmod_money
 
     def divmod_other(val)
       quotient, remainder = fractional.divmod(as_d(val))
-      [self.class.new(quotient, currency), self.class.new(remainder, currency)]
+      [dup_with(fractional: quotient), dup_with(fractional: remainder)]
     end
     private :divmod_other
 
@@ -263,7 +281,7 @@ class Money
       if (fractional < 0 && val < 0) || (fractional > 0 && val > 0)
         self.modulo(val)
       else
-        self.modulo(val) - (val.is_a?(Money) ? val : self.class.new(val, currency))
+        self.modulo(val) - (val.is_a?(Money) ? val : dup_with(fractional: val))
       end
     end
 
@@ -274,7 +292,7 @@ class Money
     # @example
     #   Money.new(-100).abs #=> #<Money @fractional=100>
     def abs
-      self.class.new(fractional.abs, currency)
+      dup_with(fractional: fractional.abs)
     end
 
     # Test if the money amount is zero.

data/lib/money/money/constructors.rb

@@ -10,8 +10,7 @@ class Money
     # @example
     #   Money.empty #=> #<Money @fractional=0>
     def empty(currency = default_currency)
-      @empty ||= {}
-      @empty[currency] ||= new(0, currency).freeze
+      new(0, currency)
     end
     alias_method :zero, :empty