exchange 0.2.6

data/lib/core_extensions/conversability.rb

@@ -0,0 +1,32 @@
+module Exchange
+  
+  # The conversability module which will get included in Fixnum and Float, giving them the currency exchange methods
+  # @author Beat Richartz
+  # @version 0.2
+  # @since 0.1
+  
+  module Conversability
+    # Method missing is used here to allow instantiation and immediate conversion of Currency objects from a common Fixnum or Float
+    # @example Instantiate from any type of number
+    #   40.usd => #<Exchange::Currency @value=40 @currency=:usd>
+    #   -33.nok => #<Exchange::Currency @value=-33 @currency=:nok>
+    #   33.333.sek => #<Exchange::Currency @value=33.333 @currency=:sek>
+    # @example Instantiate and immediatly convert
+    #   1.usd.to_eur => #<Exchange::Currency @value=0.79 @currency=:eur>
+    #   1.nok.to_chf => #<Exchange::Currency @value=6.55 @currency=:chf>
+    #   -3.5.dkk.to_huf => #<Exchange::Currency @value=-346.55 @currency=:huf>
+    # @example Instantiate and immediatly convert at a specific time in the past
+    #   1.usd.to_eur(:at => Time.now - 86400) => #<Exchange::Currency @value=0.80 @currency=:eur>
+    #   1.nok.to_chf(:at => Time.now - 3600) => #<Exchange::Currency @value=6.57 @currency=:chf>
+    #   -3.5.dkk.to_huf(:at => Time.now - 172800) => #<Exchange::Currency @value=-337.40 @currency=:huf>
+    
+    def method_missing method, *args, &block
+      return Exchange::Currency.new(self, method, *args) if method.to_s.length == 3 && Exchange::Configuration.api_class::CURRENCIES.include?(method.to_s)
+    
+      super method, *args, &block
+    end
+  end
+end
+
+Fixnum.send :include, Exchange::Conversability
+Float.send  :include, Exchange::Conversability

data/lib/exchange.rb

@@ -0,0 +1,11 @@
+require 'open-uri'
+require 'bundler'
+require 'json'
+require 'nokogiri'
+require 'redis'
+require 'memcached'
+require 'exchange/configuration'
+require 'exchange/currency'
+require 'exchange/external_api'
+require 'exchange/cache'
+require 'core_extensions/conversability'

data/lib/exchange/cache.rb

@@ -0,0 +1,4 @@
+require 'exchange/cache/base'
+require 'exchange/cache/memcached'
+require 'exchange/cache/redis'
+require 'exchange/cache/rails'

data/lib/exchange/cache/base.rb

@@ -0,0 +1,51 @@
+module Exchange
+  # The cache module. All Classes handling caching for this gem have to be placed here. Allows easy extension with own caching solutions
+  # as shown in the example below.
+  # @example Write your own caching module
+  #   module Cache
+  #     class MyCustomCache < Base
+  #       class << self
+  #         # a cache class has to have the class method "cached"
+  #         def cached api, opts={}, &block
+  #           # generate the key with key(api, opts[:at]) and you will get a unique key to store in your cache
+  #           # Your code goes here
+  #         end
+  #       end
+  #     end
+  #   end
+  #   # Now, you can configure your Caching solution in the configuration. The Symbol will get camelcased and constantized
+  #   Exchange::Configuration.cache = :my_custom_cache
+  #   # Have fun, and don't forget to write tests.
+  
+  module Cache
+    
+    # The base Class for all Caching operations. Essentially generates a helper function for all cache classes to generate a key
+    # @author Beat Richartz
+    # @version 0.1
+    # @since 0.1
+    
+    class Base
+      class << self
+        
+        protected
+        
+          # A Cache Key generator for the API Classes and the time
+          # Generates a key which can handle expiration by itself
+          # @param [Exchange::ExternalAPI::Subclass] api_class The API to store the data for
+          # @param [optional, Time] time 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, Time.gm(2012,1,1)) #=> "Exchange_ExternalAPI_CurrencyBot_2012_1"
+          
+          def key(api_class, time=nil)
+            time      ||= Time.now
+            key_parts = [api_class.to_s.gsub(/::/, '_'), time.year, time.yday]
+            key_parts << time.hour if Exchange::Configuration.update == :hourly
+            key_parts.join('_')
+          end
+        
+      end
+    end
+    CachingWithoutBlockError = Class.new(ArgumentError)
+  end
+end

