money 6.0.0.pre2 → 6.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db3de84c7fca4fad50f28617c05aa96b0a8cd2f9
-  data.tar.gz: 3a22bb6c242e6b96660f78add455217a5eac3e5d
+  metadata.gz: b9dae4831f4901cf906ae3d6f155c9bac6e3f67f
+  data.tar.gz: 43718a7d7edfce6329053cd90a7b61ec2d4d3a78
 SHA512:
-  metadata.gz: c55f42b4d76f62ba787b54ef929d202f1edd873d9abc7139fc1cb8e5276f59263d293f4b1c316e35cf814493c211598adee7812b83d23f60e51d276d7bbe6919
-  data.tar.gz: c6b9250d167858e374ab2ae18da527aa4d3c06017a60cb8574190da4afca629020bdf18d4e0005abd2fd48b80dbced701b61e16bce81dbf78aee87b83933437a
+  metadata.gz: a13f5e9078a642608bc4d224639b27ca74b44952c6cba8790515534c5e09d50d77eba86c4f0fc0540fb4d840cf8b9c3cef6ef8af6a06fb5c81740850862e971e
+  data.tar.gz: 652d159f7d083c9975f15ad14f3f92cd2aea19c475cacc3dead90711771d5ed04b32e96a66b97b08ee3153816670037088a8ad8fb49f2c5b552b8336a2dde2af

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 # Changelog
 
 ## master
+- New option :sign_positive to add a + sign to positive numbers
+- Only allow to multiply a money by a number (int, float)
 - Fix typo
 - Wrap the currency symbol in a span if :html is specified in the rules
 - Added Money::Currency.all method
@@ -9,6 +11,14 @@
 - Works on Ruby 1.8.7
 - Update deps
 - Depreciate Money.parse
+- Passing :symbol => false when formatting 'JPY' currency in :ja locale
+  will work as expected
+- Divide now obeys the specified rounding mode
+- Add Money#round method. This is helpful when working in infinite_precision mode and would like to perform rounding at specific points in your work flow.
+- In infinite precision mode, deserialized Money objects no longer return Float values from the `fractional` method.
+- Changed `thousands_separator` for Swedish Krona from dot to blank space.
+- Allow mathematical operations with first argument being not an instance of Money (eg. 2 * money instead of money * 2).
+- Money#dollars and Money#amount methods return numbers of type BigDecimal.
 
 ## 5.1.1
 

data/README.md

