exchange 0.10.2 → 0.11.0

data/README.rdoc

@@ -231,11 +231,11 @@ The options available are
     :app_id (default nil)                     The app id to use with your api request
     :protocol (default :http)                 The protocol to use with the request
     
-  :allow_mixed_opterations (default true)   If set to false, Operations with with different currencies raise errors.
+  :implicit_conversions (default true)      If set to false, Operations with with different currencies raise errors.
 
-If you're afraid of mixed currency operations, just don't allow them
-  Exchange.configuration.allow_mixed_operations = false
-  1.in(:usd) + 1.in(:eur)                                 #=> MixedCurrencyError
+If you want to maintain control over when a currency is converted, turn implicit conversions off
+  Exchange.configuration.implicit_conversions = false
+  1.in(:usd) + 1.in(:eur)                                 #=> raises ImplicitConversionDenied
 
 === Caching Options  
 

data/changelog.rdoc

@@ -1,5 +1,8 @@
 = Changes to Exchange
 
+== 0.11.0
+- Better implementation for preventing implicit conversions, if wished for: Now all operations including comparisons throw errors when implicit conversions are not allowed and currencies are to be converted implicitly.
+
 == 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.
 

data/lib/exchange/base.rb

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

data/lib/exchange/configuration.rb

@@ -84,7 +84,7 @@ module Exchange
                     :host => nil,
                     :port => nil
                   },
-                  :allow_mixed_operations => true
+                  :implicit_conversions => true
                 }
     
     # Initialize a new configuration. Takes a hash and/or a block. Lets you easily set the configuration the way you want it to be
@@ -93,10 +93,10 @@ module Exchange
     # @param [Hash] configuration The configuration as a hash
     # @param [Proc] block A block to yield the configuration with
     # @example Define the configuration with a hash
-    #   Exchange::Configuration.new(:allow_mixed_operations => false, :api => {:subclass => :open_exchange_rates, :retries => 2})
+    #   Exchange::Configuration.new(:implicit_conversions => false, :api => {:subclass => :open_exchange_rates, :retries => 2})
     # @example Define the configuration with a block
     #   Exchange::Configuration.new do |c|
-    #     c.allow_mixed_operations = false
+    #     c.implicit_conversions = false
     #     c.cache = {
     #       :subclass => Exhange::Cache::Redis,
     #       :expire => :hourly
@@ -115,28 +115,28 @@ module Exchange
     def reset
       api.reset
       cache.reset
-      self.allow_mixed_operations = DEFAULTS[:allow_mixed_operations]
+      self.implicit_conversions = DEFAULTS[:implicit_conversions]
     end
     
-    # Getter for the mixed operations configuration. If set to true, operations with mixed currencies will not raise errors
-    # If set to false, mixed operations will raise errors
+    # Getter for the implicit Conversions configuration. If set to true, implicit conversions will not raise errors
+    # If set to false, implicit conversions will raise errors
     # @since 0.6
     # @version 0.6
-    # @return [Boolean] True if mixed operations are allowed, false if not
+    # @return [Boolean] True if implicit conversions are allowed, false if not
     #
-    def allow_mixed_operations
-      @config[:allow_mixed_operations]
+    def implicit_conversions
+      @config[:implicit_conversions]
     end
     
-    # Setter for the mixed operations configuration. If set to true, operations with mixed currencies will not raise errors
-    # If set to false, mixed operations will raise errors
+    # Setter for the implicit conversions configuration. If set to true, implicit conversions will not raise errors
+    # If set to false, implicit conversions will raise errors
     # @since 0.6
     # @version 0.6
     # @param [Boolean] data The configuration to set
     # @return [Boolean] The configuration set
     #
-    def allow_mixed_operations= data
-      @config[:allow_mixed_operations] = data
+    def implicit_conversions= data
+      @config[:implicit_conversions] = data
     end
         
     # Setter for the api configuration.

data/lib/exchange/money.rb

@@ -169,11 +169,11 @@ module Exchange
     # Add value to the currency
     # @param [Integer, Float, Exchange::Money] other The value to be added to the currency. If an Exchange::Money, it is converted to the instance's currency and then the converted value is added.
     # @return [Exchange::Money] 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
+    # @raise [ImplicitConversionError] 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.configuration.implicit_conversions = false
     #   Exchange::Money.new(20,:nok) + Exchange::Money.new(20,:sek)
