money 6.5.1 → 6.16.0

data/config/currency_non_iso.json

@@ -1,17 +1,35 @@
 {
+  "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": ""
+    "iso_numeric": "",
+    "smallest_denomination": 1
   },
   "jep": {
     "priority": 100,
@@ -28,5 +46,85 @@
     "thousands_separator": ",",
     "iso_numeric": "",
     "smallest_denomination": 1
+  },
+  "ggp": {
+    "priority": 100,
+    "iso_code": "GGP",
+    "name": "Guernsey Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "GGP",
+    "alternate_symbols": [],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "imp": {
+    "priority": 100,
+    "iso_code": "IMP",
+    "name": "Isle of Man Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "IMP",
+    "alternate_symbols": ["M£"],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "xfu": {
+    "priority": 100,
+    "iso_code": "XFU",
+    "name": "UIC Franc",
+    "symbol": "",
+    "disambiguate_symbol": "XFU",
+    "alternate_symbols": [],
+    "subunit": "",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": ""
+  },
+  "gbx": {
+    "priority": 100,
+    "iso_code": "GBX",
+    "name": "British Penny",
+    "symbol": "",
+    "disambiguate_symbol": "GBX",
+    "alternate_symbols": [],
+    "subunit": "",
+    "subunit_to_unit": 1,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "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/base.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 class Money
   # Provides classes that aid in the ability of exchange one currency with
   # another.
@@ -120,7 +118,7 @@ class Money
       # @example
       #   same_currency?("usd", "USD")                #=> true
       #   same_currency?("usd", "EUR")                #=> false
-      #   same_currency?("usd", Currency.new("USD")   #=> true
+      #   same_currency?("usd", Currency.new("USD"))   #=> true
       #   same_currency?("usd", "USD")                #=> true
       def same_currency?(currency1, currency2)
         Currency.wrap(currency1) == Currency.wrap(currency2)

data/lib/money/bank/variable_exchange.rb

@@ -1,4 +1,5 @@
 require 'money/bank/base'
+require 'money/rates_store/memory'
 require 'json'
 require 'yaml'
 
@@ -15,42 +16,63 @@ class Money
     # conversion rates. One must manually specify them with +add_rate+, after
     # which one can perform exchanges with +#exchange_with+.
     #
+    # Exchange rates are stored in memory using +Money::RatesStore::Memory+ by default.
+    # Pass custom rates stores for other types of storage (file, database, etc)
+    #
     # @example
     #   bank = Money::Bank::VariableExchange.new
     #   bank.add_rate("USD", "CAD", 1.24515)
     #   bank.add_rate("CAD", "USD", 0.803115)
     #
-    #   c1 = 100_00.to_money("USD")
-    #   c2 = 100_00.to_money("CAD")
+    #   c1 = Money.new(100_00, "USD")
+    #   c2 = Money.new(100_00, "CAD")
     #
     #   # Exchange 100 USD to CAD:
-    #   bank.exchange_with(c1, "CAD") #=> #<Money @fractional=1245150>
+    #   bank.exchange_with(c1, "CAD") #=> #<Money fractional:12451 currency:CAD>
     #
     #   # Exchange 100 CAD to USD:
-    #   bank.exchange_with(c2, "USD") #=> #<Money @fractional=803115>
+    #   bank.exchange_with(c2, "USD") #=> #<Money fractional:8031 currency:USD>
+    #
+    #   # With custom exchange rates storage
+    #   redis_store = MyCustomRedisStore.new(host: 'localhost:6379')
+    #   bank = Money::Bank::VariableExchange.new(redis_store)
+    #   # Store rates in redis
+    #   bank.add_rate 'USD', 'CAD', 0.98
+    #   # Get rate from redis
+    #   bank.get_rate 'USD', 'CAD'
     class VariableExchange < Base
 
-      attr_reader :rates, :mutex
+      attr_reader :mutex
 
       # 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
 
-      # Setup rates hash and mutex for rates locking
+      # Initializes a new +Money::Bank::VariableExchange+ object.
+      # It defaults to using an in-memory, thread safe store instance for
+      # storing exchange rates.
       #
-      # @return [self]
-      def setup
-        @rates = {}
-        @mutex = Mutex.new
-        self
+      # @param [RateStore] st An exchange rate store, used to persist exchange rate pairs.
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another. See +Money::bank::base+
+      def initialize(st = Money::RatesStore::Memory.new, &block)
+        @store = st
+        super(&block)
+      end
+
+      def store
+        @store.is_a?(String) ? Object.const_get(@store) : @store
       end
 
       def marshal_dump
-        [@rates, @rounding_method]
+        [store.marshal_dump, @rounding_method]
       end
 
       def marshal_load(arr)
-        @rates, @rounding_method = arr
-        @mutex = Mutex.new
+        store_info = arr[0]
+        @store = store_info.shift.new(*store_info)
+        @rounding_method = arr[1]
       end
 
       # Exchanges the given +Money+ object to a new +Money+ object in
@@ -76,14 +98,14 @@ class Money
       #   bank.add_rate("USD", "CAD", 1.24515)
       #   bank.add_rate("CAD", "USD", 0.803115)
       #
-      #   c1 = 100_00.to_money("USD")
-      #   c2 = 100_00.to_money("CAD")
+      #   c1 = Money.new(100_00, "USD")
+      #   c2 = Money.new(100_00, "CAD")
       #
       #   # Exchange 100 USD to CAD:
-      #   bank.exchange_with(c1, "CAD") #=> #<Money @fractional=1245150>
+      #   bank.exchange_with(c1, "CAD") #=> #<Money fractional:12451 currency:CAD>
       #
       #   # Exchange 100 CAD to USD:
-      #   bank.exchange_with(c2, "USD") #=> #<Money @fractional=803115>
+      #   bank.exchange_with(c2, "USD") #=> #<Money fractional:8031 currency:USD>
       def exchange_with(from, to_currency, &block)
         to_currency = Currency.wrap(to_currency)
         if from.currency == to_currency
@@ -91,8 +113,10 @@ class Money
         else
           if rate = get_rate(from.currency, to_currency)
             fractional = calculate_fractional(from, to_currency)
-            Money.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}'"
@@ -101,24 +125,25 @@ 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_i
+          ex
         end
       end
 
       # Registers a conversion rate and returns it (uses +#set_rate+).
+      # Delegates to +Money::RatesStore::Memory+
       #
       # @param [Currency, String, Symbol] from Currency to exchange from.
       # @param [Currency, String, Symbol] to Currency to exchange to.
@@ -134,14 +159,14 @@ class Money
         set_rate(from, to, rate)
       end
 
-      # Set the rate for the given currencies. Uses +Mutex+ to synchronize data
+      # Set the rate for the given currencies.
       # access.
+      # Delegates to +Money::RatesStore::Memory+
       #
       # @param [Currency, String, Symbol] from Currency to exchange from.
       # @param [Currency, String, Symbol] to Currency to exchange to.
       # @param [Numeric] rate Rate to use when exchanging currencies.
-      # @param [Hash] opts Options hash to set special parameters
-      # @option opts [Boolean] :without_mutex disables the usage of a mutex
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
       #
       # @return [Numeric]
       #
@@ -150,21 +175,16 @@ class Money
       #   bank.set_rate("USD", "CAD", 1.24515)
       #   bank.set_rate("CAD", "USD", 0.803115)
       def set_rate(from, to, rate, opts = {})
-        fn = -> { @rates[rate_key_for(from, to)] = rate }
-        if opts[:without_mutex]
-          fn.call
-        else
-          @mutex.synchronize { fn.call }
-        end
+        store.add_rate(Currency.wrap(from).iso_code, Currency.wrap(to).iso_code, rate)
       end
 
-      # Retrieve the rate for the given currencies. Uses +Mutex+ to synchronize
+      # Retrieve the rate for the given currencies.
       # data access.
+      # Delegates to +Money::RatesStore::Memory+
       #
       # @param [Currency, String, Symbol] from Currency to exchange from.
       # @param [Currency, String, Symbol] to Currency to exchange to.
-      # @param [Hash] opts Options hash to set special parameters
-      # @option opts [Boolean] :without_mutex disables the usage of a mutex
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
       #
       # @return [Numeric]
       #
@@ -176,12 +196,7 @@ class Money
       #   bank.get_rate("USD", "CAD") #=> 1.24515
       #   bank.get_rate("CAD", "USD") #=> 0.803115
       def get_rate(from, to, opts = {})
-        fn = -> { @rates[rate_key_for(from, to)] }
-        if opts[:without_mutex]
-          fn.call
-        else
-          @mutex.synchronize { fn.call }
-        end
+        store.get_rate(Currency.wrap(from).iso_code, Currency.wrap(to).iso_code)
       end
 
       # Return the known rates as a string in the format specified. If +file+
@@ -190,8 +205,7 @@ class Money
       #
       # @param [Symbol] format Request format for the resulting string.
       # @param [String] file Optional file location to write the rates to.
-      # @param [Hash] opts Options hash to set special parameters
-      # @option opts [Boolean] :without_mutex disables the usage of a mutex
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
       #
       # @return [String]
       #
@@ -205,39 +219,33 @@ 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)
 
-        s = ""
-        fn = -> {
-          s = case format
-              when :json
-                JSON.dump(@rates)
-              when :ruby
-                Marshal.dump(@rates)
-              when :yaml
-                YAML.dump(@rates)
-              end
+        store.transaction do
+          s = FORMAT_SERIALIZERS[format].dump(rates)
 
           unless file.nil?
             File.open(file, "w") {|f| f.write(s) }
           end
-        }
-        if opts[:without_mutex]
-          fn.call
-        else
-          @mutex.synchronize { fn.call }
+
+          s
+        end
+      end
+
+      # This should be deprecated.
+      def rates
+        store.each_rate.each_with_object({}) do |(from,to,rate),hash|
+          hash[[from, to].join(SERIALIZER_SEPARATOR)] = rate
         end
-        s
       end
 
       # Loads rates provided in +s+ given the specified format. Available
       # formats are +:json+, +:ruby+ and +:yaml+.
+      # Delegates to +Money::RatesStore::Memory+
       #
       # @param [Symbol] format The format of +s+.
       # @param [String] s The rates string.
-      # @param [Hash] opts Options hash to set special parameters
-      # @option opts [Boolean] :without_mutex disables the usage of a mutex
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
       #
       # @return [self]
       #
@@ -251,40 +259,24 @@ 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)
 
-        fn = -> {
-          @rates = case format
-                   when :json
-                     JSON.load(s)
-                   when :ruby
-                     Marshal.load(s)
-                   when :yaml
-                     YAML.load(s)
-                   end
-        }
-        if opts[:without_mutex]
-          fn.call
-        else
-          @mutex.synchronize { fn.call }
+        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
-        self
-      end
 
-      private
+        store.transaction do
+          data = FORMAT_SERIALIZERS[format].load(s)
 
-      # Return the rate hashkey for the given currencies.
-      #
-      # @param [Currency, String, Symbol] from The currency to exchange from.
-      # @param [Currency, String, Symbol] to The currency to exchange to.
-      #
-      # @return [String]
-      #
-      # @example
-      #   rate_key_for("USD", "CAD") #=> "USD_TO_CAD"
-      def rate_key_for(from, to)
-        "#{Currency.wrap(from).iso_code}_TO_#{Currency.wrap(to).iso_code}".upcase
+          data.each do |key, rate|
+            from, to = key.split(SERIALIZER_SEPARATOR)
+            store.add_rate from, to, rate
+          end
+        end
+
+        self
       end
     end
   end

data/lib/money/currency/heuristics.rb

@@ -3,150 +3,8 @@
 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].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.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

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