vatcalc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e13c738c08997c3f9eed7520fca91a0ce0d8396e
+  data.tar.gz: 03c1ab0f632e87dd5211887c5a09376b57e6925c
+SHA512:
+  metadata.gz: 77a06947b030edb11ce582f640d589318de1d99c37159088491348bcaf4ef9945c81ab3a556a8a9b64df4ecfdfeb263a267b905db99a418f34c474368a0b6eaa
+  data.tar.gz: 86fbacf991bdb51c976e6a3d8e9b036390d9df8baf15a6113d2f48e85dbf57f054409d0d32851097eea552f18edd090e2a48cbfaf5cf988d455a8aebd56bb34d

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.15.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at TODO: Write your email address. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in vatcalc.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 TODO: Write your name
+
+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,189 @@
+# Vatcalc
+
+A gem to calculate VAT of multiple products with differently VAT percentages.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vatcalc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vatcalc
+
+## Include
+
+Include Vatcalc::ActsAsBillElement in your models / Classes
+
+```ruby
+
+class Product < ActiveRecord::Base
+  include Vatcalc::ActsAsBillElement
+  
+  acts_as_bill_element(amount: price, vat_percentage: :my_vat_percentage_field, currency: "EUR", prefix: :bill)
+  
+  #you can pass the following key value pairs
+  
+  # amount: the price for the product [required]
+  #     you can pass:
+  #         symbol => for a method 
+  #         lambda => ->(obj) {obj.price * 3}
+  #         Float, Integer for a fix amount.
+  #     NOTE: 
+  #         if the value is an Integer it is assumed that the amount is given in cents.
+  # 
+  #
+  # currency: 
+  #     self-descriptive [optional] 
+  #     standard value is the money default currency
+  #     => https://github.com/RubyMoney/money
+  #
+  #     you can pass: 
+  #         symbol => for a method 
+  #         lambda => ->(obj) {obj.other_object.find_my_currency}
+  #         String => "EUR", "USD"
+  #
+  #
+  # vat_percentage: 
+  #     the VAT percentage for the given product. [optional]
+  #     This option will be ignored if you set the service option to true. +see below+
+  #     Default is Vatcalc.vat_percentage => @see section "Configuration"
+  #     you can pass: 
+  #         symbol => for a method 
+  #         lambda => ->(obj) {obj.find_my_currency}
+  #         String => "EUR", "USD"
+  #     NOTE: 
+  #         if the value is between 1 and 100 the value will be divided by 100. 
+  #         For example if you pass a value like 19 it is assumed that you mean 19% 
+  #         if the value is between 0 and 100 the value won't be divided. 
+  #
+  # prefix: the prefix to call gross,vat,net,vat_splitted, and vat_percentage on your object.
+  #        @see below.
+  #
+  #
+  # net: 
+  #     is the amount given as net amount ? [optional]
+  #     Default => false
+  #
+  #
+  #
+  # service:
+  #     is the object a service like a Coupon or a Fee ? If this option is set to true
+  #     the object has not a fix VAT percentage.
+  #     the vat will be calculated by the non-service net rates in a bill.
+  
+  
+  ....
+  
+  #now you can call 
+  product.bill_gross #=> #<Money fractional:1000 currency:EUR>
+  product.bill_net #=> #<Money fractional:840 currency:EUR> 
+  product.bill_vat #=> #<Money fractional:160 currency:EUR> 
+  
+  
+  product.bill_vat_splitted #=> {#<Vatcalc::VATPercentage vat_percentage:19%> => #<Money fractional:160 currency:EUR>}
+  # the key in the result hash is a Vatcalc::VATPercentage object it responds to to_f, to_s, to_d
+  # @example
+  #     vp.to_s => "19%"
+  #     vp.to_f => 1.19
+  #     vp.to_d => #<BigDecimal:7f7ee20989a0,'0.119E1',18(36)>
+  
+  
+end
+```
+
+## Bill
+
+Creating a new bill object
+```ruby
+
+bill = Vatcalc::Bill.new(elements: [product1,product2,fee])
+
+#NOTE: 
+#    If you pass an Array of 2D arrays it is assumed that the first element in 2D Array is the object
+#    and the second element is the quantity.
+#    @example elements: 
+#            [ 
+#                [ product1, 2 ],
+#                [ product2, 1 ] 
+#            ]
+
+#now you can call
+bill.gross #=> #<Money fractional:15000 currency:EUR>
+bill.vat #=>  #<Money fractional:1925 currency:EUR>
+bill.net #=> #<Money fractional:13075 currency:EUR>
+
+# if you only want to get amounts of the base.
+bill.base.gross
+...
+
+# if you only want to get amounts of the services.
+bill.services.gross
+...
+
+
+
+bill.vat_splitted #=> 
+#
+#   {
+#       #<Vatcalc::VATPercentage vat_percentage:7%> => #<Money fractional:325 currency:EUR>,
+#       #<Vatcalc::VATPercentage vat_percentage:19%> => #<Money fractional:1600 currency:EUR>
+#   } 
+
+# To get the vat rates 
+# These vat rates are the net sums of the non-service elements grouped by vat_percentage and divided by total 
+# non-service elements net amount
+
+bill.vat_rates # => 
+#   {
+#       #<Vatcalc::VATPercentage vat_percentage:19%>=>0.6424,
+#       #<Vatcalc::VATPercentage vat_percentage:7%>=>0.3576,
+#   }
+
+## NOTE: Each service Element will be taxed by these rates.
+
+
+
+
+bill.each do |obj, quantity, gross, vat, net|
+    # NOTE: gross, vat, net are already multiplied by quantity
+    # do stuff .. 
+end
+
+
+
+
+
+```
+
+
+## Configuration
+
+```ruby
+gem 'vatcalc'
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/vatcalc. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Vatcalc project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/vatcalc/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "vatcalc"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/vatcalc.rb

@@ -0,0 +1,51 @@
+require "vatcalc/version"
+require 'active_support'
+require 'active_support/core_ext'
+
+require "vatcalc/util"
+require "vatcalc/vat_percentage"
+
+require "vatcalc/gnv"
+require "vatcalc/base_element"
+
+require "vatcalc/service_element"
+require "vatcalc/bill"
+
+require "vatcalc/acts_as_bill_element"
+
+module Vatcalc
+  mattr_accessor :currency
+
+  class << self
+
+    def vat_percentage
+      @vat_percentage
+    end
+
+    def vat_percentage=(v)
+      @vat_percentage = VATPercentage.new(v)
+    end
+
+    alias :percentage :vat_percentage
+    alias :percentage= :vat_percentage=
+
+
+    def vat_of(v,**args)
+      BaseElement.new(v,**args).vat
+    end
+
+    def net_of(v,**args)
+      BaseElement.new(v,**args).net
+    end
+
+    def gross_of(v,**args)
+      BaseElement.new(v,**args).gross
+    end
+
+  end
+
+  #German Standard Settings
+  self.currency = "EUR"
+  self.vat_percentage= 19.00
+
+end

data/lib/vatcalc/acts_as_bill_element.rb

@@ -0,0 +1,57 @@
+module Vatcalc
+
+
+  def self.acts_as_bill_element?
+    @acts_as_bill_element ||= ->(obj) { obj.class.respond_to?(:acts_as_bill_element) && obj.respond_to?(:as_vatcalc_bill_element) }
+  end
+
+
+  module ActsAsBillElement
+
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def acts_as_bill_element(amount:, service: false, currency: nil, vat_percentage: nil, prefix: :bill, net: false)
+
+        args_to_convert = {amount: amount,currency: currency,net: net}
+        delegators = [:gross,:net,:vat,:vat_splitted]
+
+        if service
+           klass  = Vatcalc::ServiceElement
+        else
+          klass  =  Vatcalc::BaseElement
+          args_to_convert[:vat_percentage] = vat_percentage
+          delegators << :vat_percentage
+        end
+
+
+        delegate *delegators, prefix: prefix, to: :as_vatcalc_bill_element
+        v_name = :@as_vatcalc_bill_element
+
+        define_method(:as_vatcalc_bill_element) do
+          unless instance_variable_get(v_name)
+            args = args_to_convert.inject({}) do |h,(k,v)|
+              case v
+              when Proc
+                h[k] = v.call(self)
+              when Symbol
+                h[k] = send(v)
+              else
+                h[k] = v
+              end
+              h
+            end
+            instance_variable_set v_name, klass.new( args.delete(:amount), **args)
+          end
+          instance_variable_get(v_name)
+        end
+      end
+
+
+    end
+
+
+  end
+end

data/lib/vatcalc/base_element.rb

@@ -0,0 +1,56 @@
+# A Base Element Object inherits from GNV
+#@see Vatcalc::GNV
+#
+# A BaseElement always needs an VAT percentage and an amount
+# if no VAT Percentage is given it takes the default VAT Percentage
+module Vatcalc    
+  class BaseElement < GNV
+
+    include Comparable
+
+
+    attr_reader :vat_percentage
+    alias_method :percentage, :vat_percentage
+    alias_method :vat_p, :vat_percentage
+
+
+    #Initalizes a new Object of an BaseElement
+    #@param amount = [Money,Numeric]
+    #@param options = [Hash]
+    #
+    # Assumes that the amount is a gross value but you can pass a net value as well if you pass the 
+    # option net: true 
+    #
+    #@example 
+    #
+    # => b = BaseElement.new 10.00, vat_percentage: 19, currency: "EUR"
+    #    b.net.to_f = 8.40
+    # => b = BaseElement.new 10.00, vat_percentage: 7,  currency: "USD"
+    #    b.net.to_f = 9.35
+    # => b = BaseElement.new 10.00, vat_percentage: 7,  currency: "USD", net: true
+    # => b.gross = 10.70
+    def initialize(amount,currency: nil, vat_percentage: nil, net: false)
+      @currency = currency || Vatcalc.currency
+      amount = Util.to_money(amount,@currency)
+      vp = Util.to_vat_percentage(vat_percentage)
+      @vector = net ? Vector[amount * vp, amount] : Vector[amount, amount / vp] 
+      @vat_percentage = vp
+      @vat_splitted = {@vat_percentage => vat}
+    end
+
+    def hash
+      #vector comes from GNV
+      [@vector,@vat_percentage].hash
+    end
+
+    def ==(oth)
+      oth.is_a?(BaseElement) && (oth.vector == @vector) && (vat_p == oth.vat_p)
+    end
+
+
+    def inspect
+      "#<#{self.class.name} vat_percentage:#{vat_p} gross:#{gross} net: #{net} vat:#{vat} currency:#{@currency}>"
+    end
+
+  end
+end

data/lib/vatcalc/bill.rb

@@ -0,0 +1,227 @@
+
+module Vatcalc    
+  class Bill 
+
+    include Enumerable
+
+    attr_reader :currency
+    attr_reader :services
+    attr_reader :base
+
+    alias_method :service_elements, :services
+    alias_method :base_elements, :base
+
+    delegate :rates,:rates!,:human_rates,:vat_percentages, to: :@base
+    delegate :each, to: :all
+
+    def initialize(elements: [],currency: nil)
+      @base = Base.new #defined at the bottom
+      @services = Services.new #defined at the bottom
+      @currency = currency
+      insert(elements)
+    end
+
+
+    #inserts one or more element which included the Vatcalc::ActsAsBillElement module
+    #@param obj = [Array,Object]
+    #@result = [Vatcalc::Bill]
+    def insert(obj, quantity = 1) 
+      case obj
+      when Array 
+        return (obj.each { |obj, quantity| insert(obj, quantity)}.last || self)
+      when Vatcalc.acts_as_bill_element? 
+        gnv = obj.as_vatcalc_bill_element
+      else raise ArgumentError.new ("Can't insert a #{obj.class} into #{self}. #{obj.class} must include Vatcalc::ActsAsBillElement")
+      end
+      if (quantity ||= 1) > 0 
+        gnv.source = obj
+        @currency = gnv.currency
+        case gnv
+        when BaseElement
+          @base.insert(gnv,quantity)
+          # if an base element is inserted after services already in here.
+          @services.rates_changed!(@base.rates) if @services.length > 0
+        when ServiceElement
+          @services.insert(gnv,quantity)
+          # the service gets now the rates of the base
+          gnv.change_rates(@base.rates)
+        end
+
+        @base.currency = @currency
+        @services.currency = @currency
+      end
+      self
+    end
+
+    [:gross,:vat,:net].each do |m|
+      define_method(m) { base.send(m) + services.send(m) }
+    end
+
+    def vat_splitted
+      all.vat_splitted
+    end
+
+    def all
+      (base + services) 
+    end
+
+
+    RoundPrecision = 4
+    #will only be used in rspec for test
+    Tolerance = BigDecimal("1E-#{RoundPrecision}")
+    #@see +rates+
+
+    alias_method :percentages, :vat_percentages
+    alias_method :vat_rates, :rates
+    alias_method :elements, :all
+
+    # A GNVCollection consists basically of a an 2D Array of GNV 
+    # GNV Objects +@see Vatcalc::GNV+
+    # It's a helper class to calculate amounts and iterate through 
+    # specific GNV objects.
+    class GNVCollection
+      include Enumerable
+
+      attr_reader :collection
+      attr_accessor :currency
+
+      delegate :length, :first, :last, to: :@collection
+
+      # which class can be inserted in the collection
+      def self.for
+        GNV
+      end
+
+      def initialize(col=[],currency = nil)
+        @collection = col
+        @currency = currency
+      end
+      
+      def insert(gnv,quantity)
+        raise(TypeError.new) unless gnv.is_a?(self.class.for)
+        @currency = gnv.currency
+        @vat_splitted = nil
+        @collection << [gnv,quantity]
+        @gross, @vat, @net = [nil] * 3
+        self
+      end
+
+      def <<(arg)
+        insert(arg,1) 
+      end
+
+      def vat_splitted
+        @vat_splitted ||= @collection.inject(GNV.new(0,0,@currency)){|sum,(gnv,q)| sum += (gnv * q) }.vat_splitted
+      end
+
+      [:gross,:vat,:net].each do |it|
+        define_method(it) { instance_variable_get("@#{it}") || instance_variable_set( "@#{it}", @collection.inject(new_money) {|sum,(gnv,q)| sum += (gnv.send(it) * q) } ) } 
+      end
+
+      def +(other)
+        raise(TypeError.new) unless other.is_a?(GNVCollection)
+        GNVCollection.new(@collection + other.collection,@currency)
+      end
+
+      def each
+        result = []
+        @collection.each do |gnv,quantity|
+          arr = [gnv.source, quantity, gross*quantity, net*quantity, vat*quantity]
+          result << arr
+          yield *arr
+        end
+        result 
+      end
+
+      def each_gnv
+        @collection.each {|gnv,quantity| yield gnv, quantity }
+      end
+
+      private
+
+      def money_hash
+        Hash.new(new_money)
+      end
+
+      def new_money
+        Money.new(0,@currency)
+      end
+
+
+    end
+
+
+    class Base < GNVCollection
+
+      attr_reader :vat_percentages
+
+      def initialize(*args)
+        super 
+        @vat_percentages = Set.new 
+      end
+
+      def self.for
+        BaseElement
+      end
+
+      def insert(gnv,quantity)
+        super
+        @rates = nil
+        @vat_percentages << gnv.vat_p
+        self
+      end
+
+      # Output of rates in form of
+      # key is VAT Percentage and Value is the rate 
+      # "{1.0=>0.0092, 1.19=>0.8804, 1.07=>0.1104}"
+      def rates
+        @rates ||= rates!
+      end
+
+      def rates!
+        @rates = Hash.new(0.00)
+        if net.to_f != 0 
+          left_over = 1.00
+          grouped_amounts = @collection.inject(money_hash){ |h,(gnv,q)| h[gnv.vat_p] += gnv.net * q; h}.sort
+
+          grouped_amounts.each_with_index do |(vp,amount),i|
+            if i == (grouped_amounts.length - 1)
+              #last element
+              @rates[vp] = left_over.round(4)
+            else
+              @rates[vp] = (amount / net).round(4)
+              left_over -= @rates[vp]
+            end
+          end
+        else
+          max_p = @vat_percentages.max
+          @rates[max_p] = 1.00 if max_p
+        end
+        @rates = @rates.sort.reverse.to_h #sorted by vat percentage
+      end
+
+      # Output of rates in form of
+      # key is VAT Percentage and Value is the rate in decimal form
+      # {"19%"=>"69.81%", "7%"=>"21.74%", "0%"=>"8.45%"}
+      def human_rates
+        #example ((1.19 - 1.00)*100).round(2) => 19.0
+        rates.inject({}){|h,(pr,v)| h[pr.to_s] = Util.human_percentage_value(v,4); h}
+      end
+
+    end
+
+    class Services < GNVCollection
+      def self.for
+        ServiceElement
+      end
+
+      def rates_changed!(rates)
+        @vat_splitted = nil
+        @gross, @vat, @net = [nil] * 3
+        each_gnv {|gnv,_| gnv.change_rates(rates)}
+      end
+    end
+
+
+  end
+end

data/lib/vatcalc/gnv.rb

@@ -0,0 +1,122 @@
+require "matrix"
+
+# A GNV Object consists basically of a 2D Vector
+# First value is gross, second is net.
+# Vat is calculated by gross - net
+# 
+# GNV is an abstract Object and should only used for internal calculations in this library.
+#
+#@example
+# GNV.new(10.00,9.00)
+#
+# You can add or subtract two GNVs
+# GNV.new(10.00,9.00) + GNV.new(9.00,0.00)
+module Vatcalc
+  class GNV
+
+    include Comparable
+
+    attr_reader :vector,:currency
+    attr_accessor :source
+
+    def initialize(gross,net,cur=nil)
+      @currency ||= (cur || Vatcalc.currency)
+      init_vector(gross,net)
+    end
+
+    [:+,:-].each do |m_name|
+      define_method(m_name) do |oth|
+        gnv = oth.is_a?(GNV) ? to_gnv(@vector.send(m_name,oth.vector)) : raise(TypeError.new) 
+        gnv.tap do |g|
+          g.vat_splitted = oth.vat_splitted.merge(self.vat_splitted) {|vp,m1,m2| m1 + m2}
+        end
+      end
+    end
+
+    def *(oth)
+      gnv = oth.is_a?(Numeric) ? to_gnv(@vector * oth) : raise(TypeError.new) 
+      gnv.tap do |g|
+        h = new_money_hash
+        self.vat_splitted.each {|vp,m| h[vp] = m*oth}
+        g.vat_splitted = h
+      end
+    end
+
+    #For usage of => - GNV.new(100.00,90.00)
+    def -@
+      to_gnv(-@vector)
+    end
+
+
+    def ==(oth)
+      oth.is_a?(GNV) && oth.vector == @vector
+    end
+
+    alias_method :eql?, :==
+
+    def <=>(other)
+      if other.respond_to?(:net)
+        net <=> other.net
+      else
+        net <=> other
+      end
+    end
+
+
+
+    #@see https://www.mutuallyhuman.com/blog/2011/01/25/class-coercion-in-ruby
+    def coerce(oth)
+      [self,oth]
+    end
+
+    def gross
+      @vector[0]
+    end
+
+    def net
+      @vector[1]
+    end
+
+    def vat_splitted
+      @vat_splitted ||= new_money_hash
+    end
+
+    # Returns a Integer hash value based on the +value+
+    # in order to use functions like & (intersection), group_by, etc.
+    #
+    # @return [Integer]
+    #
+    # @example
+    #   GNV.new(19,11).hash #=> 908351
+    def hash
+      @vector.hash
+    end
+
+    #Always gross - net
+    def vat
+      gross - net
+    end
+
+    def to_gnv(v=@vector)
+      GNV.new(v[0],v[1],@currency)
+    end
+
+    protected
+
+    def vat_splitted=(h)
+      @vat_splitted = h
+    end
+
+    private 
+
+    def init_vector(g,n)
+      @vector = Vector[*[g,n].map{|i| Util.to_money(i,@currency)}]
+    end
+
+    def new_money_hash
+      Hash.new(Money.new(0,@currency))
+    end
+
+
+  end
+end

data/lib/vatcalc/service_element.rb

@@ -0,0 +1,93 @@
+module Vatcalc
+  class ServiceElement < GNV
+
+
+    attr_reader :vat_splitted,:rates
+
+    #Initalizes a new Object of an ServiceElement
+    #@param amount = [Money,Numeric]
+    #@param options = [Hash]
+    #
+    # Assumes that the amount is a gross value but you can pass a net value as well if you pass the 
+    # option net: true 
+    #
+    #@example 
+    # => b = ServiceElement.new 10.00, currency: "EUR"
+    #    b.net.to_f = 8.40
+    # => b = ServiceElement.new 10.00, currency: "USD"
+    #    b.net.to_f = 9.35
+    # => b = ServiceElement.new 10.00, currency: "USD", net: true
+    # => b.gross = 10.70
+    def initialize(amount,net: false, currency: nil, rates: {})
+      @net_service = net 
+      #if an service element is initialized # =>  gross equals net
+      super amount, amount, currency
+      change_rates(rates)
+    end
+
+    # Allocates net or gross by new vat_percentage rates and calculates the vat splitted by given rates
+    # @param rates [Hash]
+    # =>
+    # 
+    # @return [Hash]
+    # @example
+    #   => {#<Vatcalc::VATPercentage vat_percentage:19%>=>#<Money fractional:64 currency:EUR>,
+    #       #<Vatcalc::VATPercentage vat_percentage:7%>=>#<Money fractional:39 currency:EUR>}
+    #
+    def change_rates(new_rates)
+      if new_rates.is_a? Hash
+        if !new_rates.empty?
+          # Using basically the allocate function of the Money gem here.
+          # EXPLANATION FROM MONEY GEM: 
+          #
+          # Allocates money between different parties without losing pennies.
+          # After the mathematical split has been performed, leftover pennies will
+          # be distributed round-robin amongst the parties. This means that parties
+          # listed first will likely receive more pennies than ones that are listed later
+          
+          # @param [Array<Numeric>] splits [0.50, 0.25, 0.25] to give 50% of the cash to party1, 25% to party2, and 25% to party3.
+          
+          # @return [Array<Money>]
+          
+          # @example
+          #   Money.new(5,   "USD").allocate([0.3, 0.7])         #=> [Money.new(2), Money.new(3)]
+          #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33]) #=> [Money.new(34), Money.new(33), Money.new(33)]
+          #
+          allocated = (@net_service ? net : gross).allocate(new_rates.values)
+          # Init new vector after the allocate calculation
+          # Comes from superclass GNV
+          init_vector(0,0)
+          @vat_splitted = {}
+          new_rates.keys.zip(allocated).each do |vp,splitted|
+            #creating a new base element
+            b = BaseElement.new(splitted, net: @net_service,vat_percentage: vp, currency: @currency)
+            @vector += b.vector
+            @vat_splitted[b.vat_percentage] = b.vat 
+          end
+          @rates = new_rates
+        else
+          @vat_splitted = {}
+        end
+        @rates = new_rates
+      else
+        ArgumentError.new "Hash must be given not #{arg.class}"
+      end
+    end
+
+    def hash
+      #vector comes from GNV
+      [@vector,@vat_splitted].hash
+    end
+
+    def ==(oth)
+      oth.is_a?(ServiceElement) && oth.gross == gross && oth.net == net && (@vat_splitted == oth.vat_splitted)
+    end
+
+
+    def inspect
+      "#<#{self.class.name} vat_splitted:#{vat_splitted} gross:#{gross} net: #{net} vat:#{vat} currency: #{@currency}>"
+    end
+
+
+  end
+end

data/lib/vatcalc/util.rb

@@ -0,0 +1,67 @@
+
+require "money"
+
+
+module Vatcalc 
+  class Util
+    class << self
+
+      #Converts an Object into a Money object
+      #@return [Money]
+      #@example 
+      # => Vatcalc::Util.convert_to_money(10.00) 
+      def convert_to_money(obj,curr=nil)
+        curr ||= Vatcalc.currency
+        case obj
+        when Money
+          obj
+        when Fixnum
+          Money.new(obj,curr)
+        when Numeric
+          Money.new(obj*100,curr)
+        else
+          raise InvalidAmountError.new "Can't convert #{obj.class} to an Money instance"
+        end
+      end
+
+      # ALIAS for convert_to_money method
+      alias_method :conv_to_money, :convert_to_money
+      alias_method :conv_to_m, :convert_to_money
+      alias_method :to_money, :convert_to_money
+
+      #Converts an Object into an VATPercentage Object
+      #@return [VATPercentage]
+      #
+      #@example
+      # => Vatcalc::Util.to_vat_percentage
+      def convert_to_vat_percentage(vat_percentage)
+        case vat_percentage
+        when VATPercentage
+          vat_percentage 
+        when nil
+          Vatcalc.vat_percentage
+        else
+          VATPercentage.new(vat_percentage)
+        end
+      end
+
+      # ALIAS for convert_to_vat_percentage method
+      alias_method :to_vat_percentage, :convert_to_vat_percentage
+      alias_method :to_vat_p, :convert_to_vat_percentage
+
+      #Returns a human friendly percentage value
+      #@param value = [Float,Integer,String]
+      # => human_percentage_value(0.19) => 19% 
+      def human_percentage_value(value,precision=2)
+        full, fraction = ((value.to_f)*100).to_f.round(precision).divmod(1)
+        full.to_s + (fraction > 0.00 ? ("," + fraction.round(precision).to_s[2..-1]) : "") + "%"
+      end
+
+    end
+
+  end
+
+
+  class InvalidAmountError < TypeError
+  end
+end

data/lib/vatcalc/vat_percentage.rb

@@ -0,0 +1,110 @@
+module Vatcalc
+  class VATPercentage < Numeric
+
+    include Comparable
+
+    attr_reader :value
+
+    #Init a VATPercentage object by
+    # => Integer
+    #   => VATPercentage.new 19
+    # => Float
+    #   => VATPercentage.new 0.19
+    # => String
+    #   =>  VATPercentage.new 19%
+    #   =>  VATPercentage.new 19,1%
+    #   =>  VATPercentage.new 19,1%
+    #   =>  VATPercentage.new 19.1%
+    def initialize(obj)
+      @value = case obj
+      when VATPercentage
+        obj.value
+      when 0.00..0.99
+        as_d(obj.to_f + 1.00)
+      when 1..100.00
+        as_d((obj.to_f / 100 ) + 1.00)
+      else
+        if obj.is_a?(String) && obj.match(/[0-9]{0,2}\.|\,{0,1}[0-9]{0,2}/)
+          as_d((obj.gsub("," , ".").to_f / 100) + 1.00)
+        else
+          raise TypeError.new("Can't convert #{obj.class} #{obj} to an valid #{self.class}")
+        end
+      end
+    end
+
+    delegate :to_i,:to_f, to: :to_d
+
+
+    #For comparisaon between a value or a +VATPercentage+
+    #@return [Intger]
+    #@see module Comparable
+    def <=>(other)
+      to_d <=> as_d(other)
+    end
+
+    #Returns a gross value
+    #@return [Money]
+    #@example
+    # => 10.00 * VATPercentage.new(19) #=> #<Money fractional:1190 currency:EUR> 
+    def *(other)
+      case other
+      when Money
+        other * @value
+      when Numeric
+        Util.convert_to_money(other) * @value
+      when VATPercentage
+        raise TypeError.new "Can't multiply a VATPercentage by another VATPercentage"
+      else
+        if other.respond_to?(:coerce)
+          a,b = other.coerce(self)
+          a * b
+        else
+          raise TypeError.new "Can't multiply #{other.class} by VATPercentage"
+        end
+      end
+    end
+
+    #@see https://www.mutuallyhuman.com/blog/2011/01/25/class-coercion-in-ruby
+    #Basic usage of coerce. Now you can write:
+    # + 10.00 * VATPercentage.new(19) + 
+    # and:  
+    # + VATPercentage.new(19) * 10.00 + 
+    def coerce(other)
+      [self,other]
+    end
+
+    def to_d
+      @value
+    end
+
+    def inspect
+      "#<#{self.class.name} vat_percentage:#{to_s}>"
+    end
+
+    # Returns a Integer hash value based on the +value+
+    # in order to use functions like & (intersection), group_by, etc.
+    #
+    # @return [Integer]
+    #
+    # @example
+    #   VATPercentage.new(19).hash #=> 908351
+    def hash
+      [@value,self.class].hash
+    end
+
+    def to_s 
+      Util.human_percentage_value(@value-1.00)
+    end
+
+
+    private 
+    def as_d(num)
+      if num.respond_to?(:to_d)
+        num.is_a?(Rational) ? num.to_d(5) : num.to_d
+      else
+        BigDecimal.new(num.to_s.empty? ? 0 : num.to_s)
+      end
+    end
+
+  end
+end

data/lib/vatcalc/version.rb

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

data/vatcalc.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "vatcalc/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "vatcalc"
+  spec.version       = Vatcalc::VERSION
+  spec.authors       = ["Christopher Geduhn"]
+  spec.email         = ["christopher.geduhn@googlemail.com"]
+
+  spec.summary       = %q{ A gem to calculate VAT of multiple products with differently VAT percentages. }
+  spec.description   = %q{ A gem to calculate VAT of multiple products with differently VAT percentages. }
+  spec.homepage      = "https://github.com/cgeduhn/vatcalc"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "money"
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: vatcalc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christopher Geduhn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: " A gem to calculate VAT of multiple products with differently VAT percentages. "
+email:
+- christopher.geduhn@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/vatcalc.rb
+- lib/vatcalc/acts_as_bill_element.rb
+- lib/vatcalc/base_element.rb
+- lib/vatcalc/bill.rb
+- lib/vatcalc/gnv.rb
+- lib/vatcalc/service_element.rb
+- lib/vatcalc/util.rb
+- lib/vatcalc/vat_percentage.rb
+- lib/vatcalc/version.rb
+- vatcalc.gemspec
+homepage: https://github.com/cgeduhn/vatcalc
+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.6.13
+signing_key: 
+specification_version: 4
+summary: A gem to calculate VAT of multiple products with differently VAT percentages.
+test_files: []