exchange 0.9.0 → 0.10.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    exchange (0.9.0)
+    exchange (0.10.0)
       json (>= 1.0.0)
 
 GEM

data/README.rdoc

@@ -7,21 +7,24 @@ You can use it with just plain ruby projects, in Rails 2 and 3, Sinatra or whate
 == Installation
 === Bundler / Rails
 Add it to your Gemfile  
-  gem "exchange", ">=0.8.0"
+  gem "exchange", ">=0.10.0"
 === Manually
 Just install it as a gem
   gem install exchange
 Then require it
   require 'exchange'
+  
+=== Deprecations in 0.10.0
+The old gem API (3.eur, 5.usd.to_chf) has been abandoned in favor of the new (1.in(:eur), 5.in(:usd).to(:chf)). This resolves a conflict of the earlier versions with the active support "try" method, which also stands for turkish lira. It also makes dynamic instantiation of currencies easier (in(currency) is better than send(currency), to(currency) much better than send(:"to_#{currency}")) Version 0.9.0 still supports the old API, so if you don't have the time to change now, just continue to use the old version and change later. There are no other changes than the api and no bugfixes from 0.9.0 to 0.10.0.
 
 == Features
 
 === Easy Conversion
 
 Conversion of currencies does not get any easier
-  1.eur.to_usd
+  1.in(:eur).to(:usd)
 or better for historic dates
-  1.eur.to_usd(:at => Time.now - 84600)
+  1.in(:eur).to(:usd, :at => Time.now - 84600)
   
   
 === Precise Calculation
@@ -36,8 +39,8 @@ Whereas
   
 Exchange uses BigDecimal in all its currency and conversion operations, so you will not be a likely victim for floating point inaccuracies. It even does implicitly convert counterparts of basic operations like (* / - +) to calculate your values safely:
 
-  (50.usd * 0.29).round 0 #=> "USD 15.00"
-  (0.29 * 50.usd).round 0 #=> 15
+  (50.in(:usd) * 0.29).round 0 #=> "USD 15.00"
+  (0.29 * 50.in(:usd)).round 0 #=> 15
   
 === BigDecimal? Sounds slow to me
 
@@ -76,7 +79,7 @@ Now you're able to do this:
   
   article = Article.new
   article.price #=> will give you money in the currency defined on the manager
-  article.price = 3.45.usd #Will implicitly convert the price if manager.currency is not :usd
+  article.price = 3.45.in(:usd) #Will implicitly convert the price if manager.currency is not :usd
   
 You can feed the currency option with a proc or a symbol representing the method. For in-depth information about typecasting {visit the documentation here}[http://rubydoc.info/github/beatrichartz/exchange/Exchange/Typecasting]
 
@@ -85,12 +88,12 @@ You can feed the currency option with a proc or a symbol representing the method
 You're hitting the internet only daily to get new rates (hourly updates are available if you're eager to have the absolutely newest ones)
 
 === ISO 4217 Currency formatting
-On of the issues with currencies is: You never know the format they should be in. With Exchange, you can just use the currencies
+One of the issues with currencies is: You never know the format they should be in. With Exchange, you can just use the currencies
 to_s method, which takes care of the right format for you. You can either have a string with the currency code in front, or just the amount in the right format
 
-  49.567.usd.to_s           #=> "USD 49.57"
-  45.jpy.to_s               #=> "JPY 45"
-  34.34.omr.to_s            #=> "OMR 34.340"
+  49.567.in(:usd).to_s           #=> "USD 49.57"
+  45.in(:jpy).to_s               #=> "JPY 45"
+  34.34.in(:omr).to_s            #=> "OMR 34.340"
 
 === Use three great APIs or your own
 
@@ -120,88 +123,88 @@ But, same here, if you don't like any of these or want to use your own caching s
 
 Converting one currency to another is as easy as 1,2,3. Don't be afraid, even if it returns a currency object, all Fixed and Float operations can be applied as method missing routes to the value
 
-  1.usd.to_eur                                  #=> #<Exchange::Money @value=0.93 @currency=:eur>
-  2.3.dkk.to_sek                                #=> #<Exchange::Money @value=3.33 @currency=:sek>
-  45.54.nok.to_sek                              #=> #<Exchange::Money @value=3.33 @currency=:sek>
+  1.in(:usd).to(:eur)                                  #=> #<Exchange::Money @value=0.93 @currency=:eur>
+  2.3.in(:dkk).to(:sek)                                #=> #<Exchange::Money @value=3.33 @currency=:sek>
+  45.54.in(:nok).to(:sek)                              #=> #<Exchange::Money @value=3.33 @currency=:sek>
 
 Easily convert one currency to another at a historical rate
 
-  1.52.usd.to_eur :at => '2011-01-01'           #=> #<Exchange::Money @value=1.23 @currency=:eur>
-  3.45.eur.to_sek :at => Time.gm(2011,3,3)      #=> #<Exchange::Money @value=19.23 @currency=:sek>
-  345.sek.to_nok :at => Time.gm(2011,3,3)       #=> #<Exchange::Money @value=348 @currency=:nok>
+  1.52.in(:usd).to :eur, :at => '2011-01-01'           #=> #<Exchange::Money @value=1.23 @currency=:eur>
+  3.45.in(:eur).to :sek, :at => Time.gm(2011,3,3)      #=> #<Exchange::Money @value=19.23 @currency=:sek>
+  345.in(:sek).to :nok, :at => Time.gm(2011,3,3)       #=> #<Exchange::Money @value=348 @currency=:nok>
   
 Or even define an instance of currency as historic by adding a time.
 
-  1.52.usd(:at => '2011-01-01').to_eur          #=> #<Exchange::Money @value=1.23 @currency=:eur>
-  3.45.eur(:at => Time.gm(2011,3,3)).to_sek     #=> #<Exchange::Money @value=19.23 @currency=:sek>
-  345.sek(:at => Time.gm(2011,3,3)).to_nok      #=> #<Exchange::Money @value=348 @currency=:nok>
+  1.52.in(:usd, :at => '2011-01-01').to(:eur)          #=> #<Exchange::Money @value=1.23 @currency=:eur>
+  3.45.in(:usd, :at => Time.gm(2011,3,3)).to(:sek)     #=> #<Exchange::Money @value=19.23 @currency=:sek>
+  345.in(:usd, :at => Time.gm(2011,3,3)).to(:nok)      #=> #<Exchange::Money @value=348 @currency=:nok>
   
 Do multiple conversion steps at once (if in any way useful)
 
-  3.chf.to_eur(:at => '2011-02-04').to_usd      #=> #<Exchange::Money @value=5.3 @currency=:eur>
+  3.in(:chf).to(:eur, :at => '2011-02-04').to(:usd)      #=> #<Exchange::Money @value=5.3 @currency=:eur>
   
   
 === Compare
 
 Compare Currencies, they will convert implicitly
 
