money 6.6.1 → 6.7.0

data/lib/money/currency/heuristics.rb

@@ -53,7 +53,7 @@ class Money
       def currencies_by_name
         {}.tap do |r|
           table.each do |dummy,c|
-            name_parts = c[:name].downcase.split
+            name_parts = c[:name].unaccent.downcase.split
             name_parts.each {|part| part.chomp!('.')}
 
             # construct one branch per word
@@ -94,7 +94,7 @@ class Money
           str.gsub!(/[0-9][\.,:0-9]*[0-9]/,'')
           str.gsub!(/[0-9]/, '')
           str.downcase!
-          @words = str.split
+          @words = str.unaccent.split
           @words.each {|word| word.chomp!('.'); word.chomp!(',') }
         end
 
@@ -151,3 +151,4 @@ class Money
     end
   end
 end
+

data/lib/money/money.rb

@@ -472,9 +472,9 @@ class Money
   end
 
   # Allocates money between different parties without losing pennies.
-  # After the mathmatically split has been performed, left over pennies will
+  # After the mathematical split has been performed, leftover pennies will
   # be distributed round-robin amongst the parties. This means that parties
-  # listed first will likely recieve more pennies then ones that are listed later
+  # listed first will likely receive more pennies than ones that are listed later
   #
   # @param [Array<Numeric>] splits [0.50, 0.25, 0.25] to give 50% of the cash to party1, 25% to party2, and 25% to party3.
   #

data/lib/money/money/arithmetic.rb

@@ -1,4 +1,17 @@
 class Money
+  CoercedNumber = Struct.new(:value) do
+    include Comparable
+
+    def +(other) raise TypeError; end
+    def -(other) raise TypeError; end
+    def /(other) raise TypeError; end
+    def <=>(other) raise TypeError; end
+
+    def *(other)
+      other * value
+    end
+  end
+
   module Arithmetic
 
     # Returns a money object with changed polarity.
@@ -11,22 +24,23 @@ class Money
       self.class.new(-fractional, currency)
     end
 
-    # Checks whether two money objects have the same currency and the same
-    # amount. If money objects have a different currency it will only be true
-    # if the amounts are both zero. Checks against objects that do not respond
-    # to #to_money, in which case, it will always return false.
+    # Checks whether two Money objects have the same currency and the same
+    # amount. If Money objects have a different currency it will only be true
+    # if the amounts are both zero. Checks against objects that are not Money or
+    # a subclass will always return false.
     #
     # @param [Money] other_money Value to compare with.
     #
     # @return [Boolean]
     #
     # @example
-    #   Money.new(100).eql?(Money.new(101))           #=> false
-    #   Money.new(100).eql?(Money.new(100))           #=> true
-    #   Money.new(0, "USD").eql?(Money.new(0, "EUR")) #=> true
+    #   Money.new(100).eql?(Money.new(101))                #=> false
+    #   Money.new(100).eql?(Money.new(100))                #=> true
+    #   Money.new(100, "USD").eql?(Money.new(100, "GBP"))  #=> false
+    #   Money.new(0, "USD").eql?(Money.new(0, "EUR"))      #=> true
+    #   Money.new(100).eql?("1.00")                        #=> false
     def eql?(other_money)
-      if other_money.respond_to?(:to_money)
-        other_money = other_money.to_money
+      if other_money.is_a?(Money)
         (fractional == other_money.fractional && currency == other_money.currency) ||
           (fractional == 0 && other_money.fractional == 0)
       else
@@ -34,14 +48,23 @@ class Money
       end
     end
 
-    def <=>(val)
-      if val.respond_to?(:to_money)
-        val = val.to_money unless val.respond_to?(:fractional)
-        if fractional != 0 && val.fractional != 0 && currency != val.currency
-          val = val.exchange_to(currency)
-        end
-        fractional <=> val.fractional
+    # Compares two Money objects. If money objects have a different currency it
+    # will attempt to convert the currency.
+    #
+    # @param [Money] other_money Value to compare with.
+    #
+    # @return [Fixnum]
+    #
+    # @raise [TypeError] when other object is not Money
+    #
+    def <=>(other_money)
+      return nil unless other_money.is_a?(Money)
+      if fractional != 0 && other_money.fractional != 0 && currency != other_money.currency
+        other_money = other_money.exchange_to(currency)
       end
