mudrat_projector 0.9.0

data/lib/mudrat_projector/projection.rb

@@ -0,0 +1,45 @@
+module MudratProjector
+  class Projection
+    attr :range
+
+    SequenceEntry = Struct.new :transaction, :batch_id do
+      def sort_key
+        [transaction.date, batch_id]
+      end
+
+      def <=> other_entry
+        sort_key <=> other_entry.sort_key
+      end
+    end
+
+    def initialize range: date_range, chart: chart_of_accounts
+      @chart                = chart
+      @batch_id             = 0
+      @range                = range
+      @transaction_sequence = []
+    end
+
+    def << transaction
+      @transaction_sequence.push SequenceEntry.new(transaction, @batch_id)
+    end
+
+    def add_transaction_batch batch
+      batch.each do |transaction| 
+        self << transaction
+        @batch_id += 1
+      end
+    end
+
+    def project!
+      freeze
+      transaction_sequence.each do |transaction|
+        @chart.apply_transaction transaction
+        yield transaction if block_given?
+      end
+    end
+
+    def transaction_sequence
+      @transaction_sequence.tap(&:sort!).map &:transaction
+    end
+  end
+end

data/lib/mudrat_projector/projector.rb

@@ -0,0 +1,71 @@
+module MudratProjector
+  class Projector
+    extend Forwardable
+    extend BankerRounding
+
+    AccountDoesNotExist = Class.new StandardError
+    AccountExists       = Class.new ArgumentError
+    BalanceError        = Class.new StandardError
+    InvalidAccount      = Class.new ArgumentError
+    InvalidTransaction  = Class.new StandardError
+
+    attr :from
+
+    def initialize params = {}
+      @chart        = params.fetch :chart, ChartOfAccounts.new
+      @from         = params.fetch :from, ABSOLUTE_START
+      @transactions = []
+      @validator    = Validator.new projector: self, chart: @chart
+    end
+
+    def_delegators :@chart, *%i(accounts account_balance apply_transaction balance fetch net_worth split_account)
+    def_delegators :@validator, *%i(must_be_balanced! validate_account! validate_transaction!)
+
+    def accounts= accounts
+      accounts.each do |account_id, params|
+        add_account account_id, params
+      end
+    end
+
+    def account_exists? account_id
+      @chart.exists? account_id
+    end
+
+    def add_account account_id, **params
+      validate_account! account_id, params
+      @chart.add_account account_id, params
+    end
+
+    def add_transaction params
+      if params.is_a? Transaction
+        transaction = params
+      else
+        klass = params.has_key?(:schedule) ? ScheduledTransaction : Transaction
+        transaction = klass.new params
+        validate_transaction! transaction
+      end
+      @transactions.push transaction
+    end
+
+    def balanced?
+      balance.zero?
+    end
+
+    def project to: end_of_projection, build_next: false, &block
+      must_be_balanced!
+      projection = Projection.new range: (from..to), chart: @chart
+      handler = TransactionHandler.new projection: projection
+      if build_next
+        handler.next_projector = self.class.new from: to + 1, chart: @chart
+      end
+      @transactions.each do |transaction| handler << transaction; end
+      projection.project! &block
+      handler.next_projector
+    end
+
+    def transactions= transactions
+      transactions.each do |transaction| add_transaction transaction; end
+    end
+
+  end
+end

data/lib/mudrat_projector/schedule.rb

@@ -0,0 +1,45 @@
+module MudratProjector
+  class Schedule
+    attr :count, :scalar, :unit
+
+    def initialize params = {}
+      @count  = params.fetch :count, nil
+      @scalar = params.fetch :scalar
+      @unit   = params.fetch :unit
+    end
+
+    def advance_over range
+      split_count_over(range).reduce range.begin do |date, factor|
+        @count -= factor if @count
+        yield [date, factor]
+        DateDiff.advance intervals: factor, unit: unit, from: date
+      end
+    end
+
+    def finished?
+      (count.nil? || count > 0) ? false : true
+    end
+
+    def split_count_over range
+      diff = DateDiff.date_diff unit: unit, from: range.begin, to: range.end
+      full_units, final_prorate = [@count, diff].compact.min.divmod 1
+      ([1] * full_units).tap do |list|
+        list.push final_prorate unless final_prorate.zero?
+      end
+    end
+
+    def serialize
+      {
+        scalar: scalar,
+        unit:   unit,
+      }.tap { |h| h[:count] = count if count }
+    end
+
+    def slice range, &block
+      bits = []
+      advance_over range do |date, factor| bits.push [date, factor]; end
+      leftover = finished? ? nil : serialize
+      [bits, leftover]
+    end
+  end
+end

