fortuneteller 0.1.0

data/lib/fortuneteller/job.rb

@@ -0,0 +1,78 @@
+module FortuneTeller
+  # Representation of a job being simulated with FortuneTeller
+  class Job < TransformGenerator
+    def initialize(**args)
+      super(**args)
+      @data.savings_plans = []
+    end
+
+    def salary
+      @data.salary
+    end
+
+    def calculate_take_home_pay
+      salary = @data.salary
+      plan = @data.savings_plans[0]
+      pretax_gross = (salary / 12.0).floor
+      pretax_savings = ((plan.percent / 100.0) * pretax_gross).floor
+      pretax_adjusted = pretax_gross - pretax_savings
+      tax_withholding = (pretax_adjusted * 0.3).floor
+      (pretax_adjusted - tax_withholding)
+    end
+
+    def add_savings_plan(savings_plan)
+      @data.savings_plans << savings_plan
+    end
+
+    private
+
+    def gen_transforms(from:, to:, plan:)
+      fields = gen_transform_fields(@data)
+      transforms = []
+      transforms.push gen_transform(from, fields) if from.day == 1
+      current = from.next_month.at_beginning_of_month
+      while current < to
+        transforms.push gen_transform(current, fields)
+        current = current.next_month.at_beginning_of_month
+      end
+      transforms
+    end
+
+    def gen_transform(date, fields)
+      self.class::Transform.new(date: date, holder: holder, **fields)
+    end
+
+    def gen_transform_fields(data)
+      wages = (data.salary / 12.0).floor
+      account_credits = {}
+      income = { wages: wages, saved: 0, matched: 0, pay_period: :monthly }
+      data.savings_plans.each do |p|
+        s = (wages * p.percent / 100.0).floor
+        income[:saved] += s
+        m = (wages * p.match / 100.0).floor
+        income[:matched] += m
+        account_credits[p.account_id] = s + m
+      end
+      { account_credits: account_credits, income: income }
+    end
+
+    # The transforms generated by job
+    class Transform < FortuneTeller::TransformBase
+
+      def initialize(income:, account_credits:, **base)
+        @income = income
+        @account_credits = account_credits
+        super(**base)
+      end
+
+      def apply_to(state)
+        state.apply_w2_income(
+          date: date,
+          holder: holder,
+          income: @income,
+          account_credits: @account_credits
+        )
+      end
+    end
+  end
+end

data/lib/fortuneteller/moment_struct.rb