+      fractional <=> other_money.fractional
+    rescue Money::Bank::UnknownRate
+      nil
     end
 
     # Test if the amount is positive. Returns +true+ if the money amount is
@@ -81,7 +104,8 @@ class Money
     # @example
     #   Money.new(100) + Money.new(100) #=> #<Money @fractional=200>
     def +(other_money)
-      return self if other_money == 0
+      return self if other_money.zero?
+      raise TypeError unless other_money.is_a?(Money)
       other_money = other_money.exchange_to(currency)
       self.class.new(fractional + other_money.fractional, currency)
     end
@@ -98,7 +122,8 @@ class Money
     # @example
     #   Money.new(100) - Money.new(99) #=> #<Money @fractional=1>
     def -(other_money)
-      return self if other_money == 0
+      return self if other_money.zero?
+      raise TypeError unless other_money.is_a?(Money)
       other_money = other_money.exchange_to(currency)
       self.class.new(fractional - other_money.fractional, currency)
     end
@@ -279,7 +304,7 @@ class Money
     # @example
     #   2 * Money.new(10) #=> #<Money @fractional=20>
     def coerce(other)
-      [self, other]
+      [CoercedNumber.new(other), self]
     end
   end
 end

data/lib/money/money/formatting.rb

@@ -1,30 +1,6 @@
 # encoding: UTF-8
 class Money
   module Formatting
-    def self.included(base)
-      [
-        [:thousands_separator, :delimiter, ","],
-        [:decimal_mark, :separator, "."]
-      ].each do |method, name, character|
-        define_i18n_method(method, name, character)
-      end
-    end
-
-    def self.define_i18n_method(method, name, character)
-      define_method(method) do
-        if self.class.use_i18n
-          begin
-            I18n.t name, :scope => "number.currency.format", :raise => true
-          rescue I18n::MissingTranslationData
-            I18n.t name, :scope =>"number.format", :default => (currency.send(method) || character)
-          end
-        else
-          currency.send(method) || character
-        end
-      end
-      alias_method name, method
-    end
-
     # Creates a formatted price string according to several rules.
     #
     # @param [Hash] rules The options used to format the string.
@@ -215,6 +191,10 @@ class Money
     #   #         CAD: "CAD$"
     #   Money.new(10000, "CAD").format(:translate => true) #=> "CAD$100.00"
     #
+    # @example
+    #   Money.new(89000, :btc).format(:drop_trailing_zeros => true) #=> B⃦0.00089
+    #   Money.new(110, :usd).format(:drop_trailing_zeros => true)   #=> $1.1
+    #
     # Note that the default rules can be defined through +Money.default_formatting_rules+ hash.
     #
     # @see +Money.default_formatting_rules+ for more information.
@@ -239,13 +219,13 @@ class Money
       formatted = self.abs.to_s
 
       if rules[:rounded_infinite_precision]
