money 3.5.5 → 3.6.0

data/spec/core_extensions_spec.rb

@@ -0,0 +1,142 @@
+require "spec_helper"
+
+describe "Money core extensions" do
+
+  describe Numeric do
+    describe "#to_money" do
+      it "should work" do
+        money = 1234.to_money
+        money.cents.should == 1234_00
+        money.currency.should == Money.default_currency
+
+        money = 100.37.to_money
+        money.cents.should == 100_37
+        money.currency.should == Money.default_currency
+
+        money = BigDecimal.new('1234').to_money
+        money.cents.should == 1234_00
+        money.currency.should == Money.default_currency
+      end
+
+      it "should accept optional currency" do
+        1234.to_money('USD').should == Money.new(123400, 'USD')
+        1234.to_money('EUR').should == Money.new(123400, 'EUR')
+      end
+
+      it "should respect :subunit_to_unit currency property" do
+        10.to_money('USD').should == Money.new(10_00, 'USD')
+        10.to_money('TND').should == Money.new(10_000, 'TND')
+        10.to_money('CLP').should == Money.new(10, 'CLP')
+      end
+
+      specify "#issue/15" do
+        amount = 555.55.to_money
+        amount.should == Money.new(55555)
+      end
+    end
+  end
+
+  describe String do
+    describe "#to_money" do
+
+      StringToMoney = {
+        "20.15"           => Money.new(20_15)             ,
+        "100"             => Money.new(100_00)            ,
+        "100.37"          => Money.new(100_37)            ,
+        "100,37"          => Money.new(100_37)            ,
+        "100 000"         => Money.new(100_000_00)        ,
+        "100,000.00"      => Money.new(100_000_00)        ,
+        "1,000"           => Money.new(1_000_00)          ,
+        "-1,000"          => Money.new(-1_000_00)         ,
+        "1,000.5"         => Money.new(1_000_50)          ,
+        "1,000.51"        => Money.new(1_000_51)          ,
+        "1,000.505"       => Money.new(1_000_51)          ,
+        "1,000.504"       => Money.new(1_000_50)          ,
+        "1,000.0000"      => Money.new(1_000_00)          ,
+        "1,000.5000"      => Money.new(1_000_50)          ,
+        "1,000.5099"      => Money.new(1_000_51)          ,
+        "1.550"           => Money.new(1_55)              ,
+        "25."             => Money.new(25_00)             ,
+        ".75"             => Money.new(75)                ,
+
+        "100 USD"         => Money.new(100_00, "USD")     ,
+        "-100 USD"        => Money.new(-100_00, "USD")    ,
+        "100 EUR"         => Money.new(100_00, "EUR")     ,
+        "100.37 EUR"      => Money.new(100_37, "EUR")     ,
+        "100,37 EUR"      => Money.new(100_37, "EUR")     ,
+        "100,000.00 USD"  => Money.new(100_000_00, "USD") ,
+        "100.000,00 EUR"  => Money.new(100_000_00, "EUR") ,
+        "1,000 USD"       => Money.new(1_000_00, "USD")   ,
+        "-1,000 USD"      => Money.new(-1_000_00, "USD")  ,
+        "1,000.5500 USD"  => Money.new(1_000_55, "USD")   ,
+        "-1,000.6500 USD" => Money.new(-1_000_65, "USD")  ,
+        "1.550 USD"       => Money.new(1_55, "USD")       ,
+
+        "USD 100"         => Money.new(100_00, "USD")     ,
+        "EUR 100"         => Money.new(100_00, "EUR")     ,
+        "EUR 100.37"      => Money.new(100_37, "EUR")     ,
+        "CAD -100.37"     => Money.new(-100_37, "CAD")    ,
+        "EUR 100,37"      => Money.new(100_37, "EUR")     ,
+        "EUR -100,37"     => Money.new(-100_37, "EUR")    ,
+        "USD 100,000.00"  => Money.new(100_000_00, "USD") ,
+        "EUR 100.000,00"  => Money.new(100_000_00, "EUR") ,
+        "USD 1,000"       => Money.new(1_000_00, "USD")   ,
+        "USD -1,000"      => Money.new(-1_000_00, "USD")  ,
+        "USD 1,000.9000"  => Money.new(1_000_90, "USD")   ,
+        "USD -1,000.090"  => Money.new(-1_000_09, "USD")  ,
+        "USD 1.5500"      => Money.new(1_55, "USD")       ,
+
+        "$100 USD"        => Money.new(100_00, "USD")     ,
+        "$1,194.59 USD"   => Money.new(1_194_59, "USD")   ,
+        "$-1,955 USD"     => Money.new(-1_955_00, "USD")  ,
+        "$1,194.5900 USD" => Money.new(1_194_59, "USD")   ,
+        "$-1,955.000 USD" => Money.new(-1_955_00, "USD")  ,
+        "$1.99000 USD"    => Money.new(1_99, "USD")       ,
+      }
+
+      specify "it should work" do
+        StringToMoney.each do |string, money|
+          string.to_money.should == money
+        end
+      end
+
+      it "should coerce input to string" do
+        Money.parse(20, "USD").should == Money.new(20_00, "USD")
+      end
+
+      it "should accept optional currency" do
+        "10.10".to_money('USD').should == Money.new(1010, 'USD')
+        "10.10".to_money('EUR').should == Money.new(1010, 'EUR')
+        "10.10 USD".to_money('USD').should == Money.new(1010, 'USD')
+      end
+
+      it "should raise error if optional currency doesn't match string currency" do
+        lambda{ "10.10 USD".to_money('EUR') }.should raise_error(/Mismatching Currencies/)
+      end
+
+      it "should ignore unrecognized data" do
+        "hello 2000 world".to_money.should == Money.new(2000_00)
+      end
+
+      it "should respect :subunit_to_unit currency property" do
+        "1".to_money("USD").should == Money.new(1_00,  "USD")
+        "1".to_money("TND").should == Money.new(1_000, "TND")
+        "1".to_money("CLP").should == Money.new(1,     "CLP")
+        "1.5".to_money("KWD").cents.should == 1500
+      end
+    end
+
+    describe "#to_currency" do
+      it "should convert string to Currency" do
+        "USD".to_currency.should == Money::Currency.new(:usd)
+        "EUR".to_currency.should == Money::Currency.new(:eur)
+      end
+
+      it "should raise Money::Currency::UnknownCurrency with unknown Currency" do
+        lambda { "XXX".to_currency }.should raise_error(Money::Currency::UnknownCurrency)
+        lambda { " ".to_currency }.should raise_error(Money::Currency::UnknownCurrency)
+      end
+    end
+  end
+
+end

