big_money 1.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+gems/*
+bin/*

data/Gemfile

@@ -0,0 +1,11 @@
+# vim: syntax=ruby
+bundle_path 'gems'
+disable_rubygems
+disable_system_gems
+
+only :development do
+  gem 'jeweler'
+  gem 'shoulda'
+  gem 'hpricot'
+  gem 'erubis'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Marshall Roch
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,102 @@
+= BigMoney
+
+== Description
+
+Represents an amount of money in a particular currency. Backed by BigDecimal, so it's safe from float rounding errors.
+
+== Features
+
+* Encapsulates an amount with its currency into a single object.
+* Backed by BigDecimal, so it can store arbitrary-precision values without rounding errors. Useful if you're dealing
+  with fractional cents.
+* Sensible currency handling.
+* Supports all ISO-4217 currencies.
+* Optional currency exchange.
+* Optional string parsing.
+
+== Problems
+
+* Does not implement all of Numeric, so doesn't quite act like a real number.
+
+== Todo
+
+* Has no Money package API compatibility to ease transition (module patch welcome).
+  (http://dist.leetsoft.com/api/money/)
+
+== Synopsis
+
+=== Basic
+
+  require 'big_money'
+
+  bm = BigMoney.new('3.99', :aud)
+  bm.amount           #=> BigDecimal.new('3.99')
+  bm.currency         #=> BigMoney::Currency::AUD
+  bm.to_s             #=> '3.99'
+  bm.to_s('$.2f')     #=> '$3.99'
+  bm.to_s('$%.2f %s') #=> '$3.99 AUD'
+
+  # Not recommended but if you must.
+  BigMoney::Currency.default = :aud
+
+  bm = BigMoney.new('3.99')
+  bm.amount   #=> BigDecimal.new('3.99')
+  bm.currency #=> BigMoney::Currency::AUD
+
+  bm2 = 1.to_big_money
+  bm2.amount   #=> BigDecimal.new('3.99')
+  bm2.currency #=> BigMoney::Currency::AUD
+
+=== Exchange
+
+  require 'big_money'
+  require 'big_money/exchange/yahoo' # Use yahoo finance exchange service.
+
+  bm = BigMoney.new('3.99', :usd)
+  bm.amount   #=> BigDecimal.new('3.99')
+  bm.currency #=> BigMoney::Currency::USD
+
+  bm2 = bm.exchange(:aud)
+  bm.amount   #=> BigDecimal.new('5.22')
+  bm.currency #=> BigMoney::Currency::AUD
+
+=== Parser
+
+  require 'big_money'
+  require 'big_money/parser'
+
+  BigMoney.parse('JPY ¥2500') #=> BigMoney.new('2500', :jpy)
+  BigMoney.parse('JPY2500')   #=> BigMoney.new('2500', :jpy)
+  BigMoney.parse('2500JPY')   #=> BigMoney.new('2500', :jpy)
+  BigMoney.parse('¥2500JPY')  #=> BigMoney.new('2500', :jpy)
+
+  # ISO-4217 BigMoney::Currency::XXX aka 'No currency' will be used if a currency cannot be parsed along with the
+  # amount. If you know the currency and just need the amount XXX is always exchanged 1:1 with any currency.
+  bm = BigMoney.parse('¥2500') #=> BigMoney.new('2500', :xxx)
+  bm.exchange(:jpy)            #=> BigMoney.new('2500', :jpy)
+
+=== Types
+
+  require 'big_money'
+  require 'big_money/types'
+
+  # Numeric
+  1.to_big_money(:aud)         #=> BigMoney.new(1, :aud)
+  12_123.44.to_big_money(:aud) #=> BigMoney.new('12123.44', :aud)
+
+  # String
+  '1'.to_big_money(:aud)       #=> BigMoney.new(1, :aud)
+
+== Install
+
+* Via git:
+
+    git clone git://github.com/shanna/big_money.git
+
+* Via gem:
+
+    gem install big_money
+
+== License
+
+See LICENSE.

data/Rakefile

@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'big_money'
+    gem.summary     = %q{BigDecimal backed amount of money in a particular currency.}
+    gem.email       = ['shane.hanna@gmail.com', 'mroch@cmu.edu']
+    gem.homepage    = 'http://github.com/shanna/big_money'
+    gem.authors     = ['Shane Hanna', 'Marshall Roch']
+    gem.executables = [] # Only ever bundled development executables in bin/*
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "big_money #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :currency do
+  desc 'Create ISO 4217 currency classes from wikipedia ISO 4217 table.'
+  task :iso4217 do
+    dirname = File.dirname(__FILE__)
+    gen     = File.join(dirname, 'rakelib', %w{iso4217.rb})
+    lib     = File.expand_path(File.join(dirname, %w{lib big_money currency iso4217.rb}))
+    require gen
+    modules = BigMoney::Task::ISO4217.get
+    File.open(lib, File::CREAT | File::TRUNC | File::WRONLY) do |f|
+      f.write modules
+    end
+  end
+end
+
+task :default => :test
+

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 1
+:minor: 1
+:patch: 0
+:build: 

data/big_money.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{big_money}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Shane Hanna", "Marshall Roch"]
+  s.date = %q{2010-01-22}
+  s.email = ["shane.hanna@gmail.com", "mroch@cmu.edu"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Gemfile",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "big_money.gemspec",
+     "lib/big_money.rb",
+     "lib/big_money/currency.rb",
+     "lib/big_money/currency/iso4217.rb",
+     "lib/big_money/exchange.rb",
+     "lib/big_money/exchange/yahoo.rb",
+     "lib/big_money/parser.rb",
+     "lib/big_money/types.rb",
+     "rakelib/iso4217.rb",
+     "rakelib/iso4217.rb.erb",
+     "test/helper.rb",
+     "test/test_big_money.rb",
+     "test/test_currency.rb",
+     "test/test_exchange.rb",
+     "test/test_parser.rb"
+  ]
+  s.homepage = %q{http://github.com/shanna/big_money}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{BigDecimal backed amount of money in a particular currency.}
+  s.test_files = [
+    "test/test_exchange.rb",
+     "test/helper.rb",
+     "test/test_currency.rb",
+     "test/test_big_money.rb",
+     "test/test_parser.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/big_money.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+require 'bigdecimal'
+require 'big_money/currency'
+require 'big_money/currency/iso4217'
+
+# == Synopsis
+#
+#   bm = BigMoney.new('3.99', :aud)
+#   bm.amount           #=> BigDecimal.new('3.99')
+#   bm.currency         #=> BigMoney::Currency::AUD
+#   bm.to_s             #=> '3.99'
+#   bm.to_s('$.2f')     #=> '$3.99'
+#   bm.to_s('$%.2f %s') #=> '$3.99 AUD'
+#
+# === Amount
+#
+# Amounts can be anything Numeric or Strings that are BigDecimal friendly. Keep in mind BigDecimal will silently return
+# 0.0 for unrecognised strings. See BigMoney::Amount.
+#
+#   BigMoney.new(BigDecimal.new('12.50')) # BigDecimal
+#   BigMoney.new(12)                      # Fixnum
+#   BigMoney.new(12.50)                   # Float
+#   BigMoney.new('12.50')                 # String
+#
+# === Currency
+#
+# Any currency defined by the current ISO4217 table on Wikipedia is already available. Naturally you may define your
+# own currencies. See BigMoney::Currency.
+#
+# ==== Default
+#
+# A default currency risks exchanging an amount 1:1 between currencies if the default is unintentionally used.
+# BigMoney expects an explicit currency in the constructor and will raise an ArugmentError unless one is given or a
+# default currency set.
+#
+#   BigMoney::Currency.default = BigMoney::Currency::AUD # Module
+#   BigMoney::Currency.default = 'AUD'                   # String, ISO4217 3 letter currency code.
+#   BigMoney::Currency.default = :aud                    # Symbol, ISO4217 3 letter currency code.
+class BigMoney
+  include Comparable
+  attr_reader :amount, :currency
+
+  # Short form BigMoney::Currency.find(code) to save some typing.
+  #
+  # ==== Examples
+  #
+  #   BigMoney.currency(:usd) #=> BigMoney::Currency.find(:usd)
+  #
+  # ==== Parameters
+  # code<#to_s>:: An upper or lowercase string or symbol of the ISO-4217 currency code.
+  #
+  # ==== Returns
+  # BigMoney::Currency
+  def self.currency(currency)
+    Currency.find(currency)
+  end
+
+  # Create a BigMoney instance.
+  #
+  # ==== Parameters
+  # amount<BigDecimal, Numeric, String>:: Numeric or BigDecimal friendly String.
+  # currency<BigMoney::Currency, Symbol, String>:: Optional ISO-4217 3 letter currency code. Default BigMoney.currency.default
+  #
+  # ==== Returns
+  # BigMoney
+  def initialize(amount, currency = nil)
+    @amount = case amount
+      when BigDecimal then amount
+      when String     then BigDecimal.new(amount)
+      when Numeric    then BigDecimal.new(amount.to_s)
+      else raise TypeError.new("Can't convert +amount+ #{amount.class} into BigDecimal.")
+    end
+
+    raise ArgumentError.new("Nil +currency+ without default.") if currency.nil? && !Currency.default?
+    unless currency && @currency = Currency.find(currency)
+      raise ArgumentError.new("Unknown +currency+ '#{currency.inspect}'.") unless Currency.default?
+      @currency = Currency.default
+    end
+  end
+
+  def <=>(money)
+    money.kind_of?(self.class) ? (currency <=> money.currency).nonzero? || (amount <=> money.amount).nonzero? || 0 : nil
+  end
+
+  def eql?(money)
+    money.kind_of?(self.class) &&
+    amount == money.amount &&
+    currency == money.currency
+  end
+  alias == eql?
+
+  def -@
+    self.class.new(-amount, currency)
+  end
+
+  [:+, :-, :*, :/].each do |op|
+    define_method(op) do |rvalue|
+      raise TypeError.new("Currency mismatch, '#{currency}' with '#{rvalue.currency}'.") \
+        if rvalue.kind_of?(BigMoney) && currency != rvalue.currency
+
+      rvalue = case rvalue
+        when BigMoney   then rvalue.amount
+        when BigDecimal then rvalue.dup
+        when String     then BigDecimal.new(rvalue)
+        when Numeric    then BigDecimal.new(rvalue.to_s)
+        else raise TypeError.new("Can't convert +amount+ #{rvalue.class} into BigDecimal.")
+      end
+      self.class.new(amount.send(op, rvalue), currency)
+    end
+  end
+
+  def to_s(format = nil)
+    format ||= "%.#{currency.offset}f"
+    format.sub(/%s/, currency.code) % amount
+  end
+
+  def to_i
+    amount.to_i
+  end
+
+  def to_f
+    amount.to_f
+  end
+end # BigMoney

data/lib/big_money/currency.rb

@@ -0,0 +1,75 @@
+require 'set'
+
+class BigMoney
+  class Currency
+    include Comparable
+
+    attr_accessor :code, :offset, :name
+    alias to_s code
+
+    def hash
+      code.hash
+    end
+
+    def eql?(rvalue)
+      self.class.equal?(rvalue.class) && code == rvalue.code
+    end
+    alias == eql?
+
+    def <=>(rvalue)
+      self.class == rvalue.class ? (code <=> rvalue.code) || 0 : nil
+    end
+
+    #--
+    # TODO: Validate.
+    def initialize(code, offset, name)
+      @code, @offset, @name = code.to_s.upcase, offset, name
+    end
+
+    class << self
+      def default
+        raise "No default currency has been set. See BigMoney::Currency." unless default?
+        @@default
+      end
+
+      def default=(currency)
+        raise TypeError.new("Expected kind of BigMoney::Currency but got #{currency.class}.") \
+          unless currency.kind_of?(Currency)
+        @@default = currency
+      end
+
+      def default?
+        defined? @@default
+      end
+
+      def all
+        @@all ||= Set.new
+      end
+
+      # Find an existing currency module by Object, Symbol or String.
+      #
+      # ==== Examples
+      #
+      #   AUD = BigMoney::Currency.new(:aud, 2, 'Australian Dollar')
+      #
+      #   BigMoney::Currency.find(:aud)
+      #   BigMoney::Currency.find('aud')
+      #   BigMoney::Currency.find('AUD')
+      #   BigMoney::Currency.find(AUD)
+      def find(currency)
+        if currency.is_a?(self)
+          currency
+        else
+          currency = currency.to_s.upcase
+          all.find{|c| c.code == currency}
+        end
+      end
+
+      def register(*args)
+        self.all << currency = new(*args).freeze
+        currency
+      end
+    end
+  end # Currency
+end # BigMoney
+

data/lib/big_money/currency/iso4217.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+class BigMoney
+  class Currency
+    AED = Currency.register(%q{AED}, 2, %q{United Arab Emirates dirham})
+    AFN = Currency.register(%q{AFN}, 2, %q{Afghani})
+    ALL = Currency.register(%q{ALL}, 2, %q{Lek})
+    AMD = Currency.register(%q{AMD}, 0, %q{Armenian dram})
+    ANG = Currency.register(%q{ANG}, 2, %q{Netherlands Antillean guilder})
+    AOA = Currency.register(%q{AOA}, 1, %q{Kwanza})
+    ARS = Currency.register(%q{ARS}, 2, %q{Argentine peso})
+    AUD = Currency.register(%q{AUD}, 2, %q{Australian dollar})
+    AWG = Currency.register(%q{AWG}, 2, %q{Aruban guilder})
+    AZN = Currency.register(%q{AZN}, 2, %q{Azerbaijanian manat})
+    BAM = Currency.register(%q{BAM}, 2, %q{Convertible marks})
+    BBD = Currency.register(%q{BBD}, 2, %q{Barbados dollar})
+    BDT = Currency.register(%q{BDT}, 2, %q{Bangladeshi taka})
+    BGN = Currency.register(%q{BGN}, 2, %q{Bulgarian lev})
+    BHD = Currency.register(%q{BHD}, 3, %q{Bahraini dinar})
+    BIF = Currency.register(%q{BIF}, 0, %q{Burundian franc})
+    BMD = Currency.register(%q{BMD}, 2, %q{Bermudian dollar})
+    BND = Currency.register(%q{BND}, 2, %q{Brunei dollar})
+    BOB = Currency.register(%q{BOB}, 2, %q{Boliviano})
+    BOV = Currency.register(%q{BOV}, 2, %q{Bolivian Mvdol (funds code)})
+    BRL = Currency.register(%q{BRL}, 2, %q{Brazilian real})
+    BSD = Currency.register(%q{BSD}, 2, %q{Bahamian dollar})
+    BTN = Currency.register(%q{BTN}, 2, %q{Ngultrum})
+    BWP = Currency.register(%q{BWP}, 2, %q{Pula})
+    BYR = Currency.register(%q{BYR}, 0, %q{Belarusian ruble})
+    BZD = Currency.register(%q{BZD}, 2, %q{Belize dollar})
+    CAD = Currency.register(%q{CAD}, 2, %q{Canadian dollar})
+    CDF = Currency.register(%q{CDF}, 2, %q{Franc Congolais})
+    CHE = Currency.register(%q{CHE}, 2, %q{WIR eurocomplementary currency})
+    CHF = Currency.register(%q{CHF}, 2, %q{Swiss franc})
+    CHW = Currency.register(%q{CHW}, 2, %q{WIR franccomplementary currency})
+    CLF = Currency.register(%q{CLF}, 0, %q{Unidad de Fomento})
+    CLP = Currency.register(%q{CLP}, 0, %q{Chilean peso})
+    CNY = Currency.register(%q{CNY}, 1, %q{Chinese Yuan})
+    COP = Currency.register(%q{COP}, 0, %q{Colombian peso})
+    COU = Currency.register(%q{COU}, 2, %q{Unidad de Valor Real})
+    CRC = Currency.register(%q{CRC}, 2, %q{Costa Rican colon})
+    CUC = Currency.register(%q{CUC}, 2, %q{Cuban convertible peso})
+    CUP = Currency.register(%q{CUP}, 2, %q{Cuban peso})
+    CVE = Currency.register(%q{CVE}, 2, %q{Cape Verde escudo})
+    CZK = Currency.register(%q{CZK}, 2, %q{Czech Koruna})
+    DJF = Currency.register(%q{DJF}, 0, %q{Djibouti franc})
+    DKK = Currency.register(%q{DKK}, 2, %q{Danish krone})
+    DOP = Currency.register(%q{DOP}, 2, %q{Dominican peso})
+    DZD = Currency.register(%q{DZD}, 2, %q{Algerian dinar})
+    EEK = Currency.register(%q{EEK}, 2, %q{Kroon})
+    EGP = Currency.register(%q{EGP}, 2, %q{Egyptian pound})
+    ERN = Currency.register(%q{ERN}, 2, %q{Nakfa})
+    ETB = Currency.register(%q{ETB}, 2, %q{Ethiopian birr})
+    EUR = Currency.register(%q{EUR}, 2, %q{euro})
+    FJD = Currency.register(%q{FJD}, 2, %q{Fiji dollar})
+    FKP = Currency.register(%q{FKP}, 2, %q{Falkland Islands pound})
+    GBP = Currency.register(%q{GBP}, 2, %q{Pound sterling})
+    GEL = Currency.register(%q{GEL}, 2, %q{Lari})
+    GHS = Currency.register(%q{GHS}, 2, %q{Cedi})
+    GIP = Currency.register(%q{GIP}, 2, %q{Gibraltar pound})
+    GMD = Currency.register(%q{GMD}, 2, %q{Dalasi})
+    GNF = Currency.register(%q{GNF}, 0, %q{Guinea franc})
+    GTQ = Currency.register(%q{GTQ}, 2, %q{Quetzal})
+    GYD = Currency.register(%q{GYD}, 2, %q{Guyana dollar})
+    HKD = Currency.register(%q{HKD}, 2, %q{Hong Kong dollar})
+    HNL = Currency.register(%q{HNL}, 2, %q{Lempira})
+    HRK = Currency.register(%q{HRK}, 2, %q{Croatian kuna})
+    HTG = Currency.register(%q{HTG}, 2, %q{Haiti gourde})
+    HUF = Currency.register(%q{HUF}, 2, %q{Forint})
+    IDR = Currency.register(%q{IDR}, 0, %q{Rupiah})
+    ILS = Currency.register(%q{ILS}, 2, %q{Israeli new sheqel})
+    INR = Currency.register(%q{INR}, 2, %q{Indian rupee})
+    IQD = Currency.register(%q{IQD}, 0, %q{Iraqi dinar})
+    IRR = Currency.register(%q{IRR}, 0, %q{Iranian rial})
+    ISK = Currency.register(%q{ISK}, 0, %q{Iceland krona})
+    JMD = Currency.register(%q{JMD}, 2, %q{Jamaican dollar})
+    JOD = Currency.register(%q{JOD}, 3, %q{Jordanian dinar})
+    JPY = Currency.register(%q{JPY}, 0, %q{Japanese yen})
+    KES = Currency.register(%q{KES}, 2, %q{Kenyan shilling})
+    KGS = Currency.register(%q{KGS}, 2, %q{Som})
+    KHR = Currency.register(%q{KHR}, 0, %q{Riel})
+    KMF = Currency.register(%q{KMF}, 0, %q{Comoro franc})
+    KPW = Currency.register(%q{KPW}, 0, %q{North Korean won})
+    KRW = Currency.register(%q{KRW}, 0, %q{South Korean won})
+    KWD = Currency.register(%q{KWD}, 3, %q{Kuwaiti dinar})
+    KYD = Currency.register(%q{KYD}, 2, %q{Cayman Islands dollar})
+    KZT = Currency.register(%q{KZT}, 2, %q{Tenge})
+    LAK = Currency.register(%q{LAK}, 0, %q{Kip})
+    LBP = Currency.register(%q{LBP}, 0, %q{Lebanese pound})
+    LKR = Currency.register(%q{LKR}, 2, %q{Sri Lanka rupee})
+    LRD = Currency.register(%q{LRD}, 2, %q{Liberian dollar})
+    LSL = Currency.register(%q{LSL}, 2, %q{Lesotho loti})
+    LTL = Currency.register(%q{LTL}, 2, %q{Lithuanian litas})
+    LVL = Currency.register(%q{LVL}, 2, %q{Latvian lats})
+    LYD = Currency.register(%q{LYD}, 3, %q{Libyan dinar})
+    MAD = Currency.register(%q{MAD}, 2, %q{Moroccan dirham})
+    MDL = Currency.register(%q{MDL}, 2, %q{Moldovan leu})
+    MGA = Currency.register(%q{MGA}, 0, %q{Malagasy ariary})
+    MKD = Currency.register(%q{MKD}, 2, %q{Denar})
+    MMK = Currency.register(%q{MMK}, 0, %q{Kyat})
+    MNT = Currency.register(%q{MNT}, 2, %q{Tugrik})
+    MOP = Currency.register(%q{MOP}, 1, %q{Pataca})
+    MRO = Currency.register(%q{MRO}, 0, %q{Ouguiya})
+    MUR = Currency.register(%q{MUR}, 2, %q{Mauritius rupee})
+    MVR = Currency.register(%q{MVR}, 2, %q{Rufiyaa})
+    MWK = Currency.register(%q{MWK}, 2, %q{Kwacha})
+    MXN = Currency.register(%q{MXN}, 2, %q{Mexican peso})
+    MXV = Currency.register(%q{MXV}, 2, %q{Mexican Unidad de Inversion})
+    MYR = Currency.register(%q{MYR}, 2, %q{Malaysian ringgit})
+    MZN = Currency.register(%q{MZN}, 2, %q{Metical})
+    NAD = Currency.register(%q{NAD}, 2, %q{Namibian dollar})
+    NGN = Currency.register(%q{NGN}, 2, %q{Naira})
+    NIO = Currency.register(%q{NIO}, 2, %q{Cordoba oro})
+    NOK = Currency.register(%q{NOK}, 2, %q{Norwegian krone})
+    NPR = Currency.register(%q{NPR}, 2, %q{Nepalese rupee})
+    NZD = Currency.register(%q{NZD}, 2, %q{New Zealand dollar})
+    OMR = Currency.register(%q{OMR}, 3, %q{Rial Omani})
+    PAB = Currency.register(%q{PAB}, 2, %q{Balboa})
+    PEN = Currency.register(%q{PEN}, 2, %q{Nuevo sol})
+    PGK = Currency.register(%q{PGK}, 2, %q{Kina})
+    PHP = Currency.register(%q{PHP}, 2, %q{Philippine peso})
+    PKR = Currency.register(%q{PKR}, 2, %q{Pakistan rupee})
+    PLN = Currency.register(%q{PLN}, 2, %q{Złoty})
+    PYG = Currency.register(%q{PYG}, 0, %q{Guarani})
+    QAR = Currency.register(%q{QAR}, 2, %q{Qatari rial})
+    RON = Currency.register(%q{RON}, 2, %q{Romanian new leu})
+    RSD = Currency.register(%q{RSD}, 2, %q{Serbian dinar})
+    RUB = Currency.register(%q{RUB}, 2, %q{Russian rouble})
+    RWF = Currency.register(%q{RWF}, 0, %q{Rwanda franc})
+    SAR = Currency.register(%q{SAR}, 2, %q{Saudi riyal})
+    SBD = Currency.register(%q{SBD}, 2, %q{Solomon Islands dollar})
+    SCR = Currency.register(%q{SCR}, 2, %q{Seychelles rupee})
+    SDG = Currency.register(%q{SDG}, 2, %q{Sudanese pound})
+    SEK = Currency.register(%q{SEK}, 2, %q{Swedish krona})
+    SGD = Currency.register(%q{SGD}, 2, %q{Singapore dollar})
+    SHP = Currency.register(%q{SHP}, 2, %q{Saint Helena pound})
+    SLL = Currency.register(%q{SLL}, 0, %q{Leone})
+    SOS = Currency.register(%q{SOS}, 2, %q{Somali shilling})
+    SRD = Currency.register(%q{SRD}, 2, %q{Surinam dollar})
+    STD = Currency.register(%q{STD}, 0, %q{Dobra})
+    SYP = Currency.register(%q{SYP}, 2, %q{Syrian pound})
+    SZL = Currency.register(%q{SZL}, 2, %q{Lilangeni})
+    THB = Currency.register(%q{THB}, 2, %q{Baht})
+    TJS = Currency.register(%q{TJS}, 2, %q{Somoni})
+    TMT = Currency.register(%q{TMT}, 2, %q{Manat})
+    TND = Currency.register(%q{TND}, 3, %q{Tunisian dinar})
+    TOP = Currency.register(%q{TOP}, 2, %q{Pa'anga})
+    TRY = Currency.register(%q{TRY}, 2, %q{Turkish lira})
+    TTD = Currency.register(%q{TTD}, 2, %q{Trinidad and Tobago dollar})
+    TWD = Currency.register(%q{TWD}, 1, %q{New Taiwan dollar})
+    TZS = Currency.register(%q{TZS}, 2, %q{Tanzanian shilling})
+    UAH = Currency.register(%q{UAH}, 2, %q{Hryvnia})
+    UGX = Currency.register(%q{UGX}, 0, %q{Uganda shilling})
+    USD = Currency.register(%q{USD}, 2, %q{US dollar})
+    USN = Currency.register(%q{USN}, 2, %q{United States dollar (next day) (funds code)})
+    USS = Currency.register(%q{USS}, 2, %q{who?})
+    UYU = Currency.register(%q{UYU}, 2, %q{Peso Uruguayo})
+    UZS = Currency.register(%q{UZS}, 2, %q{Uzbekistan som})
+    VEF = Currency.register(%q{VEF}, 2, %q{Venezuelan bolívar fuerte})
+    VND = Currency.register(%q{VND}, 0, %q{Vietnamese đồng})
+    VUV = Currency.register(%q{VUV}, 0, %q{Vatu})
+    WST = Currency.register(%q{WST}, 2, %q{Samoan tala})
+    XAF = Currency.register(%q{XAF}, 0, %q{CFA franc BEAC})
+    XAG = Currency.register(%q{XAG}, 0, %q{Silvertroy ounce})
+    XAU = Currency.register(%q{XAU}, 0, %q{Goldtroy ounce})
+    XBA = Currency.register(%q{XBA}, 0, %q{European Composite Unit})
+    XBB = Currency.register(%q{XBB}, 0, %q{European Monetary Unit})
+    XBC = Currency.register(%q{XBC}, 0, %q{European Unit of Account 9})
+    XBD = Currency.register(%q{XBD}, 0, %q{European Unit of Account 17})
+    XCD = Currency.register(%q{XCD}, 2, %q{East Caribbean dollar})
+    XDR = Currency.register(%q{XDR}, 0, %q{Special Drawing Rights})
+    XFU = Currency.register(%q{XFU}, 0, %q{UIC franc})
+    XOF = Currency.register(%q{XOF}, 0, %q{CFA Franc BCEAO})
+    XPD = Currency.register(%q{XPD}, 0, %q{Palladiumtroy ounce})
+    XPF = Currency.register(%q{XPF}, 0, %q{CFP franc})
+    XPT = Currency.register(%q{XPT}, 0, %q{Platinumtroy ounce})
+    XTS = Currency.register(%q{XTS}, 0, %q{Code reserved for testing purposes})
+    XXX = Currency.register(%q{XXX}, 0, %q{No currency})
+    YER = Currency.register(%q{YER}, 0, %q{Yemeni rial})
+    ZAR = Currency.register(%q{ZAR}, 2, %q{South African rand})
+    ZMK = Currency.register(%q{ZMK}, 0, %q{Kwacha})
+    ZWL = Currency.register(%q{ZWL}, 2, %q{Zimbabwe dollar})
+  end # Currency
+end # BigMoney
+

data/lib/big_money/exchange.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+require 'bigdecimal'
+
+class BigMoney
+
+  # == Synopsis
+  #
+  #   require 'big_money'
+  #   require 'big_money/exchange/yahoo' # Use yahoo finance exchange service.
+  #
+  #   bm = BigMoney.new('3.99', :usd)
+  #   bm.amount   #=> BigDecimal.new('3.99')
+  #   bm.currency #=> BigMoney::Currency::USD
+  #
+  #   bm2 = bm.exchange(:aud)
+  #   bm.amount   #=> BigDecimal.new('5.22')
+  #   bm.currency #=> BigMoney::Currency::AUD
+  module Exchangeable
+    # Exchange to a new Currency.
+    #
+    # ==== Examples
+    #
+    #   BigMoney.new(12.50, :aud).exchange(:usd)
+    #
+    # ==== Parameters
+    # from<BigMoney::Currency, #to_s>:: Anything that BigMoney::Currency#find can find.
+    #
+    # ==== Returns
+    # BigMoney
+    def exchange(to)
+      ex = amount * Exchange.rate(currency, to)
+      self.class.new(ex, to)
+    end
+  end # Exchangeable
+  include Exchangeable
+
+  # Find the exchange rate between two currencies.
+  #
+  # Be aware no caching is done at all at the moment.
+  #--
+  # TODO: Moneta would be ideal for this.
+  class Exchange
+    class ConversionError < StandardError; end
+
+    class << self
+      @@services = []
+      def inherited(service) #:nodoc:
+        @@services << service
+      end
+
+      # Fetch the exchange rate between two currencies.
+      #
+      # ==== Parameters
+      # from<BigMoney::Currency, .to_s>:: Anything that BigMoney::Currency#find can find.
+      # to<BigMoney::Currency, .to_s>:: Anything that BigMoney::Currency#find can find.
+      #
+      # ==== Returns
+      # BigDecimal
+      def rate(from, to)
+        exchange = []
+        exchange << (Currency.find(from) or raise ArgumentError.new("Unknown +from+ currency #{from.inspect}."))
+        exchange << (Currency.find(to) or raise ArgumentError.new("Unknown +to+ currency #{to.inspect}."))
+        return BigDecimal.new(1.to_s) if exchange.uniq.size == 1 || exchange.find{|c| c == Currency::XXX}
+
+        service = @@services.reverse.find do |service|
+          !!exchange.reject{|c| service.currencies.include?(c)}
+        end
+
+        service or raise ConversionError # TODO: Message?
+        BigDecimal.new(service.read_rate(*exchange).to_s)
+      end
+
+      protected
+        # Exchange rate from the first currency to the second.
+        #
+        # ==== Notes
+        # Abstract.
+        #
+        # ==== Parameters
+        # from<BigMoney::Currency>::
+        # to<BigMoney::Currency>::
+        #
+        # ==== Returns
+        # BigDecimal
+        def read_rate(from, to)
+          raise NotImplementedError
+        end
+
+        # Supported currencies.
+        #
+        # ==== Notes
+        # Abstract.
+        #
+        # ==== Returns
+        # Array<BigMoney::Currency, #to_s>:: Anything that BigMoney::Currency#find can find.
+        def currencies
+          raise NotImplementedError
+        end
+    end
+  end # Exchange
+
+end # Money

data/lib/big_money/exchange/yahoo.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+require 'open-uri'
+require 'big_money/exchange'
+
+class BigMoney
+  class Exchange
+
+    # Yahoo finance exchange service.
+    #
+    # http://finance.yahoo.com
+    class Yahoo < Exchange
+      class << self
+        protected
+          def read_rate(from, to)
+            s = [from, to].map{|c| c.code}.join
+            open("http://download.finance.yahoo.com/d/quotes.csv?s=#{s}=X&f=l1&e=.csv").read.strip rescue nil
+          end
+
+          def currencies
+            %w{
+              ALL DZD XAL ARS AWG AUD BSD BHD BDT BBD BYR BZD BMD BTN BOB BWP BRL GBP BND BGN BIF KHR CAD CVE KYD XOF XAF
+              CLP CNY COP KMF XCP CRC HRK CUP CYP CZK DKK DJF DOP XCD ECS EGP SVC ERN EEK ETB EUR FKP FJD GMD GHC GIP XAU
+              GTQ GNF GYD HTG HNL HKD HUF ISK INR IDR IRR IQD ILS JMD JPY JOD KZT KES KRW KWD LAK LVL LBP LSL LRD LYD LTL
+              MOP MKD MWK MYR MVR MTL MRO MUR MXN MDL MNT MAD MMK NAD NPR ANG TRY NZD NIO NGN KPW NOK OMR XPF PKR XPD PAB
+              PGK PYG PEN PHP XPT PLN QAR RON RUB RWF WST STD SAR SCR SLL XAG SGD SKK SIT SBD SOS ZAR LKR SHP SDD SZL SEK
+              CHF SYP TWD TZS THB TOP TTD TND USD AED UGX UAH UYU VUV VEB VND YER ZMK ZWD
+            }
+          end
+      end
+    end # Yahoo
+
+  end # Exchange
+end # Money
+

data/lib/big_money/parser.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require 'big_money' # Make it possible to just require 'big_money/parser'.
+
+class BigMoney
+  # Fuzzy string parsing.
+  #
+  # Supports scientific notation for amounts and ISO-4217 currency symbols.
+  #
+  # == Synopsis
+  #
+  #   require 'big_money'
+  #   require 'big_money/parser' # This module/mixin.
+  #
+  #   BigMoney.parse('JPY ¥2500')   #=> BigMoney.new('2500', :jpy)
+  #   BigMoney.parse('JPY2500')     #=> BigMoney.new('2500', :jpy)
+  #   BigMoney.parse('2500JPY')     #=> BigMoney.new('2500', :jpy)
+  #   BigMoney.parse('¥2500JPY')    #=> BigMoney.new('2500', :jpy)
+  #   BigMoney.parse('¥2500')       #=> BigMoney.new('2500', :xxx)
+  #
+  # == Currency
+  #
+  # Due to the nature of string parsing it's possible t
+  module Parser
+    REGEXP = %r{
+      (?:^|\b)
+      ((?:[a-zA-Z]{3})?)\s*             # ISO4217 Currency code.
+      [^\d+-]?                          # Currency symbol.
+      ([-+]?)                           # +-
+      [^\d+-]?                          # Currency symbol.
+      \s*(
+        (?:(?:\d(?:\d+|[., ]?)*\d)|\d)  # Digits and ., or spaces.
+        (?:[eE][-+]?\d+)?               # Exponents.
+      )\s*
+      ((?:[a-zA-Z]{3})?)                # ISO4217 Currency code.
+      (?:$|\b)
+    }x
+
+    # Fuzzy parsing.
+    #
+    # ==== Parameters
+    # money<.to_s>:: The object to parse as money.
+    #
+    # ==== Currency
+    # ISO-4217 BigMoney::Currency::XXX aka 'No currency' will be used if a currency cannot be parsed along with the
+    # amount. If you know the currency and just need the amount XXX is always exchanged 1:1 with any currency:
+    #
+    # money = BigMoney.parse('¥2500') #=> BigMoney.new('2500', :xxx)
+    # money.exchange(:jpy)            #=> BigMoney.new('2500', :jpy)
+    #
+    # ==== Returns
+    # BigMoney or nil
+    def parse(money)
+      raise TypeError.new("Can't convert +money+ #{money.class} into String.") unless money.respond_to?(:to_s)
+
+      match    = REGEXP.match(money.to_s) || return
+      currency = [match[1], match[4]].find{|c| Currency.find(c)} || Currency::XXX
+
+      # TODO: Currency should have a .delimiter method I reckon that returns the major/minor delimiter.
+      # For now '.' will do and everything else will be stripped.
+      money = [match[2], match[3].gsub(/[^0-9.Ee]/, '')].join
+      new(money, currency)
+    end
+  end # Parser
+
+  extend Parser
+end # BigMoney

data/lib/big_money/types.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+class String
+  def to_big_money(currency = nil)
+    BigMoney.new(self, currency)
+  end
+end
+
+class Numeric
+  def to_big_money(currency = nil)
+    BigMoney.new(self, currency)
+  end
+end

data/rakelib/iso4217.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), '..', 'gems', 'environment')
+require 'hpricot'
+require 'open-uri'
+require 'erubis'
+
+class BigMoney
+  module Task
+    module ISO4217
+      def self.get
+        doc   = Hpricot(open('http://en.wikipedia.org/wiki/ISO_4217').read)
+        codes = doc.at('#Active_codes').parent
+        codes.name =~ /table/ && break while codes = codes.next_sibling
+        to_ruby(codes) if codes
+      end
+
+      def self.to_ruby(codes)
+        currencies = (codes / 'tr').map{|tr| currency tr}.compact
+        currencies.reject!{|c| c[:code] !~ /[A-Z]{3}/ || c[:name] !~ /\w+/}
+        tmpl  = File.read(File.join(File.dirname(__FILE__), 'iso4217.rb.erb'))
+        eruby = Erubis::Eruby.new(tmpl)
+        eruby.result(:currencies => currencies)
+      end
+
+      def self.currency(tr)
+        values = (tr / 'td')
+        return unless values && values.size >= 4
+        {
+          :code   => code(values),
+          :name   => name(values),
+          :offset => offset(values)
+        }
+      end
+
+      def self.code(chunks)
+        chunks[0].inner_html
+      end
+
+      def self.offset(chunks)
+        chunks[2].inner_html.to_i rescue 0
+      end
+
+      def self.name(chunks)
+        name = (chunks[3] / 'a').inner_html rescue nil
+        (name.nil? || name.empty?) ? chunks[3].inner_html : name
+      end
+    end # ISO4217
+  end # Task
+end # BigMoney

data/rakelib/iso4217.rb.erb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+class BigMoney
+  class Currency
+  <% currencies.each do |currency| -%>
+    <%= currency[:code].upcase %> = Currency.register(%q{<%= currency[:code] %>}, <%= currency[:offset] %>, %q{<%= currency[:name] %>})
+  <% end -%>
+  end # Currency
+end # BigMoney
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+require File.join(root, 'gems', 'environment')
+Bundler.require_env(:development)
+require 'test/unit'
+
+begin
+  require 'shoulda'
+rescue LoadError
+  warn 'Shoulda is required for testing. Use gem bundle to install development gems.'
+  exit 1
+end
+
+$:.unshift File.join(root, 'lib'), File.dirname(__FILE__)
+require 'big_money'
+
+class Test::Unit::TestCase
+end

data/test/test_big_money.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestBigMoney < Test::Unit::TestCase
+  context BigMoney do
+    setup do
+      BigMoney::Currency.default = BigMoney::Currency::USD
+    end
+
+    context '#new' do
+      should 'initialize with big decimal' do
+        decimal = BigDecimal.new('1.005')
+        assert_same decimal, BigMoney.new(decimal).amount, 'Should not create clone of input'
+      end
+
+      should 'initialize with string' do
+        assert_equal BigDecimal.new('1.005'), BigMoney.new('1.005').amount
+        assert_equal BigDecimal.new('10'), BigMoney.new('10').amount
+        assert_equal BigDecimal.new('0'), BigMoney.new('0').amount
+        assert_equal BigDecimal.new('0'), BigMoney.new('foo').amount
+      end
+
+      should 'initialize with integer' do
+        assert_equal BigDecimal.new("100"), BigMoney.new(100).amount
+        assert_equal BigDecimal.new("0"), BigMoney.new(0).amount
+      end
+
+      should 'initialize with float' do
+        assert_equal BigDecimal.new('1.005'), BigMoney.new(1.005).amount
+        assert_equal BigDecimal.new('0'), BigMoney.new(0.0).amount
+      end
+    end
+
+    context 'operators' do
+      should 'eql?' do
+        m1, m2 = BigMoney.new(1.00), BigMoney.new(1.50)
+        assert m1.eql?(m1)
+        assert !m1.eql?(m2)
+      end
+
+      should '<=> spaceship' do
+        m1, m2 = BigMoney.new(1.00), BigMoney.new(1.50)
+        assert_equal(-1, (m1 <=> m2))
+        assert_equal(0, (m1 <=> m1))
+        assert_equal(1, (m2 <=> m1))
+      end
+
+      should 'add' do
+        m1, m2, m3 = BigMoney.new(1.00), BigMoney.new(1.50), BigMoney.new(0)
+        assert_equal BigDecimal.new('2.50'), (m1 + m2).amount
+        assert_equal BigDecimal.new('2.50'), (m2 + m1).amount
+        assert_equal BigDecimal.new('1.00'), (m1 + m3).amount
+        assert_equal BigDecimal.new('1.00'), (m3 + m1).amount
+        assert_not_same m1, m1 + m3
+        assert_not_same m1, m3 + m1
+        assert_equal BigDecimal.new('5.50'), (m2 + 4).amount
+        assert_equal BigDecimal.new('5.50'), (m2 + 4.00).amount
+      end
+
+      should 'subtract' do
+        m1, m2, m3 = BigMoney.new(1.00), BigMoney.new(1.50), BigMoney.new(0)
+        assert_equal BigDecimal.new('-0.50'), (m1 - m2).amount
+        assert_equal BigDecimal.new('0.50'), (m2 - m1).amount
+        assert_equal BigDecimal.new('1.00'), (m1 - m3).amount
+        assert_equal BigDecimal.new('-1.00'), (m3 - m1).amount
+        assert_equal BigDecimal.new('-2.50'), (m2 - 4).amount
+        assert_equal BigDecimal.new('-2.50'), (m2 - 4.00).amount
+      end
+
+      should 'multiply' do
+        m1, m2, m3 = BigMoney.new(2.00), BigMoney.new(1.50), BigMoney.new(0)
+        assert_equal BigDecimal.new('4.00'), (m1 * m1).amount
+        assert_equal BigDecimal.new('3.00'), (m1 * m2).amount
+        assert_equal BigDecimal.new('3.00'), (m2 * m1).amount
+        assert_equal BigDecimal.new('0'), (m1 * m3).amount
+        assert_equal BigDecimal.new('0'), (m3 * m1).amount
+        assert_equal BigDecimal.new('0'), (m3 * m3).amount
+        assert_equal BigDecimal.new('3.00'), (m2 * 2).amount
+        assert_equal BigDecimal.new('3.00'), (m2 * 2.00).amount
+      end
+
+      should 'divide' do
+        m1, m2, m3 = BigMoney.new(2.00), BigMoney.new(1.50), BigMoney.new(0)
+        assert_equal BigDecimal.new('1.00'), (m1 / m1).amount
+        assert_equal BigDecimal.new('0.75'), (m2 / m1).amount
+        assert_equal BigDecimal.new('0'), (m3 / m1).amount
+        assert((m1 / m3).amount.infinite?)
+        assert((m3 / m3).amount.nan?)
+        assert((m1 / 0).amount.infinite?)
+        assert((m3 / 0).amount.nan?)
+        assert_equal BigDecimal.new('0.75'), (m2 / 2).amount
+        assert_equal BigDecimal.new('0.75'), (m2 / 2.00).amount
+      end
+
+      should 'negate' do
+        assert_equal BigMoney.new(-1), -BigMoney.new(1)
+        assert_equal BigMoney.new(1),  -BigMoney.new(-1)
+        assert_equal BigMoney.new(1),  -BigMoney.new(-1)
+      end
+    end
+
+    context 'serialization' do
+      should '.to_s' do
+        assert_equal '1.00', BigMoney.new(1).to_s
+        assert_equal '1.50', BigMoney.new(1.5).to_s
+        assert_equal '-11.50', BigMoney.new(-11.5).to_s
+      end
+
+      should 'formatted .to_s' do
+        assert_equal '1.00', BigMoney.new(1).to_s('%.2f')
+        assert_equal '$1.00', BigMoney.new(1).to_s('$%.2f')
+      end
+
+      should '.to_i' do
+        assert_equal(1, BigMoney.new(1).to_i)
+        assert_equal(1, BigMoney.new(1.5).to_i)
+        assert_equal(-11, BigMoney.new(-11.5).to_i)
+      end
+
+      should '.to_f' do
+        assert_in_delta(1.0, BigMoney.new(1).to_f, 0.000001)
+        assert_in_delta(1.5, BigMoney.new(1.5).to_f, 0.000001)
+        assert_in_delta(-11.5, BigMoney.new(-11.5).to_f, 0.000001)
+      end
+    end
+  end
+end
+

data/test/test_currency.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurrency < Test::Unit::TestCase
+  context BigMoney::Currency do
+    should 'find' do
+      assert_kind_of BigMoney::Currency, BigMoney::Currency.find(:aud)
+      assert_kind_of BigMoney::Currency, BigMoney::Currency.find(:AUD)
+      assert_kind_of BigMoney::Currency, BigMoney::Currency.find('aud')
+      assert_kind_of BigMoney::Currency, BigMoney::Currency.find('AUD')
+      assert_nil     BigMoney::Currency.find(:fud)
+    end
+
+    should 'be comparable' do
+      aud = BigMoney::Currency::AUD
+      assert_operator aud, :==, BigMoney::Currency::AUD
+      assert aud != BigMoney::Currency::USD
+    end
+
+    context 'default' do
+      should 'raise exception for bad type' do
+        assert_raise(TypeError) { BigMoney::Currency.default = :fud}
+      end
+
+      should 'be settable' do
+        assert_nothing_raised{ BigMoney::Currency.default = BigMoney::Currency::AUD}
+        assert_kind_of BigMoney::Currency, BigMoney::Currency.default
+        assert_equal BigMoney::Currency::AUD, BigMoney::Currency.default
+      end
+
+      should 'be ackowledged' do
+        BigMoney::Currency.default = BigMoney::Currency::AUD
+        assert BigMoney::Currency.default?
+      end
+    end
+  end
+end

data/test/test_exchange.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'big_money/exchange'
+
+class TestEx < BigMoney::Exchange
+  def self.read_rate(from, to)
+    BigDecimal.new('2')
+  end
+
+  def self.currencies
+    BigMoney::Currency.all
+  end
+end
+
+class TestExchange < Test::Unit::TestCase
+  context BigMoney::Exchange do
+    setup do
+      @aud = BigMoney.currency(:aud)
+      @usd = BigMoney.currency(:usd)
+    end
+
+    should 'return rate' do
+      bd = BigDecimal.new('2')
+      assert_equal bd, BigMoney::Exchange.rate(@aud, @usd)
+      assert_equal bd, BigMoney::Exchange.rate(:aud, :usd)
+      assert_raise(ArgumentError) do
+        BigMoney::Exchange.rate(:aud, :fud)
+      end
+    end
+
+    should 'return equal rate' do
+      assert_equal BigDecimal.new('1'), BigMoney::Exchange.rate(:usd, :usd)
+      assert_equal BigDecimal.new('1'), BigMoney::Exchange.rate(:usd, :xxx)
+      assert_equal BigDecimal.new('1'), BigMoney::Exchange.rate(:xxx, :usd)
+    end
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'big_money/parser'
+
+class TestParser < Test::Unit::TestCase
+  context BigMoney::Parser do
+    setup do
+      @xxx = BigMoney.new('1.50', :xxx)
+      @aud = BigMoney.new('1.50', :aud)
+      @jpy = BigMoney.new('1.50', :jpy)
+    end
+
+    should 'parse' do
+      assert_equal @xxx, BigMoney.parse('1.50')
+    end
+
+    should 'parse scientific notation' do
+      assert_equal @xxx, BigMoney.parse('0.15E1')
+    end
+
+    should 'parse with leading currency' do
+      assert_equal @aud, BigMoney.parse('AUD 1.50')
+      assert_equal @aud, BigMoney.parse('AUD1.50')
+      assert_equal @aud, BigMoney.parse('AUD 0.15E1')
+      assert_equal @aud, BigMoney.parse('AUD0.15E1')
+
+      assert_equal @jpy, BigMoney.parse('JPY 1.50')
+      assert_equal @jpy, BigMoney.parse('JPY1.50')
+      assert_equal @jpy, BigMoney.parse('JPY 0.15E1')
+      assert_equal @jpy, BigMoney.parse('JPY0.15E1')
+    end
+
+    should 'parse with trailing currency' do
+      assert_equal @aud, BigMoney.parse('1.50 AUD')
+      assert_equal @aud, BigMoney.parse('1.50AUD')
+      assert_equal @aud, BigMoney.parse('0.15E1 AUD')
+      assert_equal @aud, BigMoney.parse('0.15E1AUD')
+
+      assert_equal @jpy, BigMoney.parse('1.50 JPY')
+      assert_equal @jpy, BigMoney.parse('1.50JPY')
+      assert_equal @jpy, BigMoney.parse('0.15E1 JPY')
+      assert_equal @jpy, BigMoney.parse('0.15E1JPY')
+    end
+
+    should 'parse with currency symbols' do
+      assert_equal @xxx, BigMoney.parse('$1.50')
+      assert_equal @xxx, BigMoney.parse('¤1.50')
+      assert_equal @xxx, BigMoney.parse('¥1.50')
+
+      assert_equal @xxx, BigMoney.parse('$ 1.50')
+      assert_equal @xxx, BigMoney.parse('¤ 1.50')
+      assert_equal @xxx, BigMoney.parse('¥ 1.50')
+    end
+
+    should 'parse with currency and symbols' do
+      assert_equal @aud, BigMoney.parse('AUD ¤ 1.50')
+      assert_equal @aud, BigMoney.parse('AUD ¤1.50')
+      assert_equal @aud, BigMoney.parse('AUD¤ 1.50')
+      assert_equal @aud, BigMoney.parse('AUD¤1.50')
+
+      assert_equal @aud, BigMoney.parse('¤ 1.50 AUD')
+      assert_equal @aud, BigMoney.parse('¤ 1.50AUD')
+      assert_equal @aud, BigMoney.parse('¤1.50 AUD')
+      assert_equal @aud, BigMoney.parse('¤1.50AUD')
+    end
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: big_money
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Shane Hanna
+- Marshall Roch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-22 00:00:00 +11:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- shane.hanna@gmail.com
+- mroch@cmu.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- big_money.gemspec
+- lib/big_money.rb
+- lib/big_money/currency.rb
+- lib/big_money/currency/iso4217.rb
+- lib/big_money/exchange.rb
+- lib/big_money/exchange/yahoo.rb
+- lib/big_money/parser.rb
+- lib/big_money/types.rb
+- rakelib/iso4217.rb
+- rakelib/iso4217.rb.erb
+- test/helper.rb
+- test/test_big_money.rb
+- test/test_currency.rb
+- test/test_exchange.rb
+- test/test_parser.rb
+has_rdoc: true
+homepage: http://github.com/shanna/big_money
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: BigDecimal backed amount of money in a particular currency.
+test_files: 
+- test/test_exchange.rb
+- test/helper.rb
+- test/test_currency.rb
+- test/test_big_money.rb
+- test/test_parser.rb