@@ -0,0 +1,122 @@
+# rubocop:disable Metrics/AbcSize
+module FortuneTeller
+  # We use MomentStruct for objects with scheduled changes
+  class MomentStruct
+    attr_reader :start, :future
+    def initialize(**args)
+      @start = FortuneTeller::MomentStructBase.new args
+      @future = []
+    end
+
+    def to_reader
+      FortuneTeller::MomentStructReader.new(self)
+    end
+
+    def read(date)
+      return @start if @future[0][:date] > date
+      future_ct = @future.length
+      @future.each_with_index do |f, i|
+        if (i == (future_ct - 1)) || (@future[(i + 1)][:date] > date)
+          return f[:struct]
+        end
+      end
+    end
+
+    def read_for_writing(date)
+      i = 0
+      while i < @future.length
+        future = @future[i]
+        return future[:struct] if future[:date] == date
+        break if future[:date] > date
+        i += 1
+      end
+      current = (i.zero? ? @start : @future[(i - 1)][:struct])
+      @future.insert(i, date: date, struct: current.clone)
+      @future[i][:struct]
+    end
+
+    def on(date)
+      FortuneTeller::MomentStructMoment.new(self, date)
+    end
+
+    private
+
+    def insert_at(index, date); end
+
+    def method_missing(name, *args)
+      if name.to_s.end_with?('=') || @start.respond_to?(name)
+        @start.send(name, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @start.respond_to?(name) || super
+    end
+  end
+
+  # An enumerator-like reader for efficient ordered reading
+  class MomentStructReader
+    def initialize(struct)
+      @struct = struct
+      @struct_ct = @struct.future.length
+      @date = nil
+      @next_date = (@struct.future.empty? ? nil : @struct.future[0][:date])
+      @i = -1
+      @object = @struct.start
+    end
+
+    def read(date)
+      validate_read(date)
+      @date = date
+      return @object if @next_date.nil? || (date < @next_date)
+      ((@i + 1)..(@struct_ct - 1)).each do |i|
+        next_obj = @struct.future[i + 1]
+        next unless next_obj.nil? || (next_obj[:date] > @date)
+        @next_date = (next_obj.nil? ? nil : next_obj[:date])
+        @i = i
+        return @object = @struct.future[i][:struct]
+      end
+    end
+
+    private
+
+    def validate_read(date)
+      throw 'Reading backwards' if !@date.nil? && (date < @date)
+    end
+  end
+
+  # Utility class returned while scheduling with `on`
+  class MomentStructMoment
+    DESTRUCTIVE = %i[delete_field update].freeze
+    def initialize(struct, date)
+      @struct = struct
+      @date = date
+    end
+
+    def method_missing(name, *args)
+      if name.to_s.end_with?('=') || DESTRUCTIVE.include?(name)
+        @struct.read_for_writing(@date).send(name, *args)
+      else
+        obj = @struct.read(@date)
+        if name.to_s.end_with?('=') || obj.respond_to?(name)
+          @struct.read(@date).send(name, *args)
+        else
+          super
+        end
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @struct.start.respond_to?(name) || super
+    end
+  end
+
+  # Underlying structure for method accessible hash
+  class MomentStructBase < OpenStruct
+    def update(**kargs)
+      kargs.each { |k, v| self[k] = v }
+    end
+  end
+end

data/lib/fortuneteller/person.rb

@@ -0,0 +1,11 @@
+module FortuneTeller
+  # Representation of a person being simulated with FortuneTeller
+  class Person
+    attr_reader :gender, :birthday, :filing_status
+    def initialize(gender:, birthday:, filing_status:)
+      @gender = gender
+      @birthday = birthday
+      @filing_status = filing_status
+    end
+  end
+end

data/lib/fortuneteller/savings_plans.rb

@@ -0,0 +1,13 @@
+module FortuneTeller
+  module SavingsPlans
+    # Represents a savings plan based on percent of salary
+    class Percent
+      attr_reader :account_id, :percent, :match
+      def initialize(account_id:, percent:, match: 0)
+        @account_id = account_id
+        @percent = percent
+        @match = match
+      end
+    end
+  end
+end

data/lib/fortuneteller/simulator.rb

@@ -0,0 +1,114 @@
+module FortuneTeller
+  # Simulates personal finances.
+  class Simulator
+    attr_accessor :primary, :partner, :spending_strategy
+
+    def initialize
+      @objects = {}
+      @available_keys = ('AA'..'ZZ').to_a
+    end
+
+    %i[account job social_security].each do |object_type|
+      define_method :"add_#{object_type}" do |object|
+        add_object type: object_type, object: object
+      end
+      define_method :"#{object_type.to_s.pluralize}" do
+        retrieve_objects type: object_type
+      end
+    end
+
+    def calculate_take_home_pay(_date)
+      # TODO: make this date dependant
+      @objects[:job].each_value.map(&:calculate_take_home_pay).sum
+    end
+
+    def simulate
+      validate_plan!
+      end_date = first_day_of_year((youngest_birthday.year + 101))
+      states = [initial_state]
+      while states.last.date != end_date
+        states << simulate_next_state(states.last)
+      end
+      puts states.as_json
+    end
+
+    def inflating_int(int, start_date = nil)
+      FortuneTeller::InflatingInt.new(
+        int: int,
+        start_date: (start_date.nil? ? Date.today : start_date)
+      )
+    end
+
+    private
+
+    def simulate_next_state(last)
+      end_date = first_day_of_year((last.date.year + 1))
+      transforms = static_transforms(from: last.date, to: end_date)
+      state = evolve_state(last, transforms, end_date)
+      extra = spending_strategy.resolution_transforms(state: state)
+      unless extra.empty?
+        transforms.concat(extra).sort!
+        state = evolve_state(last, transforms, end_date)
+      end
+      state
+    end
+
+    def first_day_of_year(year)
+      Date.new(year, 1, 1)
+    end
+
+    def evolve_state(state, transforms, to)
+      state = state.init_next
+      transforms.each { |t| t.apply_to(state) }
+      state.pass_time(to: to)
+      state
+    end
+
+    def static_transforms(from:, to:)
+      transforms = []
+      %i[job social_security].each do |object_type|
+        @objects[object_type].each_value { |o| transforms.push(o) }
+      end
+      transforms = transforms.map do |x|
+        x.bounded_gen_transforms(from: from, to: to, plan: self)
+      end
+      transforms.reduce([], :concat).sort
+    end
+
+    def youngest_birthday
+      return @primary.birthday if no_partner?
+      [@primary.birthday, @partner.birthday].min
+    end
+
+    def no_partner?
+      @partner.nil?
+    end
+
+    def no_primary?
+      @primary.nil?
+    end
+
+    def initial_state
+      s = FortuneTeller::State.new(start_date: Date.today)
+      @objects[:account].each { |k, a| s.add_account(key: k, account: a) }
+      s
+    end
+
+    def validate_plan!
+      throw 'Please assign primary' if no_primary?
+    end
+
+    def add_object(type:, object:)
+      key = @available_keys.shift
+      @objects[type] ||= {}
+      @objects[type][key] = object
+      key
+    end
+
+    def retrieve_objects(type:)
+      @objects[type]
+    rescue NoMethodError
+      {}
+    end
+  end
+end

data/lib/fortuneteller/social_security.rb

@@ -0,0 +1,71 @@
+module FortuneTeller
+  # Represents a persons social security strategy
+  class SocialSecurity < TransformGenerator
+    attr_reader :pia
+    def initialize(fra_pia: nil, **base)
+      @fra_pia = fra_pia
+      super(**base)
+    end
+
+    private
+
+    def gen_transforms(from:, to:, plan:)
+      benefit = get_benefit_amount(plan: plan).on(from)
+      transforms = []
+      transforms.push gen_transform(from, benefit) if from.day == 1
+      current = from.next_month.at_beginning_of_month
+      while current < to
+        transforms.push gen_transform(current, benefit)
+        current = current.next_month.at_beginning_of_month
+      end
+      transforms
+    end
+
+    def gen_transform(date, benefit)
+      self.class::Transform.new(date: date, holder: holder, benefit: benefit)
+    end
+
+    def get_benefit_amount(plan:)
+      return @benefit unless @benefit.nil?
+
+      if @start_date.day == 1
+        start_month = @start_date
+      else
+        start_month = @start_date.next_month.at_beginning_of_month
+      end
+
+      calc = FortuneTeller::Utils::SocialSecurity.new(
+        dob: plan.send(@holder).birthday,
+        start_month: start_month
+      )
+      if not @fra_pia.nil?
+        calc.fra_pia = @fra_pia
+      else
+        current_salary = plan.jobs.values.keep_if { |j| j.holder==@holder }.map(&:salary).sum
+        puts "CURRENT SAL #{@holder} #{current_salary}"
+        calc.estimate_pia(current_salary: current_salary, annual_raise: 0.98)
+      end
+
+      benefit = calc.calculate_benefit
+      puts "BENEFIT #{benefit}"
+      @benefit = plan.inflating_int(benefit, start_month)
+    end
+
+    # The transforms generated by social security
+    class Transform < FortuneTeller::TransformBase
+
+      def initialize(benefit:, **base)
+        @benefit = benefit
+        super(**base)
+      end
+
+      def apply_to(state)
+        state.apply_ss_income(
+          date: date,
+          holder: holder,
+          income: {ss: @benefit},
+        )
+      end
+    end
+  end
+end

data/lib/fortuneteller/spending_strategy.rb

@@ -0,0 +1,70 @@
+module FortuneTeller
+  # The spending strategy being used when simulating with FortuneTeller
+  class SpendingStrategy < TransformGenerator
+    def resolution_transforms(state:)
+      transforms = []
+      reader = state_reader
+      12.times do |i|
+        date = determine_transform_date(state, i)
+        data = reader.read(date)
+        next unless data.strategy == :exact
+        amount = data.amount.on(date) - determine_take_home_pay(state, i)
+        transforms.push(gen_transform(date, amount)) if amount.positive?
+      end
+      transforms
+    end
+
+    private
+
+    def gen_transform(date, amount)
+      self.class::Transform.new(
+        holder: :joint,
+        date: date,
+        withdrawal: amount
+      )
+    end
+
+    def determine_transform_date(state, index)
+      Date.new(state.from.year, (index + 1), 1)
+    end
+
+    def determine_take_home_pay(state, index)
+      c = state.cashflow
+      merged = state.class.cashflow_base
+      merged.merge!(c[:primary][index]).merge!(c[:partner][index])
+      merged.line_items[:take_home_pay]
+    end
+
+    # The transforms generated by job
+    class Transform < FortuneTeller::TransformBase
+      attr_reader :withdrawal
+      def initialize(holder:, date:, withdrawal:)
+        @withdrawal = withdrawal
+        super(holder: holder, date: date)
+      end
+
+      def apply_to(state)
+        withdrawn = 0
+        state.accounts.reject { |_k, a| a.balance.zero? }.each do |k, a|
+          a.pass_time(to: @date)
+          withdrawal = [a.balance, (@withdrawal - withdrawn)].min
+          next if withdrawal.zero?
+          make_withdrawal(state, a.account_ref.holder, k, withdrawal)
+          withdrawn += withdrawal
+          break if withdrawn == @withdrawal
+        end
+      end
+
+      private
+
+      def make_withdrawal(state, holder, account, amount)
+        state.apply_pretax_savings_withdrawal(
+          date: @date,
+          holder: holder,
+          source: account,
+          amount: amount
+        )
+      end
+    end
+  end
+end