cashrb 1.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Shane Emmons
+
+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,60 @@
+cashrb
+======
+
+Dead simple gem to work with Money/Currency without the hassle of Floats.
+
+Usage
+-----
+
+    require 'cash'
+
+    # Works with cents to avoid Floating point errors
+    n = Cash.new(100)
+    n.cents #=> 100
+    n.to_s  #=> "1.00"
+    n.to_f  #=> 1.0
+
+    # Define currency as you see fit.
+    a = Cash.new(100, :usd)
+    b = Cash.new(100, :eur)
+    a + b #=> Error! Cash::IncompatibleCurrency
+
+    # Default is 100 cents in a dollar. Is your currency different, then just
+    # tell it.
+    n = Cash.new(100, cents_in_dollar: 5)
+    n.cents #=> 100
+    n.to_s  #=> "20.0"
+    n.to_f  #=> 20.0
+
+    n = Cash.new(100, cents_in_dollar: 10)
+    n.cents #=> 100
+    n.to_s  #=> "10.0"
+    n.to_f  #=> 10.0
+
+    n = Cash.new(100, cents_in_dollar: 1)
+    n.cents #=> 100
+    n.to_s  #=> "100"
+    n.to_f  #=> 100.0
+
+    # The default rounding method when dealing with fractional cents is
+    # BigDecimal::ROUND_HALF_UP. Would you rather use bankers rounding; just
+    # pass it as an argument.
+    n = Cash.new(2.5)
+    n.cents #=> 3
+
+    n = Cash.new(2.5, rounding_method: BigDecimal::ROUND_HALF_EVEN)
+    n.cents #=> 2
+
+    # Sick of specifying :cents_in_whole, :rounding_method and :currency; just
+    # set their defaults.
+    Cash.default_cents_in_whole  = 10
+    Cash.default_rounding_method = BigDecimal::ROUND_DOWN
+    Cash.default_currency        = :EUR
+
+    n = Cash.new(100)
+    n.to_s     #=> "10.0"
+    n.to_f     #=> 10.0
+    n.currency #=> :EUR
+
+    n = Cash.new(1.9)
+    n.cents #=> 1

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+Rake::TestTask.new
+
+spec = Gem::Specification.load File.expand_path("../cashrb.gemspec", __FILE__)
+gem  = Rake::GemPackageTask.new(spec)
+gem.define

data/cashrb.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name        = "cashrb"
+  s.version     = "1.0.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Shane Emmons"]
+  s.email       = ["semmons99@gmail.com"]
+  s.homepage    = "http://github.com/semmons99/cashrb"
+  s.summary     = "Dead simple gem to work with Money/Currency without the hassle of Floats"
+  s.description = "Dead simple gem to work with Money/Currency without the hassle of Floats"
+
+  s.required_ruby_version     = ">= 1.8.7"
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.requirements << "minitest"
+
+  s.files =  Dir.glob("{lib,test}/**/*")
+  s.files += %w(CHANGELOG.md LICENSE README.md)
+  s.files += %w(Rakefile .gemtest cashrb.gemspec)
+
+  s.require_path = "lib"
+end

data/lib/cash/cash.rb

