exchange 0.8.0 → 0.9.0

data/lib/exchange/cache/configuration.rb

@@ -0,0 +1,24 @@
+module Exchange
+  module Cache
+    # @author Beat Richartz
+    # A Class that handles caching configuration options
+    # 
+    # @version 0.9
+    # @since 0.9
+    #
+    class Configuration < Exchange::Configurable
+      attr_accessor :expire, :host, :port, :path
+      
+      def_delegators :instance, :expire, :expire=, :host, :host=, :port, :port=, :path, :path=
+      
+      def parent_module
+        Cache
+      end
+      
+      def key
+        :cache
+      end
+    
+    end
+  end 
+end

data/lib/exchange/cache/file.rb

@@ -21,20 +21,18 @@ module Exchange
       #
       def cached api, opts={}, &block
         today = Time.now
-        dir   = Exchange.configuration.cache.path
+        dir   = config.path
         path  = ::File.join(dir, key(api, opts[:cache_period]))
         
         if ::File.exists?(path)
-          result = ::File.read(path)
+          result = opts[:plain] ? ::File.read(path) : ::File.read(path).decachify
         else
           result = super
           if result && !result.to_s.empty?
-            FileUtils.mkdir_p(dir) unless Dir.respond_to?(:exists?) && Dir.exists?(dir)
-            keep_files = [key(api, :daily), key(api, :monthly)]
-            Dir.entries(dir).each do |e|
-              ::File.delete(::File.join(dir, e)) unless keep_files.include?(e) || e.match(/\A\./)
-            end
-            ::File.open(path, 'w') {|f| f.write(result) }
+            make_sure_exists dir
+            clean!           dir, api
+            
+            ::File.open(path, 'w') {|f| f.write(result.cachify) }
           end
         end
         
@@ -49,12 +47,29 @@ module Exchange
       # @param [optional, Symbol] cache_period The time for which the data is valid
       # @return [String] A string that can be used as cache key
       # @example
-      #   Exchange::Cache::Base.key(Exchange::ExternalAPI::CurrencyBot, :monthly) #=> "Exchange_ExternalAPI_CurrencyBot_monthly_2012_1"
+      #   Exchange::Cache::Base.key(Exchange::ExternalAPI::OpenExchangeRates, :monthly) #=> "Exchange_ExternalAPI_CurrencyBot_monthly_2012_1"
       #
       def key(api_class, cache_period=:daily)
         time      = Time.now
         [api_class.to_s.gsub(/::/, '_'), cache_period, time.year, time.send(cache_period == :monthly ? :month : :yday)].join('_')
       end
+      
+      # Make sure the directory exists
+      # @param [String] dir the directory path
+      #
+      def make_sure_exists dir
+        FileUtils.mkdir_p(dir) unless Dir.respond_to?(:exists?) && Dir.exists?(dir)
+      end
+      
+      # Clean the files not needed anymore
+      # @param [String] dir the directory path
+      #
+      def clean! dir, api
+        keep_files = [key(api, :daily), key(api, :monthly)]
+        Dir.entries(dir).each do |e|
+          ::File.delete(::File.join(dir, e)) unless keep_files.include?(e) || e.match(/\A\./)
+        end
+      end
     
     end
   end

data/lib/exchange/cache/memcached.rb

@@ -22,7 +22,7 @@ module Exchange
       #
       def client
         Exchange::GemLoader.new('dalli').try_load unless defined?(::Dalli)
-        @client ||= Dalli::Client.new("#{Exchange.configuration.cache.host}:#{Exchange.configuration.cache.port}")
+        @client ||= Dalli::Client.new("#{config.host}:#{config.port}")
       end
       
       # returns either cached data from the memcached client or calls the block and caches it in memcached.
@@ -35,12 +35,12 @@ module Exchange
       #
       def cached api, opts={}, &block
         stored = client.get(key(api, opts))
