money 6.0.0 → 6.0.1

data/lib/money/currency/heuristics.rb

@@ -1,149 +1,153 @@
 # encoding: utf-8
 
-module Money::Currency::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
+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
+      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
+      # 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
+      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
-    end
-  end
 
-  def currencies_by_iso_code
-    {}.tap do |r|
-      table.each do |dummy,c|
-        (r[c[:iso_code].downcase] ||= []) << c
+      def currencies_by_iso_code
+        {}.tap do |r|
+          table.each do |dummy,c|
+            (r[c[:iso_code].downcase] ||= []) << c
+          end
+        end
       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!('.')}
+      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
+            # 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
+            # the leaf is a currency
+            (root[:value] ||= []) << c
+          end
+        end
       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?
+      class Analyzer
+        attr_reader :search_tree, :words
+        attr_accessor :str, :currencies
 
-      search_by_symbol
-      search_by_iso_code
-      search_by_name
+        def initialize str, search_tree
+          @str = (str||'').dup
+          @search_tree = search_tree
+          @currencies = []
+        end
 
-      prepare_reply
-    end
+        def process
+          format
+          return [] if str.empty?
 
-    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
+          search_by_symbol
+          search_by_iso_code
+          search_by_name
 
-    def search_by_symbol
-      words.each do |word|
-        if found = search_tree[:by_symbol][word]
-          currencies.concat(found)
+          prepare_reply
         end
-      end
-    end
 
-    def search_by_iso_code
-      words.each do |word|
-        if found = search_tree[:by_iso_code][word]
-          currencies.concat(found)
+        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
-      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]
+        def search_by_symbol
+          words.each do |word|
+            if found = search_tree[:by_symbol][word]
+              currencies.concat(found)
+            end
+          end
+        end
 
-        search_words.each do |word|
-          if root = root[word]
-            if root[:value]
-              currencies.concat(root[:value])
+        def search_by_iso_code
+          words.each do |word|
+            if found = search_tree[:by_iso_code][word]
+              currencies.concat(found)
             end
-          else
-            break
           end
         end
 
-        search_words.delete_at(0)
-      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
 
-    def prepare_reply
-      codes = currencies.map do |currency|
-        currency[:iso_code]
+            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
       end
-      codes.uniq!
-      codes.sort!
-      codes
     end
   end
 end

data/lib/money/currency/loader.rb

@@ -1,22 +1,24 @@
-module Money::Currency::Loader
-  extend self
+class Money
+  class Currency
+    module Loader
+      DATA_PATH = File.expand_path("../../../../config", __FILE__)
 
-  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
 
-  # 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

@@ -1,20 +1,19 @@
 # encoding: utf-8
 
-require 'json'
+require "json"
+require "money/currency/loader"
+require "money/currency/heuristics"
 
 class Money
 
   # Represents a specific currency unit.
   #
   # @see http://en.wikipedia.org/wiki/Currency
+  # @see http://iso4217.net/
   class Currency
     include Comparable
-
-    require "money/currency/loader"
-    extend  Loader
-
-    require "money/currency/heuristics"
-    extend  Heuristics
+    extend Money::Currency::Loader
+    extend Money::Currency::Heuristics
 
     # Thrown when an unknown currency is requested.
     class UnknownCurrency < StandardError; end
@@ -34,7 +33,9 @@ class Money
       #   Money::Currency.find(:foo) #=> nil
       def find(id)
         id = id.to_s.downcase.to_sym
-        new(id) if self.table[id]
+        new(id)
+      rescue UnknownCurrency
+        nil
       end
 
       # Lookup a currency with given +num+ as an ISO 4217 numeric and returns an
@@ -51,7 +52,9 @@ class Money
       def find_by_iso_numeric(num)
         num = num.to_s
         id, _ = self.table.find{|key, currency| currency[:iso_numeric] == num}
-        new(id) if self.table[id]
+        new(id)
+      rescue UnknownCurrency
+        nil
       end
 
       # Wraps the object in a +Currency+ unless it's already a +Currency+