@@ -0,0 +1,159 @@
+require 'bigdecimal'
+
+##
+# Provides methods for performing financial calculations without using floats.
+class Cash
+  class IncompatibleCurrency < ArgumentError; end
+
+  DEFAULT_CENTS_IN_WHOLE  = 100
+  DEFAULT_ROUNDING_METHOD = BigDecimal::ROUND_HALF_UP
+  DEFAULT_CURRENCY        = nil
+
+  CURRENCY_AWARE_METHODS  = [
+    :+, :-, :/, :%, :divmod, :==, :<=>, :>, :<, :>=, :<=
+  ]
+
+  class << self
+    attr_accessor :default_cents_in_whole
+    attr_accessor :default_rounding_method
+    attr_accessor :default_currency
+
+    def reset_defaults
+      @default_cents_in_whole  = DEFAULT_CENTS_IN_WHOLE
+      @default_rounding_method = DEFAULT_ROUNDING_METHOD
+      @default_currency        = DEFAULT_CURRENCY
+    end
+  end
+
+  reset_defaults
+
+  attr_reader :currency
+
+  def initialize(cents = 0, options = {})
+    parse_initialize_options(options)
+    @cents = bd(cents).round(0, @rounding_method)
+  end
+
+  def cents
+    @cents.to_i
+  end
+
+  def +(value)
+    Cash.new(@cents + value.cents)
+  end
+
+  def -(value)
+    Cash.new(@cents - value.cents)
+  end
+
+  def *(value)
+    Cash.new(@cents * bd(value))
+  end
+
+  def /(value)
+    @cents / value.cents
+  rescue NoMethodError
+    Cash.new(@cents / bd(value))
+  end
+
+  def %(value)
+    Cash.new(@cents % value.cents)
+  rescue NoMethodError
+    Cash.new(@cents % bd(value))
+  end
+
+  def divmod(value)
+    quotient, remainder = @cents.divmod value.cents
+    [quotient, Cash.new(remainder)]
+  rescue NoMethodError
+    quotient, remainder = @cents.divmod bd(value)
+    [Cash.new(quotient), Cash.new(remainder)]
+  end
+
+  def ==(value)
+    @cents == value.cents
+  end
+
+  def <=>(value)
+    @cents <=> value.cents
+  end
+
+  def >(value)
+    @cents > value.cents
+  end
+
+  def <(value)
+    @cents < value.cents
+  end
+
+  def >=(value)
+    @cents >= value.cents
+  end
+
+  def <=(value)
+    @cents <= value.cents
+  end
+
+  def to_s
+    return self.cents.to_s if @cents_in_whole == 1
+
+    dollars, cents = dollars_and_cents
+    "#{dollars}.#{formatted_cents(cents)}"
+  end
+
+  def to_f
+    self.to_s.to_f
+  end
+
+  private
+
+  def bd(val)
+    BigDecimal(val.to_s)
+  end
+
+  def dollars_and_cents
+    @cents.divmod(@cents_in_whole).map(&:to_i)
+  end
+
+  def formatted_cents(cents)
+    c = ("0" * @decimal_places) + cents.to_s
+    c[(-1 * @decimal_places), @decimal_places]
+  end
+
+  def parse_initialize_options(options)
+    opts = {
+      cents_in_whole:  self.class.default_cents_in_whole,
+      rounding_method: self.class.default_rounding_method,
+      currency:        self.class.default_currency,
+    }.merge(options)
+
+    @cents_in_whole  = opts[:cents_in_whole]
+    @decimal_places  = decimal_places(@cents_in_whole)
+    @rounding_method = opts[:rounding_method]
+    @currency        = opts[:currency]
+    nil
+  end
+
+  def decimal_places(cents_in_whole)
+    bd(Math.log10(cents_in_whole)).round(0, BigDecimal::ROUND_UP).to_i
+  end
+
+  def reject_incompatible_currency(value)
+    unless currency == value.currency
+      raise IncompatibleCurrency, "#{value.currency} != #{currency}"
+    end
+  rescue NoMethodError
+  end
+
+  CURRENCY_AWARE_METHODS.each do |mth|
+    old_mth = :"old_#{mth}"
+    alias_method old_mth, mth
+    private(old_mth)
+
+    define_method(mth) do |value|
+      reject_incompatible_currency(value)
+      send(old_mth, value)
+    end
+  end
+
+end

data/lib/cash.rb

@@ -0,0 +1 @@
+require 'cash/cash'

data/test/test_cash.rb