data/lib/mudrat_projector/scheduled_transaction.rb

@@ -0,0 +1,45 @@
+module MudratProjector
+  class ScheduledTransaction < Transaction
+    attr :schedule
+
+    def initialize params = {}
+      @schedule = Schedule.new params.fetch :schedule
+      super params
+    end
+
+    def build_transactions intervals
+      intervals.map do |date, prorate|
+        clone_transaction new_date: date, multiplier: prorate
+      end
+    end
+
+    def clone_transaction new_date: date, new_schedule: nil, multiplier: 1
+      params = build_cloned_tranasction_params new_date, multiplier
+      return Transaction.new(params) if new_schedule.nil?
+      params[:schedule] = new_schedule
+      ScheduledTransaction.new params
+    end
+
+    def multiply entries, by: 1
+      entries.map do |entry| entry * by; end
+    end
+
+    def slice slice_date
+      intervals, next_schedule = schedule.slice(date..slice_date)
+      if next_schedule
+        leftover = clone_transaction new_date: slice_date + 1, new_schedule: next_schedule
+      end
+      [build_transactions(intervals), leftover]
+    end
+
+    private
+
+    def build_cloned_tranasction_params new_date, multiplier
+      {
+        date: new_date,
+        debits: multiply(debits, by: multiplier), 
+        credits: multiply(credits, by: multiplier),
+      }
+    end
+  end
+end

data/lib/mudrat_projector/tax_calculation.rb

