money 6.0.1.beta2 → 6.0.1.beta3

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/money.rb

@@ -78,56 +78,36 @@ class Money
   end
   private :as_d
 
-  # The currency the money is in.
-  #
-  # @return [Currency]
-  attr_reader :currency
-
-  # The +Money::Bank+ based object used to perform currency exchanges with.
-  #
-  # @return [Money::Bank::*]
-  attr_reader :bank
+  # @attr_reader [Currency] currency The currency the money is in.
+  # @attr_reader [Money::Bank::*] bank The +Money::Bank+ based object used to
+  # perform currency exchanges with.
+  attr_reader :currency, :bank
 
   # Class Methods
   class << self
-    # Each Money object is associated to a bank object, which is responsible
-    # for currency exchange. This property allows you to specify the default
-    # bank object. The default value for this property is an instance of
-    # +Bank::VariableExchange.+ It allows one to specify custom exchange rates.
-    #
-    # @return [Money::Bank::*]
-    attr_accessor :default_bank
-
-    # The default currency, which is used when +Money.new+ is called without an
-    # explicit currency argument. The default value is Currency.new("USD"). The
-    # value must be a valid +Money::Currency+ instance.
-    #
-    # @return [Money::Currency]
-    attr_accessor :default_currency
-
-    # Use this to disable i18n even if it's used by other objects in your app.
-    #
-    # @return [true,false]
-    attr_accessor :use_i18n
-
-    # Use this to enable the ability to assume the currency from a passed symbol
-    #
-    # @return [true,false]
-    attr_accessor :assume_from_symbol
-
-    # Use this to enable infinite precision cents
-    #
-    # @return [true,false]
-    attr_accessor :infinite_precision
-
-    # Use this to specify the rounding mode
+    # @attr_accessor [Money::Bank::*] default_bank Each Money object is
+    # associated to a bank object, which is responsible for currency exchange.
+    # This property allows you to specify the default bank object. The default
+    # value for this property is an instance of +Bank::VariableExchange.+ It
+    # allows one to specify custom exchange rates.
+    # @attr_accessor [Money::Currency] default_currency The default currency,
+    # which is used when +Money.new+ is called without an explicit currency
+    # argument. The default value is Currency.new("USD"). The value must be a
+    # valid +Money::Currency+ instance.
+    # @attr_accessor [true, false] use_i18n Use this to disable i18n even if
+    # it's used by other objects in your app.
+    # @attr_accessor [true, false] assume_from_symbol Use this to enable the
+    # ability to assume the currency from a passed symbol
+    # @attr_accessor [true, false] infinite_precision Use this to enable
+    # infinite precision cents
+    # @attr_accessor [Integer] conversion_precision Use this to specify
+    # precision for converting Rational to BigDecimal
+    attr_accessor :default_bank, :default_currency, :use_i18n,
+      :assume_from_symbol, :infinite_precision, :conversion_precision
+
+    # @attr_writer rounding_mode Use this to specify the rounding mode
     attr_writer :rounding_mode
 
-    # Use this to specify precision for converting Rational to BigDecimal
-    #
-    # @return [Integer]
-    attr_accessor :conversion_precision
-
     # Create a new money object with value 0.
     #
     # @param [Currency, String, Symbol] currency The currency to use.
@@ -185,10 +165,12 @@ class Money
   #     Money.new(1200) * BigDecimal.new('0.029')
   #   end
   def self.rounding_mode(mode=nil)
-    return Thread.current[:money_rounding_mode] || @rounding_mode if mode.nil?
-
-    Thread.current[:money_rounding_mode] = mode
-    yield
+    if mode.nil?
+      Thread.current[:money_rounding_mode] || @rounding_mode
+    else
+      Thread.current[:money_rounding_mode] = mode
+      yield
+    end
   ensure
     Thread.current[:money_rounding_mode] = nil
   end
@@ -258,10 +240,9 @@ class Money
   # @see Money.new
   #
   def self.new_with_amount(amount, currency = Money.default_currency, bank = Money.default_bank)
-    money = from_numeric(amount, currency)
-    # Hack! You can't change a bank
-    money.instance_variable_set("@bank", bank)
-    money
+    from_numeric(amount, currency).tap do |money|
+      money.instance_variable_set("@bank", bank) # Hack! You can't change a bank
+    end
   end
 
   # Synonym of #new_with_amount
