income-tax 0.1.0

data/lib/income_tax/models/generic.rb

@@ -0,0 +1,212 @@
+module IncomeTax
+  module Models
+    class Generic
+      include Helpers
+      extend  Helpers
+
+      extend Forwardable
+      def_delegators :rate, :to_f, :to_r, :to_d
+      attr_reader :rate, :taxes, :gross_income, :net_income, :options
+
+      def self.method_added(method)
+        return super if self == Generic
+        return super if superclass.method_defined? method
+        superclass.protected_method_defined?(method) ? protected(method) : private(method)
+        super
+      end
+
+      def self.name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def self.names
+        @names ||= []
+      end
+
+      def self.other_names
+        names.select { |n| n != name }
+      end
+
+      @register_on = CountryRegister
+      def self.register_on(register = nil)
+        @register_on = register if register
+        @register_on ||= superclass.register_on
+      end
+
+      def self.register(*names)
+        @name  ||= names.first
+        self.names.concat(names)
+        names.each { |name| register_on[name] = self }
+      end
+
+      @wants_options = []
+      def self.wants_options(*options)
+        @wants_options ||= superclass.wants_options.dup
+
+        if options.any?
+          @wants_options.concat(options)
+          options.each do |option|
+            define_method(option)       { @options[option] } unless method_defined? option
+            define_method("#{option}?") { !!send(option)   } unless method_defined? "#{option}?"
+          end
+        end
+
+        @wants_options
+      end
+
+      def self.currency(value = nil)
+        @currency = value if value
+        @currency
+      end
+
+      def self.lazy(&block)
+        @lazy_mutex = Mutex.new
+        @lazy = block
+      end
+
+      def self.new(*)
+        if @lazy ||= nil
+          @lazy_mutex.synchronize do
+            if @lazy
+              @lazy.call
+              @lazy = nil
+            end
+          end
+        end
+
+        super
+      end
+
+      def initialize(income: 0, income_type: :gross, **options)
+        raise ArgumentError, "income can't be negative" if income < 0
+        @income_type = income_type
+        @options     = options.dup
+
+        set_default_options
+        setup(income: income, income_type: income_type, **options)
+        @options.freeze
+
+        based_on?(:gross) ? set_gross_income(income) : set_net_income(income)
+        cast_values
+        validate
+      end
+
+      def setup(options)
+      end
+
+      def validate
+        raise "gross income can't be negative" if gross_income < 0
+        raise "net income can't be negative"   if net_income   < 0
+        raise "taxes can't be negative"        if taxes        < 0
+
+        # devide by two to avoid off by one errors
+        if (net_income + taxes).to_i / 3 != gross_income.to_i / 3
+          raise "net income and taxes don't add up to gross income. " \
+            "%s + %s was expected to result in %s, gave %s" % [
+              net_income, taxes, gross_income, net_income + taxes
+            ]
+        end
+
+        # allow a 0.01% mismatch
+        if taxes > 0 and (1.0 - Rate(taxes, gross_income) / rate).abs > 0.0001
+          raise "tax rate does not give appropriate taxes. " \
+            "%s of %s is %s, not %s" % [
+              rate, gross_income, rate.gross_taxes(gross_income), taxes
+            ]
+        end
+      end
+
+      def set_default_options
+        options[:married]    = false if options[:married].nil?
+        options[:children]   = 0     if options[:children] == false
+        options[:children] ||= options[:married] ? 1 : 0
+        options[:age]      ||= age_for(options[:birthday]) if options[:birthday]
+        options[:age]      ||= 30
+
+        options.select! { |k,v| self.class.wants_options.include? k }
+
+        options[:age]      &&= Integer(options[:age])
+        options[:children] &&= Integer(options[:children])
+      end
+
+      def set_net_income(income)
+        @net_income = income
+        calculate_net
+
+        if rate
+          @taxes        ||= rate.net_taxes(net_income)
+          @gross_income ||= rate.gross(net_income)
+        elsif taxes
+          @gross_income ||= net_income + taxes
+          @rate         ||= Rate(taxes, gross_income)
+        elsif gross_income
+          @taxes        ||= gross_income - net_income
+          @rate         ||= Rate(taxes, gross_income)
+        else
+          raise RuntimeError, "calculate_gross was expected to either set rate, taxes or net_income"
+        end
+      end
+
+      def set_gross_income(income)
+        @gross_income = income
+        calculate_gross
+
+        if rate
+          @taxes      ||= rate.gross_taxes(gross_income)
+          @net_income ||= rate.net(gross_income)
+        elsif taxes
+          @rate       ||= Rate(taxes, gross_income)
+          @net_income ||= gross_income - taxes
+        elsif net_income
+          @taxes      ||= gross_income - net_income
+          @rate       ||= Rate(taxes, gross_income)
+        else
+          raise RuntimeError, "calculate_gross was expected to either set rate, taxes or net_income"
+        end
+      end
+
+      def based_on?(type)
+        @income_type == type
+      end
+
+      def location_name
+        self.class.name
+      end
+
+      def inspect
+        net   = net_income   .is_a?(BigDecimal) ? net_income.to_s("F")   : net_income.to_s
+        gross = gross_income .is_a?(BigDecimal) ? gross_income.to_s("F") : gross_income.to_s
+
+        "#<IncomeTax:%p, rate: %p, net: %s, gross: %s>" % [
+          location_name, rate.to_s, net, gross
+        ]
+      end
+
+      def calculate_net
+        calculate
+      end
+
+      def calculate_gross
+        calculate
+      end
+
+      def calculate
+        raise NotImplementedError
+      end
+
+      def cast_values
+        @rate         = Rate(rate)
+        @gross_income = cast_value(gross_income)
+        @net_income   = cast_value(net_income)
+        @taxes        = cast_value(taxes)
+      end
+
+      def cast_value(value)
+        value == value.to_i ? value.to_i  : Rate.decimal(value)
+      end
+
+      private :calculate_net, :calculate_gross, :calculate, :set_net_income, :set_gross_income
+    end
+  end
+end

