exchange 0.11.0 → 0.12.0

data/lib/exchange.rb

@@ -5,7 +5,7 @@ require 'exchange/base'
 require 'exchange/configurable'
 require 'exchange/gem_loader'
 require 'exchange/helper'
-require 'exchange/iso_4217'
+require 'exchange/iso'
 require 'exchange/money'
 require 'exchange/external_api'
 require 'exchange/cache'

data/lib/exchange/base.rb

@@ -2,7 +2,7 @@ module Exchange
   
   # The current version of the exchange gem
   #
-  VERSION = '0.11.0'
+  VERSION = '0.12.0'
   
   # The root installation path of the gem
   # @version 0.5

data/lib/exchange/cache/configuration.rb

@@ -8,8 +8,33 @@ module Exchange
     #
     class Configuration < Exchange::Configurable
       attr_accessor :expire, :host, :port, :path
+            
+      class << self
+        
+        def wipe_client_before_setting *setters
+          
+          setters.each do |setter|
+            define_method :"#{setter}_with_client_wipe=" do |data|
+              wipe_subclass_client!
+              send(:"#{setter}_without_client_wipe=", data)
+            end
+            alias_method :"#{setter}_without_client_wipe=", :"#{setter}="
+            alias_method :"#{setter}=", :"#{setter}_with_client_wipe="             
+          end
+          
+        end
+        
+      end
       
       def_delegators :instance, :expire, :expire=, :host, :host=, :port, :port=, :path, :path=
+      wipe_client_before_setting :host, :port
+      
+      # Overrides the parent class method to wipe the client before setting
+      # 
+      def set hash
+        wipe_subclass_client!
+        super
+      end
       
       def parent_module
         Cache
@@ -18,7 +43,13 @@ module Exchange
       def key
         :cache
       end
-    
+      
+      private
+      
+      def wipe_subclass_client!
+        subclass.wipe_client! if subclass && subclass.respond_to?(:wipe_client!)
+      end
+            
     end
   end 
 end

data/lib/exchange/cache/memcached.rb

@@ -14,6 +14,8 @@ module Exchange
     #
     class Memcached < Base
         
+      def_delegators :instance, :client, :wipe_client!
+        
       # instantiates a memcached client and memoizes it in a class variable.
       # Use this client to access memcached data. For further explanation of use visit the memcached gem documentation
       # @example
@@ -25,6 +27,12 @@ module Exchange
         @client ||= Dalli::Client.new("#{config.host}:#{config.port}")
       end
       
+      # Wipe the client instance variable
+      #
+      def wipe_client!
+        @client = nil
+      end
+      
       # returns either cached data from the memcached client or calls the block and caches it in memcached.
       # This method has to be the same in all the cache classes in order for the configuration binding to work
       # @param [Exchange::ExternalAPI::Subclass] api The API class the data has to be stored for

data/lib/exchange/cache/redis.rb

@@ -12,7 +12,9 @@ module Exchange
     #     c.cache_port = 'Your redis port (an Integer)'
     #   end
     class Redis < Base
-              
+      
+      def_delegators :instance, :client, :wipe_client!
+      
       # instantiates a redis client and memoizes it in a class variable.
       # Use this client to access redis data. For further explanation of use visit the redis gem documentation
       # @example
@@ -24,6 +26,12 @@ module Exchange
         @client ||= ::Redis.new(:host => config.host, :port => config.port)
       end
       
+      # Wipe the client instance variable
+      #
+      def wipe_client!
+        @client = nil
+      end
+      
       # returns either cached data from the redis client or calls the block and caches it in redis.
       # This method has to be the same in all the cache classes in order for the configuration binding to work
       # @param [Exchange::ExternalAPI::Subclass] api The API class the data has to be stored for

data/lib/exchange/configurable.rb

@@ -12,12 +12,15 @@ module Exchange
     def_delegators :instance, :subclass, :subclass=, :set
      
     def subclass_with_constantize