-        result = opts[:plain] ? stored.to_s.gsub(/["\s+]/, '') : JSON.load(stored) if stored && !stored.empty?
+        result = opts[:plain] ? stored : stored.decachify if stored && !stored.to_s.empty?
         
         unless result
           result = super
           if result && !result.to_s.empty?
-            client.set key(api, opts), result.to_json, Exchange.configuration.cache.expire == :daily ? 86400 : 3600
+            client.set key(api, opts), result.cachify, config.expire == :daily ? 86400 : 3600
           end
         end
         

data/lib/exchange/cache/memory.rb

@@ -0,0 +1,89 @@
+module Exchange
+  module Cache
+    # @author Beat Richartz
+    # A class that uses instance variables on the cache singleton class to store values in memory
+    # 
+    # @version 0.1
+    # @since 0.1
+    # @example Activate caching via memory by setting the cache in the configuration to :memory
+    #   Exchange::Configuration.define do |c| 
+    #     c.cache = :memory
+    #   end
+    #
+    class Memory < Base
+        
+      # returns either cached data from an instance variable or calls the block and caches it in an instance variable.
+      # 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
+      # @param [Hash] opts the options to cache with
+      # @option opts [Time] :at the historic time of the exchange rates to be cached
+      # @yield [] This method takes a mandatory block with an arity of 0 for caching
+      # @raise [CachingWithoutBlockError] an Argument Error when no mandatory block has been given
+      #
+      def cached api, opts={}, &block
+        ivar_name = instance_variable_name(api, opts)
+
+        result = instance_variable_get(ivar_name) 
+        
+        unless result && !result.to_s.empty?
+          result = super
+
+          if result && !result.to_s.empty?
+            instance_variable_set(ivar_name, result)
+          end 
+
+          clean!
+        end
+        
+        opts[:plain] ? result.cachify : result
+      end
+      
+      private
+      
+      # Generate an instance variable name for the memory cache to get and set
+      # @param [Exchange::ExternalAPI::Subclass] api The API to store the data for
+      # @param [Hash] opts The options for caching
+      # @return [String] A string that can be used as instance variable name
+      #
+      def instance_variable_name(api, opts)
+        conversion_time          = helper.assure_time(opts[:at], :default => :now)
+        time                     = Time.now
+        expire_hourly            = config.expire == :hourly || nil
+        
+        [
+          '@' + api.to_s.downcase.gsub(/::/, '_'),
+          conversion_time.year.to_s,
+          conversion_time.yday.to_s,
+          expire_hourly && conversion_time.hour.to_s,
+          time.year.to_s, 
+          time.yday.to_s, 
+          expire_hourly && time.hour.to_s,
+          opts[:key_for] && opts[:key_for].join('_')
+        ].compact.join('_')
+      end
+      
+      # Clean the memory from expired exchange instance variables. This removes instance variables matching
+      # only the specific key pattern
+      # @return [Array] The still persisting instance variables
+      #
+      def clean!
+        time = Time.now
+        
+        instance_variables.select do |i|
+          condition = false
+          match = i.to_s.match(/\A@exchange[^\d]+\d{4}_\d{1,3}_?\d{0,2}_(\d{4})_(\d{1,3})_?(\d{1,2})?/)
+          
+          if match
+            condition = match[1].to_i != time.year || match[2].to_i != time.yday
+            condition = match[3].to_i != time.hour if match[3]
+          end
+          
+          condition
+        end.each do |i|
+          remove_instance_variable i
+        end
+      end
+      
+    end
+  end
+end

data/lib/exchange/cache/rails.rb

@@ -34,7 +34,7 @@ module Exchange
       def cached api, opts={}, &block
         raise CachingWithoutBlockError.new('Caching needs a block') unless block_given?
         
-        result = client.fetch key(api, opts), :expires_in => Exchange.configuration.cache.expire == :daily ? 86400 : 3600, &block
+        result = client.fetch key(api, opts), :expires_in => config.expire == :daily ? 86400 : 3600, &block
         client.delete(key(api, opts)) unless result && !result.to_s.empty?
         
         result

data/lib/exchange/cache/redis.rb

@@ -21,7 +21,7 @@ module Exchange
       #
       def client
         Exchange::GemLoader.new('redis').try_load unless defined?(::Redis)
-        @client ||= ::Redis.new(:host => Exchange.configuration.cache.host, :port => Exchange.configuration.cache.port)
+        @client ||= ::Redis.new(:host => config.host, :port => config.port)
       end
       
       # returns either cached data from the redis client or calls the block and caches it in redis.
@@ -34,12 +34,12 @@ module Exchange
       #
       def cached api, opts={}, &block          
         if result = client.get(key(api, opts))
-          result = opts[:plain] ? result.gsub(/["\s+]/, '') : JSON.load(result)
+          result = opts[:plain] ? result : result.decachify
         else
           result = super
           if result && !result.to_s.empty?
-            client.set key(api, opts), result.to_json
-            client.expire key(api, opts), Exchange.configuration.cache.expire == :daily ? 86400 : 3600
+            client.set key(api, opts), result.cachify
+            client.expire key(api, opts), config.expire == :daily ? 86400 : 3600
           end
         end
         

data/lib/exchange/configurable.rb

@@ -0,0 +1,53 @@
+require 'singleton'
+require 'forwardable'
+
+module Exchange
+  
+  class Configurable
+    include Singleton
+    extend SingleForwardable
+    
+    attr_accessor :subclass
+    
+    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)
+      subclass_without_constantize
+    end
+    alias_method :subclass_without_constantize, :subclass
+    alias_method :subclass, :subclass_with_constantize
+    
+    def set hash
+      hash.each_pair do |k,v|
+        self.send(:"#{k}=", v)
+      end
+      
+      self
+    end
+    
+    def reset
+      set Exchange::Configuration::DEFAULTS[key]
+    end
+    
+    [:key, :parent_module].each do |subclass_method|
+      define_method subclass_method do
+        raise StandardError.new("Subclass Responsibility")
+      end
+    end
+    
+    private
+
+      # Camelize a string or a symbol
+      # @param [String, Symbol] s The string to camelize
+      # @return [String] a camelized string
+      # @example Camelize an underscored symbol
+      #   camelize(:some_thing) #=> "SomeThing"
+      #
+      def camelize s
+        s = s.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+    
+  end
+  
+end

data/lib/exchange/configuration.rb

@@ -50,11 +50,16 @@ module Exchange
         # @private
         # @macro [getter] install_getter
         #
-        def install_getter key, parent_module
+        def install_getter key
           define_method key do
             config_part = @config[key]
-            config_part = OpenStruct.new(config_part) unless config_part.is_a?(OpenStruct)
-            config_part.subclass = parent_module.const_get camelize(config_part.subclass) unless config_part.subclass.is_a?(Class)
+            
+            if key == :api && !config_part.is_a?(ExternalAPI::Configuration)
+              config_part = ExternalAPI::Configuration.set(config_part)
+            elsif key == :cache && !config_part.is_a?(Cache::Configuration)
+              config_part = Cache::Configuration.set(config_part)
+            end
+
             @config[key] = config_part
           end
         end
@@ -68,13 +73,16 @@ module Exchange
     DEFAULTS = { 
                   :api => {
                     :subclass => ExternalAPI::XavierMedia, 
-                    :retries => 5
+                    :retries => 5,
+                    :protocol => :http,
+                    :app_id => nil
                   },
                   :cache => {
-                    :subclass => Cache::Memcached,
-                    :host => 'localhost',
-                    :port => 11211,
-                    :expire => :daily
+                    :subclass => Cache::Memory,
+                    :expire => :daily,
+                    :path => nil,
+                    :host => nil,
+                    :port => nil
                   },
                   :allow_mixed_operations => true
                 }
@@ -85,7 +93,7 @@ module Exchange
     # @param [Hash] configuration The configuration as a hash
     # @param [Proc] block A block to yield the configuration with
     # @example Define the configuration with a hash
-    #   Exchange::Configuration.new(:allow_mixed_operations => false, :api => {:subclass => :currency_bot, :retries => 2})
+    #   Exchange::Configuration.new(:allow_mixed_operations => false, :api => {:subclass => :open_exchange_rates, :retries => 2})
     # @example Define the configuration with a block
     #   Exchange::Configuration.new do |c|
     #     c.allow_mixed_operations = false
@@ -100,6 +108,16 @@ module Exchange
       super()
     end 
     
+    # Allows to reset the configuration to the defaults
+    # @version 0.9
+    # @since 0.9
+    #
+    def reset
+      api.reset
+      cache.reset
+      self.allow_mixed_operations = DEFAULTS[:allow_mixed_operations]
+    end
+    
     # Getter for the mixed operations configuration. If set to true, operations with mixed currencies will not raise errors
     # If set to false, mixed operations will raise errors
     # @since 0.6
@@ -120,7 +138,7 @@ module Exchange
     def allow_mixed_operations= data
       @config[:allow_mixed_operations] = data
     end
-    
+        
     # Setter for the api configuration.
     # @since 0.6
     # @version 0.6
@@ -147,27 +165,15 @@ module Exchange
     
     # Getter for the api configuration. Instantiates the configuration as an open struct, if called for the first time.
     # Also camelizes and constantizes the api subclass, if used for the first time.
-    # @return [OpenStruct] an openstruct with the complete api configuration
+    # @return [Exchange::ExternalAPI::Configuration] an api configuration
     #
-    install_getter :api, ExternalAPI
+    install_getter :api
     
     # Getter for the cache configuration. Instantiates the configuration as an open struct, if called for the first time.
     # Also camelizes and constantizes the cache subclass, if used for the first time.
-    # @return [OpenStruct] an openstruct with the complete cache configuration
+    # @return [Exchange::Cache::Configuration] a cache configuration
     #
-    install_getter :cache, Cache
-
-    private
-      
-      # Camelize a string or a symbol
-      # @param [String, Symbol] s The string to camelize
-      # @return [String] a camelized string
-      # @example Camelize an underscored symbol
-      #   camelize(:some_thing) #=> "SomeThing"
-      #
-      def camelize s
-        s = s.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
-      end
+    install_getter :cache
       
   end
 end

data/lib/exchange/core_extensions.rb

@@ -0,0 +1,3 @@
+require 'exchange/core_extensions/numeric/conversability'
+require 'exchange/core_extensions/float/error_safe'
+require 'exchange/core_extensions/cachify'

data/lib/exchange/core_extensions/cachify.rb

@@ -0,0 +1,25 @@
+module Exchange
+  module Cachify
+    
+    def cachify
+      Marshal.dump self
+    end
+    
+  end
+  
+  module Decachify
+    
+    def decachify
+      Marshal.load self
+    end
+    
+  end
+end
+
+Numeric.send  :include, Exchange::Cachify
+String.send   :include, Exchange::Cachify
+Symbol.send   :include, Exchange::Cachify
+String.send   :include, Exchange::Decachify
+Hash.send     :include, Exchange::Cachify
+Array.send    :include, Exchange::Cachify
+NilClass.send :include, Exchange::Cachify

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

@@ -0,0 +1,25 @@
+module Exchange
+  
+  # Make Floating Points forget about their incapabilities when dealing with money
+  #
+  module ErrorSafe
+    
+    def self.included base
+      %W(* / + -).each do |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
+          else
+            send(:"#{meth}with_errors", other)
+          end
+        })
+        base.send :alias_method, :"#{meth}with_errors", meth.to_sym
+        base.send :alias_method, meth.to_sym, :"#{meth}without_errors"
+      end
+    end
+    
+  end
+  
+end
+
+Float.send(:include, Exchange::ErrorSafe)