data/lib/income_tax/models/no_taxes.rb

@@ -0,0 +1,7 @@
+module IncomeTax
+  module Models
+    class NoTaxes < FixedRate
+      rate "0%"
+    end
+  end
+end

data/lib/income_tax/models/not_implemented.rb

@@ -0,0 +1,6 @@
+module IncomeTax
+  module Models
+    class NotImplemented < Generic
+    end
+  end
+end

data/lib/income_tax/models/progressive.rb

@@ -0,0 +1,103 @@
+module IncomeTax
+  module Models
+    class Progressive < Generic
+      class Levels
+        include Helpers
+
+        def initialize(levels = [], remainder = nil)
+          @levels    = levels
+          @remainder = remainder
+        end
+
+        def level(start, rate)
+          @levels << [money(start), Rate(rate)]
+        end
+
+        def offset(delta)
+          return delta unless @levels.any?
+          @levels.last.first + money(delta)
+        end
+
+        def remainder(rate)
+          @remainder = Rate(rate)
+        end
+
+        def +(rate)
+          self.class.new(@levels.map { |b,r| [b, r + rate] }, @remainder + rate)
+        end
+
+        def multiply_brackets(factor)
+          self.class.new(@levels.map { |b,r| [(b*factor).to_i, r] }, @remainder)
+        end
+
+        def calculate(method, income)
+          remainder     = income
+          already_taxed = 0
+          taxes         = 0
+
+          @levels.each do |boundary, rate|
+            bracket       = boundary - already_taxed
+            bracket       = yield rate, bracket if block_given?
+            already_taxed = boundary
+
+            if remainder > bracket
+              taxes     += rate.public_send(method, bracket)
+              remainder -= bracket
+            else
+              taxes     += rate.public_send(method, remainder)
+              remainder  = 0
+              break
+            end
+          end
+
+          taxes + @remainder.public_send(method, remainder)
+        end
+
+        def calculate_gross(income)
+          calculate(:gross_taxes, income)
+        end
+
+        def calculate_net(income)
+          calculate(:net_taxes, income) { |rate, input| rate.net(input) }
+        end
+      end
+
+      def self.level(start, rate)
+        levels(:default).level(start, rate)
+      end
+
+      def self.offset(delta)
+        levels(:default).offset(delta)
+      end
+
+      def self.remainder(rate)
+        levels(:default).remainder(rate)
+      end
+
+      def self.levels(category = nil, *options, &block)
+        return @levels ||= {} if category.nil?
+        result = levels[category] ||= Levels.new(*options)
+        result.instance_eval(&block) if block
+        result
+      end
+
+      def level_category
+        :default
+      end
+
+      def levels(category = level_category)
+        self.class.levels.fetch(category) do
+          raise ArgumentError, "unkown level category #{category} (available: #{self.class.levels.keys.join(", ")})"
+        end
+      end
+
+      def calculate_gross
+        @taxes = levels.calculate_gross(gross_income)
+      end
+
+      def calculate_net
+        @taxes = levels.calculate_net(net_income)
+      end
+    end
+  end
+end

