morty 0.0.1 → 0.1.0

data/lib/morty/cucumber/steps.rb

@@ -0,0 +1,191 @@
+require "morty/cucumber/helpers"
+require "chronic"
+
+ParameterType(
+  name:        "date",
+  regexp:      /\d{4}-\d{2}-\d{2}/,
+  transformer: ->(date) { date.to_date }
+)
+
+ParameterType(
+  name:        "decimal",
+  regexp:      /[\d.]+/,
+  transformer: ->(str) { str.to_d }
+)
+
+Given /^an? (.+) accountant$/ do |type|
+  @accountant = accountant_class(type).new
+
+  unless type.to_sym == :sourceless
+    @accountant.source = Data.define(:id).new(id: 1)
+  end
+end
+
+Given /^the (?:accountant|configuration):$/ do |str|
+  @definition = str
+end
+
+Given /^a start date of (.*)$/ do |text|
+  @accountant.start_date = Chronic.parse(text).to_date
+end
+
+Given "an interest rate of {decimal}%" do |rate|
+  @accountant.rates = { @accountant.start_date => rate / 100.to_d }
+end
+
+Given "a daily interest rate of {decimal}%" do |rate|
+  @accountant.rates = { @accountant.start_date => rate / 100 * 365 }
+end
+
+Given "the interest rates:" do |table|
+  @accountant.rates = table.rows.map { |date, rate| [date, rate.to_d / 100] }
+end
+
+Given "the schedule:" do |table|
+  @accountant.schedule = activities_from(table)
+end
+
+When "I run the daily for {}" do |text|
+  case text
+  when "today"    then @accountant.daily Date.today
+  when "tomorrow" then @accountant.daily Date.today + 1
+  when /^(\d+) days? from now$/ then @accountant.daily Date.today + $1.to_i
+  when /^(\d+) days?$/
+    $1.to_i.times do |i|
+      @accountant.daily Date.today + i
+    end
+  end
+end
+
+When "I simulate to/until {}" do |text|
+  @accountant.simulate_to Chronic.parse(text).to_date
+end
+
+When /^I simulate (?:this activity|these activities):$/ do |table|
+  schedule = activities_from(table)
+
+  @accountant.simulate do
+    schedule.each do |event|
+      send *event.values_at(:type, :date, :amount)
+    end
+  end
+end
+
+When /^I apply (?:this activity|these activities):$/ do |table|
+  activities_from(table).each do |event|
+    @accountant.activity event[:type], event[:date], event[:amount]
+  end
+end
+
+When "I apply a(n) {word} (activity )effective {date} for ${decimal}" do |type, date, amount|
+  @accountant.activity type, @accountant.date, amount, effective_date: date
+end
+
+When "I apply a(n) {word} (activity )for ${decimal}" do |type, amount|
+  @accountant.activity type, @accountant.date, amount
+end
+
+When "I save the accountant" do
+  @accountant.save
+end
+
+When "I reload the accountant" do
+  old = @accountant
+
+  @schedule = old.schedule
+
+  @accountant          = old.class.new
+  @accountant.rates    = old.rates
+  @accountant.source   = old.source
+end
+
+When "I save and reload the accountant" do
+  date = @accountant.date
+
+  steps %Q{
+    When I save the accountant
+    When I reload the accountant
+    Given a start date of #{date}
+  }
+
+  @accountant.schedule = @schedule
+end
+
+When "I reload the accountant with a start date of {date}" do |date|
+  steps %Q{
+     When I reload the accountant
+    Given a start date of #{date}
+  }
+end
+
+When "I reload the accountant with a start_date of {date}" do |date|
+  steps %Q{
+     When I reload the accountant
+    Given a start date of #{date}
+  }
+end
+
+# I cancel the 1st payment on 2026-01-01
+When /^I (return|cancel) the (\d)(?:st|nd|rd|th) ([^ ]+) on (\d\d\d\d-\d\d-\d\d)$/ do |return_or_cancel, ordinal, type, date|
+  activities = @accountant.activities.select { |a| a.type?(type) && a.effective_date == date.to_date }
+  @accountant.send(return_or_cancel.to_sym, activities[ordinal.to_i - 1])
+end
+
+When /^I (return|cancel) the (\d\d\d\d-\d\d-\d\d) ([^ ]+)$/ do |return_or_cancel, date, type|
+  @accountant.send(return_or_cancel.to_sym, @accountant.activities.detect { |a| a.type?(type) && a.effective_date == date.to_date })
+end
+
+When /^I (return|cancel) the (\d\d\d\d-\d\d-\d\d) ([^ ]+) on (\d\d\d\d-\d\d-\d\d)$/ do |return_or_cancel, date, type, cancel_date|
+  # @accountant.finish(cancel_date)?
+  @accountant.send(return_or_cancel.to_sym, @accountant.activities.detect { |a| a.type?(type) && a.effective_date == date.to_date })
+end
+
+When "I reverse the {date} {word}" do |date, type|
+  @accountant.reverse(@accountant.activities.detect { |a| a.type?(type) && a.effective_date == date })
+end
+
+Then "the {word} ledger has these balances:" do |ledger, table|
+  expect(@accountant.accounts(ledger)).to include(balances_from(table))
+end
+
+Then "the {word} ledger has these aggregated balances:" do |ledger, table|
+  expect(@accountant.balances(ledger)).to include(balances_from(table))
+end
+
+Then "(I have )these balances:" do |table|
+  expect(@accountant.accounts).to eq(balances_from(table))
+end
+
+Then "(I have )all zero balances" do
+  expect(@accountant.accounts.values.uniq).to eq([0.to_d])
+end
+
+Then "(I have )these activity counts:" do |table|
+  expect(@accountant.activities.count_by_type).to eq activity_counts_from(table)
+end
+
+Then /^(?:I (?:still )?have )?(?:an?|(\d+)) (?:(\w+) )?activit(?:y|ies)$/ do |count, type|
+  list = type ? @accountant.activities.with_type(type.to_sym) : @accountant.activities
+
+  expect(list.size).to eq((count || 1).to_i)
+end
+
+Then /^the (?:accountant|configuration) is valid$/ do
+  expect { eval(@definition) }.not_to raise_error
+end
+
+Then /^the (?:accountant|configuration) is invalid$/ do
+  expect { eval(@definition) }.to raise_error(Morty::Error)
+end
+
+Then "I cannot save" do
+  expect { @accountant.save }.to raise_error(Morty::Error, /missing source/)
+end
+
+Then "I cannot simulate" do
+  expect { @accountant.simulate }.to raise_error(Morty::Error)
+end
+
+Then "I debug" do
+  binding.irb
+end

