money 6.7.1 → 6.13.0

data/lib/money.rb

@@ -2,18 +2,5 @@ require "bigdecimal"
 require "bigdecimal/util"
 require "set"
 require "i18n"
-require "sixarm_ruby_unaccent"
 require "money/currency"
 require "money/money"
-
-# Overwrites unaccent method of sixarm_ruby_unaccent.
-class String
-  def unaccent
-    accentmap = ACCENTMAP
-    accentmap.delete("\u{0142}") # Delete ł symbol from ACCENTMAP used in PLN currency
-    accentmap.delete("\u{010D}") # Delete č symbol from ACCENTMAP used in CZK currency
-    accentmap.delete("\u{FDFC}") # Delete ﷼ symbol from ACCENTMAP used in IRR, SAR and YER currencies
-    accentmap.delete("\u{20A8}") # Delete ₨ symbol from ACCENTMAP used in INR, LKR, MUR, NPR, PKR and SCR currencies
-    split(//u).map {|c| accentmap[c] || c }.join("")
-  end
-end

data/lib/money/bank/variable_exchange.rb

@@ -45,8 +45,9 @@ class Money
       attr_reader :mutex, :store
 
       # Available formats for importing/exporting rates.
-      RATE_FORMATS = [:json, :ruby, :yaml]
+      RATE_FORMATS = [:json, :ruby, :yaml].freeze
       SERIALIZER_SEPARATOR = '_TO_'.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
@@ -118,20 +119,20 @@ 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)).to_f
+        ex = fractional * BigDecimal(rate.to_s)
         if block_given?
           yield ex
         elsif @rounding_method
           @rounding_method.call(ex)
         else
-          ex.to_s.to_d
+          ex
         end
       end
 
@@ -216,14 +217,7 @@ class Money
           RATE_FORMATS.include? format
 
         store.transaction do
-          s = case format
-          when :json
-            JSON.dump(rates)
-          when :ruby
-            Marshal.dump(rates)
-          when :yaml
-            YAML.dump(rates)
-          end
+          s = FORMAT_SERIALIZERS[format].dump(rates)
 
           unless file.nil?
             File.open(file, "w") {|f| f.write(s) }
@@ -264,14 +258,7 @@ class Money
           RATE_FORMATS.include? format
 
         store.transaction do
-          data = case format
-           when :json
-             JSON.load(s)
-           when :ruby
-             Marshal.load(s)
-           when :yaml
-             YAML.load(s)
-           end
+          data = FORMAT_SERIALIZERS[format].load(s)
 
           data.each do |key, rate|
             from, to = key.split(SERIALIZER_SEPARATOR)

data/lib/money/currency.rb

@@ -8,7 +8,7 @@ class Money
 
   # Represents a specific currency unit.
   #
-  # @see http://en.wikipedia.org/wiki/Currency
+  # @see https://en.wikipedia.org/wiki/Currency
   # @see http://iso4217.net/
   class Currency
     include Comparable
@@ -79,7 +79,8 @@ class Money
       #   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}
+        return if num.empty?
+        id, _ = self.table.find { |key, currency| currency[:iso_numeric] == num }
         new(id)
       rescue UnknownCurrency
         nil
@@ -112,12 +113,12 @@ class Money
       #
       # == monetary unit
       # The standard unit of value of a currency, as the dollar in the United States or the peso in Mexico.
-      # http://www.answers.com/topic/monetary-unit
+      # https://www.answers.com/topic/monetary-unit
       # == fractional monetary unit, subunit
       # A monetary unit that is valued at a fraction (usually one hundredth) of the basic monetary unit
-      # http://www.answers.com/topic/fractional-monetary-unit-subunit
+      # https://www.answers.com/topic/fractional-monetary-unit-subunit
       #
-      # See http://en.wikipedia.org/wiki/List_of_circulating_currencies and
+      # 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
@@ -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,11 +198,10 @@ 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
@@ -314,10 +323,10 @@ class Money
     end
     private :compare_ids
 
-    # Returns a Fixnum hash value based on the +id+ attribute in order to use
+    # Returns a Integer hash value based on the +id+ attribute in order to use
     # functions like & (intersection), group_by, etc.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     #
     # @example
     #   Money::Currency.new(:usd).hash #=> 428936
@@ -392,45 +401,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 [Fixnum]
-    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 MRO 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]

data/lib/money/currency/heuristics.rb