-    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    #     #=> #<ImplicitConversionError "You tried to mix currencies">
     # @example Configuration allows mixed operations (default)
     #   Exchange::Money.new(20,:nok) + Exchange::Money.new(20,:sek)
     #     #=> #<Exchange::Money @value=37.56 @currency=:nok>
@@ -185,11 +185,11 @@ module Exchange
     # Subtract a value from the currency
     # @param [Integer, Float, Exchange::Money] other The value to be subtracted from the currency. If an Exchange::Money, it is converted to the instance's currency and then subtracted from the converted value.
     # @return [Exchange::Money] 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
+    # @raise [ImplicitConversionError] 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 implicit conversions
+    #   Exchange.configuration.implicit_conversions = false
     #   Exchange::Money.new(20,:nok) - Exchange::Money.new(20,:sek)
-    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    #     #=> #<ImplicitConversionError "You tried to mix currencies">
     # @example Configuration allows mixed operations (default)
     #   Exchange::Money.new(20,:nok) - Exchange::Money.new(20,:sek)
     #     #=> #<Exchange::Money @value=7.56 @currency=:nok>
@@ -201,11 +201,11 @@ module Exchange
     # Multiply a value with the currency
     # @param [Integer, Float, Exchange::Money] other The value to be multiplied with the currency. If an Exchange::Money, it is converted to the instance's currency and multiplied with the converted value.
     # @return [Exchange::Money] 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
+    # @raise [ImplicitConversionError] 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.configuration.implicit_conversions = false
     #   Exchange::Money.new(20,:nok) * Exchange::Money.new(20,:sek)
-    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    #     #=> #<ImplicitConversionError "You tried to mix currencies">
     # @example Configuration allows mixed operations (default)
     #   Exchange::Money.new(20,:nok) * Exchange::Money.new(20,:sek)
     #     #=> #<Exchange::Money @value=70.56 @currency=:nok>
@@ -217,11 +217,11 @@ module Exchange
     # Divide the currency by a value
     # @param [Integer, Float, Exchange::Money] other The value to be divided by the currency. If an Exchange::Money, it is converted to the instance's currency and divided by the converted value.
     # @return [Exchange::Money] 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
+    # @raise [ImplicitConversionError] 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.configuration.implicit_conversions = false
     #   Exchange::Money.new(20,:nok) / Exchange::Money.new(20,:sek)
-    #     #=> #<CurrencyMixError "You tried to mix currencies">
+    #     #=> #<ImplicitConversionError "You tried to mix currencies">
     # @example Configuration allows mixed operations (default)
     #   Exchange::Money.new(20,:nok) / Exchange::Money.new(20,:sek)
     #     #=> #<Exchange::Money @value=1.56 @currency=:nok>
@@ -241,12 +241,13 @@ module Exchange
     # @example Compare a currency with a number, the value of the currency will get compared
     #   Exchange::Money.new(35, :usd) == 35 #=> true
     # @since 0.1
-    # @version 0.6
+    # @version 0.11
     #
     def == other
       if is_same_currency?(other)
         other.round.value == self.round.value
-      elsif is_currency?(other)
+      elsif is_other_currency?(other)
+        test_for_currency_mix_error(other)
         other.to(currency, :at => other.time).round.value == self.round.value
       else
         value == other
@@ -258,7 +259,7 @@ module Exchange
     # @param [Whatever you want to throw at it] other The counterpart to compare
     # @return [Fixed] a number which can be used for sorting
     # @since 0.3
-    # @version 0.6
+    # @version 0.11
     # @todo which historic conversion should be used when two are present?
     # @example Compare two currencies in terms of value
     #   Exchange::Money.new(40, :usd) <=> Exchange::Money.new(28, :usd) #=> -1
@@ -271,6 +272,7 @@ module Exchange
       if is_same_currency?(other)
         value <=> other.value
       elsif is_other_currency?(other)
+        test_for_currency_mix_error(other)
         value <=> other.to(currency, :at => other.time).value
       else
         value <=> other
@@ -341,12 +343,12 @@ module Exchange
       
       # Test if another currency is used in an operation, and if so, if the operation is allowed
       # @param [Numeric, Exchange::Money] other The counterpart in the operation
-      # @raise [CurrencyMixError] an error if mixing currencies is not allowed and currencies where mixed
+      # @raise [ImplicitConversionError] an error if mixing currencies is not allowed and currencies where mixed
       # @since 0.6
       # @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.is_a?(Money) && other.currency != currency
