exchange 0.5.1 → 0.6.0

data/lib/exchange/external_api/json.rb

@@ -0,0 +1,22 @@
+module Exchange
+  module ExternalAPI
+    
+    # The json base class takes care of JSON apis. It assumes you would want to use json as a parser and preloads the gem
+    # Also, this may serve as a base for some operations which might be common to the json apis
+    # @author Beat Richartz
+    # @version 0.6
+    # @since 0.6
+    #
+    class JSON < Base
+      
+      # Initializer, essentially takes the arguments passed to initialization, loads the json gem on the way
+      # and passes the arguments to the api base
+      #
+      def initialize *args
+        Exchange::GemLoader.new('json').try_load unless defined?(::JSON)
+        super *args
+      end
+      
+    end
+  end
+end

data/lib/exchange/external_api/xavier_media.rb

@@ -6,8 +6,9 @@ module Exchange
     # @author Beat Richartz
     # @version 0.1
     # @since 0.1
-    
-    class XavierMedia < Base
+    #
+    class XavierMedia < XML
+      
       # The base of the Xaviermedia API URL
       API_URL              = "http://api.finance.xaviermedia.com/api"
       # The currencies the Xaviermedia API URL can handle
@@ -20,11 +21,11 @@ module Exchange
       # @option opts [Time, String] :at a historical date to get the exchange rates for
       # @example Update the currency bot API to use the file of March 2, 2010
       #   Exchange::ExternalAPI::XavierMedia.new.update(:at => Time.gm(3,2,2010))
-      
+      #
       def update(opts={})
         time       = Exchange::Helper.assure_time(opts[:at], :default => :now)
         api_url    = api_url(time)
-        retry_urls = Exchange::Configuration.retries.times.map{ |i| api_url(time - 86400 * (i+1)) }
+        retry_urls = Exchange.configuration.api.retries.times.map{ |i| api_url(time - 86400 * (i+1)) }
         
         Call.new(api_url, :format => :xml, :at => time, :retry_with => retry_urls) do |result|
           @base                 = result.css('basecurrency').children[0].to_s
@@ -38,7 +39,7 @@ module Exchange
         # A helper function which build a valid api url for the specified time
         # @param [Time] time The exchange rate date for which the URL should be built
         # @return [String] An Xaviermedia API URL for the specified time
-      
+        #
         def api_url(time)
           [API_URL, "#{time.strftime("%Y/%m/%d")}.xml"].join('/')
         end

data/lib/exchange/external_api/xml.rb

@@ -0,0 +1,22 @@
+module Exchange
+  module ExternalAPI
+    
+    # The xml base class takes care of XML apis. It assumes you would want to use nokogiri as a parser and preloads the gem
+    # Also, this may serve as a base for some operations which might be common to the xml apis
+    # @author Beat Richartz
+    # @version 0.6
+    # @since 0.6
+    #
+    class XML < Base
+      
+      # Initializer, essentially takes the arguments passed to initialization, loads nokogiri on the way
+      # and passes the arguments to the api base
+      #
+      def initialize *args
+        Exchange::GemLoader.new('nokogiri').try_load unless defined?(Nokogiri)
+        super *args
+      end
+      
+    end
+  end
+end

data/lib/exchange/gem_loader.rb

@@ -0,0 +1,35 @@
+module Exchange
+  
+  # The gem loader takes care of loading gems without adding too many unnecessary dependencies to the gem
+  # @author Beat Richartz
+  # @version 0.6
+  # @since 0.6
+  #
+  class GemLoader
+    
+    # The error that gets thrown if a needed gem is not available or loadable
+    #
+    GemNotFoundError  = Class.new LoadError
+
+    # initialize the loader with a gem name. 
+    # @param [string] gem The gem to require
+    # @return [Exchange::Gemloader] an instance of the gemloader
+    # @example initialize a loader for the nokogiri gem
+    #   Exchange::GemLoader.new('nokogiri')
+    #
+    def initialize gem
+      @gem = gem
+    end
+    
+    # Try to require the gem specified on initialization.
+    # @raise [GemNotFoundError] an error indicating that the gem could not be found rather than a load error
+    # @example Try to load the JSON gem
+    #   Exchange::GemLoader.new('json').try_load
+    #
+    def try_load
+      require @gem
+    rescue LoadError => e
+      raise GemNotFoundError.new("You specified #{@gem} to be used with Exchange, yet it is not loadable. Please install #{@gem} to be able to use it with Exchange")
+    end
+  end
+end