data/spec/currency_spec.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Money::Currency do
+
+  specify "#initialize should lookup data from TABLE" do
+    with_custom_definitions do
+      Money::Currency::TABLE[:usd] = {:priority => 1, :iso_code => "USD", :name => "United States Dollar", :symbol => "$", :subunit => "Cent", :subunit_to_unit => 100, :decimal_mark => ".", :thousands_separator => ","}
+      Money::Currency::TABLE[:eur] = {:priority => 2, :iso_code => "EUR", :name => "Euro", :symbol => "€", :subunit => "Cent", :subunit_to_unit => 100, :decimal_mark => ".", :thousands_separator => ","}
+
+      currency = Money::Currency.new("USD")
+      currency.id.should        == :usd
+      currency.priority.should  == 1
+      currency.iso_code.should  == "USD"
+      currency.name.should      == "United States Dollar"
+      currency.decimal_mark.should == "."
+      currency.separator.should == "."
+      currency.thousands_separator.should == ","
+      currency.delimiter.should == ","
+    end
+  end
+
+  specify "#initialize should raise UnknownMoney::Currency with unknown currency" do
+    lambda { Money::Currency.new("xxx") }.should raise_error(Money::Currency::UnknownCurrency, /xxx/)
+  end
+
+  specify "#== should return true if self === other" do
+    currency = Money::Currency.new(:eur)
+    currency.should == currency
+  end
+
+  specify "#== should return true if the id is equal" do
+    Money::Currency.new(:eur).should     == Money::Currency.new(:eur)
+    Money::Currency.new(:eur).should_not == Money::Currency.new(:usd)
+  end
+
+  specify "#eql? should return true if #== returns true" do
+    Money::Currency.new(:eur).eql?(Money::Currency.new(:eur)).should be true
+    Money::Currency.new(:eur).eql?(Money::Currency.new(:usd)).should be false
+  end
+
+  specify "#hash should return the same value for equal objects" do
+    Money::Currency.new(:eur).hash.should == Money::Currency.new(:eur).hash
+    Money::Currency.new(:eur).hash.should_not == Money::Currency.new(:usd).hash
+  end
+
+  specify "#hash can be used to return the intersection of Currency object arrays" do
+    intersection = [Money::Currency.new(:eur), Money::Currency.new(:usd)] & [Money::Currency.new(:eur)]
+    intersection.should == [Money::Currency.new(:eur)]
+  end
+
+  specify "#<=> should compare objects by priority" do
+    Money::Currency.new(:cad).should > Money::Currency.new(:usd)
+    Money::Currency.new(:usd).should < Money::Currency.new(:eur)
+  end
+
+  specify "#to_s" do
+    Money::Currency.new(:usd).to_s.should == "USD"
+    Money::Currency.new(:eur).to_s.should == "EUR"
+  end
+
+  specify "#inspect" do
+    Money::Currency.new(:usd).inspect.should ==
+    %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, iso_code: USD, subunit: Cent>}
+  end
+
+
+  specify "#self.find should return currency matching given id" do
+    with_custom_definitions do
+      Money::Currency::TABLE[:usd] = { :priority =>   1, :iso_code => "USD", :name => "United States Dollar",                      :symbol => "$",             :subunit => "Cent",          :subunit_to_unit => 100, :decimal_mark => ".", :thousands_separator => ","   }
+      Money::Currency::TABLE[:eur] = { :priority =>   2, :iso_code => "EUR", :name => "Euro",                                      :symbol => "€",             :subunit => "Cent",          :subunit_to_unit => 100, :decimal_mark => ".", :thousands_separator => ","   }
+
+      expected = Money::Currency.new(:eur)
+      Money::Currency.find(:eur).should  == expected
+      Money::Currency.find(:EUR).should  == expected
+      Money::Currency.find("eur").should == expected
+      Money::Currency.find("EUR").should == expected
+    end
+  end
+
+  specify "#self.find should return nil unless currency matching given id" do
+    with_custom_definitions do
+      Money::Currency::TABLE[:usd] = { :position =>   1, :iso_code => "USD", :name => "United States Dollar",                      :symbol => "$",             :subunit => "Cent",          :subunit_to_unit => 100, :decimal_mark => ".", :thousands_separator => ","   }
+      Money::Currency::TABLE[:eur] = { :position =>   2, :iso_code => "EUR", :name => "Euro",                                      :symbol => "€",             :subunit => "Cent",          :subunit_to_unit => 100, :decimal_mark => ".", :thousands_separator => ","   }
+
+      expected = Money::Currency.new(:eur)
+      Money::Currency.find(:eur).should  == expected
+      Money::Currency.find(:EUR).should  == expected
+      Money::Currency.find("eur").should == expected
+      Money::Currency.find("EUR").should == expected
+    end
+  end
+
+  specify "#self.wrap should return nil if object is nil" do
+    Money::Currency.wrap(nil).should == nil
+    Money::Currency.wrap(Money::Currency.new(:usd)).should == Money::Currency.new(:usd)
+    Money::Currency.wrap(:usd).should == Money::Currency.new(:usd)
+  end
+
+
+  def with_custom_definitions(&block)
+    begin
+      old = Money::Currency::TABLE.dup
+      Money::Currency::TABLE.clear
+      yield
+    ensure
+      silence_warnings do
+        Money::Currency.const_set("TABLE", old)
+      end
+    end
+  end
+
+  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call # warning voiced
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+end

data/spec/money_spec.rb