-  2.eur > 2.usd                                 #=> true (2.usd get converted to eur and compared)
-  2.nok < 2.sek                                 #=> false (2.sek get converted to nok and compared)
-  5.eur == 4.34.chf                             #=> true
-  50.eur == 4.34.chf                            #=> false
-  50.eur.to_sek == 50.eur                       #=> true
-  50.eur(:at => '2011-1-1') == 50.sek           #=> false
+  2.in(:eur) > 2.in(:usd)                                 #=> true (2.in(:usd) get converted to eur and compared)
+  2.in(:nok) < 2.in(:sek)                                 #=> false (2.in(:sek) get converted to nok and compared)
+  5.in(:eur) == 4.34.in(:chf)                             #=> true
+  50.in(:eur) == 4.34.in(:chf)                            #=> false
+  50.in(:eur).to(:sek) == 50.in(:eur)                       #=> true
+  50.in(:eur, :at => '2011-1-1') == 50.in(:sek)           #=> false
 
 Sort multiple currencies at once
 
-  [5.eur, 4.usd, 4.chf(:at => '2010-01-01')].sort   #=> [#<Exchange::Money @value=4 @currency=:usd>, #<Exchange::Money @value=4 @currency=:chf>, #<Exchange::Money @value=5 @currency=:eur>]
+  [5.in(:eur), 4.in(:usd), 4.in(:chf, :at => '2010-01-01')].sort   #=> [#<Exchange::Money @value=4 @currency=:usd>, #<Exchange::Money @value=4 @currency=:chf>, #<Exchange::Money @value=5 @currency=:eur>]
   
 This is true, because it uses the same historic conversion rate
 
-  3.eur(:at => '201-01-01').to_usd == 3.eur.to_usd(:at => '201-01-01')
+  3.in(:eur, :at => '201-01-01').to(:usd) == 3.in(:eur).to(:usd, :at => '201-01-01')
   
 But this is false, obviously, because the second instance uses the present exchange rate which differs from the historic one (if the two rates match, this will be true again)
 
-  3.eur(:at => '2001-01-01').to_usd == 3.eur.to_usd
+  3.in(:eur, :at => '2001-01-01').to(:usd) == 3.in(:eur).to(:usd)
   
 === Operate
 
 Add, Subtract, Multiply, Divide Currencies and don't lose a dime. The result will get returned in the currency of the first argument
 
-  1.usd + 1.32.eur                              #=> #<Exchange::Money @value=2.54 @currency=:usd>
-  1.usd - 1.32.eur                              #=> #<Exchange::Money @value=-0.2 @currency=:usd>
-  1.usd * 1.32.eur                              #=> #<Exchange::Money @value=3.44 @currency=:usd>
-  1.usd / 1.32.eur                              #=> #<Exchange::Money @value=0.89 @currency=:usd>
+  1.in(:usd) + 1.32.in(:eur)                              #=> #<Exchange::Money @value=2.54 @currency=:usd>
+  1.in(:usd) - 1.32.in(:eur)                              #=> #<Exchange::Money @value=-0.2 @currency=:usd>
+  1.in(:usd) * 1.32.in(:eur)                              #=> #<Exchange::Money @value=3.44 @currency=:usd>
+  1.in(:usd) / 1.32.in(:eur)                              #=> #<Exchange::Money @value=0.89 @currency=:usd>
   
   
 If you define a currency object as historic. It will use historic conversion if it gets converted (in this example, the 1.32 eur will get converted to usd at the rate of January 1 2008)
 
-  1.usd - 1.32.eur(:at => '2008-1-1')           #=> #<Exchange::Money @value=2.54 @currency=:usd>
+  1.in(:usd) - 1.32.in(:eur, :at => '2008-1-1')           #=> #<Exchange::Money @value=2.54 @currency=:usd>
 
 You can just instantiate currencies and apply operations. Rounding will by default round the currency to its ISO4217 decimal precision:
 
-  3.123.eur.round                               #=> #<Exchange::Money @value=3.12 @currency=:eur>
+  3.123.in(:eur).round                               #=> #<Exchange::Money @value=3.12 @currency=:eur>
   
 You can also pass the precision you wish for as an argument, round, ceil, floor act like normal:
 
-  3.1234.eur.round(0)                           #=> #<Exchange::Money @value=3 @currency=:eur>
+  3.1234.in(:eur).round(0)                           #=> #<Exchange::Money @value=3 @currency=:eur>
 
 Convert one currency to another and round, ceil or floor it, it still retains currency information of the actual and previous currency
 
-  1.34.usd.to_eur.round(0)                      #=> #<Exchange::Money @value=1 @currency=:eur>
-  10.34.usd.to_nok.ceil(0)                      #=> #<Exchange::Money @value=45 @currency=:nok>
-  5.34.usd.to_eur.floor(0)                      #=> #<Exchange::Money @value=4 @currency=:eur>
-  5.34.usd.to_eur.floor.from                    #=> #<Exchange::Money @value=5.34 @currency=:usd>
+  1.34.in(:usd).to(:eur).round(0)                      #=> #<Exchange::Money @value=1 @currency=:eur>
+  10.34.in(:usd).to(:nok).ceil(0)                      #=> #<Exchange::Money @value=45 @currency=:nok>
+  5.34.in(:usd).to(:eur).floor(0)                      #=> #<Exchange::Money @value=4 @currency=:eur>
+  5.34.in(:usd).to(:eur).floor.from                    #=> #<Exchange::Money @value=5.34 @currency=:usd>
   
   
 === Retain Information
 
 Access the original currency and its value after conversion, even over multiple steps
 
-  converted = 2.eur.to_usd                      #=> #<Exchange::Money @value=2.12 @currency=:usd>
-  converted.from                                #=> #<Exchange::Money @value=2 @currency=:eur>
-  converted2 = converted.to_nok                 #=> #<Exchange::Money @value=22.12 @currency=:nok>
-  converted2.from                               #=> #<Exchange::Money @value=2.12 @currency=:usd>
+  converted = 2.in(:eur).to(:usd)                      #=> #<Exchange::Money @value=2.12 @currency=:usd>
+  converted.from                                       #=> #<Exchange::Money @value=2 @currency=:eur>
+  converted2 = converted.to(:nok)                      #=> #<Exchange::Money @value=22.12 @currency=:nok>
+  converted2.from                                      #=> #<Exchange::Money @value=2.12 @currency=:usd>
 
 == Configuration
 
@@ -232,11 +235,20 @@ The options available are
 
 If you're afraid of mixed currency operations, just don't allow them
   Exchange.configuration.allow_mixed_operations = false
-  1.usd + 1.eur                                 #=> MixedCurrencyError
+  1.in(:usd) + 1.in(:eur)                                 #=> MixedCurrencyError
 
 === Caching Options  
 