data/lib/exchange/cache/memcached.rb

@@ -0,0 +1,52 @@
+module Exchange
+  module Cache
+    # @author Beat Richartz
+    # A class that cooperates with the memcached gem to cache the data from the exchange api in memcached
+    # 
+    # @version 0.1
+    # @since 0.1
+    # @example Activate caching via memcache by setting the cache in the configuration to :memcached
+    #   Exchange::Configuration.define do |c| 
+    #     c.cache = :memcached
+    #     c.cache_host = 'Your memcached host' 
+    #     c.cache_port = 'Your memcached port'
+    #   end
+    class Memcached < Base
+      class << self
+        
+        # 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
+        #   Exchange::Cache::Memcached.client.set('FOO', 'BAR')
+        # @return [::Memcached] an instance of the memcached client gem class
+        
+        def client
+          @@client ||= ::Memcached.new("#{Exchange::Configuration.cache_host}:#{Exchange::Configuration.cache_port}")
+        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
+        # @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 and calls it if no cached result is available
+        # @raise [CachingWithoutBlockError] an Argument Error when no mandatory block has been given
+         
+        def cached api, opts={}, &block
+          raise CachingWithoutBlockError.new('Caching needs a block') unless block_given?
+          begin
+            result = JSON.load client.get(key(api, opts[:at]))
+          rescue ::Memcached::NotFound
+            result = block.call
+            if result && !result.empty?
+              client.set key(api, opts[:at]), result.to_json, Exchange::Configuration.update == :daily ? 86400 : 3600
+            end
+          end
+          
+          result
+        end
+        
+      end
+    end
+  end
+end

data/lib/exchange/cache/rails.rb

@@ -0,0 +1,45 @@
+module Exchange
+  module Cache
+    # @author Beat Richartz
+    # A class that cooperates with rails to cache the data from the exchange api in rails
+    # 
+    # @version 0.1
+    # @since 0.1
+    # @example Activate caching via rails by setting the cache in the configuration to :rails
+    #   Exchange::Configuration.define do |c| 
+    #     c.cache = :rails
+    #   end
+    class Rails < Base
+      class << self
+        
+        # returns a Rails cache client. This has not to be stored since rails already memoizes it.
+        # Use this client to access rails cache data. For further explanation of use visit the rails documentation
+        # @example
+        #   Exchange::Cache::Rails.client.set('FOO', 'BAR')
+        # @return [ActiveSupport::Cache::Subclass] an instance of the rails cache class (presumably a subclass of ActiveSupport::Cache)
+        
+        def client
+          ::Rails.cache if defined?(::Rails)
+        end
+        
+        # returns either cached data from the memcached client or calls the block and caches it in rails cache.
+        # 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 and calls it if no cached result is available
+        # @raise [CachingWithoutBlockError] an Argument Error when no mandatory block has been given
+        
+        def cached api, opts={}, &block
+          raise CachingWithoutBlockError.new('Caching needs a block') unless block_given?
+          
+          result = client.fetch key(api, opts[:at]), :expires_in => Exchange::Configuration.update == :daily ? 86400 : 3600, &block
+          client.delete(key(api, opts[:at])) unless result && !result.empty?
+          
+          result
+        end
+        
+      end
+    end
+  end
+end

data/lib/exchange/cache/redis.rb

