money 6.5.1 → 6.16.0

data/lib/money/money/arithmetic.rb

@@ -1,5 +1,13 @@
 class Money
   module Arithmetic
+    # Wrapper for coerced numeric values to distinguish
+    # when numeric was on the 1st place in operation.
+    CoercedNumeric = Struct.new(:value) do
+      # Proxy #zero? method to skip unnecessary typecasts. See #- and #+.
+      def zero?
+        value.zero?
+      end
+    end
 
     # Returns a money object with changed polarity.
     #
@@ -8,40 +16,65 @@ class Money
     # @example
     #    - Money.new(100) #=> #<Money @fractional=-100>
     def -@
-      Money.new(-fractional, currency)
+      dup_with(fractional: -fractional)
     end
 
-    # Checks whether two money objects have the same currency and the same
-    # amount. Checks against money objects with a different currency and checks
-    # against objects that do not respond to #to_money 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) == Money.new(101) #=> false
-    #   Money.new(100) == Money.new(100) #=> true
-    def ==(other_money)
-      if other_money.respond_to?(:to_money)
-        other_money = other_money.to_money
-        fractional == other_money.fractional && currency == other_money.currency
+    #   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.is_a?(Money)
+        (fractional == other_money.fractional && currency == other_money.currency) ||
+          (fractional == 0 && other_money.fractional == 0)
       else
         false
       end
     end
-    alias_method :eql?, :==
 
-    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
-      else
-        raise ArgumentError, "Comparison of #{self.class} with #{val.inspect} failed"
+    # Compares two Money objects. If money objects have a different currency it
+    # will attempt to convert the currency.
+    #
+    # @param [Money] other Value to compare with.
+    #
+    # @return [Integer]
+    #
+    # @raise [TypeError] when other object is not Money
+    #
+    def <=>(other)
+      unless other.is_a?(Money)
+        return unless other.respond_to?(:zero?) && other.zero?
+        return other.is_a?(CoercedNumeric) ? 0 <=> fractional : fractional <=> 0
+      end
+
+      # Always allow comparison with zero
+      if zero? || other.zero?
+        return fractional <=> other.fractional
       end
+
+      other = other.exchange_to(currency)
+      fractional <=> other.fractional
+    rescue Money::Bank::UnknownRate
+    end
+
+    # Uses Comparable's implementation but raises ArgumentError if non-zero
+    # numeric value is given.
+    def ==(other)
+      if other.is_a?(Numeric) && !other.zero?
+        raise ArgumentError, 'Money#== supports only zero numerics'
+      end
+      super
     end
 
     # Test if the amount is positive. Returns +true+ if the money amount is
@@ -70,37 +103,51 @@ class Money
       fractional < 0
     end
 
+    # @method +(other)
     # Returns a new Money object containing the sum of the two operands' monetary
     # values. If +other_money+ has a different currency then its monetary value
     # is automatically exchanged to this object's currency using +exchange_to+.
     #
-    # @param [Money] other_money Other +Money+ object to add.
+    # @param [Money] other Other +Money+ object to add.
     #
     # @return [Money]
     #
     # @example
     #   Money.new(100) + Money.new(100) #=> #<Money @fractional=200>
-    def +(other_money)
-      return self if other_money == 0
-      other_money = other_money.exchange_to(currency)
-      Money.new(fractional + other_money.fractional, currency)
-    end
-
+    #
+    # @method -(other)
     # Returns a new Money object containing the difference between the two
     # operands' monetary values. If +other_money+ has a different currency then
     # its monetary value is automatically exchanged to this object's currency
     # using +exchange_to+.
     #
-    # @param [Money] other_money Other +Money+ object to subtract.
+    # @param [Money] other Other +Money+ object to subtract.
     #
     # @return [Money]
     #
     # @example
     #   Money.new(100) - Money.new(99) #=> #<Money @fractional=1>
-    def -(other_money)
-      return self if other_money == 0
-      other_money = other_money.exchange_to(currency)
-      Money.new(fractional - other_money.fractional, currency)
+    [:+, :-].each do |op|
+      non_zero_message = lambda do |value|
+        "Can't add or subtract a non-zero #{value.class.name} value"
+      end
+
+      define_method(op) do |other|
+        case other
+        when Money
+          other = other.exchange_to(currency)
+          new_fractional = fractional.public_send(op, other.fractional)
+          dup_with(fractional: new_fractional)
+        when CoercedNumeric
+          raise TypeError, non_zero_message.call(other.value) unless other.zero?
+          dup_with(fractional: other.value.public_send(op, fractional))
+        when Numeric
+          raise TypeError, non_zero_message.call(other) unless other.zero?
+          self
+        else
+          raise TypeError, "Unsupported argument type: #{other.class.name}"
+        end
+      end
     end
 
     # Multiplies the monetary value with the given number and returns a new
@@ -112,16 +159,17 @@ class Money
     #
     # @return [Money] The resulting money.
     #
-    # @raise [ArgumentError] If +value+ is NOT a number.
+    # @raise [TypeError] If +value+ is NOT a number.
     #
     # @example
     #   Money.new(100) * 2 #=> #<Money @fractional=200>
     #
     def *(value)
+      value = value.value if value.is_a?(CoercedNumeric)
       if value.is_a? Numeric
-        Money.new(fractional * value, currency)
+        dup_with(fractional: fractional * value)
       else