-        formatted.gsub!(/#{currency.decimal_mark}/, '.') unless '.' == currency.decimal_mark
+        formatted.gsub!(/#{decimal_mark}/, '.') unless '.' == decimal_mark
         formatted = ((BigDecimal(formatted) * currency.subunit_to_unit).round / BigDecimal(currency.subunit_to_unit.to_s)).to_s("F")
         formatted.gsub!(/\..*/) do |decimal_part|
           decimal_part << '0' while decimal_part.length < (currency.decimal_places + 1)
           decimal_part
         end
-        formatted.gsub!(/\./, currency.decimal_mark) unless '.' == currency.decimal_mark
+        formatted.gsub!(/\./, decimal_mark) unless '.' == decimal_mark
       end
 
       sign = self.negative? ? '-' : ''
@@ -254,6 +234,12 @@ class Money
         formatted = "#{formatted.to_i}"
       end
 
+      # Inspiration: https://github.com/rails/rails/blob/16214d1108c31174c94503caced3855b0f6bad95/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb#L72-L79
+      if rules[:drop_trailing_zeros]
+        escaped_decimal_mark = Regexp.escape(decimal_mark)
+        formatted = formatted.sub(/(#{escaped_decimal_mark})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_decimal_mark}\z/, '')
+      end
+
       thousands_separator_value = thousands_separator
       # Determine thousands_separator
       if rules.has_key?(:thousands_separator)
@@ -300,8 +286,31 @@ class Money
       formatted
     end
 
+    def thousands_separator
+      i18n_format_for(:thousands_separator, :delimiter, ",")
+    end
+
+    def decimal_mark
+      i18n_format_for(:decimal_mark, :separator, ".")
+    end
+
+    alias_method :delimiter, :thousands_separator
+    alias_method :separator, :decimal_mark
+
     private
 
+    def i18n_format_for(method, name, character)
+      if self.class.use_i18n
+        begin
+          I18n.t name, :scope => "number.currency.format", :raise => true
+        rescue I18n::MissingTranslationData
+          I18n.t name, :scope =>"number.format", :default => (currency.send(method) || character)
+        end
+      else
+        currency.send(method) || character
+      end
+    end
+
     # Cleans up formatting rules.
     #
     # @param [Hash] rules

data/lib/money/version.rb

@@ -1,3 +1,3 @@
 class Money
-  VERSION = "6.6.1"
+  VERSION = "6.7.0"
 end

data/money.gemspec

@@ -26,10 +26,11 @@ Test responsibly :-)
 MSG
 
   s.add_dependency 'i18n', ['>= 0.6.4', '<= 0.7.0']
+  s.add_dependency 'sixarm_ruby_unaccent', ['>= 1.1.1', '< 2']
 
   s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", "~> 3.2.0"
+  s.add_development_dependency "rspec", "~> 3.4.0"
   s.add_development_dependency "yard", "~> 0.8"
   s.add_development_dependency "kramdown", "~> 1.1"
 

data/spec/bank/base_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class Money
   module Bank
     describe Base do

data/spec/bank/single_currency_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class Money
   module Bank
     describe SingleCurrency do

data/spec/bank/variable_exchange_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'json'
 require 'yaml'
 

data/spec/currency/heuristics_spec.rb

@@ -1,5 +1,4 @@
 # encoding: utf-8
-require 'spec_helper'
 
 describe Money::Currency::Heuristics do
   describe "#analyze_string" do
@@ -77,6 +76,85 @@ describe Money::Currency::Heuristics do
       expect(it.analyze("10EUR is less than 100:- but really, I want US$1")).to eq ['EUR', 'SEK', 'USD']
     end
 
+    it "find currencies with normal characters in name using unaccent" do
+      expect(it.analyze("10 Nicaraguan Cordoba")).to eq ["NIO"]
+    end
+
+    it "find currencies with special characters in name using unaccent" do
+      expect(it.analyze("10 Nicaraguan Córdoba")).to eq ["NIO"]
+    end
+
+    it "find currencies with special symbols using unaccent" do
+      expect(it.analyze("ل.س")).not_to eq []
+      expect(it.analyze("R₣")).not_to eq []
+      expect(it.analyze("ரூ")).not_to eq []
+      expect(it.analyze("රු")).not_to eq []
+      expect(it.analyze("сом")).not_to eq []
+      expect(it.analyze("圓")).not_to eq []
+      expect(it.analyze("円")).not_to eq []
+      expect(it.analyze("৳")).not_to eq []
+      expect(it.analyze("૱")).not_to eq []
+      expect(it.analyze("௹")).not_to eq []
+      expect(it.analyze("रु")).not_to eq []
+      expect(it.analyze("ש״ח")).not_to eq []
+      expect(it.analyze("元")).not_to eq []
+      expect(it.analyze("¢")).not_to eq []
+      expect(it.analyze("£")).not_to eq [] 
+      expect(it.analyze("€")).not_to eq []
+      expect(it.analyze("¥")).not_to eq []
+      expect(it.analyze("د.إ")).not_to eq []
+      expect(it.analyze("؋")).not_to eq []
+      expect(it.analyze("դր.")).not_to eq []
+      expect(it.analyze("ƒ")).not_to eq []
+      expect(it.analyze("₼")).not_to eq []
+      expect(it.analyze("৳")).not_to eq []
+      expect(it.analyze("лв")).not_to eq []
+      expect(it.analyze("лев")).not_to eq []
+      expect(it.analyze("дин")).not_to eq []
+      expect(it.analyze("ب.د")).not_to eq []
+      expect(it.analyze("₡")).not_to eq []
+      expect(it.analyze("Kč")).not_to eq []
+      expect(it.analyze("د.ج")).not_to eq []
+      expect(it.analyze("ج.م")).not_to eq []
+      expect(it.analyze("ლ")).not_to eq []
+      expect(it.analyze("₵")).not_to eq []
+      expect(it.analyze("₪")).not_to eq []
+      expect(it.analyze("₹")).not_to eq []
+      expect(it.analyze("ع.د")).not_to eq []
+      expect(it.analyze("﷼")).not_to eq []
+      expect(it.analyze("د.ا")).not_to eq []
+      expect(it.analyze("៛")).not_to eq []
+      expect(it.analyze("₩")).not_to eq []
+      expect(it.analyze("د.ك")).not_to eq []
+      expect(it.analyze("〒")).not_to eq []
+      expect(it.analyze("₭")).not_to eq []
+      expect(it.analyze("ل.ل")).not_to eq []
+      expect(it.analyze("₨")).not_to eq []
+      expect(it.analyze("ل.د")).not_to eq []
+      expect(it.analyze("د.م.")).not_to eq []
+      expect(it.analyze("ден")).not_to eq []
+      expect(it.analyze("₮")).not_to eq []
+      expect(it.analyze("₦")).not_to eq []
+      expect(it.analyze("C$")).not_to eq []
+      expect(it.analyze("ر.ع.")).not_to eq []
+      expect(it.analyze("₱")).not_to eq []
+      expect(it.analyze("zł")).not_to eq []
+      expect(it.analyze("₲")).not_to eq []
+      expect(it.analyze("ر.ق")).not_to eq []
+      expect(it.analyze("РСД")).not_to eq []
+      expect(it.analyze("₽")).not_to eq []
+      expect(it.analyze("ر.س")).not_to eq []
+      expect(it.analyze("฿")).not_to eq []
+      expect(it.analyze("د.ت")).not_to eq []
+      expect(it.analyze("T$")).not_to eq []
+      expect(it.analyze("₺")).not_to eq []
+      expect(it.analyze("₴")).not_to eq []
+      expect(it.analyze("₫")).not_to eq []
+      expect(it.analyze("B⃦")).not_to eq []
+      expect(it.analyze("₤")).not_to eq []
+      expect(it.analyze("ރ")).not_to eq []
+    end
+
     it "should function with unicode characters" do
       expect(it.analyze("10 դր.")).to eq ["AMD"]
     end

data/spec/currency/loader_spec.rb

@@ -1,5 +1,4 @@
 # encoding: utf-8
-require 'spec_helper'
 
 describe Money::Currency::Loader do
   class CurrencyLoader

data/spec/currency_spec.rb

@@ -1,11 +1,9 @@
 # encoding: utf-8
 
-require "spec_helper"
-
 class Money
   describe Currency do
 
-    FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 450, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": ",", "smallest_denomination": 1 }'
+    FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 1000, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": ",", "smallest_denomination": 1 }'
 
     def register_foo(opts={})
       foo_attrs = JSON.parse(FOO, :symbolize_names => true)
@@ -339,21 +337,21 @@ class Money
 
     describe "#exponent" do
       it "conforms to iso 4217" do
-        Currency.new(:jpy).exponent == 0
-        Currency.new(:usd).exponent == 2
-        Currency.new(:iqd).exponent == 3
+        expect(Currency.new(:jpy).exponent).to eq 0
+        expect(Currency.new(:usd).exponent).to eq 2
+        expect(Currency.new(:iqd).exponent).to eq 3
       end
     end
 
     describe "#decimal_places" do
       it "proper places for known currency" do
-        Currency.new(:mro).decimal_places == 1
-        Currency.new(:usd).decimal_places == 2
+        expect(Currency.new(:mro).decimal_places).to eq 1
+        expect(Currency.new(:usd).decimal_places).to eq 2
       end
 
       it "proper places for custom currency" do
         register_foo
-        Currency.new(:foo).decimal_places == 3
+        expect(Currency.new(:foo).decimal_places).to eq 3
         unregister_foo
       end
     end

data/spec/money/arithmetic_spec.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require "spec_helper"
-
 describe Money do
   describe "-@" do
     it "changes the sign of a number" do
@@ -31,29 +29,21 @@ describe Money do
       expect(Money.new(0, "USD")).to eq Money.new(0, "JPY")
     end
 
-    it "returns false if used to compare with an object that doesn't respond to #to_money" do
+    it "returns false if used to compare with an object that doesn't inherit from Money" do
       expect(Money.new(1_00, "USD")).not_to eq Object.new
       expect(Money.new(1_00, "USD")).not_to eq Class
       expect(Money.new(1_00, "USD")).not_to eq Kernel
-      expect(Money.new(1_00, "USD")).not_to eq /foo/
+      expect(Money.new(1_00, "USD")).not_to eq(/foo/)
       expect(Money.new(1_00, "USD")).not_to eq nil
     end
 
-    it "can be used to compare with an object that responds to #to_money" do
-      klass = Class.new do
-        def initialize(money)
-          @money = money
-        end
-
-        def to_money
-          @money
-        end
-      end
+    it "can be used to compare with an object that inherits from Money" do
+      klass = Class.new(Money)
 
-      expect(Money.new(1_00, "USD")).to     eq klass.new(Money.new(1_00, "USD"))
-      expect(Money.new(2_50, "USD")).to     eq klass.new(Money.new(2_50, "USD"))
-      expect(Money.new(2_50, "USD")).not_to eq klass.new(Money.new(3_00, "USD"))
-      expect(Money.new(1_00, "GBP")).not_to eq klass.new(Money.new(1_00, "USD"))
+      expect(Money.new(1_00, "USD")).to     eq klass.new(1_00, "USD")
+      expect(Money.new(2_50, "USD")).to     eq klass.new(2_50, "USD")
+      expect(Money.new(2_50, "USD")).not_to eq klass.new(3_00, "USD")
+      expect(Money.new(1_00, "GBP")).not_to eq klass.new(1_00, "USD")
     end
   end
 
@@ -65,7 +55,7 @@ describe Money do
       expect(Money.new(1_00, "USD").eql?(Money.new(99_00, "EUR"))).to be false
     end
 
-    it "returns false if used to compare with an object that doesn't respond to #to_money" do
+    it "returns false if used to compare with an object that doesn't inherit from Money" do
       expect(Money.new(1_00, "USD").eql?(Object.new)).to  be false
       expect(Money.new(1_00, "USD").eql?(Class)).to       be false
       expect(Money.new(1_00, "USD").eql?(Kernel)).to      be false
@@ -73,21 +63,13 @@ describe Money do
       expect(Money.new(1_00, "USD").eql?(nil)).to         be false
     end
 
-    it "can be used to compare with an object that responds to #to_money" do
-      klass = Class.new do
-        def initialize(money)
-          @money = money
-        end
+    it "can be used to compare with an object that inherits from Money" do
+      klass = Class.new(Money)
 
-        def to_money
-          @money
-        end
-      end
-
-      expect(Money.new(1_00, "USD").eql?(klass.new(Money.new(1_00, "USD")))).to be true
-      expect(Money.new(2_50, "USD").eql?(klass.new(Money.new(2_50, "USD")))).to be true
-      expect(Money.new(2_50, "USD").eql?(klass.new(Money.new(3_00, "USD")))).to be false
-      expect(Money.new(1_00, "GBP").eql?(klass.new(Money.new(1_00, "USD")))).to be false
+      expect(Money.new(1_00, "USD").eql?(klass.new(1_00, "USD"))).to be true
+      expect(Money.new(2_50, "USD").eql?(klass.new(2_50, "USD"))).to be true
+      expect(Money.new(2_50, "USD").eql?(klass.new(3_00, "USD"))).to be false
+      expect(Money.new(1_00, "GBP").eql?(klass.new(1_00, "USD"))).to be false
     end
   end
 
@@ -112,26 +94,29 @@ describe Money do
       expect(Money.new(100_00, "USD") <=> target).to be > 0
     end
 
-    it "can be used to compare with an object that responds to #to_money" do
-      klass = Class.new do
-        def initialize(money)
-          @money = money
-        end
+    it "returns nil if currency conversion fails, and therefore cannot be compared" do
+      target = Money.new(200_00, "EUR")
+      expect(target).to receive(:exchange_to).with(Money::Currency.new("USD")).and_raise(Money::Bank::UnknownRate)
+      expect(Money.new(100_00, "USD") <=> target).to be_nil
+    end
 
-        def to_money
-          @money
-        end
-      end
+    it "can be used to compare with an object that inherits from Money" do
+      klass = Class.new(Money)
 
-      expect(Money.new(1_00) <=> klass.new(Money.new(1_00))).to eq 0
-      expect(Money.new(1_00) <=> klass.new(Money.new(99))).to be > 0
-      expect(Money.new(1_00) <=> klass.new(Money.new(2_00))).to be < 0
+      expect(Money.new(1_00) <=> klass.new(1_00)).to eq 0
+      expect(Money.new(1_00) <=> klass.new(99)).to be > 0
+      expect(Money.new(1_00) <=> klass.new(2_00)).to be < 0
     end
 
-    it "returns nil when used to compare with an object that doesn't respond to #to_money" do
+    it "raises TypeError when used to compare with an object that doesn't inherit from Money" do
+      expect(Money.new(1_00) <=> 100).to be_nil
+
       expect(Money.new(1_00) <=> Object.new).to be_nil
+
       expect(Money.new(1_00) <=> Class).to be_nil
+
       expect(Money.new(1_00) <=> Kernel).to be_nil
+
       expect(Money.new(1_00) <=> /foo/).to be_nil
     end
   end
@@ -586,5 +571,73 @@ describe Money do
       result = 2 * Money.new(4, 'USD')
       expect(result).to eq Money.new(8, 'USD')
     end
+
+    it "raises TypeError dividing by a Money (unless other is a Money)" do
+      expect {
+        2 / Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+    end
+
+    it "raises TypeError subtracting by a Money (unless other is a Money)" do
+      expect {
+        2 - Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+    end
+
+    it "raises TypeError adding by a Money (unless other is a Money)" do
+      expect {
+        2 + Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+    end
+
+    it "treats multiplication as commutative" do
+      expect {
+        2 * Money.new(2, 'USD')
+      }.to_not raise_exception
+      result = 2 * Money.new(2, 'USD')
+      expect(result).to eq(Money.new(4, 'USD'))
+    end
+
+    it "doesn't work with non-numerics" do
+      expect {
+        "2" * Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+    end
+
+    it "correctly handles <=>" do
+      expect {
+        2 < Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+
+      expect {
+        2 > Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+
+      expect {
+        2 <= Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+
+      expect {
+        2 >= Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+
+      expect {
+        2 <=> Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+    end
+
+    it "raises exceptions for all numeric types, not just Integer" do
+      expect {
+        2.0 / Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+
+      expect {
+        Rational(2,3) / Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+
+      expect {
+        BigDecimal(2) / Money.new(2, 'USD')
+      }.to raise_exception(TypeError)
+    end
   end
 end