@@ -68,9 +71,7 @@ class Money
       #   Money::Currency.wrap(c1)    #=> #<Money::Currency id: usd ...>
       #   Money::Currency.wrap("usd") #=> #<Money::Currency id: usd ...>
       def wrap(object)
-        if object.nil?
-          nil
-        elsif object.is_a?(Currency)
+        if object.nil? || object.is_a?(Currency)
           object
         else
           Currency.new(object)
@@ -128,71 +129,33 @@ class Money
       end
     end
 
-    # The symbol used to identify the currency, usually the lowercase
-    # +iso_code+ attribute.
-    #
-    # @return [Symbol]
-    attr_reader :id
-
-    # A numerical value you can use to sort/group the currency list.
-    #
-    # @return [Integer]
-    attr_reader :priority
-
-    # The international 3-letter code as defined by the ISO 4217 standard.
-    #
-    # @return [String]
-    # @see http://iso4217.net/
-    attr_reader :iso_code
-
-    #
-    # The international 3-numeric code as defined by the ISO 4217 standard.
-    #
-    # @return [String]
-    # @see http://iso4217.net/
-    attr_reader :iso_numeric
-
-    # The currency name.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # The currency symbol (UTF-8 encoded).
-    #
-    # @return [String]
-    attr_reader :symbol
-
-    # The html entity for the currency symbol
-    #
-    # @return [String]
-    attr_reader :html_entity
-
-    # The name of the fractional monetary unit.
-    #
-    # @return [String]
-    attr_reader :subunit
-
-    # The proportion between the unit and the subunit
-    #
-    # @return [Integer]
-    attr_reader :subunit_to_unit
-
-    # The decimal mark, or character used to separate the whole unit from the subunit.
-    #
-    # @return [String]
-    attr_reader :decimal_mark
-    alias :separator :decimal_mark
-
-    # The character used to separate thousands grouping of the whole unit.
-    #
-    # @return [String]
-    attr_reader :thousands_separator
-    alias :delimiter :thousands_separator
-
-    # Should the currency symbol precede the amount, or should it come after?
-    #
-    # @return [Boolean]
-    attr_reader :symbol_first
+    # @attr_reader [Symbol] id The symbol used to identify the currency,
+    # usually the lowercase +iso_code+ attribute.
+    # @attr_reader [Integer] priority A numerical value you can use to
+    # sort/group the currency list.
+    # @attr_reader [String] iso_code The international 3-letter code as defined
+    # by the ISO 4217 standard.
+    # @attr_reader [String] iso_numeric The international 3-numeric code as
+    # defined by the ISO 4217 standard.
+    # @attr_reader [String] name The currency name.
+    # @attr_reader [String] symbol The currency symbol (UTF-8 encoded).
+    # @attr_reader [String] html_entity The html entity for the currency symbol
+    # @attr_reader [String] subunit The name of the fractional monetary unit.
+    # @attr_reader [Integer] subunit_to_unit The proportion between the unit
+    # and the subunit
+    # @attr_reader [String] decimal_mark The decimal mark, or character used to
+    # separate the whole unit from the subunit.
+    # @attr_reader [String] The character used to separate thousands grouping
+    # of the whole unit.
+    # @attr_reader [Boolean] symbol_first Should the currency symbol precede
+    # the amount, or should it come after?
+
+    attr_reader :id, :priority, :iso_code, :iso_numeric, :name, :symbol,
+      :html_entity, :subunit, :subunit_to_unit, :decimal_mark,
+      :thousands_separator, :symbol_first
+
+    alias_method :separator, :decimal_mark
+    alias_method :delimiter, :thousands_separator
 
     # Create a new +Currency+ object.
     #
@@ -205,12 +168,15 @@ class Money
     #   Money::Currency.new(:usd) #=> #<Money::Currency id: usd ...>
     def initialize(id)
       id = id.to_s.downcase
-      raise(UnknownCurrency, "Unknown currency `#{id}'") unless self.class.stringified_keys.include?(id)
 