+        raise ImplicitConversionError.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.implicit_conversions && 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
@@ -361,8 +363,8 @@ module Exchange
   
   end
   
-  # The error that will get thrown when currencies get mixed up in base operations
+  # The error that will get thrown when implicit conversions take place and are not allowed
   #
-  CurrencyMixError = Class.new(ArgumentError)
+  ImplicitConversionError = Class.new(StandardError)
   
 end

data/spec/exchange/configuration_spec.rb

@@ -11,7 +11,7 @@ describe "Exchange::Configuration" do
     subject.cache.expire.should == :daily
   end
   it "should respond to all configuration getters and setters" do
-    [:api, :allow_mixed_operations, :cache].each do |k|
+    [:api, :implicit_conversions, :cache].each do |k|
       subject.should be_respond_to(k)
       subject.should be_respond_to(:"#{k}=")
     end
@@ -59,7 +59,7 @@ describe "Exchange::Configuration" do
         :port => 112211,
         :path => 'PATH'
       }
-      c.allow_mixed_operations = false
+      c.implicit_conversions = false
     }
     it "should restore the defaults" do
       subject.reset
@@ -70,7 +70,7 @@ describe "Exchange::Configuration" do
       subject.cache.host.should be_nil
       subject.cache.port.should be_nil
       subject.cache.path.should be_nil
-      subject.allow_mixed_operations.should be_true
+      subject.implicit_conversions.should be_true
     end
   end
   after(:all) do

data/spec/exchange/money_spec.rb

@@ -10,7 +10,7 @@ describe "Exchange::Money" do
       c.cache = {
         :subclass => :no_cache
       }
-      c.allow_mixed_operations = true
+      c.implicit_conversions = true
     end
   end
   after(:all) do
@@ -60,15 +60,15 @@ describe "Exchange::Money" do
         subject.currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