-      self.subclass = parent_module.const_get camelize(self.subclass_without_constantize) unless self.subclass_without_constantize.is_a?(Class)
+      self.subclass = parent_module.const_get camelize(self.subclass_without_constantize) unless !self.subclass_without_constantize || self.subclass_without_constantize.is_a?(Class)
       subclass_without_constantize
     end
     alias_method :subclass_without_constantize, :subclass
     alias_method :subclass, :subclass_with_constantize
     
+    # Set a configuration via a hash of options
+    # @params [Hash] hash The hash of options to set the configuration to
+    #
     def set hash
       hash.each_pair do |k,v|
         self.send(:"#{k}=", v)
@@ -26,6 +29,8 @@ module Exchange
       self
     end
     
+    # Reset the configuration to a set of defaults
+    #
     def reset
       set Exchange::Configuration::DEFAULTS[key]
     end

data/lib/exchange/core_extensions/float/error_safe.rb

@@ -19,7 +19,7 @@ module Exchange
     def self.prevent_errors_with_exchange_for base, meth
       base.send(:define_method, :"#{meth}without_errors", lambda { |other|
         if other.is_a?(Exchange::Money)
-          BigDecimal.new(self.to_s).send(meth, other).to_f
+          BigDecimal.new(self.to_s).send(meth, other.value).to_f
         else
           send(:"#{meth}with_errors", other)
         end

data/lib/exchange/core_extensions/numeric/conversability.rb

@@ -29,11 +29,7 @@ module Exchange
     # @version 0.10
     #
     def in currency, options={}
-      if ISO4217.currencies.include? currency
-        Money.new(self, currency, options)
-      else
-        raise Exchange::NoCurrencyError.new("#{currency} is not a currency")
-      end
+      Money.new(self, currency, options)
     end    
   end
 end

data/lib/exchange/{iso_4217.rb → iso.rb}

@@ -10,7 +10,7 @@ module Exchange
   # @since 0.3
   # @author Beat Richartz
   #
-  class ISO4217
+  class ISO
     include Singleton
     extend SingleForwardable
     
@@ -24,38 +24,34 @@ module Exchange
           self.class_eval <<-EOV
             def #{op}(amount, currency, precision=nil)
               minor = definitions[currency][:minor_unit]
-              (amount.is_a?(BigDecimal) ? amount : BigDecimal.new(amount.to_s, minor)).#{op}(precision || minor)
+              (amount.is_a?(BigDecimal) ? amount : BigDecimal.new(amount.to_s, precision_for(amount, currency))).#{op}(precision || minor)
             end
           EOV
         end
     
     end
           
-    # The ISO 4217 that have to be loaded. Nothing much to say here. Just use this method to get to the definitions
+    # The ISO 4217 that have to be loaded. Use this method to get to the definitions
     # They are static, so they can be stored in a class variable without many worries
-    # @return [Hash] The iso427 Definitions with the currency code as keys
+    # @return [Hash] The iso4217 Definitions with the currency code as keys
     #
     def definitions
-      return @definitions if @definitions
-      loaded       = YAML.load_file(File.join(ROOT_PATH, 'iso4217.yml'))
-      @definitions = {}
-      
-      loaded.each_pair do |k,v| 
-        v.keys.each do |key|
-          v[key.to_sym] = v.delete(key)
-        end
-        
-        @definitions[k.downcase.to_sym] = v
-      end
-      
-      @definitions
+      @definitions ||= symbolize_keys(YAML.load_file(File.join(ROOT_PATH, 'iso4217.yml')))
+    end
+    
+    # A map of country abbreviations to currency codes. Makes an instantiation of currency codes via a country code
+    # possible
+    # @return [Hash] The ISO3166 (1 and 2) country codes matched to a currency
+    #
+    def country_map
+      @country_map ||= symbolize_keys(YAML.load_file(File.join(ROOT_PATH, 'iso4217_country_map.yml')))
     end
     
     # All currencies defined by ISO 4217 as an array of symbols for inclusion testing
     # @return [Array] An Array of currency symbols
     #
     def currencies
-      @currencies  ||= definitions.keys.map(&:to_s).sort.map(&:to_sym)
+      @currencies  ||= definitions.keys.sort_by(&:to_s)
     end
     
     # Check if a currency is defined by ISO 4217 standards
@@ -63,7 +59,15 @@ module Exchange
     # @return [Boolean] true if the symbol matches a currency, false if not
     #
     def defines? currency
-      currencies.include? currency
+      currencies.include?(country_map[currency] ? country_map[currency] : currency)
+    end
+    
+    # Asserts a given argument is a currency. Tries to match with a country code if the argument is not a currency
+    # @param [Symbol, String] arg The argument to assert
+    # @return [Symbol] The matching currency as a symbol
+    #
+    def assert_currency! arg
+      defines?(arg) ? (country_map[arg] || arg) : raise(Exchange::NoCurrencyError.new("#{arg} is not a currency nor a country code matchable to a currency"))
     end
     
     # Use this to instantiate a currency amount. For one, it is important that we use BigDecimal here so nothing gets lost because
@@ -72,10 +76,15 @@ module Exchange
     # @param [String, Symbol] currency The currency you want to instantiate the money in
     # @return [BigDecimal] The instantiated currency
     # @example instantiate a currency from a string
-    #   Exchange::ISO4217.instantiate("4523", "usd") #=> #<Bigdecimal 4523.00>
+    #   Exchange::ISO.instantiate("4523", "usd") #=> #<Bigdecimal 4523.00>
+    # @note Reinstantiation is not needed in case the amount is already a big decimal. In this case, the maximum precision is already given.
     #
     def instantiate(amount, currency)
-      BigDecimal.new(amount.to_s, definitions[currency][:minor_unit])
+      if amount.is_a?(BigDecimal)
+        amount
+      else
+        BigDecimal.new(amount.to_s, precision_for(amount, currency))
+      end
     end
     
     # Converts the currency to a string in ISO 4217 standardized format, either with or without the currency. This leaves you
@@ -86,17 +95,18 @@ module Exchange
     # @option opts [Boolean] :amount_only Whether you want to have the currency in the string or not
     # @return [String] The formatted string
     # @example Convert a currency to a string
-    #   Exchange::ISO4217.stringify(49.567, :usd) #=> "USD 49.57"
+    #   Exchange::ISO.stringify(49.567, :usd) #=> "USD 49.57"
     # @example Convert a currency without minor to a string
-    #   Exchange::ISO4217.stringif(45, :jpy) #=> "JPY 45"
+    #   Exchange::ISO.stringif(45, :jpy) #=> "JPY 45"
     # @example Convert a currency with a three decimal minor to a string
-    #   Exchange::ISO4217.stringif(34.34, :omr) #=> "OMR 34.340"
+    #   Exchange::ISO.stringif(34.34, :omr) #=> "OMR 34.340"
     # @example Convert a currency to a string without the currency
-    #   Exchange::ISO4217.stringif(34.34, :omr, :amount_only => true) #=> "34.340"
+    #   Exchange::ISO.stringif(34.34, :omr, :amount_only => true) #=> "34.340"
     #
     def stringify(amount, currency, opts={})
       format      = "%.#{definitions[currency][:minor_unit]}f"
-      "#{currency.to_s.upcase + ' ' unless opts[:amount_only]}#{format % amount}"
+      pre         = [opts[:amount_only] && '', opts[:symbol] && (definitions[currency][:symbol] || currency.to_s.upcase), currency.to_s.upcase + ' '].detect{|a| a.is_a?(String)}
+      "#{pre}#{format % amount}"
     end
     
     # Use this to round a currency amount. This allows us to round exactly to the number of minors the currency has in the 
@@ -104,7 +114,7 @@ module Exchange
     # @param [BigDecimal, Fixed, Float, String] amount The amount of money you want to round
     # @param [String, Symbol] currency The currency you want to round the money in
     # @example Round a currency with 2 minors
-    #   Exchange::ISO4217.round("4523.456", "usd") #=> #<Bigdecimal 4523.46>
+    #   Exchange::ISO.round("4523.456", "usd") #=> #<Bigdecimal 4523.46>
     
     install_operation :round
     
@@ -113,7 +123,7 @@ module Exchange
     # @param [BigDecimal, Fixed, Float, String] amount The amount of money you want to ceil
     # @param [String, Symbol] currency The currency you want to ceil the money in
     # @example Ceil a currency with 2 minors
-    #   Exchange::ISO4217.ceil("4523.456", "usd") #=> #<Bigdecimal 4523.46>
+    #   Exchange::ISO.ceil("4523.456", "usd") #=> #<Bigdecimal 4523.46>
     
     install_operation :ceil
     
@@ -122,13 +132,44 @@ module Exchange
     # @param [BigDecimal, Fixed, Float, String] amount The amount of money you want to floor
     # @param [String, Symbol] currency The currency you want to floor the money in
     # @example Floor a currency with 2 minors
-    #   Exchange::ISO4217.floor("4523.456", "usd") #=> #<Bigdecimal 4523.46>
+    #   Exchange::ISO.floor("4523.456", "usd") #=> #<Bigdecimal 4523.46>
     
     install_operation :floor
     
     # Forwards the assure_time method to the instance using singleforwardable
     #
-    def_delegators :instance, :definitions, :instantiate, :stringify, :round, :ceil, :floor, :currencies, :defines?
+    def_delegators :instance, :definitions, :instantiate, :stringify, :round, :ceil, :floor, :currencies, :country_map, :defines?, :assert_currency!
+    
+    private
+    
+    # symbolizes keys and returns a new hash
+    #
+    def symbolize_keys hsh
+      new_hsh = Hash.new
+      
+      hsh.each_pair do |k,v| 
+        if v.is_a?(Hash)
+          v.keys.each do |key|
+            v[key.to_sym] = v.delete(key)
+          end
+        end
+        
+        new_hsh[k.downcase.to_sym] = v
+      end
+      
+      new_hsh
+    end
+    
+    # get a precision for a specified amount and a specified currency
+    # @params [Float, Integer] amount The amount to get the precision for
+    # @params [Symbol] currency the currency to get the precision for
+    #
+    def precision_for amount, currency
+      defined_minor_precision                         = definitions[currency][:minor_unit]
+      given_major_precision, given_minor_precision    = amount.to_s.match(/^-?(\d*)\.?(\d*)$/).to_a[1..2].map(&:size)
+      
+      given_major_precision + [defined_minor_precision, given_minor_precision].max
+    end
     
   end
 end

data/lib/exchange/money.rb

@@ -48,14 +48,16 @@ module Exchange
     #   Exchange::Money.new(40, :usd).to(:eur, :at => Time.gm(2012,9,1)) 
     #     #=> #<Exchange::Money @number=37.0 @currency=:usd @time=#<Time> @from=#<Exchange::Money @number=40.0 @currency=:usd>>
     #
-    def initialize value, currency_arg=nil, opts={}, &block      
+    def initialize value, currency_arg=nil, opts={}, &block
+      currency_arg      = ISO.assert_currency!(currency_arg) if currency_arg
+      
       @from             = opts[:from]
       @api              = Exchange.configuration.api.subclass
       
       yield(self) if block_given?
       
       self.time             = Helper.assure_time(time || opts[:at], :default => :now)
-      self.value            = ISO4217.instantiate(value, currency || currency_arg)
+      self.value            = ISO.instantiate(value, currency || currency_arg)
       self.currency         = currency || currency_arg
     end
     
@@ -81,6 +83,8 @@ module Exchange
     #   Exchange::Money.new(40,:nok).to(:sek, :at => Time.gm(2012,2,2))
     #
     def to other, options={}
+      other = ISO.assert_currency!(other)
+      
       if api_supports_currency?(other)
         opts = { :at => time, :from => self }.merge(options)
         Money.new(api.new.convert(value, currency, other, opts), other, opts)
@@ -88,6 +92,7 @@ module Exchange
         raise_no_rate_error(other)
       end
     end
+    alias :in :to
     
     class << self
       
@@ -98,7 +103,7 @@ module Exchange
         #
         def install_operation op
           define_method op do |*precision|
-            Exchange::Money.new(ISO4217.send(op, self.value, self.currency, precision.first), currency, :at => time, :from => self)
+            Exchange::Money.new(ISO.send(op, self.value, self.currency, precision.first), currency, :at => time, :from => self)
           end
         end
       
@@ -110,7 +115,7 @@ module Exchange
           self.class_eval <<-EOV
             def #{op}(other)
               test_for_currency_mix_error(other)
-              new_value = value #{op} (other.kind_of?(Money) ? other.to(self.currency, :at => other.time) : BigDecimal.new(other.to_s))
+              new_value = value #{op} (other.kind_of?(Money) ? other.to(self.currency, :at => other.time).value : BigDecimal.new(other.to_s))
               Exchange::Money.new(new_value, currency, :at => time, :from => self)
             end
           EOV
@@ -292,12 +297,12 @@ module Exchange
     # @example Convert a currency with a three decimal minor to a string
     #   Exchange::Money.new(34.34, :omr).to_s #=> "OMR 34.340"
     # @example Convert a currency to a string without the currency
-    #   Exchange::ISO4217.stringif(34.34, :omr).to_s(:iso) #=> "34.340"
+    #   Exchange::ISO.stringif(34.34, :omr).to_s(:iso) #=> "34.340"
     #
     def to_s format=:currency
       [
-        format == :currency && ISO4217.stringify(value, currency),
-        format == :amount && ISO4217.stringify(value, currency, :amount_only => true)
+        format == :currency && ISO.stringify(value, currency),
+        format == :amount && ISO.stringify(value, currency, :amount_only => true)
       ].detect{|l| l.is_a?(String) }
     end
     

data/lib/exchange/typecasting.rb

@@ -77,13 +77,13 @@ module Exchange
         att = send(attribute)
         attribute_setter = :"#{attribute}_without_exchange_typecasting="
         
-        if !data.respond_to?(:currency)
-          send(attribute_setter, data)
+        send(attribute_setter, if !data.respond_to?(:currency)
+          data
         elsif att.currency == data.currency
-          send(attribute_setter, data.value)
+          data.value
         elsif att.currency != data.currency
-          send(attribute_setter, data.to(att.currency).value)
-        end
+          data.to(att.currency).value
+        end)
       end
       exchange_typecasting_alias_method_chain attribute, '='
     end

data/spec/exchange/cache/configuration_spec.rb

@@ -39,6 +39,44 @@ describe "Exchange::Cache::Configuration" do
     end
   end
   
+  describe "setting and wiping the client" do
+    context "with a wipeable client" do
+      before(:each) do
+        subject.subclass = :memcached
+        subject.host = '127.0.0.1'
+        subject.port = 11211
+      end
+      after(:each) do
+        subject.subclass = :no_cache
+      end
+      it "should do so for the host" do
+        subject.subclass.client.should_not be_nil
+        subject.subclass.instance.instance_variable_get("@client").should_not be_nil
+        subject.host = 'new'
+        subject.subclass.instance.instance_variable_get("@client").should be_nil
+      end
+      it "should do so for the port" do
+        subject.subclass.client.should_not be_nil
+        subject.subclass.instance.instance_variable_get("@client").should_not be_nil
+        subject.port = 112
+        subject.subclass.instance.instance_variable_get("@client").should be_nil
+      end
+    end
+    context "without a wipeable client" do
+      before(:each) do
+        subject.subclass = :memory
+      end
+      it "should not fail for the host" do
+        subject.host = 'new'
+        subject.host.should == 'new'
+      end
+      it "should not fail for the port" do
+        subject.port = 11
+        subject.port.should == 11
+      end
+    end
+  end
+  
   describe "reset" do
     before(:each) do
       subject.set :subclass => :no_cache, :expire => :daily, :host => 'localhost', :port => 112211, :path => "PATH"