@@ -0,0 +1,1268 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Money do
+
+  describe "#new" do
+    it "rounds the given cents to an integer" do
+      Money.new(1.00, "USD").cents.should == 1
+      Money.new(1.01, "USD").cents.should == 1
+      Money.new(1.50, "USD").cents.should == 2
+    end
+
+    it "is associated to the singleton instance of Bank::VariableExchange by default" do
+      Money.new(0).bank.should be_equal(Money::Bank::VariableExchange.instance)
+    end
+
+  end
+
+  describe "#cents" do
+    it "returns the amount of cents passed to the constructor" do
+      Money.new(200_00, "USD").cents.should == 200_00
+    end
+
+    it "stores cents as an integer regardless of what is passed into the constructor" do
+      [ Money.new(100), 1.to_money, 1.00.to_money, BigDecimal('1.00').to_money ].each do |m|
+        m.cents.should == 100
+        m.cents.should be_an_instance_of(Fixnum)
+      end
+    end
+  end
+
+  describe "#dollars" do
+    it "gets cents as dollars" do
+      Money.new_with_dollars(1).should == Money.new(100)
+      Money.new_with_dollars(1, "USD").should == Money.new(100, "USD")
+      Money.new_with_dollars(1, "EUR").should == Money.new(100, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.new(1_00,  "USD").dollars.should == 1
+      Money.new(1_000, "TND").dollars.should == 1
+      Money.new(1,     "CLP").dollars.should == 1
+    end
+
+    it "should not loose precision" do
+      Money.new(100_37).dollars.should == 100.37
+      Money.new_with_dollars(100.37).dollars.should == 100.37
+    end
+  end
+
+  specify "#currency returns the currency passed to the constructor" do
+    Money.new(200_00, "USD").currency.should == Money::Currency.new("USD")
+  end
+
+  specify "#currency_string returns the iso_code of the currency object" do
+    Money.new(200_00, "USD").currency_as_string.should == Money::Currency.new("USD").to_s
+    Money.new(200_00, "USD").currency_as_string.should == "USD"
+    Money.new(200_00, "EUR").currency_as_string.should == "EUR"
+    Money.new(200_00, "YEN").currency_as_string.should == "YEN"
+  end
+
+  specify "#currency_string= set the currency object using the provided string" do
+    obj = Money.new(200_00, "USD")
+    obj.currency_as_string = "EUR"
+    obj.currency.should == Money::Currency.new("EUR")
+    obj.currency_as_string = "YEN"
+    obj.currency.should == Money::Currency.new("YEN")
+    obj.currency_as_string = "USD"
+    obj.currency.should == Money::Currency.new("USD")
+  end
+
+  specify "#zero? returns whether the amount is 0" do
+    Money.new(0, "USD").should be_zero
+    Money.new(0, "EUR").should be_zero
+    Money.new(1, "USD").should_not be_zero
+    Money.new(10, "YEN").should_not be_zero
+    Money.new(-1, "EUR").should_not be_zero
+  end
+
+  specify "#nonzero? returns whether the amount is not 0" do
+    Money.new(0, "USD").should_not be_nonzero
+    Money.new(0, "EUR").should_not be_nonzero
+    Money.new(1, "USD").should be_nonzero
+    Money.new(10, "YEN").should be_nonzero
+    Money.new(-1, "EUR").should be_nonzero
+  end
+
+  specify "#nonzero? has the same return-value semantics as Numeric#nonzero?" do
+    Money.new(0, "USD").nonzero?.should be_nil
+
+    money = Money.new(1, "USD")
+    money.nonzero?.should be_equal(money)
+  end
+
+  specify "#exchange_to exchanges the amount via its exchange bank" do
+    money = Money.new(100_00, "USD")
+    money.bank.should_receive(:exchange_with).with(Money.new(100_00, Money::Currency.new("USD")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
+    money.exchange_to("EUR")
+  end
+
+  specify "#exchange_to exchanges the amount properly" do
+    money = Money.new(100_00, "USD")
+    money.bank.should_receive(:exchange_with).with(Money.new(100_00, Money::Currency.new("USD")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
+    money.exchange_to("EUR").should == Money.new(200_00, "EUR")
+  end
+
+  specify "#== returns true if and only if their amount and currency are equal" do
+    Money.new(1_00, "USD").should == Money.new(1_00, "USD")
+    Money.new(1_00, "USD").should_not == Money.new(1_00, "EUR")
+    Money.new(1_00, "USD").should_not == Money.new(2_00, "USD")
+    Money.new(1_00, "USD").should_not == Money.new(99_00, "EUR")
+  end
+
+  specify "#== can be used to compare with a String money value" do
+    Money.new(1_00, "USD").should == "1.00"
+    Money.new(1_00, "USD").should_not == "2.00"
+    Money.new(1_00, "GBP").should_not == "1.00"
+  end
+
+  specify "#== can be used to compare with a Numeric money value" do
+    Money.new(1_00, "USD").should == 1
+    Money.new(1_57, "USD").should == 1.57
+    Money.new(1_00, "USD").should_not == 2
+    Money.new(1_00, "GBP").should_not == 1
+  end
+
+  specify "#== 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
+
+    Money.new(1_00, "USD").should == klass.new(Money.new(1_00, "USD"))
+    Money.new(2_50, "USD").should == klass.new(Money.new(2_50, "USD"))
+    Money.new(2_50, "USD").should_not == klass.new(Money.new(3_00, "USD"))
+    Money.new(1_00, "GBP").should_not == klass.new(Money.new(1_00, "USD"))
+  end
+
+  specify "#== returns false if used to compare with an object that doesn't respond to #to_money" do
+    Money.new(1_00, "USD").should_not == Object.new
+    Money.new(1_00, "USD").should_not == Class
+    Money.new(1_00, "USD").should_not == Kernel
+    Money.new(1_00, "USD").should_not == /foo/
+    Money.new(1_00, "USD").should_not == nil
+  end
+
+  specify "#eql? returns true if and only if their amount and currency are equal" do
+    Money.new(1_00, "USD").eql?(Money.new(1_00, "USD")).should be true
+    Money.new(1_00, "USD").eql?(Money.new(1_00, "EUR")).should be false
+    Money.new(1_00, "USD").eql?(Money.new(2_00, "USD")).should be false
+    Money.new(1_00, "USD").eql?(Money.new(99_00, "EUR")).should be false
+  end
+
+  specify "#eql? can be used to compare with a String money value" do
+    Money.new(1_00, "USD").eql?("1.00").should be true
+    Money.new(1_00, "USD").eql?("2.00").should be false
+    Money.new(1_00, "GBP").eql?("1.00").should be false
+  end
+
+  specify "#eql? can be used to compare with a Numeric money value" do
+    Money.new(1_00, "USD").eql?(1).should be true
+    Money.new(1_57, "USD").eql?(1.57).should be true
+    Money.new(1_00, "USD").eql?(2).should be false
+    Money.new(1_00, "GBP").eql?(1).should be false
+  end
+
+  specify "#eql? 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
+
+    Money.new(1_00, "USD").eql?(klass.new(Money.new(1_00, "USD"))).should be true
+    Money.new(2_50, "USD").eql?(klass.new(Money.new(2_50, "USD"))).should be true
+    Money.new(2_50, "USD").eql?(klass.new(Money.new(3_00, "USD"))).should be false
+    Money.new(1_00, "GBP").eql?(klass.new(Money.new(1_00, "USD"))).should be false
+  end
+
+  specify "#eql? returns false if used to compare with an object that doesn't respond to #to_money" do
+    Money.new(1_00, "USD").eql?(Object.new).should be false
+    Money.new(1_00, "USD").eql?(Class).should be false
+    Money.new(1_00, "USD").eql?(Kernel).should be false
+    Money.new(1_00, "USD").eql?(/foo/).should be false
+    Money.new(1_00, "USD").eql?(nil).should be false
+  end
+
+  specify "#hash should return the same value for equal objects" do
+    Money.new(1_00, :eur).hash.should == Money.new(1_00, :eur).hash
+    Money.new(2_00, :usd).hash.should == Money.new(2_00, :usd).hash
+    Money.new(1_00, :eur).hash.should_not == Money.new(2_00, :eur).hash
+    Money.new(1_00, :eur).hash.should_not == Money.new(1_00, :usd).hash
+    Money.new(1_00, :eur).hash.should_not == Money.new(2_00, :usd).hash
+  end
+
+  specify "#hash can be used to return the intersection of Money object arrays" do
+    intersection = [Money.new(1_00, :eur), Money.new(1_00, :usd)] & [Money.new(1_00, :eur)]
+    intersection.should == [Money.new(1_00, :eur)]
+  end
+
+  specify "#<=> can be used to compare with a String money value" do
+    (Money.new(1_00) <=> "1.00").should == 0
+    (Money.new(1_00) <=> ".99").should > 0
+    (Money.new(1_00) <=> "2.00").should < 0
+  end
+
+  specify "#<=> can be used to compare with a Numeric money value" do
+    (Money.new(1_00) <=> 1).should == 0
+    (Money.new(1_00) <=> 0.99).should > 0
+    (Money.new(1_00) <=> 2.00).should < 0
+  end
+
+  specify "#<=> 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
+
+    (Money.new(1_00) <=> klass.new(Money.new(1_00))).should == 0
+    (Money.new(1_00) <=> klass.new(Money.new(99))).should > 0
+    (Money.new(1_00) <=> klass.new(Money.new(2_00))).should < 0
+  end
+
+  specify "#<=> raises ArgumentError when used to compare with an object that doesn't respond to #to_money" do
+    expected_message = /Comparison .+ failed/
+    lambda{ Money.new(1_00) <=> Object.new  }.should raise_error(ArgumentError, expected_message)
+    lambda{ Money.new(1_00) <=> Class       }.should raise_error(ArgumentError, expected_message)
+    lambda{ Money.new(1_00) <=> Kernel      }.should raise_error(ArgumentError, expected_message)
+    lambda{ Money.new(1_00) <=> /foo/       }.should raise_error(ArgumentError, expected_message)
+  end
+
+  describe "#*" do
+    it "should multiply current money amount by the multiplier while retaining the currency" do
+      (Money.new(1_00, "USD") * 10).should == Money.new(10_00, "USD")
+    end
+
+    it "should multiply Money by Fixnum and returns Money" do
+      ts = [
+        {:a => Money.new( 10, :USD), :b =>  4, :c => Money.new( 40, :USD)},
+        {:a => Money.new( 10, :USD), :b => -4, :c => Money.new(-40, :USD)},
+        {:a => Money.new(-10, :USD), :b =>  4, :c => Money.new(-40, :USD)},
+        {:a => Money.new(-10, :USD), :b => -4, :c => Money.new( 40, :USD)},
+      ]
+      ts.each do |t|
+        (t[:a] * t[:b]).should == t[:c]
+      end
+    end
+
+    it "should not multiply Money by Money (same currency)" do
+      lambda { Money.new( 10, :USD) * Money.new( 4, :USD) }.should raise_error(ArgumentError)
+    end
+
+    it "should not multiply Money by Money (different currency)" do
+      lambda { Money.new( 10, :USD) * Money.new( 4, :EUR) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#/" do
+    it "divides current money amount by the divisor while retaining the currency" do
+      (Money.new(10_00, "USD") / 10).should == Money.new(1_00, "USD")
+    end
+
+    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)},
+      ]
+      ts.each do |t|
+        (t[:a] / t[:b]).should == t[:c]
+      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},
+        {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => -3.25},
+        {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => -3.25},
+        {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c =>  3.25},
+      ]
+      ts.each do |t|
+        (t[:a] / t[:b]).should == t[:c]
+      end
+    end
+
+    it "divides Money by Money (different currency) and returns Float" do
+      ts = [
+        {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c =>  1.625},
+        {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => -1.625},
+        {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => -1.625},
+        {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c =>  1.625},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        (t[:a] / t[:b]).should == t[:c]
+      end
+    end
+  end
+
+  specify "#div -> money / fixnum" 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)},
+    ]
+    ts.each do |t|
+      t[:a].div(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#div -> money / money (same currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c =>  3.25},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => -3.25},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => -3.25},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c =>  3.25},
+    ]
+    ts.each do |t|
+      t[:a].div(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#div -> money / money (different currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c =>  1.625},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => -1.625},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => -1.625},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c =>  1.625},
+    ]
+    ts.each do |t|
+      t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+      t[:a].div(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#divmod -> money `divmod` 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(-1, :USD)]},
+    ]
+    ts.each do |t|
+      t[:a].divmod(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#divmod -> money `divmod` money (same currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => [ 3, Money.new( 1, :USD)]},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => [-4, Money.new(-3, :USD)]},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => [-4, Money.new( 3, :USD)]},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => [ 3, Money.new(-1, :USD)]},
+    ]
+    ts.each do |t|
+      t[:a].divmod(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#divmod -> money `divmod` money (different currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => [ 1, Money.new( 5, :USD)]},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => [-2, Money.new(-3, :USD)]},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => [-2, Money.new( 3, :USD)]},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => [ 1, Money.new(-5, :USD)]},
+    ]
+    ts.each do |t|
+      t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+      t[:a].divmod(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#modulo -> money `modulo` fixnum" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :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(-1, :USD)},
+    ]
+    ts.each do |t|
+      t[:a].modulo(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#modulo -> money `modulo` money (same currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+    ]
+    ts.each do |t|
+      t[:a].modulo(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#modulo -> money `modulo` money (different currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+    ]
+    ts.each do |t|
+      t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+      t[:a].modulo(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#% -> money % fixnum" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :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(-1, :USD)},
+    ]
+    ts.each do |t|
+      (t[:a] % t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#% -> money % money (same currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+    ]
+    ts.each do |t|
+      (t[:a] % t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#% -> money % money (different currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 3, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+    ]
+    ts.each do |t|
+      t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+      (t[:a] % t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#remainder -> money `remainder` fixnum" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
+      {:a => Money.new( 13, :USD), :b => -4, :c => Money.new( 1, :USD)},
+      {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-1, :USD)},
+      {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+    ]
+    ts.each do |t|
+      t[:a].remainder(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#remainder -> money `remainder` money (same currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new( 1, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new(-1, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+    ]
+    ts.each do |t|
+      t[:a].remainder(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#remainder -> money `remainder` money (different currency)" do
+    ts = [
+      {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
+      {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new( 5, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new(-5, :USD)},
+      {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+    ]
+    ts.each do |t|
+      t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+      t[:a].remainder(t[:b]).should == t[:c]
+    end
+  end
+
+  specify "#abs correctly returns the absolute value as a new Money object" do
+    n = Money.new(-1, :USD)
+    n.abs.should == Money.new( 1, :USD)
+    n.should     == Money.new(-1, :USD)
+  end
+
+  specify "Money.format brute force :subunit_to_unit = 1" do
+    ("0".."9").each do |amt|
+      amt.to_money("VUV").format(:symbol => false).should == amt
+    end
+    ("-1".."-9").each do |amt|
+      amt.to_money("VUV").format(:symbol => false).should == amt
+    end
+    "1000".to_money("VUV").format(:symbol => false).should == "1,000"
+    "-1000".to_money("VUV").format(:symbol => false).should == "-1,000"
+  end
+
+  specify "Money.format brute force :subunit_to_unit = 5" do
+    ("0.0".."9.4").each do |amt|
+      next if amt[-1].to_i > 4
+      amt.to_money("MGA").format(:symbol => false).should == amt
+    end
+    ("-0.1".."-9.4").each do |amt|
+      next if amt[-1].to_i > 4
+      amt.to_money("MGA").format(:symbol => false).should == amt
+    end
+    "1000.0".to_money("MGA").format(:symbol => false).should == "1,000.0"
+    "-1000.0".to_money("MGA").format(:symbol => false).should == "-1,000.0"
+  end
+
+  specify "Money.format brute force :subunit_to_unit = 10" do
+    ("0.0".."9.9").each do |amt|
+      amt.to_money("VND").format(:symbol => false).should == amt.to_s.gsub(/\./, ",")
+    end
+    ("-0.1".."-9.9").each do |amt|
+      amt.to_money("VND").format(:symbol => false).should == amt.to_s.gsub(/\./, ",")
+    end
+    "1000.0".to_money("VND").format(:symbol => false).should == "1.000,0"
+    "-1000.0".to_money("VND").format(:symbol => false).should == "-1.000,0"
+  end
+
+  specify "Money.format brute force :subunit_to_unit = 100" do
+    ("0.00".."9.99").each do |amt|
+      amt.to_money("USD").format(:symbol => false).should == amt
+    end
+    ("-0.01".."-9.99").each do |amt|
+      amt.to_money("USD").format(:symbol => false).should == amt
+    end
+    "1000.00".to_money("USD").format(:symbol => false).should == "1,000.00"
+    "-1000.00".to_money("USD").format(:symbol => false).should == "-1,000.00"
+  end
+
+  specify "Money.format brute force :subunit_to_unit = 1000" do
+    ("0.000".."9.999").each do |amt|
+      amt.to_money("IQD").format(:symbol => false).should == amt
+    end
+    ("-0.001".."-9.999").each do |amt|
+      amt.to_money("IQD").format(:symbol => false).should == amt
+    end
+    "1000.000".to_money("IQD").format(:symbol => false).should == "1,000.000"
+    "-1000.000".to_money("IQD").format(:symbol => false).should == "-1,000.000"
+  end
+
+  specify "Money.to_s works" do
+    Money.new(10_00).to_s.should == "10.00"
+    Money.new(400_08).to_s.should == "400.08"
+    Money.new(-237_43).to_s.should == "-237.43"
+  end
+
+  specify "Money.to_s should respect :subunit_to_unit currency property" do
+    Money.new(10_00, "BHD").to_s.should == "1.000"
+    Money.new(10_00, "CNY").to_s.should == "10.00"
+  end
+
+  specify "Money.to_s shouldn't have decimal when :subunit_to_unit is 1" do
+    Money.new(10_00, "CLP").to_s.should == "1000"
+  end
+
+  specify "Money.to_s should work with :subunit_to_unit == 5" do
+    Money.new(10_00, "MGA").to_s.should == "200.0"
+  end
+
+  specify "Money.to_s should respect :decimal_mark" do
+    Money.new(10_00, "BRL").to_s.should == "10,00"
+  end
+
+  specify "Money.to_f works" do
+    Money.new(10_00).to_f.should == 10.0
+  end
+
+  specify "Money.to_f should respect :subunit_to_unit currency property" do
+    Money.new(10_00, "BHD").to_f.should == 1.0
+  end
+
+  specify "#symbol works as documented" do
+    currency = Money::Currency.new("EUR")
+    currency.should_receive(:symbol).and_return("€")
+    Money.empty(currency).symbol.should == "€"
+
+    currency = Money::Currency.new("EUR")
+    currency.should_receive(:symbol).and_return(nil)
+    Money.empty(currency).symbol.should == "¤"
+  end
+
+  {
+    :thousands_separator => { :default => ",", :other => "." },
+    :decimal_mark => { :default => ".", :other => "," }
+  }.each do |method, options|
+    describe "##{method}" do
+      context "without I18n" do
+        it "works as documented" do
+          Money.empty("USD").send(method).should == options[:default]
+          Money.empty("EUR").send(method).should == options[:other]
+          Money.empty("BRL").send(method).should == options[:other]
+        end
+      end
+
+      if Object.const_defined?("I18n")
+        context "with I18n" do
+          before :all do
+            reset_i18n
+            store_number_formats(:en, method => options[:default])
+            store_number_formats(:de, method => options[:other])
+          end
+
+          it "looks up #{method} for current locale" do
+            I18n.locale = :en
+            Money.empty("USD").send(method).should == options[:default]
+            I18n.locale = :de
+            Money.empty("USD").send(method).should == options[:other]
+          end
+
+          it "fallbacks to default behaviour for missing translations" do
+            I18n.locale = :de
+            Money.empty("USD").send(method).should == options[:other]
+            I18n.locale = :fr
+            Money.empty("USD").send(method).should == options[:default]
+          end
+
+          after :all do
+            reset_i18n
+          end
+        end
+      else
+        puts "can't test ##{method} with I18n because it isn't loaded"
+      end
+    end
+  end
+
+  describe "#format" do
+    it "returns the monetary value as a string" do
+      Money.ca_dollar(100).format.should == "$1.00"
+      Money.new(40008).format.should == "$400.08"
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.new(10_00, "BHD").format.should == "ب.د1.000"
+    end
+
+    it "doesn't display a decimal when :subunit_to_unit is 1" do
+      Money.new(10_00, "CLP").format.should == "$1.000"
+    end
+
+    it "respects the thousands_separator and decimal_mark defaults" do
+      one_thousand = Proc.new do |currency|
+        Money.new(1000_00, currency).format
+      end
+
+      # Pounds
+      one_thousand["GBP"].should == "£1,000.00"
+
+      # Dollars
+      one_thousand["USD"].should == "$1,000.00"
+      one_thousand["CAD"].should == "$1,000.00"
+      one_thousand["AUD"].should == "$1,000.00"
+      one_thousand["NZD"].should == "$1,000.00"
+      one_thousand["ZWD"].should == "$1,000.00"
+
+      # Yen
+      one_thousand["JPY"].should == "¥1,000.00"
+      one_thousand["CNY"].should == "¥1,000.00"
+
+      # Euro
+      one_thousand["EUR"].should == "1.000,00 €"
+
+      # Rupees
+      one_thousand["INR"].should == "₨1,000.00"
+      one_thousand["NPR"].should == "₨1,000.00"
+      one_thousand["SCR"].should == "1,000.00 ₨"
+      one_thousand["LKR"].should == "1,000.00 ₨"
+
+      # Brazilian Real
+      one_thousand["BRL"].should == "R$ 1.000,00"
+
+      # Other
+      one_thousand["SEK"].should == "kr1,000.00"
+      one_thousand["GHC"].should == "₵1,000.00"
+    end
+
+    describe "if the monetary value is 0" do
+      before :each do
+        @money = Money.us_dollar(0)
+      end
+
+      it "returns 'free' when :display_free is true" do
+        @money.format(:display_free => true).should == 'free'
+      end
+
+      it "returns '$0.00' when :display_free is false or not given" do
+        @money.format.should == '$0.00'
+        @money.format(:display_free => false).should == '$0.00'
+        @money.format(:display_free => nil).should == '$0.00'
+      end
+
+      it "returns the value specified by :display_free if it's a string-like object" do
+        @money.format(:display_free => 'gratis').should == 'gratis'
+      end
+    end
+
+    specify "#format(:with_currency => true) works as documented" do
+      Money.ca_dollar(100).format(:with_currency => true).should == "$1.00 CAD"
+      Money.us_dollar(85).format(:with_currency => true).should == "$0.85 USD"
+    end
+
+    specify "#format(:no_cents => true) works as documented" do
+      Money.ca_dollar(100).format(:no_cents => true).should == "$1"
+      Money.ca_dollar(599).format(:no_cents => true).should == "$5"
+      Money.ca_dollar(570).format(:no_cents => true, :with_currency => true).should == "$5 CAD"
+      Money.ca_dollar(39000).format(:no_cents => true).should == "$390"
+    end
+
+    specify "#format(:no_cents => true) should respect :subunit_to_unit currency property" do
+      Money.new(10_00, "BHD").format(:no_cents => true).should == "ب.د1"
+    end
+
+    specify "#format(:symbol => a symbol string) uses the given value as the money symbol" do
+      Money.new(100, "GBP").format(:symbol => "£").should == "£1.00"
+    end
+
+    specify "#format(:symbol => true) returns symbol based on the given currency code" do
+      one = Proc.new do |currency|
+        Money.new(100, currency).format(:symbol => true)
+      end
+
+      # Pounds
+      one["GBP"].should == "£1.00"
+
+      # Dollars
+      one["USD"].should == "$1.00"
+      one["CAD"].should == "$1.00"
+      one["AUD"].should == "$1.00"
+      one["NZD"].should == "$1.00"
+      one["ZWD"].should == "$1.00"
+
+      # Yen
+      one["JPY"].should == "¥1.00"
+      one["CNY"].should == "¥1.00"
+
+      # Euro
+      one["EUR"].should == "1,00 €"
+
+      # Rupees
+      one["INR"].should == "₨1.00"
+      one["NPR"].should == "₨1.00"
+      one["SCR"].should == "1.00 ₨"
+      one["LKR"].should == "1.00 ₨"
+
+      # Brazilian Real
+      one["BRL"].should == "R$ 1,00"
+
+      # Other
+      one["SEK"].should == "kr1.00"
+      one["GHC"].should == "₵1.00"
+    end
+
+    specify "#format(:symbol => true) returns $ when currency code is not recognized" do
+      currency = Money::Currency.new("EUR")
+      currency.should_receive(:symbol).and_return(nil)
+      Money.new(100, currency).format(:symbol => true).should == "1,00 ¤"
+    end
+
+    specify "#format(:symbol => some non-Boolean value that evaluates to true) returns symbol based on the given currency code" do
+      Money.new(100, "GBP").format(:symbol => true).should == "£1.00"
+      Money.new(100, "EUR").format(:symbol => true).should == "1,00 €"
+      Money.new(100, "SEK").format(:symbol => true).should == "kr1.00"
+    end
+
+    specify "#format with :symbol == "", nil or false returns the amount without a symbol" do
+      money = Money.new(100, "GBP")
+      money.format(:symbol => "").should == "1.00"
+      money.format(:symbol => nil).should == "1.00"
+      money.format(:symbol => false).should == "1.00"
+    end
+
+    specify "#format without :symbol assumes that :symbol is set to true" do
+      money = Money.new(100)
+      money.format.should == "$1.00"
+
+      money = Money.new(100, "GBP")
+      money.format.should == "£1.00"
+
+      money = Money.new(100, "EUR")
+      money.format.should == "1,00 €"
+    end
+
+    specify "#format(:decimal_mark => a decimal_mark string) works as documented" do
+      Money.us_dollar(100).format(:decimal_mark => ",").should == "$1,00"
+    end
+
+    specify "#format will default decimal_mark to '.' if currency isn't recognized" do
+      Money.new(100, "ZWD").format.should == "$1.00"
+    end
+
+    specify "#format(:separator => a separator  string) works as documented" do
+      Money.us_dollar(100).format(:separator  => ",").should == "$1,00"
+    end
+
+    specify "#format(:thousands_separator => a thousands_separator string) works as documented" do
+      Money.us_dollar(100000).format(:thousands_separator => ".").should == "$1.000.00"
+      Money.us_dollar(200000).format(:thousands_separator => "").should  == "$2000.00"
+    end
+
+    specify "#format(:thousands_separator => false or nil) works as documented" do
+      Money.us_dollar(100000).format(:thousands_separator => false).should == "$1000.00"
+      Money.us_dollar(200000).format(:thousands_separator => nil).should   == "$2000.00"
+    end
+
+    specify "#format(:delimiter => a delimiter string) works as documented" do
+      Money.us_dollar(100000).format(:delimiter => ".").should == "$1.000.00"
+      Money.us_dollar(200000).format(:delimiter => "").should  == "$2000.00"
+    end
+
+    specify "#format(:delimiter => false or nil) works as documented" do
+      Money.us_dollar(100000).format(:delimiter => false).should == "$1000.00"
+      Money.us_dollar(200000).format(:delimiter => nil).should   == "$2000.00"
+    end
+
+    specify "#format will default thousands_separator to ',' if currency isn't recognized" do
+      Money.new(100000, "ZWD").format.should == "$1,000.00"
+    end
+
+    specify "#format(:html => true) works as documented" do
+      string = Money.ca_dollar(570).format(:html => true, :with_currency => true)
+      string.should == "$5.70 <span class=\"currency\">CAD</span>"
+    end
+
+    it "should insert commas into the result if the amount is sufficiently large" do
+      Money.us_dollar(1_000_000_000_12).format.should == "$1,000,000,000.12"
+      Money.us_dollar(1_000_000_000_12).format(:no_cents => true).should == "$1,000,000,000"
+    end
+
+    it "inserts thousands separator into the result if the amount is sufficiently large and the currency symbol is at the end" do
+      Money.euro(1_234_567_12).format.should == "1.234.567,12 €"
+      Money.euro(1_234_567_12).format(:no_cents => true).should == "1.234.567 €"
+    end
+
+    it "inserts currency symbol before the amount when :symbol_position is set to :before" do
+      Money.euro(1_234_567_12).format(:symbol_position => :before).should == "€1.234.567,12"
+    end
+
+    it "inserts currency symbol after the amount when :symbol_position is set to :after" do
+      Money.us_dollar(1_000_000_000_12).format(:symbol_position => :after).should == "1,000,000,000.12 $"
+    end
+  end
+
+
+  describe "Money.empty" do
+    it "Money.empty creates a new Money object of 0 cents" do
+      Money.empty.should == Money.new(0)
+    end
+  end
+
+  describe "Money.ca_dollar" do
+    it "creates a new Money object of the given value in CAD" do
+      Money.ca_dollar(50).should == Money.new(50, "CAD")
+    end
+  end
+
+  describe "Money.us_dollar" do
+    it "creates a new Money object of the given value in USD" do
+      Money.us_dollar(50).should == Money.new(50, "USD")
+    end
+  end
+
+  describe "Money.euro" do
+    it "creates a new Money object of the given value in EUR" do
+      Money.euro(50).should == Money.new(50, "EUR")
+    end
+  end
+
+
+  describe "Money.new_with_dollars" do
+    it "converts given amount to cents" do
+      Money.new_with_dollars(1).should == Money.new(100)
+      Money.new_with_dollars(1, "USD").should == Money.new(100, "USD")
+      Money.new_with_dollars(1, "EUR").should == Money.new(100, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.new_with_dollars(1, "USD").should == Money.new(1_00,  "USD")
+      Money.new_with_dollars(1, "TND").should == Money.new(1_000, "TND")
+      Money.new_with_dollars(1, "CLP").should == Money.new(1,     "CLP")
+    end
+
+    it "should not loose precision" do
+      Money.new_with_dollars(1234).cents.should == 1234_00
+      Money.new_with_dollars(100.37).cents.should == 100_37
+      Money.new_with_dollars(BigDecimal.new('1234')).cents.should == 1234_00
+    end
+
+    it "accepts a currency options" do
+      m = Money.new_with_dollars(1)
+      m.currency.should == Money.default_currency
+
+      m = Money.new_with_dollars(1, Money::Currency.wrap("EUR"))
+      m.currency.should == Money::Currency.wrap("EUR")
+
+      m = Money.new_with_dollars(1, "EUR")
+      m.currency.should == Money::Currency.wrap("EUR")
+    end
+
+    it "accepts a bank options" do
+      m = Money.new_with_dollars(1)
+      m.bank.should == Money.default_bank
+
+      m = Money.new_with_dollars(1, "EUR", bank = Object.new)
+      m.bank.should == bank
+    end
+
+    it "is associated to the singleton instance of Bank::VariableExchange by default" do
+      Money.new_with_dollars(0).bank.should be_equal(Money::Bank::VariableExchange.instance)
+    end
+  end
+
+  describe "Money.from_string" do
+    it "converts given amount to cents" do
+      Money.from_string("1").should == Money.new(1_00)
+      Money.from_string("1").should == Money.new(1_00, "USD")
+      Money.from_string("1", "EUR").should == Money.new(1_00, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.from_string("1", "USD").should == Money.new(1_00,  "USD")
+      Money.from_string("1", "TND").should == Money.new(1_000, "TND")
+      Money.from_string("1", "CLP").should == Money.new(1,     "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Money.from_string("1")
+      m.currency.should == Money.default_currency
+
+      m = Money.from_string("1", Money::Currency.wrap("EUR"))
+      m.currency.should == Money::Currency.wrap("EUR")
+
+      m = Money.from_string("1", "EUR")
+      m.currency.should == Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe "Money.from_fixnum" do
+    it "converts given amount to cents" do
+      Money.from_fixnum(1).should == Money.new(1_00)
+      Money.from_fixnum(1).should == Money.new(1_00, "USD")
+      Money.from_fixnum(1, "EUR").should == Money.new(1_00, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.from_fixnum(1, "USD").should == Money.new(1_00,  "USD")
+      Money.from_fixnum(1, "TND").should == Money.new(1_000, "TND")
+      Money.from_fixnum(1, "CLP").should == Money.new(1,     "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Money.from_fixnum(1)
+      m.currency.should == Money.default_currency
+
+      m = Money.from_fixnum(1, Money::Currency.wrap("EUR"))
+      m.currency.should == Money::Currency.wrap("EUR")
+
+      m = Money.from_fixnum(1, "EUR")
+      m.currency.should == Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe "Money.from_float" do
+    it "converts given amount to cents" do
+      Money.from_float(1.2).should == Money.new(1_20)
+      Money.from_float(1.2).should == Money.new(1_20, "USD")
+      Money.from_float(1.2, "EUR").should == Money.new(1_20, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.from_float(1.2, "USD").should == Money.new(1_20,  "USD")
+      Money.from_float(1.2, "TND").should == Money.new(1_200, "TND")
+      Money.from_float(1.2, "CLP").should == Money.new(1,     "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Money.from_float(1.2)
+      m.currency.should == Money.default_currency
+
+      m = Money.from_float(1.2, Money::Currency.wrap("EUR"))
+      m.currency.should == Money::Currency.wrap("EUR")
+
+      m = Money.from_float(1.2, "EUR")
+      m.currency.should == Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe "Money.from_bigdecimal" do
+    it "converts given amount to cents" do
+      Money.from_bigdecimal(BigDecimal.new("1")).should == Money.new(1_00)
+      Money.from_bigdecimal(BigDecimal.new("1")).should == Money.new(1_00, "USD")
+      Money.from_bigdecimal(BigDecimal.new("1"), "EUR").should == Money.new(1_00, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.from_bigdecimal(BigDecimal.new("1"), "USD").should == Money.new(1_00,  "USD")
+      Money.from_bigdecimal(BigDecimal.new("1"), "TND").should == Money.new(1_000, "TND")
+      Money.from_bigdecimal(BigDecimal.new("1"), "CLP").should == Money.new(1,     "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Money.from_bigdecimal(BigDecimal.new("1"))
+      m.currency.should == Money.default_currency
+
+      m = Money.from_bigdecimal(BigDecimal.new("1"), Money::Currency.wrap("EUR"))
+      m.currency.should == Money::Currency.wrap("EUR")
+
+      m = Money.from_bigdecimal(BigDecimal.new("1"), "EUR")
+      m.currency.should == Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe "Money.from_numeric" do
+    it "converts given amount to cents" do
+      Money.from_numeric(1).should == Money.new(1_00)
+      Money.from_numeric(1.0).should == Money.new(1_00)
+      Money.from_numeric(BigDecimal.new("1")).should == Money.new(1_00)
+    end
+
+    it "should raise ArgumentError with unsupported argument" do
+      lambda { Money.from_numeric("100") }.should raise_error(ArgumentError)
+    end
+
+    it "should optimize workload" do
+      Money.should_receive(:from_fixnum).with(1, "USD").and_return(Money.new(1_00,  "USD"))
+      Money.from_numeric(1, "USD").should == Money.new(1_00,  "USD")
+      Money.should_receive(:from_bigdecimal).with(BigDecimal.new("1.0"), "USD").and_return(Money.new(1_00,  "USD"))
+      Money.from_numeric(1.0, "USD").should == Money.new(1_00,  "USD")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      Money.from_numeric(1, "USD").should == Money.new(1_00,  "USD")
+      Money.from_numeric(1, "TND").should == Money.new(1_000, "TND")
+      Money.from_numeric(1, "CLP").should == Money.new(1,     "CLP")
+    end
+
+    it "accepts a bank option" do
+      Money.from_numeric(1).should == Money.new(1_00)
+      Money.from_numeric(1).should == Money.new(1_00, "USD")
+      Money.from_numeric(1, "EUR").should == Money.new(1_00, "EUR")
+    end
+
+    it "accepts a currency options" do
+      m = Money.from_numeric(1)
+      m.currency.should == Money.default_currency
+
+      m = Money.from_numeric(1, Money::Currency.wrap("EUR"))
+      m.currency.should == Money::Currency.wrap("EUR")
+
+      m = Money.from_numeric(1, "EUR")
+      m.currency.should == Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe "split" do
+    specify "#split needs at least one party" do
+      lambda {Money.us_dollar(1).split(0)}.should raise_error(ArgumentError)
+      lambda {Money.us_dollar(1).split(-1)}.should raise_error(ArgumentError)
+    end
+
+
+    specify "#gives 1 cent to both people if we start with 2" do
+      Money.us_dollar(2).split(2).should == [Money.us_dollar(1), Money.us_dollar(1)]
+    end
+
+    specify "#split may distribute no money to some parties if there isnt enough to go around" do
+      Money.us_dollar(2).split(3).should == [Money.us_dollar(1), Money.us_dollar(1), Money.us_dollar(0)]
+    end
+
+    specify "#split does not lose pennies" do
+      Money.us_dollar(5).split(2).should == [Money.us_dollar(3), Money.us_dollar(2)]
+    end
+
+    specify "#split a dollar" do
+      moneys = Money.us_dollar(100).split(3)
+      moneys[0].cents.should == 34
+      moneys[1].cents.should == 33
+      moneys[2].cents.should == 33
+    end
+  end
+
+  describe "allocation" do
+    specify "#allocate takes no action when one gets all" do
+      Money.us_dollar(005).allocate([1]).should == [Money.us_dollar(5)]
+    end
+
+    specify "#allocate keeps currencies intact" do
+      Money.ca_dollar(005).allocate([1]).should == [Money.ca_dollar(5)]
+    end
+
+    specify "#allocate does not loose pennies" do
+      moneys = Money.us_dollar(5).allocate([0.3,0.7])
+      moneys[0].should == Money.us_dollar(2)
+      moneys[1].should == Money.us_dollar(3)
+    end
+
+    specify "#allocate does not loose pennies" do
+      moneys = Money.us_dollar(100).allocate([0.333,0.333, 0.333])
+      moneys[0].cents.should == 34
+      moneys[1].cents.should == 33
+      moneys[2].cents.should == 33
+    end
+
+    specify "#allocate requires total to be less then 1" do
+      lambda { Money.us_dollar(0.05).allocate([0.5,0.6]) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "Money.add_rate" do
+    it "saves rate into current bank" do
+      Money.add_rate("EUR", "USD", 10)
+      Money.new(10_00, "EUR").exchange_to("USD").should == Money.new(100_00, "USD")
+    end
+  end
+
+
+  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call # warning voiced
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+end
+
+describe "Actions involving two Money objects" do
+  describe "if the other Money object has the same currency" do
+    specify "#<=> compares the two object amounts" do
+      (Money.new(1_00, "USD") <=> Money.new(1_00, "USD")).should == 0
+      (Money.new(1_00, "USD") <=> Money.new(99, "USD")).should > 0
+      (Money.new(1_00, "USD") <=> Money.new(2_00, "USD")).should < 0
+    end
+
+    specify "#+ adds other amount to current amount and returns a Money while retaining the currency" do
+      (Money.new(10_00, "USD") + Money.new(90, "USD")).should == Money.new(10_90, "USD")
+    end
+
+    specify "#- subtracts other amount from current amount and returns a Money while retaining the currency" do
+      (Money.new(10_00, "USD") - Money.new(90, "USD")).should == Money.new(9_10, "USD")
+    end
+
+    specify "#* should raise ArgumentError" do
+      lambda { Money.new(10_00, "USD") * Money.new(2, "USD") }.should raise_error(ArgumentError)
+    end
+
+    specify "#/ divides current amount by other amount and returns a Float" do
+      (Money.new(10_00, "USD") / Money.new(100_00, "USD")).should == 0.1
+    end
+  end
+
+  describe "if the other Money object has a different currency" do
+    specify "#<=> converts other object amount to current currency, then compares the two object amounts" do
+      target = Money.new(200_00, "EUR")
+      target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(300_00, "USD"))
+      (Money.new(100_00, "USD") <=> target).should < 0
+
+      target = Money.new(200_00, "EUR")
+      target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(100_00, "USD"))
+      (Money.new(100_00, "USD") <=> target).should == 0
+
+      target = Money.new(200_00, "EUR")
+      target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(99_00, "USD"))
+      (Money.new(100_00, "USD") <=> target).should > 0
+    end
+
+    specify "#+ converts other object amount to current currency, then adds other amount to current amount and returns a Money" do
+      other = Money.new(90, "EUR")
+      other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
+      (Money.new(10_00, "USD") + other).should == Money.new(19_00, "USD")
+    end
+
+    specify "#- converts other object amount to current currency, then subtracts other amount from current amount and returns a Money" do
+      other = Money.new(90, "EUR")
+      other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
+      (Money.new(10_00, "USD") - other).should == Money.new(1_00, "USD")
+    end
+
+    specify "#* should raise ArgumentError" do
+      lambda { Money.new(10_00, "USD") * Money.new(10, "EUR") }.should raise_error(ArgumentError)
+    end
+
+    specify "#/ converts other object amount to current currency, then divides current amount by other amount and returns a Float" do
+      other = Money.new(1000, "EUR")
+      other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(100_00, "USD"))
+      (Money.new(10_00, "USD") / other).should == 0.1
+    end
+  end
+end
+
+
+describe "Money.parse" do
+
+    it "should be able to parse european-formatted inputs under 10EUR" do
+      five_ninety_five = Money.new(595, 'EUR')
+
+      Money.parse('EUR 5,95').should    == five_ninety_five
+      #TODO: try and handle these
+      #Money.parse('€5,95').should       == five_ninety_five
+      #Money.parse('&#036;5.95').should  == five_ninety_five
+    end
+
+    it "should be able to parse european-formatted inputs with multiple thousands-seperators" do
+      Money.parse('EUR 1.234.567,89').should     == Money.new(123456789, 'EUR')
+      Money.parse('EUR 1.111.234.567,89').should == Money.new(111123456789, 'EUR')
+    end
+
+    it "should be able to parse USD-formatted inputs under $10" do
+      five_ninety_five = Money.new(595, 'USD')
+
+      Money.parse(5.95).should          == five_ninety_five
+      Money.parse('5.95').should        == five_ninety_five
+      Money.parse('$5.95').should       == five_ninety_five
+      Money.parse("\n $5.95 \n").should == five_ninety_five
+      Money.parse('$ 5.95').should      == five_ninety_five
+      Money.parse('$5.95 ea.').should   == five_ninety_five
+      Money.parse('$5.95, each').should == five_ninety_five
+    end
+
+    it "should be able to parse USD-formatted inputs with multiple thousands-seperators" do
+      Money.parse('1,234,567.89').should     == Money.new(123456789, 'USD')
+      Money.parse('1,111,234,567.89').should == Money.new(111123456789, 'USD')
+    end
+
+    it "should not return a price if there is a price range" do
+      lambda {Money.parse('$5.95-10.95')}.should    raise_error ArgumentError
+      lambda {Money.parse('$5.95 - 10.95')}.should  raise_error ArgumentError
+      lambda {Money.parse('$5.95 - $10.95')}.should raise_error ArgumentError
+    end
+
+    it "should not return a price for completely invalid input" do
+      # TODO: shouldn't these throw an error instead of being considered
+      # equal to $0.0?
+      empty_price = Money.new(0, 'USD')
+
+      Money.parse(nil).should             == empty_price
+      Money.parse('hellothere').should    == empty_price
+      Money.parse('').should              == empty_price
+    end
+end