@@ -310,17 +291,14 @@ class Money
   #
   # @see Money.new_with_dollars
   #
-  def initialize(fractional, currency = Money.default_currency, bank = Money.default_bank)
-    if (fractional.is_a? Money)
-      money = fractional
-      @fractional = money.fractional
-      @currency   = money.currency
-      @bank       = money.bank
-    else
-      @fractional = as_d(fractional)
-      @currency   = Currency.wrap(currency)
-      @bank       = bank
-    end
+  def initialize(obj, currency = Money.default_currency, bank = Money.default_bank)
+    @fractional = obj.fractional
+    @currency   = obj.currency
+    @bank       = obj.bank
+  rescue NoMethodError
+    @fractional = as_d(obj)
+    @currency   = Currency.wrap(currency)
+    @bank       = bank
   end
 
   # Assuming using a currency using dollars:
@@ -479,7 +457,7 @@ class Money
   #
   # @return [self]
   def to_money(given_currency = nil)
-    given_currency = Currency.wrap(given_currency) if given_currency
+    given_currency = Currency.wrap(given_currency)
     if given_currency.nil? || self.currency == given_currency
       self
     else
@@ -551,30 +529,42 @@ class Money
   #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33]) #=> [Money.new(34), Money.new(33), Money.new(33)]
   #
   def allocate(splits)
-    allocations = splits.inject(0) { |sum, n| sum + as_d(n) }
+    allocations = allocations_from_splits(splits)
 
     if (allocations - BigDecimal("1")) > Float::EPSILON
       raise ArgumentError, "splits add to more then 100%"
     end
 
+    amounts, left_over = amounts_from_splits(allocations, splits)
+
+    unless self.class.infinite_precision
+      left_over.to_i.times { |i| amounts[i % amounts.length] += 1 }
+    end
+
+    amounts.collect { |fractional| Money.new(fractional, currency) }
+  end
+
+  def allocations_from_splits(splits)
+    splits.inject(0) { |sum, n| sum + as_d(n) }
+  end
+  private :allocations_from_splits
+
+  def amounts_from_splits(allocations, splits)
     left_over = fractional
 
     amounts = splits.map do |ratio|
       if self.class.infinite_precision
-        fraction = fractional * ratio
+        fractional * ratio
       else
-        fraction = (fractional * ratio / allocations).floor
-        left_over -= fraction
-        fraction
+        (fractional * ratio / allocations).floor.tap do |frac|
+          left_over -= frac
+        end
       end
     end
 
-    unless self.class.infinite_precision
-      left_over.to_i.times { |i| amounts[i % amounts.length] += 1 }
-    end
-
-    amounts.collect { |fractional| Money.new(fractional, currency) }
+    [amounts, left_over]
   end
+  private :amounts_from_splits
 
   # Split money amongst parties evenly without loosing pennies.
   #
@@ -588,22 +578,29 @@ class Money
     raise ArgumentError, "need at least one party" if num < 1
 
     if self.class.infinite_precision
-      amt = div(as_d(num))
-      return 1.upto(num).map{amt}
+      split_infinite(num)
+    else
+      split_flat(num)
     end
+  end
 
+  def split_infinite(num)
+    amt = div(as_d(num))
+    1.upto(num).map{amt}
+  end
+  private :split_infinite
+
+  def split_flat(num)
     low = Money.new(fractional / num, currency)
     high = Money.new(low.fractional + 1, currency)
 
     remainder = fractional % num
-    result = []
 
-    num.times do |index|
-      result[index] = index < remainder ? high : low
+    Array.new(num).each_with_index.map do |_, index|
+      index < remainder ? high : low
     end
-
-    result
   end
+  private :split_flat
 
   # Round the monetary amount to smallest unit of coinage.
   #
@@ -622,10 +619,9 @@ class Money
   #
   def round(rounding_mode = self.class.rounding_mode)
     if self.class.infinite_precision
-      return Money.new(fractional.round(0, rounding_mode), self.currency)
+      Money.new(fractional.round(0, rounding_mode), self.currency)
     else
-      return self
+      self
     end
   end
-
 end