more_money 0.0.10 → 0.1.1

data/Manifest.txt

@@ -8,5 +8,7 @@ lib/more_money.rb
 lib/more_money/version.rb
 lib/more_money/core_extensions.rb
 lib/more_money/more_money.rb
+lib/more_money/price.rb
 test/test_helper.rb
 test/more_money_test.rb
+test/price_test.rb

data/lib/more_money/core_extensions.rb

@@ -2,9 +2,18 @@
 #   100.to_money => #<Money @cents=10000>
 #   100.37.to_money => #<Money @cents=10037>
 class Numeric
-  def to_money
-    Money.new(self * 100)
+
+  def to_money(currency = nil)
+    args = [(self * 100), currency].compact
+    Money.new(*args)
+  end
+
+  def to_price(opts = {})
+    money = to_money(opts[:currency])
+    args = [opts[:tax_code], opts[:tax_inclusive]].compact
+    Price.new(money.cents, money.currency, *args)
   end
+
 end
 
 # Allows Writing of '100'.to_money for +String+ types
@@ -12,10 +21,11 @@ end
 #   '100'.to_money => #<Money @cents=10000>
 #   '100.37'.to_money => #<Money @cents=10037>
 class String
-  def to_money
+
+  def to_money(currency = nil)
     # Get the currency
     matches = scan(/([A-Z]{2,3})/)
-    currency = matches[0] ? matches[0][0] : MoreMoney::Money.default_currency
+    currency ||= matches[0] ? matches[0][0] : MoreMoney::Money.default_currency
     
     # Get the cents amount
     matches = scan(/(\-?\d+(\.(\d+))?)/)
@@ -23,10 +33,19 @@ class String
     
     MoreMoney::Money.new(cents, currency)
   end
+
+  def to_price(opts = {})
+    money = to_money(opts[:currency])
+    args = [opts[:tax_code], opts[:tax_inclusive]].compact
+    Price.new(money.cents, money.currency, *args)
+  end
+
 end
 
 class NilClass
+
   def to_money(currency = MoreMoney::Money.default_currency)
     MoreMoney::Money.new(nil, currency)
   end
+
 end

data/lib/more_money/more_money.rb

@@ -121,7 +121,7 @@ module MoreMoney
     #
     def self.curr_symbol(currency = Money.default_currency)
       check_currency(currency)
-      CURRENCIES[currency][:symbol]
+      CURRENCIES[currency][:symbol].dup
     end
 
     # Creates a new money object. 
@@ -244,7 +244,7 @@ module MoreMoney
         newstr = []
         3.times { newstr << formatted.shift } unless rules.include?(:no_cents)
         formatted.each_with_index do |num, index|
-          newstr << ',' if index !=0 && index % 3 == 0
+          newstr << ',' if index !=0 && num != '-' && index % 3 == 0
           newstr << num
         end
         formatted = newstr.to_s.reverse!

data/lib/more_money/price.rb