data/lib/exchange/helper.rb

@@ -1,27 +1,34 @@
+require 'singleton'
+require 'forwardable'
+
 module Exchange
+  
   # Helper Functions that get used throughout the gem can be placed here
   # @author Beat Richartz
-  # @version 0.3
+  # @version 0.6
   # @since 0.3
-  
+  #
   class Helper
-    class << self
+    include Singleton
+    extend SingleForwardable
     
-      # A helper function to assure a value is an instance of time
-      # @param [Time, String, NilClass] The value to be asserted
-      # @param [Hash] opts Options for assertion
-      # @option opts [Symbol] :default a method that can be sent to Time if the argument is nil (:now for example)
-      
-      def assure_time(arg=nil, opts={})
-        if arg
-          arg.kind_of?(Time) ? arg : Time.gm(*arg.split('-'))
-        elsif opts[:default]
-          Time.send(opts[:default])
-        end
+    # A helper function to assure a value is an instance of time
+    # @param [Time, String, NilClass] The value to be asserted
+    # @param [Hash] opts Options for assertion
+    # @option opts [Symbol] :default a method that can be sent to Time if the argument is nil (:now for example)
+    #
+    def assure_time(arg=nil, opts={})
+      if arg
+        arg.kind_of?(Time) ? arg : Time.gm(*arg.split('-'))
+      elsif opts[:default]
+        Time.send(opts[:default])
       end
-    
     end
     
+    # Forwards the assure_time method to the instance using singleforwardable
+    #
+    def_delegator :instance, :assure_time
+    
   end
   
 end

data/lib/exchange/iso_4217.rb

@@ -1,67 +1,74 @@
+require 'singleton'
+require 'forwardable'
+
 module Exchange
   
   # This class handles everything that has to do with certified formatting of the different currencies. The standard is stored in 
   # the iso4217 YAML file.
-  # @version 0.3
+  # @version 0.6
   # @since 0.3
   # @author Beat Richartz
-  
+  #
   class ISO4217
+    include Singleton
+    extend SingleForwardable
+    
     class << self
       
-      # The ISO 4217 that have to be loaded. Nothing much to say here. Just 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
-      
-      def definitions
-        @@definitions ||= YAML.load_file(File.join(EXCHANGE_GEM_ROOT_PATH, 'iso4217.yml'))
-      end
-      
-      # Use this to instantiate a currency amount. For one, it is important that we use BigDecimal here so nothing gets lost because
-      # of floating point errors. For the other, This allows us to set the precision exactly according to the iso definition
-      # @param [BigDecimal, Fixed, Float, String] amount The amount of money you want to instantiate
-      # @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>
-      
-      def instantiate(amount, currency)
-        BigDecimal.new(amount.to_s, definitions[currency.to_s.upcase]['minor_unit'])
-      end
-      
-      # Converts the currency to a string in ISO 4217 standardized format, either with or without the currency. This leaves you
-      # with no worries how to display the currency.
-      # @param [BigDecimal, Fixed, Float] amount The amount of currency you want to stringify
-      # @param [String, Symbol] currency The currency you want to stringify
-      # @param [Hash] opts The options for formatting
-      # @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"
-      # @example Convert a currency without minor to a string
-      #   Exchange::ISO4217.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"
-      # @example Convert a currency to a string without the currency
-      #   Exchange::ISO4217.stringif(34.34, :omr, :amount_only => true) #=> "34.340"
-      
-      def stringify(amount, currency, opts={})
-        format      = "%.#{definitions[currency.to_s.upcase]['minor_unit']}f"
-        "#{currency.to_s.upcase + ' ' unless opts[:amount_only]}#{format % amount}"
-      end
-      
       private
         # @private
         # @macro [attach] install_operations
       
         def install_operation op      
           self.class_eval <<-EOV
