money 3.1.0 → 3.1.5

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+Money 3.1.5
+===========
+
+Features
+--------
+ - Added support for creating objects with the main monetary unit instead of
+   cents.
+   ([#issue/25](http://github.com/RubyMoney/money/issues/25))
+ - Deprecated `Money#format` with separate params instead of Hash. Deprecation
+   target set to Money 3.5.0.
+   ([#issue/31](http://github.com/RubyMoney/money/issues/31))
+ - Deprecated `Money#new(0, :currency => "EUR")` in favor of
+   `Money#new(0, "EUR")`. Deprecation target set to Money 3.5.0.
+   ([#issue/31](http://github.com/RubyMoney/money/issues/31))
+ - Throw ArgumentError when trying to multiply two Money objects together.
+   ([#issue/29](http://github.com/RubyMoney/money/issues/29))
+ - Update Money#parse to use :subunit_to_unit
+   ([#issue/30](http://github.com/RubyMoney/money/issues/30))
+
+Bugfixes
+--------
+ - Downgraded required_rubygems_version to >= 1.3.6.
+   ([#issue/26](http://github.com/RubyMoney/money/issues/26))
+ - Use BigDecimal when floating point calculations are needed.
+ - Ruby 1.9.2 compatibility enhancements.
+
+
 Money 3.1.0
 ===========
 

data/lib/money.rb

@@ -20,7 +20,8 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+require 'bigdecimal'
+require 'money/currency'
 require 'money/money'
 require 'money/defaults'
 require 'money/core_extensions'

data/lib/money/bank/variable_exchange.rb

@@ -81,9 +81,10 @@ class Money
         end
         _to_currency_  = Currency.wrap(to_currency)
 
-        cents = from.cents / (from.currency.subunit_to_unit.to_f / _to_currency_.subunit_to_unit.to_f)
+        cents = from.cents / (BigDecimal.new(from.currency.subunit_to_unit.to_s) / BigDecimal.new(_to_currency_.subunit_to_unit.to_s))
 
-        ex = cents * rate
+        ex = cents * BigDecimal.new(rate.to_s)
+        ex = ex.to_f
         ex = if block_given?
                block.call(ex)
              elsif @rounding_method
@@ -151,8 +152,7 @@ class Money
       # Available formats are +:json+, +:ruby+ and +:yaml+.
       #
       # @param [Symbol] format Request format for the resulting string.
-      # @param [optional, String] file Optional file location to write the
-      #  rates to.
+      # @param [String] file Optional file location to write the rates to.
       #
       # @return [String]
       #

data/lib/money/core_extensions.rb

@@ -1,37 +1,34 @@
 # Open +Numeric+ to add new method.
 class Numeric
-  # Converts this numeric to a +Money+ object in the default currency.
+
+  # Converts this numeric into a +Money+ object in the given +currency+.
   #
-  # @param [optional, Money::Currency, String, Symbol] currency The currency to
-  #  set the resulting +Money+ object to.
+  # @param [Currency, String, Symbol] currency
+  #   The currency to set the resulting +Money+ object to.
   #
   # @return [Money]
   #
   # @example
   #   100.to_money                   #=> #<Money @cents=10000>
   #   100.37.to_money                #=> #<Money @cents=10037>
-  #   require 'bigdecimal'
   #   BigDecimal.new('100').to_money #=> #<Money @cents=10000>
-  def to_money(currency = Money.default_currency)
-    currency = Money::Currency.new(currency) unless currency.is_a?(Money::Currency)
-    amt = self * currency.subunit_to_unit
-    amt = case amt.class.to_s
-          when 'BigDecimal'
-            amt.to_s('F')
-          else
-            amt.to_s
-          end
-    Money.new(amt.to_i, currency)
+  #
+  # @see Money.from_numeric
+  #
+  def to_money(currency = nil)
+    Money.from_numeric(self, currency || Money.default_currency)
   end
+
 end
 
 # Open +String+ to add new methods.
 class String
-  # Parses the current string and converts it to a +Money+ object. Excess
-  # characters will be discarded.
+
+  # Parses the current string and converts it to a +Money+ object.
+  # Excess characters will be discarded.
   #
-  # @param [optional, Money::Currency, String, Symbol] currency The currency to
-  #  set the resulting +Money+ object to.
+  # @param [Currency, String, Symbol] currency
+  #   The currency to set the resulting +Money+ object to.
   #
   # @return [Money]
   #
@@ -42,147 +39,25 @@ class String
   #   'USD 100'.to_money            #=> #<Money @cents=10000, @currency=#<Money::Currency id: usd>>
   #   '$100 USD'.to_money           #=> #<Money @cents=10000, @currency=#<Money::Currency id: usd>>
   #   'hello 2000 world'.to_money   #=> #<Money @cents=200000 @currency=#<Money::Currency id: usd>>
+  #
+  # @see Money.from_string
+  #
   def to_money(currency = nil)
-    # Get the currency.
-    matches = scan /([A-Z]{2,3})/
-    _currency_ = matches[0] ? matches[0][0] : nil
-
-    # check that currency passed and embedded currency are the same, or only
-    # one or the other is present.
-    if currency.nil? and _currency_.nil?
-      currency = Money.default_currency
-    elsif currency.nil?
-      currency = _currency_
-    elsif _currency_.nil?
-      currency = currency
-    elsif currency != _currency_
-      raise "mismatching currencies"
-    end
-
-    cents = calculate_cents(self)
-    Money.new(cents, currency)
+    Money.parse(self, currency)
   end
 
-  # Parses the current string and converts it to a +Currency+ object.
+  # Converts the current string into a +Currency+ object.
   #
   # @return [Money::Currency]
   #
+  # @raise [Money::Currency::UnknownCurrency]
+  #   If this String reference an unknown currency.
+  #
   # @example
   #   "USD".to_currency #=> #<Money::Currency id: usd>
+  #
   def to_currency
     Money::Currency.new(self)
   end
 
-  private
-
-  # Takes a number string and attempts to massage out the number.
-  #
-  # @param [String] number The string containing a potential number.
-  #
-  # @return [Integer]
-  def calculate_cents(number)
-    # remove anything that's not a number, potential delimiter, or minus sign
-    num = number.gsub(/[^\d|\.|,|\'|\s|\-]/, '').strip
-
-    # set a boolean flag for if the number is negative or not
-    negative = num.split(//).first == "-"
-
-    # if negative, remove the minus sign from the number
-    num = num.gsub(/^-/, '') if negative
-
-    # gather all separators within the result number
-    used_separators = num.scan /[^\d]/
-
-    # determine the number of unique separators within the number
-    #
-    # e.g.
-    # $1,234,567.89 would return 2 (, and .)
-    # $125,00 would return 1
-    # $199 would return 0
-    # $1 234,567.89 would raise an error (separators are space, comma, and period)
-    case used_separators.uniq.length
-    # no separator or delimiter; major (dollars) is the number, and minor (cents) is 0
-    when 0 then major, minor = num, 0
-
-    # two separators, so we know the last item in this array is the
-    # major/minor delimiter and the rest are separators
-    when 2
-      separator, delimiter = used_separators.uniq
-      # remove all separators, split on the delimiter
-      major, minor = num.gsub(separator, '').split(delimiter)
-      min = 0 unless min
-    when 1
-      # we can't determine if the comma or period is supposed to be a separator or a delimiter
-      # e.g.
-      # 1,00 - comma is a delimiter
-      # 1.000 - period is a delimiter
-      # 1,000 - comma is a separator
-      # 1,000,000 - comma is a separator
-      # 10000,00 - comma is a delimiter
-      # 1000,000 - comma is a delimiter
-
-      # assign first separator for reusability
-      separator = used_separators.first
-
-      # separator is used as a separator when there are multiple instances, always
-      if num.scan(separator).length > 1 # multiple matches; treat as separator
-        major, minor = num.gsub(separator, ''), 0
-      else
-        # ex: 1,000 - 1.0000 - 10001.000
-        # split number into possible major (dollars) and minor (cents) values
-        possible_major, possible_minor = num.split(separator)
-        possible_major ||= "0"
-        possible_minor ||= "00"
-
-        # if the minor (cents) length isn't 3, assign major/minor from the possibles
-        # e.g.
-        #   1,00 => 1.00
-        #   1.0000 => 1.00
-        #   1.2 => 1.20
-        if possible_minor.length != 3 # delimiter
-          major, minor = possible_major, possible_minor
-        else
-          # minor length is three
-          # let's try to figure out intent of the delimiter
-
-          # the major length is greater than three, which means
-          # the comma or period is used as a delimiter
-          # e.g.
-          #   1000,000
-          #   100000,000
-          if possible_major.length > 3
-            major, minor = possible_major, possible_minor
-          else
-            # number is in format ###{sep}### or ##{sep}### or #{sep}###
-            # handle as , is sep, . is delimiter
-            if separator == '.'
-              major, minor = possible_major, possible_minor
-            else
-              major, minor = "#{possible_major}#{possible_minor}", 0
-            end
-          end
-        end
-      end
-    else
-      raise ArgumentError, "Invalid currency amount"
-    end
-
-    # build the string based on major/minor since separator/delimiters have been removed
-    # avoiding floating point arithmetic here to ensure accuracy
-    cents = (major.to_i * 100)
-    # add the minor number as well. this may have any number of digits,
-    # so we treat minor as a string and truncate or right-fill it with zeroes
-    # until it becomes a two-digit number string, which we add to cents.
-    minor = minor.to_s
-    truncated_minor = minor[0..1]
-    truncated_minor << "0" * (2 - truncated_minor.size) if truncated_minor.size < 2
-    cents += truncated_minor.to_i
-    # respect rounding rules
-    if minor.size >= 3 && minor[2..2].to_i >= 5
-      cents += 1
-    end
-
-    # if negative, multiply by -1; otherwise, return positive cents
-    negative ? cents * -1 : cents
-  end
 end

data/lib/money/money.rb

@@ -1,12 +1,11 @@
 # encoding: utf-8
-require 'money/currency'
 require 'money/bank/variable_exchange'
 
 # Represents an amount of money in a given currency.
 class Money
   include Comparable
 
-  # The value of the money is cents.
+  # The value of the money in cents.
   #
   # @return [Integer]
   attr_reader :cents
@@ -101,10 +100,258 @@ class Money
     Money.new(cents, "EUR")
   end
 
+
+  # Creates a new Money object of +amount+ value in dollars,
+  # with given +currency+.
+  #
+  # The amount value is expressed in +dollars+
+  # where the +dollar+ is the main monetary unit,
+  # opposite to the subunit-based representation
+  # used internally by this library called +cents+.
+  #
+  # @param [Numeric] amount The money amount, in dollars.
+  # @param [Currency, String, Symbol] currency The currency format.
+  # @param [Money::Bank::*] bank The exchange bank to use.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   Money.new_with_dollars(100)
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.new_with_dollars(100, "USD")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.new_with_dollars(100, "EUR")
+  #   #=> #<Money @cents=10000 @currency="EUR">
+  #
+  # @see Money.new
+  #
+  def self.new_with_dollars(amount, currency = Money.default_currency, bank = Money.default_bank)
+    money = from_numeric(amount, currency)
+    # Hack! You can't change a bank
+    money.instance_variable_set("@bank", bank)
+    money
+  end
+
+
+  # Parses the current string and converts it to a +Money+ object.
+  # Excess characters will be discarded.
+  #
+  # @param [String, #to_s] input The input to parse.
+  # @param [Currency, String, Symbol] currency The currency format.
+  #   The currency to set the resulting +Money+ object to.
+  #
+  # @return [Money]
+  #
+  # @raise [ArgumentError] If any +currency+ is supplied and
+  #   given value doesn't match the one extracted from
+  #   the +input+ string.
+  #
+  # @example
+  #   '100'.to_money                #=> #<Money @cents=10000>
+  #   '100.37'.to_money             #=> #<Money @cents=10037>
+  #   '100 USD'.to_money            #=> #<Money @cents=10000, @currency=#<Money::Currency id: usd>>
+  #   'USD 100'.to_money            #=> #<Money @cents=10000, @currency=#<Money::Currency id: usd>>
+  #   '$100 USD'.to_money           #=> #<Money @cents=10000, @currency=#<Money::Currency id: usd>>
+  #   'hello 2000 world'.to_money   #=> #<Money @cents=200000 @currency=#<Money::Currency id: usd>>
+  #
+  # @example Mismatching currencies
+  #   'USD 2000'.to_money("EUR")    #=> ArgumentError
+  #
+  # @see Money.from_string
+  #
+  def self.parse(input, currency = nil)
+    i = input.to_s
+
+    # Get the currency.
+    m = i.scan /([A-Z]{2,3})/
+    c = m[0] ? m[0][0] : nil
+
+    # check that currency passed and embedded currency are the same,
+    # and negotiate the final currency
+    if currency.nil? and c.nil?
+      currency = Money.default_currency
+    elsif currency.nil?
+      currency = c
+    elsif c.nil?
+      currency = currency
+    elsif currency != c
+      # TODO: ParseError
+      raise ArgumentError, "Mismatching Currencies"
+    end
+    currency = Money::Currency.wrap(currency)
+
+    cents = extract_cents(i, currency)
+    Money.new(cents, currency)
+  end
+
+  # Converts a String into a Money object treating the +value+
+  # as dollars and converting them to the corresponding cents value,
+  # according to +currency+ subunit property,
+  # before instantiating the Money object.
+  #
+  # Behind the scenes, this method relies on {Money.from_bigdecimal}
+  # to avoid problems with string-to-numeric conversion.
+  #
+  # @param [String, #to_s] value The money amount, in dollars.
+  # @param [Currency, String, Symbol] currency
+  #   The currency to set the resulting +Money+ object to.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   Money.from_string("100")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_string("100", "USD")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_string("100", "EUR")
+  #   #=> #<Money @cents=10000 @currency="EUR">
+  #   Money.from_string("100", "BHD")
+  #   #=> #<Money @cents=100 @currency="BHD">
+  #
+  # @see String#to_money
+  # @see Money.parse
+  #
+  def self.from_string(value, currency = Money.default_currency)
+    from_bigdecimal(BigDecimal.new(value.to_s), currency)
+  end
+
+  # Converts a Fixnum into a Money object treating the +value+
+  # as dollars and converting them to the corresponding cents value,
+  # according to +currency+ subunit property,
+  # before instantiating the Money object.
+  #
+  # @param [Fixnum] value The money amount, in dollars.
+  # @param [Currency, String, Symbol] currency The currency format.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   Money.from_fixnum(100)
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_fixnum(100, "USD")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_fixnum(100, "EUR")
+  #   #=> #<Money @cents=10000 @currency="EUR">
+  #   Money.from_fixnum(100, "BHD")
+  #   #=> #<Money @cents=100 @currency="BHD">
+  #
+  # @see Fixnum#to_money
+  # @see Money.from_numeric
+  #
+  def self.from_fixnum(value, currency = Money.default_currency)
+    currency = Money::Currency.wrap(currency)
+    amount   = value * currency.subunit_to_unit
+    Money.new(amount, currency)
+  end
+
+  # Converts a Float into a Money object treating the +value+
+  # as dollars and converting them to the corresponding cents value,
+  # according to +currency+ subunit property,
+  # before instantiating the Money object.
+  #
+  # Behind the scenes, this method relies on Money.from_bigdecimal
+  # to avoid problems with floating point precision.
+  #
+  # @param [Float] value The money amount, in dollars.
+  # @param [Currency, String, Symbol] currency The currency format.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   Money.from_float(100.0)
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_float(100.0, "USD")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_float(100.0, "EUR")
+  #   #=> #<Money @cents=10000 @currency="EUR">
+  #   Money.from_float(100.0, "BHD")
+  #   #=> #<Money @cents=100 @currency="BHD">
+  #
+  # @see Float#to_money
+  # @see Money.from_numeric
+  #
+  def self.from_float(value, currency = Money.default_currency)
+    from_bigdecimal(BigDecimal.new(value.to_s), currency)
+  end
+
+  # Converts a BigDecimal into a Money object treating the +value+
+  # as dollars and converting them to the corresponding cents value,
+  # according to +currency+ subunit property,
+  # before instantiating the Money object.
+  #
+  # @param [BigDecimal] value The money amount, in dollars.
+  # @param [Currency, String, Symbol] currency The currency format.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   Money.from_bigdecimal(BigDecimal.new("100")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_bigdecimal(BigDecimal.new("100", "USD")
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_bigdecimal(BigDecimal.new("100", "EUR")
+  #   #=> #<Money @cents=10000 @currency="EUR">
+  #   Money.from_bigdecimal(BigDecimal.new("100", "BHD")
+  #   #=> #<Money @cents=100 @currency="BHD">
+  #
+  # @see BigDecimal#to_money
+  # @see Money.from_numeric
+  #
+  def self.from_bigdecimal(value, currency = Money.default_currency)
+    currency = Money::Currency.wrap(currency)
+    amount   = value * currency.subunit_to_unit
+    Money.new(amount.fix, currency)
+  end
+
+  # Converts a Numeric value into a Money object treating the +value+
+  # as dollars and converting them to the corresponding cents value,
+  # according to +currency+ subunit property,
+  # before instantiating the Money object.
+  #
+  # This method relies on various +Money.from_*+ methods
+  # and tries to forwards the call to the most appropriate method
+  # in order to reduce computation effort.
+  # For instance, if +value+ is an Integer, this method calls
+  # {Money.from_fixnum} instead of using the default
+  # {Money.from_bigdecimal} which adds the overload to converts
+  # the value into a slower BigDecimal instance.
+  #
+  # @param [Numeric] value The money amount, in dollars.
+  # @param [Currency, String, Symbol] currency The currency format.
+  #
+  # @return [Money]
+  #
+  # @raise +ArgumentError+ Unless +value+ is a supported type.
+  #
+  # @example
+  #   Money.from_numeric(100)
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_numeric(100.00)
+  #   #=> #<Money @cents=10000 @currency="USD">
+  #   Money.from_numeric("100")
+  #   #=> ArgumentError
+  #
+  # @see Numeric#to_money
+  # @see Money.from_fixnum
+  # @see Money.from_float
+  # @see Money.from_bigdecimal
+  #
+  def self.from_numeric(value, currency = Money.default_currency)
+    case value
+      when Fixnum
+        from_fixnum(value, currency)
+      when Numeric
+        from_bigdecimal(BigDecimal.new(value.to_s), currency)
+      else
+        raise ArgumentError, "`value' should be a Numeric object"
+    end
+  end
+
+
   # Adds a new exchange rate to the default bank and return the rate.
   #
   # @param [Currency, String, Symbol] from_currency Currency to exchange from.
-  # @param [Currency, String, Symbol[ to_currency Currency to exchange to.
+  # @param [Currency, String, Symbol] to_currency Currency to exchange to.
   # @param [Numeric] rate Rate to exchange with.
   #
   # @return [Numeric]
@@ -115,19 +362,30 @@ class Money
     Money.default_bank.add_rate(from_currency, to_currency, rate)
   end
 
-  # Creates a new money object. Alternatively you can use the convenience
-  # methods like +Money#ca_dollar+ and +Money#us_dollar+
+
+  # Creates a new Money object of +cents+ value in cents,
+  # with given +currency+.
   #
-  # @param [Integer] cents The cents value.
-  # @param [optional, Currency, String, Symbol] currency The currency format.
-  # @param [optional, Money::Bank::*] bank The exchange bank to use.
+  # Alternatively you can use the convenience
+  # methods like {Money.ca_dollar} and {Money.us_dollar}.
+  #
+  # @param [Integer] cents The money amount, in cents.
+  # @param [Currency, String, Symbol] currency The currency format.
+  # @param [Money::Bank::*] bank The exchange bank to use.
   #
   # @return [Money]
   #
   # @example
-  #  Money.new(100) #=> #<Money @cents=100>
-  def initialize(cents, currency = Money.default_currency,
-                 bank = Money.default_bank)
+  #   Money.new(100)
+  #   #=> #<Money @cents=100 @currency="USD">
+  #   Money.new(100, "USD")
+  #   #=> #<Money @cents=100 @currency="USD">
+  #   Money.new(100, "EUR")
+  #   #=> #<Money @cents=100 @currency="EUR">
+  #
+  # @see Money.new_with_dollars
+  #
+  def initialize(cents, currency = Money.default_currency, bank = Money.default_bank)
     @cents = cents.round
     if currency.is_a?(Hash)
       # Earlier versions of Money wrongly documented the constructor as being able
@@ -136,6 +394,8 @@ class Money
       #   Money.new(50, :currency => "USD")
       #
       # We retain compatibility here.
+      Money.deprecate "Passing :currency as option is deprecated and will be removed in v3.5.0. " +
+                      "Please use `Money.new('#{cents}'#{currency[:currency].nil? ? "" : ", '#{currency[:currency]}'"})'"
       @currency = Currency.wrap(currency[:currency] || Money.default_currency)
     else
       @currency = Currency.wrap(currency)
@@ -143,6 +403,22 @@ class Money
     @bank = bank
   end
 
+  # Returns the value of the money in dollars,
+  # instead of in cents.
+  #
+  # @return [Float]
+  #
+  # @example
+  #   Money.new(100).dollars           # => 1.0
+  #   Money.new_with_dollars(1).dollar # => 1.0
+  #
+  # @see #to_f
+  # @see #cents
+  #
+  def dollars
+    to_f
+  end
+
   # Return string representation of currency object
   #
   # @return [String]
@@ -222,7 +498,7 @@ class Money
   #
   # @return [-1, 0, 1]
   #
-  # @raise +ArgumentError+
+  # @raise [ArgumentError]
   #
   # @example
   #   Money.new(100) <=> 99             #=>  1
@@ -237,7 +513,7 @@ class Money
         cents <=> other_money.exchange_to(currency).cents
       end
     else
-      raise ArgumentError, "comparison of #{self.class} with #{other_money.inspect} failed"
+      raise ArgumentError, "Comparison of #{self.class} with #{other_money.inspect} failed"
     end
   end
 
@@ -281,51 +557,63 @@ class Money
   # Multiplies the monetary value with the given number and returns a new
   # +Money+ object with this monetary value and the same currency.
   #
-  # Multiplying with another Money object is currently not supported.
+  # Note that you can't multiply a Money object by an other +Money+ object.
   #
-  # @param [Fixnum] fixnum Number to multiply by.
+  # @param [Numeric] value Number to multiply by.
   #
-  # @return [Money]
+  # @return [Money] The resulting money.
+  #
+  # @raise [ArgumentError] If +value+ is a Money instance.
   #
   # @example
   #   Money.new(100) * 2 #=> #<Money @cents=200>
-  def *(fixnum)
-    Money.new(cents * fixnum, currency)
+  #
+  def *(value)
+    if value.is_a?(Money)
+      raise ArgumentError, "Can't multiply a Money by a Money"
+    else
+      Money.new(cents * value, currency)
+    end
   end
 
   # Divides the monetary value with the given number and returns a new +Money+
-  # object with this monetary value and the same currency. Can also divide by
-  # another +Money+ object to get a ratio. +Money/Numeric+ returns +Money+.
-  # +Money/Money+ returns +Float+
+  # object with this monetary value and the same currency.
+  # Can also divide by another +Money+ object to get a ratio.
+  #
+  # +Money/Numeric+ returns +Money+. +Money/Money+ returns +Float+.
   #
-  # @param [Money, Numeric] val Number to divide by.
+  # @param [Money, Numeric] value Number to divide by.
   #
-  # @return [Money, Float]
+  # @return [Money] The resulting money if you divide Money by a number.
+  # @return [Float] The resulting number if you divide Money by a Money.
   #
   # @example
   #   Money.new(100) / 10            #=> #<Money @cents=10>
   #   Money.new(100) / Money.new(10) #=> 10.0
-  def /(val)
-    if val.is_a?(Money)
-      if currency == val.currency
-        cents / val.cents.to_f
+  #
+  def /(value)
+    if value.is_a?(Money)
+      if currency == value.currency
+        (cents / BigDecimal.new(value.cents.to_s)).to_f
       else
-        cents / val.exchange_to(currency).cents.to_f
+        (cents / BigDecimal(value.exchange_to(currency).cents.to_s)).to_f
       end
     else
-      Money.new(cents / val, currency)
+      Money.new(cents / value, currency)
     end
   end
 
   # Synonym for +#/+.
   #
-  # @param [Money, Numeric] val Number to divide by.
+  # @param [Money, Numeric] value Number to divide by.
   #
-  # @return [Money, Float]
+  # @return [Money] The resulting money if you divide Money by a number.
+  # @return [Float] The resulting number if you divide Money by a Money.
   #
   # @see #/
-  def div(val)
-    self / val
+  #
+  def div(value)
+    self / value
   end
 
   # Divide money by money or fixnum and return array containing quotient and
@@ -569,9 +857,9 @@ class Money
     end
 
     if rules[:no_cents] or currency.subunit_to_unit == 1
-      formatted = sprintf("#{symbol_value}%d", cents.to_f / currency.subunit_to_unit)
+      formatted = sprintf("#{symbol_value}%d", self.to_f)
     else
-      formatted = sprintf("#{symbol_value}%.2f", cents.to_f / currency.subunit_to_unit)
+      formatted = sprintf("#{symbol_value}%.2f", self.to_f)
     end
 
     delimiter_value = delimiter
@@ -585,7 +873,7 @@ class Money
     end
 
     # Apply delimiter
-    formatted.gsub!(/(\d)(?=\d{3}+(?:\.|$))(\d{3}\..*)?/, "\\1#{delimiter_value}\\2")
+    formatted.gsub!(/(\d)(?=(?:\d{3})+(?:\.|$))(\d{3}\..*)?/, "\\1#{delimiter_value}\\2")
 
     separator_value = separator
     # Determine separator
@@ -613,7 +901,7 @@ class Money
   #   Money.ca_dollar(100).to_s #=> "1.00"
   def to_s
     return sprintf("%d", cents) if currency.subunit_to_unit == 1
-    sprintf("%.2f", cents.to_f / currency.subunit_to_unit)
+    sprintf("%.2f", self.to_f)
   end
 
   # Return the amount of money as a float. Floating points cannot guarantee
@@ -626,7 +914,7 @@ class Money
   # @example
   #   Money.us_dollar(100).to_f => 1.0
   def to_f
-    cents.to_f / currency.subunit_to_unit
+    (BigDecimal.new(cents.to_s) / currency.subunit_to_unit).to_f
   end
 
   # Receive the amount of this money object in another Currency.
@@ -694,10 +982,14 @@ class Money
   #
   # @return [Hash]
   def normalize_formatting_rules(rules)
-    if rules.size == 1
+    if rules.size == 0
+      rules = {}
+    elsif rules.size == 1
       rules = rules.pop
       rules = { rules => true } if rules.is_a?(Symbol)
     else
+      Money.deprecate "Passing options as parameters is deprecated and will be removed in v3.5.0. " +
+                      "Please use `#format(#{rules.map { |r| ":#{r} => true" }.join(", ") })'"
       rules = rules.inject({}) do |h,s|
         h[s] = true
         h
@@ -705,4 +997,118 @@ class Money
     end
     rules
   end
+
+  # Takes a number string and attempts to massage out the number.
+  #
+  # @param [String] input The string containing a potential number.
+  #
+  # @return [Integer]
+  #
+  def self.extract_cents(input, currency = Money.default_currency)
+    # remove anything that's not a number, potential delimiter, or minus sign
+    num = input.gsub(/[^\d|\.|,|\'|\s|\-]/, '').strip
+
+    # set a boolean flag for if the number is negative or not
+    negative = num.split(//).first == "-"
+
+    # if negative, remove the minus sign from the number
+    num = num.gsub(/^-/, '') if negative
+
+    # gather all separators within the result number
+    used_separators = num.scan /[^\d]/
+
+    # determine the number of unique separators within the number
+    #
+    # e.g.
+    # $1,234,567.89 would return 2 (, and .)
+    # $125,00 would return 1
+    # $199 would return 0
+    # $1 234,567.89 would raise an error (separators are space, comma, and period)
+    case used_separators.uniq.length
+    # no separator or delimiter; major (dollars) is the number, and minor (cents) is 0
+    when 0 then major, minor = num, 0
+
+    # two separators, so we know the last item in this array is the
+    # major/minor delimiter and the rest are separators
+    when 2
+      separator, delimiter = used_separators.uniq
+      # remove all separators, split on the delimiter
+      major, minor = num.gsub(separator, '').split(delimiter)
+      min = 0 unless min
+    when 1
+      # we can't determine if the comma or period is supposed to be a separator or a delimiter
+      # e.g.
+      # 1,00 - comma is a delimiter
+      # 1.000 - period is a delimiter
+      # 1,000 - comma is a separator
+      # 1,000,000 - comma is a separator
+      # 10000,00 - comma is a delimiter
+      # 1000,000 - comma is a delimiter
+
+      # assign first separator for reusability
+      separator = used_separators.first
+
+      # separator is used as a separator when there are multiple instances, always
+      if num.scan(separator).length > 1 # multiple matches; treat as separator
+        major, minor = num.gsub(separator, ''), 0
+      else
+        # ex: 1,000 - 1.0000 - 10001.000
+        # split number into possible major (dollars) and minor (cents) values
+        possible_major, possible_minor = num.split(separator)
+        possible_major ||= "0"
+        possible_minor ||= "00"
+
+        # if the minor (cents) length isn't 3, assign major/minor from the possibles
+        # e.g.
+        #   1,00 => 1.00
+        #   1.0000 => 1.00
+        #   1.2 => 1.20
+        if possible_minor.length != 3 # delimiter
+          major, minor = possible_major, possible_minor
+        else
+          # minor length is three
+          # let's try to figure out intent of the delimiter
+
+          # the major length is greater than three, which means
+          # the comma or period is used as a delimiter
+          # e.g.
+          #   1000,000
+          #   100000,000
+          if possible_major.length > 3
+            major, minor = possible_major, possible_minor
+          else
+            # number is in format ###{sep}### or ##{sep}### or #{sep}###
+            # handle as , is sep, . is delimiter
+            if separator == '.'
+              major, minor = possible_major, possible_minor
+            else
+              major, minor = "#{possible_major}#{possible_minor}", 0
+            end
+          end
+        end
+      end
+    else
+      # TODO: ParseError
+      raise ArgumentError, "Invalid currency amount"
+    end
+
+    # build the string based on major/minor since separator/delimiters have been removed
+    # avoiding floating point arithmetic here to ensure accuracy
+    cents = (major.to_i * currency.subunit_to_unit)
+    # add the minor number as well. this may have any number of digits,
+    # so we treat minor as a string and truncate or right-fill it with zeroes
+    # until it becomes a two-digit number string, which we add to cents.
+    minor = minor.to_s
+    truncated_minor = minor[0..1]
+    truncated_minor << "0" * (2 - truncated_minor.size) if truncated_minor.size < 2
+    cents += truncated_minor.to_i
+    # respect rounding rules
+    if minor.size >= 3 && minor[2..2].to_i >= 5
+      cents += 1
+    end
+
+    # if negative, multiply by -1; otherwise, return positive cents
+    negative ? cents * -1 : cents
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: money
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 9
   prerelease: false
   segments: 
   - 3
   - 1
-  - 0
-  version: 3.1.0
+  - 5
+  version: 3.1.5
 platform: ruby
 authors: 
 - Tobias Luetke
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-13 00:00:00 -04:00
+date: 2010-10-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -109,12 +109,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 21
+      hash: 23
       segments: 
       - 1
       - 3
-      - 7
-      version: 1.3.7
+      - 6
+      version: 1.3.6
 requirements: 
 - json if you plan to import/export rates formatted as json
 rubyforge_project: money