-Use Memcached to cache the result (default). Exchange will cache the API files with a key starting with 'exchange_'
+In Key/Value stores, exchange will cache the API files with a key starting with 'exchange_'
+
+Use Memory to cache the result (default). 
+  Exchange.configuration = Exchange::Configuration.new do |c|
+    c.cache = {
+      :subclass => :memory
+    }
+  end
+
+Use Memcached to cache the result. 
   Exchange.configuration = Exchange::Configuration.new do |c|
     c.cache = {
       :subclass => :memcached,
@@ -245,7 +257,7 @@ Use Memcached to cache the result (default). Exchange will cache the API files w
     }
   end
 
-Use Redis to cache the result. Exchange will cache the API files with a key starting with 'exchange_'
+Use Redis to cache the result.
   Exchange.configuration = Exchange::Configuration.new do |c|
     c.cache = {
       :subclass => :redis,
@@ -254,7 +266,7 @@ Use Redis to cache the result. Exchange will cache the API files with a key star
     }
   end
 
-Use Rails to cache the result. Exchange will cache the API files with a key starting with 'exchange_'
+Use Rails to cache the result.
   Exchange.configuration = Exchange::Configuration.new do |c|
     c.cache = {
       :subclass => :rails
@@ -263,17 +275,18 @@ Use Rails to cache the result. Exchange will cache the API files with a key star
   
 === API Options
 
-Use the Xaviermedia API as the source of your conversion rates
+Use the Xaviermedia API
   Exchange.configuration = Exchange::Configuration.new do |c|
     c.api = {
       :subclass => :xavier_media
     }
   end
 
-Use the open exchange rates Open Source API as a source of your conversion rates
+Use the open exchange rates Open Source API
   Exchange.configuration = Exchange::Configuration.new do |c|
     c.api = {
-      :subclass => :open_exchange_rates
+      :subclass => :open_exchange_rates,
+      :app_id => "Your open exchange rates app id"
     }
   end
   

data/Rakefile

@@ -19,9 +19,9 @@ Jeweler::Tasks.new do |gem|
   gem.license = "MIT"
   gem.summary = %Q{Simple Exchange Rate operations for your ruby app}
   gem.description = %Q{The Exchange Gem gives you easy access to currency functions directly on your Numbers. Imagine a conversion as easy as 
-    1.eur.to_usd
+    1.in(:eur).to(:usd)
   or even better 
-    1.eur.to_usd(:at => Time.now - 84600)
+    1.in(:eur).to(:usd, :at => Time.now - 84600)
   which gets you an exchange at the rates of yesterday.}
   gem.email = "exchange_gem@gmail.com"
   gem.authors = ["Beat Richartz"]

data/benchmark/benchmark.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'benchmark'
 require 'bigdecimal'
 
@@ -6,7 +7,7 @@ class Helper
     begin
       require a_gem.to_s
       return true
-    rescue LoadError => e
+    rescue LoadError
       puts "You do not have #{a_gem} installed. gem install #{a_gem} to benchmark it\n\n"
       return false
     end
@@ -31,15 +32,15 @@ two = BigDecimal.new("4.234")
 3.times { results[:big_decimal] << Benchmark.realtime { operations.times { one * two } } }
 
 if helper.load_or_omit(:money)
-  Money.add_rate("USD", "CAD", 1.24515)
+  m = Money.us_dollar(50)
   results[:money] = []
-  3.times { results[:money] << Benchmark.realtime { operations.times { Money.us_dollar(50) * 0.29 } } }
+  3.times { results[:money] << Benchmark.realtime { operations.times { m * 0.29 } } }
 end
 
 if helper.load_or_omit(:exchange)
-  1.usd.to_cad #make the rate available in memory
+  m = 50.in(:usd)
   results[:exchange] = []
-  3.times { results[:exchange] << Benchmark.realtime { operations.times { 50.usd * 0.29 } } }
+  3.times { results[:exchange] << Benchmark.realtime { operations.times { m * 0.29 } } }
 end
 
 puts "#{operations} operations\n\n"

data/changelog.rdoc

@@ -1,5 +1,8 @@
 = Changes to Exchange
 
+== 0.10.0
+- Changed the gem API to be less invasive in the numeric classes. The deprecated API had issues with three letter methods defined in active support, mainly the try method. The new API has just two methods, in(currency) and to(currency). There are no known conflicts at this time.
+
 == 0.9.0
 - added memory cache support as the new default. This allows you to cache without any external requirement, directly in ruby.
 - Added a typecasting helper for money to exchange. This allows you to typecast any given attribute into a instance of Exchange::Money

data/exchange.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version           = Exchange::VERSION
   s.authors           = ["Beat Richartz"]
   s.date              = "2012-10-09"
-  s.description       = "The Exchange Gem gives you easy access to currency functions directly on your Numbers. Imagine a conversion as easy as \n    1.eur.to_usd\n  or even better \n    1.eur.to_usd(:at => Time.now - 84600)\n  which gets you an exchange at the rates of yesterday."
+  s.description       = "The Exchange Gem gives you easy access to currency functions directly on your Numbers. Imagine a conversion as easy as \n    1.in(:eur).to(:usd)  or even better \n    1.in(:eur).to(:usd, :at => Time.now - 84600)\n  which gets you an exchange at the rates of yesterday."
   s.email             = "exchange_gem@gmail.com"
   s.homepage          = "http://github.com/beatrichartz/exchange"
   s.licenses          = ["MIT"]

data/lib/exchange/base.rb

@@ -2,7 +2,7 @@ module Exchange
   
   # The current version of the exchange gem
   #
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
   
   # The root installation path of the gem
   # @version 0.5
@@ -16,4 +16,10 @@ module Exchange
   #
   NoRateError       = Class.new StandardError
   
+  # The error that gets thrown if the given currency is not a currency
+  # @version 0.10
+  # @since 0.10
+  #
+  NoCurrencyError   = Class.new(ArgumentError)
+  
 end

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

@@ -4,17 +4,36 @@ module Exchange
   #
   module ErrorSafe
     
+    # Installs a method chain that overwrites the old error prone meth with the new one
+    #
+    def self.money_error_preventing_method_chain base, meth
+      base.send :alias_method, :"#{meth}with_errors", meth
+      base.send :alias_method, meth, :"#{meth}without_errors"
+    end
+    
+    # @!macro prevent_errors_with_exchange_for
+    #   Prevents float errors when dealing with instances of Exchange::Money
+    #   By Typecasting the float into a Big Decimal
+    #   @method $1(other)
+    #
+    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
+        else
+          send(:"#{meth}with_errors", other)
+        end
+      })
+      money_error_preventing_method_chain base, meth
+    end
+    
     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"