data/lib/income_tax/models.rb

@@ -0,0 +1,10 @@
+module IncomeTax
+  module Models
+    require 'income_tax/models/generic'
+    require 'income_tax/models/not_implemented'
+    require 'income_tax/models/progressive'
+    require 'income_tax/models/fixed_rate'
+    require 'income_tax/models/no_taxes'
+    require 'income_tax/models/delegate'
+  end
+end

data/lib/income_tax/rate.rb

@@ -0,0 +1,152 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'forwardable'
+
+module IncomeTax
+  class Rate < Numeric
+    PROTOTYPE = new
+    private_constant :PROTOTYPE
+
+    include Comparable
+
+    def self.new(input, other = nil)
+      return super unless other.nil?
+      input.is_a?(Rate) ? input : super
+    end
+
+    def self.decimal(input)
+      return input.to_d unless input.is_a? Rational
+      input.to_d(input.to_f.to_s.size)
+    end
+
+    def self.rational(input, other)
+      return 0r if input == 0
+      Rational(input, other).to_r.rationalize(0.00001r)
+    end
+
+    attr_reader :to_d, :to_r, :to_f, :to_s, :to_i, :preferred_coercion
+    protected :preferred_coercion
+
+    extend Forwardable
+    def_delegators :to_r, :denominator, :numerator, :rationalize
+    def_delegators :to_f, :nan?, :finite?, :infinite?, :arg, :angle, :magnitude, :next_float, :phase, :prev_float
+    def_delegators :to_d, :exponent, :fix, :frac, :precs, :sign, :split, :to_digits
+
+    def initialize(value, other = nil)
+      value     = Rate.rational(value, other) if other
+      _, value  = case value
+                  when /^\-?\d+(\.\d+)?\%$/ then @preferred_coercion, @to_r = :to_r, value.to_r / 100
+                  when /^[10\-?]\.\d+$/     then @preferred_coercion, @to_r = :to_r, value.to_r
+                  when BigDecimal           then @preferred_coercion, @to_d = :to_d, value
+                  when Rational             then @preferred_coercion, @to_r = :to_r, value
+                  when Float                then @preferred_coercion, @to_f = :to_f, value
+                  when Integer              then @preferred_coercion, @to_r = :to_r, value.to_r / 100
+                  else raise ArgumentError, "cannot handle %p as rate input" % [value]
+                  end
+
+      @to_d ||= Rate.decimal(value)
+      @to_r ||= Float === value ? value.to_s.to_r : value.to_r
+      @to_f ||= value.to_f
+      @to_i ||= value.to_i
+      @to_s ||= (@to_d * 100).to_s("F") + "%"
+      @to_s.sub! ".0%", "%"
+
+      @preferred_coercion = :to_i if @to_i == value
+    end
+
+    def gross(value)
+      math(value) do |rate, net|
+        if rate == 1
+          net == 0 ? 0 : BigDecimal('Infinity')
+        else
+          net / (1 - rate)
+        end
+      end
+    end
+
+    def net(value)
+      math(value) do |rate, gross|
+        gross * (1 - rate)
+      end
+    end
+
+    def gross_taxes(value)
+      self * value
+    end
+
+    def net_taxes(value)
+      math(value) do |rate, net|
+        rate == 1 ? net : net / (1 - rate) - net
+      end
+    end
+
+    def preferred_representation
+      send(@preferred_coercion)
+    end
+
+    def inspect
+      "#<%p:%p>" % [ self.class, to_s ]
+    end
+
+    def -@
+      self.class.new(-preferred_representation)
+    end
+
+    def +(other)   math(other,        &:+)   end
+    def -(other)   math(other,        &:-)   end
+    def *(other)   math(other,        &:*)   end
+    def /(other)   math(other,        &:/)   end
+    def **(other)  math(other,        &:**)  end
+    def <=>(other) math(other, false, &:<=>) end
+
+    def eql?(other)
+      other.class == self.class and other == self
+    end
+
+    def hash
+      to_s.hash ^ to_d.hash
+    end
+
+    def coerce(other)
+      case other
+      when Rate       then [ other,                                 self                            ]
+      when Rational   then [ other,                                 to_r                            ]
+      when BigDecimal then [ other,                                 to_d                            ]
+      when Integer    then [ other.public_send(preferred_coercion), public_send(preferred_coercion) ]
+      else                 [ Float(other),                          to_f                            ]
+      end
+    end
+
+    def math(other, cast = nil)
+      if other.is_a? Rate
+        coercion = preferred_coercion == other.preferred_coercion ? preferred_coercion : :to_d
+        result   = yield(public_send(coercion), other.public_send(coercion))
+        cast == false ? result : Rate.new(result)
+      else
+        b, a   = coerce(other)
+        result = yield(a, b)
+        cast ? Rate.new(result) : cast(result, other)
+      end
+    end
+
+    def cast(result, input)
+      return result unless input.is_a? Integer and not result.is_a? Integer
+      return result if result.respond_to?(:infinite?) and result.infinite?
+      return result if result.respond_to?(:nan?)      and result.nan?
+      result == result.to_i ? result.to_i : result
+    end
+
+    private :math, :cast
+
+    module BigDecimalExtension
+      def BigDecimal(input, *)
+        Rate === input ? input.to_d : super
+      end
+
+      private :BigDecimal
+      Object.prepend(self)
+    end
+
+    private_constant :BigDecimalExtension
+  end
+end