data/lib/morty/diff.rb

@@ -0,0 +1,71 @@
+module Morty
+  class Diff
+    def initialize(original, adjusted)
+      @original = original.activities
+      @adjusted = adjusted.activities
+    end
+
+    def entries
+      original_sums = Sum.new(@original)
+      adjusted_sums = Sum.new(@adjusted.list - additional.list)
+
+      diff = adjusted_sums - original_sums
+
+      diff.map { |type, amount| Entry.new(entry_type: type, amount: amount) }
+    end
+
+    def additional
+      @additional ||= @adjusted.reject { |a| a.type?(:interest) || original?(a) }
+    end
+
+    def original?(activity)
+      @original.include?(activity)
+    end
+
+    class Sum
+      def initialize(activities)
+        @entries = activities.flat_map(&:entries)
+      end
+
+      def calculate
+        return @hash if @hash
+
+        hash = @entries.each_with_object(Hash.new(0.to_d)) do |entry, sums|
+          sums[entry.type] += entry.amount
+        end
+
+        @hash = reduce(hash)
+      end
+
+      # @param other Sum
+      def -(other)
+        left = calculate
+        right = other.calculate
+
+        types = left.keys + right.keys
+
+        result = types.uniq.each_with_object(Hash.new(0.to_d)) do |type, sums|
+          sums[type] = left[type] - right[type]
+        end
+
+        reduce(result)
+      end
+
+      def reduce(input)
+        input.each_with_object(Hash.new(0.to_d)) do |(type, amount), sums|
+          inverse = type.inverse
+
+          next if sums.key?(type) || sums.key?(inverse)
+
+          amount -= input[inverse] if input.key?(inverse)
+
+          case
+          when amount  > 0 then sums[type]    += amount
+          when amount  < 0 then sums[inverse] += amount.abs
+          when amount == 0 then next
+          end
+        end
+      end
+    end
+  end
+end