@@ -0,0 +1,154 @@
+module MudratProjector
+  class TaxCalculation
+    attr :values_hash
+    attr :w2_gross, :se_gross, :pretax_deductions, :other_gross
+    attr :projector, :household, :taxes_withheld
+
+    def initialize projector, household, values_hash
+      @values_hash = values_hash
+      @projector = projector
+      @w2_gross = 0
+      @se_gross = 0
+      @pretax_deductions = 0
+      @hsa_contribs = Hash.new { |h,k| h[k] = 0 }
+      @household = household
+      @itemized_deduction = 0
+      @taxes_withheld = 0
+      @other_gross = 0
+      extend_year_shim
+    end
+
+    def method_missing method_name, *args
+      if args.empty? && values_hash.has_key?(method_name)
+        values_hash.fetch method_name
+      else
+        super
+      end
+    end
+
+    def << transaction
+      @w2_gross += transaction.salaries_and_wages
+      @se_gross += transaction.business_profit
+      @other_gross += transaction.dividend_income
+      @itemized_deduction += transaction.charitable_contributions
+      @itemized_deduction += transaction.interest_paid
+      @itemized_deduction += transaction.taxes_paid
+      @taxes_withheld     += transaction.taxes_withheld
+      transaction.debits.each do |entry|
+        account = projector.fetch entry.account_id
+        if account.type == :asset && account.tag?(:hsa)
+          revenue = transaction.credits.select { |e| a = projector.fetch(e.account_id); a.type == :revenue && a.tag?(:salary)}
+          @pretax_deductions += revenue.reduce 0 do |s,e| s + e.amount; end
+          @hsa_contribs[account] += [entry.amount - pretax_deductions, 0].max
+        end
+      end
+    end
+
+    def adjustments
+      (self_employment_tax / 2) + hsa_contributions
+    end
+
+    def agi
+      total_income - adjustments
+    end
+
+    def brackets
+      bracket_caps = super.tap do |list|
+        list.push Float::INFINITY
+      end
+      values_hash.fetch(:bracket_rates).zip bracket_caps
+    end
+
+    def deduction
+      [itemized_deduction, standard_deduction].max
+    end
+
+    def effective_rate
+      (((gross - net) / gross) * 100).round 2
+    end
+
+    def exemption
+      personal_exemption * household.exemptions
+    end
+
+    def gross
+      w2_gross + se_gross + other_gross
+    end
+
+    def income_tax
+      amount_taxed = 0
+      brackets.reduce 0 do |sum, (rate, cap)|
+        if cap == Float::INFINITY
+          in_bracket = taxable_income - amount_taxed
+        else
+          in_bracket = [cap, taxable_income].min - amount_taxed
+        end
+        amount_taxed += in_bracket
+        t = (in_bracket * (rate / 100))
+        sum + t
+      end
+    end
+
+    def hsa_contributions
+      @hsa_contribs.reduce 0 do |sum, (account, amount)|
+        type = [:individual, :family, :senior].detect { |tag| account.tag? tag }
+        max = hsa_limit.fetch type
+        sum + [amount, max].min
+      end
+    end
+
+    def itemized_deduction
+      @itemized_deduction
+    end
+
+    def medicare_withheld
+      w2_gross * (hi_rate / 100)
+    end
+
+    def net
+      gross - taxes
+    end
+
+    def self_employment_tax
+      rate = (oasdi_rate + hi_rate) / 100
+      se_gross * (1 - rate) * (rate * 2)
+    end
+
+    def social_security_withheld
+      [w2_gross, oasdi_wage_base].min * (oasdi_rate / 100)
+    end
+
+    def taxable_income
+      agi - deduction - exemption
+    end
+
+    def taxes
+      withholding_tax + income_tax + self_employment_tax
+    end
+
+    def taxes_owed
+      taxes - taxes_withheld
+    end
+
+    def total_income
+      gross - pretax_deductions
+    end
+
+    def year
+      projector.from.year
+    end
+
+    def withholding_tax
+      medicare_withheld + social_security_withheld
+    end
+
+    private
+
+    def extend_year_shim
+      shim_module = "Year#{year}".to_sym
+      if TaxCalculator.const_defined? shim_module
+        extend TaxCalculator.const_get shim_module
+      end
+    end
+  end
+end

data/lib/mudrat_projector/tax_calculator.rb