@@ -0,0 +1,54 @@
+module Exchange
+  module Cache
+    # @author Beat Richartz
+    # A class that cooperates with the redis gem and the redis key value store to cache the data from the exchange api in redis
+    # 
+    # @version 0.1
+    # @since 0.1
+    # @example Activate caching via redis by setting the cache in the configuration to :redis
+    #   Exchange::Configuration.define do |c| 
+    #     c.cache = :redis
+    #     c.cache_host = 'Your redis host' 
+    #     c.cache_port = 'Your redis port (an Integer)'
+    #   end
+    class Redis < Base
+      class << self
+        
+        # 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
+        #   Exchange::Cache::Redis.client.set('FOO', 'BAR')
+        # @return [::Redis] an instance of the redis client gem class
+        
+        def client
+          @@client ||= ::Redis.new(:host => Exchange::Configuration.cache_host, :port => Exchange::Configuration.cache_port)
+        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
+        # @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 and calls it if no cached result is available
+        # @raise [CachingWithoutBlockError] an Argument Error when no mandatory block has been given
+        
+        def cached api, opts={}, &block
+          raise CachingWithoutBlockError.new('Caching needs a block') unless block_given?
+          
+          if result = client.get(key(api, opts[:at]))
+            result = JSON.load result
+          else
+            result = block.call
+            if result && !result.empty?
+              client.set key(api, opts[:at]), result.to_json
+              client.expire key(api, opts[:at]), Exchange::Configuration.update == :daily ? 86400 : 3600
+            end
+          end
+          
+          result
+        end
+        
+      end
+    end
+  end
+end

data/lib/exchange/configuration.rb

@@ -0,0 +1,72 @@
+module Exchange
+  # @author Beat Richartz
+  # A configuration class that stores the configuration of the gem. It allows to set the api from which the data gets retrieved,
+  # the cache in which the data gets cached, the regularity of updates for the currency rates, how many times the api calls should be 
+  # retried on failure, and wether operations mixing currencies should raise errors or not
+  # @version 0.1
+  # @since 0.1
+  class Configuration    
+    class << self
+      @@config ||= {:api => :currency_bot, :retries => 5, :allow_mixed_operations => true, :cache => :memcached, :cache_host => 'localhost', :cache_port => 11211, :update => :daily} 
+      
+      # A configuration method that stores the configuration of the gem. It allows to set the api from which the data gets retrieved,
+      # the cache in which the data gets cached, the regularity of updates for the currency rates, how many times the api calls should be 
+      # retried on failure, and wether operations mixing currencies should raise errors or not
+      # @version 0.1
+      # @since 0.1
+      # @example Set a configuration by passing a block to the configuration
+      #   Exchange::Configuration.define do |c| 
+      #     c.cache       = :redis
+      #     c.cache_host  = '127.0.0.1'
+      #     c.cache_port  = 6547
+      #     c.api         = :currency_bot
+      #     c.retries     = 1
+      #     c.allow_mixed_operations  = false
+      #     c.update      = :hourly
+      #   end
+      # @yield [Exchange::Configuration] yields a the configuration class
+      # @yieldparam [optional, Symbol] cache The cache type to use. Possible Values: :redis, :memcached or :rails or false to disable caching. Defaults to :memcached
+      # @yieldparam [optional, String] cache_host A string with the hostname or IP to set the cache host to. Does not have to be set for Rails cache
+      # @yieldparam [optional, Integer] cache_port An integer for the cache port. Does not have to be set for Rails cache
+      # @yieldparam [optional, Symbol] api The API to use. Possible Values: :currency_bot (Open Source currency bot API) or :xavier_media (Xavier Media API). Defaults to :currency_bot
+      # @yieldparam [optional, Integer] retries The number of times the gem should retry to connect to the api host. Defaults to 5.
+      # @yieldparam [optional, Boolean] If set to false, Operations with with different currencies raise errors. Defaults to true.
+      # @yieldparam [optional, Symbol] The regularity of updates for the API. Possible values: :daily, :hourly. Defaults to :daily.
+      # @example Set configuration values directly to the class
+      #   Exchange::Configuration.cache = :redis
+      #   Exchange::Configuration.api   = :xavier_media
+      def define &blk
+        self.instance_eval(&blk)
+      end
+      
+      [:api, :retries, :cache, :cache_host, :cache_port, :update, :allow_mixed_operations].each do |m|
+        define_method m do
+          @@config[m]
+        end
+        define_method :"#{m}=" do |data|
+          @@config.merge! m => data
+        end
+      end
+      
+      # The instantiated api class according to the configuration
+      # @example
+      #   Exchange::Configuration.api = :currency_bot
+      #   Exchange::Configuration.api_class #=> Exchange::ExternalAPI::CurrencyBot
+      # @return [Exchange::ExternalAPI::Subclass] A subclass of Exchange::ExternalAPI
+      
+      def api_class
+        Exchange::ExternalAPI.const_get self.api.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+      
+      # The instantiated cache class according to the configuration
+      # @example
+      #   Exchange::Configuration.cache = :redis
+      #   Exchange::Configuration.cache_class #=> Exchange::ExternalAPI::Redis
+      # @return [Exchange::Cache::Subclass] A subclass of Exchange::Cache (or nil if caching has been set to false)
+      
+      def cache_class
+        Exchange::Cache.const_get self.cache.to_s.gsub(/(?:^|_)(.)/) { $1.upcase } if self.cache
+      end
+    end 
+  end
+end