data/lib/morty/dsl.rb

@@ -0,0 +1,86 @@
+module Morty
+  # DSL for defining Accountants.
+  #
+  # @example
+  #   class Accountant < Morty::Accountant
+  #     source :customer
+  #
+  #     activity :sale do |amount|
+  #       entry :cash, :revenue, amount
+  #     end
+  #   end
+  #
+  #   Accountant.new(source: customer, start_date: Date.current)
+  module DSL
+    def self.extended(klass)
+      klass.class_attribute :activity_procs
+      klass.class_attribute :balances_list
+      klass.class_attribute :daily_proc
+      klass.class_attribute :daily_guard_proc
+      klass.class_attribute :ledgers
+      klass.class_attribute :source_name
+
+      klass.activity_procs = Hash.new { |hash, key| hash[key] = {} }
+      klass.balances_list  = Hash.new { |hash, key| hash[key] = {} }
+      klass.ledgers        = [:default]
+    end
+
+    def activity(name, &block)
+      raise Error, "missing block" unless block_given?
+
+      activity_procs[current_ledger][name] = block
+    end
+
+    def balance(name, accounts)
+      balances_list[current_ledger][name.to_sym] = accounts.map(&:to_sym)
+    end
+
+    def current_ledger
+      @ledger || :default
+    end
+
+    def daily(&block)
+      raise Error, "missing block" unless block_given?
+
+      self.daily_proc = block
+    end
+
+    def daily_guard(&block)
+      self.daily_guard_proc = block
+    end
+
+    # define activities scoped to a given ledger
+    def ledger(name, &block)
+      raise Error, "missing block" unless block_given?
+
+      @ledger = name.to_sym
+
+      self.ledgers |= [name]
+
+      instance_exec(&block)
+    ensure
+      @ledger = nil
+    end
+
+    def source(name)
+      name = name.to_sym
+
+      raise Error, "invalid source: #{name} method already defined in #{self}" if instance_methods.include?(name)
+
+      klass = name.to_s.classify.safe_constantize
+      raise Error, "invalid source: #{name}"             unless klass
+      raise Error, "invalid source: #{name} missing #id" unless klass.instance_methods.include?(:id)
+
+      define_method(name) { source }
+
+      self.source_name = name
+    end
+
+    # define an activity that uses a waterfall
+    def waterfall(name, **kwargs)
+      activity name do
+        waterfall amount, **kwargs
+      end
+    end
+  end
+end

data/lib/morty/engine.rb

@@ -0,0 +1,21 @@
+require "active_record/railtie"
+
+require "lookup_by"
+
+module Morty
+  def self.table_name_prefix
+    "morty."
+  end
+
+  class Engine < ::Rails::Engine
+    isolate_namespace Morty
+
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match?(root.to_s)
+        config.paths["db/migrate"].expanded.each do |path|
+          app.config.paths["db/migrate"] << path unless app.config.paths["db/migrate"].include?(path)
+        end
+      end
+    end
+  end
+end

data/lib/morty/error.rb

@@ -0,0 +1,3 @@
+module Morty
+  class Error < StandardError; end
+end