-        raise ArgumentError, "Can't multiply a Money by a #{value.class.name}'s value"
+        raise TypeError, "Can't multiply a #{self.class.name} by a #{value.class.name}'s value"
       end
     end
 
@@ -141,10 +189,11 @@ class Money
     #   Money.new(100) / Money.new(10) #=> 10.0
     #
     def /(value)
-      if value.is_a?(Money)
+      if value.is_a?(self.class)
         fractional / as_d(value.exchange_to(currency).fractional).to_f
       else
-        Money.new(fractional / as_d(value), currency)
+        raise TypeError, 'Can not divide by Money' if value.is_a?(CoercedNumeric)
+        dup_with(fractional: fractional / as_d(value))
       end
     end
 
@@ -164,9 +213,9 @@ class Money
     # Divide money by money or fixnum and return array containing quotient and
     # modulus.
     #
-    # @param [Money, Fixnum] val Number to divmod by.
+    # @param [Money, Integer] val Number to divmod by.
     #
-    # @return [Array<Money,Money>,Array<Fixnum,Money>]
+    # @return [Array<Money,Money>,Array<Integer,Money>]
     #
     # @example
     #   Money.new(100).divmod(9)            #=> [#<Money @fractional=11>, #<Money @fractional=1>]
@@ -182,23 +231,19 @@ class Money
     def divmod_money(val)
       cents = val.exchange_to(currency).cents
       quotient, remainder = fractional.divmod(cents)
-      [quotient, Money.new(remainder, currency)]
+      [quotient, dup_with(fractional: remainder)]
     end
     private :divmod_money
 
     def divmod_other(val)
-      if self.class.infinite_precision
-        quotient, remainder = fractional.divmod(as_d(val))
-        [Money.new(quotient, currency), Money.new(remainder, currency)]
-      else
-        [div(val), Money.new(fractional.modulo(val), currency)]
-      end
+      quotient, remainder = fractional.divmod(as_d(val))
+      [dup_with(fractional: quotient), dup_with(fractional: remainder)]
     end
     private :divmod_other
 
     # Equivalent to +self.divmod(val)[1]+
     #
-    # @param [Money, Fixnum] val Number take modulo with.
+    # @param [Money, Integer] val Number take modulo with.
     #
     # @return [Money]
     #
@@ -211,7 +256,7 @@ class Money
 
     # Synonym for +#modulo+.
     #
-    # @param [Money, Fixnum] val Number take modulo with.
+    # @param [Money, Integer] val Number take modulo with.
     #
     # @return [Money]
     #
@@ -222,7 +267,7 @@ class Money
 
     # If different signs +self.modulo(val) - val+ otherwise +self.modulo(val)+
     #
-    # @param [Money, Fixnum] val Number to rake remainder with.
+    # @param [Money, Integer] val Number to rake remainder with.
     #
     # @return [Money]
     #
@@ -236,7 +281,7 @@ class Money
       if (fractional < 0 && val < 0) || (fractional > 0 && val > 0)
         self.modulo(val)
       else
-        self.modulo(val) - (val.is_a?(Money) ? val : Money.new(val, currency))
+        self.modulo(val) - (val.is_a?(Money) ? val : dup_with(fractional: val))
       end
     end
 
@@ -247,7 +292,7 @@ class Money
     # @example
     #   Money.new(-100).abs #=> #<Money @fractional=100>
     def abs
-      Money.new(fractional.abs, currency)
+      dup_with(fractional: fractional.abs)
     end
 
     # Test if the money amount is zero.
@@ -279,7 +324,7 @@ class Money
     # @example
     #   2 * Money.new(10) #=> #<Money @fractional=20>
     def coerce(other)
-      [self, other]
+      [self, CoercedNumeric.new(other)]
     end
   end
 end

data/lib/money/money/constructors.rb

@@ -10,8 +10,7 @@ class Money
     # @example
     #   Money.empty #=> #<Money @fractional=0>
     def empty(currency = default_currency)
-      @empty ||= {}
-      @empty[currency] ||= Money.new(0, currency).freeze
+      new(0, currency)
     end
     alias_method :zero, :empty
 
@@ -28,7 +27,7 @@ class Money
     #   n.cents    #=> 100
     #   n.currency #=> #<Money::Currency id: cad>
     def ca_dollar(cents)
-      Money.new(cents, "CAD")
+      new(cents, "CAD")
     end
     alias_method :cad, :ca_dollar
 
@@ -45,7 +44,7 @@ class Money
     #   n.cents    #=> 100
     #   n.currency #=> #<Money::Currency id: usd>
     def us_dollar(cents)
-      Money.new(cents, "USD")
+      new(cents, "USD")
     end
     alias_method :usd, :us_dollar
 
@@ -61,7 +60,7 @@ class Money
     #   n.cents    #=> 100
     #   n.currency #=> #<Money::Currency id: eur>
     def euro(cents)
-      Money.new(cents, "EUR")
+      new(cents, "EUR")
     end
     alias_method :eur, :euro
 
@@ -77,7 +76,7 @@ class Money
     #   n.fractional    #=> 100
     #   n.currency #=> #<Money::Currency id: gbp>
     def pound_sterling(pence)
-      Money.new(pence, "GBP")
+      new(pence, "GBP")
     end
     alias_method :gbp, :pound_sterling