@@ -0,0 +1,144 @@
+module MudratProjector
+  class TaxCalculator
+    module Year2012
+      # see http://en.wikipedia.org/wiki/Tax_Relief,_Unemployment_Insurance_Reauthorization,_and_Job_Creation_Act_of_2010
+      def social_security_withheld
+        super * (4.2.to_d / 6.2.to_d)
+      end
+    end
+
+    attr :household, :projector
+
+    HOUSEHOLD_TYPES = %i(married_filing_jointly married_filing_separately single
+                         head_of_household)
+    EXPENSE_ACCOUNT_ID = :united_states_treasury
+
+    Household = Struct.new :filing_status, :exemptions do
+      def initialize *args
+        super
+        unless HOUSEHOLD_TYPES.include? filing_status
+          raise "Invalid filing status #{filing_status.inspect}"
+        end
+      end
+    end
+
+    def self.project projector, to: end_date, household: nil
+      tax_calculator = new projector: projector, household: household
+      (projector.from.year..to.year).each do
+        calculation = tax_calculator.calculate!
+        yield calculation if block_given?
+      end
+      tax_calculator.projector
+    end
+
+    class TransactionWrapper
+      INCOME_VALUES      = %i(business_profit dividend_income salaries_and_wages)
+      ADJUSTMENTS_VALUES = %i(other_adjustments)
+      DEDUCTIONS_VALUES  = %i(charitable_contributions interest_paid taxes_paid)
+      CREDITS_VALUES     = %i()
+
+      VALUES = [INCOME_VALUES, ADJUSTMENTS_VALUES, DEDUCTIONS_VALUES, CREDITS_VALUES].flatten 1
+
+      attr :calculator, :taxes_withheld
+      private :calculator
+
+      def initialize calculator, transaction
+        @calculator = calculator
+        @taxes_withheld = 0
+        @transaction = transaction
+        VALUES.each do |attr_name| instance_variable_set "@#{attr_name}", 0; end
+      end
+
+      VALUES.each do |attr_name| attr attr_name; end
+
+      def calculate!
+        @transaction.entries.each do |entry|
+          account = calculator.projector.fetch entry.account_id
+          if account.type == :revenue
+            @salaries_and_wages += entry.delta if account.tag? :salary
+            @business_profit    += entry.delta if account.tag? :self_employed
+            @dividend_income    += entry.delta if account.tag? :dividend
+          elsif account.type == :expense
+            @business_profit    -= entry.delta if account.tag? :self_employed
+            @charitable_contributions +=
+                                   entry.delta if account.tag? "501c".to_sym
+            @interest_paid      += entry.delta if account.tag? :mortgage_interest
+            @taxes_paid         += entry.delta if account.tag? :tax
+            @taxes_withheld     += entry.delta if entry.account_id == EXPENSE_ACCOUNT_ID
+          elsif account.type == :asset
+            @other_adjustments  += entry.delta if account.tag?(:hsa) && entry.debit?
+          end
+        end
+      end
+      
+      def debits
+        @transaction.debits
+      end
+
+      def credits
+        @transaction.credits
+      end
+    end
+
+    def initialize projector: nil, household: {}
+      @household   = Household.new(
+        household.fetch(:filing_status),
+        household.fetch(:exemptions),
+      )
+      @projector   = projector
+      @values_hash = parse_yaml
+      unless projector.account_exists? EXPENSE_ACCOUNT_ID
+        projector.add_account EXPENSE_ACCOUNT_ID, type: :expense
+      end
+      unless projector.account_exists? :owed_taxes
+        projector.add_account :owed_taxes, type: :liability
+      end
+    end
+
+    def calculate!
+      end_of_calendar_year = Date.new year, 12, 31
+      calculation = TaxCalculation.new projector, household, @values_hash
+      next_projector = projector.project to: end_of_calendar_year, build_next: true do |transaction|
+        calculation << TransactionWrapper.new(self, transaction).tap(&:calculate!)
+      end
+      final_transaction = Transaction.new(
+        date: end_of_calendar_year,
+        debit:  { amount: calculation.taxes_owed, account_id: EXPENSE_ACCOUNT_ID },
+        credit: { amount: calculation.taxes_owed, account_id: :owed_taxes },
+      )
+      projector.apply_transaction final_transaction
+      @projector = next_projector
+      @values_hash = parse_yaml
+      calculation
+    end
+
+    def year
+      projector.from.year
+    end
+
+    private
+
+    def parse_yaml
+      yaml = File.expand_path '../tax_values_by_year.yml', __FILE__
+      by_year = YAML.load File.read(yaml)
+      max_year = by_year.keys.max
+      parsed = by_year.fetch([year, max_year].min).tap do |hash|
+        recursively_symbolize_keys! hash
+      end
+      hash = parsed.fetch household.filing_status
+      parsed.each_with_object hash do |(key, value), hash|
+        hash[key] = value unless HOUSEHOLD_TYPES.include? key
+      end
+      hash
+    end
+
+    def recursively_symbolize_keys! hash
+      hash.keys.each do |key|
+        value = hash.delete key
+        recursively_symbolize_keys! value if value.is_a? Hash
+        key = key.respond_to?(:to_sym) ? key.to_sym : key
+        hash[key] = value
+      end
+    end
+  end
+end

data/lib/mudrat_projector/tax_values_by_year.yml