data/lib/exchange/currency.rb

@@ -0,0 +1,237 @@
+# Top Level Module of the the gem.
+# @author Beat Richartz
+# @version 0.1
+# @since 0.1
+
+module Exchange
+  # @author Beat Richartz
+  # Currency Objects instantiated from the currency class can be used for basic mathematical operations and currency conversions
+  # @version 0.1
+  # @since 0.1
+  class Currency
+    include Comparable
+    
+    # @attr_reader
+    # @return [Float] number The number the currency object has been instantiated from
+    attr_reader :value
+    
+    # @attr_reader
+    # @return [Symbol, String] currency the currency of the currency object
+    attr_reader :currency
+    
+    # @attr_reader
+    # @return [Time] The time at which the conversion has taken place or should take place if the object is involved in operations
+    attr_reader :time
+    
+    # @attr_reader
+    # @return [Exchange::Currency] The original currency object this currency object was converted from
+    attr_reader :from
+    
+    # Intialize the currency with a number and a currency
+    # @param [Integer, Float] number The number the currency is instantiated from
+    # @param [String, Symbol] currency The currency the currency object is in
+    # @param [Hash] opts Optional Parameters for instantiation
+    # @option opts [Time] :at The time at which conversion took place
+    # @option opts [String,Symbol] :from The currency object this currency object was converted from
+    # @version 0.2
+    #
+    # @example Instantiate a currency object of 40 US Dollars
+    #   Exchange::Currency.new(40, :usd) 
+    #     #=> #<Exchange::Currency @number=40.0 @currency=:usd @time=#<Time>>
+    # @example Instantiate a currency object of 40 US Dollars and convert it to Euro. It shows the conversion date and the original currency
+    #   Exchange::Currency.new(40, :usd).to_eur(:at => Time.gm(2012,9,1)) 
+    #     #=> #<Exchange::Currency @number=37.0 @currency=:usd @time=#<Time> @from=#<Exchange::Currency @number=40.0 @currency=:usd>>
+    
+    def initialize value, currency, opts={}
+      @value            = value.to_f
+      @currency         = currency
+      @time             = assure_time(opts[:at], :default => :now)
+      @from             = opts[:from] if opts[:from]
+    end
+    
+    # Method missing is used to handle conversions from one currency object to another. It only handles currencies which are available in
+    # the API class set in the configuration.
+    # @example Calls convert_to with 'chf'
+    #   Exchange::Currency.new(40,:usd).to_chf
+    # @example Calls convert_to with 'sek' and :at => Time.gm(2012,2,2)
+    #   Exchange::Currency.new(40,:nok).to_sek(:at => Time.gm(2012,2,2))
+    
+    def method_missing method, *args, &block
+      if method.to_s.match(/\Ato_(\w+)/) && Exchange::Configuration.api_class::CURRENCIES.include?($1)
+        args.first[:at] ||= time if args.first
+        return self.convert_to($1, args.first || {:at => self.time})
+      end
+
+      self.value.send method, *args, &block
+    end
+    
+    # Converts this instance of currency into another currency
+    # @return [Exchange::Currency] An instance of Exchange::Currency with the converted number and the converted currency
+    # @param [Symbol, String] other The currency to convert the number to
+    # @param [Hash] opts An options hash
+    # @option [Time] :at The timestamp of the rate the conversion took place in
+    # @example convert to 'chf'
+    #   Exchange::Currency.new(40,:usd).convert_to('chf')
+    # @example convert to 'sek' at a specific rate
+    #   Exchange::Currency.new(40,:nok).convert_to('sek', :at => Time.gm(2012,2,2))
+    
+    def convert_to other, opts={}
+      Exchange::Currency.new(Exchange::Configuration.api_class.new.convert(value, currency, other, opts), other, opts.merge(:from => self))
+    end
+    
+    class << self
+      
+      private
+        # @private
+        # @macro [attach] install_operations
+         
+        def install_operation op
+          define_method op do
+            @value = self.value.send(op)
+            self
+          end
+        end
+      
+        # @private
+        # @macro [attach] base_operations
+        #   @method $1(other)
+      
+        def base_operation op
+          self.class_eval <<-EOV
+            def #{op}(other)
+              #{'raise Exchange::CurrencyMixError.new("You\'re trying to mix up #{self.currency} with #{other.currency}. You denied mixing currencies in the configuration, allow it or convert the currencies before mixing") if !Exchange::Configuration.allow_mixed_operations && other.kind_of?(Exchange::Currency) && other.currency != self.currency'}
+              @value #{op}= other.kind_of?(Exchange::Currency) ? other.convert_to(self.currency, :at => other.time) : other
+              self
+            end
+          EOV
+        end
+      
+    end
+    
+    # Round the currency (Equivalent to normal round)
+    # @return [Exchange::Currency] The currency you started with with a rounded value
+    # @example
+    #   Exchange::Currency.new(40.5, :usd).round
+    #     #=> #<Exchange::Currency @number=41 @currency=:usd>
+    
+    install_operation :round
+    
+    
+    # Ceil the currency (Equivalent to normal ceil)
+    # @return [Exchange::Currency] The currency you started with with a ceiled value
+    # @example
+    #   Exchange::Currency.new(40.4, :usd).ceil
+    #     #=> #<Exchange::Currency @number=41 @currency=:usd>
+    
+    install_operation :ceil
+    
+    
+    # Floor the currency (Equivalent to normal floor)
+    # @return [Exchange::Currency] The currency you started with with a floored value
+    # @example
+    #   Exchange::Currency.new(40.7, :usd).floor
+    #     #=> #<Exchange::Currency @number=40 @currency=:usd>
+    
+    install_operation :floor
+    
+    
+    # Add value to the currency
+    # @param [Integer, Float, Exchange::Currency] other The value to be added to the currency. If an Exchange::Currency, it is converted to the instance's currency and then the converted value is added.
+    # @return [Exchange::Currency] The currency with the added value
+    # @raise [CurrencyMixError] If the configuration does not allow mixed operations, this method will raise an error if two different currencies are used in the operation
+    # @example Configuration disallows mixed operations
+    #   Exchange::Configuration.allow_mixed_operations = false
+    #   Exchange::Currency.new(20,:nok) + Exchange::Currency.new(20,:sek)
+    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    # @example Configuration allows mixed operations (default)
+    #   Exchange::Currency.new(20,:nok) + Exchange::Currency.new(20,:sek)
+    #     #=> #<Exchange::Currency @value=37.56 @currency=:nok>
+    
+    base_operation '+'
+    
+    # Subtract a value from the currency
+    # @param [Integer, Float, Exchange::Currency] other The value to be subtracted from the currency. If an Exchange::Currency, it is converted to the instance's currency and then subtracted from the converted value.
+    # @return [Exchange::Currency] The currency with the added value
+    # @raise [CurrencyMixError] If the configuration does not allow mixed operations, this method will raise an error if two different currencies are used in the operation
+    # @example Configuration disallows mixed operations
+    #   Exchange::Configuration.allow_mixed_operations = false
+    #   Exchange::Currency.new(20,:nok) - Exchange::Currency.new(20,:sek)
+    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    # @example Configuration allows mixed operations (default)
+    #   Exchange::Currency.new(20,:nok) - Exchange::Currency.new(20,:sek)
+    #     #=> #<Exchange::Currency @value=7.56 @currency=:nok>
+    
+    base_operation '-'
+    
+    # Multiply a value with the currency
+    # @param [Integer, Float, Exchange::Currency] other The value to be multiplied with the currency. If an Exchange::Currency, it is converted to the instance's currency and multiplied with the converted value.
+    # @return [Exchange::Currency] The currency with the multiplied value
+    # @raise [CurrencyMixError] If the configuration does not allow mixed operations, this method will raise an error if two different currencies are used in the operation
+    # @example Configuration disallows mixed operations
+    #   Exchange::Configuration.allow_mixed_operations = false
+    #   Exchange::Currency.new(20,:nok) * Exchange::Currency.new(20,:sek)
+    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    # @example Configuration allows mixed operations (default)
+    #   Exchange::Currency.new(20,:nok) * Exchange::Currency.new(20,:sek)
+    #     #=> #<Exchange::Currency @value=70.56 @currency=:nok>
+    
+    base_operation '*'
+    
+    # Divide the currency by a value
+    # @param [Integer, Float, Exchange::Currency] other The value to be divided by the currency. If an Exchange::Currency, it is converted to the instance's currency and divided by the converted value.
+    # @return [Exchange::Currency] The currency with the divided value
+    # @raise [CurrencyMixError] If the configuration does not allow mixed operations, this method will raise an error if two different currencies are used in the operation
+    # @example Configuration disallows mixed operations
+    #   Exchange::Configuration.allow_mixed_operations = false
+    #   Exchange::Currency.new(20,:nok) / Exchange::Currency.new(20,:sek)
+    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    # @example Configuration allows mixed operations (default)
+    #   Exchange::Currency.new(20,:nok) / Exchange::Currency.new(20,:sek)
+    #     #=> #<Exchange::Currency @value=1.56 @currency=:nok>
+    
+    base_operation '/'
+    
+    def == other
+      if other.is_a?(Exchange::Currency) && other.currency == self.currency
+        other.value == self.value
+      elsif other.is_a?(Exchange::Currency)
+        other.convert_to(self.currency, :at => other.time).value == self.value
+      else
+        self.value == other
+      end
+    end
+    
+    def <=> other
+      if other.is_a?(Exchange::Currency) && ((other.currency == self.currency && self.value < other.value) || (other.currency != self.currency && self.value < other.convert_to(self.currency, :at => other.time).value))
+        -1
+      elsif other.is_a?(Exchange::Currency) && ((other.currency == self.currency && self.value > other.value) || (other.currency != self.currency && self.value > other.convert_to(self.currency, :at => other.time).value))
+        1
+      elsif other.is_a?(Exchange::Currency)
+        0
+      else
+        self.value <=> other
+      end
+        
+    end
+    
+    protected
+    
+      # 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 If the argument is nil, you can define :default as :now to be delivered with Time.now instead of nil
+      # @version 0.2
+      
+      def assure_time(arg=nil, opts={})
+        if arg
+          arg.kind_of?(Time) ? arg : Time.gm(*arg.split('-'))
+        elsif opts[:default] == :now
+          Time.now
+        end
+      end
+  
+  end
+  
+  # The error that will get thrown when currencies get mixed up in base operations
+  CurrencyMixError = Class.new(ArgumentError)
+end