@@ -0,0 +1,236 @@
+module MoreMoney
+
+  class TaxMissingMethod < StandardError# :nodoc:
+  end
+
+  class PricesWithDifferentTaxesCompared < StandardError# :nodoc:
+  end
+
+  class PricesWithDifferentInclusiveClause < StandardError# :nodoc:
+  end
+
+  class PriceInvalidTax < StandardError# :nodoc:
+  end
+
+  class Price
+
+    include Comparable
+
+    TAXES = {}
+
+    #the current default tax
+    def self.default_tax
+      @default_tax
+    end
+
+
+    #set the default tax
+    #  MoreMoney::Money.default_tax_rate = 'GBP'
+    #
+    def self.default_tax=(tax_code)
+      @default_tax = tax_code
+    end
+
+    #show if by default prices are tax inclusive/exclusive
+    def self.default_inclusive
+      @default_inclusive
+    end
+
+    #set if by default prices are tax inclusive
+    def self.default_inclusive=(default_inclusive)
+      raise ArgumentError, "default inclusive can be only true or false" unless [TrueClass, FalseClass].member?(default_inclusive.class)
+      @default_inclusive = default_inclusive
+    end
+
+    #adds a tax to the set of available ones.
+    #
+    #  MoreMoney::Price.add_tax(tax_obj)
+    #
+    #a tax object is a generic ruby object that responds to the methods
+    #  
+    #  * apply -> lamba that applies the tax to a net value
+    #  * discount -> lambda that drops the tax from the gross value
+    #  * code -> short code for the tax
+    #  * formatted code -> code for display purpouse
+    #
+    def self.add_tax(tax)
+      case tax
+        when Hash
+          TAXES[tax[:code]] = tax[:taxes].map { |t| TAXES[t] }
+      else
+          mandatory_methods = [:apply, :discount, :code, :formatted_code]
+          mandatory_methods.each do |m|
+            raise TaxMissingMethod, "#{m} method is not defined by #{tax.inspect}" unless tax.respond_to? m
+          end
+        TAXES[tax.code] = tax
+      end
+    end
+
+    def self.check_tax(tax_code)
+      raise PriceInvalidTax, "#{tax_code} is not defined as a tax" unless TAXES.key?(tax_code)
+    end
+
+    attr_reader :money, :tax, :tax_inclusive, :tax_amounts, :tax_code
+
+    # Creates a new price object. 
+    #
+    #  Price.new(100) 
+    # 
+    def initialize(cents, currency = Money.default_currency, tax = Price.default_tax, tax_inclusive = Price.default_inclusive)
+      @money = Money.new(cents, currency)
+      self.class.check_tax(tax)
+      @tax = TAXES[tax]
+      @tax_code = tax
+      @tax_amounts = []
+      @tax_inclusive = tax_inclusive
+      @tax_inclusive ? discount_tax : apply_tax
+    end
+
+    def tax_inclusive?
+      tax_inclusive
+    end
+
+    #returns a Money object with the net amount
+    def net
+      tax_inclusive ? tax_amounts.inject(gross) { |sum, a| sum - a[1] } : money
+    end
+
+    #returns a Money object with the gross amount
+    def gross
+      tax_inclusive ? money : tax_amounts.inject(net) { |sum, a| sum + a[1] }
+    end
+
+    def cents
+      money.cents
+    end
+
+    #currency
+    def currency
+      money.currency
+    end
+
+    # Do two money objects equal? Only works if both objects are of the same currency
+    def eql?(other_price)
+      raise_different_tax(other_price)
+      net == other_price.net
+    end
+
+    def <=>(other_price)
+      raise_different_tax(other_price)
+      net <=> other_price.net
+    end
+
+    %w(+ -).each do |operator|
+      class_eval <<-EOE
+        def #{operator}(other_price)
+          raise_different_tax(other_price)
+          raise_different_inclusive(other_price)
+          if tax_inclusive == other_price.tax_inclusive
+            new_money = money #{operator} other_price.money
+            Price.new(new_money.cents, currency, tax_code, tax_inclusive)
+          else
+            new_money = net #{operator} other_price.net
+            Price.new(new_money.cents, currency, tax_code, false)
+          end
+        end
+      EOE
+    end
+
+    def -@
+      self.class.new(-cents, currency, tax_code, tax_inclusive)
+    end
+
+    # multiply money by fixnum
+    def *(fixnum)
+      Price.new(money.cents * fixnum, currency, tax_code, tax_inclusive)
+    end
+
+    # divide money by fixnum
+    def /(fixnum)
+      Price.new(money.cents / fixnum, currency, tax_code, tax_inclusive)
+    end
+
+    # Test if the price is zero
+    def zero?
+      return money.zero?
+    end
+
+    # Test if the price is zero
+    def no_cost?
+      return (money.zero? || money.cents.nil?)
+    end
+
+    # Format the price according rules
+    #
+    # Currently supported are :with_tax_inclusion, :with_tax
+    # All the extra rules specified will be passed to the money object
+    #
+    def format(*rules)
+      rules = rules.flatten
+      price_string = []
+      price_string << (tax.formatted_code) if rules.delete(:with_tax)
+      price_string << (tax_inclusive ? 'inc.' : 'exc.') if rules.delete(:with_tax_inclusion)
+      ([money.format(rules)] + price_string).join(' ')
+    end
+
+    # Money.new(100, 'USD').to_s => "1.00"
+    def to_s
+      cents.nil? ? '' : sprintf("%.2f", money.cents.to_f / 100  )
+    end
+
+    # Conversation to self
+    def to_price
+      self
+    end  
+
+    private
+
+    def raise_different_tax(other_price)
+      raise PricesWithDifferentTaxesCompared, "Can not compare prices with different taxation" unless tax == other_price.tax
+    end
+
+    def raise_different_inclusive(other_price)
+      raise PricesWithDifferentInclusiveClause, "Can not add/subtract prices with different inclusive clause.\n Look at Price.sum method" unless tax_inclusive == other_price.tax_inclusive
+    end
+
+    def apply_tax(tax_to_apply = @tax)
+      if tax_to_apply.is_a? Array
+        tax_to_apply.each { |t| apply_tax(t) }
+      else
+        @tax_amounts << [tax_to_apply, tax_to_apply.apply.call(self)]
+      end
+    end
+
+    def discount_tax(tax_to_discount = @tax)
+      if tax_to_discount.is_a? Array
+        tax_to_discount.reverse.each { |t| discount_tax(t) }
+      else
+        @tax_amounts << [tax_to_discount, tax_to_discount.discount.call(self)]
+      end
+    end
+
+  end
+
+  #class methods for price
+  
+  class Price
+
+    #returns an array with the sum of the given arguments grouped by tax code
+    #it can only sum
+    def self.partial_sum(*args)
+      return nil if (to_sum = args.flatten.compact).size == 0
+      raise PricesWithDifferentInclusiveClause unless to_sum.collect { |p| p.tax_inclusive }.uniq.size == 1
+      same_tax_groups = to_sum.collect { |p| p.tax }.uniq.map { |tax| to_sum.select { |p| p.tax == tax } }
+      same_tax_group_sums = same_tax_groups.map { |g| g.inject(Price.new(0, g.first.currency, g.first.tax_code, g.first.tax_inclusive)) { |tot, p| tot + p } }
+    end
+
+    def self.sum(*args)
+      return nil if args.flatten.size == 0
+      type = args.last.is_a?(Symbol) ? args.pop : :gross
+      partial = [true, false].map { |t| partial_sum(args.flatten.select { |a| a.tax_inclusive == t }) }.flatten.compact
+      partial.inject(Money.new(0, partial.first.currency)) { |tot, p| tot + p.send(type == :gross ? :gross : :net) }
+    end
+
+  end
+  
+end