@@ -0,0 +1,102 @@
+2012:
+  oasdi_rate: 6.2
+  oasdi_wage_base: 110_100
+  hi_rate: 1.45
+  personal_exemption: 3_800
+  hsa_limit:
+    individual: 3_100
+    family:     6_250
+    senior:     1000
+  bracket_rates:
+    - 10.0
+    - 15.0
+    - 25.0
+    - 28.0
+    - 33.0
+    - 35.0
+  married_filing_jointly:
+    standard_deduction: 11_900
+    brackets:
+      - 17_400
+      - 70_700
+      - 142_700
+      - 217_450
+      - 388_350
+  married_filing_separately:
+    standard_deduction: 5_950
+    brackets:
+      - 8_700
+      - 35_350
+      - 71_350
+      - 108_725
+      - 194_175
+  single:
+    standard_deduction: 5_950
+    brackets:
+      - 8_700
+      - 35_350
+      - 85_650
+      - 178_650
+      - 388_350
+  head_of_household:
+    standard_deduction: 8_700
+    brackets:
+      - 12_400
+      - 47_350
+      - 122_300
+      - 190_050
+      - 388_350
+
+2013:
+  oasdi_rate: 6.2
+  oasdi_wage_base: 113_700
+  hi_rate: 1.45
+  personal_exemption: 3_900
+  hsa_limit:
+    individual: 3_250
+    family:     6_450
+    senior:     1000
+  bracket_rates:
+    - 10.0
+    - 15.0
+    - 25.0
+    - 28.0
+    - 33.0
+    - 35.0
+    - 39.6
+  married_filing_jointly:
+    standard_deduction: 12_200
+    brackets:
+      - 17_850
+      - 72_500
+      - 146_400
+      - 223_050
+      - 398_350
+      - 450_000
+  married_filing_separately:
+    standard_deduction: 6_100
+    brackets:
+      - 8_925
+      - 36_250
+      - 73_200
+      - 111_525
+      - 199_175
+      - 225_000
+  single:
+    standard_deduction: 6_100
+    brackets:
+      - 8_925
+      - 36_250
+      - 87_850
+      - 183_250
+      - 398_350
+      - 400_000
+  head_of_household:
+    standard_deduction: 8_950
+    brackets:
+      - 12_750
+      - 48_600
+      - 125_450
+      - 203_150
+      - 398_350
+      - 425_000

data/lib/mudrat_projector/transaction.rb

@@ -0,0 +1,71 @@
+module MudratProjector
+  class Transaction
+    include Enumerable
+
+    attr :credits, :date, :debits
+
+    def initialize params = {}
+      @date        = params.fetch :date
+      self.credits = extract_entry_params :credit, params
+      self.debits  = extract_entry_params :debit,  params
+    end
+
+    def balanced?
+      sum_credits = build_set_for_balance credits
+      sum_debits  = build_set_for_balance debits
+      (sum_credits ^ sum_debits).empty?
+    end
+
+    def credits= credits
+      @credits = build_entries :credit, credits
+    end
+
+    def debits= debits
+      @debits = build_entries :debit, debits
+    end
+
+    def each &block
+      credits.each &block
+      debits.each &block
+    end
+
+    def slice slice_date
+      if date > slice_date
+        [[], self]
+      else
+        [[self], nil]
+      end
+    end
+
+    private
+
+    def extract_entry_params credit_or_debit, params
+      entries = Array params["#{credit_or_debit}s".to_sym]
+      return entries unless params.has_key? credit_or_debit
+      unless entries.empty?
+        raise ArgumentError, "You cannot supply both #{credit_or_debit} and "\
+          "#{credit_or_debit}s"
+      end
+      [params.fetch(credit_or_debit)]
+    end
+
+    def build_entries credit_or_debit, entries
+      entries.map do |entry_params|
+        if entry_params.is_a? TransactionEntry
+          entry_params
+        else
+          TransactionEntry.public_send "new_#{credit_or_debit}", entry_params
+        end
+      end
+    end
+
+    def build_set_for_balance entries
+      hash = Hash.new { |h,k| h[k] = 0 }
+      entries.each do |entry|
+        balance_key = entry.class == TransactionEntry ? :fixed : entry.other_account_id
+        hash[balance_key] += entry.scalar
+      end
+      hash.reduce Set.new do |set, (_, value)| set << value; end
+    end
+  end
+end