data/lib/morty/event.rb

@@ -0,0 +1,27 @@
+module Morty
+  class Event
+    attr_reader :info
+
+    def initialize(event)
+      case event
+      when Activity then @info = event.to_event
+      when Event    then @info = event.info
+      when Hash     then @info = { amount: event[:amount], date: event[:date], type: event[:type] }
+      else
+        raise Error, "Event.new takes an Activity, Event, or Hash(:amount, :date, :type)"
+      end
+    end
+
+    def amount
+      @info[:amount]
+    end
+
+    def date
+      @info[:date]
+    end
+
+    def type
+      @info[:type]
+    end
+  end
+end

data/lib/morty/list/activity.rb

@@ -0,0 +1,57 @@
+module Morty
+  module List
+    class Activity
+      include Enumerable
+
+      attr_reader :list
+
+      delegate_missing_to :@list
+
+      def initialize(obj)
+        case obj
+        when self.class             then @list = obj.list
+        when Array                  then @list = obj
+        when ActiveRecord::Relation then @list = obj.to_a
+        else raise Error
+        end
+      end
+
+      def between(start, finish, by_accounting_date: false)
+        range = start.to_date .. finish.to_date
+
+        if by_accounting_date
+          select { |a| range.cover?(a.accounting_date) }
+        else
+          select { |a| range.cover?(a.effective_date)  }
+        end
+      end
+
+      def by_type
+        group_by(&:type)
+      end
+
+      def count_by_type
+        by_type.transform_values(&:size)
+      end
+
+      def each(&block) = list.each(&block)
+
+      def push(activity)
+        return if activity.entries.none?
+
+        list << activity
+      end
+
+      def reject(&block) = self.class.new list.reject(&block)
+      def select(&block) = self.class.new list.select(&block)
+
+      def sum_by_account
+        Morty::Account.sum_over_activities list.map(&:id)
+      end
+
+      def with_type(type)
+        self.class.new(select { |a| a.activity_type?(type.to_sym) })
+      end
+    end
+  end
+end

data/lib/morty/rate.rb

@@ -0,0 +1,59 @@
+module Morty
+  class Rate
+    include Comparable
+
+    attr_reader :daily, :daily_leap, :monthly, :yearly
+
+    def initialize(annual_rate)
+      case annual_rate
+      when self.class
+        @rate = annual_rate.yearly
+      else
+        @rate = annual_rate.to_d
+      end
+
+      @daily      = @rate./(365).round(8)
+      @daily_leap = @rate./(366).round(8)
+
+      @monthly    = @rate./(12).round(8)
+      @yearly     = @rate
+    end
+
+    def <=>(other)
+      case other
+      when Rate
+        yearly <=> other.yearly
+      else
+        yearly <=> self.class.new(other).yearly
+      end
+    end
+
+    def annual_percentage
+      "%.3f" % (@yearly * 100)
+    end
+
+    def daily_for(date)
+      date.leap? ? daily_leap : daily
+    end
+
+    def daily_percentage
+      "%.8f" % (daily * 100)
+    end
+
+    def daily_percentage_leap
+      "%.8f" % (daily_leap * 100)
+    end
+
+    def inspect
+      "#<Morty::Rate: #{annual_percentage}% annually, #{daily_percentage}%/#{daily_percentage_leap}% daily>"
+    end
+
+    def to_d
+      yearly
+    end
+
+    def to_s
+      "%.2f" % @yearly
+    end
+  end
+end

data/lib/morty/schedule.rb

@@ -0,0 +1,36 @@
+module Morty
+  class Schedule
+    include Enumerable
+
+    attr_reader :accountant, :events
+
+    def initialize(accountant, list)
+      @accountant = accountant
+
+
+      @events = case list
+                when nil      then []
+                when Array    then list.map { |event| Event.new(event) }
+                when Schedule then list.events
+                end
+    end
+
+    def <<(events)
+      @events += events.map { |event| Event.new(event) }
+    end
+
+    def between(start, finish)
+      range = start.to_date .. finish.to_date
+
+      events.select { |e| range.cover?(e.date) }
+    end
+
+    def each(&block)
+      @events.each(&block)
+    end
+
+    def for(date)
+      select { |e| e.date == date }
+    end
+  end
+end