@@ -0,0 +1,293 @@
+require 'minitest/autorun'
+require 'bigdecimal'
+require 'cash'
+
+class TestCash < MiniTest::Unit::TestCase
+
+  def teardown
+    Cash.reset_defaults
+  end
+
+  def test_default_cents_in_whole
+    Cash.default_cents_in_whole = 10
+
+    rs = Cash.new(100)
+    assert_equal "10.0", rs.to_s
+  end
+
+  def test_default_rounding_method
+    Cash.default_rounding_method = BigDecimal::ROUND_DOWN
+
+    rs = Cash.new(1.9)
+    assert_equal 1, rs.cents
+  end
+
+  def test_default_currency
+    Cash.default_currency = :usd
+
+    rs = Cash.new(100)
+    assert_equal :usd, rs.currency
+  end
+
+  def test_new
+    rs = Cash.new(100)
+    assert_equal 100, rs.cents
+    assert_equal nil, rs.currency
+  end
+
+  def test_new_with_default_rounding_method
+    rs = Cash.new(2.5)
+    assert_equal 3, rs.cents
+  end
+
+  def test_new_with_rounding_method
+    rs = Cash.new(2.5, rounding_method: BigDecimal::ROUND_HALF_EVEN)
+    assert_equal 2, rs.cents
+  end
+
+  def test_new_with_currency
+    rs = Cash.new(0, currency: :usd)
+    assert_equal :usd, rs.currency
+  end
+
+  def test_plus_with_Cash_Cash
+    rs = Cash.new(6) + Cash.new(4)
+    assert_equal Cash.new(10), rs
+  end
+
+  def test_plus_with_Cash_Cash_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) + Cash.new(4, currency: :usd)
+    end
+  end
+
+  def test_minus_with_Cash_Cash
+    rs = Cash.new(6) - Cash.new(4)
+    assert_equal Cash.new(2), rs
+  end
+
+  def test_minus_with_Cash_Cash_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) - Cash.new(4, currency: :usd)
+    end
+  end
+
+  def test_multiple_with_Cash_Numeric
+    rs = Cash.new(6) * 2
+    assert_equal Cash.new(12), rs
+  end
+
+  def test_divide_with_Cash_Cash
+    rs = Cash.new(6) / Cash.new(4)
+    assert_equal BigDecimal("1.5"), rs
+  end
+
+  def test_divide_with_Cash_Cash_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) / Cash.new(4, currency: :usd)
+    end
+  end
+
+  def test_divide_with_Cash_Numeric
+    rs = Cash.new(6) / 2
+    assert_equal Cash.new(3), rs
+  end
+
+  def test_modulo_with_Cash_Cash
+    rs = Cash.new(6) % Cash.new(4)
+    assert_equal Cash.new(2), rs
+  end
+
+  def test_modulo_with_Cash_Cash_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) % Cash.new(4, currency: :usd)
+    end
+  end
+      
+  def test_modulo_with_Cash_Numeric
+    rs = Cash.new(6) % 4
+    assert_equal Cash.new(2), rs
+  end
+
+  def test_divmod_with_Cash_Cash
+    rs = Cash.new(6).divmod(Cash.new(4))
+    assert_equal [BigDecimal("1"), Cash.new(2)], rs
+  end
+
+  def test_divmod_with_Cash_Cash_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6).divmod(Cash.new(4, currency: :usd))
+    end
+  end
+
+  def test_divmod_with_Cash_Numeric
+    rs = Cash.new(6).divmod(4)
+    assert_equal [Cash.new(1), Cash.new(2)], rs
+  end
+
+  def test_equal_to_when_equal_to
+    rs = Cash.new(6) == Cash.new(6)
+    assert true
+  end
+
+  def test_equal_to_when_not_equal_to
+    rs = Cash.new(6) == Cash.new(4)
+    refute false
+  end
+
+  def test_equal_to_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) == Cash.new(6, currency: :usd)
+    end
+  end
+
+  def test_compare_when_greater_than
+    rs = Cash.new(6) <=> Cash.new(4)
+    assert_equal 1, rs
+  end
+
+  def test_compare_when_less_than
+    rs = Cash.new(4) <=> Cash.new(6)
+    assert_equal -1, rs
+  end
+
+  def test_compare_when_equal_to
+    rs = Cash.new(6) <=> Cash.new(6)
+    assert_equal 0, rs
+  end
+
+  def test_compare_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) <=> Cash.new(6, currency: :usd)
+    end
+  end
+
+  def test_greater_than_when_greater_than
+    rs = Cash.new(6) > Cash.new(4)
+    assert true
+  end
+
+  def test_greater_than_when_less_than
+    rs = Cash.new(4) > Cash.new(6)
+    refute false
+  end
+
+  def test_greater_than_when_equal_to
+    rs = Cash.new(6) > Cash.new(6)
+    refute false
+  end
+
+  def test_greater_than_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) > Cash.new(6, currency: :usd)
+    end
+  end
+
+  def test_less_than_when_greater_than
+    rs = Cash.new(6) < Cash.new(4)
+    refute false
+  end
+
+  def test_less_than_when_less_than
+    rs = Cash.new(4) < Cash.new(6)
+    assert true
+  end
+
+  def test_less_than_when_equal_to
+    rs = Cash.new(6) < Cash.new(6)
+    refute false
+  end
+
+  def test_less_than_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) < Cash.new(6, currency: :usd)
+    end
+  end
+
+  def test_greater_than_or_equal_to_when_greater_than
+    rs = Cash.new(6) >= Cash.new(4)
+    assert true
+  end
+
+  def test_greater_than_or_equal_to_when_less_than
+    rs = Cash.new(4) >= Cash.new(6)
+    refute false
+  end
+
+  def test_greater_than_or_equal_to_when_equal_to
+    rs = Cash.new(6) >= Cash.new(6)
+    assert true
+  end
+
+  def test_greater_than_or_equal_to_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) >= Cash.new(6, currency: :usd)
+    end
+  end
+
+  def test_less_than_or_equal_to_when_greater_than
+    rs = Cash.new(6) <= Cash.new(4)
+    refute false
+  end
+
+  def test_less_than_or_equal_to_when_less_than
+    rs = Cash.new(4) <= Cash.new(6)
+    assert true
+  end
+
+  def test_less_than_or_equal_to_when_equal_to
+    rs = Cash.new(6) <= Cash.new(6)
+    assert true
+  end
+
+  def test_less_than_or_equal_to_with_different_currencies
+    assert_raises Cash::IncompatibleCurrency do
+      Cash.new(6) <= Cash.new(6, currency: :usd)
+    end
+  end
+    
+  def test_to_s
+    assert_equal "0.00", Cash.new(0  ).to_s
+    assert_equal "0.01", Cash.new(1  ).to_s
+    assert_equal "0.10", Cash.new(10 ).to_s
+    assert_equal "1.00", Cash.new(100).to_s
+    assert_equal "1.01", Cash.new(101).to_s
+    assert_equal "1.10", Cash.new(110).to_s
+  end
+
+  def test_to_s_with_cents_in_whole
+    assert_equal "0",     Cash.new(0,    cents_in_whole: 1   ).to_s
+    assert_equal "1",     Cash.new(1,    cents_in_whole: 1   ).to_s
+    assert_equal "0.4",   Cash.new(4,    cents_in_whole: 5   ).to_s
+    assert_equal "1.0",   Cash.new(5,    cents_in_whole: 5   ).to_s
+    assert_equal "0.9",   Cash.new(9,    cents_in_whole: 10  ).to_s
+    assert_equal "1.0",   Cash.new(10,   cents_in_whole: 10  ).to_s
+    assert_equal "0.99",  Cash.new(99,   cents_in_whole: 100 ).to_s
+    assert_equal "1.00",  Cash.new(100,  cents_in_whole: 100 ).to_s
+    assert_equal "0.999", Cash.new(999,  cents_in_whole: 1000).to_s
+    assert_equal "1.000", Cash.new(1000, cents_in_whole: 1000).to_s
+  end
+
+  def test_to_f
+    assert_equal 0.0,  Cash.new(0  ).to_f
+    assert_equal 0.01, Cash.new(1  ).to_f
+    assert_equal 0.1,  Cash.new(10 ).to_f
+    assert_equal 1.0,  Cash.new(100).to_f
+    assert_equal 1.01, Cash.new(101).to_f
+    assert_equal 1.1,  Cash.new(110).to_f
+  end
+
+  def test_to_f_with_cents_in_whole
+    assert_equal 0.0,   Cash.new(0,    cents_in_whole: 1   ).to_f
+    assert_equal 1.0,   Cash.new(1,    cents_in_whole: 1   ).to_f
+    assert_equal 0.4,   Cash.new(4,    cents_in_whole: 5   ).to_f
+    assert_equal 1.0,   Cash.new(5,    cents_in_whole: 5   ).to_f
+    assert_equal 0.9,   Cash.new(9,    cents_in_whole: 10  ).to_f
+    assert_equal 1.0,   Cash.new(10,   cents_in_whole: 10  ).to_f
+    assert_equal 0.99,  Cash.new(99,   cents_in_whole: 100 ).to_f
+    assert_equal 1.0,   Cash.new(100,  cents_in_whole: 100 ).to_f
+    assert_equal 0.999, Cash.new(999,  cents_in_whole: 1000).to_f
+    assert_equal 1.0,   Cash.new(1000, cents_in_whole: 1000).to_f
+  end
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: cashrb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Shane Emmons
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-02-23 00:00:00.000000000 -05:00
+default_executable: 
+dependencies: []
+description: Dead simple gem to work with Money/Currency without the hassle of Floats
+email:
+- semmons99@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cash/cash.rb
+- lib/cash.rb
+- test/test_cash.rb
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- .gemtest
+- cashrb.gemspec
+has_rdoc: true
+homepage: http://github.com/semmons99/cashrb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements:
+- minitest
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Dead simple gem to work with Money/Currency without the hassle of Floats
+test_files: []