monetize 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1c2a9a44b80e3d27927f8d5a0771ecd796f7061
+  data.tar.gz: da0255a4102dec917a27f22808b4ec2f6535fa12
+SHA512:
+  metadata.gz: 28eb3b256dc924f5d643c61dcd3b17e0f7d9df444c4daca6077b7ac0dff29741149ad1b5ddc55d83e8d12fe79abe45d1c595638f52a77af6db129bbfa59761b3
+  data.tar.gz: 800592844fdfdf4fb66df3855b14c51240a7516f44c687eaea16bd6a7a27d713b41f4a2ea8096e4eb43aa64137e318efbc930921afea5e7e9bbbb90943cc018c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Shane Emmons
+
+MIT License
+
+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.md

@@ -0,0 +1,31 @@
+# Monetize
+
+A library for converting various objects into `Money` objects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'monetize'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install monetize
+
+## Usage
+
+```ruby
+# Coming Soon
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/monetize.rb

@@ -0,0 +1,135 @@
+require "money"
+require "monetize/version"
+
+module Monetize
+  def self.parse(input, currency = Money.default_currency)
+    input = input.to_s.strip
+
+    computed_currency = if Money.assume_from_symbol && input =~ /^(\$|€|£)/
+                          case input
+                          when /^\$/ then "USD"
+                          when /^€/ then "EUR"
+                          when /^£/ then "GBP"
+                          end
+                        else
+                          input[/[A-Z]{2,3}/]
+                        end
+
+    currency = computed_currency || currency || Money.default_currency
+    currency = Money::Currency.wrap(currency)
+
+    fractional = extract_cents(input, currency)
+    Money.new(fractional, currency)
+  end
+
+  def self.from_string(value, currency = Money.default_currency)
+    value = BigDecimal.new(value.to_s)
+    from_bigdecimal(value, currency)
+  end
+
+  def self.from_fixnum(value, currency = Money.default_currency)
+    currency = Money::Currency.wrap(currency)
+    value = value * currency.subunit_to_unit
+    Money.new(value, currency)
+  end
+
+  def self.from_float(value, currency = Money.default_currency)
+    value = BigDecimal.new(value.to_s)
+    from_bigdecimal(value, currency)
+  end
+
+  def self.from_bigdecimal(value, currency = Money.default_currency)
+    currency = Money::Currency.wrap(currency)
+    value = value * currency.subunit_to_unit
+    value = value.round unless Money.infinite_precision
+    Money.new(value, currency)
+  end
+
+  def self.from_numeric(value, currency = Money.default_currency)
+    case value
+    when Fixnum
+      from_fixnum(value, currency)
+    when Numeric
+      value = BigDecimal.new(value.to_s)
+      from_bigdecimal(value, currency)
+    else
+      raise ArgumentError, "'value' should be a type of Numeric"
+    end
+  end
+
+  def self.extract_cents(input, currency = Money.default_currency)
+    num = input.gsub(/[^\d.,'-]/, '')
+
+    negative = num =~ /^-|-$/ ? true : false
+
+    decimal_char = currency.decimal_mark
+
+    num = num.sub(/^-|-$/, '') if negative
+
+    if num.include?('-')
+      raise ArgumentError, "Invalid currency amount (hyphen)"
+    end
+
+    num.chop! if num.match(/[\.|,]$/)
+
+    used_delimiters = num.scan(/[^\d]/)
+
+    case used_delimiters.uniq.length
+    when 0
+      major, minor = num, 0
+    when 2
+      thousands_separator, decimal_mark = used_delimiters.uniq
+
+      major, minor = num.gsub(thousands_separator, '').split(decimal_mark)
+      min = 0 unless min
+    when 1
+      decimal_mark = used_delimiters.first
+
+      if decimal_char == decimal_mark
+        major, minor = num.split(decimal_char)
+      else
+        if num.scan(decimal_mark).length > 1 # multiple matches; treat as decimal_mark
+          major, minor = num.gsub(decimal_mark, ''), 0
+        else
+          possible_major, possible_minor = num.split(decimal_mark)
+          possible_major ||= "0"
+          possible_minor ||= "00"
+
+          if possible_minor.length != 3 # thousands_separator
+            major, minor = possible_major, possible_minor
+          else
+            if possible_major.length > 3
+              major, minor = possible_major, possible_minor
+            else
+              if decimal_mark == '.'
+                major, minor = possible_major, possible_minor
+              else
+                major, minor = "#{possible_major}#{possible_minor}", 0
+              end
+            end
+          end
+        end
+      end
+    else
+      raise ArgumentError, "Invalid currency amount"
+    end
+
+    cents = major.to_i * currency.subunit_to_unit
+    minor = minor.to_s
+    minor = if minor.size < currency.decimal_places
+              (minor + ("0" * currency.decimal_places))[0,currency.decimal_places].to_i
+            elsif minor.size > currency.decimal_places
+              if minor[currency.decimal_places,1].to_i >= 5
+                minor[0,currency.decimal_places].to_i+1
+              else
+                minor[0,currency.decimal_places].to_i
+              end
+            else
+              minor.to_i
+            end
+
+    cents += minor
+
+    negative ? cents * -1 : cents
+  end
+end

data/lib/monetize/core_extensions.rb

@@ -0,0 +1,3 @@
+require "monetize/core_extensions/numeric"
+require "monetize/core_extensions/string"
+require "monetize/core_extensions/symbol"

data/lib/monetize/core_extensions/numeric.rb

@@ -0,0 +1,5 @@
+class Numeric
+  def to_money(currency = nil)
+    Monetize.from_numeric(self, currency || Money.default_currency)
+  end
+end

data/lib/monetize/core_extensions/string.rb

@@ -0,0 +1,9 @@
+class String
+  def to_money(currency = nil)
+    Monetize.parse(self, currency)
+  end
+
+  def to_currency
+    Money::Currency.new(self)
+  end
+end

data/lib/monetize/core_extensions/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def to_currency
+    Money::Currency.new(self)
+  end
+end

data/lib/monetize/version.rb

@@ -0,0 +1,3 @@
+module Monetize
+  VERSION = "0.1.0"
+end

data/monetize.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "monetize/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "monetize"
+  spec.version       = Monetize::VERSION
+  spec.authors       = ["Shane Emmons"]
+  spec.email         = ["shane@emmons.io"]
+  spec.description   = "A library for converting various objects into `Money` objects."
+  spec.summary       = "A library for converting various objects into `Money` objects."
+  spec.homepage      = "https://github.com/RubyMoney/monetize"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "money", "~> 6.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta1"
+end

data/spec/core_extensions_spec.rb

@@ -0,0 +1,161 @@
+require "spec_helper"
+require "monetize"
+require "monetize/core_extensions"
+
+describe Monetize, "core extensions" do
+  describe Numeric do
+    describe "#to_money" do
+      it "work as documented" do
+        money = 1234.to_money
+        expect(money.cents).to eq 1234_00
+        expect(money.currency).to eq Money.default_currency
+
+        money = 100.37.to_money
+        expect(money.cents).to eq 100_37
+        expect(money.currency).to eq Money.default_currency
+
+        money = BigDecimal.new('1234').to_money
+        expect(money.cents).to eq 1234_00
+        expect(money.currency).to eq Money.default_currency
+      end
+
+      it "accepts optional currency" do
+        expect(1234.to_money('USD')).to eq Money.new(123400, 'USD')
+        expect(1234.to_money('EUR')).to eq Money.new(123400, 'EUR')
+      end
+
+      it "respects :subunit_to_unit currency property" do
+        expect(10.to_money('USD')).to eq Money.new(10_00, 'USD')
+        expect(10.to_money('TND')).to eq Money.new(10_000, 'TND')
+        expect(10.to_money('CLP')).to eq Money.new(10, 'CLP')
+      end
+
+      specify "GH-15" do
+        amount = 555.55.to_money
+        expect(amount).to eq Money.new(55555)
+      end
+    end
+  end
+
+  describe String do
+    describe "#to_money" do
+
+      STRING_TO_MONEY = {
+        "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")       ,
+      }
+
+      it "works as documented" do
+        STRING_TO_MONEY.each do |string, money|
+          expect(string.to_money).to eq money
+        end
+      end
+
+      it "coerces input to string" do
+        expect(Monetize.parse(20, "USD")).to eq Money.new(20_00, "USD")
+      end
+
+      it "accepts optional currency" do
+        expect("10.10".to_money('USD')).to eq Money.new(1010, 'USD')
+        expect("10.10".to_money('EUR')).to eq Money.new(1010, 'EUR')
+        expect("10.10 USD".to_money('USD')).to eq Money.new(1010, 'USD')
+      end
+
+      it "uses parsed currency, even if currency is passed" do
+        expect("10.10 USD".to_money("EUR")).to eq(Money.new(1010, "USD"))
+      end
+
+      it "ignores unrecognized data" do
+        expect("hello 2000 world".to_money).to eq Money.new(2000_00)
+      end
+
+      it "respects :subunit_to_unit currency property" do
+        expect("1".to_money("USD")).to eq Money.new(1_00,  "USD")
+        expect("1".to_money("TND")).to eq Money.new(1_000, "TND")
+        expect("1".to_money("CLP")).to eq Money.new(1,     "CLP")
+        expect("1.5".to_money("KWD").cents).to eq 1500
+      end
+    end
+
+    describe "#to_currency" do
+      it "converts String to Currency" do
+        expect("USD".to_currency).to eq Money::Currency.new("USD")
+        expect("EUR".to_currency).to eq Money::Currency.new("EUR")
+      end
+
+      it "raises Money::Currency::UnknownCurrency with unknown Currency" do
+        expect { "XXX".to_currency }.to raise_error(Money::Currency::UnknownCurrency)
+        expect { " ".to_currency }.to raise_error(Money::Currency::UnknownCurrency)
+      end
+    end
+  end
+
+  describe Symbol do
+    describe "#to_currency" do
+      it "converts Symbol to Currency" do
+        expect(:usd.to_currency).to eq Money::Currency.new("USD")
+        expect(:ars.to_currency).to eq Money::Currency.new("ARS")
+      end
+
+      it "is case-insensitive" do
+        expect(:EUR.to_currency).to eq Money::Currency.new("EUR")
+      end
+
+      it "raises Money::Currency::UnknownCurrency with unknown Currency" do
+        expect { :XXX.to_currency }.to raise_error(Money::Currency::UnknownCurrency)
+        expect { :" ".to_currency }.to raise_error(Money::Currency::UnknownCurrency)
+      end
+    end
+  end
+
+end

data/spec/monetize_spec.rb

@@ -0,0 +1,323 @@
+require "spec_helper"
+require "monetize"
+
+describe Monetize do
+
+  bar = '{ "priority": 1, "iso_code": "BAR", "iso_numeric": "840", "name": "Dollar with 4 decimal places", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 10000, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": "," }'
+  eu4 = '{ "priority": 1, "iso_code": "EU4", "iso_numeric": "841", "name": "Euro with 4 decimal places", "symbol": "€", "subunit": "Cent", "subunit_to_unit": 10000, "symbol_first": true, "html_entity": "€", "decimal_mark": ",", "thousands_separator": "." }'
+
+  describe ".parse" do
+
+    it "parses european-formatted inputs under 10EUR" do
+      expect(Monetize.parse('EUR 5,95')).to eq Money.new(595, 'EUR')
+    end
+
+    it "parses european-formatted inputs with multiple thousands-seperators" do
+      expect(Monetize.parse('EUR 1.234.567,89')).to eq Money.new(123456789, 'EUR')
+      expect(Monetize.parse('EUR 1.111.234.567,89')).to eq Money.new(111123456789, 'EUR')
+    end
+
+    describe 'currency assumption' do
+      context 'opted in' do
+        before do
+          Money.assume_from_symbol = true
+        end
+
+        it "parses formatted inputs with the currency passed as a symbol" do
+          original_currency = Money.default_currency
+          Money.default_currency = "EUR"
+          Money.default_currency = original_currency
+          expect(Monetize.parse("€5.95")).to eq Money.new(595, 'EUR')
+          expect(Monetize.parse(" €5.95 ")).to eq Money.new(595, 'EUR')
+          expect(Monetize.parse("£9.99")).to eq Money.new(999, 'GBP')
+        end
+
+        it 'should assume default currency if not a recognised symbol' do
+          expect(Monetize.parse("L9.99")).to eq Money.new(999, 'USD')
+        end
+      end
+      context 'opted out' do
+        before do
+          Money.assume_from_symbol = false
+        end
+        it "parses formatted inputs with the currency passed as a symbol but ignores the symbol" do
+          expect(Monetize.parse("$5.95")).to eq Money.new(595, 'USD')
+          expect(Monetize.parse("€5.95")).to eq Money.new(595, 'USD')
+          expect(Monetize.parse(" €5.95 ")).to eq Money.new(595, 'USD')
+          expect(Monetize.parse("£9.99")).to eq Money.new(999, 'USD')
+
+        end
+      end
+      it 'should opt out by default' do
+        expect(Money.assume_from_symbol).to be false
+      end
+    end
+
+    it "parses USD-formatted inputs under $10" do
+      five_ninety_five = Money.new(595, 'USD')
+
+      expect(Monetize.parse(5.95)).to eq five_ninety_five
+      expect(Monetize.parse('5.95')).to eq five_ninety_five
+      expect(Monetize.parse('$5.95')).to eq five_ninety_five
+      expect(Monetize.parse("\n $5.95 \n")).to eq five_ninety_five
+      expect(Monetize.parse('$ 5.95')).to eq five_ninety_five
+      expect(Monetize.parse('$5.95 ea.')).to eq five_ninety_five
+      expect(Monetize.parse('$5.95, each')).to eq five_ninety_five
+    end
+
+    it "parses USD-formatted inputs with multiple thousands-seperators" do
+      expect(Monetize.parse('1,234,567.89')).to eq Money.new(123456789, 'USD')
+      expect(Monetize.parse('1,111,234,567.89')).to eq Money.new(111123456789, 'USD')
+    end
+
+    it "does not return a price if there is a price range" do
+      expect { Monetize.parse('$5.95-10.95') }.to raise_error ArgumentError
+      expect { Monetize.parse('$5.95 - 10.95') }.to raise_error ArgumentError
+      expect { Monetize.parse('$5.95 - $10.95') }.to raise_error ArgumentError
+    end
+
+    it "does not return a price for completely invalid input" do
+      expect(Monetize.parse(nil)).to eq Money.empty
+      expect(Monetize.parse('hellothere')).to eq Money.empty
+      expect(Monetize.parse('')).to eq Money.empty
+    end
+
+    it "handles negative inputs" do
+      five_ninety_five = Money.new(-595, 'USD')
+
+      expect(Monetize.parse("$-5.95")).to eq five_ninety_five
+      expect(Monetize.parse("-$5.95")).to eq five_ninety_five
+      expect(Monetize.parse("$5.95-")).to eq five_ninety_five
+    end
+
+    it "raises ArgumentError when unable to detect polarity" do
+      expect { Monetize.parse('-$5.95-') }.to raise_error ArgumentError
+    end
+
+    it "parses correctly strings with exactly 3 decimal digits" do
+      expect(Monetize.parse("6,534", "EUR")).to eq Money.new(653, "EUR")
+    end
+
+    context "custom currencies with 4 decimal places" do
+      before :each do
+        Money::Currency.register(JSON.parse(bar, :symbolize_names => true))
+        Money::Currency.register(JSON.parse(eu4, :symbolize_names => true))
+      end
+
+      after :each do
+        Money::Currency.unregister(JSON.parse(bar, :symbolize_names => true))
+        Money::Currency.unregister(JSON.parse(eu4, :symbolize_names => true))
+      end
+
+      # String#to_money(Currency) is equivalent to Monetize.parse(String, Currency)
+      it "parses strings respecting subunit to unit, decimal and thousands separator" do
+        expect("$0.4".to_money("BAR")).to eq Money.new(4000, "BAR")
+        expect("€0,4".to_money("EU4")).to eq Money.new(4000, "EU4")
+
+        expect("$0.04".to_money("BAR")).to eq Money.new(400, "BAR")
+        expect("€0,04".to_money("EU4")).to eq Money.new(400, "EU4")
+
+        expect("$0.004".to_money("BAR")).to eq Money.new(40, "BAR")
+        expect("€0,004".to_money("EU4")).to eq Money.new(40, "EU4")
+
+        expect("$0.0004".to_money("BAR")).to eq Money.new(4, "BAR")
+        expect("€0,0004".to_money("EU4")).to eq Money.new(4, "EU4")
+
+        expect("$0.0024".to_money("BAR")).to eq Money.new(24, "BAR")
+        expect("€0,0024".to_money("EU4")).to eq Money.new(24, "EU4")
+
+        expect("$0.0324".to_money("BAR")).to eq Money.new(324, "BAR")
+        expect("€0,0324".to_money("EU4")).to eq Money.new(324, "EU4")
+
+        expect("$0.5324".to_money("BAR")).to eq Money.new(5324, "BAR")
+        expect("€0,5324".to_money("EU4")).to eq Money.new(5324, "EU4")
+
+        expect("$6.5324".to_money("BAR")).to eq Money.new(65324, "BAR")
+        expect("€6,5324".to_money("EU4")).to eq Money.new(65324, "EU4")
+
+        expect("$86.5324".to_money("BAR")).to eq Money.new(865324, "BAR")
+        expect("€86,5324".to_money("EU4")).to eq Money.new(865324, "EU4")
+
+        expect("$186.5324".to_money("BAR")).to eq Money.new(1865324, "BAR")
+        expect("€186,5324".to_money("EU4")).to eq Money.new(1865324, "EU4")
+
+        expect("$3,331.0034".to_money("BAR")).to eq Money.new(33310034, "BAR")
+        expect("€3.331,0034".to_money("EU4")).to eq Money.new(33310034, "EU4")
+
+        expect("$8,883,331.0034".to_money("BAR")).to eq Money.new(88833310034, "BAR")
+        expect("€8.883.331,0034".to_money("EU4")).to eq Money.new(88833310034, "EU4")
+      end
+    end
+  end
+
+  describe ".from_string" do
+    it "converts given amount to cents" do
+      expect(Monetize.from_string("1")).to eq Money.new(1_00)
+      expect(Monetize.from_string("1")).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_string("1", "EUR")).to eq Money.new(1_00, "EUR")
+    end
+
+    it "respects :subunit_to_unit currency property" do
+      expect(Monetize.from_string("1", "USD")).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_string("1", "TND")).to eq Money.new(1_000, "TND")
+      expect(Monetize.from_string("1", "CLP")).to eq Money.new(1, "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Monetize.from_string("1")
+      expect(m.currency).to eq Money.default_currency
+
+      m = Monetize.from_string("1", Money::Currency.wrap("EUR"))
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+
+      m = Monetize.from_string("1", "EUR")
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe ".from_fixnum" do
+    it "converts given amount to cents" do
+      expect(Monetize.from_fixnum(1)).to eq Money.new(1_00)
+      expect(Monetize.from_fixnum(1)).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_fixnum(1, "EUR")).to eq Money.new(1_00, "EUR")
+    end
+
+    it "should respect :subunit_to_unit currency property" do
+      expect(Monetize.from_fixnum(1, "USD")).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_fixnum(1, "TND")).to eq Money.new(1_000, "TND")
+      expect(Monetize.from_fixnum(1, "CLP")).to eq Money.new(1, "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Monetize.from_fixnum(1)
+      expect(m.currency).to eq Money.default_currency
+
+      m = Monetize.from_fixnum(1, Money::Currency.wrap("EUR"))
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+
+      m = Monetize.from_fixnum(1, "EUR")
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe ".from_float" do
+    it "converts given amount to cents" do
+      expect(Monetize.from_float(1.2)).to eq Money.new(1_20)
+      expect(Monetize.from_float(1.2)).to eq Money.new(1_20, "USD")
+      expect(Monetize.from_float(1.2, "EUR")).to eq Money.new(1_20, "EUR")
+    end
+
+    it "respects :subunit_to_unit currency property" do
+      expect(Monetize.from_float(1.2, "USD")).to eq Money.new(1_20, "USD")
+      expect(Monetize.from_float(1.2, "TND")).to eq Money.new(1_200, "TND")
+      expect(Monetize.from_float(1.2, "CLP")).to eq Money.new(1, "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Monetize.from_float(1.2)
+      expect(m.currency).to eq Money.default_currency
+
+      m = Monetize.from_float(1.2, Money::Currency.wrap("EUR"))
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+
+      m = Monetize.from_float(1.2, "EUR")
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe ".from_bigdecimal" do
+    it "converts given amount to cents" do
+      expect(Monetize.from_bigdecimal(BigDecimal.new("1"))).to eq Money.new(1_00)
+      expect(Monetize.from_bigdecimal(BigDecimal.new("1"))).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "EUR")).to eq Money.new(1_00, "EUR")
+    end
+
+    it "respects :subunit_to_unit currency property" do
+      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "USD")).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "TND")).to eq Money.new(1_000, "TND")
+      expect(Monetize.from_bigdecimal(BigDecimal.new("1"), "CLP")).to eq Money.new(1, "CLP")
+    end
+
+    it "accepts a currency options" do
+      m = Monetize.from_bigdecimal(BigDecimal.new("1"))
+      expect(m.currency).to eq Money.default_currency
+
+      m = Monetize.from_bigdecimal(BigDecimal.new("1"), Money::Currency.wrap("EUR"))
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+
+      m = Monetize.from_bigdecimal(BigDecimal.new("1"), "EUR")
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+    end
+
+    context "infinite_precision = true" do
+      before do
+        Money.infinite_precision = true
+      end
+
+      after do
+        Money.infinite_precision = false
+      end
+
+      it "keeps precision" do
+        expect(Monetize.from_bigdecimal(BigDecimal.new("1.23456"))).to eq Money.new(123.456)
+        expect(Monetize.from_bigdecimal(BigDecimal.new("-1.23456"))).to eq Money.new(-123.456)
+        expect(Monetize.from_bigdecimal(BigDecimal.new("1.23456"))).to eq Money.new(123.456, "USD")
+        expect(Monetize.from_bigdecimal(BigDecimal.new("1.23456"), "EUR")).to eq Money.new(123.456, "EUR")
+      end
+    end
+  end
+
+  describe ".from_numeric" do
+    it "converts given amount to cents" do
+      expect(Monetize.from_numeric(1)).to eq Money.new(1_00)
+      expect(Monetize.from_numeric(1.0)).to eq Money.new(1_00)
+      expect(Monetize.from_numeric(BigDecimal.new("1"))).to eq Money.new(1_00)
+    end
+
+    it "raises ArgumentError with unsupported argument" do
+      expect { Monetize.from_numeric("100") }.to raise_error(ArgumentError)
+    end
+
+    it "optimizes workload" do
+      expect(Monetize).to receive(:from_fixnum).with(1, "USD").and_return(Money.new(1_00, "USD"))
+      expect(Monetize.from_numeric(1, "USD")).to eq Money.new(1_00, "USD")
+      expect(Monetize).to receive(:from_bigdecimal).with(BigDecimal.new("1.0"), "USD").and_return(Money.new(1_00, "USD"))
+      expect(Monetize.from_numeric(1.0, "USD")).to eq Money.new(1_00, "USD")
+    end
+
+    it "respects :subunit_to_unit currency property" do
+      expect(Monetize.from_numeric(1, "USD")).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_numeric(1, "TND")).to eq Money.new(1_000, "TND")
+      expect(Monetize.from_numeric(1, "CLP")).to eq Money.new(1, "CLP")
+    end
+
+    it "accepts a bank option" do
+      expect(Monetize.from_numeric(1)).to eq Money.new(1_00)
+      expect(Monetize.from_numeric(1)).to eq Money.new(1_00, "USD")
+      expect(Monetize.from_numeric(1, "EUR")).to eq Money.new(1_00, "EUR")
+    end
+
+    it "accepts a currency options" do
+      m = Monetize.from_numeric(1)
+      expect(m.currency).to eq Money.default_currency
+
+      m = Monetize.from_numeric(1, Money::Currency.wrap("EUR"))
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+
+      m = Monetize.from_numeric(1, "EUR")
+      expect(m.currency).to eq Money::Currency.wrap("EUR")
+    end
+  end
+
+  describe ".extract_cents" do
+    it "correctly treats pipe marks '|' in input (regression test)" do
+      expect(Monetize.extract_cents('100|0')).to eq Monetize.extract_cents('100!0')
+    end
+  end
+
+  context "given the same inputs to .parse and .from_*" do
+    it "gives the same results" do
+      expect(4.635.to_money).to eq "4.635".to_money
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.order = "random"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: monetize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane Emmons
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+description: A library for converting various objects into `Money` objects.
+email:
+- shane@emmons.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/monetize.rb
+- lib/monetize/core_extensions.rb
+- lib/monetize/core_extensions/numeric.rb
+- lib/monetize/core_extensions/string.rb
+- lib/monetize/core_extensions/symbol.rb
+- lib/monetize/version.rb
+- monetize.gemspec
+- spec/core_extensions_spec.rb
+- spec/monetize_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/RubyMoney/monetize
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A library for converting various objects into `Money` objects.
+test_files:
+- spec/core_extensions_spec.rb
+- spec/monetize_spec.rb
+- spec/spec_helper.rb