+        
+        # @macro prevent_errors_with_exchange_for
+        #
+        prevent_errors_with_exchange_for base, meth.to_sym
+        
       end
     end
     

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

@@ -1,38 +1,40 @@
 module Exchange
   
-  # The conversability module which will get included in Fixnum and Float, giving them the currency exchange methods
+  # The conversability module which will get included in Fixnum and Float, giving them the in currency instantiate methods
   # @author Beat Richartz
-  # @version 0.2
+  # @version 0.10
   # @since 0.1
   #
   module Conversability
     
-    # Dynamic method generation is used here to allow instantiation and immediate conversion of Currency objects from 
-    # a common Fixnum or Float or BigDecimal. Since some builds of ruby 1.9 handle certain type conversion of Fixnum, Float 
-    # and others via method missing, this is not handled via method missing because it would seriously break down performance.
+    # The in method instantiates a money object from a numeric type.
+    # @param [Symbol] currency the currency to instantiate the money with
+    # @param [Hash] options The options to instantiate the currency with
+    # @option [Time] :at The time for which the currency should be instantiated
     # 
     # @example Instantiate from any type of number
-    #   40.usd => #<Exchange::Money @value=40 @currency=:usd>
-    #   -33.nok => #<Exchange::Money @value=-33 @currency=:nok>
-    #   33.333.sek => #<Exchange::Money @value=33.333 @currency=:sek>
+    #   40.in(:usd) => #<Exchange::Money @value=40 @currency=:usd>
+    #   -33.in(:nok) => #<Exchange::Money @value=-33 @currency=:nok>
+    #   33.333.in(:sek) => #<Exchange::Money @value=33.333 @currency=:sek>
     # @example Instantiate and immediatly convert
-    #   1.usd.to_eur => #<Exchange::Money @value=0.79 @currency=:eur>
-    #   1.nok.to_chf => #<Exchange::Money @value=6.55 @currency=:chf>
-    #   -3.5.dkk.to_huf => #<Exchange::Money @value=-346.55 @currency=:huf>
+    #   1.in(:usd).to(:eur) => #<Exchange::Money @value=0.79 @currency=:eur>
+    #   1.in(:nok).to(:chf) => #<Exchange::Money @value=6.55 @currency=:chf>
+    #   -3.5.in(:chf).to(:dkk) => #<Exchange::Money @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::Money @value=0.80 @currency=:eur>
-    #   1.nok.to_chf(:at => Time.now - 3600) => #<Exchange::Money @value=6.57 @currency=:chf>
-    #   -3.5.dkk.to_huf(:at => Time.now - 172800) => #<Exchange::Money @value=-337.40 @currency=:huf>
+    #   1.in(:usd).to(:eur, :at => Time.now - 86400) => #<Exchange::Money @value=0.80 @currency=:eur>
+    #   1.in(:nok).to(:chf, :at => Time.now - 3600) => #<Exchange::Money @value=6.57 @currency=:chf>
+    #   -3.5.in(:dkk).to(:huf, :at => Time.now - 172800) => #<Exchange::Money @value=-337.40 @currency=:huf>
     #
     # @since 0.1
-    # @version 0.2
+    # @version 0.10
     #
-    ISO4217.currencies.each do |c|
-      define_method c do |*args|
-        Money.new(self, c, *args)
+    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
-    end
-    
+    end    
   end
 end
 

data/lib/exchange/money.rb

@@ -39,13 +39,13 @@ module Exchange
     # @param [Hash] opts Optional Parameters for instantiation
     # @option opts [Time] :at The time at which conversion took place
     # @option opts [String,Symbol] :from The money object this money object was converted from
-    # @version 0.2
+    # @version 0.9
     #
     # @example Instantiate a money object of 40 US Dollars
     #   Exchange::Money.new(40, :usd) 
     #     #=> #<Exchange::Money @number=40.0 @currency=:usd @time=#<Time>>
     # @example Instantiate a money object of 40 US Dollars and convert it to Euro. It shows the conversion date and the original currency
-    #   Exchange::Money.new(40, :usd).to_eur(:at => Time.gm(2012,9,1)) 
+    #   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      
@@ -61,38 +61,32 @@ module Exchange
     
     # Method missing is used to handle conversions from one money 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::Money.new(40,:usd).to_chf
-    # @example Calls convert_to with 'sek' and :at => Time.gm(2012,2,2)
-    #   Exchange::Money.new(40,:nok).to_sek(:at => Time.gm(2012,2,2))
+    # @example convert to chf
+    #   Exchange::Money.new(40,:usd).to(:chf)    
+    # @example convert to sek at a given time
+    #   Exchange::Money.new(40,:nok).to(:sek, :at => Time.gm(2012,2,2))
     #
     def method_missing method, *args, &block
       value.send method, *args, &block
     end
     
-    ISO4217.currencies.each do |c|
-      define_method :"to_#{c}" do |*args|
-        if api_supports_currency?(c)
-          convert_to c, { :at => time }.merge(args.first || {})
-        else
-          raise_no_rate_error(c)
-        end
-      end
-    end
-    
     # Converts this instance of currency into another currency
     # @return [Exchange::Money] An instance of Exchange::Money 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
+    # @param [Hash] options An options hash
     # @option [Time] :at The timestamp of the rate the conversion took place in
     # @example convert to 'chf'
-    #   Exchange::Money.new(40,:usd).convert_to('chf')
+    #   Exchange::Money.new(40,:usd).to(:chf)
     # @example convert to 'sek' at a specific rate
-    #   Exchange::Money.new(40,:nok).convert_to('sek', :at => Time.gm(2012,2,2))
+    #   Exchange::Money.new(40,:nok).to(:sek, :at => Time.gm(2012,2,2))
     #
-    def convert_to other, opts={}
-      opts[:from] = self
-      Money.new(api.new.convert(value, currency, other, opts), other, opts)
+    def to other, options={}
+      if api_supports_currency?(other)
+        opts = { :at => time, :from => self }.merge(options)
+        Money.new(api.new.convert(value, currency, other, opts), other, opts)
+      else
+        raise_no_rate_error(other)
+      end
     end
     
     class << self
@@ -100,7 +94,7 @@ module Exchange
       private
       
         # @private
-        # @macro [attach] install_operations
+        # @!macro [attach] install_operation
         #
         def install_operation op
           define_method op do |*precision|
@@ -109,14 +103,14 @@ module Exchange
         end
       
         # @private
-        # @macro [attach] base_operations
+        # @!macro [attach] base_operation
         #   @method $1(other)
         #   
         def base_operation op
           self.class_eval <<-EOV
             def #{op}(other)
               test_for_currency_mix_error(other)
-              new_value = value #{op} (other.kind_of?(Money) ? other.convert_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) : BigDecimal.new(other.to_s))
               Exchange::Money.new(new_value, currency, :at => time, :from => self)
             end
           EOV