data/lib/more_money/version.rb

@@ -1,8 +1,8 @@
 module MoreMoney #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    TINY  = 10
+    MINOR = 1
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/more_money_test.rb

@@ -68,6 +68,17 @@ class MoreMoneyTest < Test::Unit::TestCase
     assert_equal "free as in a beer", Money.gb_pound(0).format
   end
 
+  def test_format_negative_amount
+    ten_pounds = Money.gb_pound(-1000)
+    hundred_pounds = Money.gb_pound(-10000)
+    hundred_thousand_pounds = Money.gb_pound(-10000000)
+    million_pounds = Money.gb_pound(-100000000)
+    assert_equal "£ -10.00", ten_pounds.format(:with_thousands)
+    assert_equal "£ -100.00", hundred_pounds.format(:with_thousands)
+    assert_equal "£ -100,000.00", hundred_thousand_pounds.format(:with_thousands)
+    assert_equal "£ -1,000,000.00", million_pounds.format(:with_thousands)
+  end
+
   def test_nil
     a = Money.new(nil)
     assert_equal nil, a.cents
@@ -144,4 +155,12 @@ class MoreMoneyTest < Test::Unit::TestCase
     assert_equal [ 100, 'GBP'], c.exchange_to('GBP').instance_eval("[cents, currency]")
     assert_raise(MoreMoney::MoneyMissingExchangeRate) { d.exchange_to('GBP') }
   end
+
+  def test_multiple_currency_protected
+    10.times do
+      assert_equal '£ 10.00', Money.new(1000, 'GBP').format(:with_thousands)
+      Money.curr_symbol('GBP') << ' '
+    end
+  end
+
 end