-            def self.#{op}(amount, currency, precision=nil)
+            def #{op}(amount, currency, precision=nil)
               minor = definitions[currency.to_s.upcase]['minor_unit']
               (amount.is_a?(BigDecimal) ? amount : BigDecimal.new(amount.to_s, minor)).#{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
+    # 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
+    #
+    def definitions
+      @@definitions ||= YAML.load_file(File.join(ROOT_PATH, 'iso4217.yml'))
+    end
+    
+    # Use this to instantiate a currency amount. For one, it is important that we use BigDecimal here so nothing gets lost because
+    # of floating point errors. For the other, This allows us to set the precision exactly according to the iso definition
+    # @param [BigDecimal, Fixed, Float, String] amount The amount of money you want to instantiate
+    # @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>
+    #
+    def instantiate(amount, currency)
+      BigDecimal.new(amount.to_s, definitions[currency.to_s.upcase]['minor_unit'])
+    end
+    
+    # Converts the currency to a string in ISO 4217 standardized format, either with or without the currency. This leaves you
+    # with no worries how to display the currency.
+    # @param [BigDecimal, Fixed, Float] amount The amount of currency you want to stringify
+    # @param [String, Symbol] currency The currency you want to stringify
+    # @param [Hash] opts The options for formatting
+    # @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"
+    # @example Convert a currency without minor to a string
+    #   Exchange::ISO4217.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"
+    # @example Convert a currency to a string without the currency
+    #   Exchange::ISO4217.stringif(34.34, :omr, :amount_only => true) #=> "34.340"
+    #
+    def stringify(amount, currency, opts={})
+      format      = "%.#{definitions[currency.to_s.upcase]['minor_unit']}f"
+      "#{currency.to_s.upcase + ' ' unless opts[:amount_only]}#{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 
@@ -91,5 +98,9 @@ module Exchange
     
     install_operation :floor
     
+    # Forwards the assure_time method to the instance using singleforwardable
+    #
+    def_delegators :instance, :definitions, :instantiate, :stringify, :round, :ceil, :floor
+    
   end
 end

data/spec/core_extensions/conversability_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe "Exchange::Conversability" do
   before(:all) do
-    Exchange::Configuration.cache = false
+    Exchange.configuration = Exchange::Configuration.new { |c| c.cache = { :subclass => :no_cache } }
   end
   before(:each) do
     @time = Time.gm(2012,8,27)
     Time.stub! :now => @time
   end
   after(:all) do
-    Exchange::Configuration.cache = :memcached
+    Exchange::configuration = Exchange::Configuration.new { |c| c.cache = { :subclass => :memcached } }
   end
   it "should define all currencies on Fixnum, Float and BigDecimal" do
     Exchange::ISO4217.definitions.keys.each do |c|

data/spec/exchange/cache/base_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "Exchange::Cache::Base" do
-  subject { Exchange::Cache::Base }
+  subject { Exchange::Cache::Base.instance }
   describe "key generation" do
     before(:each) do
       time = Time.gm 2012, 03, 01, 23, 23, 23
@@ -9,20 +9,20 @@ describe "Exchange::Cache::Base" do
     end
     context "with a daily cache" do
       it "should build a timestamped key with the class given, the yearday and the year" do
-        Exchange::Cache::Base.send(:key, :xavier_media).should == 'exchange_xavier_media_2012_61'
-        Exchange::Cache::Base.send(:key, :currency_bot).should == 'exchange_currency_bot_2012_61'
+        subject.send(:key, :xavier_media).should == 'exchange_xavier_media_2012_61'
+        subject.send(:key, :currency_bot).should == 'exchange_currency_bot_2012_61'
       end
     end
     context "with an hourly cache" do
       before(:each) do