@@ -253,7 +247,7 @@ module Exchange
       if is_same_currency?(other)
         other.round.value == self.round.value
       elsif is_currency?(other)
-        other.convert_to(currency, :at => other.time).round.value == self.round.value
+        other.to(currency, :at => other.time).round.value == self.round.value
       else
         value == other
       end
@@ -277,7 +271,7 @@ module Exchange
       if is_same_currency?(other)
         value <=> other.value
       elsif is_other_currency?(other)
-        value <=> other.convert_to(currency, :at => other.time).value
+        value <=> other.to(currency, :at => other.time).value
       else
         value <=> other
       end
@@ -352,7 +346,7 @@ module Exchange
       # @version 0.6
       #
       def test_for_currency_mix_error other
-        raise CurrencyMixError.new("You\'re trying to mix up #{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?(Money) && other.currency != currency
+        raise CurrencyMixError.new("You\'re trying to mix up #{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.is_a?(Money) && other.currency != currency
       end
       
       # Helper method to raise a no rate error for a given currency if no rate is given

data/lib/exchange/typecasting.rb

@@ -16,7 +16,7 @@ module Exchange
   #
   #   end
   #   
-  #   MyClass.find(1).update_attributes :price => 1.usd
+  #   MyClass.find(1).update_attributes :price => 1.in(:usd)
   #   MyClass.find(1).price #=> 0.77 EUR
   # 
   # @example The getter sets the currency automatically to the currency set in the definition (example in Ohm)
@@ -40,54 +40,122 @@ module Exchange
   #   managermanager.update :currency => :usd
   #   my_instance.price #=> instance of exchange currency in usd
   #
+  # @author Beat Richartz
+  # @since 0.9.0
+  # @version 0.9.0
+  #
   module Typecasting
-
-    # installs a setter and a getter for the attribute you want to typecast as exchange money
     
-    def money *attributes
-      
-      options = attributes.last.is_a?(Hash) ? attributes.pop : {}
+    # Installs a money getter
+    # @!macro [attach] install_money_getter
+    #   @method $1
+    #
+    def install_money_getter attribute, options={}
       
-      attributes.each do |attribute|
+      define_method :"#{attribute}_with_exchange_typecasting" do
+        currency = evaluate_money_option(options[:currency]) if options[:currency]
+        
+        test_for_currency_error(currency)
         
-        define_method :"#{attribute}_with_exchange_typecasting" do
-          currency = evaluate_money_option(options[:currency]) if options[:currency]
-          raise NoCurrencyError.new("No currency is given for typecasting #{attributes.join(', ')}. Make sure a currency is present") unless currency
-          
-          time     = evaluate_money_option(options[:at]) if options[:at]
-          
-          Exchange::Money.new(send(:"#{attribute}_without_exchange_typecasting")) do |c|
-            c.currency = currency
-            c.time     = time if time
-          end
+        time     = evaluate_money_option(options[:at]) if options[:at]
+        
+        Exchange::Money.new(send(:"#{attribute}_without_exchange_typecasting")) do |c|
+          c.currency = currency
+          c.time     = time if time
         end
-        alias_method :"#{attribute}_without_exchange_typecasting", attribute.to_sym
-        alias_method attribute.to_sym, :"#{attribute}_with_exchange_typecasting"
+      end
+      exchange_typecasting_alias_method_chain attribute
       
-        define_method :"#{attribute}_with_exchange_typecasting=" do |data|
-          att = send(attribute)
-          
-          if !data.respond_to?(:currency)
-            send(:"#{attribute}_without_exchange_typecasting=", data)
-          elsif att.currency == data.currency
-            send(:"#{attribute}_without_exchange_typecasting=", data.value)
-          elsif att.currency != data.currency
-            send(:"#{attribute}_without_exchange_typecasting=", data.send(:"to_#{att.currency}").value)
-          end
-        end
-        alias_method :"#{attribute}_without_exchange_typecasting=", :"#{attribute}="
-        alias_method :"#{attribute}=", :"#{attribute}_with_exchange_typecasting="
+    end
+    
+    # Installs a money setter
+    # @!macro [attach] install_money_setter
+    #   @method $1(data)
+    #
+    def install_money_setter attribute, options={}
+      define_method :"#{attribute}_with_exchange_typecasting=" do |data|
+        att = send(attribute)
+        attribute_setter = :"#{attribute}_without_exchange_typecasting="
         
+        if !data.respond_to?(:currency)
+          send(attribute_setter, data)
+        elsif att.currency == data.currency
+          send(attribute_setter, data.value)
+        elsif att.currency != data.currency
+          send(attribute_setter, data.to(att.currency).value)
+        end
       end
-      
+      exchange_typecasting_alias_method_chain attribute, '='
+    end
+    
+    # Install an alias method chain for an attribute
+    # @param [String, Symbol] attribute The attribute to install the alias method chain for
+    # @param [String] setter The setter sign ('=') if this is a setter
+    #
+    def exchange_typecasting_alias_method_chain attribute, setter=nil
+      alias_method :"#{attribute}_without_exchange_typecasting#{setter}", :"#{attribute}#{setter}"
+      alias_method :"#{attribute}#{setter}", :"#{attribute}_with_exchange_typecasting#{setter}"
+    end
+    
+    # @!macro [attach] install_money_option_eval
+    #   @method evaluate_money_option
+    #
+    def install_money_option_eval
       define_method :evaluate_money_option do |option|
         option.is_a?(Proc) ? instance_eval(&option) : send(option)
       end
     end
-        
-    # Is raised when no currency is given for typecasting
+    
+    # @!macro [attach] install_currency_error_tester
+    #   @method test_for_currency_error
     #
-    NoCurrencyError = Class.new(ArgumentError)
+    def install_currency_error_tester
+      define_method :test_for_currency_error do |currency|
+        raise NoCurrencyError.new("No currency is given for typecasting #{attribute}. Make sure a currency is present") unless currency
+      end
+    end
+
+    # installs a setter and a getter for the attribute you want to typecast as exchange money
+    # @overload def money(*attributes, options={})
+    #   @param [Symbol] attributes The attributes you want to typecast as money. 
+    #   @param [Hash] options Pass a hash as last argument as options
+    #   @option options [Symbol, Proc] :currency The currency to evaluate the money with. Can be a symbol or a proc
+    #   @option options [Symbol, Proc] :at The time at which the currency should be casted. All conversions of this currency will take place at this time
+    # @raise [NoCurrencyError] if no currency option is given or the currency evals to nil
+    # @example configure money with symbols, the currency option here will call the method currency in the object context
+    #   money :price, :currency => :currency, :time => :created_at
+    # @example configure money with a proc, the proc will be called with the object as an argument. This is equivalent to the example above
+    #   money :price, :currency => lambda {|o| o.currency}, :time => lambda{|o| o.created_at}
+    #
+    def money *attributes
+      
+      options = attributes.last.is_a?(Hash) ? attributes.pop : {}
+      
+      attributes.each do |attribute|
+        
+        # Get the attribute typecasted into money 
+        # @return [Exchange::Money] an instance of money
+        #
+        install_money_getter attribute, options
+        
+        # Set the attribute either with money or just any data
+        # Implicitly converts values given that are not in the same currency as the currency option evaluates to
+        # @param [Exchange::Money, String, Numberic] data The data to set the attribute to
+        # 
+        install_money_setter attribute, options
+        
+      end
+      
+      # Evaluates options given either as symbols or as procs
+      # @param [Symbol, Proc] option The option to evaluate
+      #
+      install_money_option_eval
+      
+      # Evaluates whether an error should be raised because there is no currency present
+      # @param [Symbol] currency The currency, if given
+      #
+      install_currency_error_tester
+    end
     
   end
 

data/spec/exchange/core_extensions/float/error_safe_spec.rb

@@ -15,7 +15,7 @@ describe "Exchange::ErrorSafe" do
   describe "money safe calculation" do
     describe "*" do
       it "should calculate correctly with exchange money" do
-        (0.29 * 50.usd).round.should == 15
+        (0.29 * 50.in(:usd)).round.should == 15
       end
       it "should not touch other operations" do
         (0.29 * 50).round.should == 14
@@ -23,7 +23,7 @@ describe "Exchange::ErrorSafe" do
     end
     describe "/" do
       it "should calculate correctly with exchange money" do
-        (((1829.82 / 12.usd) * 100).round.to_f / 100).to_f.should == 152.49
+        (((1829.82 / 12.in(:usd)) * 100).round.to_f / 100).to_f.should == 152.49
       end
       it "should not touch other operations" do
         (((1829.82 / 12) * 100).round.to_f / 100).should == 152.48
@@ -31,7 +31,7 @@ describe "Exchange::ErrorSafe" do
     end
     describe "+" do
       it "should calculate correctly with exchange money" do
-        (1.0e+25 + BigDecimal.new("9999999999999999900000000").usd).round.to_f.should == 2.0e+25
+        (1.0e+25 + BigDecimal.new("9999999999999999900000000").in(:usd)).round.to_f.should == 2.0e+25
       end
       it "should not touch other operations" do
         (1.0e+25 + BigDecimal.new("9999999999999999900000000")).round.should == 20000000000000001811939328
@@ -39,7 +39,7 @@ describe "Exchange::ErrorSafe" do
     end
     describe "-" do
       it "should calculate correctly with exchange money" do
-        (1.0e+25 - BigDecimal.new("9999999999999999900000000").usd).round.should == 100000000
+        (1.0e+25 - BigDecimal.new("9999999999999999900000000").in(:usd)).round.should == 100000000
       end
       it "should not touch other operations" do
         (1.0e+25 - BigDecimal.new("9999999999999999900000000")).should == 0

data/spec/exchange/core_extensions/numeric/conversability_spec.rb

@@ -11,92 +11,94 @@ describe "Exchange::Conversability" do
   after(:all) do
     Exchange.configuration.reset
   end
-  it "should define all currencies on Fixnum, Float and BigDecimal" do
-    Exchange::ISO4217.definitions.keys.each do |c|
-      1.should be_respond_to(c.to_s.downcase.to_sym)
-      1.1.should be_respond_to(c.to_s.downcase.to_sym)
-      BigDecimal.new("1").should be_respond_to(c.to_s.downcase.to_sym)
-    end
-  end
   context "with a fixnum" do
     it "should allow to convert to a currency" do
-      3.eur.should be_kind_of Exchange::Money
-      3.eur.value.should == 3
+      3.in(:eur).should be_kind_of Exchange::Money
+      3.in(:eur).value.should == 3
     end
     it "should allow to convert to a curreny with a negative number" do
-      -3.eur.should be_kind_of Exchange::Money
-      -3.eur.value.should == -3
+      -3.in(:eur).should be_kind_of Exchange::Money
+      -3.in(:eur).value.should == -3
     end
     it "should allow to do full conversions" do
       mock_api("http://api.finance.xaviermedia.com/api/2012/08/27.xml", fixture('api_responses/example_xml_api.xml'), 3)
-      3.eur.to_chf.should be_kind_of Exchange::Money
-      3.eur.to_chf.value.round(2).should == 3.68
-      3.eur.to_chf.currency.should == :chf
+      3.in(:eur).to(:chf).should be_kind_of Exchange::Money
+      3.in(:eur).to(:chf).value.round(2).should == 3.68
+      3.in(:eur).to(:chf).currency.should == :chf
     end
     it "should allow to do full conversions with negative numbers" do
       mock_api("http://api.finance.xaviermedia.com/api/2012/08/27.xml", fixture('api_responses/example_xml_api.xml'), 3)
-      -3.eur.to_chf.should be_kind_of Exchange::Money
-      -3.eur.to_chf.value.round(2).should == -3.68
-      -3.eur.to_chf.currency.should == :chf
+      -3.in(:eur).to(:chf).should be_kind_of Exchange::Money
+      -3.in(:eur).to(:chf).value.round(2).should == -3.68
+      -3.in(:eur).to(:chf).currency.should == :chf
     end
     it "should allow to define a historic time in which the currency should be interpreted" do
-      3.chf(:at => Time.gm(2010,1,1)).time.yday.should == 1
-      3.chf(:at => Time.gm(2010,1,1)).time.year.should == 2010
-      3.chf(:at => '2010-01-01').time.year.should == 2010
+      3.in(:chf, :at => Time.gm(2010,1,1)).time.yday.should == 1
+      3.in(:chf, :at => Time.gm(2010,1,1)).time.year.should == 2010
+      3.in(:chf, :at => '2010-01-01').time.year.should == 2010
+    end
+    it "should raise a no currency error if the currency does not exist" do
+      lambda { 35.in(:zzz) }.should raise_error(Exchange::NoCurrencyError, "zzz is not a currency")
     end
   end
   context "with a float" do
     it "should allow to convert to a currency" do
-      3.25.eur.should be_kind_of Exchange::Money
-      3.25.eur.value.round(2).should == 3.25
+      3.25.in(:eur).should be_kind_of Exchange::Money
+      3.25.in(:eur).value.round(2).should == 3.25
     end
     it "should allow to convert to a curreny with a negative number" do
-      -3.25.eur.should be_kind_of Exchange::Money
-      -3.25.eur.value.round(2).should == -3.25
+      -3.25.in(:eur).should be_kind_of Exchange::Money
+      -3.25.in(:eur).value.round(2).should == -3.25
     end
     it "should allow to do full conversions" do
       mock_api("http://api.finance.xaviermedia.com/api/2012/08/27.xml", fixture('api_responses/example_xml_api.xml'), 3)
-      3.25.eur.to_chf.should be_kind_of Exchange::Money
-      3.25.eur.to_chf.value.round(2).should == 3.99
-      3.25.eur.to_chf.currency.should == :chf
+      3.25.in(:eur).to(:chf).should be_kind_of Exchange::Money
+      3.25.in(:eur).to(:chf).value.round(2).should == 3.99
+      3.25.in(:eur).to(:chf).currency.should == :chf
     end
     it "should allow to do full conversions with negative numbers" do
       mock_api("http://api.finance.xaviermedia.com/api/2012/08/27.xml", fixture('api_responses/example_xml_api.xml'), 3)
-      -3.25.eur.to_chf.should be_kind_of Exchange::Money
-      -3.25.eur.to_chf.value.round(2).should == -3.99
-      -3.25.eur.to_chf.currency.should == :chf
+      -3.25.in(:eur).to(:chf).should be_kind_of Exchange::Money
+      -3.25.in(:eur).to(:chf).value.round(2).should == -3.99
+      -3.25.in(:eur).to(:chf).currency.should == :chf
     end
     it "should allow to define a historic time in which the currency should be interpreted" do
-      3.25.chf(:at => Time.gm(2010,1,1)).time.yday.should == 1
-      3.25.chf(:at => Time.gm(2010,1,1)).time.year.should == 2010
-      3.25.chf(:at => '2010-01-01').time.year.should == 2010
+      3.25.in(:chf, :at => Time.gm(2010,1,1)).time.yday.should == 1
+      3.25.in(:chf, :at => Time.gm(2010,1,1)).time.year.should == 2010
+      3.25.in(:chf, :at => '2010-01-01').time.year.should == 2010
+    end
+    it "should raise a no currency error if the currency does not exist" do
+      lambda { 35.23.in(:zzz) }.should raise_error(Exchange::NoCurrencyError, "zzz is not a currency")
     end
   end
   context "with a big decimal" do
     it "should allow to convert to a currency" do
-      BigDecimal.new("3.25").eur.should be_kind_of Exchange::Money
-      BigDecimal.new("3.25").eur.value.round(2).should == 3.25
+      BigDecimal.new("3.25").in(:eur).should be_kind_of Exchange::Money
+      BigDecimal.new("3.25").in(:eur).value.round(2).should == 3.25
     end
     it "should allow to convert to a curreny with a negative number" do
-      BigDecimal.new("-3.25").eur.should be_kind_of Exchange::Money
-      BigDecimal.new("-3.25").eur.value.round(2).should == -3.25
+      BigDecimal.new("-3.25").in(:eur).should be_kind_of Exchange::Money
+      BigDecimal.new("-3.25").in(:eur).value.round(2).should == -3.25
     end
     it "should allow to do full conversions" do
       mock_api("http://api.finance.xaviermedia.com/api/2012/08/27.xml", fixture('api_responses/example_xml_api.xml'), 3)
-      BigDecimal.new("3.25").eur.to_chf.should be_kind_of Exchange::Money
-      BigDecimal.new("3.25").eur.to_chf.value.round(2).should == 3.99
-      BigDecimal.new("3.25").eur.to_chf.currency.should == :chf
+      BigDecimal.new("3.25").in(:eur).to(:chf).should be_kind_of Exchange::Money
+      BigDecimal.new("3.25").in(:eur).to(:chf).value.round(2).should == 3.99
+      BigDecimal.new("3.25").in(:eur).to(:chf).currency.should == :chf
     end
     it "should allow to do full conversions with negative numbers" do
       mock_api("http://api.finance.xaviermedia.com/api/2012/08/27.xml", fixture('api_responses/example_xml_api.xml'), 3)
-      BigDecimal.new("-3.25").eur.to_chf.should be_kind_of Exchange::Money
-      BigDecimal.new("-3.25").eur.to_chf.value.round(2).should == -3.99
-      BigDecimal.new("-3.25").eur.to_chf.currency.should == :chf
+      BigDecimal.new("-3.25").in(:eur).to(:chf).should be_kind_of Exchange::Money
+      BigDecimal.new("-3.25").in(:eur).to(:chf).value.round(2).should == -3.99
+      BigDecimal.new("-3.25").in(:eur).to(:chf).currency.should == :chf
     end
     it "should allow to define a historic time in which the currency should be interpreted" do
-      BigDecimal.new("3.25").chf(:at => Time.gm(2010,1,1)).time.yday.should == 1
-      BigDecimal.new("3.25").chf(:at => Time.gm(2010,1,1)).time.year.should == 2010
-      BigDecimal.new("3.25").chf(:at => '2010-01-01').time.year.should == 2010
+      BigDecimal.new("3.25").in(:chf, :at => Time.gm(2010,1,1)).time.yday.should == 1
+      BigDecimal.new("3.25").in(:chf, :at => Time.gm(2010,1,1)).time.year.should == 2010
+      BigDecimal.new("3.25").in(:chf, :at => '2010-01-01').time.year.should == 2010
+    end
+    it "should raise a no currency error if the currency does not exist" do
+      lambda { BigDecimal.new("3.25").in(:zzz) }.should raise_error(Exchange::NoCurrencyError, "zzz is not a currency")
     end
   end
 end

data/spec/exchange/external_api/open_exchange_rates_spec.rb

@@ -59,7 +59,7 @@ describe "Exchange::ExternalAPI::OpenExchangeRates" do
       subject.convert(70, :sek, :usd, :at => Time.gm(2011,9,9)).round(2).should == 10.38
     end
     it "should convert right when the year is the same, but the yearday is not" do
-      mock_api("https://openexchangerates.org/api/historical/#{Time.now.year}-0#{Time.now.month > 9 ? Time.now.month - 1 : Time.now.month + 1}-01.json?app_id=", fixture('api_responses/example_json_api.json'))
+      mock_api("https://openexchangerates.org/api/historical/#{Time.now.year}-#{'0' if Time.now.month < 11}#{Time.now.month > 9 ? Time.now.month - 1 : Time.now.month + 1}-01.json?app_id=", fixture('api_responses/example_json_api.json'))
       subject.convert(70, :sek, :usd, :at => Time.gm(Time.now.year,Time.now.month > 9 ? Time.now.month - 1 : Time.now.month + 1,1)).round(2).should == 10.38
     end
     it "should convert right when the yearday is the same, but the year is not" do

data/spec/exchange/external_api/xavier_media_spec.rb

@@ -55,7 +55,7 @@ describe "Exchange::ExternalAPI::XavierMedia" do
       subject.convert(70, :sek, :usd, :at => Time.gm(2011,9,9)).round(2).should == 10.35
     end
     it "should convert right when the year is the same, but the yearday is not" do
-      mock_api("http://api.finance.xaviermedia.com/api/#{Time.now.year}/0#{Time.now.month > 9 ? Time.now.month - 1 : Time.now.month + 1}/01.xml", fixture('api_responses/example_xml_api.xml'))
+      mock_api("http://api.finance.xaviermedia.com/api/#{Time.now.year}/#{'0' if Time.now.month < 11}#{Time.now.month > 9 ? Time.now.month - 1 : Time.now.month + 1}/01.xml", fixture('api_responses/example_xml_api.xml'))
       subject.convert(70, :sek, :usd, :at => Time.gm(Time.now.year,Time.now.month > 9 ? Time.now.month - 1 : Time.now.month + 1,1)).round(2).should == 10.35
     end
     it "should convert right when the yearday is the same, but the year is not" do

data/spec/exchange/money_spec.rb

@@ -32,12 +32,12 @@ describe "Exchange::Money" do
       currency.time.should == Time.gm(2012,9,9)
     end
   end
-  describe "convert_to" do
+  describe "to" do
     it "should be able to convert itself to other currencies" do
       mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 3)
-      subject.convert_to(:chf).value.round(2).should == 36.5
-      subject.convert_to(:chf).currency.should == :chf
-      subject.convert_to(:chf).should be_kind_of Exchange::Money
+      subject.to(:chf).value.round(2).should == 36.5
+      subject.to(:chf).currency.should == :chf
+      subject.to(:chf).should be_kind_of Exchange::Money
     end
   end
   describe "operations" do
@@ -324,7 +324,7 @@ describe "Exchange::Money" do
       let(:comp2) { Exchange::Money.new(40, :usd) }
       let(:comp3) { Exchange::Money.new(50, :eur) }
       let(:comp4) { Exchange::Money.new(45, :eur) }
-      let(:comp5) { Exchange::Money.new(50, :eur).to_usd }
+      let(:comp5) { Exchange::Money.new(50, :eur).to(:usd) }
       let(:comp6) { Exchange::Money.new(66.1, :usd, :at => Time.gm(2011,1,1)) }
       before(:each) do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
@@ -464,7 +464,7 @@ describe "Exchange::Money" do
     it "should be able to convert via to_currency to other currencies" do
       mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 6)
       {:chf => 36.5, :usd => 40.0, :dkk => 225.12, :sek => 269.85, :nok => 232.06, :rub => 1205.24}.each do |currency, value|