data/lib/income_tax/register.rb

@@ -0,0 +1,35 @@
+module IncomeTax
+  class Register
+    def initialize(type = "entry")
+      @type     = type
+      @register = {}
+    end
+
+    def add(key, value)
+      @register[normalize(key)] = value
+    end
+
+    def get(key)
+      @register.fetch(normalize(key)) do
+        raise ArgumentError, "unknown #{@type} #{key.inspect}"
+      end
+    end
+
+    def include?(key)
+      @register.include? normalize(key)
+    end
+
+    def normalize(key)
+      key.to_s.
+        tr("_ÅåÉé", " AaEe").
+        gsub(/republic of (the)?/i, 'republic').
+        downcase.
+        gsub(' and ', '').
+        gsub(/\W/, '')
+    end
+
+    alias_method :[]=, :add
+    alias_method :[],  :get
+    private :normalize
+  end
+end

data/lib/income_tax/version.rb

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

data/lib/income_tax.rb

@@ -0,0 +1,17 @@
+module IncomeTax
+  require 'income_tax/register'
+  CountryRegister = Register.new('country')
+
+  require 'income_tax/helpers'
+  extend Helpers
+  singleton_class.send(:public, :Rate)
+
+  require 'income_tax/rate'
+  require 'income_tax/models'
+  require 'income_tax/countries'
+  require 'income_tax/factory'
+
+  def self.new(*args)
+    Factory.generate(*args)
+  end
+end