-        Exchange::Configuration.update = :hourly
+        Exchange.configuration.cache.expire = :hourly
       end
       after(:each) do
-        Exchange::Configuration.update = :daily
+        Exchange.configuration.cache.expire = :daily
       end
       it "should build a timestamped key with the class given, the yearday, the year and the hour" do
-        Exchange::Cache::Base.send(:key, :xavier_media).should == 'exchange_xavier_media_2012_61_23'
-        Exchange::Cache::Base.send(:key, :currency_bot).should == 'exchange_currency_bot_2012_61_23'
+        subject.send(:key, :xavier_media).should == 'exchange_xavier_media_2012_61_23'
+        subject.send(:key, :currency_bot).should == 'exchange_currency_bot_2012_61_23'
       end
     end
   end

data/spec/exchange/cache/file_spec.rb

@@ -1,16 +1,21 @@
 require 'spec_helper'
 
 describe "Exchange::Cache::File" do
-  subject { Exchange::Cache::File }
+  subject { Exchange::Cache::File.instance }
   before(:each) do
-    Exchange::Configuration.define do |c|
-      c.cache      = :file
-    end
+    Exchange.configuration = Exchange::Configuration.new { |c|
+      c.cache      = {
+        :subclass => :file,
+        :path     => 'STORE/PATH'
+      }
+    }
   end
   after(:each) do
-    Exchange::Configuration.define do |c|
-      c.cache      = :memcached
-    end
+    Exchange.configuration = Exchange::Configuration.new { |c|
+      c.cache      = {
+        :subclass => :memcached
+      }
+    }
   end
   describe "cached" do
     it "should raise an error if no block was given" do
@@ -20,9 +25,8 @@ describe "Exchange::Cache::File" do
       context "with a daily cache" do
         before(:each) do
           subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
-          Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
-          ::File.should_receive(:exists?).with('STORE/KEY').and_return(true)
-          ::File.should_receive(:read).with('STORE/KEY').and_return 'CONTENT'
+          ::File.should_receive(:exists?).with('STORE/PATH/KEY').and_return(true)
+          ::File.should_receive(:read).with('STORE/PATH/KEY').and_return 'CONTENT'
         end
         it "should return the file contents" do
           subject.cached('API_CLASS') { 'something' }.should == 'CONTENT'
@@ -31,9 +35,8 @@ describe "Exchange::Cache::File" do
       context "with an monthly cache" do
         before(:each) do
           subject.should_receive(:key).with('API_CLASS', an_instance_of(Symbol)).and_return('KEY')
-          Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
-          ::File.should_receive(:exists?).with('STORE/KEY').and_return(true)
-          ::File.should_receive(:read).with('STORE/KEY').and_return 'CONTENT'
+          ::File.should_receive(:exists?).with('STORE/PATH/KEY').and_return(true)
+          ::File.should_receive(:read).with('STORE/PATH/KEY').and_return 'CONTENT'
         end
         it "should return the file contents" do
           subject.cached('API_CLASS', :cache_period => :monthly) { 'something' }.should == 'CONTENT'
@@ -43,9 +46,8 @@ describe "Exchange::Cache::File" do
     context "when no file is cached yet" do
       before(:each) do
         subject.should_receive(:key).with('API_CLASS', an_instance_of(Symbol)).at_most(3).times.and_return('KEY')
-        Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
-        ::File.should_receive(:exists?).with('STORE/KEY').and_return(false)
-        Dir.should_receive(:entries).with('STORE').once.and_return(%W(entry entry2))
+        ::File.should_receive(:exists?).with('STORE/PATH/KEY').and_return(false)
+        Dir.should_receive(:entries).with('STORE/PATH').once.and_return(%W(entry entry2))
         ::File.should_receive(:delete).with(an_instance_of(String)).twice
         FileUtils.should_receive(:mkdir_p).once
         ::File.should_receive(:open).once