data/lib/morty/seed.rb

@@ -0,0 +1,60 @@
+module Morty
+  module Seed
+    # Populate the accounts table
+    #
+    # Morty::Seed.accounts %w[
+    #   cash
+    #   interest
+    #   principal
+    #   principal_late
+    #   principal_charged_off
+    #   revenue
+    # ]
+    def self.accounts(list)
+      list.each_slice(2) do |type, account|
+        Account.where(account: account, account_type_id: type).first_or_create!
+      end
+
+      Account.lookup.reload
+    end
+
+    # Populate the account_types table
+    #
+    # Morty::Seed.account_types %w[
+    # A Asset     DR
+    # X Expense   DR
+    # L Liability CR
+    # E Equity    CR
+    # R Revenue   CR
+    # ]
+    def self.account_types(list)
+      raise ArgumentError, "expected triples" unless list.size % 3 == 0
+
+      list.each_slice(3) do |abbr, type, normal_balance|
+        AccountType.find_or_create_by!(account_type_id: abbr) do |at|
+          at.account_type   = type
+          at.normal_balance = normal_balance.upcase
+        end
+      end
+
+      AccountType.lookup.reload
+    end
+
+    # Populate valid entry_types
+    #
+    # Morty::Seed.entry_types(:default, %w[
+    #   principal      cash
+    #   cash           principal
+    #   cash           interest
+    #   interest       revenue
+    #   principal_late principal
+    # ]
+    def self.entry_types(ledger, list)
+      list.each_slice(2) do |dr, cr|
+        # Create the entry type and its reverse (debit and credit reversed)
+        EntryType.where(ledger: ledger, dr: dr, cr: cr).first_or_create!
+        EntryType.where(ledger: ledger, dr: cr, cr: dr).first_or_create!
+      end
+    end
+  end
+end

data/lib/morty/source.rb

@@ -0,0 +1,19 @@
+module Morty
+  # A wrapper class for the object for which we are accounting
+  class Source
+    attr_reader :object
+
+    delegate_missing_to :@object
+
+    def initialize(object)
+      raise Error, "source must define an id method" unless object.respond_to?(:id)
+
+      @object = object
+    end
+
+    # has_many light
+    def activities
+      Activity.where(source_id: object.id)
+    end
+  end
+end

data/lib/morty/tasks/morty_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :morty do
+#   # Task goes here
+# end

data/lib/morty/version.rb

@@ -1,3 +1,3 @@
 module Morty
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/morty.rb

@@ -1,5 +1,31 @@
+require "morty/engine"
 require "morty/version"
 
 module Morty
-  # Your code goes here...
+  autoload :Accountant, "morty/accountant"
+  autoload :Adjustment, "morty/adjustment"
+  autoload :Book,       "morty/book"
+  autoload :Diff,       "morty/diff"
+  autoload :DSL,        "morty/dsl"
+  autoload :Error,      "morty/error"
+  autoload :Event,      "morty/event"
+  autoload :Rate,       "morty/rate"
+  autoload :Source,     "morty/source"
+  autoload :Schedule,  "morty/schedule"
+  autoload :Seed,       "morty/seed"
+
+  module Context
+    autoload :Activity,   "morty/context/activity"
+    autoload :Daily,      "morty/context/daily"
+    autoload :Simulation, "morty/context/simulation"
+  end
+
+  module Cucumber
+    autoload :Helpers,  "morty/cucumber/helpers"
+    autoload :Steps,    "morty/cucumber/steps"
+  end
+
+  module List
+    autoload :Activity, "morty/list/activity"
+  end
 end