-        Exchange.configuration.allow_mixed_operations = false
-        lambda { subject + Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = false
+        lambda { subject + Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+        Exchange.configuration.implicit_conversions = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-        Exchange.configuration.allow_mixed_operations = false
+        Exchange.configuration.implicit_conversions = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         lambda { subject + Exchange::Money.new(30, :usd) }.should_not raise_error
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
       end
       context "modifying the base value" do
         before(:each) do
@@ -94,15 +94,15 @@ describe "Exchange::Money" do
           @instantiated.currency.should == :usd
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
-          Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated += Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = false
+          lambda { @instantiated += Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+          Exchange.configuration.implicit_conversions = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-          Exchange.configuration.allow_mixed_operations = false
+          Exchange.configuration.implicit_conversions = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           lambda { @instantiated += Exchange::Money.new(30, :usd) }.should_not raise_error
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
         end
       end
     end
@@ -119,20 +119,20 @@ describe "Exchange::Money" do
       end
       it "should be able to subtract another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
         (subject - Exchange::Money.new(10, :chf)).value.round(2).should == 29.04
         (subject - Exchange::Money.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
-        Exchange.configuration.allow_mixed_operations = false
-        lambda { subject - Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = false
+        lambda { subject - Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+        Exchange.configuration.implicit_conversions = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-        Exchange.configuration.allow_mixed_operations = false
+        Exchange.configuration.implicit_conversions = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         lambda { subject - Exchange::Money.new(30, :usd) }.should_not raise_error
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
       end
       context "modifying the base value" do
         before(:each) do
@@ -151,7 +151,7 @@ describe "Exchange::Money" do
         end
         it "should be able to subtract another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
           added = (@instantiated -= Exchange::Money.new(10, :chf))
           added.value.round(2).should == 29.04
           added.currency.should == :usd
@@ -159,15 +159,15 @@ describe "Exchange::Money" do
           @instantiated.currency.should == :usd
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
-          Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated -= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = false
+          lambda { @instantiated -= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+          Exchange.configuration.implicit_conversions = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-          Exchange.configuration.allow_mixed_operations = false
+          Exchange.configuration.implicit_conversions = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           lambda { @instantiated -= Exchange::Money.new(30, :usd) }.should_not raise_error
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
         end
       end
     end
@@ -189,20 +189,20 @@ describe "Exchange::Money" do
       end
       it "should be able to multiply by another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
         (subject * Exchange::Money.new(10, :chf)).value.round(1).should == 438.3
         (subject * Exchange::Money.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
-        Exchange.configuration.allow_mixed_operations = false
-        lambda { subject * Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = false
+        lambda { subject * Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+        Exchange.configuration.implicit_conversions = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-        Exchange.configuration.allow_mixed_operations = false
+        Exchange.configuration.implicit_conversions = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         lambda { subject * Exchange::Money.new(30, :usd) }.should_not raise_error
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
       end
       context "modifying the base value" do
         before(:each) do
@@ -221,7 +221,7 @@ describe "Exchange::Money" do
         end
         it "should be able to multiply by another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
           added = (@instantiated *= Exchange::Money.new(9, :chf))
           added.value.round(1).should == 394.50
           added.currency.should == :usd
@@ -229,15 +229,15 @@ describe "Exchange::Money" do
           @instantiated.currency.should == :usd
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
-          Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated *= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = false
+          lambda { @instantiated *= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+          Exchange.configuration.implicit_conversions = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-          Exchange.configuration.allow_mixed_operations = false
+          Exchange.configuration.implicit_conversions = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           lambda { @instantiated *= Exchange::Money.new(30, :usd) }.should_not raise_error
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
         end
       end
     end
@@ -266,20 +266,20 @@ describe "Exchange::Money" do
       end
       it "should be able to divide by another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
         (subject / Exchange::Money.new(10, :chf)).value.round(2).should == BigDecimal.new("3.65")
         (subject / Exchange::Money.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
-        Exchange.configuration.allow_mixed_operations = false
-        lambda { subject / Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = false
+        lambda { subject / Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+        Exchange.configuration.implicit_conversions = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-        Exchange.configuration.allow_mixed_operations = false
+        Exchange.configuration.implicit_conversions = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         lambda { subject / Exchange::Money.new(30, :usd) }.should_not raise_error
-        Exchange.configuration.allow_mixed_operations = true
+        Exchange.configuration.implicit_conversions = true
       end
       context "modifying the base value" do
         before(:each) do
@@ -298,7 +298,7 @@ describe "Exchange::Money" do
         end
         it "should be able to divide by another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
           added = (@instantiated /= Exchange::Money.new(10, :chf))
           added.value.round(2).should == 3.65
           added.currency.should == :usd
@@ -306,15 +306,15 @@ describe "Exchange::Money" do
           @instantiated.currency.should == :usd
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
-          Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated /= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = false
+          lambda { @instantiated /= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::ImplicitConversionError)
+          Exchange.configuration.implicit_conversions = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
-          Exchange.configuration.allow_mixed_operations = false
+          Exchange.configuration.implicit_conversions = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           lambda { @instantiated /= Exchange::Money.new(30, :usd) }.should_not raise_error
-          Exchange.configuration.allow_mixed_operations = true
+          Exchange.configuration.implicit_conversions = true
         end
       end
     end
@@ -348,6 +348,17 @@ describe "Exchange::Money" do
           mock_api("http://openexchangerates.org/api/historical/2011-01-01.json?app_id=", fixture('api_responses/example_historic_json.json'), 2)
           (comp3 == comp6).should be_false
         end
+        context "with implicit conversion turned off" do
+          before(:each) do
+            Exchange.configuration.implicit_conversions = false
+          end
+          after(:each) do
+            Exchange.configuration.implicit_conversions = true
+          end
+          it "should raise an error" do
+            lambda { comp3 == comp5 }.should raise_error(Exchange::ImplicitConversionError)
+          end
+        end
       end
     end
     describe "sorting" do
@@ -362,6 +373,17 @@ describe "Exchange::Money" do
       it "should sort and by doing conversions" do
         [subject, comp1, comp2, comp3, comp4].sort.should == [comp2, subject, comp1, comp4, comp3]
       end
+      context "with implicit conversion turned off" do
+        before(:each) do
+          Exchange.configuration.implicit_conversions = false
+        end
+        after(:each) do
+          Exchange.configuration.implicit_conversions = true
+        end
+        it "should raise an error" do
+          lambda { [subject, comp1, comp2, comp3, comp4].sort }.should raise_error(Exchange::ImplicitConversionError)
+        end
+      end
     end
     describe "round" do
       subject { Exchange::Money.new(40.123, :usd) }

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 10
-  - 2
-  version: 0.10.2
+  - 11
+  - 0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Beat Richartz