@@ -57,8 +59,7 @@ describe "Exchange::Cache::File" do
     context "when no result is returned" do
       before(:each) do
         subject.should_receive(:key).with('API_CLASS', an_instance_of(Symbol)).at_most(3).times.and_return('KEY')
-        Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
-        ::File.should_receive(:exists?).with('STORE/KEY').and_return(false)
+        ::File.should_receive(:exists?).with('STORE/PATH/KEY').and_return(false)
         FileUtils.should_receive(:mkdir_p).never
         ::File.should_receive(:open).never
       end

data/spec/exchange/cache/memcached_spec.rb

@@ -1,41 +1,48 @@
 require 'spec_helper'
 
-describe "Exchange::Cache::Memcached" do
-  subject { Exchange::Cache::Memcached }
+describe "Exchange::CacheDalli::Client" do
+  subject { Exchange::Cache::Memcached.instance }
   before(:each) do
-    Exchange::Configuration.define do |c|
-      c.cache_host = 'HOST'
-      c.cache_port = 'PORT'
-    end
+    Exchange.configuration = Exchange::Configuration.new { |c|
+      c.cache = {
+        :host => 'HOST',
+        :port => 'PORT'
+      }
+    }
   end
   after(:each) do
-    Exchange::Configuration.define do |c|
-      c.cache_host = 'localhost'
-      c.cache_port = 11211
-    end
+    Exchange.configuration = Exchange::Configuration.new { |c|
+      c.cache = {
+        :host => 'localhost',
+        :port => 11211
+      }
+    }
   end
   describe "client" do
     let(:client) { mock('memcached') }
+    before(:each) do
+      Exchange::GemLoader.new('dalli').try_load
+    end
     after(:each) do
-      subject.send(:remove_class_variable, "@@client")
+      subject.instance_variable_set "@client", nil
     end
     it "should set up a client on the specified host and port for the cache" do
-      ::Memcached.should_receive(:new).with("HOST:PORT").and_return(client)
+      Dalli::Client.should_receive(:new).with("HOST:PORT").and_return(client)
       subject.client.should == client
     end
   end
   describe "cached" do
+    let(:client) { mock('memcached', :get => '') }
+    before(:each) do
+      Dalli::Client.should_receive(:new).with("HOST:PORT").and_return(client)
+    end
+    after(:each) do
+      subject.instance_variable_set "@client", nil
+    end
     it "should raise an error if no block was given" do
       lambda { subject.cached('API_CLASS') }.should raise_error(Exchange::Cache::CachingWithoutBlockError)
     end
     context "when a cached result exists" do
-      let(:client) { mock('memcached') }
-      before(:each) do
-        ::Memcached.should_receive(:new).with("HOST:PORT").and_return(client)
-      end
-      after(:each) do
-        subject.send(:remove_class_variable, "@@client")
-      end
       context "when loading json" do
         before(:each) do
           subject.should_receive(:key).with('API_CLASS', {}).and_return('KEY')
@@ -63,11 +70,7 @@ describe "Exchange::Cache::Memcached" do
       let(:client) { mock('memcached') }
       before(:each) do
         subject.should_receive(:key).with('API_CLASS', {}).twice.and_return('KEY')
-        ::Memcached.should_receive(:new).with("HOST:PORT").and_return(client)
-        client.should_receive(:get).with('KEY').and_raise(::Memcached::NotFound)
-      end
-      after(:each) do
-        subject.send(:remove_class_variable, "@@client")
+        client.should_receive(:get).with('KEY').and_return(nil)
       end
       context "with daily cache" do
         it "should call the block and set and return the result" do
@@ -77,10 +80,10 @@ describe "Exchange::Cache::Memcached" do
       end
       context "with hourly cache" do
         before(:each) do
-          Exchange::Configuration.update = :hourly
+          Exchange.configuration.cache.expire = :hourly
         end
         after(:each) do
-          Exchange::Configuration.update = :daily
+          Exchange.configuration.cache.expire = :daily
         end
         it "should call the block and set and return the result" do
           client.should_receive(:set).with('KEY', "{\"RESULT\":\"YAY\"}", 3600).once