data/test/price_test.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+include MoreMoney
+
+Tax = Struct.new(:apply, :discount, :code, :formatted_code, :rate)
+
+class MoreMoneyPriceTest < Test::Unit::TestCase
+
+  def setup
+    Money.load_std_currencies
+    Money.default_currency = 'GBP'
+    define_taxes
+    Price.default_inclusive = false
+    @net_price = Price.new(1000)
+    @gross_price = Price.new(1175, 'GBP', 'UK_175', true)
+    @price_net_quebec = Price.new(10000, 'GBP', 'CAD_QUEBEC')
+    @price_gross_quebec = Price.new(11395, 'GBP', 'CAD_QUEBEC', true)
+    @price_net_ontario = Price.new(10000, 'GBP', 'CAD_ONTARIO')
+    @price_gross_ontario = Price.new(11400, 'GBP', 'CAD_ONTARIO', true)
+  end
+  
+  def test_simple_tax
+    price = Price.new(1000)
+    assert_equal 1000, price.money.cents
+    assert_equal 1175, price.gross.cents
+    price2 = Price.new(1175, 'GBP', 'UK_175', true)
+    assert_equal 1175, price2.gross.cents
+    assert_equal 1000, price2.net.cents
+  end
+
+  def test_tax_amounts
+    assert_equal [600, 795], @price_net_quebec.tax_amounts.collect { |a| a[1].cents }
+    assert_equal [795, 600], @price_gross_quebec.tax_amounts.collect { |a| a[1].cents }
+    assert_equal [600, 800], @price_net_ontario.tax_amounts.collect { |a| a[1].cents }
+    assert_equal [800, 600], @price_gross_ontario.tax_amounts.collect { |a| a[1].cents }
+  end
+
+
+  def test_taxes_on_taxes_gross
+    assert_equal 11395, @price_net_quebec.gross.cents
+    assert_equal 11395, @price_gross_quebec.gross.cents
+    assert_equal 11400, @price_net_ontario.gross.cents
+    assert_equal 11400, @price_gross_ontario.gross.cents
+  end
+
+  def test_taxes_on_taxes_net
+    assert_equal 10000, @price_net_quebec.net.cents
+    assert_equal 10000, @price_gross_quebec.net.cents
+    assert_equal 10000, @price_net_ontario.net.cents
+    assert_equal 10000, @price_gross_ontario.net.cents
+  end
+
+  def test_core_extention_number
+    assert_equal Price.new(1000), 10.to_price
+    assert_equal @price_net_quebec, 100.to_price(:currency => 'GBP', :tax_code => 'CAD_QUEBEC')
+    assert_equal @price_gross_quebec, 113.95.to_price(:currency => 'GBP', :tax_code => 'CAD_QUEBEC', :tax_inclusive => true)
+  end
+
+  def test_core_extention_string
+    assert_equal Price.new(1000), '10.00'.to_price
+    assert_equal @price_net_quebec, '100.00'.to_price(:currency => 'GBP', :tax_code => 'CAD_QUEBEC')
+    assert_equal @price_gross_quebec, '113.95'.to_price(:currency => 'GBP', :tax_code => 'CAD_QUEBEC', :tax_inclusive => true)
+  end
+
+  def test_unary_minus
+    np = - @price_net_quebec
+    assert_equal (- @price_net_quebec.cents), np.cents
+    assert_equal 100.to_price(:currency => 'GBP', :tax_code => 'CAD_QUEBEC'), (- np)
+  end
+
+  #def test_rounding
+  #  (100..10000).each do |n|
+  #    p "testing #{n}"
+  #    p = Price.new(n, 'GBP', 'UK_175', true)
+  #    assert_equal n, p.money.cents
+  #    assert_equal p.money.cents, Price.new(p.net.cents).gross.cents
+  #  end
+  #end
+
+  def test_sum
+    to_sum =  [@net_price, @price_net_quebec, @price_net_ontario]
+    assert_equal Price.sum(to_sum), Price.sum(*to_sum)
+    assert_equal 21000, Price.sum(to_sum, :net).cents
+    assert_equal 23970, Price.sum(to_sum, :gross).cents
+    assert_equal 'GBP', Price.sum(to_sum, :net).currency
+    to_sum =  [@net_price, @price_net_quebec, @price_net_ontario, @price_gross_ontario]
+    assert_equal Price.sum(to_sum), Price.sum(*to_sum)
+    assert_equal 31000, Price.sum(to_sum, :net).cents
+    assert_equal 35370, Price.sum(to_sum, :gross).cents
+    assert_equal 'GBP', Price.sum(to_sum, :net).currency
+    to_sum =  [@net_price, @price_net_quebec, @price_net_ontario, @price_net_ontario]
+    assert_equal Price.sum(to_sum), Price.sum(*to_sum)
+    assert_equal 31000, Price.sum(to_sum, :net).cents
+    assert_equal 35370, Price.sum(to_sum, :gross).cents
+    assert_equal 'GBP', Price.sum(to_sum, :net).currency
+  end
+
+  def test_partial_sum
+    to_sum =  [@net_price, @price_net_quebec, @price_net_ontario]
+    assert_equal Price.partial_sum(to_sum), Price.partial_sum(*to_sum)
+    #assert_equal 21000, Price.partial_sum(to_sum).cents
+    #assert_equal 23970, Price.partial_sum(to_sum).cents
+    #assert_equal 'GBP', Price.partial_sum(to_sum).currency
+  end
+  
+  private
+
+  def define_taxes
+
+    revert_rate = lambda { |rate| rate / (1 + rate) }
+    gb_std = Tax.new
+    gb_std.rate = 0.175
+    gb_std.apply = lambda { |price| price.net * 0.175 }
+    gb_std.discount = lambda { |price| price.gross * revert_rate.call(0.175) }
+    gb_std.code = "UK_175"
+    gb_std.formatted_code = "VAT 17.5%"
+    Price.add_tax(gb_std)
+
+    cad_gst = Tax.new
+    cad_gst.rate = 0.06
+    cad_gst.apply = lambda { |price| price.net * cad_gst.rate }
+    cad_gst.discount = lambda { |price| price.net * revert_rate.call(cad_gst.rate) }
+    cad_gst.code = "CAD_GST"
+    cad_gst.formatted_code = "GST 6%"
+    Price.add_tax(cad_gst)
+
+    cad_pst_quebec = Tax.new
+    cad_pst_quebec.rate = 0.075
+    cad_pst_quebec.apply = lambda { |price| price.gross * 0.075 }
+    cad_pst_quebec.discount = lambda { |price| price.net * revert_rate.call(0.075) }
+    cad_pst_quebec.code = "CAD_PST_QUEBEC"
+    cad_pst_quebec.formatted_code = "PST Quebec 7.5%"
+    Price.add_tax(cad_pst_quebec)
+
+    cad_pst_ontario = Tax.new
+    cad_pst_ontario.rate = 0.08
+    cad_pst_ontario.apply = lambda { |price| price.net * 0.08 }
+    cad_pst_ontario.discount = lambda { |price| price.net * 0.08 / (1 + 0.08 + Price::TAXES['CAD_GST'].rate) }
+    cad_pst_ontario.code = "CAD_PST_ONTARIO"
+    cad_pst_ontario.formatted_code = "PST Ontario 8%"
+    Price.add_tax(cad_pst_ontario)
+
+    cad_quebec = {:code => 'CAD_QUEBEC', :taxes => ['CAD_GST', 'CAD_PST_QUEBEC']}
+    Price.add_tax(cad_quebec)
+    cad_ontario = {:code => 'CAD_ONTARIO', :taxes => ['CAD_GST', 'CAD_PST_ONTARIO']}
+    Price.add_tax(cad_ontario)
+    Price.default_tax = gb_std.code
+  end
+
+end