-      @id  = id.to_sym
-      data = self.class.table[@id]
-      data.each_pair do |key, value|
-        instance_variable_set(:"@#{key}", value)
+      if self.class.stringified_keys.include?(id)
+        @id = id.to_sym
+        data = self.class.table[@id]
+        data.each_pair do |key, value|
+          instance_variable_set(:"@#{key}", value)
+        end
+      else
+        raise UnknownCurrency, "Unknown currency '#{id}'"
       end
     end
 
@@ -244,10 +210,19 @@ class Money
     #   c1 == c1 #=> true
     #   c1 == c2 #=> false
     def ==(other_currency)
-      self.equal?(other_currency) ||
-      self.id.to_s.downcase == (other_currency.is_a?(Currency) ? other_currency.id.to_s.downcase : other_currency.to_s.downcase)
+      self.equal?(other_currency) || compare_ids(other_currency)
     end
 
+    def compare_ids(other_currency)
+      other_currency_id = if other_currency.is_a?(Currency)
+                            other_currency.id.to_s.downcase
+                          else
+                            other_currency.to_s.downcase
+                          end
+      self.id.to_s.downcase == other_currency_id
+    end
+    private :compare_ids
+
     # Compares +self+ with +other_currency+ and returns +true+ if the are the
     # same or if their +id+ attributes match.
     #
@@ -288,7 +263,7 @@ class Money
     # Returns a string representation corresponding to the upcase +id+
     # attribute.
     #
-    # -–
+    # --
     # DEV: id.to_s.upcase corresponds to iso_code but don't use ISO_CODE for consistency.
     #
     # @return [String]
@@ -300,6 +275,30 @@ class Money
       id.to_s.upcase
     end
 
+    # Returns a string representation corresponding to the upcase +id+
+    # attribute. Useful in cases where only implicit conversions are made.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Money::Currency.new(:usd).to_str #=> "USD"
+    #   Money::Currency.new(:eur).to_str #=> "EUR"
+    def to_str
+      id.to_s.upcase
+    end
+
+    # Returns a symbol representation corresponding to the upcase +id+
+    # attribute.
+    #
+    # @return [Symbol]
+    #
+    # @example
+    #   Money::Currency.new(:usd).to_sym #=> :USD
+    #   Money::Currency.new(:eur).to_sym #=> :EUR
+    def to_sym
+      id.to_s.upcase.to_sym
+    end
+
     # Conversation to +self+.
     #
     # @return [self]
@@ -307,7 +306,6 @@ class Money
       self
     end
 
-
     # Returns currency symbol or iso code for currencies with no symbol.
     #
     # @return [String]
@@ -328,31 +326,24 @@ class Money
 
     # 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
-      }
+      @decimal_places_cache ||= {1 => 0, 10 => 1, 100 => 2, 1000 => 3}
     end
 
     # The number of decimal places needed.
     #
     # @return [Integer]
     def decimal_places
-      cache = self.class.decimal_places_cache
-      places  = cache[subunit_to_unit]
-      unless places
-        places = calculate_decimal_places(subunit_to_unit)
-        cache[subunit_to_unit] = places
-      end
-      places
+      cache[subunit_to_unit] ||= calculate_decimal_places(subunit_to_unit)
     end
 
+    def cache
+      self.class.decimal_places_cache
+    end
+    private :cache
+
     # If we need to figure out how many decimal places we need we
     # use repeated integer division.
     def calculate_decimal_places(num)
-      return 0 if num == 1
       i = 1
       while num >= 10
         num /= 10
@@ -361,6 +352,5 @@ class Money
       i
     end
     private :calculate_decimal_places
-
   end
 end

data/lib/money/deprecations.rb

@@ -5,6 +5,11 @@ class Money
   #
   # @return [nil]
   def self.deprecate(message)
-    warn "DEPRECATION WARNING: #{message}"
+    unless Money.silence_core_extensions_deprecations
+      file, line = caller(2).first.split(':', 2)
+      line = line.to_i
+
+      warn "DEPRECATION WARNING: #{message} (called from: #{file}:#{line})"
+    end
   end
 end