@@ -3,152 +3,9 @@
 class Money
   class Currency
     module Heuristics
-
-      # An robust and efficient algorithm for finding currencies in
-      # text. Using several algorithms it can find symbols, iso codes and
-      # even names of currencies.
-      # Although not recommendable, it can also attempt to find the given
-      # currency in an entire sentence
-      #
-      # Returns: Array (matched results)
       def analyze(str)
-        return Analyzer.new(str, search_tree).process
-      end
-
-      private
-
-      # Build a search tree from the currency database
-      def search_tree
-        @_search_tree ||= {
-          :by_symbol => currencies_by_symbol,
-          :by_iso_code => currencies_by_iso_code,
-          :by_name => currencies_by_name
-        }
-      end
-
-      def currencies_by_symbol
-        {}.tap do |r|
-          table.each do |dummy, c|
-            symbol = (c[:symbol]||"").downcase
-            symbol.chomp!('.')
-            (r[symbol] ||= []) << c
-
-            (c[:alternate_symbols]||[]).each do |ac|
-              ac = ac.downcase
-              ac.chomp!('.')
-              (r[ac] ||= []) << c
-            end
-          end
-        end
-      end
-
-      def currencies_by_iso_code
-        {}.tap do |r|
-          table.each do |dummy,c|
-            (r[c[:iso_code].downcase] ||= []) << c
-          end
-        end
-      end
-
-      def currencies_by_name
-        {}.tap do |r|
-          table.each do |dummy,c|
-            name_parts = c[:name].unaccent.downcase.split
-            name_parts.each {|part| part.chomp!('.')}
-
-            # construct one branch per word
-            root = r
-            while name_part = name_parts.shift
-              root = (root[name_part] ||= {})
-            end
-
-            # the leaf is a currency
-            (root[:value] ||= []) << c
-          end
-        end
-      end
-
-      class Analyzer
-        attr_reader :search_tree, :words
-        attr_accessor :str, :currencies
-
-        def initialize str, search_tree
-          @str = (str||'').dup
-          @search_tree = search_tree
-          @currencies = []
-        end
-
-        def process
-          format
-          return [] if str.empty?
-
-          search_by_symbol
-          search_by_iso_code
-          search_by_name
-
-          prepare_reply
-        end
-
-        def format
-          str.gsub!(/[\r\n\t]/,'')
-          str.gsub!(/[0-9][\.,:0-9]*[0-9]/,'')
-          str.gsub!(/[0-9]/, '')
-          str.downcase!
-          @words = str.unaccent.split
-          @words.each {|word| word.chomp!('.'); word.chomp!(',') }
-        end
-
-        def search_by_symbol
-          words.each do |word|
-            if found = search_tree[:by_symbol][word]
-              currencies.concat(found)
-            end
-          end
-        end
-
-        def search_by_iso_code
-          words.each do |word|
-            if found = search_tree[:by_iso_code][word]
-              currencies.concat(found)
-            end
-          end
-        end
-
-        def search_by_name
-          # remember, the search tree by name is a construct of branches and leaf!
-          # We need to try every combination of words within the sentence, so we
-          # end up with a x^2 equation, which should be fine as most names are either
-          # one or two words, and this is multiplied with the words of given sentence
-
-          search_words = words.dup
-
-          while search_words.length > 0
-            root = search_tree[:by_name]
-
-            search_words.each do |word|
-              if root = root[word]
-                if root[:value]
-                  currencies.concat(root[:value])
-                end
-              else
-                break
-              end
-            end
-
-            search_words.delete_at(0)
-          end
-        end
-
-        def prepare_reply
-          codes = currencies.map do |currency|
-            currency[:iso_code]
-          end
-          codes.uniq!
-          codes.sort!
-          codes
-        end
+        raise StandardError, 'Heuristics deprecated, add `gem "money-heuristics"` to Gemfile'
       end
     end
   end
 end
-

data/lib/money/currency/loader.rb

@@ -17,7 +17,7 @@ class Money
       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)
+        JSON.parse(json, symbolize_names: true)
       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/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,24 @@
+require 'money/locale_backend/base'
+
+class Money
+  module LocaleBackend
+    class I18n < Base
+      KEY_MAP = {
+        thousands_separator: :delimiter,
+        decimal_mark: :separator
+      }.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)
+        if Money.use_i18n
+          warn '[DEPRECATION] `use_i18n` is deprecated - use `Money.locale_backend = :i18n` instead'
+
+          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