@@ -2,6 +2,8 @@
 
 [![Gem Version](https://badge.fury.io/rb/money.png)](http://badge.fury.io/rb/money) [![Build Status](https://travis-ci.org/RubyMoney/money.png?branch=master)](https://travis-ci.org/RubyMoney/money) [![Code Climate](https://codeclimate.com/github/RubyMoney/money.png)](https://codeclimate.com/github/RubyMoney/money)
 
+:warning: Please read the [migration notes](#migration-notes) before upgrading to a new major version.
+
 ## Contributing
 
 See the [Contribution Guidelines](https://github.com/RubyMoney/money/blob/master/CONTRIBUTING.md)
@@ -249,9 +251,26 @@ implementations.
 - [nbrb_currency](https://github.com/slbug/nbrb_currency)
 - [money-open-exchange-rates](https://github.com/spk/money-open-exchange-rates)
 - [money-historical-bank](https://github.com/atwam/money-historical-bank)
+- [russian_central_bank](https://github.com/rmustafin/russian_central_bank)
 
 ## Ruby on Rails
 
 To integrate money in a Rails application use [money-rails](http://github.com/RubyMoney/money-rails).
 
 For deprecated methods of integrating with Rails, check [the wiki](https://github.com/RubyMoney/money/wiki).
+
+## Migration Notes
+
+#### Version 6.0.0.pre3
+
+- The `Money#dollars` and `Money#amount` methods now return instances of
+  `BigDecimal` rather than `Float`. We should avoid representing monetary
+  values with floating point types so to avoid a whole class of errors relating
+  to lack of precision. There are two migration options for this change:
+  * The first is to test your application and where applicable update the
+    application to accept a `BigDecimal` return value. This is the recommended
+    path.
+  * The second is to migrate from the `#amount` and `#dollars` methods to use
+    the `#to_f` method instead. This option should only be used where `Float`
+    is the desired type and nothing else will do for your application's
+    requirements.

data/config/currency_iso.json

@@ -1731,7 +1731,7 @@
     "symbol_first": false,
     "html_entity": "",
     "decimal_mark": ",",
-    "thousands_separator": ".",
+    "thousands_separator": " ",
     "iso_numeric": "752"
   },
   "sgd": {

data/lib/money/money.rb

@@ -22,16 +22,27 @@ class Money
   #
   # @return [Integer]
   def fractional
+    # Ensure we have a BigDecimal. If the Money object is created
+    # from YAML, @fractional can end up being set to a Float.
+    fractional = as_d(@fractional)
+
     if self.class.infinite_precision
-      @fractional
+      fractional
+    else
+      fractional.round(0, self.class.rounding_mode).to_i
+    end
+  end
+
+  def as_d(num)
+    if num.is_a?(Rational)
+      num.to_d(self.class.conversion_precision)
+    elsif num.respond_to?(:to_d)
+      num.to_d
     else
-      # If the Money object is created from a serialized YAML string, 
-      # @fractional can end up being set to a Float. We need to ensure 
-      # it is BigDecimal before calling #round with two paramers. 
-      # Float class only provides #round with 0 or 1 parameter.
-      BigDecimal.new(@fractional.to_s, 0).round(0, self.class.rounding_mode).to_i
+      BigDecimal.new(num.to_s)
     end
   end
+  private :as_d
 
   # The currency the money is in.
   #
@@ -238,13 +249,7 @@ class Money
   # @see Money.new_with_dollars
   #
   def initialize(fractional, currency = Money.default_currency, bank = Money.default_bank)
-    @fractional = if fractional.is_a?(Rational)
-                    fractional.to_d(self.class.conversion_precision)
-                  elsif fractional.respond_to?(:to_d)
-                    fractional.to_d
-                  else
-                    BigDecimal.new(fractional.to_s)
-                  end
+    @fractional = as_d(fractional)
     @currency = Currency.wrap(currency)
     @bank     = bank
   end
@@ -255,14 +260,14 @@ class Money
   #
   # Synonym of #amount
   #
-  # @return [Float]
+  # @return [BigDecimal]
   #
   # @example
   #   Money.new(100).dollars           # => 1.0
   #   Money.new_with_dollars(1).dollar # => 1.0
   #
   # @see #amount
-  # @see #to_f
+  # @see #to_d
   # @see #cents
   #
   def dollars
@@ -271,17 +276,17 @@ class Money
 
   # Returns the numerical value of the money
   #
-  # @return [Float]
+  # @return [BigDecimal]
   #
   # @example
   #   Money.new(100).amount            # => 1.0
   #   Money.new_with_amount(1).amount  # => 1.0
   #
-  # @see #to_f
+  # @see #to_d
   # @see #fractional
   #
   def amount
-    to_f
+    to_d
   end
 
   # Return string representation of currency object
@@ -385,13 +390,13 @@ class Money
   # @example
   #   Money.us_dollar(100).to_d => BigDecimal.new("1.0")
   def to_d
-    BigDecimal.new(fractional.to_s) / BigDecimal.new(currency.subunit_to_unit.to_s)
+    as_d(fractional) / as_d(currency.subunit_to_unit)
   end
 
   # Return the amount of money as a float. Floating points cannot guarantee
   # precision. Therefore, this function should only be used when you no longer
   # need to represent currency or working with another system that requires
-  # decimals.
+  # floats.
   #
   # @return [Float]
   #
@@ -476,10 +481,7 @@ class Money
   #   Money.new(5, "USD").allocate([0.3,0.7)) #=> [Money.new(2), Money.new(3)]
   #   Money.new(100, "USD").allocate([0.33,0.33,0.33]) #=> [Money.new(34), Money.new(33), Money.new(33)]
   def allocate(splits)
-    allocations = splits.inject(BigDecimal("0")) do |sum, n|
-      n = BigDecimal(n.to_s) unless n.is_a?(BigDecimal)
-      sum + n
-    end
+    allocations = splits.inject(0) { |sum, n| sum + as_d(n) }
 
     if (allocations - BigDecimal("1")) > Float::EPSILON
       raise ArgumentError, "splits add to more then 100%"
@@ -516,12 +518,12 @@ class Money
     raise ArgumentError, "need at least one party" if num < 1
 
     if self.class.infinite_precision
-      amt = self.div(BigDecimal(num.to_s))
+      amt = div(as_d(num))
       return 1.upto(num).map{amt}
     end
 
-    low = Money.new(fractional / num, self.currency)
-    high = Money.new(low.fractional + 1, self.currency)
+    low = Money.new(fractional / num, currency)
+    high = Money.new(low.fractional + 1, currency)
 
     remainder = fractional % num
     result = []
@@ -533,4 +535,23 @@ class Money
     result
   end
 
+  # Round the monetary amount to smallest unit of coinage.
+  #
+  # This method is only useful when operating with infinite_precision turned
+  # on. Without infinite_precision values are rounded to the smallest unit of
+  # coinage automatically.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   Money.new(10.1, 'USD').round #=> Money.new(10, 'USD')
+  #
+  def round(rounding_mode = self.class.rounding_mode)
+    if self.class.infinite_precision
+      return Money.new(fractional.round(0, rounding_mode), self.currency)
+    else
+      return self
+    end
+  end
+
 end

data/lib/money/money/arithmetic.rb

@@ -26,7 +26,7 @@ class Money
     def ==(other_money)
       if other_money.respond_to?(:to_money)
         other_money = other_money.to_money
-        fractional == other_money.fractional && self.currency == other_money.currency
+        fractional == other_money.fractional && currency == other_money.currency
       else
         false
       end
@@ -93,11 +93,8 @@ class Money
     # @example
     #   Money.new(100) + Money.new(100) #=> #<Money @fractional=200>
     def +(other_money)
-      if currency == other_money.currency
-        Money.new(fractional + other_money.fractional, other_money.currency)
-      else
-        Money.new(fractional + other_money.exchange_to(currency).fractional, currency)
-      end
+      other_money = other_money.exchange_to(currency)
+      Money.new(fractional + other_money.fractional, currency)
     end
 
     # Returns a new Money object containing the difference between the two
@@ -112,11 +109,8 @@ class Money
     # @example
     #   Money.new(100) - Money.new(99) #=> #<Money @fractional=1>
     def -(other_money)
-      if currency == other_money.currency
-        Money.new(fractional - other_money.fractional, other_money.currency)
-      else
-        Money.new(fractional - other_money.exchange_to(currency).fractional, currency)
-      end
+      other_money = other_money.exchange_to(currency)
+      Money.new(fractional - other_money.fractional, currency)
     end
 
     # Multiplies the monetary value with the given number and returns a new
@@ -128,16 +122,16 @@ class Money
     #
     # @return [Money] The resulting money.
     #
-    # @raise [ArgumentError] If +value+ is a Money instance.
+    # @raise [ArgumentError] If +value+ is NOT a number.
     #
     # @example
     #   Money.new(100) * 2 #=> #<Money @fractional=200>
     #
     def *(value)
-      if value.is_a?(Money)
-        raise ArgumentError, "Can't multiply a Money by a Money"
-      else
+      if value.is_a? Numeric
         Money.new(fractional * value, currency)
+      else
+        raise ArgumentError, "Can't multiply a Money by a #{value.class.name}'s value"
       end
     end
 
@@ -158,13 +152,9 @@ class Money
     #
     def /(value)
       if value.is_a?(Money)
-        if currency == value.currency
-          (fractional / BigDecimal.new(value.fractional.to_s)).to_f
-        else
-          (fractional / BigDecimal(value.exchange_to(currency).fractional.to_s)).to_f
-        end
+        fractional / as_d(value.exchange_to(currency).fractional).to_f
       else
-        Money.new(fractional / value, currency)
+        Money.new(fractional / as_d(value), currency)
       end
     end
 
@@ -193,16 +183,16 @@ class Money
     #   Money.new(100).divmod(Money.new(9)) #=> [11, #<Money @fractional=1>]
     def divmod(val)
       if val.is_a?(Money)
-        a = self.fractional
-        b = self.currency == val.currency ? val.fractional : val.exchange_to(self.currency).cents
+        a = fractional
+        b = val.exchange_to(currency).cents
         q, m = a.divmod(b)
-        return [q, Money.new(m, self.currency)]
+        return [q, Money.new(m, currency)]
       else
         if self.class.infinite_precision
-          q, m = self.fractional.divmod(BigDecimal(val.to_s))
-          return [Money.new(q, self.currency), Money.new(m, self.currency)]
+          q, m = fractional.divmod(as_d(val))
+          return [Money.new(q, currency), Money.new(m, currency)]
         else
-          return [self.div(val), Money.new(self.fractional.modulo(val), self.currency)]
+          return [div(val), Money.new(fractional.modulo(val), currency)]
         end
       end
     end
@@ -217,7 +207,7 @@ class Money
     #   Money.new(100).modulo(9)            #=> #<Money @fractional=1>
     #   Money.new(100).modulo(Money.new(9)) #=> #<Money @fractional=1>
     def modulo(val)
-      self.divmod(val)[1]
+      divmod(val)[1]
     end
 
     # Synonym for +#modulo+.
@@ -228,7 +218,7 @@ class Money
     #
     # @see #modulo
     def %(val)
-      self.modulo(val)
+      modulo(val)
     end
 
     # If different signs +self.modulo(val) - val+ otherwise +self.modulo(val)+
@@ -258,7 +248,7 @@ class Money
     # @example
     #   Money.new(-100).abs #=> #<Money @fractional=100>
     def abs
-      Money.new(self.fractional.abs, self.currency)
+      Money.new(fractional.abs, currency)
     end
 
     # Test if the money amount is zero.
@@ -284,5 +274,13 @@ class Money
       fractional != 0 ? self : nil
     end
 
+    # Used to make Money instance handle the operations when arguments order is reversed
+    # @return [Array]
+    #
+    # @example
+    #   2 * Money.new(10) #=> #<Money @fractional=20>
+    def coerce(other)
+      [self, other]
+    end
   end
 end

data/lib/money/money/formatting.rb

@@ -180,6 +180,18 @@ class Money
     #   Money.new(-100, "GBP").format(:sign_before_symbol => true)  #=> "-£1.00"
     #   Money.new(-100, "GBP").format(:sign_before_symbol => false) #=> "£-1.00"
     #   Money.new(-100, "GBP").format                               #=> "£-1.00"
+    #
+    # @option *rules [Boolean] :sign_positive (false) Whether positive numbers should be
+    #  signed, too.
+    #
+    # @example
+    #   # You can specify to display the sign with positive numbers
+    #   Money.new(100, "GBP").format(:sign_positive => true,  :sign_before_symbol => true)  #=> "+£1.00"
+    #   Money.new(100, "GBP").format(:sign_positive => true,  :sign_before_symbol => false) #=> "£+1.00"
+    #   Money.new(100, "GBP").format(:sign_positive => false, :sign_before_symbol => true)  #=> "£1.00"
+    #   Money.new(100, "GBP").format(:sign_positive => false, :sign_before_symbol => false) #=> "£1.00"
+    #   Money.new(100, "GBP").format                               #=> "£+1.00"
+
     def format(*rules)
       # support for old format parameters
       rules = normalize_formatting_rules(rules)
@@ -208,7 +220,9 @@ class Money
           symbol
         end
 
-      formatted = rules[:no_cents] ? "#{self.to_s.to_i}" : self.to_s
+      sign = self.negative? ? '-' : ''
+      formatted = rules[:no_cents] ? "#{self.abs.to_s.to_i}" : self.abs.to_s
+
 
       if rules[:no_cents_if_whole] && cents % currency.subunit_to_unit == 0
         formatted = "#{self.to_s.to_i}"
@@ -233,10 +247,13 @@ class Money
           :after
         end
 
-      sign = ""
-      if rules[:sign_before_symbol] == true && self.negative?
-        formatted.tr!("-", "")
-        sign = "-"
+      if rules[:sign_positive] == true && self.positive?
+        sign = '+'
+      end
+
+      if rules[:sign_before_symbol] == true
+        sign_before = sign
+        sign = ''
       end
 
       if symbol_value && !symbol_value.empty?
@@ -244,10 +261,10 @@ class Money
 
         formatted = if symbol_position == :before
           symbol_space = rules[:symbol_before_without_space] === false ? " " : ""
-          "#{sign}#{symbol_value}#{symbol_space}#{formatted}"
+          "#{sign_before}#{symbol_value}#{symbol_space}#{sign}#{formatted}"
         else
           symbol_space = rules[:symbol_after_without_space] ? "" : " "
-          "#{sign}#{formatted}#{symbol_space}#{symbol_value}"
+          "#{sign_before}#{formatted}#{symbol_space}#{sign}#{symbol_value}"
         end
       end
 
@@ -306,7 +323,7 @@ class Money
 
   def localize_formatting_rules(rules)
     if currency.iso_code == "JPY" && I18n.locale == :ja
-      rules[:symbol] = "円"
+      rules[:symbol] = "円" unless rules[:symbol] == false
       rules[:symbol_position] = :after
       rules[:symbol_after_without_space] = true
     end

data/money.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = "money"
-  s.version     = "6.0.0.pre2"
+  s.version     = "6.0.0.pre3"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Tobias Luetke", "Hongli Lai", "Jeremy McNevin",
                    "Shane Emmons", "Simone Carletti"]
@@ -10,6 +10,17 @@ Gem::Specification.new do |s|
   s.summary     = "Money and currency exchange support library."
   s.description = "This library aids one in handling money and different currencies."
 
+  s.post_install_message = '''
+Please note the following API changes in Money version 6
+
+ - Money#amount, Money#dollars methods now return instances of BigDecimal (rather than Float).
+
+Please read the migration notes at https://github.com/RubyMoney/money#migration-notes
+and choose the migration that best suits your application.
+
+Test responsibly :-)
+'''
+
   s.required_ruby_version     = ">= 1.8.7"
 
   s.add_dependency "i18n",       "~> 0.6.4"

data/spec/money/arithmetic_spec.rb

@@ -259,14 +259,18 @@ describe Money do
     it "does not multiply Money by Money (different currency)" do
       expect { Money.new( 10, :USD) * Money.new( 4, :EUR) }.to raise_error(ArgumentError)
     end
+
+    it "does not multiply Money by an object which is NOT a number" do
+      expect { Money.new( 10, :USD) *  'abc' }.to raise_error(ArgumentError)
+    end
   end
 
   describe "#/" do
     it "divides Money by Fixnum and returns Money" do
       ts = [
         {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
-        {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-4, :USD)},
-        {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-4, :USD)},
+        {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
+        {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3, :USD)},
         {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3, :USD)},
       ]
       ts.each do |t|
@@ -274,6 +278,44 @@ describe Money do
       end
     end
 
+    context 'rounding preference' do
+      before do
+        Money.stub(:rounding_mode => rounding_mode)
+      end
+
+      after do
+        Money.unstub(:rounding_mode)
+      end
+
+      context 'ceiling rounding' do
+        let(:rounding_mode) { BigDecimal::ROUND_CEILING }
+        it "obeys the rounding preference" do
+          (Money.new(10) / 3).should == Money.new(4)
+        end
+      end
+
+      context 'floor rounding' do
+        let(:rounding_mode) { BigDecimal::ROUND_FLOOR }
+        it "obeys the rounding preference" do
+          (Money.new(10) / 6).should == Money.new(1)
+        end
+      end
+
+      context 'half up rounding' do
+        let(:rounding_mode) { BigDecimal::ROUND_HALF_UP }
+        it "obeys the rounding preference" do
+          (Money.new(10) / 4).should == Money.new(3)
+        end
+      end
+
+      context 'half down rounding' do
+        let(:rounding_mode) { BigDecimal::ROUND_HALF_DOWN }
+        it "obeys the rounding preference" do
+          (Money.new(10) / 4).should == Money.new(2)
+        end
+      end
+    end
+
     it "divides Money by Money (same currency) and returns Float" do
       ts = [
         {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c =>  3.25},
@@ -326,8 +368,8 @@ describe Money do
     it "divides Money by Fixnum and returns Money" do
       ts = [
           {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-4, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-4, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3, :USD)},
           {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3, :USD)},
       ]
       ts.each do |t|
@@ -387,8 +429,8 @@ describe Money do
     it "calculates division and modulo with Fixnum" do
       ts = [
           {:a => Money.new( 13, :USD), :b =>  4, :c => [Money.new( 3, :USD), Money.new( 1, :USD)]},
-          {:a => Money.new( 13, :USD), :b => -4, :c => [Money.new(-4, :USD), Money.new(-3, :USD)]},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => [Money.new(-4, :USD), Money.new( 3, :USD)]},
+          {:a => Money.new( 13, :USD), :b => -4, :c => [Money.new(-3, :USD), Money.new(-3, :USD)]},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => [Money.new(-3, :USD), Money.new( 3, :USD)]},
           {:a => Money.new(-13, :USD), :b => -4, :c => [Money.new( 3, :USD), Money.new(-1, :USD)]},
       ]
       ts.each do |t|
@@ -595,4 +637,11 @@ describe Money do
       money.nonzero?.should be_equal(money)
     end
   end
+
+  describe "#coerce" do
+    it "allows mathematical operations by coercing arguments" do
+      result = 2 * Money.new(4, 'USD')
+      result.should == Money.new(8, 'USD')
+    end
+  end
 end

data/spec/money/formatting_spec.rb

@@ -82,7 +82,9 @@ describe Money, "formatting" do
       before { @_locale = I18n.locale; I18n.locale = :ja }
 
       it "formats Japanese currency in Japanese properly" do
-        Money.new(1000, "JPY").format.should == "1,000円"
+        money = Money.new(1000, "JPY")
+        money.format.should == "1,000円"
+        money.format(:symbol => false).should == "1,000"
       end
 
       after  { I18n.locale = @_locale }
@@ -133,7 +135,7 @@ describe Money, "formatting" do
       one_thousand["BRL"].should == "R$ 1.000,00"
 
       # Other
-      one_thousand["SEK"].should == "1.000,00 kr"
+      one_thousand["SEK"].should == "1 000,00 kr"
       one_thousand["GHC"].should == "₵1,000.00"
     end
 
@@ -265,6 +267,9 @@ describe Money, "formatting" do
         money.format(:symbol => "").should == "1.00"
         money.format(:symbol => nil).should == "1.00"
         money.format(:symbol => false).should == "1.00"
+
+        money = Money.new(100, "JPY")
+        money.format(:symbol => false).should == "100"
       end
 
       it "defaults :symbol to true" do
@@ -406,6 +411,34 @@ describe Money, "formatting" do
       end
     end
 
+    describe ":sign_positive option" do
+      specify "(:sign_positive => true, :sign_before_symbol => true) works as documented" do
+        Money.us_dollar(      0).format(:sign_positive => true, :sign_before_symbol => true).should == "$0.00"
+        Money.us_dollar( 100000).format(:sign_positive => true, :sign_before_symbol => true).should == "+$1,000.00"
+        Money.us_dollar(-100000).format(:sign_positive => true, :sign_before_symbol => true).should == "-$1,000.00"
+      end
+
+      specify "(:sign_positive => true, :sign_before_symbol => false) works as documented" do
+        Money.us_dollar(      0).format(:sign_positive => true, :sign_before_symbol => false).should == "$0.00"
+        Money.us_dollar( 100000).format(:sign_positive => true, :sign_before_symbol => false).should == "$+1,000.00"
+        Money.us_dollar( 100000).format(:sign_positive => true, :sign_before_symbol => nil).should == "$+1,000.00"
+        Money.us_dollar(-100000).format(:sign_positive => true, :sign_before_symbol => false).should == "$-1,000.00"
+        Money.us_dollar(-100000).format(:sign_positive => true, :sign_before_symbol => nil).should == "$-1,000.00"
+      end
+
+      specify "(:sign_positive => false, :sign_before_symbol => true) works as documented" do
+        Money.us_dollar( 100000).format(:sign_positive => false, :sign_before_symbol => true).should == "$1,000.00"
+        Money.us_dollar(-100000).format(:sign_positive => false, :sign_before_symbol => true).should == "-$1,000.00"
+      end
+
+      specify "(:sign_positive => false, :sign_before_symbol => false) works as documented" do
+        Money.us_dollar( 100000).format(:sign_positive => false, :sign_before_symbol => false).should == "$1,000.00"
+        Money.us_dollar( 100000).format(:sign_positive => false, :sign_before_symbol => nil).should == "$1,000.00"
+        Money.us_dollar(-100000).format(:sign_positive => false, :sign_before_symbol => false).should == "$-1,000.00"
+        Money.us_dollar(-100000).format(:sign_positive => false, :sign_before_symbol => nil).should == "$-1,000.00"
+      end
+    end
+
     context "when the monetary value is 0" do
       let(:money) { Money.us_dollar(0) }
 

data/spec/money/parsing_spec.rb

@@ -9,7 +9,7 @@ describe Money, "parsing" do
 
   describe ".parse" do
     it "is depreciated" do
-      Money.should_receive(:deprecate)
+      Money.should_receive(:deprecate).at_least(1).times
       Money.parse("1.95")
     end
 
@@ -32,7 +32,7 @@ describe Money, "parsing" do
         before do
           Money.assume_from_symbol = true
         end
-        it "parses formatted inputs with the currency passed as a symbol" do 
+        it "parses formatted inputs with the currency passed as a symbol" do
           with_default_currency("EUR") do
             Money.parse("$5.95").should == Money.new(595, 'USD')
           end

data/spec/money_spec.rb

@@ -157,8 +157,8 @@ describe Money do
     end
     
     context "loading a serialized Money via YAML" do
-      it "uses BigDecimal when rounding" do
-        serialized = <<YAML
+
+      let(:serialized) { <<YAML
 !ruby/object:Money
   fractional: 249.5
   currency: !ruby/object:Money::Currency
@@ -178,12 +178,30 @@ describe Money do
     mutex: !ruby/object:Mutex {}
     last_updated: 2012-11-23 20:41:47.454438399 +02:00
 YAML
+      }
+
+      it "uses BigDecimal when rounding" do
         m = YAML::load serialized
         m.should be_a(Money)
         m.class.infinite_precision.should == false
         m.fractional.should == 250 # 249.5 rounded up
         m.fractional.should be_a(Integer)
       end
+
+      context "with infinite_precision" do
+        before do
+          Money.infinite_precision = true
+        end
+
+        after do
+          Money.infinite_precision = false
+        end
+
+        it "is a BigDecimal" do
+          money = YAML::load serialized
+          money.fractional.should be_a BigDecimal
+        end
+      end
     end
 
     context "user changes rounding_mode" do
@@ -239,6 +257,10 @@ YAML
       Money.new(100_37).amount.should == 100.37
       Money.new_with_amount(100.37).amount.should == 100.37
     end
+
+    it 'produces a BigDecimal' do
+      Money.new(1_00).amount.should be_a BigDecimal
+    end
   end
 
   describe "#dollars" do
@@ -494,4 +516,49 @@ YAML
       end
     end
   end
+
+  describe "#round" do
+
+    let(:money) { Money.new(15.75, 'NZD') }
+    subject(:rounded) { money.round }
+
+    context "without infinite_precision" do
+      before do
+        Money.infinite_precision = false
+      end
+
+      it "returns self (as it is already rounded)" do
+        rounded = money.round
+        rounded.should be money
+        rounded.cents.should eq 16
+      end
+    end
+
+    context "with infinite_precision" do
+      before do
+        Money.infinite_precision = true
+      end
+
+      after do
+        Money.infinite_precision = false
+      end
+
+      it "returns a different money" do
+        rounded.should_not be money
+      end
+
+      it "rounds the cents" do
+        rounded.cents.should eq 16
+      end
+
+      it "maintains the currency" do
+        rounded.currency.should eq Money::Currency.new('NZD')
+      end
+
+      it "uses a provided rounding strategy" do
+        rounded = money.round(BigDecimal::ROUND_DOWN)
+        rounded.cents.should eq 15
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: money
 version: !ruby/object:Gem::Version
-  version: 6.0.0.pre2
+  version: 6.0.0.pre3
 platform: ruby
 authors:
 - Tobias Luetke
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-27 00:00:00.000000000 Z
+date: 2013-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -80,18 +80,18 @@ files:
 - config/currency_backwards_compatible.json
 - config/currency_iso.json
 - config/currency_non_iso.json
+- lib/money.rb
 - lib/money/bank/base.rb
 - lib/money/bank/variable_exchange.rb
 - lib/money/core_extensions.rb
+- lib/money/currency.rb
 - lib/money/currency/heuristics.rb
 - lib/money/currency/loader.rb
-- lib/money/currency.rb
 - lib/money/deprecations.rb
+- lib/money/money.rb
 - lib/money/money/arithmetic.rb
 - lib/money/money/formatting.rb
 - lib/money/money/parsing.rb
-- lib/money/money.rb
-- lib/money.rb
 - spec/bank/base_spec.rb
 - spec/bank/variable_exchange_spec.rb
 - spec/core_extensions_spec.rb
@@ -112,7 +112,16 @@ homepage: http://rubymoney.github.com/money
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |2
+
+  Please note the following API changes in Money version 6
+
+   - Money#amount, Money#dollars methods now return instances of BigDecimal (rather than Float).
+
+  Please read the migration notes at https://github.com/RubyMoney/money#migration-notes
+  and choose the migration that best suits your application.
+
+  Test responsibly :-)
 rdoc_options: []
 require_paths:
 - lib
@@ -128,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Money and currency exchange support library.