-        c = subject.send(:"to_#{currency}")
+        c = subject.to(currency)
         c.value.round(2).should == value
         c.currency.should == currency
       end
@@ -472,17 +472,17 @@ describe "Exchange::Money" do
     it "should be able to convert via to_currency to other currencies and use historic data" do
       mock_api("http://openexchangerates.org/api/historical/2011-10-09.json?app_id=", fixture('api_responses/example_json_api.json'), 6)
       {:chf => 36.5, :usd => 40.0, :dkk => 225.12, :sek => 269.85, :nok => 232.06, :rub => 1205.24}.each do |currency, value|
-        c = subject.send(:"to_#{currency}", :at => Time.gm(2011,10,9))
+        c = subject.to(currency, :at => Time.gm(2011,10,9))
         c.value.round(2).should == value
         c.currency.should == currency
       end
     end
     it "should use the own time if defined as historic to convert" do
       mock_api("http://openexchangerates.org/api/historical/2011-01-01.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-      5.eur(:at => Time.gm(2011,1,1)).to_usd.value.should == 5.eur.to_usd(:at => Time.gm(2011,1,1)).value
+      5.in(:eur, :at => Time.gm(2011,1,1)).to(:usd).value.should == 5.in(:eur).to(:usd, :at => Time.gm(2011,1,1)).value
     end
     it "should raise errors for currency conversions it does not have rates for" do
-      lambda { subject.to_ssp }.should raise_error(Exchange::NoRateError)
+      lambda { subject.to(:ssp) }.should raise_error(Exchange::NoRateError)
     end
     it "should pass on methods it does not understand to its number" do
       subject.to_f.should == 40

data/spec/exchange/typecasting_spec.rb

@@ -70,16 +70,16 @@ describe "Exchange::Typecasting" do
     end
     it "should set the value if the given value is numeric" do
       subject.price = 0.83
-      subject.price.should == 0.83.eur
+      subject.price.should == 0.83.in(:eur)
     end
     it "should not convert the value if the given value is in the same currency" do
-      subject.price = 0.83.eur
-      subject.price.should == 0.83.eur
+      subject.price = 0.83.in(:eur)
+      subject.price.should == 0.83.in(:eur)
     end
     it "should convert the value if the given value is in another currency" do
       mock_api("http://api.finance.xaviermedia.com/api/#{Time.now.strftime("%Y/%m/%d")}.xml", fixture('api_responses/example_xml_api.xml'))
-      subject.price = 0.83.usd
-      subject.price.should == 0.62.eur
+      subject.price = 0.83.in(:usd)
+      subject.price.should == 0.62.in(:eur)
     end
   end
   

metadata

@@ -1,84 +1,73 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: exchange
-version: !ruby/object:Gem::Version 
-  hash: 59
+version: !ruby/object:Gem::Version
+  version: 0.10.0
   prerelease: 
-  segments: 
-  - 0
-  - 9
-  - 0
-  version: 0.9.0
 platform: ruby
-authors: 
+authors:
 - Beat Richartz
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-10-09 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: json
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: yard
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 7
-        - 4
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.7.4
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bundler
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
-  version_requirements: *id003
-description: |-
-  The Exchange Gem gives you easy access to currency functions directly on your Numbers. Imagine a conversion as easy as 
-      1.eur.to_usd
-    or even better 
-      1.eur.to_usd(:at => Time.now - 84600)
-    which gets you an exchange at the rates of yesterday.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: ! "The Exchange Gem gives you easy access to currency functions directly
+  on your Numbers. Imagine a conversion as easy as \n    1.in(:eur).to(:usd)  or even
+  better \n    1.in(:eur).to(:usd, :at => Time.now - 84600)\n  which gets you an exchange
+  at the rates of yesterday."
 email: exchange_gem@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .document
 - .gitignore
 - .rspec
@@ -90,6 +79,7 @@ files:
 - Rakefile
 - benchmark/benchmark.rb
 - changelog.rdoc
+- exchange-0.9.0.gem
 - exchange.gemspec
 - iso4217.yml
 - lib/exchange.rb
@@ -158,39 +148,31 @@ files:
 - spec/support/api_responses/example_json_api.json
 - spec/support/api_responses/example_xml_api.xml
 homepage: http://github.com/beatrichartz/exchange
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Simple Exchange Rate operations for your ruby app
-test_files: 
+test_files:
 - spec/exchange/cache/base_spec.rb
 - spec/exchange/cache/configuration_spec.rb
 - spec/exchange/cache/file_spec.rb