metadata

@@ -1,33 +1,28 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: more_money
 version: !ruby/object:Gem::Version 
-  version: 0.0.10
-date: 2007-02-14 00:00:00 +00:00
-summary: handles money objects in any currency using just integer as backend
-require_paths: 
-- lib
-email: use rubyforge to contact
-homepage: http://moremoney.rubyforge.org
-rubyforge_project: moremoney
-description: handles money objects in any currency using just integer as backend
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.1.1
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Paolo Negri
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-20 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: handles money objects in any currency using just integer as backend
+email: use rubyforge to contact
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- CHANGELOG.txt
+- README.txt
 files: 
 - Manifest.txt
 - CHANGELOG.txt
@@ -39,19 +34,37 @@ files:
 - lib/more_money/version.rb
 - lib/more_money/core_extensions.rb
 - lib/more_money/more_money.rb
+- lib/more_money/price.rb
 - test/test_helper.rb
 - test/more_money_test.rb
-test_files: 
-- test/more_money_test.rb
-rdoc_options: []
-
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+- test/price_test.rb
+has_rdoc: true
+homepage: http://moremoney.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: []
 
-dependencies: []
-
+rubyforge_project: moremoney
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: handles money objects in any currency using just integer as backend
+test_files: 
+- test/more_money_test.rb
+- test/price_test.rb